DetectorChamber vtk handler

src/Math/ContainerBox.h

@@ -29,63 +29,147 @@
 #define U_CONTAINERBOX_H
 
 #include "Geometry.h"
+#include "Math/Dense.h"
+#include "Math/Transform.h"
+#include <utility>
 
 
 namespace uLib {
 
 
 
+/**
+ * @brief Represents an oriented bounding box (OBB) within a hierarchical transformation system.
+ *
+ * ContainerBox inherits from AffineTransform, which defines its parent coordinate system.
+ * It contains an internal local transformation (m_LocalT) that defines the box's
+ * specific origin and size relative to its own coordinate system.
+ */
 class ContainerBox : public AffineTransform {
-public:
-    ContainerBox() : m_LocalT(this) {}
 
+    typedef AffineTransform BaseClass;
+
+public:
+    /**
+     * @brief Default constructor.
+     * Initializes the local transformation with this instance as its parent.
+     */
+    ContainerBox() : 
+        m_LocalT(this)  // BaseClass is Parent of m_LocalTransform
+    {}
+
+    /**
+     * @brief Copy constructor.
+     * @param copy The ContainerBox instance to copy from.
+     */
     ContainerBox(const ContainerBox &copy) :
-        m_LocalT(this),
+        m_LocalT(this), // BaseClass is Parent of m_LocalTransform
         AffineTransform(copy)
     {
-        // FIX for performance //
         this->SetOrigin(copy.GetOrigin());
         this->SetSize(copy.GetSize());
     }
 
+    /**
+     * @brief Sets the box origin relative to its coordinate system.
+     * @param v The origin position vector.
+     */
     inline void SetOrigin(const Vector3f &v) { m_LocalT.SetPosition(v); }
 
+    /**
+     * @brief Gets the box origin relative to its coordinate system.
+     * @return The origin position vector.
+     */
     inline Vector3f GetOrigin() const { return m_LocalT.GetPosition(); }
 
+    /**
+     * @brief Sets the size of the box.
+     * Re-initializes the local transformation and applies the new scale.
+     * @param v The size vector (width, height, depth).
+     */
     void SetSize(const Vector3f &v) {
         Vector3f pos = this->GetOrigin();
-        m_LocalT = AffineTransform(this);
+        m_LocalT = AffineTransform(this); // regenerate local transform
         m_LocalT.Scale(v);
         m_LocalT.SetPosition(pos);
     }
 
+    /**
+     * @brief Gets the current size (scale) of the box.
+     * @return The size vector.
+     */
     inline Vector3f GetSize() const { return m_LocalT.GetScale(); }
 
-    // FIX... //
+    /**
+     * @brief Swaps two local axes of the box.
+     * @param first Index of the first axis (0=X, 1=Y, 2=Z).
+     * @param second Index of the second axis (0=X, 1=Y, 2=Z).
+     */
     inline void FlipLocalAxes(int first, int second)
     { m_LocalT.FlipAxes(first,second); }
 
+    /**
+     * @brief Returns the world transformation matrix of the box's volume.
+     * @return A 4x4 transformation matrix.
+     */
     Matrix4f GetWorldMatrix() const { return m_LocalT.GetWorldMatrix(); }
 
+    /**
+     * @brief Returns the local transformation matrix of the box's volume.
+     * @return A 4x4 transformation matrix.
+     */
+    Matrix4f GetLocalMatrix() const { return m_LocalT.GetMatrix(); }
+
+    /**
+     * @brief Transforms a point from box-local space to world space.
+     * @param v The local point (4D homogeneous vector).
+     * @return The transformed point in world space.
+     */
     inline Vector4f GetWorldPoint(const Vector4f &v) const {
         return m_LocalT.GetWorldMatrix() * v;
     }
 
+    /**
+     * @brief Transforms a point from box-local space coordinates to world space.
+     * @param x X coordinate in local space.
+     * @param y Y coordinate in local space.
+     * @param z Z coordinate in local space.
+     * @return The transformed point in world space.
+     */
     inline Vector4f GetWorldPoint(const float x, const float y, const float z) {
         return this->GetWorldPoint(Vector4f(x,y,z,1));
     }
 
+    /**
+     * @brief Transforms a point from world space to box-local space.
+     * @param v The world point (4D homogeneous vector).
+     * @return The transformed point in box-local space.
+     */
     inline Vector4f GetLocalPoint(const Vector4f &v) const {
         return m_LocalT.GetWorldMatrix().inverse() * v;
     }
 
+    /**
+     * @brief Transforms a point from world space coordinates to box-local space.
+     * @param x X coordinate in world space.
+     * @param y Y coordinate in world space.
+     * @param z Z coordinate in world space.
+     * @return The transformed point in box-local space.
+     */
     inline Vector4f GetLocalPoint(const float x, const float y, const float z) {
          return this->GetLocalPoint(Vector4f(x,y,z,1));
     }
 
+    /** Translate using transformation chain */
+    using BaseClass::Translate;
 
-protected:
+    /** Rotate using transformation chain */
+    using BaseClass::Rotate;
 
+    /** Scale using transformation chain */
+    using BaseClass::Scale;
+
+    
 private:
     AffineTransform  m_LocalT;
 };