temp_viz removed

modules/viz/include/opencv2/viz.hpp

@@ -53,12 +53,15 @@
 #include <opencv2/viz/viz3d.hpp>
 
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         //! takes coordiante frame data and builds transfrom to global coordinate frame
         CV_EXPORTS Affine3f makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin = Vec3f::all(0));
 
         CV_EXPORTS Affine3f makeCameraPose(const Vec3f& position, const Vec3f& focal_point, const Vec3f& up_vector);
+    }
 }
 
 

modules/viz/include/opencv2/viz/events.hpp

@@ -3,8 +3,10 @@
 #include <string>
 #include <opencv2/viz/types.hpp>
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         class KeyboardEvent
         {
         public:
@@ -70,12 +72,13 @@ namespace temp_viz
             Point pointer;
             unsigned int key_state;
         };
+    }
 }
 
 ////////////////////////////////////////////////////////////////////
 /// Implementation
 
-inline temp_viz::KeyboardEvent::KeyboardEvent (bool _action, const std::string& _key_sym, unsigned char key, bool alt, bool ctrl, bool shift)
+inline cv::viz::KeyboardEvent::KeyboardEvent (bool _action, const std::string& _key_sym, unsigned char key, bool alt, bool ctrl, bool shift)
   : action_ (_action), modifiers_ (0), key_code_(key), key_sym_ (_key_sym)
 {
   if (alt)
@@ -88,15 +91,15 @@ inline temp_viz::KeyboardEvent::KeyboardEvent (bool _action, const std::string&
     modifiers_ |= Shift;
 }
 
-inline bool temp_viz::KeyboardEvent::isAltPressed () const { return (modifiers_ & Alt) != 0; }
-inline bool temp_viz::KeyboardEvent::isCtrlPressed () const { return (modifiers_ & Ctrl) != 0; }
-inline bool temp_viz::KeyboardEvent::isShiftPressed () const { return (modifiers_ & Shift) != 0; }
-inline unsigned char temp_viz::KeyboardEvent::getKeyCode () const { return key_code_; }
-inline const temp_viz::String& temp_viz::KeyboardEvent::getKeySym () const { return key_sym_; }
-inline bool temp_viz::KeyboardEvent::keyDown () const { return action_; }
-inline bool temp_viz::KeyboardEvent::keyUp () const { return !action_; }
+inline bool cv::viz::KeyboardEvent::isAltPressed () const { return (modifiers_ & Alt) != 0; }
+inline bool cv::viz::KeyboardEvent::isCtrlPressed () const { return (modifiers_ & Ctrl) != 0; }
+inline bool cv::viz::KeyboardEvent::isShiftPressed () const { return (modifiers_ & Shift) != 0; }
+inline unsigned char cv::viz::KeyboardEvent::getKeyCode () const { return key_code_; }
+inline const cv::String& cv::viz::KeyboardEvent::getKeySym () const { return key_sym_; }
+inline bool cv::viz::KeyboardEvent::keyDown () const { return action_; }
+inline bool cv::viz::KeyboardEvent::keyUp () const { return !action_; }
 
-inline temp_viz::MouseEvent::MouseEvent (const Type& _type, const MouseButton& _button, const Point& _p,  bool alt, bool ctrl, bool shift)
+inline cv::viz::MouseEvent::MouseEvent (const Type& _type, const MouseButton& _button, const Point& _p,  bool alt, bool ctrl, bool shift)
     : type(_type), button(_button), pointer(_p), key_state(0)
 {
     if (alt)

modules/viz/include/opencv2/viz/types.hpp

@@ -5,37 +5,40 @@
 #include <opencv2/core.hpp>
 #include <opencv2/core/affine.hpp>
 
-namespace temp_viz
+namespace cv
 {
-    //qt creator hack
-    typedef cv::Scalar Scalar;
-    typedef cv::Mat Mat;
     typedef std::string String;
-
-    typedef cv::Vec3d Vec3d;
-    typedef cv::Vec3f Vec3f;
-    typedef cv::Vec4d Vec4d;
-    typedef cv::Vec4f Vec4f;
-    typedef cv::Vec2d Vec2d;
-    typedef cv::Vec2i Vec2i;
-    typedef cv::Vec3b Vec3b;
-    typedef cv::Matx33d Matx33d;
-    typedef cv::Affine3f Affine3f;
-    typedef cv::Affine3d Affine3d;
-    typedef cv::Point2i Point2i;
-    typedef cv::Point3f Point3f;
-    typedef cv::Point3d Point3d;
-    typedef cv::Matx44d Matx44d;
-    typedef cv::Matx44f Matx44f;
-    typedef cv::Size Size;
-    typedef cv::Point Point;
-    typedef cv::InputArray InputArray;
-    using cv::Point3_;
-    using cv::Vec;
-    using cv::Mat_;
-    using cv::DataDepth;
-    using cv::DataType;
-
+//    //qt creator hack
+//    typedef cv::Scalar Scalar;
+//    typedef cv::Mat Mat;
+//    typedef std::string String;
+
+//    typedef cv::Vec3d Vec3d;
+//    typedef cv::Vec3f Vec3f;
+//    typedef cv::Vec4d Vec4d;
+//    typedef cv::Vec4f Vec4f;
+//    typedef cv::Vec2d Vec2d;
+//    typedef cv::Vec2i Vec2i;
+//    typedef cv::Vec3b Vec3b;
+//    typedef cv::Matx33d Matx33d;
+//    typedef cv::Affine3f Affine3f;
+//    typedef cv::Affine3d Affine3d;
+//    typedef cv::Point2i Point2i;
+//    typedef cv::Point3f Point3f;
+//    typedef cv::Point3d Point3d;
+//    typedef cv::Matx44d Matx44d;
+//    typedef cv::Matx44f Matx44f;
+//    typedef cv::Size Size;
+//    typedef cv::Point Point;
+//    typedef cv::InputArray InputArray;
+//    using cv::Point3_;
+//    using cv::Vec;
+//    using cv::Mat_;
+//    using cv::DataDepth;
+//    using cv::DataType;
+//    using cv::Ptr;
+    namespace viz
+    {
         class CV_EXPORTS Color : public Scalar
         {
         public:
@@ -106,4 +109,5 @@ namespace temp_viz
 
         template<typename _Tp> inline bool isNan(const Point3_<_Tp>& p)
         { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
+    }
 }

modules/viz/include/opencv2/viz/viz3d.hpp

@@ -13,8 +13,10 @@
 #include <opencv2/viz/widgets.hpp>
 #include <opencv2/viz/events.hpp>
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         class CV_EXPORTS Viz3d
         {
         public:
@@ -55,6 +57,7 @@ namespace temp_viz
             struct VizImpl;
             VizImpl* impl_;
         };
+    }
 }
 
 

modules/viz/include/opencv2/viz/widget_accessor.hpp

@@ -4,8 +4,10 @@
 #include <vtkSmartPointer.h>
 #include <vtkProp.h>
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         class Widget;
 
         //The class is only that depends on VTK in its interface.
@@ -15,4 +17,5 @@ namespace temp_viz
             static vtkSmartPointer<vtkProp> getProp(const Widget &widget);
             static void setProp(Widget &widget, vtkSmartPointer<vtkProp> prop);
         };
+    }
 }

