diff --git a/Examples/GeometryTransforms/GeometryTransformsExample.cpp b/Examples/GeometryTransforms/GeometryTransformsExample.cpp
index d0235eb9c2033fb017d018eeaaabd2be5780314d..d612eed653d9ef84097ad211a076d604f4183767 100644
--- a/Examples/GeometryTransforms/GeometryTransformsExample.cpp
+++ b/Examples/GeometryTransforms/GeometryTransformsExample.cpp
@@ -21,13 +21,13 @@
 
 #include "imstkAPIUtilities.h"
 #include "imstkCamera.h"
-#include "imstkCube.h"
 #include "imstkCylinder.h"
 #include "imstkKeyboardSceneControl.h"
 #include "imstkLight.h"
 #include "imstkLogger.h"
 #include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
+#include "imstkOrientedBox.h"
 #include "imstkPlane.h"
 #include "imstkRenderMaterial.h"
 #include "imstkScene.h"
@@ -75,8 +75,8 @@ main()
     scene->addSceneObject(planeObj);
 
     //  Cube
-    imstkNew<Cube> cubeGeom;
-    cubeGeom->setWidth(10.0);
+    imstkNew<OrientedBox> cubeGeom;
+    cubeGeom->setExtents(5.0, 5.0, 5.0);
     cubeGeom->scale(0.5, Geometry::TransformType::ConcatenateToTransform);
     cubeGeom->rotate(Vec3d(1.0, 1.0, 0.0), PI_4, Geometry::TransformType::ApplyToData);
     cubeGeom->translate(Vec3d(0.0, 0.0, 10.0));
diff --git a/Examples/Levelset/levelsetExample.cpp b/Examples/Levelset/levelsetExample.cpp
index b373cae74f6b7324bfae15ec708ecf111d979475..0256682ce45d2657e631d6086d9d894216dcee51 100644
--- a/Examples/Levelset/levelsetExample.cpp
+++ b/Examples/Levelset/levelsetExample.cpp
@@ -20,23 +20,16 @@
 =========================================================================*/
 
 #include "imstkCamera.h"
-#include "imstkCube.h"
-#include "imstkImageData.h"
-#include "imstkImplicitGeometryToImageData.h"
 #include "imstkKeyboardSceneControl.h"
 #include "imstkLevelSetDeformableObject.h"
 #include "imstkLevelSetModel.h"
 #include "imstkLight.h"
-#include "imstkLogger.h"
 #include "imstkMeshIO.h"
 #include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
-#include "imstkPlane.h"
-#include "imstkRenderMaterial.h"
 #include "imstkScene.h"
 #include "imstkSceneManager.h"
 #include "imstkSimulationManager.h"
-#include "imstkSphere.h"
 #include "imstkSurfaceMesh.h"
 #include "imstkSurfaceMeshDistanceTransform.h"
 #include "imstkVisualModel.h"
diff --git a/Examples/ObjectController/ObjectControllerExample.cpp b/Examples/ObjectController/ObjectControllerExample.cpp
index df3c210ccb1f56fbb093de3c7756793c4213edeb..5156ab7f318e824752f62695d05cd3231f158d8d 100644
--- a/Examples/ObjectController/ObjectControllerExample.cpp
+++ b/Examples/ObjectController/ObjectControllerExample.cpp
@@ -21,7 +21,6 @@
 
 #include "imstkCamera.h"
 #include "imstkCollidingObject.h"
-#include "imstkCube.h"
 #include "imstkHapticDeviceClient.h"
 #include "imstkHapticDeviceManager.h"
 #include "imstkKeyboardSceneControl.h"
@@ -29,6 +28,7 @@
 #include "imstkLogger.h"
 #include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
+#include "imstkOrientedBox.h"
 #include "imstkScene.h"
 #include "imstkSceneManager.h"
 #include "imstkSceneObjectController.h"
@@ -56,7 +56,7 @@ main()
     std::shared_ptr<HapticDeviceClient> client     = server->makeDeviceClient(deviceName);
 
     // Object
-    imstkNew<Cube>            geom(Vec3d(0.0, 1.0, 0.0), 2.0);
+    imstkNew<OrientedBox>     geom(Vec3d(0.0, 1.0, 0.0), Vec3d(1.0, 5.0, 1.0));
     imstkNew<CollidingObject> object("VirtualObject");
     object->setVisualGeometry(geom);
     object->setCollidingGeometry(geom);
diff --git a/Examples/ObjectControllerDummyClient/ObjectCtrlDummyClientExample.cpp b/Examples/ObjectControllerDummyClient/ObjectCtrlDummyClientExample.cpp
index ea17a3ba2bb244231ec352ff772a937328f5633e..8d586705c6c8cb8a38ccecfd6b28cffeb971afa4 100644
--- a/Examples/ObjectControllerDummyClient/ObjectCtrlDummyClientExample.cpp
+++ b/Examples/ObjectControllerDummyClient/ObjectCtrlDummyClientExample.cpp
@@ -21,11 +21,11 @@
 
 #include "imstkCamera.h"
 #include "imstkCollidingObject.h"
-#include "imstkCube.h"
 #include "imstkDummyClient.h"
 #include "imstkLight.h"
 #include "imstkLogger.h"
 #include "imstkNew.h"
+#include "imstkOrientedBox.h"
 #include "imstkScene.h"
 #include "imstkSceneManager.h"
 #include "imstkSceneObjectController.h"
@@ -49,9 +49,7 @@ main()
     imstkNew<DummyClient> client("DummyClient");
 
     // Object
-    imstkNew<Cube> geom;
-    geom->setPosition(0.0, 1.0, 0.0);
-    geom->setWidth(2.0);
+    imstkNew<OrientedBox> geom(Vec3d(0.0, 1.0, 0.0), Vec3d(1.0, 1.0, 1.0));
 
     imstkNew<CollidingObject> object("VirtualObject");
     object->setVisualGeometry(geom);
diff --git a/Examples/RigidBodyDynamics/RigidBodyDynamicsExample.cpp b/Examples/RigidBodyDynamics/RigidBodyDynamicsExample.cpp
index 8d43f6578fef01fc68654dce9adb7855f54348ea..01b4d27ea8705b0bf9bff6d5e7fce8ad9a84db53 100644
--- a/Examples/RigidBodyDynamics/RigidBodyDynamicsExample.cpp
+++ b/Examples/RigidBodyDynamics/RigidBodyDynamicsExample.cpp
@@ -20,7 +20,6 @@
 =========================================================================*/
 
 #include "imstkCamera.h"
-#include "imstkCube.h"
 #include "imstkIsometricMap.h"
 #include "imstkKeyboardSceneControl.h"
 #include "imstkLight.h"
@@ -28,6 +27,7 @@
 #include "imstkMeshIO.h"
 #include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
+#include "imstkOrientedBox.h"
 #include "imstkPlane.h"
 #include "imstkRenderMaterial.h"
 #include "imstkRigidBodyModel.h"
@@ -84,8 +84,7 @@ makeCubeRigidObject(std::string& name, const Vec3d& pos)
     imstkNew<RigidObject> cubeObj(name);
 
     // Create cube geometry
-    imstkNew<Cube> cubeGeom;
-    cubeGeom->setWidth(20.0);
+    imstkNew<OrientedBox> cubeGeom(Vec3d::Zero(), Vec3d(10.0, 10.0, 10.0));
     cubeGeom->translate(pos);
 
     // Create cube VisualModel
diff --git a/Examples/RigidBodyDynamics2/RigidBodyDynamicsExample2.cpp b/Examples/RigidBodyDynamics2/RigidBodyDynamicsExample2.cpp
index 75fded3ceeafd4cbe2673d5a1238836f3c44d882..5968337071aad3bc76fea619a45b4e5469c1b3ff 100644
--- a/Examples/RigidBodyDynamics2/RigidBodyDynamicsExample2.cpp
+++ b/Examples/RigidBodyDynamics2/RigidBodyDynamicsExample2.cpp
@@ -22,7 +22,6 @@
 #include "imstkCamera.h"
 #include "imstkCollisionGraph.h"
 #include "imstkCompositeImplicitGeometry.h"
-#include "imstkCube.h"
 #include "imstkGeometryUtilities.h"
 #include "imstkImplicitGeometryToImageData.h"
 #include "imstkKeyboardDeviceClient.h"
@@ -31,6 +30,7 @@
 #include "imstkLogger.h"
 #include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
+#include "imstkOrientedBox.h"
 #include "imstkPlane.h"
 #include "imstkRbdConstraint.h"
 #include "imstkRenderMaterial.h"