modules/viz/include/opencv2/viz/widgets.hpp

@@ -3,8 +3,10 @@
 #include <opencv2/viz/types.hpp>
 
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         /////////////////////////////////////////////////////////////////////////////
         /// The base class for all widgets
         class CV_EXPORTS Widget
@@ -174,7 +176,9 @@ namespace temp_viz
         template<> CV_EXPORTS TextWidget Widget::cast<TextWidget>();
         template<> CV_EXPORTS CloudWidget Widget::cast<CloudWidget>();
         template<> CV_EXPORTS CloudNormalsWidget Widget::cast<CloudNormalsWidget>();
-}
+
+    } /* namespace viz */
+} /* namespace cv */
 
 
 

modules/viz/src/common.cpp

@@ -5,7 +5,7 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
-//Eigen::Matrix4d temp_viz::vtkToEigen (vtkMatrix4x4* vtk_matrix)
+//Eigen::Matrix4d cv::viz::vtkToEigen (vtkMatrix4x4* vtk_matrix)
 //{
 //    Eigen::Matrix4d eigen_matrix = Eigen::Matrix4d::Identity ();
 //    for (int i=0; i < 4; i++)
@@ -16,7 +16,7 @@
 //}
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
-//Eigen::Vector2i temp_viz::worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
+//Eigen::Vector2i cv::viz::worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
 //{
 //    // Transform world to clipping coordinates
 //    Eigen::Vector4d world (view_projection_matrix * world_pt);
@@ -34,7 +34,7 @@
 //}
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-//void temp_viz::getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24])
+//void cv::viz::getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24])
 //{
 //    // Set up the normals
 //    Eigen::Vector4d normals[6];
@@ -65,7 +65,7 @@
 //    }
 //}
 