@@ -116,9 +116,8 @@ main()
 
         // Create surface mesh cube (so we can use pointset for point->implicit collision)
         {
-            imstkNew<Cube> cubeGeom;
-            cubeGeom->setWidth(4.0);
-            std::shared_ptr<SurfaceMesh> surfMesh = GeometryUtils::toCubeSurfaceMesh(cubeGeom);
+            imstkNew<OrientedBox>        cubeGeom(Vec3d::Zero(), Vec3d(1.5, 3.0, 1.0));
+            std::shared_ptr<SurfaceMesh> surfMesh = GeometryUtils::toSurfaceMesh(cubeGeom);
 
             imstkNew<SurfaceMeshSubdivide> subdivide;
             subdivide->setInputMesh(surfMesh);
diff --git a/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp b/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp
index 78cca81778364a514257e52ec4b7cc7418878336..0dcc94293ce39ada4257f2e345e47e91d7651a15 100644
--- a/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp
+++ b/Examples/RigidBodyVirtualCoupling/RigidBodyVirtualCouplingExample.cpp
@@ -20,7 +20,6 @@
 =========================================================================*/
 
 #include "imstkCamera.h"
-#include "imstkCube.h"
 #include "imstkHapticDeviceClient.h"
 #include "imstkHapticDeviceManager.h"
 #include "imstkIsometricMap.h"
@@ -30,6 +29,7 @@
 #include "imstkMeshIO.h"
 #include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
+#include "imstkOrientedBox.h"
 #include "imstkPlane.h"
 #include "imstkRenderMaterial.h"
 #include "imstkRigidBodyModel.h"
@@ -93,7 +93,7 @@ makeCubeRigidObject(const std::string& name, const Vec3d& pos)
     imstkNew<RigidObject> cubeObj(name);
 
     // Create Cube object
-    imstkNew<Cube> cubeGeom(pos, 20.0);
+    imstkNew<OrientedBox> cubeGeom(pos, Vec3d(10.0, 15.0, 10.0));
 
     // cube visual model
     auto surfMesh = MeshIO::read<SurfaceMesh>(iMSTK_DATA_ROOT "/asianDragon/asianDragon.obj");
@@ -268,7 +268,7 @@ main()
             const Vec3d& devPos = controller->getPosition();
             const Quatd& devQ   = controller->getRotation();
             rbdModel->getModelGeometry()->rotate(devQ);
-            auto cubeGeo = std::dynamic_pointer_cast<Cube>(cubeObj->getPhysicsGeometry());
+            auto cubeGeo = std::dynamic_pointer_cast<OrientedBox>(cubeObj->getPhysicsGeometry());
             const Vec3d cubePos      = rbdModel->getModelGeometry()->getTranslation();
             const Vec3d cubeVelocity = (cubePos - prevCubePos) / 2.0;
             const Vec3d damp  = -1000000 * cubeVelocity;
diff --git a/Examples/Screenshot/ScreenshotExample.cpp b/Examples/Screenshot/ScreenshotExample.cpp
index db0f30d9c89d00ebf173af90f6e38f18c19a4a3e..2a4da30af067fc85b7d717e11cee8c4ba10858ae 100644
--- a/Examples/Screenshot/ScreenshotExample.cpp
+++ b/Examples/Screenshot/ScreenshotExample.cpp
@@ -20,13 +20,13 @@
 =========================================================================*/
 
 #include "imstkCamera.h"
-#include "imstkCube.h"
 #include "imstkKeyboardDeviceClient.h"
 #include "imstkKeyboardSceneControl.h"
 #include "imstkLight.h"
 #include "imstkLogger.h"
 #include "imstkMouseSceneControl.h"
 #include "imstkNew.h"
+#include "imstkOrientedBox.h"
 #include "imstkPlane.h"
 #include "imstkScene.h"
 #include "imstkSceneManager.h"
@@ -57,9 +57,7 @@ main()
     planeObj->setVisualGeometry(planeGeom);
 
     // Cube
-    imstkNew<Cube> cubeGeom;
-    cubeGeom->setWidth(0.5);
-    cubeGeom->setPosition(1.0, -1.0, 0.5);
+    imstkNew<OrientedBox> cubeGeom(Vec3d(1.0, -1.0, 0.5), Vec3d(0.25, 0.25, 0.25));
     // rotates could be replaced by cubeGeom->setOrientationAxis(1,1,1) (normalized inside)
     cubeGeom->rotate(UP_VECTOR, PI_4, Geometry::TransformType::ApplyToData);
     cubeGeom->rotate(RIGHT_VECTOR, PI_4, Geometry::TransformType::ApplyToData);
diff --git a/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.cpp b/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.cpp
index 66803298001f86fc18aab3b543676eccc88f45ef..22ccb891a0bab1159cc657457b4d49a3e578dbf8 100644
--- a/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.cpp
+++ b/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.cpp
@@ -20,7 +20,7 @@
 =========================================================================*/
 
 #include "imstkRigidBodyModel.h"
-#include "imstkCube.h"
+#include "imstkOrientedBox.h"
 #include "imstkLogger.h"
 #include "imstkPlane.h"
 #include "imstkSphere.h"
@@ -48,9 +48,9 @@ RigidBodyModel::initialize()
         {
             createSphere();
         }
-        else if (geomType == "Cube")
+        else if (geomType == "OrientedBox")
         {
-            createCube();
+            createOrientedBox();
         }
         else if (geomType == "Plane")
         {
@@ -151,7 +151,7 @@ RigidBodyModel::createPlane()
 }
 
 void
-RigidBodyModel::createCube()
+RigidBodyModel::createOrientedBox()
 {
     const auto physxMaterial = m_rigidBodyWorld->m_Physics->createMaterial((PxReal)m_config->m_staticFriction,
         (PxReal)m_config->m_dynamicFriction,
@@ -160,12 +160,12 @@ RigidBodyModel::createCube()
     const auto physics = m_rigidBodyWorld->m_Physics;
     const auto PxScene = m_rigidBodyWorld->m_Scene;
 
-    const auto cubeGeo = std::dynamic_pointer_cast<imstk::Cube>(m_geometry);
+    const auto obbGeo = std::dynamic_pointer_cast<OrientedBox>(m_geometry);
 
-    auto l = (PxReal)cubeGeo->getWidth();
+    Vec3d extents = obbGeo->getExtents();
 
-    const auto  p = cubeGeo->getPosition() + cubeGeo->getTranslation();
-    const Quatd q(cubeGeo->getRotation());
+    const auto  p = obbGeo->getPosition() + obbGeo->getTranslation();
+    const Quatd q(obbGeo->getRotation());
 
     PxTransform trans((float)p[0], (float)p[1], (float)p[2], PxQuat((float)q.x(), (float)q.y(), (float)q.z(), (float)q.w()));
 
@@ -173,7 +173,10 @@ RigidBodyModel::createCube()
     {
         m_pxStaticActor = PxCreateStatic(*physics,
                                          trans,
-                                         PxBoxGeometry(l / (PxReal)2., l / (PxReal)2., l / (PxReal)2.),
+                                         PxBoxGeometry(
+                                             static_cast<PxReal>(extents[0]),
+                                             static_cast<PxReal>(extents[1]),
+                                             static_cast<PxReal>(extents[2])),
                                          *physxMaterial);
         if (m_pxStaticActor)
         {
@@ -184,7 +187,10 @@ RigidBodyModel::createCube()
     {
         m_pxDynamicActor = PxCreateDynamic(*physics,
                                            trans,
-                                           PxBoxGeometry(l / (PxReal)2., l / (PxReal)2., l / (PxReal)2.),
+                                           PxBoxGeometry(
+                                               static_cast<PxReal>(extents[0]),
+                                               static_cast<PxReal>(extents[1]),
+                                               static_cast<PxReal>(extents[2])),
                                            *physxMaterial,
             (PxReal)0.1);
 
diff --git a/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.h b/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.h
index af70c4dc49ae876f0d40583df94744e542389939..fce924d99314a9a0f5ae15ec488126409e2b95e0 100644
--- a/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.h
+++ b/Source/DynamicalModels/ObjectModels/imstkRigidBodyModel.h
@@ -63,7 +63,7 @@ public:
         {
             "Plane",
             "Sphere",
-            "Cube",
+            "OrientedBox",
             "SurfaceMesh"
         };
     };
@@ -183,7 +183,7 @@ private:
     ///
     /// \brief TODO
     ///
-    void createCube();
+    void createOrientedBox();
     ///
     /// \brief TODO
     ///
diff --git a/Source/Geometry/Analytic/imstkCube.h b/Source/Geometry/Analytic/imstkCube.h
deleted file mode 100644
index 90248ca509b72bce37e09393553175b77587f0d7..0000000000000000000000000000000000000000
--- a/Source/Geometry/Analytic/imstkCube.h
+++ /dev/null
@@ -1,108 +0,0 @@
-/*=========================================================================
-
-   Library: iMSTK
-
-   Copyright (c) Kitware, Inc. & Center for Modeling, Simulation,
-   & Imaging in Medicine, Rensselaer Polytechnic Institute.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0.txt
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-=========================================================================*/
-
-#pragma once
-
-#include "imstkAnalyticalGeometry.h"
-
-namespace imstk
-{
-class Cube;
-
-///
-/// \class Cube
-///
-/// \brief Cube geometry
-///
-class Cube : public AnalyticalGeometry
-{
-public:
-    Cube(const Vec3d& pos = Vec3d(0.0, 0.0, 0.0), const double width = 1.0, const Vec3d& orientationAxis = Vec3d(0.0, 1.0, 0.0),
-         const std::string& name = std::string("defaultCube")) : AnalyticalGeometry(name)
-    {
-        setPosition(pos);
-        setOrientationAxis(orientationAxis);
-        setWidth(width);
-    }
-
-    virtual ~Cube() override = default;
-
-    ///
-    /// \brief Returns the string representing the type name of the geometry
-    ///
-    virtual const std::string getTypeName() const override { return "Cube"; }
-
-public:
-    ///
-    /// \brief Print the cube info
-    ///
-    void print() const override;
-
-    ///
-    /// \brief Returns the volume of the cube
-    ///
-    double getVolume() override { return m_width * m_width * m_width; }
-
-    ///
-    /// \brief Returns the width of the cube
-    ///
-    double getWidth(DataType type = DataType::PostTransform);
-
-    ///
-    /// \brief Sets the width of the cube
-    ///
-    void setWidth(const double w);
-
-    ///
-    /// \brief Returns signed distance to surface at pos
-    /// \todo Doesn't support orientation yet
-    ///
-    double getFunctionValue(const Vec3d& pos) const override
-    {
-        // Unrotate the point and cube to axes align the cube
-        const Mat3d r      = Quatd::FromTwoVectors(m_orientationAxisPostTransform, Vec3d(0.0, 1.0, 0.0)).toRotationMatrix();
-        const Vec3d p      = r * pos;
-        const Vec3d center = r * m_positionPostTransform;
-
-        // Then test
-        const Vec3d dmin = p - center - Vec3d(m_widthPostTransform, m_widthPostTransform, m_widthPostTransform) * 0.5;
-        const Vec3d dmax = center - p - Vec3d(m_widthPostTransform, m_widthPostTransform, m_widthPostTransform) * 0.5;
-        const Vec3d d    = dmin.cwiseMax(dmax);
-        return std::max(std::max(d[0], d[1]), d[2]);
-    }
-
-    ///
-    /// \brief Get the min, max of the AABB around the cube
-    ///
-    void computeBoundingBox(Vec3d& min, Vec3d& max, const double paddingPercent = 0.0) override;
-
-    ///
-    /// \brief Update the Cube parameters applying the latest transform
-    ///
-    void updatePostTransformData() const override;
-
-protected:
-    void applyTransform(const Mat4d& m) override;
-
-    double m_width = 1.0;                      ///> Width of the cube
-    mutable double m_widthPostTransform = 1.0; ///> Width of the cube once transform applied
-};
-}
diff --git a/Source/Geometry/Analytic/imstkCube.cpp b/Source/Geometry/Analytic/imstkOrientedBox.cpp
similarity index 61%
rename from Source/Geometry/Analytic/imstkCube.cpp
rename to Source/Geometry/Analytic/imstkOrientedBox.cpp
index 027cb03d5211c6d115d19d2f6a3cf1f2a89beb20..4b2d417493f440cb43729d30e7e9b0f35490e1a2 100644
--- a/Source/Geometry/Analytic/imstkCube.cpp
+++ b/Source/Geometry/Analytic/imstkOrientedBox.cpp
@@ -19,82 +19,85 @@
 
 =========================================================================*/
 
-#include "imstkCube.h"
+#include "imstkOrientedBox.h"
 #include "imstkLogger.h"
 
 namespace imstk
 {
 void
-Cube::print() const
+OrientedBox::print() const
 {
     Geometry::print();
-    LOG(INFO) << "Width: " << m_width;
+    LOG(INFO) << "Extent0: " << m_extents[0];
+    LOG(INFO) << "Extent1: " << m_extents[1];
+    LOG(INFO) << "Extent2: " << m_extents[2];
 }
 
-double
-Cube::getWidth(DataType type /* = DataType::PostTransform */)
+Vec3d
+OrientedBox::getExtents(DataType type /* = DataType::PostTransform */)
 {
     if (type == DataType::PostTransform)
     {
         this->updatePostTransformData();
-        return m_widthPostTransform;
+        return m_extentsPostTransform;
     }
-    return m_width;
+    return m_extents;
 }
 
 void
-Cube::setWidth(const double w)
+OrientedBox::setExtents(const Vec3d extents)
 {
-    if (w <= 0)
+    if (extents[0] <= 0.0 || extents[1] <= 0.0 || extents[2] <= 0.0)
     {
-        LOG(WARNING) << "error: width should be positive.";
+        LOG(WARNING) << "error: extents should be positive.";
         return;
     }
-    if (m_width == w)
+    if (m_extents == extents)
     {
         return;
     }
-    m_width = w;
+    m_extents = extents;
     m_transformApplied = false;
     this->postModified();
 }
 
 void
-Cube::applyTransform(const Mat4d& m)
+OrientedBox::applyTransform(const Mat4d& m)
 {
     AnalyticalGeometry::applyTransform(m);
-    /*Vec3d s = Vec3d(
-        m_transform.block<3, 1>(0, 0).norm(),
-        m_transform.block<3, 1>(0, 1).norm(),
-        m_transform.block<3, 1>(0, 2).norm());*/
-    const double s0 = m.block<3, 1>(0, 0).norm();
-    this->setWidth(m_width * s0);
+    Vec3d s = Vec3d(
+        m.block<3, 1>(0, 0).norm(),
+        m.block<3, 1>(0, 1).norm(),
+        m.block<3, 1>(0, 2).norm());
+    this->setExtents(m_extents.cwiseProduct(s));
     this->postModified();
 }
 
 void
-Cube::updatePostTransformData() const
+OrientedBox::updatePostTransformData() const
 {
     if (m_transformApplied)
     {
         return;
     }
     AnalyticalGeometry::updatePostTransformData();
-    const double s0 = m_transform.block<3, 1>(0, 0).norm();
-    m_widthPostTransform = s0 * m_width;
-    m_transformApplied   = true;
+    const Vec3d s = getScaling();
+    m_extentsPostTransform = m_extents.cwiseProduct(s);
+    m_transformApplied     = true;
 }
 
 void
-Cube::computeBoundingBox(Vec3d& min, Vec3d& max, const double imstkNotUsed(paddingPercent))
+OrientedBox::computeBoundingBox(Vec3d& min, Vec3d& max, const double imstkNotUsed(paddingPercent))
 {
     updatePostTransformData();
 
     const Mat3d r = Quatd::FromTwoVectors(Vec3d(0.0, 1.0, 0.0), m_orientationAxisPostTransform).toRotationMatrix();
 
-    const Vec3d a = r.col(0) * m_widthPostTransform * 0.5;
-    const Vec3d b = r.col(1) * m_widthPostTransform * 0.5;
-    const Vec3d c = r.col(2) * m_widthPostTransform * 0.5;
+    Vec3d rotatedExtents = r * m_extentsPostTransform;
+
+    const Vec3d a = r.col(0) * m_extentsPostTransform[0];
+    const Vec3d b = r.col(1) * m_extentsPostTransform[1];
+    const Vec3d c = r.col(2) * m_extentsPostTransform[2];
 
     Vec3d pts[8];
     pts[0] = m_positionPostTransform + a + b + c;
diff --git a/Source/Geometry/Analytic/imstkOrientedBox.h b/Source/Geometry/Analytic/imstkOrientedBox.h
new file mode 100644
index 0000000000000000000000000000000000000000..7e467b2db8c9b8c5ec23579d97a90809273553a3
--- /dev/null
+++ b/Source/Geometry/Analytic/imstkOrientedBox.h
@@ -0,0 +1,161 @@
+/*=========================================================================
+
+   Library: iMSTK
+
+   Copyright (c) Kitware, Inc. & Center for Modeling, Simulation,
+   & Imaging in Medicine, Rensselaer Polytechnic Institute.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0.txt
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+=========================================================================*/
+
+#pragma once
+
+#include "imstkAnalyticalGeometry.h"
+
+namespace imstk
+{
+///
+/// \class OrientedBox
+///
+/// \brief OrientedBox geometry
+///
+class OrientedBox : public AnalyticalGeometry
+{
+public:
+    OrientedBox(const Vec3d& pos = Vec3d(0.0, 0.0, 0.0), const Vec3d extents = Vec3d(0.5, 0.5, 0.5), const Vec3d& orientationAxis = Vec3d(0.0, 1.0, 0.0),
+                const std::string& name = std::string("defaultOrientedBox")) : AnalyticalGeometry(name)
+    {
+        setPosition(pos);
+        setOrientationAxis(orientationAxis);
+        setExtents(extents);
+    }
+
+    virtual ~OrientedBox() override = default;
+
+    ///
+    /// \brief Returns the string representing the type name of the geometry
+    ///
+    virtual const std::string getTypeName() const override { return "OrientedBox"; }
+
+public:
+    ///
+    /// \brief Print the cube info
+    ///
+    void print() const override;
+
+    ///
+    /// \brief Returns the volume of the cube
+    ///
+    virtual double getVolume() override { return m_extents[0] * m_extents[1] * m_extents[2] * 8.0; }
+
+    ///
+    /// \brief Returns the extents of the cube
+    ///
+    Vec3d getExtents(DataType type = DataType::PostTransform);
+
+    ///
+    /// \brief Sets the extents of the cube (half dimensions)
+    ///
+    void setExtents(const Vec3d extents);
+
+    ///
+    /// \brief Sets the width of the cube (half dimensions)
+    ///
+    void setExtents(const double x, const double y, const double z) { setExtents(Vec3d(x, y, z)); }
+
+    ///
+    /// \brief Returns signed distance to surface at pos
+    /// \todo Doesn't support orientation yet
+    ///
+    double getFunctionValue(const Vec3d& pos) const override
+    {
+        const Mat3d  rot     = Quatd::FromTwoVectors(m_orientationAxisPostTransform, Vec3d(0.0, 1.0, 0.0)).toRotationMatrix();
+        const Vec3d& extents = m_extentsPostTransform;
+
+        const Vec3d diff   = (pos - m_positionPostTransform);
+        const Mat3d rotInv = rot.transpose();
+        const Vec3d proj   = rotInv * diff; // dot product/project onto each axes
+
+        bool inside[3] =
+        {
+            (std::abs(proj[0]) < extents[0]),
+            (std::abs(proj[1]) < extents[1]),
+            (std::abs(proj[2]) < extents[2])
+        };
+        bool isInsideCube = inside[0] && inside[1] && inside[2];
+
+        double signedDist = 0.0;
+        if (isInsideCube)
+        {
+            // If inside, find closest face, that is the signed distance
+            signedDist = std::numeric_limits<double>::lowest();
+            for (int i = 0; i < 3; i++)
+            {
+                double dist = proj[i];
+                if (dist < extents[i] && dist >= 0.0)
+                {
+                    const double unsignedDistToSide = (extents[i] - dist);
+                    if (-unsignedDistToSide > signedDist)
+                    {
+                        signedDist = -unsignedDistToSide;
+                    }
+                }
+                else if (dist > -extents[i] && dist < 0.0)
+                {
+                    const double unsignedDistToSide = (extents[i] + dist);
+                    if (-unsignedDistToSide > signedDist)
+                    {
+                        signedDist = -unsignedDistToSide;
+                    }
+                }
+            }
+        }
+        else
+        {
+            // If outside we need to also consider diagonal distance to corners and edges
+            // Compute nearest point
+            Vec3d closestPt = Vec3d::Zero();
+            Vec3d axialSignedDists = Vec3d::Zero();
+            for (int i = 0; i < 3; i++)
+            {
+                double dist = proj[i];
+
+                // If distance farther than the box extents, clamp to the box
+                if (dist >= extents[i] || dist <= -extents[i])
+                {
+                    axialSignedDists[i] = std::abs(dist) - extents[i];
+                }
+            }
+            signedDist = axialSignedDists.norm();
+        }
+        return signedDist;
+    }
+
+    ///
+    /// \brief Get the min, max of the AABB around the cube
+    ///
+    void computeBoundingBox(Vec3d& min, Vec3d& max, const double paddingPercent = 0.0) override;
+
+    ///
+    /// \brief Update the Cube parameters applying the latest transform
+    ///
+    void updatePostTransformData() const override;
+
+protected:
+    void applyTransform(const Mat4d& m) override;
+
+    Vec3d m_extents = Vec3d(0.5, 0.5, 0.5);                      // Half dimensions of the oriented box
+    mutable Vec3d m_extentsPostTransform = Vec3d(0.5, 0.5, 0.5); ///> Half dimensions of the oriented box once transform applied
+};
+}
diff --git a/Source/Geometry/Testing/imstkCubeTest.cpp b/Source/Geometry/Testing/imstkCubeTest.cpp
deleted file mode 100644
index 639b08b01540f622d2181366ecab6b24e06b8cc3..0000000000000000000000000000000000000000
--- a/Source/Geometry/Testing/imstkCubeTest.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-/*=========================================================================
-
-   Library: iMSTK
-
-   Copyright (c) Kitware, Inc. & Center for Modeling, Simulation,
-   & Imaging in Medicine, Rensselaer Polytechnic Institute.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0.txt
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-=========================================================================*/
-
-#include "imstkCube.h"
-
-#include <gtest/gtest.h>
-
-using namespace imstk;
-
-class imstkCubeTest : public ::testing::Test
-{
-protected:
-    Cube m_cube;
-};
-
-///
-/// \brief TODO
-///
-TEST_F(imstkCubeTest, SetGetWidth)
-{
-    m_cube.setWidth(2);
-    EXPECT_DOUBLE_EQ(2, m_cube.getWidth());
-
-    m_cube.setWidth(0.003);
-    EXPECT_DOUBLE_EQ(0.003, m_cube.getWidth());
-
-    m_cube.setWidth(400000000);
-    EXPECT_DOUBLE_EQ(400000000, m_cube.getWidth());
-
-    m_cube.setWidth(0);
-    EXPECT_LT(0, m_cube.getWidth());
-
-    m_cube.setWidth(-5);
-    EXPECT_LT(0, m_cube.getWidth());
-}
-
-///
-/// \brief TODO
-///
-TEST_F(imstkCubeTest, GetVolume)
-{
-    m_cube.setWidth(2);
-    EXPECT_DOUBLE_EQ(8, m_cube.getVolume());
-
-    m_cube.setWidth(0.003);
-    EXPECT_DOUBLE_EQ(0.003 * 0.003 * 0.003, m_cube.getVolume());
-
-    const double w = 400000000;
-    m_cube.setWidth(400000000);
-    EXPECT_DOUBLE_EQ(w * w * w, m_cube.getVolume());
-}
-
-///
-/// \brief test the cube SDF evaluator
-///
-TEST_F(imstkCubeTest, GetFunctionValue)
-{
-    m_cube.setWidth(2.);
-    m_cube.updatePostTransformData();
-
-    EXPECT_DOUBLE_EQ(-1., m_cube.getFunctionValue(Vec3d(0.0, 0.0, 0.0)));
-    EXPECT_DOUBLE_EQ(-0.5, m_cube.getFunctionValue(Vec3d(0.5, 0.0, 0.0)));
-    EXPECT_DOUBLE_EQ(0.0, m_cube.getFunctionValue(Vec3d(1.0, 1.0, 1.0)));
-    EXPECT_DOUBLE_EQ(9.0, m_cube.getFunctionValue(Vec3d(0.0, -10.0, 0.0)));
-
-    m_cube.rotate(Vec3d(1.0, 0.0, 0.0), 0.5 * PI);
-    m_cube.updatePostTransformData();
-
-    EXPECT_DOUBLE_EQ(-1.0, m_cube.getFunctionValue(Vec3d(0.0, 0.0, 0.0)));
-    EXPECT_DOUBLE_EQ(-0.5, m_cube.getFunctionValue(Vec3d(0.5, 0.0, 0.0)));
-    EXPECT_NEAR(0.0, m_cube.getFunctionValue(Vec3d(1.0, 1.0, 1.0)), 1.0e-10);
-    EXPECT_DOUBLE_EQ(9.0, m_cube.getFunctionValue(Vec3d(0.0, -10.0, 0.0)));
-
-    m_cube.rotate(Vec3d(1.0, 0.0, 0.0), 0.25 * PI);
-    m_cube.updatePostTransformData();
-
-    EXPECT_DOUBLE_EQ(-1.0, m_cube.getFunctionValue(Vec3d(0.0, 0.0, 0.0)));
-}
-
-///
-/// \brief TODO
-///
-int
-imstkCubeTest(int argc, char* argv[])
-{
-    // Init Google Test & Mock
-    ::testing::InitGoogleTest(&argc, argv);
-
-    // Run tests with gtest
-    return RUN_ALL_TESTS();
-}
diff --git a/Source/Geometry/Testing/imstkOrientedBoxTest.cpp b/Source/Geometry/Testing/imstkOrientedBoxTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..90b3588fe31e23c3faf62ada4425faafa7600aef
--- /dev/null
+++ b/Source/Geometry/Testing/imstkOrientedBoxTest.cpp
@@ -0,0 +1,87 @@
+/*=========================================================================
+
+   Library: iMSTK
+
+   Copyright (c) Kitware, Inc. & Center for Modeling, Simulation,
+   & Imaging in Medicine, Rensselaer Polytechnic Institute.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0.txt
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+=========================================================================*/
+
+#include "imstkOrientedBox.h"
+
+#include <gtest/gtest.h>
+
+using namespace imstk;
+
+class imstkOrientedBoxTest : public ::testing::Test
+{
+protected:
+    OrientedBox m_box;
+};
+
+///
+/// \brief TODO
+///
+TEST_F(imstkOrientedBoxTest, SetGetWidth)
+{
+    m_box.setExtents(1.0, 1.0, 1.0);
+    const Vec3d extents = m_box.getExtents();
+    EXPECT_DOUBLE_EQ(1.0, extents[0]);
+    EXPECT_DOUBLE_EQ(1.0, extents[1]);
+    EXPECT_DOUBLE_EQ(1.0, extents[2]);
+}
+
+///
+/// \brief TODO
+///
+TEST_F(imstkOrientedBoxTest, GetVolume)
+{
+    m_box.setExtents(1.0, 1.0, 1.0);
+    EXPECT_DOUBLE_EQ(8, m_box.getVolume());
+}
+
+///
+/// \brief test the cube SDF evaluator
+///
+TEST_F(imstkOrientedBoxTest, GetFunctionValue)
+{
+    m_box.setExtents(1.0, 1.0, 2.0);
+    m_box.updatePostTransformData();
+
+    EXPECT_DOUBLE_EQ(-1., m_box.getFunctionValue(Vec3d(0.0, 0.0, 0.0)));
+    EXPECT_DOUBLE_EQ(-0.5, m_box.getFunctionValue(Vec3d(0.5, 0.0, 0.0)));
+    EXPECT_DOUBLE_EQ(0.0, m_box.getFunctionValue(Vec3d(1.0, 1.0, 2.0)));
+    EXPECT_DOUBLE_EQ(9.0, m_box.getFunctionValue(Vec3d(0.0, -10.0, 0.0)));
+
+    m_box.rotate(Vec3d(1.0, 0.0, 0.0), 0.5 * PI);
+    m_box.updatePostTransformData();
+
+    EXPECT_DOUBLE_EQ(-1.0, m_box.getFunctionValue(Vec3d(0.0, 0.0, 0.0)));
+    EXPECT_DOUBLE_EQ(-0.5, m_box.getFunctionValue(Vec3d(0.5, 0.0, 0.0)));
+    EXPECT_DOUBLE_EQ(-0.5, m_box.getFunctionValue(Vec3d(0.0, -1.5, 0.0)));
+}
+
+///
+/// \brief TODO
+///
+int
+imstkOrientedBoxTest(int argc, char* argv[])
+{
+    // Init Google Test & Mock
+    ::testing::InitGoogleTest(&argc, argv);
+
+    // Run tests with gtest
+    return RUN_ALL_TESTS();
+}
diff --git a/Source/Geometry/Testing/imstkSurfaceMeshTest.cpp b/Source/Geometry/Testing/imstkSurfaceMeshTest.cpp
index 1c18239c868196eaacc7f4e33418d2d265d22eec..ad1e9ce1a74743e0f959885cba453f9230ff6925 100644
--- a/Source/Geometry/Testing/imstkSurfaceMeshTest.cpp
+++ b/Source/Geometry/Testing/imstkSurfaceMeshTest.cpp
@@ -19,7 +19,7 @@
 
 =========================================================================*/
 
-#include "imstkCube.h"
+#include "imstkOrientedBox.h"
 #include "imstkGeometryUtilities.h"
 #include "imstkMath.h"
 #include "imstkPointSet.h"
@@ -186,7 +186,7 @@ TEST_F(imstkSurfaceMeshTest, ComputeVertexNormals)
 TEST_F(imstkSurfaceMeshTest, GetVolume)
 {
     std::shared_ptr<SurfaceMesh> cubeSurfMesh =
-        GeometryUtils::toCubeSurfaceMesh(std::make_shared<Cube>(Vec3d(0.0, 0.0, 0.0), 1.0));
+        GeometryUtils::toSurfaceMesh(std::make_shared<OrientedBox>());
     EXPECT_NEAR(1.0, cubeSurfMesh->getVolume(), 0.0000000000001);
 }
 
diff --git a/Source/Geometry/imstkGeometryUtilities.cpp b/Source/Geometry/imstkGeometryUtilities.cpp
index 4a5c78f448df360a6cbd7209a60c172c7a464cca..056ac17d1d2cd73f1584713f5b2b59888a0fbfc6 100644
--- a/Source/Geometry/imstkGeometryUtilities.cpp
+++ b/Source/Geometry/imstkGeometryUtilities.cpp
@@ -20,11 +20,11 @@
 =========================================================================*/
 
 #include "imstkGeometryUtilities.h"
-#include "imstkCube.h"
 #include "imstkHexahedralMesh.h"
 #include "imstkImageData.h"
 #include "imstkLineMesh.h"
 #include "imstkLogger.h"
+#include "imstkOrientedBox.h"
 #include "imstkParallelUtils.h"
 #include "imstkPlane.h"
 #include "imstkSphere.h"
@@ -775,18 +775,19 @@ GeometryUtils::copyToVtkDataAttributes(vtkDataSetAttributes* pointData, const st
 }
 
 std::shared_ptr<SurfaceMesh>
-GeometryUtils::toCubeSurfaceMesh(std::shared_ptr<Cube> cube)
+GeometryUtils::toSurfaceMesh(std::shared_ptr<OrientedBox> obb)
 {
     vtkNew<vtkCubeSource> cubeSource;
-    cubeSource->SetCenter(cube->getPosition(Geometry::DataType::PreTransform).data());
-    cubeSource->SetXLength(cube->getWidth());
-    cubeSource->SetYLength(cube->getWidth());
-    cubeSource->SetZLength(cube->getWidth());
+    cubeSource->SetCenter(obb->getPosition(Geometry::DataType::PreTransform).data());
+    Vec3d extents = obb->getExtents();
+    cubeSource->SetXLength(extents[0] * 2.0);
+    cubeSource->SetYLength(extents[1] * 2.0);
+    cubeSource->SetZLength(extents[2] * 2.0);
     cubeSource->Update();
 
     Mat4d mat;
     mat.setIdentity();
-    mat.block<3, 3>(0, 0) = cube->getRotation();
+    mat.block<3, 3>(0, 0) = obb->getRotation();
 
     vtkNew<vtkTransform> transform;
     transform->SetMatrix(mat.data());
diff --git a/Source/Geometry/imstkGeometryUtilities.h b/Source/Geometry/imstkGeometryUtilities.h
index d2bce7fc43bb735a1da9607f6bb26bfa97a1a375..ecbf4955f26e65c47c8f9c48e0bc69c1d2f10875 100644
--- a/Source/Geometry/imstkGeometryUtilities.h
+++ b/Source/Geometry/imstkGeometryUtilities.h
@@ -56,7 +56,7 @@ class SurfaceMesh;
 class TetrahedralMesh;
 class VolumetricMesh;
 
-class Cube;
+class OrientedBox;
 class Sphere;
 class Plane;
 
@@ -194,9 +194,9 @@ void copyToDataMap(vtkDataSetAttributes* pointData, std::unordered_map<std::stri
 void copyToVtkDataAttributes(vtkDataSetAttributes* pointData, const std::unordered_map<std::string, std::shared_ptr<AbstractDataArray>>& dataMap);
 
 ///
-/// \brief Produces SurfaceMesh cube from imstkCube
+/// \brief Produces SurfaceMesh box from imstkOrientedBox
 ///
-std::shared_ptr<SurfaceMesh> toCubeSurfaceMesh(std::shared_ptr<Cube> cube);
+std::shared_ptr<SurfaceMesh> toSurfaceMesh(std::shared_ptr<OrientedBox> obb);
 
 ///
 /// \brief UV sphere from imstkSphere
diff --git a/Source/Rendering/CMakeLists.txt b/Source/Rendering/CMakeLists.txt
index eb7e049ff975add5248c127db32082a6c299a279..9cd5ece2fae4cf79aaadd45152529343ecf5e22c 100644
--- a/Source/Rendering/CMakeLists.txt
+++ b/Source/Rendering/CMakeLists.txt
@@ -5,7 +5,7 @@
 set(VTK_H_FILES
     VTKRenderer/imstkVTKRenderer.h
     VTKRenderer/imstkVTKTextureDelegate.h
-    VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.h
+    VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.h
     VTKRenderer/RenderDelegate/imstkVTKLineMeshRenderDelegate.h
     VTKRenderer/RenderDelegate/imstkVTKPlaneRenderDelegate.h
     VTKRenderer/RenderDelegate/imstkVTKRenderDelegate.h
@@ -28,7 +28,7 @@ set(VTK_H_FILES
 set(VTK_CPP_FILES
     VTKRenderer/imstkVTKRenderer.cpp
     VTKRenderer/imstkVTKTextureDelegate.cpp
-    VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.cpp
+    VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.cpp
     VTKRenderer/RenderDelegate/imstkVTKLineMeshRenderDelegate.cpp
     VTKRenderer/RenderDelegate/imstkVTKPlaneRenderDelegate.cpp
     VTKRenderer/RenderDelegate/imstkVTKRenderDelegate.cpp
diff --git a/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.cpp b/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.cpp
similarity index 61%
rename from Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.cpp
rename to Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.cpp
index 39ff30de2aad8b3ded86a454c44ee3877e6b928e..73181e7cc1e75f5d35bf3b7853ca764f0f66c4e0 100644
--- a/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.cpp
+++ b/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.cpp
@@ -19,8 +19,8 @@
 
 =========================================================================*/
 
-#include "imstkVTKCubeRenderDelegate.h"
-#include "imstkCube.h"
+#include "imstkVTKOrientedBoxRenderDelegate.h"
+#include "imstkOrientedBox.h"
 #include "imstkVisualModel.h"
 
 #include <vtkActor.h>
@@ -30,20 +30,21 @@
 
 namespace imstk
 {
-VTKCubeRenderDelegate::VTKCubeRenderDelegate(std::shared_ptr<VisualModel> visualModel) : VTKPolyDataRenderDelegate(visualModel)
+VTKOrientedCubeRenderDelegate::VTKOrientedCubeRenderDelegate(std::shared_ptr<VisualModel> visualModel) : VTKPolyDataRenderDelegate(visualModel),
+    m_cubeSource(vtkSmartPointer<vtkCubeSource>::New())
 {
-    //auto geometry = std::static_pointer_cast<Cube>(visualModel->getGeometry());
+    auto         geometry = std::dynamic_pointer_cast<OrientedBox>(visualModel->getGeometry());
+    const Vec3d& extents  = geometry->getExtents();
 
-    vtkNew<vtkCubeSource> cubeSource;
-    cubeSource->SetCenter(0, 0, 0);
-    cubeSource->SetXLength(1.0);
-    cubeSource->SetYLength(1.0);
-    cubeSource->SetZLength(1.0);
+    m_cubeSource->SetCenter(0.0, 0.0, 0.0);
+    m_cubeSource->SetXLength(extents[0] * 2.0);
+    m_cubeSource->SetYLength(extents[1] * 2.0);
+    m_cubeSource->SetZLength(extents[2] * 2.0);
 
     // Setup mapper
     {
         vtkNew<vtkPolyDataMapper> mapper;
-        mapper->SetInputConnection(cubeSource->GetOutputPort());
+        mapper->SetInputConnection(m_cubeSource->GetOutputPort());
         vtkNew<vtkActor> actor;
         actor->SetMapper(mapper);
         actor->SetUserTransform(m_transform);
@@ -56,17 +57,23 @@ VTKCubeRenderDelegate::VTKCubeRenderDelegate(std::shared_ptr<VisualModel> visual
 }
 
 void
-VTKCubeRenderDelegate::processEvents()
+VTKOrientedCubeRenderDelegate::processEvents()
 {
     VTKRenderDelegate::processEvents();
 
     // Don't use events for primitives, just always update
-    auto geometry = std::static_pointer_cast<Cube>(m_visualModel->getGeometry());
+    auto         geometry = std::dynamic_pointer_cast<OrientedBox>(m_visualModel->getGeometry());
+    const Vec3d& extents  = geometry->getExtents();
+
+    m_cubeSource->SetXLength(extents[0] * 2.0);
+    m_cubeSource->SetYLength(extents[1] * 2.0);
+    m_cubeSource->SetZLength(extents[2] * 2.0);
+    m_cubeSource->Modified();
 
     AffineTransform3d T = AffineTransform3d::Identity();
     T.translate(geometry->getPosition(Geometry::DataType::PostTransform));
     T.rotate(Quatd::FromTwoVectors(UP_VECTOR, geometry->getOrientationAxis(Geometry::DataType::PostTransform)));
-    T.scale(geometry->getWidth(Geometry::DataType::PostTransform));
+    T.scale(1.0);
     T.matrix().transposeInPlace();
 
     m_transform->SetMatrix(T.data());
diff --git a/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.h b/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.h
similarity index 74%
rename from Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.h
rename to Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.h
index 4518656b5c1e11ee91fa4ea2fd2f8e44ad0b58f7..c8776ea0f4b7f60778e8fa64c050d3d1e4fb72e6 100644
--- a/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKCubeRenderDelegate.h
+++ b/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKOrientedBoxRenderDelegate.h
@@ -23,29 +23,34 @@
 
 #include "imstkVTKPolyDataRenderDelegate.h"
 
+class vtkCubeSource;
+
 namespace imstk
 {
 ///
-/// \class VTKCubeRenderDelegate
+/// \class VTKOrientedCubeRenderDelegate
 ///
-/// \brief Cube render delegate with VTK backend
+/// \brief Oriented box render delegate with VTK backend
 ///
-class VTKCubeRenderDelegate : public VTKPolyDataRenderDelegate
+class VTKOrientedCubeRenderDelegate : public VTKPolyDataRenderDelegate
 {
 public:
     ///
     /// \brief Constructor
     ///
-    VTKCubeRenderDelegate(std::shared_ptr<VisualModel> visualModel);
+    VTKOrientedCubeRenderDelegate(std::shared_ptr<VisualModel> visualModel);
 
     ///
     /// \brief Destructor
     ///
-    virtual ~VTKCubeRenderDelegate() override = default;
+    virtual ~VTKOrientedCubeRenderDelegate() override = default;
 
     ///
     /// \brief Update cube source based on the cube geometry
     ///
     void processEvents() override;
+
+protected:
+    vtkSmartPointer<vtkCubeSource> m_cubeSource;
 };
 } // imstk
diff --git a/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKRenderDelegate.cpp b/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKRenderDelegate.cpp
index 78866d40afc28f187acda158c1fd9c83cf780dbd..56e00828d1b1605904a4456206e4ef02bd7e1d02 100644
--- a/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKRenderDelegate.cpp
+++ b/Source/Rendering/VTKRenderer/RenderDelegate/imstkVTKRenderDelegate.cpp
@@ -33,17 +33,17 @@
 
 // VTK render delegates
 #include "imstkVTKCapsuleRenderDelegate.h"
-#include "imstkVTKCubeRenderDelegate.h"
 #include "imstkVTKCylinderRenderDelegate.h"
 #include "imstkVTKFluidRenderDelegate.h"
-#include "imstkVTKSurfaceNormalRenderDelegate.h"
 #include "imstkVTKHexahedralMeshRenderDelegate.h"
 #include "imstkVTKImageDataRenderDelegate.h"
 #include "imstkVTKLineMeshRenderDelegate.h"
+#include "imstkVTKOrientedBoxRenderDelegate.h"
 #include "imstkVTKPlaneRenderDelegate.h"
 #include "imstkVTKPointSetRenderDelegate.h"
 #include "imstkVTKSphereRenderDelegate.h"
 #include "imstkVTKSurfaceMeshRenderDelegate.h"
+#include "imstkVTKSurfaceNormalRenderDelegate.h"
 #include "imstkVTKTetrahedralMeshRenderDelegate.h"
 
 #include <vtkActor.h>
@@ -127,9 +127,9 @@ VTKRenderDelegate::makeDelegate(std::shared_ptr<VisualModel> visualModel)
         {
             return std::make_shared<VTKCapsuleRenderDelegate>(visualModel);
         }
-        else if (geomType == "Cube")
+        else if (geomType == "OrientedBox")
         {
-            return std::make_shared<VTKCubeRenderDelegate>(visualModel);
+            return std::make_shared<VTKOrientedCubeRenderDelegate>(visualModel);
         }
         else if (geomType == "Cylinder")
         {
diff --git a/Source/apiUtilities/imstkAPIUtilities.cpp b/Source/apiUtilities/imstkAPIUtilities.cpp
index 478ff0a30547e134aab1f5d10f78fc7306dae3d1..df74d14c90630918d064e8484a2d681d9efb485e 100644
--- a/Source/apiUtilities/imstkAPIUtilities.cpp
+++ b/Source/apiUtilities/imstkAPIUtilities.cpp
@@ -32,7 +32,7 @@
 
 // Geometry
 #include "imstkCapsule.h"
-#include "imstkCube.h"
+#include "imstkOrientedBox.h"
 #include "imstkImageData.h"
 #include "imstkMeshIO.h"
 #include "imstkPlane.h"
@@ -48,7 +48,7 @@ std::unordered_map<std::string, std::function<std::shared_ptr<Geometry>()>> geom
 {
     { "Sphere", []() { return std::make_shared<Sphere>(); } },
     { "Plane", []() { return std::make_shared<Sphere>(); } },
-    { "Cube", []() { return std::make_shared<Sphere>(); } },
+    { "OrientedBox", []() { return std::make_shared<OrientedBox>(); } },
     { "Capsule", []() { return std::make_shared<Sphere>(); } },
     { "Cylinder", []() { return std::make_shared<Sphere>(); } }
 };