-//int temp_viz::cullFrustum (double frustum[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb)
+//int cv::viz::cullFrustum (double frustum[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb)
 //{
 //    int result = PCL_INSIDE_FRUSTUM;
 
@@ -104,7 +104,7 @@
 //}
 
 //void
-//temp_viz::getModelViewPosition (Eigen::Matrix4d model_view_matrix, Eigen::Vector3d &position)
+//cv::viz::getModelViewPosition (Eigen::Matrix4d model_view_matrix, Eigen::Vector3d &position)
 //{
 //  //Compute eye or position from model view matrix
 //  Eigen::Matrix4d inverse_model_view_matrix = model_view_matrix.inverse();
@@ -174,7 +174,7 @@ int hull_vertex_table[43][7] = {
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 //float
-//temp_viz::viewScreenArea (
+//cv::viz::viewScreenArea (
 //        const Eigen::Vector3d &eye,
 //        const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb,
 //        const Eigen::Matrix4d &view_projection_matrix, int width, int height)
@@ -261,7 +261,7 @@ int hull_vertex_table[43][7] = {
 //    for (int i = 0; i < num; i++)
 //    {
 //        Eigen::Vector4d world_pt = bounding_box[hull_vertex_table[pos][i]];
-//        Eigen::Vector2i screen_pt = temp_viz::worldToView(world_pt, view_projection_matrix, width, height);
+//        Eigen::Vector2i screen_pt = cv::viz::worldToView(world_pt, view_projection_matrix, width, height);
 //        //    cout << "point[" << i << "]: " << screen_pt.x() << " " << screen_pt.y() << endl;
 //        dst[i] = Eigen::Vector2d(screen_pt.x (), screen_pt.y ());
 //    }
@@ -276,7 +276,7 @@ int hull_vertex_table[43][7] = {
 //}
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Camera::computeViewMatrix (Affine3d& view_mat) const
+void cv::viz::Camera::computeViewMatrix (Affine3d& view_mat) const
 {
     //constructs view matrix from camera pos, view up, and the point it is looking at
     //this code is based off of gluLookAt http://www.opengl.org/wiki/GluLookAt_code
@@ -297,7 +297,7 @@ void temp_viz::Camera::computeViewMatrix (Affine3d& view_mat) const
 }
 
 ///////////////////////////////////////////////////////////////////////
-void temp_viz::Camera::computeProjectionMatrix (Matx44d& proj) const
+void cv::viz::Camera::computeProjectionMatrix (Matx44d& proj) const
 {
     double top    = clip[0] * tan (0.5 * fovy);
     double left   = -(top * window_size[0]) / window_size[1];

modules/viz/src/common.h

@@ -3,20 +3,21 @@
 #include <opencv2/core/cvdef.h>
 #include <opencv2/core.hpp>
 #include <opencv2/viz/types.hpp>
-//#include <vtkMatrix4x4.h>
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         //CV_EXPORTS Eigen::Matrix4d vtkToEigen (vtkMatrix4x4* vtk_matrix);
         //CV_EXPORTS Eigen::Vector2i worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
         //CV_EXPORTS void getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24]);
 
-//    enum FrustumCull
-//    {
-//        PCL_INSIDE_FRUSTUM,
-//        PCL_INTERSECT_FRUSTUM,
-//        PCL_OUTSIDE_FRUSTUM
-//    };
+    //    enum FrustumCull
+    //    {
+    //        PCL_INSIDE_FRUSTUM,
+    //        PCL_INTERSECT_FRUSTUM,
+    //        PCL_OUTSIDE_FRUSTUM
+    //    };
 
         //CV_EXPORTS int cullFrustum (double planes[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb);
         //CV_EXPORTS float viewScreenArea (const Eigen::Vector3d &eye, const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
@@ -120,4 +121,6 @@ namespace temp_viz
             }
         };
 
+    }
+
 }

modules/viz/src/interactor_style.cpp

@@ -7,9 +7,9 @@
 using namespace cv;
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::Initialize ()
+void cv::viz::InteractorStyle::Initialize ()
 {
-    modifier_ = temp_viz::InteractorStyle::KB_MOD_ALT;
+    modifier_ = cv::viz::InteractorStyle::KB_MOD_ALT;
     // Set windows size (width, height) to unknown (-1)
     win_size_ = Vec2i(-1, -1);
     win_pos_ = Vec2i(0, 0);
@@ -33,7 +33,7 @@ void temp_viz::InteractorStyle::Initialize ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::saveScreenshot (const std::string &file)
+void cv::viz::InteractorStyle::saveScreenshot (const std::string &file)
 {
     FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
     wif_->SetInput (Interactor->GetRenderWindow ());
@@ -44,29 +44,29 @@ void temp_viz::InteractorStyle::saveScreenshot (const std::string &file)
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::zoomIn ()
+void cv::viz::InteractorStyle::zoomIn ()
 {
     FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
     // Zoom in
     StartDolly ();
     double factor = 10.0 * 0.2 * .5;
-    Dolly (pow (1.1, factor));
+    Dolly (std::pow (1.1, factor));
     EndDolly ();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::zoomOut ()
+void cv::viz::InteractorStyle::zoomOut ()
 {
     FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
     // Zoom out
     StartDolly ();
     double factor = 10.0 * -0.2 * .5;
-    Dolly (pow (1.1, factor));
+    Dolly (std::pow (1.1, factor));
     EndDolly ();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnChar ()
+void cv::viz::InteractorStyle::OnChar ()
 {
     // Make sure we ignore the same events we handle in OnKeyDown to avoid calling things twice
     FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
@@ -133,7 +133,7 @@ void temp_viz::InteractorStyle::OnChar ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
+void cv::viz::InteractorStyle::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
 {
     // Register the callback function and store the user data
     mouseCallback_ = callback;
@@ -141,7 +141,7 @@ void temp_viz::InteractorStyle::registerMouseCallback(void (*callback)(const Mou
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void *cookie)
+void cv::viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void *cookie)
 {
     // Register the callback function and store the user data
     keyboardCallback_ = callback;
@@ -150,7 +150,7 @@ void temp_viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const
 
 //////////////////////////////////////////////////////////////////////////////////////////////
 void
-temp_viz::InteractorStyle::OnKeyDown ()
+cv::viz::InteractorStyle::OnKeyDown ()
 {
     if (!init_)
     {
@@ -507,7 +507,7 @@ temp_viz::InteractorStyle::OnKeyDown ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnKeyUp ()
+void cv::viz::InteractorStyle::OnKeyUp ()
 {
     KeyboardEvent event (false, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
     // Check if there is a keyboard callback registered
@@ -518,7 +518,7 @@ void temp_viz::InteractorStyle::OnKeyUp ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMouseMove ()
+void cv::viz::InteractorStyle::OnMouseMove ()
 {
     Vec2i p(Interactor->GetEventPosition());
     MouseEvent event (MouseEvent::MouseMove, MouseEvent::NoButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
@@ -528,7 +528,7 @@ void temp_viz::InteractorStyle::OnMouseMove ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnLeftButtonDown ()
+void cv::viz::InteractorStyle::OnLeftButtonDown ()
 {
     Vec2i p(Interactor->GetEventPosition());
     MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
@@ -539,7 +539,7 @@ void temp_viz::InteractorStyle::OnLeftButtonDown ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnLeftButtonUp ()
+void cv::viz::InteractorStyle::OnLeftButtonUp ()
 {
     Vec2i p(Interactor->GetEventPosition());
     MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
@@ -549,7 +549,7 @@ void temp_viz::InteractorStyle::OnLeftButtonUp ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMiddleButtonDown ()
+void cv::viz::InteractorStyle::OnMiddleButtonDown ()
 {
     Vec2i p(Interactor->GetEventPosition());
 
@@ -561,7 +561,7 @@ void temp_viz::InteractorStyle::OnMiddleButtonDown ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMiddleButtonUp ()
+void cv::viz::InteractorStyle::OnMiddleButtonUp ()
 {
     Vec2i p(Interactor->GetEventPosition());
     MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
@@ -571,7 +571,7 @@ void temp_viz::InteractorStyle::OnMiddleButtonUp ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnRightButtonDown ()
+void cv::viz::InteractorStyle::OnRightButtonDown ()
 {
     Vec2i p(Interactor->GetEventPosition());
 
@@ -583,7 +583,7 @@ void temp_viz::InteractorStyle::OnRightButtonDown ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnRightButtonUp ()
+void cv::viz::InteractorStyle::OnRightButtonUp ()
 {
     Vec2i p(Interactor->GetEventPosition());
     MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::RightButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
@@ -593,7 +593,7 @@ void temp_viz::InteractorStyle::OnRightButtonUp ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMouseWheelForward ()
+void cv::viz::InteractorStyle::OnMouseWheelForward ()
 {
     Vec2i p(Interactor->GetEventPosition());
     MouseEvent event (MouseEvent::MouseScrollUp, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
@@ -625,7 +625,7 @@ void temp_viz::InteractorStyle::OnMouseWheelForward ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMouseWheelBackward ()
+void cv::viz::InteractorStyle::OnMouseWheelBackward ()
 {
     Vec2i p(Interactor->GetEventPosition());
     MouseEvent event (MouseEvent::MouseScrollDown, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
@@ -658,7 +658,7 @@ void temp_viz::InteractorStyle::OnMouseWheelBackward ()
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnTimer ()
+void cv::viz::InteractorStyle::OnTimer ()
 {
     if (!init_)
     {
@@ -676,10 +676,15 @@ void temp_viz::InteractorStyle::OnTimer ()
 }
 
 
-namespace temp_viz
-{
-    // Standard VTK macro for *New ()
-    vtkStandardNewMacro (InteractorStyle);
 
+
+
+namespace cv
+{
+    namespace viz
+    {
+        //Standard VTK macro for *New()
+        vtkStandardNewMacro(InteractorStyle)
+    }
 }
 

modules/viz/src/interactor_style.h

@@ -3,8 +3,10 @@
 #include "viz_types.h"
 #include <opencv2/viz/events.hpp>
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         /** \brief PCLVisualizerInteractorStyle defines an unique, custom VTK
           * based interactory style for PCL Visualizer applications. Besides
           * defining the rendering style, we also create a list of custom actions
@@ -54,7 +56,7 @@ namespace temp_viz
             /** \brief Pass a pointer to the actor map
               * \param[in] actors the actor map that will be used with this style
               */
-            inline void setCloudActorMap (const cv::Ptr<CloudActorMap>& actors) { actors_ = actors; }
+            inline void setCloudActorMap (const Ptr<CloudActorMap>& actors) { actors_ = actors; }
 
             /** \brief Pass a set of renderers to the interactor style.
                   * \param[in] rens the vtkRendererCollection to use
@@ -152,4 +154,5 @@ namespace temp_viz
             /** \brief MouseEvent callback user data */
             void *mouse_callback_cookie_;
         };
+    }
 }

modules/viz/src/mesh_load.cpp

@@ -6,7 +6,7 @@
 #include <vtkPointData.h>
 #include <vtkCellArray.h>
 
-temp_viz::Mesh3d::Ptr temp_viz::Mesh3d::mesh_load(const String& file)
+cv::viz::Mesh3d::Ptr cv::viz::Mesh3d::mesh_load(const String& file)
 {
     Mesh3d::Ptr mesh = new Mesh3d();
 

modules/viz/src/precomp.hpp

@@ -158,8 +158,10 @@
 #include "opencv2/viz/widget_accessor.hpp"
 #include <opencv2/calib3d.hpp>
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         template<typename _Tp> Vec<_Tp, 3>* vtkpoints_data(vtkSmartPointer<vtkPoints>& points);
 
         template<> static inline Vec3f* vtkpoints_data<float>(vtkSmartPointer<vtkPoints>& points)
@@ -177,4 +179,5 @@ namespace temp_viz
             double *pointer = static_cast<vtkDoubleArray*>(data)->GetPointer(0);
             return reinterpret_cast<Vec3d*>(pointer);
         }
+    }
 }

modules/viz/src/types.cpp

@@ -3,20 +3,20 @@
 //////////////////////////////////////////////////////////////////////////////////////////////////////
 /// cv::viz::Color
 
-temp_viz::Color::Color() : Scalar(0, 0, 0) {}
-temp_viz::Color::Color(double gray) : Scalar(gray, gray, gray) {}
-temp_viz::Color::Color(double blue, double green, double red) : Scalar(blue, green, red) {}
-temp_viz::Color::Color(const Scalar& color) : Scalar(color) {}
+cv::viz::Color::Color() : Scalar(0, 0, 0) {}
+cv::viz::Color::Color(double gray) : Scalar(gray, gray, gray) {}
+cv::viz::Color::Color(double blue, double green, double red) : Scalar(blue, green, red) {}
+cv::viz::Color::Color(const Scalar& color) : Scalar(color) {}
 
-temp_viz::Color temp_viz::Color::black()   { return Color(  0,   0, 0); }
-temp_viz::Color temp_viz::Color::green()   { return Color(  0, 255, 0); }
-temp_viz::Color temp_viz::Color::blue()    { return Color(255,   0, 0); }
-temp_viz::Color temp_viz::Color::cyan()    { return Color(255, 255, 0); }
+cv::viz::Color cv::viz::Color::black()   { return Color(  0,   0, 0); }
+cv::viz::Color cv::viz::Color::green()   { return Color(  0, 255, 0); }
+cv::viz::Color cv::viz::Color::blue()    { return Color(255,   0, 0); }
+cv::viz::Color cv::viz::Color::cyan()    { return Color(255, 255, 0); }
 
-temp_viz::Color temp_viz::Color::red()     { return Color(  0,   0, 255); }
-temp_viz::Color temp_viz::Color::magenta() { return Color(  0, 255, 255); }
-temp_viz::Color temp_viz::Color::yellow()  { return Color(255,   0, 255); }
-temp_viz::Color temp_viz::Color::white()   { return Color(255, 255, 255); }
+cv::viz::Color cv::viz::Color::red()     { return Color(  0,   0, 255); }
+cv::viz::Color cv::viz::Color::magenta() { return Color(  0, 255, 255); }
+cv::viz::Color cv::viz::Color::yellow()  { return Color(255,   0, 255); }
+cv::viz::Color cv::viz::Color::white()   { return Color(255, 255, 255); }
 
-temp_viz::Color temp_viz::Color::gray()    { return Color(128, 128, 128); }
+cv::viz::Color cv::viz::Color::gray()    { return Color(128, 128, 128); }
 

modules/viz/src/viz.cpp

 #include "precomp.hpp"
 
 
-cv::Affine3f temp_viz::makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin)
+cv::Affine3f cv::viz::makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin)
 {
     Affine3f::Mat3 R;
     R.val[0] = axis_x.val[0];

modules/viz/src/viz3d.cpp

@@ -2,89 +2,89 @@
 #include "viz3d_impl.hpp"
 
 
-temp_viz::Viz3d::Viz3d(const String& window_name) : impl_(new VizImpl(window_name))
+cv::viz::Viz3d::Viz3d(const String& window_name) : impl_(new VizImpl(window_name))
 {
 
 }
 
-temp_viz::Viz3d::~Viz3d()
+cv::viz::Viz3d::~Viz3d()
 {
     delete impl_;
 }
 
-void temp_viz::Viz3d::setBackgroundColor(const Color& color)
+void cv::viz::Viz3d::setBackgroundColor(const Color& color)
 {
     impl_->setBackgroundColor(color);
 }
 
-bool temp_viz::Viz3d::addPolygonMesh (const Mesh3d& mesh, const String& id)
+bool cv::viz::Viz3d::addPolygonMesh (const Mesh3d& mesh, const String& id)
 {
     return impl_->addPolygonMesh(mesh, Mat(), id);
 }
 
-bool temp_viz::Viz3d::updatePolygonMesh (const Mesh3d& mesh, const String& id)
+bool cv::viz::Viz3d::updatePolygonMesh (const Mesh3d& mesh, const String& id)
 {
     return impl_->updatePolygonMesh(mesh, Mat(), id);
 }
 
-bool temp_viz::Viz3d::addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id)
+bool cv::viz::Viz3d::addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id)
 {
     return impl_->addPolylineFromPolygonMesh(mesh, id);
 }
 
-bool temp_viz::Viz3d::addPolygon(const Mat& cloud, const Color& color, const String& id)
+bool cv::viz::Viz3d::addPolygon(const Mat& cloud, const Color& color, const String& id)
 {
     return impl_->addPolygon(cloud, color, id);
 }
 
-void temp_viz::Viz3d::spin()
+void cv::viz::Viz3d::spin()
 {
     impl_->spin();
 }
 
-void temp_viz::Viz3d::spinOnce (int time, bool force_redraw)
+void cv::viz::Viz3d::spinOnce (int time, bool force_redraw)
 {
     impl_->spinOnce(time, force_redraw);
 }
 
-void temp_viz::Viz3d::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
+void cv::viz::Viz3d::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
 {
     impl_->registerKeyboardCallback(callback, cookie);
 }
 
-void temp_viz::Viz3d::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
+void cv::viz::Viz3d::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
 {
     impl_->registerMouseCallback(callback, cookie);
 }
 
-bool temp_viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
+bool cv::viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
 
-void temp_viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
+void cv::viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
 {
     impl_->showWidget(id, widget, pose);
 }
 
-void temp_viz::Viz3d::removeWidget(const String &id)
+void cv::viz::Viz3d::removeWidget(const String &id)
 {
     impl_->removeWidget(id);
 }
 
-temp_viz::Widget temp_viz::Viz3d::getWidget(const String &id) const
+cv::viz::Widget cv::viz::Viz3d::getWidget(const String &id) const
 {
     return impl_->getWidget(id);
 }
 
-void temp_viz::Viz3d::setWidgetPose(const String &id, const Affine3f &pose)
+void cv::viz::Viz3d::setWidgetPose(const String &id, const Affine3f &pose)
 {
     impl_->setWidgetPose(id, pose);
 }
 
-void temp_viz::Viz3d::updateWidgetPose(const String &id, const Affine3f &pose)
+void cv::viz::Viz3d::updateWidgetPose(const String &id, const Affine3f &pose)
 {
     impl_->updateWidgetPose(id, pose);
 }
 
-temp_viz::Affine3f temp_viz::Viz3d::getWidgetPose(const String &id) const
+cv::Affine3f cv::viz::Viz3d::getWidgetPose(const String &id) const
 {
     return impl_->getWidgetPose(id);
 }

modules/viz/src/viz3d_impl.hpp

@@ -10,7 +10,7 @@
 #include <opencv2/viz/viz3d.hpp>
 
 
-struct temp_viz::Viz3d::VizImpl
+struct cv::viz::Viz3d::VizImpl
 {
 public:
     typedef cv::Ptr<VizImpl> Ptr;
@@ -280,30 +280,31 @@ private:
 
 
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
+        //void getTransformationMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternionf& orientation, Eigen::Matrix4f &transformation);
 
-//void getTransformationMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternionf& orientation, Eigen::Matrix4f &transformation);
-
-//void convertToVtkMatrix (const Eigen::Matrix4f &m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
+        //void convertToVtkMatrix (const Eigen::Matrix4f &m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
 
-void convertToVtkMatrix (const cv::Matx44f& m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
-void convertToCvMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, cv::Matx44f &m);
+        void convertToVtkMatrix (const cv::Matx44f& m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
+        void convertToCvMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, cv::Matx44f &m);
 
-vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f &m);
-cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix);
+        vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f &m);
+        cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix);
 
-/** \brief Convert origin and orientation to vtkMatrix4x4
+        /** \brief Convert origin and orientation to vtkMatrix4x4
               * \param[in] origin the point cloud origin
               * \param[in] orientation the point cloud orientation
               * \param[out] vtk_matrix the resultant VTK 4x4 matrix
               */
-void convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<float> &orientation, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
-void convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, Eigen::Matrix4f &m);
+        void convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<float> &orientation, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
+        void convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, Eigen::Matrix4f &m);
 
 
-struct NanFilter
-{
+        struct NanFilter
+        {
             template<typename _Tp, typename _Msk>
             struct Impl
             {
@@ -341,10 +342,10 @@ struct NanFilter
 
                 return table[nan_mask.depth() - 5](source, output, nan_mask);
             }
-};
+        };
 
-struct ApplyAffine
-{
+        struct ApplyAffine
+        {
             const Affine3f& affine_;
             ApplyAffine(const Affine3f& affine) : affine_(affine) {}
 
@@ -361,10 +362,11 @@ struct ApplyAffine
                 return result;
             }
 
-private:
+        private:
             ApplyAffine(const ApplyAffine&);
             ApplyAffine& operator=(const ApplyAffine&);
-};
+        };
+    }
 
 }
 

modules/viz/src/viz_types.h

@@ -2,8 +2,10 @@
 
 #include "precomp.hpp"
 
-namespace temp_viz
+namespace cv
 {
+    namespace viz
+    {
         struct CV_EXPORTS CloudActor
         {
             /** \brief The actor holding the data to render. */
@@ -27,5 +29,6 @@ namespace temp_viz
         typedef std::map<std::string, CloudActor> CloudActorMap;
         typedef std::map<std::string, vtkSmartPointer<vtkProp> > ShapeActorMap;
         typedef std::map<std::string, WidgetActor> WidgetActorMap;
+    }
 }
 

modules/viz/src/widget.cpp

@@ -3,7 +3,7 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// widget implementation
 
-class temp_viz::Widget::Impl
+class cv::viz::Widget::Impl
 {
 public:
     vtkSmartPointer<vtkProp> prop;
@@ -12,17 +12,17 @@ public:
     Impl() : prop(0) {}
 };
 
-temp_viz::Widget::Widget() : impl_(0)
+cv::viz::Widget::Widget() : impl_(0)
 {
     create();
 }
 
-temp_viz::Widget::Widget(const Widget &other) : impl_(other.impl_) 
+cv::viz::Widget::Widget(const Widget &other) : impl_(other.impl_) 
 {
     if (impl_) CV_XADD(&impl_->ref_counter, 1);
 }
 
-temp_viz::Widget& temp_viz::Widget::operator=(const Widget &other)
+cv::viz::Widget& cv::viz::Widget::operator=(const Widget &other)
 {
     if (this != &other)
     {
@@ -33,19 +33,19 @@ temp_viz::Widget& temp_viz::Widget::operator=(const Widget &other)
     return *this;
 }
 
-temp_viz::Widget::~Widget()
+cv::viz::Widget::~Widget()
 {
     release();
 }
 
-void temp_viz::Widget::create()
+void cv::viz::Widget::create()
 {
     if (impl_) release();
     impl_ = new Impl();
     impl_->ref_counter = 1;
 }
 
-void temp_viz::Widget::release()
+void cv::viz::Widget::release()
 {
     if (impl_ && CV_XADD(&impl_->ref_counter, -1) == 1)
     {
@@ -57,12 +57,12 @@ void temp_viz::Widget::release()
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// widget accessor implementaion
 
-vtkSmartPointer<vtkProp> temp_viz::WidgetAccessor::getProp(const Widget& widget)
+vtkSmartPointer<vtkProp> cv::viz::WidgetAccessor::getProp(const Widget& widget)
 {
     return widget.impl_->prop;
 }
 
-void temp_viz::WidgetAccessor::setProp(Widget& widget, vtkSmartPointer<vtkProp> prop)
+void cv::viz::WidgetAccessor::setProp(Widget& widget, vtkSmartPointer<vtkProp> prop)
 {
     widget.impl_->prop = prop;
 }
@@ -70,18 +70,18 @@ void temp_viz::WidgetAccessor::setProp(Widget& widget, vtkSmartPointer<vtkProp>
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// widget3D implementation
 
-struct temp_viz::Widget3D::MatrixConverter
+struct cv::viz::Widget3D::MatrixConverter
 {
-    static cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
+    static Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
     {
-        cv::Matx44f m;
+        Matx44f m;
         for (int i = 0; i < 4; i++)
             for (int k = 0; k < 4; k++)
                 m(i, k) = vtk_matrix->GetElement (i, k);
         return m;
     }
     
-    static vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f& m)
+    static vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const Matx44f& m)
     {
         vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New ();
         for (int i = 0; i < 4; i++)
@@ -91,7 +91,7 @@ struct temp_viz::Widget3D::MatrixConverter
     }
 };
 
-void temp_viz::Widget3D::setPose(const Affine3f &pose)
+void cv::viz::Widget3D::setPose(const Affine3f &pose)
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
     CV_Assert(actor);
@@ -101,7 +101,7 @@ void temp_viz::Widget3D::setPose(const Affine3f &pose)
     actor->Modified ();
 }
 
-void temp_viz::Widget3D::updatePose(const Affine3f &pose)
+void cv::viz::Widget3D::updatePose(const Affine3f &pose)
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
     CV_Assert(actor);
@@ -121,7 +121,7 @@ void temp_viz::Widget3D::updatePose(const Affine3f &pose)
     actor->Modified ();
 }
 
-temp_viz::Affine3f temp_viz::Widget3D::getPose() const
+cv::Affine3f cv::viz::Widget3D::getPose() const
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
     CV_Assert(actor);
@@ -131,7 +131,7 @@ temp_viz::Affine3f temp_viz::Widget3D::getPose() const
     return Affine3f(matrix_cv);
 }
 
-void temp_viz::Widget3D::setColor(const Color &color)
+void cv::viz::Widget3D::setColor(const Color &color)
 {
     // Cast to actor instead of prop3d since prop3d doesn't provide getproperty
     vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
@@ -148,7 +148,7 @@ void temp_viz::Widget3D::setColor(const Color &color)
     actor->Modified ();
 }
 
-template<> temp_viz::Widget3D temp_viz::Widget::cast<temp_viz::Widget3D>()
+template<> cv::viz::Widget3D cv::viz::Widget::cast<cv::viz::Widget3D>()
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
     CV_Assert(actor);
@@ -161,7 +161,7 @@ template<> temp_viz::Widget3D temp_viz::Widget::cast<temp_viz::Widget3D>()
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// widget2D implementation
 
-void temp_viz::Widget2D::setColor(const Color &color)
+void cv::viz::Widget2D::setColor(const Color &color)
 {
     vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
     CV_Assert(actor);
@@ -170,7 +170,7 @@ void temp_viz::Widget2D::setColor(const Color &color)
     actor->Modified ();
 }
 
-template<> temp_viz::Widget2D temp_viz::Widget::cast<temp_viz::Widget2D>()
+template<> cv::viz::Widget2D cv::viz::Widget::cast<cv::viz::Widget2D>()
 {
     vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
     CV_Assert(actor);