Merge pull request #20 from ozantonkal/low_order_tasks

Low order tasks

doc/tutorials/viz/viz.rst

+.. _viz:
+
+Launching Viz
+*************
+
+Goal
+====
+
+In this tutorial you will learn how to
+
+.. container:: enumeratevisibleitemswithsquare
+
+  * Open a visualization window.
+  * Access a window by its name.
+  * Start event loop.
+  * Start event loop for a given amount of time.
+
+Code
+====
+
+You can download the code from `here <../../../../samples/cpp/tutorial_code/viz/launching_viz.cpp>`_.
+
+.. code-block:: cpp
+
+    #include <opencv2/viz.hpp>
+    #include <iostream>
+
+    using namespace cv;
+    using namespace std;
+  
+    /**
+    * @function main
+    */
+    int main()
+    {
+        /// Create a window
+        viz::Viz3d myWindow("Viz Demo");
+        
+        /// Start event loop
+        myWindow.spin();
+        
+        /// Event loop is over when pressed q, Q, e, E
+        cout << "First event loop is over" << endl;
+        
+        /// Access window via its name
+        viz::Viz3d sameWindow = viz::get("Viz Demo");
+        
+        /// Start event loop
+        sameWindow.spin();
+        
+        /// Event loop is over when pressed q, Q, e, E
+        cout << "Second event loop is over" << endl;
+        
+        /// Event loop is over when pressed q, Q, e, E
+        /// Start event loop once for 1 millisecond
+        sameWindow.spinOnce(1, true);
+        while(!sameWindow.wasStopped())
+        {
+            /// Interact with window
+            
+            /// Event loop for 1 millisecond
+            sameWindow.spinOnce(1, true);
+        }
+        
+        /// Once more event loop is stopped
+        cout << "Last event loop is over" << endl;
+        return 0;
+    }
+    
+Explanation
+===========
+
+Here is the general structure of the program:
+
+* Create a window.
+
+.. code-block:: cpp
+
+    /// Create a window
+    viz::Viz3d myWindow("Viz Demo");
+    
+* Start event loop. This event loop will run until user terminates it by pressing **e**, **E**, **q**, **Q**.
+
+.. code-block:: cpp
+
+    /// Start event loop
+    myWindow.spin();
+    
+* Access same window via its name. Since windows are implicitly shared, **sameWindow** is exactly the same with **myWindow**. If the name does not exist, a new window is created.
+
+.. code-block:: cpp
+
+    /// Access window via its name
+    viz::Viz3d sameWindow = viz::get("Viz Demo");
+    
+* Start a controlled event loop. Once it starts, **wasStopped** is set to false. Inside the while loop, in each iteration, **spinOnce** is called to prevent event loop from completely stopping. Inside the while loop, user can execute other statements including those which interact with the window.
+
+.. code-block:: cpp
+
+    /// Event loop is over when pressed q, Q, e, E
+    /// Start event loop once for 1 millisecond
+    sameWindow.spinOnce(1, true);
+    while(!sameWindow.wasStopped())
+    {
+        /// Interact with window
+        
+        /// Event loop for 1 millisecond
+        sameWindow.spinOnce(1, true);
+    }
+    
+Results
+=======
+
+Here is the result of the program.
+
+.. image:: images/window_demo.png
+    :alt: Launching Viz
+    :align: center

modules/viz/CMakeLists.txt

@@ -49,4 +49,3 @@ if(BUILD_opencv_viz)
       target_link_libraries(opencv_viz "-framework Cocoa")
   endif()
 endif()
-

modules/viz/doc/viz.rst

+***********************
+viz. 3D Visualizer
+***********************
+
+.. toctree::
+	:maxdepth: 2
+	
+	viz3d.rst
+	widget.rst

modules/viz/doc/viz3d.rst

+Viz3d
+=====
+
+.. highlight:: cpp
+
+Viz3d
+-----
+.. ocv:class:: Viz3d
+
+The Viz3d class represents a 3D visualizer window. This class is implicitly shared.    ::
+
+    class CV_EXPORTS Viz3d
+    {
+    public:
+        typedef cv::Ptr<Viz3d> Ptr;
+        typedef void (*KeyboardCallback)(const KeyboardEvent&, void*);
+        typedef void (*MouseCallback)(const MouseEvent&, void*);
+
+        Viz3d(const String& window_name = String());
+        Viz3d(const Viz3d&);
+        Viz3d& operator=(const Viz3d&);
+        ~Viz3d();
+
+        void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
+        void removeWidget(const String &id);
+        Widget getWidget(const String &id) const;
+        void removeAllWidgets();
+
+        void setWidgetPose(const String &id, const Affine3f &pose);
+        void updateWidgetPose(const String &id, const Affine3f &pose);
+        Affine3f getWidgetPose(const String &id) const;
+        
+        void setCamera(const Camera &camera);
+        Camera getCamera() const;
+        Affine3f getViewerPose();
+        void setViewerPose(const Affine3f &pose);
+        
+        void resetCameraViewpoint (const String &id);
+        void resetCamera();
+        
+        void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord);
+        void converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction);
+        
+        Size getWindowSize() const;
+        void setWindowSize(const Size &window_size);
+        String getWindowName() const;
+        void saveScreenshot (const String &file);
+        void setWindowPosition (int x, int y);
+        void setFullScreen (bool mode);
+        void setBackgroundColor(const Color& color = Color::black());
+
+        void spin();
+        void spinOnce(int time = 1, bool force_redraw = false);
+        bool wasStopped() const;
+
+        void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
+        void registerMouseCallback(MouseCallback callback, void* cookie = 0);
+        
+        void setRenderingProperty(const String &id, int property, double value);
+        double getRenderingProperty(const String &id, int property);
+        
+        void setDesiredUpdateRate(double rate);
+        double getDesiredUpdateRate();
+        
+        void setRepresentationToSurface();
+        void setRepresentationToWireframe();
+        void setRepresentationToPoints();
+    private:
+        /* hidden */
+    };
+
+Viz3d::Viz3d
+------------
+The constructors.
+
+.. ocv:function:: Viz3d::Viz3d(const String& window_name = String())
+
+    :param window_name: Name of the window.
+
+Viz3d::showWidget
+-----------------
+Shows a widget in the window.
+
+.. ocv:function:: void Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity())
+
+    :param id: A unique id for the widget.
+    :param widget: The widget to be rendered in the window.
+    :param pose: Pose of the widget.
+    
+Viz3d::removeWidget
+-------------------
+Removes a widget from the window.
+
+.. ocv:function:: void removeWidget(const String &id)
+
+    :param id: The id of the widget that will be removed.
+    
+Viz3d::getWidget
+----------------
+Retrieves a widget from the window. A widget is implicitly shared;
+that is, if the returned widget is modified, the changes will be 
+immediately visible in the window.
+
+.. ocv:function:: Widget getWidget(const String &id) const
+
+    :param id: The id of the widget that will be returned.
+    
+Viz3d::removeAllWidgets
+-----------------------
+Removes all widgets from the window.
+
+.. ocv:function:: void removeAllWidgets()
+
+Viz3d::setWidgetPose
+--------------------
+Sets pose of a widget in the window.
+
+.. ocv:function:: void setWidgetPose(const String &id, const Affine3f &pose)
+
+    :param id: The id of the widget whose pose will be set.
+    :param pose: The new pose of the widget.
+
+Viz3d::updateWidgetPose
+-----------------------
+Updates pose of a widget in the window by pre-multiplying its current pose.
+
+.. ocv:function:: void updateWidgetPose(const String &id, const Affine3f &pose)
+
+    :param id: The id of the widget whose pose will be updated.
+    :param pose: The pose that the current pose of the widget will be pre-multiplied by.
+
+Viz3d::getWidgetPose
+--------------------
+Returns the current pose of a widget in the window.
+
+.. ocv:function:: Affine3f getWidgetPose(const String &id) const
+
+    :param id: The id of the widget whose pose will be returned.
+
+Viz3d::setCamera
+----------------
+Sets the intrinsic parameters of the viewer using Camera.
+
+.. ocv:function:: void setCamera(const Camera &camera)
+
+    :param camera: Camera object wrapping intrinsinc parameters.
+
+Viz3d::getCamera
+----------------
+Returns a camera object that contains intrinsic parameters of the current viewer.
+
+.. ocv:function:: Camera getCamera() const
+
+Viz3d::getViewerPose
+--------------------
+Returns the current pose of the viewer.
+
+..ocv:function:: Affine3f getViewerPose()
+
+Viz3d::setViewerPose
+--------------------
+Sets pose of the viewer.
+
+.. ocv:function:: void setViewerPose(const Affine3f &pose)
+
+    :param pose: The new pose of the viewer.
+
+Viz3d::resetCameraViewpoint
+---------------------------
+Resets camera viewpoint to a 3D widget in the scene.
+
+.. ocv:function:: void resetCameraViewpoint (const String &id)
+
+    :param pose: Id of a 3D widget.
+    
+Viz3d::resetCamera
+------------------
+Resets camera.
+
+.. ocv:function:: void resetCamera()
+
+Viz3d::convertToWindowCoordinates
+---------------------------------
+Transforms a point in world coordinate system to window coordinate system.
+
+.. ocv:function:: void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord)
+
+    :param pt: Point in world coordinate system.
+    :param window_coord: Output point in window coordinate system.
+    
+Viz3d::converTo3DRay
+--------------------
+Transforms a point in window coordinate system to a 3D ray in world coordinate system.
+
+.. ocv:function:: void converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction)
+
+    :param window_coord: Point in window coordinate system.
+    :param origin: Output origin of the ray.
+    :param direction: Output direction of the ray.
+    
+Viz3d::getWindowSize
+--------------------
+Returns the current size of the window.
+
+.. ocv:function:: Size getWindowSize() const
+
+Viz3d::setWindowSize
+--------------------
+Sets the size of the window.
+
+.. ocv:function:: void setWindowSize(const Size &window_size)
+
+    :param window_size: New size of the window.
+    
+Viz3d::getWindowName
+--------------------
+Returns the name of the window which has been set in the constructor.
+
+.. ocv:function:: String getWindowName() const
+
+Viz3d::saveScreenshot
+---------------------
+Saves screenshot of the current scene.
+
+.. ocv:function:: void saveScreenshot(const String &file)
+
+    :param file: Name of the file.
+    
+Viz3d::setWindowPosition
+------------------------
+Sets the position of the window in the screen.
+
+.. ocv:function:: void setWindowPosition(int x, int y)
+
+    :param x: x coordinate of the window
+    :param y: y coordinate of the window
+    
+Viz3d::setFullScreen
+--------------------
+Sets or unsets full-screen rendering mode.
+
+.. ocv:function:: void setFullScreen(bool mode)
+
+    :param mode: If true, window will use full-screen mode.
+    
+Viz3d::setBackgroundColor
+-------------------------
+Sets background color.
+
+.. ocv:function:: void setBackgroundColor(const Color& color = Color::black())
+
+Viz3d::spin
+-----------
+The window renders and starts the event loop.
+
+.. ocv:function:: void spin()
+
+Viz3d::spinOnce
+---------------
+Starts the event loop for a given time.
+
+.. ocv:function:: void spinOnce(int time = 1, bool force_redraw = false)
+
+    :param time: Amount of time in milliseconds for the event loop to keep running.
+    :param force_draw: If true, window renders.
+
+Viz3d::wasStopped
+-----------------
+Returns whether the event loop has been stopped.
+
+.. ocv:function:: bool wasStopped()
+
+Viz3d::registerKeyboardCallback
+-------------------------------
+Sets keyboard handler.
+
+.. ocv:function:: void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0)
+
+    :param callback: Keyboard callback.
+    :param cookie: The optional parameter passed to the callback.
+    
+Viz3d::registerMouseCallback
+----------------------------
+Sets mouse handler.
+
+.. ocv:function:: void registerMouseCallback(MouseCallback callback, void* cookie = 0)
+
+    :param callback: Mouse callback.
+    :param cookie: The optional parameter passed to the callback.
+
+Viz3d::setRenderingProperty
+---------------------------
+Sets rendering property of a widget.
+
+.. ocv:function:: void setRenderingProperty(const String &id, int property, double value)
+
+    :param id: Id of the widget.
+    :param property: Property that will be modified.
+    :param value: The new value of the property.
+    
+Viz3d::getRenderingProperty
+---------------------------
+Returns rendering property of a widget.
+
+.. ocv:function:: double getRenderingProperty(const String &id, int property)
+
+    :param id: Id of the widget.
+    :param property: Property.
+
+Viz3d::setDesiredUpdateRate
+---------------------------
+Sets desired update rate of the window.
+
+.. ocv:function:: void setDesiredUpdateRate(double rate)
+
+    :param rate: Desired update rate. The default is 30.
+    
+Viz3d::getDesiredUpdateRate
+---------------------------
+Returns desired update rate of the window.
+
+.. ocv:function:: double getDesiredUpdateRate()
+
+Viz3d::setRepresentationToSurface
+---------------------------------
+Sets geometry representation of the widgets to surface.
+
+.. ocv:function:: void setRepresentationToSurface()
+
+Viz3d::setRepresentationToWireframe
+-----------------------------------
+Sets geometry representation of the widgets to wireframe.
+
+.. ocv:function:: void setRepresentationToWireframe()
+
+Viz3d::setRepresentationToPoints
+--------------------------------
+Sets geometry representation of the widgets to points.
+
+.. ocv:function:: void setRepresentationToPoints()
+
+Color
+-----
+.. ocv:class:: Color
+
+This class a represents BGR color. ::
+
+    class CV_EXPORTS Color : public Scalar
+    {
+    public:
+        Color();
+        Color(double gray);
+        Color(double blue, double green, double red);
+
+        Color(const Scalar& color);
+
+        static Color black();
+        static Color blue();
+        static Color green();
+        static Color cyan();
+
+        static Color red();
+        static Color magenta();
+        static Color yellow();
+        static Color white();
+
+        static Color gray();
+    };
+
+Mesh3d
+------
+.. ocv:class:: Mesh3d
+
+This class wraps mesh attributes, and it can load a mesh from a ``ply`` file. ::
+
+    class CV_EXPORTS Mesh3d
+    {
+    public:
+
+        Mat cloud, colors;
+        Mat polygons;
+
+        //! Loads mesh from a given ply file
+        static Mesh3d loadMesh(const String& file);
+        
+    private:
+        /* hidden */
+    };
+    
+Mesh3d::loadMesh
+----------------
+Loads a mesh from a ``ply`` file.
+
+.. ocv:function:: static Mesh3d loadMesh(const String& file)
+
+    :param file: File name.
+ 
+ 
+KeyboardEvent
+-------------
+.. ocv:class:: KeyboardEvent
+
+This class represents a keyboard event. ::
+
+    class CV_EXPORTS KeyboardEvent
+    {
+    public:
+        static const unsigned int Alt   = 1;
+        static const unsigned int Ctrl  = 2;
+        static const unsigned int Shift = 4;
+
+        //! Create a keyboard event
+        //! - Note that action is true if key is pressed, false if released
+        KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift);
+
+        bool isAltPressed () const;
+        bool isCtrlPressed () const;
+        bool isShiftPressed () const;
+
+        unsigned char getKeyCode () const;
+
+        const String& getKeySym () const;
+        bool keyDown () const;
+        bool keyUp () const;
+
+    protected:
+        /* hidden */
+    };
+
+KeyboardEvent::KeyboardEvent
+----------------------------
+Constructs a KeyboardEvent.
+
+.. ocv:function:: KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift)
+
+    :param action: If true, key is pressed. If false, key is released.
+    :param key_sym: Name of the key.
+    :param key: Code of the key.
+    :param alt: If true, ``alt`` is pressed.
+    :param ctrl: If true, ``ctrl`` is pressed.
+    :param shift: If true, ``shift`` is pressed.
+    
+MouseEvent
+----------
+.. ocv:class:: MouseEvent
+
+This class represents a mouse event. ::
+
+    class CV_EXPORTS MouseEvent
+    {
+    public:
+        enum Type { MouseMove = 1, MouseButtonPress, MouseButtonRelease, MouseScrollDown, MouseScrollUp, MouseDblClick } ;
+        enum MouseButton { NoButton = 0, LeftButton, MiddleButton, RightButton, VScroll } ;
+
+        MouseEvent (const Type& type, const MouseButton& button, const Point& p, bool alt, bool ctrl, bool shift);
+
+        Type type;
+        MouseButton button;
+        Point pointer;
+        unsigned int key_state;
+    };
+    
+MouseEvent::MouseEvent
+----------------------
+Constructs a MouseEvent.
+
+.. ocv:function:: MouseEvent (const Type& type, const MouseButton& button, const Point& p, bool alt, bool ctrl, bool shift)
+
+    :param type: Type of the event. This can be **MouseMove**, **MouseButtonPress**, **MouseButtonRelease**, **MouseScrollDown**, **MouseScrollUp**, **MouseDblClick**.
+    :param button: Mouse button. This can be **NoButton**, **LeftButton**, **MiddleButton**, **RightButton**, **VScroll**.
+    :param p: Position of the event.
+    :param alt: If true, ``alt`` is pressed.
+    :param ctrl: If true, ``ctrl`` is pressed.
+    :param shift: If true, ``shift`` is pressed.
+    
+Camera
+------
+.. ocv:class:: Camera
+
+This class wraps intrinsic parameters of a camera. It provides several constructors
+that can extract the intrinsic parameters from ``field of view``, ``intrinsic matrix`` and
+``projection matrix``. ::
+
+    class CV_EXPORTS Camera
+    {
+    public:
+        Camera(float f_x, float f_y, float c_x, float c_y, const Size &window_size);
+        Camera(const Vec2f &fov, const Size &window_size);
+        Camera(const cv::Matx33f &K, const Size &window_size);
+        Camera(const cv::Matx44f &proj, const Size &window_size);
+        
+        inline const Vec2d & getClip() const { return clip_; }
+        inline void setClip(const Vec2d &clip) { clip_ = clip; }
+        
+        inline const Size & getWindowSize() const { return window_size_; }
+        void setWindowSize(const Size &window_size);
+        
+        inline const Vec2f & getFov() const { return fov_; }
+        inline void setFov(const Vec2f & fov) { fov_ = fov; }
+        
+        inline const Vec2f & getPrincipalPoint() const { return principal_point_; }
+        inline const Vec2f & getFocalLength() const { return focal_; }
+        
+        void computeProjectionMatrix(Matx44f &proj) const;
+        
+        static Camera KinectCamera(const Size &window_size);
+        
+    private:
+        /* hidden */
+    };
+
+Camera::Camera
+--------------
+Constructs a Camera.
+
+.. ocv:function:: Camera(float f_x, float f_y, float c_x, float c_y, const Size &window_size)
+
+    :param f_x: Horizontal focal length.
+    :param f_y: Vertical focal length.
+    :param c_x: x coordinate of the principal point.
+    :param c_y: y coordinate of the principal point.
+    :param window_size: Size of the window. This together with focal length and principal point determines the field of view.
+
+.. ocv:function:: Camera(const Vec2f &fov, const Size &window_size)
+
+    :param fov: Field of view (horizontal, vertical)
+    :param window_size: Size of the window.
+
+    Principal point is at the center of the window by default.
+    
+.. ocv:function:: Camera(const cv::Matx33f &K, const Size &window_size)
+
+    :param K: Intrinsic matrix of the camera.
+    :param window_size: Size of the window. This together with intrinsic matrix determines the field of view.
+
+.. ocv:function:: Camera(const cv::Matx44f &proj, const Size &window_size)
+
+    :param proj: Projection matrix of the camera.
+    :param window_size: Size of the window. This together with projection matrix determines the field of view.
+
+Camera::computeProjectionMatrix
+-------------------------------
+Computes projection matrix using intrinsic parameters of the camera.
+
+.. ocv:function:: void computeProjectionMatrix(Matx44f &proj) const
+
+    :param proj: Output projection matrix.
+        
+Camera::KinectCamera
+--------------------
+Creates a Kinect Camera.
+
+.. ocv:function:: static Camera KinectCamera(const Size &window_size)
+
+    :param window_size: Size of the window. This together with intrinsic matrix of a Kinect Camera determines the field of view.
+

modules/viz/doc/widget.rst

+Widget
+======
+    
+.. highlight:: cpp
+
+In this section, the built-in widgets are presented. 
+
+Widget
+------
+.. ocv:class:: Widget
+
+Base class of all widgets. Widget is implicitly shared.::
+
+    class CV_EXPORTS Widget
+    {
+    public:
+        Widget();
+        Widget(const Widget& other);
+        Widget& operator=(const Widget& other);
+        ~Widget();
+        
+        //! Create a widget directly from ply file
+        static Widget fromPlyFile(const String &file_name);
+        
+        //! Rendering properties of this particular widget
+        void setRenderingProperty(int property, double value);
+        double getRenderingProperty(int property) const;
+
+        //! Casting between widgets
+        template<typename _W> _W cast();
+    private:
+        /* hidden */
+    };
+
+Widget::fromPlyFile
+-------------------
+Creates a widget from ply file.
+
+.. ocv:function:: static Widget fromPlyFile(const String &file_name)
+
+    :param file_name: Ply file name.
+    
+Widget::setRenderingProperty
+----------------------------
+Sets rendering property of the widget.
+
+.. ocv:function:: void setRenderingProperty(int property, double value)
+
+    :param property: Property that will be modified.
+    :param value: The new value of the property.
+    
+Widget::getRenderingProperty
+----------------------------
+Returns rendering property of the widget.
+
+.. ocv:function:: double getRenderingProperty(int property) const
+
+    :param property: Property.
+    
+Widget::cast
+------------
+Casts a widget to another.
+
+.. ocv:function:: template<typename _W> _W cast()
+
+WidgetAccessor
+--------------
+.. ocv:class:: WidgetAccessor
+
+This class is for users who want to develop their own widgets using VTK library API. ::
+
+    struct CV_EXPORTS WidgetAccessor
+    {
+        static vtkSmartPointer<vtkProp> getProp(const Widget &widget);
+        static void setProp(Widget &widget, vtkSmartPointer<vtkProp> prop);
+    };
+    
+Widget3D
+--------
+.. ocv:class:: Widget3D
+
+Base class of all 3D widgets. ::
+
+    class CV_EXPORTS Widget3D : public Widget
+    {
+    public:
+        Widget3D() {}
+
+        void setPose(const Affine3f &pose);
+        void updatePose(const Affine3f &pose);
+        Affine3f getPose() const;
+
+        void setColor(const Color &color);
+    private:
+        /* hidden */
+    };
+
+Widget3D::setPose
+-----------------
+Sets pose of the widget.
+
+.. ocv:function:: void setPose(const Affine3f &pose)
+
+    :param pose: The new pose of the widget.
+    
+Widget3D::updateWidgetPose
+--------------------------
+Updates pose of the widget by pre-multiplying its current pose.
+
+.. ocv:function:: void updateWidgetPose(const Affine3f &pose)
+
+    :param pose: The pose that the current pose of the widget will be pre-multiplied by.
+
+Widget3D::getPose
+-----------------
+Returns the current pose of the widget.
+
+.. ocv:function:: Affine3f getWidgetPose() const
+
+Widget3D::setColor
+------------------
+Sets the color of the widget.
+
+.. ocv:function:: void setColor(const Color &color)
+
+    :param color: Color
+    
+Widget2D
+--------
+.. ocv:class:: Widget2D
+
+Base class of all 2D widgets. ::
+
+    class CV_EXPORTS Widget2D : public Widget
+    {
+    public:
+        Widget2D() {}
+
+        void setColor(const Color &color);
+    };
+    
+Widget2D::setColor
+------------------
+Sets the color of the widget.
+
+.. ocv:function:: void setColor(const Color &color)
+
+    :param color: Color
+
+LineWidget
+----------
+.. ocv:class:: LineWidget
+
+This 3D Widget defines a finite line. ::
+
+    class CV_EXPORTS LineWidget : public Widget3D
+    {
+    public:
+        LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color = Color::white());
+    };
+    
+LineWidget::LineWidget
+----------------------
+Constructs a LineWidget.
+
+.. ocv:function:: LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color = Color::white())
+
+    :param pt1: Start point of the line.
+    :param pt2: End point of the line.
+    :param color: Color of the line.
+    
+PlaneWidget
+-----------
+.. ocv:class:: PlaneWidget
+
+This 3D Widget defines a finite plane. ::
+
+    class CV_EXPORTS PlaneWidget : public Widget3D
+    {
+    public:
+        PlaneWidget(const Vec4f& coefs, double size = 1.0, const Color &color = Color::white());
+        PlaneWidget(const Vec4f& coefs, const Point3f& pt, double size = 1.0, const Color &color = Color::white());
+    private:
+        /* hidden */
+    };
+    
+PlaneWidget::PlaneWidget
+------------------------
+Constructs a PlaneWidget.
+
+.. ocv:function:: PlaneWidget(const Vec4f& coefs, double size = 1.0, const Color &color = Color::white())
+    
+    :param coefs: Plane coefficients as in (A,B,C,D) where Ax + By + Cz + D = 0.
+    :param size: Size of the plane.
+    :param color: Color of the plane.
+
+.. ocv:function:: PlaneWidget(const Vec4f& coefs, const Point3f& pt, double size = 1.0, const Color &color = Color::white())
+
+    :param coefs: Plane coefficients as in (A,B,C,D) where Ax + By + Cz + D = 0.
+    :param pt: Position of the plane.
+    :param color: Color of the plane.
+    
+SphereWidget
+------------
+.. ocv:class:: SphereWidget
+
+This 3D Widget defines a sphere. ::
+
+    class CV_EXPORTS SphereWidget : public Widget3D
+    {
+    public:
+        SphereWidget(const cv::Point3f &center, float radius, int sphere_resolution = 10, const Color &color = Color::white())
+    };
+
+SphereWidget::SphereWidget
+--------------------------
+Constructs a SphereWidget.
+
+.. ocv:function:: SphereWidget(const cv::Point3f &center, float radius, int sphere_resolution = 10, const Color &color = Color::white())
+
+    :param center: Center of the sphere.
+    :param radius: Radius of the sphere.
+    :param sphere_resolution: Resolution of the sphere.
+    :param color: Color of the sphere.
+
+ArrowWidget
+-----------
+.. ocv:class:: ArrowWidget
+
+This 3D Widget defines an arrow. ::
+
+    class CV_EXPORTS ArrowWidget : public Widget3D
+    {
+    public:
+        ArrowWidget(const Point3f& pt1, const Point3f& pt2, double thickness = 0.03, const Color &color = Color::white());
+    };
+    
+ArrowWidget::ArrowWidget
+------------------------
+Constructs an ArrowWidget.
+
+.. ocv:function:: ArrowWidget(const Point3f& pt1, const Point3f& pt2, double thickness = 0.03, const Color &color = Color::white())
+
+    :param pt1: Start point of the arrow.
+    :param pt2: End point of the arrow.
+    :param thickness: Thickness of the arrow. Thickness of arrow head is also adjusted accordingly.
+    :param color: Color of the arrow.
+    
+Arrow head is located at the end point of the arrow.
+    
+CircleWidget
+------------
+.. ocv:class:: CircleWidget
+
+This 3D Widget defines a circle. ::
+
+    class CV_EXPORTS CircleWidget : public Widget3D
+    {
+    public:
+        CircleWidget(const Point3f& pt, double radius, double thickness = 0.01, const Color &color = Color::white());
+    };
+    
+CircleWidget::CircleWidget
+--------------------------
+Constructs a CircleWidget.
+
+.. ocv:function:: CircleWidget(const Point3f& pt, double radius, double thickness = 0.01, const Color &color = Color::white())
+
+    :param pt: Center of the circle.
+    :param radius: Radius of the circle.
+    :param thickness: Thickness of the circle.
+    :param color: Color of the circle.
+    
+CylinderWidget
+--------------
+.. ocv:class:: CylinderWidget
+
+This 3D Widget defines a cylinder. ::
+
+    class CV_EXPORTS CylinderWidget : public Widget3D
+    {
+    public:
+        CylinderWidget(const Point3f& pt_on_axis, const Point3f& axis_direction, double radius, int numsides = 30, const Color &color = Color::white());
+    };
+
+CylinderWidget::CylinderWidget
+------------------------------
+Constructs a CylinderWidget.
+
+.. ocv:function:: CylinderWidget(const Point3f& pt_on_axis, const Point3f& axis_direction, double radius, int numsides = 30, const Color &color = Color::white())
+
+    :param pt_on_axis: A point on the axis of the cylinder.
+    :param axis_direction: Direction of the axis of the cylinder.
+    :param radius: Radius of the cylinder.
+    :param numsides: Resolution of the cylinder.
+    :param color: Color of the cylinder.
+    
+CubeWidget
+----------
+.. ocv:class:: CubeWidget
+
+This 3D Widget defines a cube. ::
+
+    class CV_EXPORTS CubeWidget : public Widget3D
+    {
+    public:
+        CubeWidget(const Point3f& pt_min, const Point3f& pt_max, bool wire_frame = true, const Color &color = Color::white());
+    };
+    
+CubeWidget::CubeWidget
+----------------------
+Constructs a CudeWidget.
+
+.. ocv:function:: CubeWidget(const Point3f& pt_min, const Point3f& pt_max, bool wire_frame = true, const Color &color = Color::white())
+
+    :param pt_min: Specifies minimum point of the bounding box.
+    :param pt_max: Specifies maximum point of the bounding box.
+    :param wire_frame: If true, cube is represented as wireframe.
+    :param color: Color of the cube.
+    
+CoordinateSystemWidget
+----------------------
+.. ocv:class:: CoordinateSystemWidget
+
+This 3D Widget represents a coordinate system. ::
+
+    class CV_EXPORTS CoordinateSystemWidget : public Widget3D
+    {
+    public:
+        CoordinateSystemWidget(double scale = 1.0);
+    };
+    
+CoordinateSystemWidget::CoordinateSystemWidget
+----------------------------------------------
+Constructs a CoordinateSystemWidget.
+
+.. ocv:function:: CoordinateSystemWidget(double scale = 1.0)
+
+    :param scale: Determines the size of the axes.
+    
+PolyLineWidget
+--------------
+.. ocv:class:: PolyLineWidget
+
+This 3D Widget defines a poly line. ::
+
+    class CV_EXPORTS PolyLineWidget : public Widget3D
+    {
+    public:
+        PolyLineWidget(InputArray points, const Color &color = Color::white());
+
+    private:
+        /* hidden */
+    };
+
+PolyLineWidget::PolyLineWidget
+------------------------------
+Constructs a PolyLineWidget.
+
+.. ocv:function:: PolyLineWidget(InputArray points, const Color &color = Color::white())
+    
+    :param points: Point set.
+    :param color: Color of the poly line.
+    
+GridWidget
+----------
+.. ocv:class:: GridWidget
+
+This 3D Widget defines a grid. ::
+
+    class CV_EXPORTS GridWidget : public Widget3D
+    {
+    public:
+        //! Creates grid at the origin
+        GridWidget(const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white());
+        //! Creates grid based on the plane equation
+        GridWidget(const Vec4f &coeffs, const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white());
+    private:
+        /* hidden */
+    };
+    
+GridWidget::GridWidget
+----------------------
+Constructs a GridWidget.
+
+.. ocv:function:: GridWidget(const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white())
+
+    :param dimensions: Number of columns and rows, respectively.
+    :param spacing: Size of each column and row, respectively.
+    :param color: Color of the grid.
+    
+.. ocv:function:  GridWidget(const Vec4f &coeffs, const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white())
+    
+    :param coeffs: Plane coefficients as in (A,B,C,D) where Ax + By + Cz + D = 0.
+    :param dimensions: Number of columns and rows, respectively.
+    :param spacing: Size of each column and row, respectively.
+    :param color: Color of the grid.
+    
+Text3DWidget
+------------
+.. ocv:class:: Text3DWidget
+
+This 3D Widget represents 3D text. The text always faces the camera. ::
+
+    class CV_EXPORTS Text3DWidget : public Widget3D
+    {
+    public:
+        Text3DWidget(const String &text, const Point3f &position, double text_scale = 1.0, const Color &color = Color::white());
+
+        void setText(const String &text);
+        String getText() const;
+    };
+    
+Text3DWidget::Text3DWidget
+--------------------------
+Constructs a Text3DWidget.
+
+.. ocv:function:: Text3DWidget(const String &text, const Point3f &position, double text_scale = 1.0, const Color &color = Color::white())
+
+    :param text: Text content of the widget.
+    :param position: Position of the text.
+    :param text_scale: Size of the text.
+    :param color: Color of the text.
+    
+Text3DWidget::setText
+---------------------
+Sets the text content of the widget.
+
+.. ocv:function:: void setText(const String &text)
+
+    :param text: Text content of the widget.
+
+Text3DWidget::getText
+---------------------
+Returns the current text content of the widget.
+
+.. ocv:function:: String getText() const
+
+TextWidget
+----------
+.. ocv:class:: TextWidget
+
+This 2D Widget represents text overlay. ::
+
+    class CV_EXPORTS TextWidget : public Widget2D
+    {
+    public:
+        TextWidget(const String &text, const Point2i &pos, int font_size = 10, const Color &color = Color::white());
+
+        void setText(const String &text);
+        String getText() const;
+    };
+    
+TextWidget::TextWidget
+----------------------
+Constructs a TextWidget.
+
+.. ocv:function:: TextWidget(const String &text, const Point2i &pos, int font_size = 10, const Color &color = Color::white())
+
+    :param text: Text content of the widget.
+    :param pos: Position of the text.
+    :param font_size: Font size.
+    :param color: Color of the text.
+    
+TextWidget::setText
+---------------------
+Sets the text content of the widget.
+
+.. ocv:function:: void setText(const String &text)
+
+    :param text: Text content of the widget.
+
+TextWidget::getText
+---------------------
+Returns the current text content of the widget.
+
+.. ocv:function:: String getText() const
+
+ImageOverlayWidget
+------------------
+.. ocv:class:: ImageOverlayWidget
+
+This 2D Widget represents an image overlay. ::
+
+    class CV_EXPORTS ImageOverlayWidget : public Widget2D
+    {
+    public:
+        ImageOverlayWidget(const Mat &image, const Rect &rect);
+        
+        void setImage(const Mat &image);
+    };
+    
+ImageOverlayWidget::ImageOverlayWidget
+--------------------------------------
+Constructs a ImageOverlayWidget.
+
+.. ocv:function:: ImageOverlayWidget(const Mat &image, const Rect &rect)
+
+    :param image: BGR or Gray-Scale image.
+    :param rect: Image is scaled and positioned based on rect.
+    
+ImageOverlayWidget::setImage
+----------------------------
+Sets the image content of the widget.
+
+.. ocv:function:: void setImage(const Mat &image)
+
+    :param image: BGR or Gray-Scale image.
+    
+Image3DWidget
+-------------
+.. ocv:class:: Image3DWidget
+
+This 3D Widget represents 3D image. ::
+
+    class CV_EXPORTS Image3DWidget : public Widget3D
+    {
+    public:
+        //! Creates 3D image at the origin
+        Image3DWidget(const Mat &image, const Size &size);
+        //! Creates 3D image at a given position, pointing in the direction of the normal, and having the up_vector orientation
+        Image3DWidget(const Vec3f &position, const Vec3f &normal, const Vec3f &up_vector, const Mat &image, const Size &size);
+        
+        void setImage(const Mat &image);
+    };
+
+Image3DWidget::Image3DWidget
+----------------------------
+Constructs a Image3DWidget.
+
+.. ocv:function:: Image3DWidget(const Mat &image, const Size &size)
+    
+    :param image: BGR or Gray-Scale image.
+    :param size: Size of the image.
+    
+.. ocv:function:: Image3DWidget(const Vec3f &position, const Vec3f &normal, const Vec3f &up_vector, const Mat &image, const Size &size)
+
+    :param position: Position of the image.
+    :param normal: Normal of the plane that represents the image.
+    :param up_vector: Determines orientation of the image.
+    :param image: BGR or Gray-Scale image.
+    :param size: Size of the image.
+    
+Image3DWidget::setImage
+-----------------------
+Sets the image content of the widget.
+
+.. ocv:function:: void setImage(const Mat &image)
+
+    :param image: BGR or Gray-Scale image.
+    
+CameraPositionWidget
+--------------------
+.. ocv:class:: CameraPositionWidget
+
+This 3D Widget represents camera position. ::
+
+    class CV_EXPORTS CameraPositionWidget : public Widget3D
+    {
+    public:
+        //! Creates camera coordinate frame (axes) at the origin
+        CameraPositionWidget(double scale = 1.0);
+        //! Creates frustum based on the intrinsic marix K at the origin
+        CameraPositionWidget(const Matx33f &K, double scale = 1.0, const Color &color = Color::white());
+        //! Creates frustum based on the field of view at the origin
+        CameraPositionWidget(const Vec2f &fov, double scale = 1.0, const Color &color = Color::white());
+        //! Creates frustum and display given image at the far plane
+        CameraPositionWidget(const Matx33f &K, const Mat &img, double scale = 1.0, const Color &color = Color::white());
+    };
+    
+CameraPositionWidget::CameraPositionWidget
+------------------------------------------
+Constructs a CameraPositionWidget.
+
+.. ocv:function:: CameraPositionWidget(double scale = 1.0)
+
+    Creates camera coordinate frame at the origin.
+    
+.. ocv:function:: CameraPositionWidget(const Matx33f &K, double scale = 1.0, const Color &color = Color::white())
+
+    :param K: Intrinsic matrix of the camera.
+    :param scale: Scale of the frustum.
+    :param color: Color of the frustum.
+    
+    Creates viewing frustum of the camera based on its intrinsic matrix K.
+    
+.. ocv:function:: CameraPositionWidget(const Vec2f &fov, double scale = 1.0, const Color &color = Color::white())
+
+    :param fov: Field of view of the camera (horizontal, vertical).
+    :param scale: Scale of the frustum.
+    :param color: Color of the frustum.
+    
+    Creates viewing frustum of the camera based on its field of view fov.
+
+.. ocv:function:: CameraPositionWidget(const Matx33f &K, const Mat &img, double scale = 1.0, const Color &color = Color::white())
+
+    :param K: Intrinsic matrix of the camera.
+    :param img: BGR or Gray-Scale image that is going to be displayed at the far plane of the frustum.
+    :param scale: Scale of the frustum and image.
+    :param color: Color of the frustum.
+    
+    Creates viewing frustum of the camera based on its intrinsic matrix K, and displays image on the far end plane.
+    
+TrajectoryWidget
+----------------
+.. ocv:class:: TrajectoryWidget
+
+This 3D Widget represents a trajectory. ::
+
+    class CV_EXPORTS TrajectoryWidget : public Widget3D
+    {
+    public:
+        enum {DISPLAY_FRAMES = 1, DISPLAY_PATH = 2};
+        
+        //! Displays trajectory of the given path either by coordinate frames or polyline
+        TrajectoryWidget(const std::vector<Affine3f> &path, int display_mode = TrajectoryWidget::DISPLAY_PATH, const Color &color = Color::white(), double scale = 1.0);
+        //! Displays trajectory of the given path by frustums
+        TrajectoryWidget(const std::vector<Affine3f> &path, const Matx33f &K, double scale = 1.0, const Color &color = Color::white());
+        //! Displays trajectory of the given path by frustums
+        TrajectoryWidget(const std::vector<Affine3f> &path, const Vec2f &fov, double scale = 1.0, const Color &color = Color::white());
+        
+    private:
+        /* hidden */
+    };
+    
+TrajectoryWidget::TrajectoryWidget
+----------------------------------
+Constructs a TrajectoryWidget.
+
+.. ocv:function:: TrajectoryWidget(const std::vector<Affine3f> &path, int display_mode = TrajectoryWidget::DISPLAY_PATH, const Color &color = Color::white(), double scale = 1.0)
+
+    :param path: List of poses on a trajectory.
+    :param display_mode: Display mode. This can be DISPLAY_PATH, DISPLAY_FRAMES, DISPLAY_PATH & DISPLAY_FRAMES.
+    :param color: Color of the polyline that represents path. Frames are not affected.
+    :param scale: Scale of the frames. Polyline is not affected.
+    
+    Displays trajectory of the given path as follows:
+    
+    * DISPLAY_PATH : Displays a poly line that represents the path.
+    * DISPLAY_FRAMES : Displays coordinate frames at each pose.
+    * DISPLAY_PATH & DISPLAY_FRAMES : Displays both poly line and coordinate frames.
+    
+.. ocv:function:: TrajectoryWidget(const std::vector<Affine3f> &path, const Matx33f &K, double scale = 1.0, const Color &color = Color::white())
+
+    :param path: List of poses on a trajectory.
+    :param K: Intrinsic matrix of the camera.
+    :param scale: Scale of the frustums.
+    :param color: Color of the frustums.
+    
+    Displays frustums at each pose of the trajectory.
+    
+.. ocv:function:: TrajectoryWidget(const std::vector<Affine3f> &path, const Vec2f &fov, double scale = 1.0, const Color &color = Color::white())
+
+    :param path: List of poses on a trajectory.
+    :param fov: Field of view of the camera (horizontal, vertical).
+    :param scale: Scale of the frustums.
+    :param color: Color of the frustums.
+    
+    Displays frustums at each pose of the trajectory.
+
+SpheresTrajectoryWidget
+-----------------------
+.. ocv:class:: SpheresTrajectoryWidget
+
+This 3D Widget represents a trajectory using spheres and lines, where spheres represent the positions of the camera, and lines
+represent the direction from previous position to the current. ::
+
+    class CV_EXPORTS SpheresTrajectoryWidget : public Widget3D
+    {
+    public:
+        SpheresTrajectoryWidget(const std::vector<Affine3f> &path, float line_length = 0.05f, 
+                    double init_sphere_radius = 0.021, sphere_radius = 0.007, 
+                    Color &line_color = Color::white(), const Color &sphere_color = Color::white());
+    };
+    
+SpheresTrajectoryWidget::SpheresTrajectoryWidget
+------------------------------------------------
+Constructs a SpheresTrajectoryWidget.
+
+.. ocv:function:: SpheresTrajectoryWidget(const std::vector<Affine3f> &path, float line_length = 0.05f, double init_sphere_radius = 0.021, double sphere_radius = 0.007, const Color &line_color = Color::white(), const Color &sphere_color = Color::white())
+    
+    :param path: List of poses on a trajectory.
+    :param line_length: Length of the lines.
+    :param init_sphere_radius: Radius of the first sphere which represents the initial position of the camera.
+    :param sphere_radius: Radius of the rest of the spheres.
+    :param line_color: Color of the lines.
+    :param sphere_color: Color of the spheres.
+    
+CloudWidget
+-----------
+.. ocv:class:: CloudWidget
+
+This 3D Widget defines a point cloud. ::
+
+    class CV_EXPORTS CloudWidget : public Widget3D
+    {
+    public:
+        //! Each point in cloud is mapped to a color in colors
+        CloudWidget(InputArray cloud, InputArray colors);
+        //! All points in cloud have the same color
+        CloudWidget(InputArray cloud, const Color &color = Color::white());
+
+    private:
+        /* hidden */
+    };
+    
+CloudWidget::CloudWidget
+------------------------
+Constructs a CloudWidget.
+
+.. ocv:function:: CloudWidget(InputArray cloud, InputArray colors)
+
+    :param cloud: Point set which can be of type: CV_32FC3, CV_32FC4, CV_64FC3, CV_64FC4.
+    :param colors: Set of colors. It has to be of the same size with cloud.
+    
+    Points in the cloud belong to mask when they are set to (NaN, NaN, NaN). 
+
+.. ocv:function:: CloudWidget(InputArray cloud, const Color &color = Color::white())
+    
+    :param cloud: Point set which can be of type: CV_32FC3, CV_32FC4, CV_64FC3, CV_64FC4.
+    :param color: A single color for the whole cloud.
+
+    Points in the cloud belong to mask when they are set to (NaN, NaN, NaN). 
+
+CloudCollectionWidget
+---------------------
+.. ocv:class:: CloudCollectionWidget
+
+This 3D Widget defines a collection of clouds. ::
+
+    class CV_EXPORTS CloudCollectionWidget : public Widget3D
+    {
+    public:
+        CloudCollectionWidget();
+        
+        //! Each point in cloud is mapped to a color in colors
+        void addCloud(InputArray cloud, InputArray colors, const Affine3f &pose = Affine3f::Identity());
+        //! All points in cloud have the same color
+        void addCloud(InputArray cloud, const Color &color = Color::white(), Affine3f &pose = Affine3f::Identity());
+        
+    private:
+        /* hidden */
+    };
+    
+CloudCollectionWidget::CloudCollectionWidget
+--------------------------------------------
+Constructs a CloudCollectionWidget.
+
+.. ocv:function:: CloudCollectionWidget()
+
+CloudCollectionWidget::addCloud
+-------------------------------
+Adds a cloud to the collection.
+
+.. ocv:function:: void addCloud(InputArray cloud, InputArray colors, const Affine3f &pose = Affine3f::Identity())
+
+    :param cloud: Point set which can be of type: CV_32FC3, CV_32FC4, CV_64FC3, CV_64FC4.
+    :param colors: Set of colors. It has to be of the same size with cloud.
+    :param pose: Pose of the cloud.
+    
+    Points in the cloud belong to mask when they are set to (NaN, NaN, NaN). 
+    
+.. ocv:function:: void addCloud(InputArray cloud, const Color &color = Color::white(), const Affine3f &pose = Affine3f::Identity())
+
+    :param cloud: Point set which can be of type: CV_32FC3, CV_32FC4, CV_64FC3, CV_64FC4.
+    :param colors: A single color for the whole cloud.
+    :param pose: Pose of the cloud.
+    
+    Points in the cloud belong to mask when they are set to (NaN, NaN, NaN). 
+    
+CloudNormalsWidget
+------------------
+.. ocv:class:: CloudNormalsWidget
+
+This 3D Widget represents normals of a point cloud. ::
+
+    class CV_EXPORTS CloudNormalsWidget : public Widget3D
+    {
+    public:
+        CloudNormalsWidget(InputArray cloud, InputArray normals, int level = 100, float scale = 0.02f, const Color &color = Color::white());
+
+    private:
+        /* hidden */
+    };
+    
+CloudNormalsWidget::CloudNormalsWidget
+--------------------------------------
+Constructs a CloudNormalsWidget.
+
+.. ocv:function:: CloudNormalsWidget(InputArray cloud, InputArray normals, int level = 100, float scale = 0.02f, const Color &color = Color::white())
+    
+    :param cloud: Point set which can be of type: CV_32FC3, CV_32FC4, CV_64FC3, CV_64FC4.
+    :param normals: A set of normals that has to be of same type with cloud.
+    :param level: Display only every levelth normal.
+    :param scale: Scale of the arrows that represent normals.
+    :param color: Color of the arrows that represent normals.
+    
+MeshWidget
+----------
+.. ocv:class:: MeshWidget
+
+This 3D Widget defines a mesh. ::
+    
+    class CV_EXPORTS MeshWidget : public Widget3D
+    {
+    public:
+        MeshWidget(const Mesh3d &mesh);
+        
+    private:
+        /* hidden */
+    };
+    
+MeshWidget::MeshWidget
+----------------------
+Constructs a MeshWidget.
+
+.. ocv:function:: MeshWidget(const Mesh3d &mesh)
+
+    :param mesh: Mesh object that will be displayed.
+
+
+
+

modules/viz/include/opencv2/viz.hpp

@@ -65,9 +65,10 @@ namespace cv
         //! 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));
 
-        //! constructs camera pose from position, focal_point and up_vector (see gluLookAt() for more infromation
+        //! constructs camera pose from position, focal_point and up_vector (see gluLookAt() for more infromation)
         CV_EXPORTS Affine3f makeCameraPose(const Vec3f& position, const Vec3f& focal_point, const Vec3f& y_dir);
 
+        //! retrieves a window by its name
         CV_EXPORTS Viz3d get(const String &window_name);
 
         //! checks float value for Nan
@@ -92,6 +93,7 @@ namespace cv
         template<typename _Tp> inline bool isNan(const Point3_<_Tp>& p)
         { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
         
+        //! helper class that provides access by name infrastructure
         class CV_EXPORTS VizAccessor
         {
         public:
@@ -102,6 +104,7 @@ namespace cv
             void add(Viz3d window);
             void remove(const String &window_name);
             
+            //! window names automatically have Viz - prefix even though not provided by the users
             static void generateWindowName(const String &window_name, String &output);
             
         private:
@@ -112,8 +115,8 @@ namespace cv
             static bool is_instantiated_;
             static VizMap viz_map_;
         };
-    }
-}
+    } /* namespace viz */
+} /* namespace cv */
 
 
 #endif /* __OPENCV_VIZ_HPP__ */

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

@@ -39,6 +39,7 @@ namespace cv
             Mat cloud, colors;
             Mat polygons;
 
+            //! Loads mesh from a given ply file
             static cv::viz::Mesh3d loadMesh(const String& file);
             
         private:
@@ -52,14 +53,8 @@ namespace cv
             static const unsigned int Ctrl  = 2;
             static const unsigned int Shift = 4;
 
-            /** \brief Constructor
-              * \param[in] action    true for key was pressed, false for released
-              * \param[in] key_sym   the key-name that caused the action
-              * \param[in] key       the key code that caused the action
-              * \param[in] alt       whether the alt key was pressed at the time where this event was triggered
-              * \param[in] ctrl      whether the ctrl was pressed at the time where this event was triggered
-              * \param[in] shift     whether the shift was pressed at the time where this event was triggered
-              */
+            //! Create a keyboard event
+            //! - Note that action is true if key is pressed, false if released
             KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift);
 
             bool isAltPressed () const;

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

@@ -7,7 +7,6 @@
 #include <opencv2/core.hpp>
 #include <opencv2/viz/types.hpp>
 #include <opencv2/viz/widgets.hpp>
-#include <boost/concept_check.hpp>
 
 namespace cv
 {
@@ -25,18 +24,10 @@ namespace cv
             Viz3d& operator=(const Viz3d&);
             ~Viz3d();
 
-            void setBackgroundColor(const Color& color = Color::black());
-
-            //to refactor
-            bool addPolygonMesh(const Mesh3d& mesh, const String& id = "polygon");
-            bool updatePolygonMesh(const Mesh3d& mesh, const String& id = "polygon");
-            bool addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id = "polyline");
-            bool addPolygon(const Mat& cloud, const Color& color, const String& id = "polygon");
-
-
             void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
             void removeWidget(const String &id);
             Widget getWidget(const String &id) const;
+            void removeAllWidgets();
 
             void setWidgetPose(const String &id, const Affine3f &pose);
             void updateWidgetPose(const String &id, const Affine3f &pose);
@@ -47,13 +38,19 @@ namespace cv
             Affine3f getViewerPose();
             void setViewerPose(const Affine3f &pose);
             
+            void resetCameraViewpoint (const String &id);
+            void resetCamera();
+            
             void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord);
             void converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction);
             
             Size getWindowSize() const;
             void setWindowSize(const Size &window_size);
-            
             String getWindowName() const;
+            void saveScreenshot (const String &file);
+            void setWindowPosition (int x, int y);
+            void setFullScreen (bool mode);
+            void setBackgroundColor(const Color& color = Color::black());
 
             void spin();
             void spinOnce(int time = 1, bool force_redraw = false);
@@ -61,6 +58,16 @@ namespace cv
 
             void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
             void registerMouseCallback(MouseCallback callback, void* cookie = 0);
+            
+            void setRenderingProperty(const String &id, int property, double value);
+            double getRenderingProperty(const String &id, int property);
+            
+            void setDesiredUpdateRate(double time);
+            double getDesiredUpdateRate();
+            
+            void setRepresentationToSurface();
+            void setRepresentationToWireframe();
+            void setRepresentationToPoints();
         private:
 
             struct VizImpl;

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

 #pragma once
 
 #include <opencv2/viz/types.hpp>
-#include <common.h>
-
 
 namespace cv
 {
@@ -14,19 +12,23 @@ namespace cv
         {
         public:
             Widget();
-            Widget(const Widget &other);
-            Widget& operator =(const Widget &other);
-
+            Widget(const Widget& other);
+            Widget& operator=(const Widget& other);
             ~Widget();
+            
+            //! Create a widget directly from ply file
+            static Widget fromPlyFile(const String &file_name);
+            
+            //! Rendering properties of this particular widget
+            void setRenderingProperty(int property, double value);
+            double getRenderingProperty(int property) const;
 
+            //! Casting between widgets
             template<typename _W> _W cast();
         private:
             class Impl;
             Impl *impl_;
             friend struct WidgetAccessor;
-
-            void create();
-            void release();
         };
 
         /////////////////////////////////////////////////////////////////////////////
@@ -41,7 +43,6 @@ namespace cv
             Affine3f getPose() const;
 
             void setColor(const Color &color);
-
         private:
             struct MatrixConverter;
 
@@ -61,9 +62,6 @@ namespace cv
         {
         public:
             LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color = Color::white());
-
-            void setLineWidth(float line_width);
-            float getLineWidth();
         };
 
         class CV_EXPORTS PlaneWidget : public Widget3D
@@ -123,7 +121,9 @@ namespace cv
         class CV_EXPORTS GridWidget : public Widget3D
         {
         public:
+            //! Creates grid at the origin
             GridWidget(const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white());
+            //! Creates grid based on the plane equation
             GridWidget(const Vec4f &coeffs, const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white());
             
         private:
@@ -160,7 +160,9 @@ namespace cv
         class CV_EXPORTS Image3DWidget : public Widget3D
         {
         public:
+            //! Creates 3D image at the origin
             Image3DWidget(const Mat &image, const Size &size);
+            //! Creates 3D image at a given position, pointing in the direction of the normal, and having the up_vector orientation
             Image3DWidget(const Vec3f &position, const Vec3f &normal, const Vec3f &up_vector, const Mat &image, const Size &size);
             
             void setImage(const Mat &image);
@@ -169,11 +171,14 @@ namespace cv
         class CV_EXPORTS CameraPositionWidget : public Widget3D
         {
         public:
+            //! Creates camera coordinate frame (axes) at the origin
             CameraPositionWidget(double scale = 1.0);
+            //! Creates frustum based on the intrinsic marix K at the origin
             CameraPositionWidget(const Matx33f &K, double scale = 1.0, const Color &color = Color::white());
+            //! Creates frustum based on the field of view at the origin
             CameraPositionWidget(const Vec2f &fov, double scale = 1.0, const Color &color = Color::white());
+            //! Creates frustum and display given image at the far plane
             CameraPositionWidget(const Matx33f &K, const Mat &img, double scale = 1.0, const Color &color = Color::white());
-            
         };
         
         class CV_EXPORTS TrajectoryWidget : public Widget3D
@@ -181,9 +186,12 @@ namespace cv
         public:
             enum {DISPLAY_FRAMES = 1, DISPLAY_PATH = 2};
             
+            //! Displays trajectory of the given path either by coordinate frames or polyline
             TrajectoryWidget(const std::vector<Affine3f> &path, int display_mode = TrajectoryWidget::DISPLAY_PATH, const Color &color = Color::white(), double scale = 1.0);
-            TrajectoryWidget(const std::vector<Affine3f> &path, const Matx33f &K, double scale = 1.0, const Color &color = Color::white()); // Camera frustums
-            TrajectoryWidget(const std::vector<Affine3f> &path, const Vec2f &fov, double scale = 1.0, const Color &color = Color::white()); // Camera frustums
+            //! Displays trajectory of the given path by frustums
+            TrajectoryWidget(const std::vector<Affine3f> &path, const Matx33f &K, double scale = 1.0, const Color &color = Color::white());
+            //! Displays trajectory of the given path by frustums
+            TrajectoryWidget(const std::vector<Affine3f> &path, const Vec2f &fov, double scale = 1.0, const Color &color = Color::white());
             
         private:
             struct ApplyPath;
@@ -199,7 +207,9 @@ namespace cv
         class CV_EXPORTS CloudWidget : public Widget3D
         {
         public:
+            //! Each point in cloud is mapped to a color in colors
             CloudWidget(InputArray cloud, InputArray colors);
+            //! All points in cloud have the same color
             CloudWidget(InputArray cloud, const Color &color = Color::white());
 
         private:
@@ -211,7 +221,9 @@ namespace cv
         public:
             CloudCollectionWidget();
             
+            //! Each point in cloud is mapped to a color in colors
             void addCloud(InputArray cloud, InputArray colors, const Affine3f &pose = Affine3f::Identity());
+            //! All points in cloud have the same color
             void addCloud(InputArray cloud, const Color &color = Color::white(), const Affine3f &pose = Affine3f::Identity());
             
         private:

modules/viz/src/cloud_widgets.cpp

@@ -298,7 +298,7 @@ struct cv::viz::CloudCollectionWidget::CreateCloudWidget
         }
         
         vtkPolyData *data = vtkPolyData::SafeDownCast(mapper->GetInput());
-        CV_Assert(data);
+        CV_Assert("Cloud Widget without data" && data);
         
         vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
         appendFilter->AddInputConnection(mapper->GetInput()->GetProducerPort());
@@ -357,7 +357,7 @@ void cv::viz::CloudCollectionWidget::addCloud(InputArray _cloud, InputArray _col
     transform_filter->Update();
     
     vtkLODActor *actor = vtkLODActor::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Incompatible widget type." && actor);
     
     Vec3d minmax(scalars->GetRange());
     CreateCloudWidget::createMapper(actor, transform_filter->GetOutput(), minmax);
@@ -392,7 +392,7 @@ void cv::viz::CloudCollectionWidget::addCloud(InputArray _cloud, const Color &co
     transform_filter->Update();
     
     vtkLODActor *actor = vtkLODActor::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Incompatible widget type." && actor);
     
     Vec3d minmax(scalars->GetRange());
     CreateCloudWidget::createMapper(actor, transform_filter->GetOutput(), minmax);

modules/viz/src/common.cpp

-#include <common.h>
-#include <cstdlib>
-#include <opencv2/viz/types.hpp>
-#include "viz3d_impl.hpp"
-
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-//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);
-//    // Normalize w-component
-//    world /= world.w ();
-
-//    // X/Y screen space coordinate
-//    int screen_x = int (floor (double (((world.x () + 1) / 2.0) * width) + 0.5));
-//    int screen_y = int (floor (double (((world.y () + 1) / 2.0) * height) + 0.5));
-
-//    // Calculate -world_pt.y () because the screen Y axis is oriented top->down, ie 0 is top-left
-//    //int winY = (int) floor ( (double) (((1 - world_pt.y ()) / 2.0) * height) + 0.5); // top left
-
-//    return (Eigen::Vector2i (screen_x, screen_y));
-//}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-//void cv::viz::getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24])
-//{
-//    // Set up the normals
-//    Eigen::Vector4d normals[6];
-//    for (int i=0; i < 6; i++)
-//    {
-//        normals[i] = Eigen::Vector4d (0.0, 0.0, 0.0, 1.0);
-
-//        // if i is even set to -1, if odd set to +1
-//        normals[i] (i/2) = 1 - (i%2)*2;
-//    }
-
-//    // Transpose the matrix for use with normals
-//    Eigen::Matrix4d view_matrix = view_projection_matrix.transpose ();
-
-//    // Transform the normals to world coordinates
-//    for (int i=0; i < 6; i++)
-//    {
-//        normals[i] = view_matrix * normals[i];
-
-//        double f = 1.0/sqrt (normals[i].x () * normals[i].x () +
-//                             normals[i].y () * normals[i].y () +
-//                             normals[i].z () * normals[i].z ());
-
-//        planes[4*i + 0] = normals[i].x ()*f;
-//        planes[4*i + 1] = normals[i].y ()*f;
-//        planes[4*i + 2] = normals[i].z ()*f;
-//        planes[4*i + 3] = normals[i].w ()*f;
-//    }
-//}
-
-//int cv::viz::cullFrustum (double frustum[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb)
-//{
-//    int result = PCL_INSIDE_FRUSTUM;
-
-//    for(int i =0; i < 6; i++){
-//        double a = frustum[(i*4)];
-//        double b = frustum[(i*4)+1];
-//        double c = frustum[(i*4)+2];
-//        double d = frustum[(i*4)+3];
-
-//        //cout << i << ": " << a << "x + " << b << "y + " << c << "z + " << d << endl;
-
-//        //  Basic VFC algorithm
-//        Eigen::Vector3d center ((max_bb.x () - min_bb.x ()) / 2 + min_bb.x (),
-//                                (max_bb.y () - min_bb.y ()) / 2 + min_bb.y (),
-//                                (max_bb.z () - min_bb.z ()) / 2 + min_bb.z ());
-
-//        Eigen::Vector3d radius (fabs (static_cast<double> (max_bb.x () - center.x ())),
-//                                fabs (static_cast<double> (max_bb.y () - center.y ())),
-//                                fabs (static_cast<double> (max_bb.z () - center.z ())));
-
-//        double m = (center.x () * a) + (center.y () * b) + (center.z () * c) + d;
-//        double n = (radius.x () * fabs(a)) + (radius.y () * fabs(b)) + (radius.z () * fabs(c));
-
-//        if (m + n < 0){
-//            result = PCL_OUTSIDE_FRUSTUM;
-//            break;
-//        }
-
-//        if (m - n < 0)
-//        {
-//            result = PCL_INTERSECT_FRUSTUM;
-//        }
-//    }
-
-//    return result;
-//}
-
-//void
-//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();
-//  for (int i=0; i < 3; i++)
-//  {
-//    position(i) = inverse_model_view_matrix(i, 3);
-//  }
-//}
-
-// Lookup table of max 6 bounding box vertices, followed by number of vertices, ie {v0, v1, v2, v3, v4, v5, nv}
-//
-//      3--------2
-//     /|       /|       Y      0 = xmin, ymin, zmin
-//    / |      / |       |      6 = xmax, ymax. zmax
-//   7--------6  |       |
-//   |  |     |  |       |
-//   |  0-----|--1       +------X
-//   | /      | /       /
-//   |/       |/       /
-//   4--------5       Z
-
-int hull_vertex_table[43][7] = {
-    { 0, 0, 0, 0, 0, 0, 0 }, // inside
-    { 0, 4, 7, 3, 0, 0, 4 }, // left
-    { 1, 2, 6, 5, 0, 0, 4 }, // right
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 1, 5, 4, 0, 0, 4 }, // bottom
-    { 0, 1, 5, 4, 7, 3, 6 }, // bottom, left
-    { 0, 1, 2, 6, 5, 4, 6 }, // bottom, right
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 2, 3, 7, 6, 0, 0, 4 }, // top
-    { 4, 7, 6, 2, 3, 0, 6 }, // top, left
-    { 2, 3, 7, 6, 5, 1, 6 }, // top, right
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 3, 2, 1, 0, 0, 4 }, // front
-    { 0, 4, 7, 3, 2, 1, 6 }, // front, left
-    { 0, 3, 2, 6, 5, 1, 6 }, // front, right
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 3, 2, 1, 5, 4, 6 }, // front, bottom
-    { 2, 1, 5, 4, 7, 3, 6 }, // front, bottom, left
-    { 0, 3, 2, 6, 5, 4, 6 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 3, 7, 6, 2, 1, 6 }, // front, top
-    { 0, 4, 7, 6, 2, 1, 6 }, // front, top, left
-    { 0, 3, 7, 6, 5, 1, 6 }, // front, top, right
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 4, 5, 6, 7, 0, 0, 4 }, // back
-    { 4, 5, 6, 7, 3, 0, 6 }, // back, left
-    { 1, 2, 6, 7, 4, 5, 6 }, // back, right
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 0, 1, 5, 6, 7, 4, 6 }, // back, bottom
-    { 0, 1, 5, 6, 7, 3, 6 }, // back, bottom, left
-    { 0, 1, 2, 6, 7, 4, 6 }, // back, bottom, right
-    { 0, 0, 0, 0, 0, 0, 0 },
-    { 2, 3, 7, 4, 5, 6, 6 }, // back, top
-    { 0, 4, 5, 6, 2, 3, 6 }, // back, top, left
-    { 1, 2, 3, 7, 4, 5, 6 }  // back, top, right
-};
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-//float
-//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)
-//{
-//    Eigen::Vector4d bounding_box[8];
-//    bounding_box[0] = Eigen::Vector4d(min_bb.x (), min_bb.y (), min_bb.z (), 1.0);
-//    bounding_box[1] = Eigen::Vector4d(max_bb.x (), min_bb.y (), min_bb.z (), 1.0);
-//    bounding_box[2] = Eigen::Vector4d(max_bb.x (), max_bb.y (), min_bb.z (), 1.0);
-//    bounding_box[3] = Eigen::Vector4d(min_bb.x (), max_bb.y (), min_bb.z (), 1.0);
-//    bounding_box[4] = Eigen::Vector4d(min_bb.x (), min_bb.y (), max_bb.z (), 1.0);
-//    bounding_box[5] = Eigen::Vector4d(max_bb.x (), min_bb.y (), max_bb.z (), 1.0);
-//    bounding_box[6] = Eigen::Vector4d(max_bb.x (), max_bb.y (), max_bb.z (), 1.0);
-//    bounding_box[7] = Eigen::Vector4d(min_bb.x (), max_bb.y (), max_bb.z (), 1.0);
-
-//    // Compute 6-bit code to classify eye with respect to the 6 defining planes
-//    int pos = ((eye.x () < bounding_box[0].x ()) )  // 1 = left
-//            + ((eye.x () > bounding_box[6].x ()) << 1)  // 2 = right
-//            + ((eye.y () < bounding_box[0].y ()) << 2)  // 4 = bottom
-//            + ((eye.y () > bounding_box[6].y ()) << 3)  // 8 = top
-//            + ((eye.z () < bounding_box[0].z ()) << 4)  // 16 = front
-//            + ((eye.z () > bounding_box[6].z ()) << 5); // 32 = back
-
-//    // Look up number of vertices
-//    int num = hull_vertex_table[pos][6];
-//    if (num == 0)
-//    {
-//        return (float (width * height));
-//    }
-//    //return 0.0;
-
-
-//    //  cout << "eye: " << eye.x() << " " << eye.y() << " " << eye.z() << endl;
-//    //  cout << "min: " << bounding_box[0].x() << " " << bounding_box[0].y() << " " << bounding_box[0].z() << endl;
-//    //
-//    //  cout << "pos: " << pos << " ";
-//    //  switch(pos){
-//    //    case 0:  cout << "inside" << endl; break;
-//    //    case 1:  cout << "left" << endl; break;
-//    //    case 2:  cout << "right" << endl; break;
-//    //    case 3:
-//    //    case 4:  cout << "bottom" << endl; break;
-//    //    case 5:  cout << "bottom, left" << endl; break;
-//    //    case 6:  cout << "bottom, right" << endl; break;
-//    //    case 7:
-//    //    case 8:  cout << "top" << endl; break;
-//    //    case 9:  cout << "top, left" << endl; break;
-//    //    case 10:  cout << "top, right" << endl; break;
-//    //    case 11:
-//    //    case 12:
-//    //    case 13:
-//    //    case 14:
-//    //    case 15:
-//    //    case 16:  cout << "front" << endl; break;
-//    //    case 17:  cout << "front, left" << endl; break;
-//    //    case 18:  cout << "front, right" << endl; break;
-//    //    case 19:
-//    //    case 20:  cout << "front, bottom" << endl; break;
-//    //    case 21:  cout << "front, bottom, left" << endl; break;
-//    //    case 22:
-//    //    case 23:
-//    //    case 24:  cout << "front, top" << endl; break;
-//    //    case 25:  cout << "front, top, left" << endl; break;
-//    //    case 26:  cout << "front, top, right" << endl; break;
-//    //    case 27:
-//    //    case 28:
-//    //    case 29:
-//    //    case 30:
-//    //    case 31:
-//    //    case 32:  cout << "back" << endl; break;
-//    //    case 33:  cout << "back, left" << endl; break;
-//    //    case 34:  cout << "back, right" << endl; break;
-//    //    case 35:
-//    //    case 36:  cout << "back, bottom" << endl; break;
-//    //    case 37:  cout << "back, bottom, left" << endl; break;
-//    //    case 38:  cout << "back, bottom, right" << endl; break;
-//    //    case 39:
-//    //    case 40:  cout << "back, top" << endl; break;
-//    //    case 41:  cout << "back, top, left" << endl; break;
-//    //    case 42:  cout << "back, top, right" << endl; break;
-//    //  }
-
-//    //return -1 if inside
-//    Eigen::Vector2d dst[8];
-//    for (int i = 0; i < num; i++)
-//    {
-//        Eigen::Vector4d world_pt = bounding_box[hull_vertex_table[pos][i]];
-//        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 ());
-//    }
-
-//    double sum = 0.0;
-//    for (int i = 0; i < num; ++i)
-//    {
-//        sum += (dst[i].x () - dst[(i+1) % num].x ()) * (dst[i].y () + dst[(i+1) % num].y ());
-//    }
-
-//    return (fabsf (float (sum * 0.5f)));
-//}

modules/viz/src/common.h

@@ -8,20 +8,6 @@ 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
-    //    };
-
-        //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);
-
         enum RenderingProperties
         {
             VIZ_POINT_SIZE,

modules/viz/src/interactor_style.cpp

 #include "precomp.hpp"
-
 #include "interactor_style.h"
 
-//#include <q/visualization/vtk/vtkVertexBufferObjectMapper.h>
-
 using namespace cv;
 
 //////////////////////////////////////////////////////////////////////////////////////////////
@@ -152,17 +149,9 @@ void cv::viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const K
 void
 cv::viz::InteractorStyle::OnKeyDown ()
 {
-    if (!init_)
-    {
-        std::cout << "Interactor style not initialized. Please call Initialize () before continuing" << std::endl;
-        return;
-    }
-
-    if (!renderer_)
-    {
-        std::cout << "No renderer given! Use SetRendererCollection () before continuing." << std::endl;
-        return;
-    }
+    
+    CV_Assert("Interactor style not initialized. Please call Initialize () before continuing" && init_);
+    CV_Assert("No renderer given! Use SetRendererCollection () before continuing." && renderer_);
 
     FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
 
@@ -235,7 +224,7 @@ cv::viz::InteractorStyle::OnKeyDown ()
         {
             for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
             {
-                vtkSmartPointer<vtkActor> apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ());
+                vtkActor* apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ());
                 apart->GetProperty ()->SetRepresentationToPoints ();
             }
         }
@@ -258,15 +247,12 @@ cv::viz::InteractorStyle::OnKeyDown ()
         cam->GetFocalPoint (focal);
         cam->GetPosition (pos);
         cam->GetViewUp (view);
-#ifndef M_PI
-        # define M_PI   3.14159265358979323846     // pi
-#endif
 
         int *win_pos = Interactor->GetRenderWindow ()->GetPosition ();
         int *win_size = Interactor->GetRenderWindow ()->GetSize ();
         ofs_cam << clip[0]  << "," << clip[1]  << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
                                pos[0]   << "," << pos[1]   << "," << pos[2]   << "/" << view[0]  << "," << view[1]  << "," << view[2] << "/" <<
-                               cam->GetViewAngle () / 180.0 * M_PI  << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
+                               cam->GetViewAngle () / 180.0 * CV_PI  << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
                             << endl;
         ofs_cam.close ();
 
@@ -310,7 +296,7 @@ cv::viz::InteractorStyle::OnKeyDown ()
             {
                 for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
                 {
-                    vtkSmartPointer<vtkActor> apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ());
+                    vtkActor* apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ());
                     float psize = apart->GetProperty ()->GetPointSize ();
                     if (psize < 63.0f)
                         apart->GetProperty ()->SetPointSize (psize + 1.0f);
@@ -331,7 +317,7 @@ cv::viz::InteractorStyle::OnKeyDown ()
             {
                 for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); )
                 {
-                    vtkSmartPointer<vtkActor> apart = static_cast<vtkActor*> (path->GetLastNode ()->GetViewProp ());
+                    vtkActor* apart = static_cast<vtkActor*> (path->GetLastNode ()->GetViewProp ());
                     float psize = apart->GetProperty ()->GetPointSize ();
                     if (psize > 1.0f)
                         apart->GetProperty ()->SetPointSize (psize - 1.0f);
@@ -432,17 +418,17 @@ cv::viz::InteractorStyle::OnKeyDown ()
 
         vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera ();
 
-        static CloudActorMap::iterator it = actors_->begin ();
+        static WidgetActorMap::iterator it = widget_actor_map_->begin ();
         // it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault.
         bool found_transformation = false;
 
-        for (size_t idx = 0; idx < actors_->size (); ++idx, ++it)
+        for (size_t idx = 0; idx < widget_actor_map_->size (); ++idx, ++it)
         {
-            if (it == actors_->end ())
-                it = actors_->begin ();
-
-            const CloudActor& actor = it->second;
-            if (actor.viewpoint_transformation_.GetPointer ())
+            if (it == widget_actor_map_->end ())
+                it = widget_actor_map_->begin ();
+            
+            vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second);
+            if (actor && actor->GetUserMatrix())
             {
                 found_transformation = true;
                 break;
@@ -452,18 +438,18 @@ cv::viz::InteractorStyle::OnKeyDown ()
         // if a valid transformation was found, use it otherwise fall back to default view point.
         if (found_transformation)
         {
-            const CloudActor& actor = it->second;
-            cam->SetPosition (actor.viewpoint_transformation_->GetElement (0, 3),
-                              actor.viewpoint_transformation_->GetElement (1, 3),
-                              actor.viewpoint_transformation_->GetElement (2, 3));
-
-            cam->SetFocalPoint (actor.viewpoint_transformation_->GetElement (0, 3) - actor.viewpoint_transformation_->GetElement (0, 2),
-                                actor.viewpoint_transformation_->GetElement (1, 3) - actor.viewpoint_transformation_->GetElement (1, 2),
-                                actor.viewpoint_transformation_->GetElement (2, 3) - actor.viewpoint_transformation_->GetElement (2, 2));
-
-            cam->SetViewUp (actor.viewpoint_transformation_->GetElement (0, 1),
-                            actor.viewpoint_transformation_->GetElement (1, 1),
-                            actor.viewpoint_transformation_->GetElement (2, 1));
+            vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second);
+            cam->SetPosition (actor->GetUserMatrix()->GetElement (0, 3),
+                              actor->GetUserMatrix()->GetElement (1, 3),
+                              actor->GetUserMatrix()->GetElement (2, 3));
+
+            cam->SetFocalPoint (actor->GetUserMatrix()->GetElement (0, 3) - actor->GetUserMatrix()->GetElement (0, 2),
+                                actor->GetUserMatrix()->GetElement (1, 3) - actor->GetUserMatrix()->GetElement (1, 2),
+                                actor->GetUserMatrix()->GetElement (2, 3) - actor->GetUserMatrix()->GetElement (2, 2));
+
+            cam->SetViewUp (actor->GetUserMatrix()->GetElement (0, 1),
+                            actor->GetUserMatrix()->GetElement (1, 1),
+                            actor->GetUserMatrix()->GetElement (2, 1));
         }
         else
         {
@@ -473,10 +459,10 @@ cv::viz::InteractorStyle::OnKeyDown ()
         }
 
         // go to the next actor for the next key-press event.
-        if (it != actors_->end ())
+        if (it != widget_actor_map_->end ())
             ++it;
         else
-            it = actors_->begin ();
+            it = widget_actor_map_->begin ();
 
         CurrentRenderer->SetActiveCamera (cam);
         CurrentRenderer->ResetCameraClippingRange ();
@@ -659,17 +645,8 @@ void cv::viz::InteractorStyle::OnMouseWheelBackward ()
 //////////////////////////////////////////////////////////////////////////////////////////////
 void cv::viz::InteractorStyle::OnTimer ()
 {
-    if (!init_)
-    {
-        std::cout << "[PCLVisualizerInteractorStyle] Interactor style not initialized. Please call Initialize () before continuing.\n" << std::endl;
-        return;
-    }
-
-    if (!renderer_)
-    {
-        std::cout <<  "[PCLVisualizerInteractorStyle] No renderer collection given! Use SetRendererCollection () before continuing." << std::endl;
-        return;
-    }
+    CV_Assert("Interactor style not initialized." && init_);
+    CV_Assert("Renderer has not been set." && renderer_);
     renderer_->Render ();
     Interactor->Render ();
 }

modules/viz/src/interactor_style.h

@@ -50,7 +50,7 @@ namespace cv
             /** \brief Initialization routine. Must be called before anything else. */
             virtual void Initialize ();
 
-            inline void setCloudActorMap (const Ptr<CloudActorMap>& actors) { actors_ = actors; }
+            inline void setWidgetActorMap (const Ptr<WidgetActorMap>& actors) { widget_actor_map_ = actors; }
             void setRenderer (vtkSmartPointer<vtkRenderer>& ren) { renderer_ = ren; }
             void registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie = 0);
             void registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void * cookie = 0);
@@ -73,8 +73,8 @@ namespace cv
             vtkSmartPointer<vtkRenderer> renderer_;
 
             /** \brief Actor map stored internally. */
-            cv::Ptr<CloudActorMap> actors_;
-
+            cv::Ptr<WidgetActorMap> widget_actor_map_;
+            
             /** \brief The current window width/height. */
             Vec2i win_size_;
 

modules/viz/src/precomp.hpp

@@ -5,8 +5,6 @@
 #include <list>
 #include <vector>
 
-#include <Eigen/Geometry>
-
 #if defined __GNUC__
 #pragma GCC system_header
 #ifdef __DEPRECATED
@@ -17,34 +15,19 @@
 
 #include <vtkAppendPolyData.h>
 #include <vtkAssemblyPath.h>
-#include <vtkAxesActor.h>
-#include <vtkActor.h>
-#include <vtkBoxRepresentation.h>
-#include <vtkBoxWidget.h>
-#include <vtkBoxWidget2.h>
 #include <vtkCellData.h>
-#include <vtkMath.h>
-#include <vtkLoopSubdivisionFilter.h>
 #include <vtkLineSource.h>
-#include <vtkLegendScaleActor.h>
-#include <vtkLightKit.h>
-#include <vtkPlatonicSolidSource.h>
 #include <vtkPropPicker.h>
-#include <vtkGeneralTransform.h>
 #include <vtkSmartPointer.h>
 #include <vtkDataSet.h>
-#include <vtkDataSetSurfaceFilter.h>
-#include <vtkExecutive.h>
 #include <vtkPolygon.h>
 #include <vtkPointPicker.h>
 #include <vtkUnstructuredGrid.h>
-#include <vtkConeSource.h>
 #include <vtkDiskSource.h>
 #include <vtkPlaneSource.h>
 #include <vtkSphereSource.h>
 #include <vtkArrowSource.h>
 #include <vtkOutlineSource.h>
-#include <vtkIdentityTransform.h>
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkTubeFilter.h>
@@ -59,18 +42,12 @@
 #include <vtkDataSetMapper.h>
 #include <vtkCellArray.h>
 #include <vtkCommand.h>
-#include <vtkCellLocator.h>
 #include <vtkPLYReader.h>
-#include <vtkTransformFilter.h>
 #include <vtkPolyLine.h>
 #include <vtkVectorText.h>
 #include <vtkFollower.h>
-#include <vtkCallbackCommand.h>
 #include <vtkInteractorStyle.h>
-#include <vtkInformationVector.h>
-#include <vtkDataArray.h>
 #include <vtkUnsignedCharArray.h>
-#include <vtkPoints.h>
 #include <vtkRendererCollection.h>
 #include <vtkPNGWriter.h>
 #include <vtkWindowToImageFilter.h>
@@ -78,78 +55,22 @@
 #include <vtkProperty.h>
 #include <vtkCamera.h>
 #include <vtkObjectFactory.h>
-#include <vtkScalarBarActor.h>
-#include <vtkScalarsToColors.h>
-#include <vtkClipPolyData.h>
 #include <vtkPlanes.h>
-#include <vtkImageImport.h>
 #include <vtkImageViewer.h>
-#include <vtkInteractorStyleImage.h>
 #include <vtkImageFlip.h>
-#include <vtkTIFFWriter.h>
-#include <vtkBMPWriter.h>
-#include <vtkJPEGWriter.h>
-#include <vtkImageViewer2.h>
 #include <vtkRenderWindow.h>
-#include <vtkXYPlotActor.h>
 #include <vtkTextProperty.h>
 #include <vtkProperty2D.h>
-#include <vtkFieldData.h>
-#include <vtkDoubleArray.h>
 #include <vtkLODActor.h>
-#include <vtkPolyDataWriter.h>
 #include <vtkTextActor.h>
-#include <vtkCleanPolyData.h>
-#include <vtkRenderer.h>
-#include <vtkObject.h>
-#include <vtkOrientationMarkerWidget.h>
-#include <vtkImageReslice.h>
-#include <vtkImageChangeInformation.h>
-#include <vtkImageCanvasSource2D.h>
-#include <vtkImageBlend.h>
-#include <vtkImageStencilData.h>
-#include <vtkImageActor.h>
-
 #include <vtkRenderWindowInteractor.h>
-#include <vtkChartXY.h>
-#include <vtkPlot.h>
-#include <vtkTable.h>
-#include <vtkContextView.h>
-#include <vtkContextScene.h>
-#include <vtkColorSeries.h>
-#include <vtkAxis.h>
-#include <vtkSelection.h>
-#include <vtkHardwareSelector.h>
-#include <vtkTriangle.h>
-#include <vtkWorldPointPicker.h>
-#include <vtkInteractorStyleRubberBandPick.h>
-#include <vtkInteractorStyleTrackballActor.h>
-#include <vtkAreaPicker.h>
-#include <vtkExtractGeometry.h>
-#include <vtkExtractPolyDataGeometry.h>
-#include <vtkVertexGlyphFilter.h>
-#include <vtkIdFilter.h>
-#include <vtkIdTypeArray.h>
-#include <vtkImageReader2Factory.h>
-#include <vtkImageReader2.h>
-#include <vtkImageData.h>
+#include <vtkMath.h>
 #include <vtkExtractEdges.h>
 #include <vtkFrustumSource.h>
 #include <vtkTextureMapToPlane.h>
-
 #include <vtkPolyDataNormals.h>
-#include <vtkMapper.h>
-#include <vtkSelectionNode.h>
-#include <vtkAbstractPicker.h>
-#include <vtkAbstractPropPicker.h>
-#include <vtkMatrix4x4.h>
-#include <vtkInteractorObserver.h>
-#include <vtkMapper2D.h>
-#include <vtkLeaderActor2D.h>
 #include <vtkAlgorithmOutput.h>
 
-
-
 #if defined __GNUC__ && defined __DEPRECATED_DISABLED__
 #define __DEPRECATED
 #undef __DEPRECATED_DISABLED__

modules/viz/src/shape_widgets.cpp

@@ -27,20 +27,6 @@ cv::viz::LineWidget::LineWidget(const Point3f &pt1, const Point3f &pt2, const Co
     setColor(color);
 }
 
-void cv::viz::LineWidget::setLineWidth(float line_width)
-{
-    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
-    actor->GetProperty()->SetLineWidth(line_width);
-}
-
-float cv::viz::LineWidget::getLineWidth()
-{
-    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
-    return actor->GetProperty()->GetLineWidth();
-}
-
 template<> cv::viz::LineWidget cv::viz::Widget::cast<cv::viz::LineWidget>()
 {
     Widget3D widget = this->cast<Widget3D>();
@@ -556,12 +542,12 @@ cv::viz::Text3DWidget::Text3DWidget(const String &text, const Point3f &position,
 void cv::viz::Text3DWidget::setText(const String &text)
 {
     vtkFollower *actor = vtkFollower::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("This widget does not support text." && actor);
     
     // Update text source
     vtkPolyDataMapper *mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
     vtkVectorText * textSource = vtkVectorText::SafeDownCast(mapper->GetInputConnection(0,0)->GetProducer());
-    CV_Assert(textSource);
+    CV_Assert("This widget does not support text." && textSource);
     
     textSource->SetText(text.c_str());
     textSource->Update();
@@ -570,11 +556,11 @@ void cv::viz::Text3DWidget::setText(const String &text)
 cv::String cv::viz::Text3DWidget::getText() const
 {
     vtkFollower *actor = vtkFollower::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("This widget does not support text." && actor);
     
     vtkPolyDataMapper *mapper = vtkPolyDataMapper::SafeDownCast(actor->GetMapper());
     vtkVectorText * textSource = vtkVectorText::SafeDownCast(mapper->GetInputConnection(0,0)->GetProducer());
-    CV_Assert(textSource);
+    CV_Assert("This widget does not support text." && textSource);
     
     return textSource->GetText();
 }
@@ -615,14 +601,14 @@ template<> cv::viz::TextWidget cv::viz::Widget::cast<cv::viz::TextWidget>()
 void cv::viz::TextWidget::setText(const String &text)
 {
     vtkTextActor *actor = vtkTextActor::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("This widget does not support text." && actor);
     actor->SetInput(text.c_str());
 }
 
 cv::String cv::viz::TextWidget::getText() const
 {
     vtkTextActor *actor = vtkTextActor::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("This widget does not support text." && actor);
     return actor->GetInput();
 }
 
@@ -671,10 +657,10 @@ void cv::viz::ImageOverlayWidget::setImage(const Mat &image)
     CV_Assert(!image.empty() && image.depth() == CV_8U);
     
     vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("This widget does not support overlay image." && actor);
     
     vtkImageMapper *mapper = vtkImageMapper::SafeDownCast(actor->GetMapper());
-    CV_Assert(mapper);
+    CV_Assert("This widget does not support overlay image." && mapper);
     
     // Create the vtk image and set its parameters based on input image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
@@ -821,7 +807,7 @@ void cv::viz::Image3DWidget::setImage(const Mat &image)
     CV_Assert(!image.empty() && image.depth() == CV_8U);
     
     vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("This widget does not support 3D image." && actor);
     
     // Create the vtk image and set its parameters based on input image
     vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
@@ -969,7 +955,6 @@ cv::viz::CameraPositionWidget::CameraPositionWidget(const Matx33f &K, const Mat
     
     // Create a camera
     vtkSmartPointer<vtkCamera> camera = vtkSmartPointer<vtkCamera>::New();
-    float f_x = K(0,0);
     float f_y = K(1,1);
     float c_y = K(1,2);
     float aspect_ratio = float(image.cols)/float(image.rows);

modules/viz/src/types.cpp

@@ -14,8 +14,8 @@ cv::viz::Color cv::viz::Color::blue()    { return Color(255,   0, 0); }
 cv::viz::Color cv::viz::Color::cyan()    { return Color(255, 255, 0); }
 
 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::yellow() { return Color(  0, 255, 255); }
+cv::viz::Color cv::viz::Color::magenta()  { return Color(255,   0, 255); }
 cv::viz::Color cv::viz::Color::white()   { return Color(255, 255, 255); }
 
 cv::viz::Color cv::viz::Color::gray()    { return Color(128, 128, 128); }
@@ -72,11 +72,12 @@ struct cv::viz::Mesh3d::loadMeshImpl
         vtkSmartPointer<vtkPLYReader> reader = vtkSmartPointer<vtkPLYReader>::New();
         reader->SetFileName(file.c_str());
         reader->Update();
+        
         vtkSmartPointer<vtkPolyData> poly_data = reader->GetOutput ();
+        CV_Assert("File does not exist or file format is not supported." && poly_data);
         
         vtkSmartPointer<vtkPoints> mesh_points = poly_data->GetPoints ();
         vtkIdType nr_points = mesh_points->GetNumberOfPoints ();
-        //vtkIdType nr_polygons = poly_data->GetNumberOfPolys ();
 
         mesh.cloud.create(1, nr_points, CV_32FC3);
 
@@ -89,18 +90,10 @@ struct cv::viz::Mesh3d::loadMeshImpl
         }
 
         // Then the color information, if any
-        vtkUnsignedCharArray* poly_colors = NULL;
-        if (poly_data->GetPointData() != NULL)
-            poly_colors = vtkUnsignedCharArray::SafeDownCast (poly_data->GetPointData ()->GetScalars ("Colors"));
-
-        // some applications do not save the name of scalars (including PCL's native vtk_io)
-        if (!poly_colors && poly_data->GetPointData () != NULL)
-            poly_colors = vtkUnsignedCharArray::SafeDownCast (poly_data->GetPointData ()->GetScalars ("scalars"));
-
-        if (!poly_colors && poly_data->GetPointData () != NULL)
-            poly_colors = vtkUnsignedCharArray::SafeDownCast (poly_data->GetPointData ()->GetScalars ("RGB"));
-
-        // TODO: currently only handles rgb values with 3 components
+        vtkUnsignedCharArray* poly_colors = 0;
+        if (poly_data->GetPointData())
+            poly_colors = vtkUnsignedCharArray::SafeDownCast(poly_data->GetPointData()->GetScalars());
+              
         if (poly_colors && (poly_colors->GetNumberOfComponents () == 3))
         {
             mesh.colors.create(1, nr_points, CV_8UC3);

modules/viz/src/viz3d.cpp

@@ -33,7 +33,9 @@ void cv::viz::Viz3d::create(const String &window_name)
 
 void cv::viz::Viz3d::release()
 {
-    if (impl_ && CV_XADD(&impl_->ref_counter, -1) == 1)
+    // If the current referene count is equal to 2, we can delete it
+    // - 2 : because minimum there will be two instances, one of which is in the map
+    if (impl_ && CV_XADD(&impl_->ref_counter, -1) == 2)
     {
         // Erase the window
         cv::viz::VizAccessor::getInstance().remove(getWindowName());
@@ -42,28 +44,6 @@ void cv::viz::Viz3d::release()
     }
 }
 
-void cv::viz::Viz3d::setBackgroundColor(const Color& color) { impl_->setBackgroundColor(color); }
-
-bool cv::viz::Viz3d::addPolygonMesh (const Mesh3d& mesh, const String& id)
-{
-    return impl_->addPolygonMesh(mesh, Mat(), id);
-}
-
-bool cv::viz::Viz3d::updatePolygonMesh (const Mesh3d& mesh, const String& id)
-{
-    return impl_->updatePolygonMesh(mesh, Mat(), id);
-}
-
-bool cv::viz::Viz3d::addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id)
-{
-    return impl_->addPolylineFromPolygonMesh(mesh, id);
-}
-
-bool cv::viz::Viz3d::addPolygon(const Mat& cloud, const Color& color, const String& id)
-{
-    return impl_->addPolygon(cloud, color, id);
-}
-
 void cv::viz::Viz3d::spin() { impl_->spin(); }
 void cv::viz::Viz3d::spinOnce (int time, bool force_redraw) { impl_->spinOnce(time, force_redraw); }
 bool cv::viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
@@ -74,11 +54,10 @@ void cv::viz::Viz3d::registerKeyboardCallback(KeyboardCallback callback, void* c
 void cv::viz::Viz3d::registerMouseCallback(MouseCallback callback, void* cookie)
 { impl_->registerMouseCallback(callback, cookie); }
 
-
-
 void cv::viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose) { impl_->showWidget(id, widget, pose); }
 void cv::viz::Viz3d::removeWidget(const String &id) { impl_->removeWidget(id); }
 cv::viz::Widget cv::viz::Viz3d::getWidget(const String &id) const { return impl_->getWidget(id); }
+void cv::viz::Viz3d::removeAllWidgets() { impl_->removeAllWidgets(); }
 void cv::viz::Viz3d::setWidgetPose(const String &id, const Affine3f &pose) { impl_->setWidgetPose(id, pose); }
 void cv::viz::Viz3d::updateWidgetPose(const String &id, const Affine3f &pose) { impl_->updateWidgetPose(id, pose); }
 cv::Affine3f cv::viz::Viz3d::getWidgetPose(const String &id) const { return impl_->getWidgetPose(id); }
@@ -88,9 +67,26 @@ cv::viz::Camera cv::viz::Viz3d::getCamera() const { return impl_->getCamera(); }
 void cv::viz::Viz3d::setViewerPose(const Affine3f &pose) { impl_->setViewerPose(pose); }
 cv::Affine3f cv::viz::Viz3d::getViewerPose() { return impl_->getViewerPose(); }
 
+void cv::viz::Viz3d::resetCameraViewpoint (const String &id) { impl_->resetCameraViewpoint(id); }
+void cv::viz::Viz3d::resetCamera() { impl_->resetCamera(); }
+
 void cv::viz::Viz3d::convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord) { impl_->convertToWindowCoordinates(pt, window_coord); }
 void cv::viz::Viz3d::converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction) { impl_->converTo3DRay(window_coord, origin, direction); }
 
 cv::Size cv::viz::Viz3d::getWindowSize() const { return impl_->getWindowSize(); }
 void cv::viz::Viz3d::setWindowSize(const Size &window_size) { impl_->setWindowSize(window_size.width, window_size.height); }
-cv::String cv::viz::Viz3d::getWindowName() const { return impl_->getWindowName(); }
+cv::String cv::viz::Viz3d::getWindowName() const { return impl_->getWindowName(); }
\ No newline at end of file
+void cv::viz::Viz3d::saveScreenshot (const String &file) { impl_->saveScreenshot(file); }
+void cv::viz::Viz3d::setWindowPosition (int x, int y) { impl_->setWindowPosition(x,y); }
+void cv::viz::Viz3d::setFullScreen (bool mode) { impl_->setFullScreen(mode); }
+void cv::viz::Viz3d::setBackgroundColor(const Color& color) { impl_->setBackgroundColor(color); }
+
+void cv::viz::Viz3d::setRenderingProperty(const String &id, int property, double value) { getWidget(id).setRenderingProperty(property, value); }
+double cv::viz::Viz3d::getRenderingProperty(const String &id, int property) { return getWidget(id).getRenderingProperty(property); }
+
+void cv::viz::Viz3d::setDesiredUpdateRate(double time) { impl_->setDesiredUpdateRate(time); }
+double cv::viz::Viz3d::getDesiredUpdateRate() { return impl_->getDesiredUpdateRate(); }
+
+void cv::viz::Viz3d::setRepresentationToSurface() { impl_->setRepresentationToSurface(); }
+void cv::viz::Viz3d::setRepresentationToWireframe() { impl_->setRepresentationToWireframe(); }
+void cv::viz::Viz3d::setRepresentationToPoints() { impl_->setRepresentationToPoints(); }
\ No newline at end of file

modules/viz/src/viz3d_impl.cpp

 #include "precomp.hpp"
 #include "viz3d_impl.hpp"
 
-#include <vtkRenderWindowInteractor.h>
 #ifndef __APPLE__
 vtkRenderWindowInteractor* vtkRenderWindowInteractorFixNew ()
 {
@@ -12,8 +11,6 @@ vtkRenderWindowInteractor* vtkRenderWindowInteractorFixNew ()
 /////////////////////////////////////////////////////////////////////////////////////////////
 cv::viz::Viz3d::VizImpl::VizImpl (const std::string &name)
     :  style_ (vtkSmartPointer<cv::viz::InteractorStyle>::New ())
-    , cloud_actor_map_ (new CloudActorMap)
-    , shape_actor_map_ (new ShapeActorMap)
     , widget_actor_map_ (new WidgetActorMap)
     , s_lastDone_(0.0)
 {
@@ -31,15 +28,12 @@ cv::viz::Viz3d::VizImpl::VizImpl (const std::string &name)
     // Create the interactor style
     style_->Initialize ();
     style_->setRenderer (renderer_);
-    style_->setCloudActorMap (cloud_actor_map_);
+    style_->setWidgetActorMap (widget_actor_map_);
     style_->UseTimersOn ();
 
     /////////////////////////////////////////////////
     interactor_ = vtkSmartPointer <vtkRenderWindowInteractor>::Take (vtkRenderWindowInteractorFixNew ());
 
-    //win_->PointSmoothingOn ();
-    //win_->LineSmoothingOn ();
-    //win_->PolygonSmoothingOn ();
     window_->AlphaBitPlanesOff ();
     window_->PointSmoothingOff ();
     window_->LineSmoothingOff ();
@@ -49,7 +43,6 @@ cv::viz::Viz3d::VizImpl::VizImpl (const std::string &name)
 
     interactor_->SetRenderWindow (window_);
     interactor_->SetInteractorStyle (style_);
-    //interactor_->SetStillUpdateRate (30.0);
     interactor_->SetDesiredUpdateRate (30.0);
 
     // Initialize and create timer, also create window
@@ -88,193 +81,173 @@ cv::viz::Viz3d::VizImpl::~VizImpl ()
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::saveScreenshot (const std::string &file) { style_->saveScreenshot (file); }
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::registerMouseCallback(MouseCallback callback, void* cookie)
-{ style_->registerMouseCallback(callback, cookie); }
+void cv::viz::Viz3d::VizImpl::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
+{
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    if (exists)
+    {
+        // Remove it if it exists and add it again
+        removeActorFromRenderer(wam_itr->second);
+    }
+    // Get the actor and set the user matrix
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(widget));
+    if (actor)
+    {
+        // If the actor is 3D, apply pose
+        vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
+        actor->SetUserMatrix (matrix);
+        actor->Modified();
+    }
+    // If the actor is a vtkFollower, then it should always face the camera
+    vtkFollower *follower = vtkFollower::SafeDownCast(actor);
+    if (follower)
+    {
+        follower->SetCamera(renderer_->GetActiveCamera());
+    }
 
-void cv::viz::Viz3d::VizImpl::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
-{ style_->registerKeyboardCallback(callback, cookie); }
+    renderer_->AddActor(WidgetAccessor::getProp(widget));
+    (*widget_actor_map_)[id] = WidgetAccessor::getProp(widget);
+}
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::spin ()
+void cv::viz::Viz3d::VizImpl::removeWidget(const String &id)
 {
-    resetStoppedFlag ();
-    window_->Render ();
-    interactor_->Start ();
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
+    CV_Assert("Widget could not be removed." && removeActorFromRenderer (wam_itr->second));
+    widget_actor_map_->erase(wam_itr);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::spinOnce (int time, bool force_redraw)
+cv::viz::Widget cv::viz::Viz3d::VizImpl::getWidget(const String &id) const
 {
-    resetStoppedFlag ();
-
-    if (time <= 0)
-        time = 1;
-
-    if (force_redraw)
-        interactor_->Render ();
-
-    double s_now_ = cv::getTickCount() / cv::getTickFrequency();
-    if (s_lastDone_ > s_now_)
-      s_lastDone_ = s_now_;
+    WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
 
-    if ((s_now_ - s_lastDone_) > (1.0 / interactor_->GetDesiredUpdateRate ()))
-    {
-        exit_main_loop_timer_callback_->right_timer_id = interactor_->CreateRepeatingTimer (time);
-        interactor_->Start ();
-        interactor_->DestroyTimer (exit_main_loop_timer_callback_->right_timer_id);
-        s_lastDone_ = s_now_;
-    }
+    Widget widget;
+    WidgetAccessor::setProp(widget, wam_itr->second);
+    return widget;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::removePointCloud (const std::string &id)
+void cv::viz::Viz3d::VizImpl::setWidgetPose(const String &id, const Affine3f &pose)
 {
-    CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
-    if (am_it == cloud_actor_map_->end ())
-        return false;
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
 
-    if (removeActorFromRenderer (am_it->second.actor))
-        return cloud_actor_map_->erase (am_it), true;
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second);
+    CV_Assert("Widget is not 3D." && actor);
 
-    return false;
+    vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
+    actor->SetUserMatrix (matrix);
+    actor->Modified ();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::removeShape (const std::string &id)
+void cv::viz::Viz3d::VizImpl::updateWidgetPose(const String &id, const Affine3f &pose)
 {
-    // Check to see if the given ID entry exists
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    // Extra step: check if there is a cloud with the same ID
-    CloudActorMap::iterator ca_it = cloud_actor_map_->find (id);
-
-    bool shape = true;
-    // Try to find a shape first
-    if (am_it == shape_actor_map_->end ())
-    {
-        // There is no cloud or shape with this ID, so just exit
-        if (ca_it == cloud_actor_map_->end ())
-            return false;
-        // Cloud found, set shape to false
-        shape = false;
-    }
+    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
 
-    // Remove the pointer/ID pair to the global actor map
-    if (shape)
-    {
-        if (removeActorFromRenderer (am_it->second))
-        {
-            shape_actor_map_->erase (am_it);
-            return (true);
-        }
-    }
-    else
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second);
+    CV_Assert("Widget is not 3D." && actor);
+
+    vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
+    if (!matrix)
     {
-        if (removeActorFromRenderer (ca_it->second.actor))
-        {
-            cloud_actor_map_->erase (ca_it);
-            return true;
-        }
+        setWidgetPose(id, pose);
+        return ;
     }
-    return false;
+    Matx44f matrix_cv = convertToMatx(matrix);
+    Affine3f updated_pose = pose * Affine3f(matrix_cv);
+    matrix = convertToVtkMatrix(updated_pose.matrix);
+
+    actor->SetUserMatrix (matrix);
+    actor->Modified ();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::removeText3D (const std::string &id)
+cv::Affine3f cv::viz::Viz3d::VizImpl::getWidgetPose(const String &id) const
 {
-    // Check to see if the given ID entry exists
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it == shape_actor_map_->end ())
-        return false;
+    WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
+    bool exists = wam_itr != widget_actor_map_->end();
+    CV_Assert("Widget does not exist." && exists);
 
-    // Remove it from all renderers
-    if (removeActorFromRenderer (am_it->second))
-        return shape_actor_map_->erase (am_it), true;
+    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second);
+    CV_Assert("Widget is not 3D." && actor);
 
-    return false;
+    vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
+    Matx44f matrix_cv = convertToMatx(matrix);
+    return Affine3f(matrix_cv);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::removeAllPointClouds ()
+void cv::viz::Viz3d::VizImpl::setDesiredUpdateRate(double time)
 {
-    // Check to see if the given ID entry exists
-    CloudActorMap::iterator am_it = cloud_actor_map_->begin ();
-    while (am_it != cloud_actor_map_->end () )
-    {
-        if (removePointCloud (am_it->first))
-            am_it = cloud_actor_map_->begin ();
-        else
-            ++am_it;
-    }
-    return (true);
+    if (interactor_)
+        interactor_->SetDesiredUpdateRate(time);
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::removeAllShapes ()
+double cv::viz::Viz3d::VizImpl::getDesiredUpdateRate()
 {
-    // Check to see if the given ID entry exists
-    ShapeActorMap::iterator am_it = shape_actor_map_->begin ();
-    while (am_it != shape_actor_map_->end ())
-    {
-        if (removeShape (am_it->first))
-            am_it = shape_actor_map_->begin ();
-        else
-            ++am_it;
-    }
-    return (true);
+    if (interactor_)
+        return interactor_->GetDesiredUpdateRate();
+    return 0.0;
 }
 
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::saveScreenshot (const std::string &file) { style_->saveScreenshot (file); }
 
-//////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkLODActor> &actor)
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::registerMouseCallback(MouseCallback callback, void* cookie)
+{ style_->registerMouseCallback(callback, cookie); }
+
+void cv::viz::Viz3d::VizImpl::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
+{ style_->registerKeyboardCallback(callback, cookie); }
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::spin ()
 {
-    vtkLODActor* actor_to_remove = vtkLODActor::SafeDownCast (actor);
+    resetStoppedFlag ();
+    window_->Render ();
+    interactor_->Start ();
+}
 
+/////////////////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::spinOnce (int time, bool force_redraw)
+{
+    resetStoppedFlag ();
 
+    if (time <= 0)
+        time = 1;
 
-    // Iterate over all actors in this renderer
-    vtkPropCollection* actors = renderer_->GetViewProps ();
-    actors->InitTraversal ();
+    if (force_redraw)
+        interactor_->Render ();
 
-    vtkProp* current_actor = NULL;
-    while ((current_actor = actors->GetNextProp ()) != NULL)
+    double s_now_ = cv::getTickCount() / cv::getTickFrequency();
+    if (s_lastDone_ > s_now_)
+      s_lastDone_ = s_now_;
+
+    if ((s_now_ - s_lastDone_) > (1.0 / interactor_->GetDesiredUpdateRate ()))
     {
-        if (current_actor != actor_to_remove)
-            continue;
-        renderer_->RemoveActor (actor);
-        //        renderer->Render ();
-        // Found the correct viewport and removed the actor
-        return (true);
+        exit_main_loop_timer_callback_->right_timer_id = interactor_->CreateRepeatingTimer (time);
+        interactor_->Start ();
+        interactor_->DestroyTimer (exit_main_loop_timer_callback_->right_timer_id);
+        s_lastDone_ = s_now_;
     }
-
-    return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkActor> &actor)
+void cv::viz::Viz3d::VizImpl::removeAllWidgets()
 {
-    vtkActor* actor_to_remove = vtkActor::SafeDownCast (actor);
-
-    // Add it to all renderers
-    //rens_->InitTraversal ();
-
-
-        // Iterate over all actors in this renderer
-    vtkPropCollection* actors = renderer_->GetViewProps ();
-    actors->InitTraversal ();
-    vtkProp* current_actor = NULL;
-    while ((current_actor = actors->GetNextProp ()) != NULL)
-    {
-        if (current_actor != actor_to_remove)
-            continue;
-        renderer_->RemoveActor (actor);
-        //        renderer->Render ();
-        // Found the correct viewport and removed the actor
-        return (true);
-    }
-    return false;
+    widget_actor_map_->clear();
+    renderer_->RemoveAllViewProps();
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
@@ -341,226 +314,6 @@ void cv::viz::Viz3d::VizImpl::setBackgroundColor (const Color& color)
     renderer_->SetBackground (c.val);
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::getPointCloudRenderingProperties (int property, double &value, const std::string &id)
-{
-    CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
-    if (am_it == cloud_actor_map_->end ())
-        return false;
-
-    vtkLODActor* actor = vtkLODActor::SafeDownCast (am_it->second.actor);
-
-    switch (property)
-    {
-        case VIZ_POINT_SIZE:
-        {
-            value = actor->GetProperty ()->GetPointSize ();
-            actor->Modified ();
-            break;
-        }
-        case VIZ_OPACITY:
-        {
-            value = actor->GetProperty ()->GetOpacity ();
-            actor->Modified ();
-            break;
-        }
-        case VIZ_LINE_WIDTH:
-        {
-            value = actor->GetProperty ()->GetLineWidth ();
-            actor->Modified ();
-            break;
-        }
-        default:
-            CV_Assert("getPointCloudRenderingProperties: Unknown property");
-    }
-
-    return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::setPointCloudRenderingProperties (int property, double value, const std::string &id)
-{
-    CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
-    if (am_it == cloud_actor_map_->end ())
-        return std::cout << "[setPointCloudRenderingProperties] Could not find any PointCloud datasets with id <" << id << ">!" << std::endl, false;
-
-    vtkLODActor* actor = vtkLODActor::SafeDownCast (am_it->second.actor);
-
-    switch (property)
-    {
-        case VIZ_POINT_SIZE:
-        {
-            actor->GetProperty ()->SetPointSize (float (value));
-            actor->Modified ();
-            break;
-        }
-        case VIZ_OPACITY:
-        {
-            actor->GetProperty ()->SetOpacity (value);
-            actor->Modified ();
-            break;
-        }
-            // Turn on/off flag to control whether data is rendered using immediate
-            // mode or note. Immediate mode rendering tends to be slower but it can
-            // handle larger datasets. The default value is immediate mode off. If you
-            // are having problems rendering a large dataset you might want to consider
-            // using immediate more rendering.
-        case VIZ_IMMEDIATE_RENDERING:
-        {
-            actor->GetMapper ()->SetImmediateModeRendering (int (value));
-            actor->Modified ();
-            break;
-        }
-        case VIZ_LINE_WIDTH:
-        {
-            actor->GetProperty ()->SetLineWidth (float (value));
-            actor->Modified ();
-            break;
-        }
-        default:
-            CV_Assert("setPointCloudRenderingProperties: Unknown property");
-    }
-    return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::setPointCloudSelected (const bool selected, const std::string &id)
-{
-    CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
-    if (am_it == cloud_actor_map_->end ())
-        return std::cout << "[setPointCloudRenderingProperties] Could not find any PointCloud datasets with id <" << id << ">!" << std::endl, false;
-
-    vtkLODActor* actor = vtkLODActor::SafeDownCast (am_it->second.actor);
-    if (selected)
-    {
-        actor->GetProperty ()->EdgeVisibilityOn ();
-        actor->GetProperty ()->SetEdgeColor (1.0, 0.0, 0.0);
-        actor->Modified ();
-    }
-    else
-    {
-        actor->GetProperty ()->EdgeVisibilityOff ();
-        actor->Modified ();
-    }
-
-    return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::setShapeRenderingProperties (int property, double value, const std::string &id)
-{
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it == shape_actor_map_->end ())
-        return std::cout << "[setShapeRenderingProperties] Could not find any shape with id <" << id << ">!\n" << std::endl, false;
-
-    vtkActor* actor = vtkActor::SafeDownCast (am_it->second);
-
-    switch (property)
-    {
-    case VIZ_POINT_SIZE:
-    {
-        actor->GetProperty ()->SetPointSize (float (value));
-        actor->Modified ();
-        break;
-    }
-    case VIZ_OPACITY:
-    {
-        actor->GetProperty ()->SetOpacity (value);
-        actor->Modified ();
-        break;
-    }
-    case VIZ_LINE_WIDTH:
-    {
-        actor->GetProperty ()->SetLineWidth (float (value));
-        actor->Modified ();
-        break;
-    }
-    case VIZ_FONT_SIZE:
-    {
-        vtkTextActor* text_actor = vtkTextActor::SafeDownCast (am_it->second);
-        vtkSmartPointer<vtkTextProperty> tprop = text_actor->GetTextProperty ();
-        tprop->SetFontSize (int (value));
-        text_actor->Modified ();
-        break;
-    }
-    case VIZ_REPRESENTATION:
-    {
-        switch (int (value))
-        {
-            case REPRESENTATION_POINTS:    actor->GetProperty ()->SetRepresentationToPoints (); break;
-            case REPRESENTATION_WIREFRAME: actor->GetProperty ()->SetRepresentationToWireframe (); break;
-            case REPRESENTATION_SURFACE:   actor->GetProperty ()->SetRepresentationToSurface ();  break;
-        }
-        actor->Modified ();
-        break;
-    }
-    case VIZ_SHADING:
-    {
-        switch (int (value))
-        {
-        case SHADING_FLAT: actor->GetProperty ()->SetInterpolationToFlat (); break;
-        case SHADING_GOURAUD:
-        {
-            if (!actor->GetMapper ()->GetInput ()->GetPointData ()->GetNormals ())
-            {
-                std::cout << "[cv::viz::PCLVisualizer::setShapeRenderingProperties] Normals do not exist in the dataset, but Gouraud shading was requested. Estimating normals...\n" << std::endl;
-
-                vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New ();
-                normals->SetInput (actor->GetMapper ()->GetInput ());
-                normals->Update ();
-                vtkDataSetMapper::SafeDownCast (actor->GetMapper ())->SetInput (normals->GetOutput ());
-            }
-            actor->GetProperty ()->SetInterpolationToGouraud ();
-            break;
-        }
-        case SHADING_PHONG:
-        {
-            if (!actor->GetMapper ()->GetInput ()->GetPointData ()->GetNormals ())
-            {
-                std::cout << "[cv::viz::PCLVisualizer::setShapeRenderingProperties] Normals do not exist in the dataset, but Phong shading was requested. Estimating normals...\n" << std::endl;
-                vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New ();
-                normals->SetInput (actor->GetMapper ()->GetInput ());
-                normals->Update ();
-                vtkDataSetMapper::SafeDownCast (actor->GetMapper ())->SetInput (normals->GetOutput ());
-            }
-            actor->GetProperty ()->SetInterpolationToPhong ();
-            break;
-        }
-        }
-        actor->Modified ();
-        break;
-    }
-    default:
-        CV_Assert("setShapeRenderingProperties: Unknown property");
-
-    }
-    return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::initCameraParameters ()
-{
-    Vec2i window_size(window_->GetScreenSize());
-    window_size /= 2;
-    
-    Camera camera_temp(Vec2f(0.0,0.8575), Size(window_size[0], window_size[1]));
-    setCamera(camera_temp);
-    setViewerPose(makeCameraPose(Vec3f(0.0f,0.0f,0.0f), Vec3f(0.0f, 0.0f, 1.0f), Vec3f(0.0f, 1.0f, 0.0f)));
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::cameraParamsSet () const { return (camera_set_); }
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::updateCamera ()
-{
-    std::cout << "[cv::viz::PCLVisualizer::updateCamera()] This method was deprecated, just re-rendering all scenes now." << std::endl;
-    //rens_->InitTraversal ();
-    // Update the camera parameters
-
-    renderer_->Render ();
-}
-
 /////////////////////////////////////////////////////////////////////////////////////////////
 void cv::viz::Viz3d::VizImpl::setCamera(const Camera &camera)
 {
@@ -668,29 +421,21 @@ void cv::viz::Viz3d::VizImpl::converTo3DRay(const Point3d &window_coord, Point3d
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::resetCamera ()
-{
-    renderer_->ResetCamera ();
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::resetCameraViewpoint (const std::string &id)
+void cv::viz::Viz3d::VizImpl::resetCameraViewpoint (const String &id)
 {
-    // TODO Cloud actor is not used
     vtkSmartPointer<vtkMatrix4x4> camera_pose;
-    static CloudActorMap::iterator it = cloud_actor_map_->find (id);
-    if (it != cloud_actor_map_->end ())
-        camera_pose = it->second.viewpoint_transformation_;
+    static WidgetActorMap::iterator it = widget_actor_map_->find (id);
+    if (it != widget_actor_map_->end ())
+    {
+        vtkProp3D *actor = vtkProp3D::SafeDownCast(it->second);
+        CV_Assert("Widget is not 3D." && actor);
+        camera_pose = actor->GetUserMatrix();
+    }
     else
         return;
 
     // Prevent a segfault
-    if (!camera_pose)
-        return;
-
-    // set all renderer to this viewpoint
-    //rens_->InitTraversal ();
-
+    if (!camera_pose) return;
 
     vtkSmartPointer<vtkCamera> cam = renderer_->GetActiveCamera ();
     cam->SetPosition (camera_pose->GetElement (0, 3),
@@ -710,176 +455,40 @@ void cv::viz::Viz3d::VizImpl::resetCameraViewpoint (const std::string &id)
     renderer_->Render ();
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, const std::string & id)
-{
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it != shape_actor_map_->end ())
-    {
-        std::cout << "[addModelFromPolyData] A shape with id <" << id << "> already exists! Please choose a different id and retry." << std::endl;
-        return (false);
-    }
-
-    vtkSmartPointer<vtkLODActor> actor;
-    createActorFromVTKDataSet (polydata, actor);
-    actor->GetProperty ()->SetRepresentationToWireframe ();
-    renderer_->AddActor(actor);
-
-    // Save the pointer/ID pair to the global actor map
-    (*shape_actor_map_)[id] = actor;
-    return (true);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, vtkSmartPointer<vtkTransform> transform, const std::string & id)
-{
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it != shape_actor_map_->end ())
-    {
-        std::cout << "[addModelFromPolyData] A shape with id <"<<id<<"> already exists! Please choose a different id and retry." << std::endl;
-        return (false);
-    }
-
-    vtkSmartPointer <vtkTransformFilter> trans_filter = vtkSmartPointer<vtkTransformFilter>::New ();
-    trans_filter->SetTransform (transform);
-    trans_filter->SetInput (polydata);
-    trans_filter->Update();
-
-    // Create an Actor
-    vtkSmartPointer <vtkLODActor> actor;
-    createActorFromVTKDataSet (trans_filter->GetOutput (), actor);
-    actor->GetProperty ()->SetRepresentationToWireframe ();
-    renderer_->AddActor(actor);
-
-    // Save the pointer/ID pair to the global actor map
-    (*shape_actor_map_)[id] = actor;
-    return (true);
-}
-
-
-////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::addModelFromPLYFile (const std::string &filename, const std::string &id)
-{
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it != shape_actor_map_->end ())
-        return std::cout << "[addModelFromPLYFile] A shape with id <"<<id<<"> already exists! Please choose a different id and retry.." << std::endl, false;
-
-    vtkSmartPointer<vtkPLYReader> reader = vtkSmartPointer<vtkPLYReader>::New ();
-    reader->SetFileName (filename.c_str ());
-
-    vtkSmartPointer<vtkLODActor> actor;
-    createActorFromVTKDataSet (reader->GetOutput (), actor);
-    actor->GetProperty ()->SetRepresentationToWireframe ();
-    renderer_->AddActor(actor);
-
-    (*shape_actor_map_)[id] = actor;
-    return true;
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::addModelFromPLYFile (const std::string &filename, vtkSmartPointer<vtkTransform> transform, const std::string &id)
-{
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it != shape_actor_map_->end ())
-        return std::cout << "[addModelFromPLYFile] A shape with id <"<<id<<"> already exists! Please choose a different id and retry." << std::endl, false;
-
-    vtkSmartPointer <vtkPLYReader > reader = vtkSmartPointer<vtkPLYReader>::New ();
-    reader->SetFileName (filename.c_str ());
-
-    vtkSmartPointer <vtkTransformFilter> trans_filter = vtkSmartPointer<vtkTransformFilter>::New ();
-    trans_filter->SetTransform (transform);
-    trans_filter->SetInputConnection (reader->GetOutputPort ());
-
-    vtkSmartPointer <vtkLODActor> actor;
-    createActorFromVTKDataSet (trans_filter->GetOutput (), actor);
-    actor->GetProperty ()->SetRepresentationToWireframe ();
-    renderer_->AddActor(actor);
-
-    (*shape_actor_map_)[id] = actor;
-    return (true);
-}
-
-bool cv::viz::Viz3d::VizImpl::addPolylineFromPolygonMesh (const Mesh3d& /*mesh*/, const std::string &/*id*/)
+///////////////////////////////////////////////////////////////////////////////////
+void cv::viz::Viz3d::VizImpl::resetCamera()
 {
-//     CV_Assert(mesh.cloud.rows == 1 && mesh.cloud.type() == CV_32FC3);
-// 
-//     ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-//     if (am_it != shape_actor_map_->end ())
-//         return std::cout << "[addPolylineFromPolygonMesh] A shape with id <"<< id << "> already exists! Please choose a different id and retry.\n" << std::endl, false;
-// 
-//     vtkSmartPointer<vtkPoints> poly_points = vtkSmartPointer<vtkPoints>::New ();
-//     poly_points->SetNumberOfPoints (mesh.cloud.size().area());
-// 
-//     const cv::Point3f *cdata = mesh.cloud.ptr<cv::Point3f>();
-//     for (int i = 0; i < mesh.cloud.cols; ++i)
-//         poly_points->InsertPoint (i, cdata[i].x, cdata[i].y,cdata[i].z);
-// 
-// 
-//     // Create a cell array to store the lines in and add the lines to it
-//     vtkSmartPointer <vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New ();
-//     vtkSmartPointer <vtkPolyData> polyData;
-//     allocVtkPolyData (polyData);
-// 
-//     for (size_t i = 0; i < mesh.polygons.size (); i++)
-//     {
-//         vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
-//         polyLine->GetPointIds()->SetNumberOfIds(mesh.polygons[i].vertices.size());
-//         for(unsigned int k = 0; k < mesh.polygons[i].vertices.size(); k++)
-//         {
-//             polyLine->GetPointIds()->SetId(k,mesh. polygons[i].vertices[k]);
-//         }
-// 
-//         cells->InsertNextCell (polyLine);
-//     }
-// 
-//     // Add the points to the dataset
-//     polyData->SetPoints (poly_points);
-// 
-//     // Add the lines to the dataset
-//     polyData->SetLines (cells);
-// 
-//     // Setup actor and mapper
-//     vtkSmartPointer < vtkPolyDataMapper > mapper = vtkSmartPointer<vtkPolyDataMapper>::New ();
-//     mapper->SetInput (polyData);
-// 
-//     vtkSmartPointer <vtkActor> actor = vtkSmartPointer<vtkActor>::New ();
-//     actor->SetMapper (mapper);
-//     renderer_->AddActor(actor);
-// 
-//     // Save the pointer/ID pair to the global actor map
-//     (*shape_actor_map_)[id] = actor;
-    return (true);
+    renderer_->ResetCamera();
 }
 
-
 ///////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::setRepresentationToSurfaceForAllActors ()
+void cv::viz::Viz3d::VizImpl::setRepresentationToSurface()
 {
-    vtkActorCollection * actors = renderer_->GetActors ();
-    actors->InitTraversal ();
+    vtkActorCollection * actors = renderer_->GetActors();
+    actors->InitTraversal();
     vtkActor * actor;
-    while ((actor = actors->GetNextActor ()) != NULL)
-        actor->GetProperty ()->SetRepresentationToSurface ();
+    while ((actor = actors->GetNextActor()) != NULL)
+        actor->GetProperty()->SetRepresentationToSurface();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::setRepresentationToPointsForAllActors ()
+void cv::viz::Viz3d::VizImpl::setRepresentationToPoints()
 {
-    vtkActorCollection * actors = renderer_->GetActors ();
-    actors->InitTraversal ();
+    vtkActorCollection * actors = renderer_->GetActors();
+    actors->InitTraversal();
     vtkActor * actor;
-    while ((actor = actors->GetNextActor ()) != NULL)
-        actor->GetProperty ()->SetRepresentationToPoints ();
+    while ((actor = actors->GetNextActor()) != NULL)
+        actor->GetProperty()->SetRepresentationToPoints();
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::setRepresentationToWireframeForAllActors ()
+void cv::viz::Viz3d::VizImpl::setRepresentationToWireframe()
 {
-    vtkActorCollection * actors = renderer_->GetActors ();
-    actors->InitTraversal ();
+    vtkActorCollection * actors = renderer_->GetActors();
+    actors->InitTraversal();
     vtkActor *actor;
-    while ((actor = actors->GetNextActor ()) != NULL)
-        actor->GetProperty ()->SetRepresentationToWireframe ();
+    while ((actor = actors->GetNextActor()) != NULL)
+        actor->GetProperty()->SetRepresentationToWireframe();
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
@@ -926,595 +535,19 @@ void cv::viz::Viz3d::VizImpl::updateCells (vtkSmartPointer<vtkIdTypeArray> &cell
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::allocVtkPolyData (vtkSmartPointer<vtkAppendPolyData> &polydata)
-{polydata = vtkSmartPointer<vtkAppendPolyData>::New (); }
-
-void cv::viz::Viz3d::VizImpl::allocVtkPolyData (vtkSmartPointer<vtkPolyData> &polydata)
-{ polydata = vtkSmartPointer<vtkPolyData>::New (); }
-
-void cv::viz::Viz3d::VizImpl::allocVtkUnstructuredGrid (vtkSmartPointer<vtkUnstructuredGrid> &polydata)
-{ polydata = vtkSmartPointer<vtkUnstructuredGrid>::New (); }
-
-//////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<float> &orientation, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix)
-{
-    // set rotation
-    Eigen::Matrix3f rot = orientation.toRotationMatrix ();
-    for (int i = 0; i < 3; i++)
-        for (int k = 0; k < 3; k++)
-            vtk_matrix->SetElement (i, k, rot (i, k));
-
-    // set translation
-    vtk_matrix->SetElement (0, 3, origin (0));
-    vtk_matrix->SetElement (1, 3, origin (1));
-    vtk_matrix->SetElement (2, 3, origin (2));
-    vtk_matrix->SetElement (3, 3, 1.0f);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////////////////////
-
 void cv::viz::Viz3d::VizImpl::setFullScreen (bool mode)
 {
     if (window_)
         window_->SetFullScreen (mode);
 }
 
-void cv::viz::Viz3d::VizImpl::setWindowName (const std::string &name)
-{
-    if (window_)
-        window_->SetWindowName (name.c_str ());
-}
-
+//////////////////////////////////////////////////////////////////////////////////////////////
 cv::String cv::viz::Viz3d::VizImpl::getWindowName() const
 {
     return (window_ ? window_->GetWindowName() : "");
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////
 void cv::viz::Viz3d::VizImpl::setWindowPosition (int x, int y) { window_->SetPosition (x, y); }
 void cv::viz::Viz3d::VizImpl::setWindowSize (int xw, int yw) { window_->SetSize (xw, yw); }
 cv::Size cv::viz::Viz3d::VizImpl::getWindowSize() const { return Size(window_->GetSize()[0], window_->GetSize()[1]); }
-
-bool cv::viz::Viz3d::VizImpl::addPolygonMesh (const Mesh3d& /*mesh*/, const Mat& /*mask*/, const std::string &/*id*/)
-{
-//     CV_Assert(mesh.cloud.type() == CV_32FC3 && mesh.cloud.rows == 1 && !mesh.polygons.empty ());
-//     CV_Assert(mesh.colors.empty() || (!mesh.colors.empty() && mesh.colors.size() == mesh.cloud.size() && mesh.colors.type() == CV_8UC3));
-//     CV_Assert(mask.empty() || (!mask.empty() && mask.size() == mesh.cloud.size() && mask.type() == CV_8U));
-// 
-//     if (cloud_actor_map_->find (id) != cloud_actor_map_->end ())
-//         return std::cout << "[addPolygonMesh] A shape with id <" << id << "> already exists! Please choose a different id and retry." << std::endl, false;
-// 
-//     //    int rgb_idx = -1;
-//     //    std::vector<sensor_msgs::PointField> fields;
-// 
-// 
-//     //    rgb_idx = temp_viz::getFieldIndex (*cloud, "rgb", fields);
-//     //    if (rgb_idx == -1)
-//     //      rgb_idx = temp_viz::getFieldIndex (*cloud, "rgba", fields);
-// 
-//     vtkSmartPointer<vtkUnsignedCharArray> colors_array;
-// #if 1
-//     if (!mesh.colors.empty())
-//     {
-//         colors_array = vtkSmartPointer<vtkUnsignedCharArray>::New ();
-//         colors_array->SetNumberOfComponents (3);
-//         colors_array->SetName ("Colors");
-// 
-//         const unsigned char* data = mesh.colors.ptr<unsigned char>();
-// 
-//         //TODO check mask
-//         CV_Assert(mask.empty()); //because not implemented;
-// 
-//         for(int i = 0; i < mesh.colors.cols; ++i)
-//             colors_array->InsertNextTupleValue(&data[i*3]);
-// 
-//         //      temp_viz::RGB rgb_data;
-//         //      for (size_t i = 0; i < cloud->size (); ++i)
-//         //      {
-//         //        if (!isFinite (cloud->points[i]))
-//         //          continue;
-//         //        memcpy (&rgb_data, reinterpret_cast<const char*> (&cloud->points[i]) + fields[rgb_idx].offset, sizeof (temp_viz::RGB));
-//         //        unsigned char color[3];
-//         //        color[0] = rgb_data.r;
-//         //        color[1] = rgb_data.g;
-//         //        color[2] = rgb_data.b;
-//         //        colors->InsertNextTupleValue (color);
-//         //      }
-//     }
-// #endif
-// 
-//     // Create points from polyMesh.cloud
-//     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New ();
-//     vtkIdType nr_points = mesh.cloud.size().area();
-// 
-//     points->SetNumberOfPoints (nr_points);
-// 
-// 
-//     // Get a pointer to the beginning of the data array
-//     float *data = static_cast<vtkFloatArray*> (points->GetData ())->GetPointer (0);
-// 
-// 
-//     std::vector<int> lookup;
-//     // If the dataset is dense (no NaNs)
-//     if (mask.empty())
-//     {
-//         cv::Mat hdr(mesh.cloud.size(), CV_32FC3, (void*)data);
-//         mesh.cloud.copyTo(hdr);
-//     }
-//     else
-//     {
-//         lookup.resize (nr_points);
-// 
-//         const unsigned char *mdata = mask.ptr<unsigned char>();
-//         const cv::Point3f *cdata = mesh.cloud.ptr<cv::Point3f>();
-//         cv::Point3f* out = reinterpret_cast<cv::Point3f*>(data);
-// 
-//         int j = 0;    // true point index
-//         for (int i = 0; i < nr_points; ++i)
-//             if(mdata[i])
-//             {
-//                 lookup[i] = j;
-//                 out[j++] = cdata[i];
-//             }
-//         nr_points = j;
-//         points->SetNumberOfPoints (nr_points);
-//     }
-// 
-//     // Get the maximum size of a polygon
-//     int max_size_of_polygon = -1;
-//     for (size_t i = 0; i < mesh.polygons.size (); ++i)
-//         if (max_size_of_polygon < static_cast<int> (mesh.polygons[i].vertices.size ()))
-//             max_size_of_polygon = static_cast<int> (mesh.polygons[i].vertices.size ());
-// 
-//     vtkSmartPointer<vtkLODActor> actor;
-// 
-//     if (mesh.polygons.size () > 1)
-//     {
-//         // Create polys from polyMesh.polygons
-//         vtkSmartPointer<vtkCellArray> cell_array = vtkSmartPointer<vtkCellArray>::New ();
-//         vtkIdType *cell = cell_array->WritePointer (mesh.polygons.size (), mesh.polygons.size () * (max_size_of_polygon + 1));
-//         int idx = 0;
-//         if (lookup.size () > 0)
-//         {
-//             for (size_t i = 0; i < mesh.polygons.size (); ++i, ++idx)
-//             {
-//                 size_t n_points = mesh.polygons[i].vertices.size ();
-//                 *cell++ = n_points;
-//                 //cell_array->InsertNextCell (n_points);
-//                 for (size_t j = 0; j < n_points; j++, ++idx)
-//                     *cell++ = lookup[mesh.polygons[i].vertices[j]];
-//                 //cell_array->InsertCellPoint (lookup[vertices[i].vertices[j]]);
-//             }
-//         }
-//         else
-//         {
-//             for (size_t i = 0; i < mesh.polygons.size (); ++i, ++idx)
-//             {
-//                 size_t n_points = mesh.polygons[i].vertices.size ();
-//                 *cell++ = n_points;
-//                 //cell_array->InsertNextCell (n_points);
-//                 for (size_t j = 0; j < n_points; j++, ++idx)
-//                     *cell++ = mesh.polygons[i].vertices[j];
-//                 //cell_array->InsertCellPoint (vertices[i].vertices[j]);
-//             }
-//         }
-//         vtkSmartPointer<vtkPolyData> polydata;
-//         allocVtkPolyData (polydata);
-//         cell_array->GetData ()->SetNumberOfValues (idx);
-//         cell_array->Squeeze ();
-//         polydata->SetStrips (cell_array);
-//         polydata->SetPoints (points);
-// 
-//         if (colors_array)
-//             polydata->GetPointData ()->SetScalars (colors_array);
-// 
-//         createActorFromVTKDataSet (polydata, actor, false);
-//     }
-//     else
-//     {
-//         vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New ();
-//         size_t n_points = mesh.polygons[0].vertices.size ();
-//         polygon->GetPointIds ()->SetNumberOfIds (n_points - 1);
-// 
-//         if (lookup.size () > 0)
-//         {
-//             for (size_t j = 0; j < n_points - 1; ++j)
-//                 polygon->GetPointIds ()->SetId (j, lookup[mesh.polygons[0].vertices[j]]);
-//         }
-//         else
-//         {
-//             for (size_t j = 0; j < n_points - 1; ++j)
-//                 polygon->GetPointIds ()->SetId (j, mesh.polygons[0].vertices[j]);
-//         }
-//         vtkSmartPointer<vtkUnstructuredGrid> poly_grid;
-//         allocVtkUnstructuredGrid (poly_grid);
-//         poly_grid->Allocate (1, 1);
-//         poly_grid->InsertNextCell (polygon->GetCellType (), polygon->GetPointIds ());
-//         poly_grid->SetPoints (points);
-//         poly_grid->Update ();
-//         if (colors_array)
-//             poly_grid->GetPointData ()->SetScalars (colors_array);
-// 
-//         createActorFromVTKDataSet (poly_grid, actor, false);
-//     }
-//     renderer_->AddActor (actor);
-//     actor->GetProperty ()->SetRepresentationToSurface ();
-//     // Backface culling renders the visualization slower, but guarantees that we see all triangles
-//     actor->GetProperty ()->BackfaceCullingOff ();
-//     actor->GetProperty ()->SetInterpolationToFlat ();
-//     actor->GetProperty ()->EdgeVisibilityOff ();
-//     actor->GetProperty ()->ShadingOff ();
-// 
-//     // Save the pointer/ID pair to the global actor map
-//     (*cloud_actor_map_)[id].actor = actor;
-//     //if (vertices.size () > 1)
-//     //  (*cloud_actor_map_)[id].cells = static_cast<vtkPolyDataMapper*>(actor->GetMapper ())->GetInput ()->GetVerts ()->GetData ();
-// 
-//     const Eigen::Vector4f& sensor_origin = Eigen::Vector4f::Zero ();
-//     const Eigen::Quaternion<float>& sensor_orientation = Eigen::Quaternionf::Identity ();
-// 
-//     // Save the viewpoint transformation matrix to the global actor map
-//     vtkSmartPointer<vtkMatrix4x4> transformation = vtkSmartPointer<vtkMatrix4x4>::New();
-//     convertToVtkMatrix (sensor_origin, sensor_orientation, transformation);
-//     (*cloud_actor_map_)[id].viewpoint_transformation_ = transformation;
-// 
-//     return (true);
-return true;
-}
-
-
-bool cv::viz::Viz3d::VizImpl::updatePolygonMesh (const Mesh3d& /*mesh*/, const cv::Mat& /*mask*/, const std::string &/*id*/)
-{
-//     CV_Assert(mesh.cloud.type() == CV_32FC3 && mesh.cloud.rows == 1 && !mesh.polygons.empty ());
-//     CV_Assert(mesh.colors.empty() || (!mesh.colors.empty() && mesh.colors.size() == mesh.cloud.size() && mesh.colors.type() == CV_8UC3));
-//     CV_Assert(mask.empty() || (!mask.empty() && mask.size() == mesh.cloud.size() && mask.type() == CV_8U));
-// 
-//     // Check to see if this ID entry already exists (has it been already added to the visualizer?)
-//     CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
-//     if (am_it == cloud_actor_map_->end ())
-//         return (false);
-// 
-//     // Get the current poly data
-//     vtkSmartPointer<vtkPolyData> polydata = static_cast<vtkPolyDataMapper*>(am_it->second.actor->GetMapper ())->GetInput ();
-//     if (!polydata)
-//         return (false);
-//     vtkSmartPointer<vtkCellArray> cells = polydata->GetStrips ();
-//     if (!cells)
-//         return (false);
-//     vtkSmartPointer<vtkPoints> points   = polydata->GetPoints ();
-//     // Copy the new point array in
-//     vtkIdType nr_points = mesh.cloud.size().area();
-//     points->SetNumberOfPoints (nr_points);
-// 
-//     // Get a pointer to the beginning of the data array
-//     float *data = (static_cast<vtkFloatArray*> (points->GetData ()))->GetPointer (0);
-// 
-//     int ptr = 0;
-//     std::vector<int> lookup;
-//     // If the dataset is dense (no NaNs)
-//     if (mask.empty())
-//     {
-//         cv::Mat hdr(mesh.cloud.size(), CV_32FC3, (void*)data);
-//         mesh.cloud.copyTo(hdr);
-// 
-//     }
-//     else
-//     {
-//         lookup.resize (nr_points);
-// 
-//         const unsigned char *mdata = mask.ptr<unsigned char>();
-//         const cv::Point3f *cdata = mesh.cloud.ptr<cv::Point3f>();
-//         cv::Point3f* out = reinterpret_cast<cv::Point3f*>(data);
-// 
-//         int j = 0;    // true point index
-//         for (int i = 0; i < nr_points; ++i)
-//             if(mdata[i])
-//             {
-//                 lookup[i] = j;
-//                 out[j++] = cdata[i];
-//             }
-//         nr_points = j;
-//         points->SetNumberOfPoints (nr_points);;
-//     }
-// 
-//     // Update colors
-//     vtkUnsignedCharArray* colors_array = vtkUnsignedCharArray::SafeDownCast (polydata->GetPointData ()->GetScalars ());
-// 
-//     if (!mesh.colors.empty() && colors_array)
-//     {
-//         if (mask.empty())
-//         {
-//             const unsigned char* data = mesh.colors.ptr<unsigned char>();
-//             for(int i = 0; i < mesh.colors.cols; ++i)
-//                 colors_array->InsertNextTupleValue(&data[i*3]);
-//         }
-//         else
-//         {
-//             const unsigned char* color = mesh.colors.ptr<unsigned char>();
-//             const unsigned char* mdata = mask.ptr<unsigned char>();
-// 
-//             int j = 0;
-//             for(int i = 0; i < mesh.colors.cols; ++i)
-//                 if (mdata[i])
-//                     colors_array->SetTupleValue (j++, &color[i*3]);
-// 
-//         }
-//     }
-// 
-//     // Get the maximum size of a polygon
-//     int max_size_of_polygon = -1;
-//     for (size_t i = 0; i < mesh.polygons.size (); ++i)
-//         if (max_size_of_polygon < static_cast<int> (mesh.polygons[i].vertices.size ()))
-//             max_size_of_polygon = static_cast<int> (mesh.polygons[i].vertices.size ());
-// 
-//     // Update the cells
-//     cells = vtkSmartPointer<vtkCellArray>::New ();
-//     vtkIdType *cell = cells->WritePointer (mesh.polygons.size (), mesh.polygons.size () * (max_size_of_polygon + 1));
-//     int idx = 0;
-//     if (lookup.size () > 0)
-//     {
-//         for (size_t i = 0; i < mesh.polygons.size (); ++i, ++idx)
-//         {
-//             size_t n_points = mesh.polygons[i].vertices.size ();
-//             *cell++ = n_points;
-//             for (size_t j = 0; j < n_points; j++, cell++, ++idx)
-//                 *cell = lookup[mesh.polygons[i].vertices[j]];
-//         }
-//     }
-//     else
-//     {
-//         for (size_t i = 0; i < mesh.polygons.size (); ++i, ++idx)
-//         {
-//             size_t n_points = mesh.polygons[i].vertices.size ();
-//             *cell++ = n_points;
-//             for (size_t j = 0; j < n_points; j++, cell++, ++idx)
-//                 *cell = mesh.polygons[i].vertices[j];
-//         }
-//     }
-//     cells->GetData ()->SetNumberOfValues (idx);
-//     cells->Squeeze ();
-//     // Set the the vertices
-//     polydata->SetStrips (cells);
-//     polydata->Update ();
-    return (true);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::addArrow (const cv::Point3f &p1, const cv::Point3f &p2, const Color& color, bool display_length, const std::string &id)
-{
-    // Check to see if this ID entry already exists (has it been already added to the visualizer?)
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it != shape_actor_map_->end ())
-        return std::cout << "[addArrow] A shape with id <" << id << "> already exists! Please choose a different id and retry." << std::endl, false;
-
-    // Create an Actor
-    vtkSmartPointer<vtkLeaderActor2D> leader = vtkSmartPointer<vtkLeaderActor2D>::New ();
-    leader->GetPositionCoordinate()->SetCoordinateSystemToWorld ();
-    leader->GetPositionCoordinate()->SetValue (p1.x, p1.y, p1.z);
-    leader->GetPosition2Coordinate()->SetCoordinateSystemToWorld ();
-    leader->GetPosition2Coordinate()->SetValue (p2.x, p2.y, p2.z);
-    leader->SetArrowStyleToFilled();
-    leader->SetArrowPlacementToPoint2 ();
-
-    if (display_length)
-        leader->AutoLabelOn ();
-    else
-        leader->AutoLabelOff ();
-
-    Color c = vtkcolor(color);
-    leader->GetProperty ()->SetColor (c.val);
-    renderer_->AddActor (leader);
-
-    // Save the pointer/ID pair to the global actor map
-    (*shape_actor_map_)[id] = leader;
-    return (true);
-}
-////////////////////////////////////////////////////////////////////////////////////////////
-bool cv::viz::Viz3d::VizImpl::addArrow (const cv::Point3f &p1, const cv::Point3f &p2, const Color& color_line, const Color& color_text, const std::string &id)
-{
-    // Check to see if this ID entry already exists (has it been already added to the visualizer?)
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it != shape_actor_map_->end ())
-    {
-        std::cout << "[addArrow] A shape with id <" << id << "> already exists! Please choose a different id and retry." << std::endl;
-        return (false);
-    }
-
-    // Create an Actor
-    vtkSmartPointer<vtkLeaderActor2D> leader = vtkSmartPointer<vtkLeaderActor2D>::New ();
-    leader->GetPositionCoordinate ()->SetCoordinateSystemToWorld ();
-    leader->GetPositionCoordinate ()->SetValue (p1.x, p1.y, p1.z);
-    leader->GetPosition2Coordinate ()->SetCoordinateSystemToWorld ();
-    leader->GetPosition2Coordinate ()->SetValue (p2.x, p2.y, p2.z);
-    leader->SetArrowStyleToFilled ();
-    leader->AutoLabelOn ();
-
-    Color ct = vtkcolor(color_text);
-    leader->GetLabelTextProperty()->SetColor(ct.val);
-
-    Color cl = vtkcolor(color_line);
-    leader->GetProperty ()->SetColor (cl.val);
-    renderer_->AddActor (leader);
-
-    // Save the pointer/ID pair to the global actor map
-    (*shape_actor_map_)[id] = leader;
-    return (true);
-}
-
-bool cv::viz::Viz3d::VizImpl::addPolygon (const cv::Mat& cloud, const Color& color, const std::string &id)
-{
-    CV_Assert(cloud.type() == CV_32FC3 && cloud.rows == 1);
-
-    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New ();
-    vtkSmartPointer<vtkPolygon> polygon    = vtkSmartPointer<vtkPolygon>::New ();
-
-    int total = cloud.size().area();
-    points->SetNumberOfPoints (total);
-    polygon->GetPointIds ()->SetNumberOfIds (total);
-
-    for (int i = 0; i < total; ++i)
-    {
-        cv::Point3f p = cloud.ptr<cv::Point3f>()[i];
-        points->SetPoint (i, p.x, p.y, p.z);
-        polygon->GetPointIds ()->SetId (i, i);
-    }
-
-    vtkSmartPointer<vtkUnstructuredGrid> poly_grid;
-    allocVtkUnstructuredGrid (poly_grid);
-    poly_grid->Allocate (1, 1);
-    poly_grid->InsertNextCell (polygon->GetCellType (), polygon->GetPointIds ());
-    poly_grid->SetPoints (points);
-    poly_grid->Update ();
-
-
-    //////////////////////////////////////////////////////
-    vtkSmartPointer<vtkDataSet> data = poly_grid;
-
-    Color c = vtkcolor(color);
-
-    // Check to see if this ID entry already exists (has it been already added to the visualizer?)
-    ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
-    if (am_it != shape_actor_map_->end ())
-    {
-        vtkSmartPointer<vtkAppendPolyData> all_data = vtkSmartPointer<vtkAppendPolyData>::New ();
-
-        // Add old data
-        all_data->AddInput (reinterpret_cast<vtkPolyDataMapper*> ((vtkActor::SafeDownCast (am_it->second))->GetMapper ())->GetInput ());
-
-        // Add new data
-        vtkSmartPointer<vtkDataSetSurfaceFilter> surface_filter = vtkSmartPointer<vtkDataSetSurfaceFilter>::New ();
-        surface_filter->SetInput (vtkUnstructuredGrid::SafeDownCast (data));
-        vtkSmartPointer<vtkPolyData> poly_data = surface_filter->GetOutput ();
-        all_data->AddInput (poly_data);
-
-        // Create an Actor
-        vtkSmartPointer<vtkLODActor> actor;
-        createActorFromVTKDataSet (all_data->GetOutput (), actor);
-        actor->GetProperty ()->SetRepresentationToWireframe ();
-        actor->GetProperty ()->SetColor (c.val);
-        actor->GetMapper ()->ScalarVisibilityOff ();
-        actor->GetProperty ()->BackfaceCullingOff ();
-
-        removeActorFromRenderer (am_it->second);
-        renderer_->AddActor (actor);
-
-        // Save the pointer/ID pair to the global actor map
-        (*shape_actor_map_)[id] = actor;
-    }
-    else
-    {
-        // Create an Actor
-        vtkSmartPointer<vtkLODActor> actor;
-        createActorFromVTKDataSet (data, actor);
-        actor->GetProperty ()->SetRepresentationToWireframe ();
-        actor->GetProperty ()->SetColor (c.val);
-        actor->GetMapper ()->ScalarVisibilityOff ();
-        actor->GetProperty ()->BackfaceCullingOff ();
-        renderer_->AddActor (actor);
-
-        // Save the pointer/ID pair to the global actor map
-        (*shape_actor_map_)[id] = actor;
-    }
-
-    return (true);
-}
-
-void cv::viz::Viz3d::VizImpl::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
-{
-    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
-    bool exists = wam_itr != widget_actor_map_->end();
-    if (exists)
-    {
-        // Remove it if it exists and add it again
-        removeActorFromRenderer(wam_itr->second.actor);
-    }
-    // Get the actor and set the user matrix
-    vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(widget));
-    if (actor)
-    {
-        // If the actor is 3D, apply pose
-        vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
-        actor->SetUserMatrix (matrix);
-        actor->Modified();
-    }
-    // If the actor is a vtkFollower, then it should always face the camera
-    vtkFollower *follower = vtkFollower::SafeDownCast(actor);
-    if (follower)
-    {
-        follower->SetCamera(renderer_->GetActiveCamera());
-    }
-
-    renderer_->AddActor(WidgetAccessor::getProp(widget));
-    (*widget_actor_map_)[id].actor = WidgetAccessor::getProp(widget);
-}
-
-void cv::viz::Viz3d::VizImpl::removeWidget(const String &id)
-{
-    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
-    bool exists = wam_itr != widget_actor_map_->end();
-    CV_Assert(exists);
-    CV_Assert(removeActorFromRenderer (wam_itr->second.actor));
-    widget_actor_map_->erase(wam_itr);
-}
-
-cv::viz::Widget cv::viz::Viz3d::VizImpl::getWidget(const String &id) const
-{
-    WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
-    bool exists = wam_itr != widget_actor_map_->end();
-    CV_Assert(exists);
-
-    Widget widget;
-    WidgetAccessor::setProp(widget, wam_itr->second.actor);
-    return widget;
-}
-
-void cv::viz::Viz3d::VizImpl::setWidgetPose(const String &id, const Affine3f &pose)
-{
-    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
-    bool exists = wam_itr != widget_actor_map_->end();
-    CV_Assert(exists);
-
-    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second.actor);
-    CV_Assert(actor);
-
-    vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
-    actor->SetUserMatrix (matrix);
-    actor->Modified ();
-}
-
-void cv::viz::Viz3d::VizImpl::updateWidgetPose(const String &id, const Affine3f &pose)
-{
-    WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
-    bool exists = wam_itr != widget_actor_map_->end();
-    CV_Assert(exists);
-
-    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second.actor);
-    CV_Assert(actor);
-
-    vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
-    if (!matrix)
-    {
-        setWidgetPose(id, pose);
-        return ;
-    }
-    Matx44f matrix_cv = convertToMatx(matrix);
-    Affine3f updated_pose = pose * Affine3f(matrix_cv);
-    matrix = convertToVtkMatrix(updated_pose.matrix);
-
-    actor->SetUserMatrix (matrix);
-    actor->Modified ();
-}
-
-cv::Affine3f cv::viz::Viz3d::VizImpl::getWidgetPose(const String &id) const
-{
-    WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
-    bool exists = wam_itr != widget_actor_map_->end();
-    CV_Assert(exists);
-
-    vtkProp3D *actor = vtkProp3D::SafeDownCast(wam_itr->second.actor);
-    CV_Assert(actor);
-
-    vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
-    Matx44f matrix_cv = convertToMatx(matrix);
-    return Affine3f(matrix_cv);
-}

modules/viz/src/viz3d_impl.hpp

@@ -16,48 +16,18 @@ public:
 
     VizImpl (const String &name);
     virtual ~VizImpl ();
+    
+    void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
+    void removeWidget(const String &id);
+    Widget getWidget(const String &id) const;
+    void removeAllWidgets();
+    
+    void setWidgetPose(const String &id, const Affine3f &pose);
+    void updateWidgetPose(const String &id, const Affine3f &pose);
+    Affine3f getWidgetPose(const String &id) const; 
 
-
-
-
-
-
-
-
-
-    //to refactor
-    bool removePointCloud (const String& id = "cloud");
-    inline bool removePolygonMesh (const String& id = "polygon") { return removePointCloud (id); }
-    bool removeShape (const String& id = "cloud");
-    bool removeText3D (const String& id = "cloud");
-    bool removeAllPointClouds ();
-
-    //create Viz3d::removeAllWidgets()
-    bool removeAllShapes ();
-
-    //to refactor
-    bool addPolygonMesh (const Mesh3d& mesh, const cv::Mat& mask, const String& id = "polygon");
-    bool updatePolygonMesh (const Mesh3d& mesh, const cv::Mat& mask, const String& id = "polygon");
-    bool addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id = "polyline");
-
-    // to refactor: Widget3D:: & Viz3d::
-    bool setPointCloudRenderingProperties (int property, double value, const String& id = "cloud");
-    bool getPointCloudRenderingProperties (int property, double &value, const String& id = "cloud");
-    bool setShapeRenderingProperties (int property, double value, const String& id);
-
-    /** \brief Set whether the point cloud is selected or not
-         *  \param[in] selected whether the cloud is selected or not (true = selected)
-         *  \param[in] id the point cloud object id (default: cloud)
-         */
-    // probably should just remove
-    bool setPointCloudSelected (const bool selected, const String& id = "cloud" );
-
-
-
-
-
-
-
+    void setDesiredUpdateRate(double time);
+    double getDesiredUpdateRate();
 
     /** \brief Returns true when the user tried to close the window */
     bool wasStopped () const { if (interactor_ != NULL) return (stopped_); else return true; }
@@ -76,78 +46,29 @@ public:
         }
     }
 
-
-
-
-
-
-
-
-
-
-    
-    // to refactor
-    bool addPolygon(const cv::Mat& cloud, const Color& color, const String& id = "polygon");
-    bool addArrow (const Point3f& pt1, const Point3f& pt2, const Color& color, bool display_length, const String& id = "arrow");
-    bool addArrow (const Point3f& pt1, const Point3f& pt2, const Color& color_line, const Color& color_text, const String& id = "arrow");
-
-    // Probably remove this
-    bool addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, const String& id = "PolyData");
-    bool addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, vtkSmartPointer<vtkTransform> transform, const String& id = "PolyData");
-
-    // I think this should be moved to 'static Widget Widget::fromPlyFile(const String&)';
-    bool addModelFromPLYFile (const String &filename, const String& id = "PLYModel");
-    bool addModelFromPLYFile (const String &filename, vtkSmartPointer<vtkTransform> transform, const String& id = "PLYModel");
-
-
-    // to implement in Viz3d with shorter name
-    void setRepresentationToSurfaceForAllActors();
-    void setRepresentationToPointsForAllActors();
-    void setRepresentationToWireframeForAllActors();
-
-
-
-
-
-
-
-
-    // ////////////////////////////////////////////////////////////////////////////////////
-    // All camera methods to refactor into set/getViewwerPose, setCamera()
-    // and 'Camera' class itself with various constructors/fields
+    void setRepresentationToSurface();
+    void setRepresentationToPoints();
+    void setRepresentationToWireframe();
     
     void setCamera(const Camera &camera);
     Camera getCamera() const;
 
-    void initCameraParameters (); /** \brief Initialize camera parameters with some default values. */
-    bool cameraParamsSet () const; /** \brief Checks whether the camera parameters were manually loaded from file.*/
-    void updateCamera (); /** \brief Update camera parameters and render. */
-    void resetCamera (); /** \brief Reset camera parameters and render. */
-
     /** \brief Reset the camera direction from {0, 0, 0} to the center_{x, y, z} of a given dataset.
       * \param[in] id the point cloud object id (default: cloud) */
-    void resetCameraViewpoint (const String& id = "cloud");
+    void resetCameraViewpoint(const String& id);
+    void resetCamera();
     
-    //to implement Viz3d set/getViewerPose()
     void setViewerPose(const Affine3f &pose);
     Affine3f getViewerPose();
 
     void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord);
     void converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction);
 
-
-
-
-
-
-
-    //to implemnt in Viz3d
     void saveScreenshot (const String &file);
     void setWindowPosition (int x, int y);
     Size getWindowSize() const;
     void setWindowSize (int xw, int yw);
     void setFullScreen (bool mode);
-    void setWindowName (const String &name);
     String getWindowName() const;
     void setBackgroundColor (const Color& color);
 
@@ -157,22 +78,6 @@ public:
     void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
     void registerMouseCallback(MouseCallback callback, void* cookie = 0);
 
-
-
-
-
-
-
-
-    //declare above (to move to up)
-    void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
-    void removeWidget(const String &id);
-    Widget getWidget(const String &id) const;
-    
-    void setWidgetPose(const String &id, const Affine3f &pose);
-    void updateWidgetPose(const String &id, const Affine3f &pose);
-    Affine3f getWidgetPose(const String &id) const; 
-
 private:
     vtkSmartPointer<vtkRenderWindowInteractor> interactor_;
 
@@ -209,6 +114,7 @@ private:
             if (event_id == vtkCommand::ExitEvent)
             {
                 viz_->stopped_ = true;
+                viz_->interactor_->GetRenderWindow()->Finalize();
                 viz_->interactor_->TerminateApp ();
             }
         }
@@ -232,12 +138,6 @@ private:
 
     /** \brief The render window interactor style. */
     vtkSmartPointer<InteractorStyle> style_;
-
-    /** \brief Internal list with actor pointers and name IDs for point clouds. */
-    cv::Ptr<CloudActorMap> cloud_actor_map_;
-
-    /** \brief Internal list with actor pointers and name IDs for shapes. */
-    cv::Ptr<ShapeActorMap> shape_actor_map_;
     
     /** \brief Internal list with actor pointers and name IDs for all widget actors */
     cv::Ptr<WidgetActorMap> widget_actor_map_;
@@ -245,13 +145,8 @@ private:
     /** \brief Boolean that holds whether or not the camera parameters were manually initialized*/
     bool camera_set_;
 
-    bool removeActorFromRenderer (const vtkSmartPointer<vtkLODActor> &actor);
-    bool removeActorFromRenderer (const vtkSmartPointer<vtkActor> &actor);
     bool removeActorFromRenderer (const vtkSmartPointer<vtkProp> &actor);
 
-    //void addActorToRenderer (const vtkSmartPointer<vtkProp> &actor);
-
-
     /** \brief Internal method. Creates a vtk actor from a vtk polydata object.
           * \param[in] data the vtk polydata object to create an actor for
           * \param[out] actor the resultant vtk actor object
@@ -268,10 +163,6 @@ private:
           * generate
           */
     void updateCells (vtkSmartPointer<vtkIdTypeArray> &cells, vtkSmartPointer<vtkIdTypeArray> &initcells, vtkIdType nr_points);
-
-    void allocVtkPolyData (vtkSmartPointer<vtkAppendPolyData> &polydata);
-    void allocVtkPolyData (vtkSmartPointer<vtkPolyData> &polydata);
-    void allocVtkUnstructuredGrid (vtkSmartPointer<vtkUnstructuredGrid> &polydata);
 };
 
 
@@ -280,17 +171,9 @@ namespace cv
 {
     namespace viz
     {
-        //void getTransformationMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternionf& orientation, Eigen::Matrix4f &transformation);
         vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f &m);
         cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix);
 
-        /** \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);
-
         struct NanFilter
         {
             template<typename _Tp, typename _Msk>

modules/viz/src/viz_types.h

@@ -6,29 +6,7 @@ namespace cv
 {
     namespace viz
     {
-        struct CV_EXPORTS CloudActor
-        {
-            /** \brief The actor holding the data to render. */
-            vtkSmartPointer<vtkLODActor> actor;
-
-            /** \brief The viewpoint transformation matrix. */
-            vtkSmartPointer<vtkMatrix4x4> viewpoint_transformation_;
-
-            /** \brief Internal cell array. Used for optimizing updatePointCloud. */
-            vtkSmartPointer<vtkIdTypeArray> cells;
-        };
-
-        // TODO This will be used to contain both cloud and shape actors
-        struct CV_EXPORTS WidgetActor
-        {
-            vtkSmartPointer<vtkProp> actor;
-            vtkSmartPointer<vtkMatrix4x4> viewpoint_transformation_;
-            vtkSmartPointer<vtkIdTypeArray> cells;
-        };
-
-        typedef std::map<std::string, CloudActor> CloudActorMap;
-        typedef std::map<std::string, vtkSmartPointer<vtkProp> > ShapeActorMap;
-        typedef std::map<std::string, WidgetActor> WidgetActorMap;
+        typedef std::map<std::string, vtkSmartPointer<vtkProp> > WidgetActorMap;
     }
 }
 

modules/viz/src/widget.cpp

-
 #include "precomp.hpp"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -8,51 +7,196 @@ class cv::viz::Widget::Impl
 {
 public:
     vtkSmartPointer<vtkProp> prop;
-    int ref_counter;
     
     Impl() : prop(0) {}
 };
 
-cv::viz::Widget::Widget() : impl_(0)
-{
-    create();
+cv::viz::Widget::Widget() : impl_( new Impl() ) { }
+
+cv::viz::Widget::Widget(const Widget& other) : impl_( new Impl() )
+{ 
+    if (other.impl_ && other.impl_->prop) impl_->prop = other.impl_->prop;
 }
 
-cv::viz::Widget::Widget(const Widget &other) : impl_(other.impl_) 
+cv::viz::Widget& cv::viz::Widget::operator=(const Widget& other)
 {
-    if (impl_) CV_XADD(&impl_->ref_counter, 1);
+    if (!impl_) impl_ = new Impl();
+    if (other.impl_) impl_->prop = other.impl_->prop;
+    return *this;
 }
 
-cv::viz::Widget& cv::viz::Widget::operator=(const Widget &other)
-{
-    if (this != &other)
+cv::viz::Widget::~Widget() 
+{ 
+    if (impl_)
     {
-        release();
-        impl_ = other.impl_;
-        if (impl_) CV_XADD(&impl_->ref_counter, 1);
+        delete impl_;
+        impl_ = 0;
     }
-    return *this;
 }
 
-cv::viz::Widget::~Widget()
+cv::viz::Widget cv::viz::Widget::fromPlyFile(const String &file_name)
 {
-    release();
+    vtkSmartPointer<vtkPLYReader> reader = vtkSmartPointer<vtkPLYReader>::New ();
+    reader->SetFileName (file_name.c_str ());
+    
+    vtkSmartPointer<vtkDataSet> data = reader->GetOutput();
+    CV_Assert("File does not exist or file format is not supported." && data);
+
+    vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
+
+    vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
+    mapper->SetInput (data);
+
+    vtkSmartPointer<vtkDataArray> scalars = data->GetPointData ()->GetScalars ();
+    if (scalars)
+    {
+        cv::Vec3d minmax(scalars->GetRange());
+        mapper->SetScalarRange(minmax.val);
+        mapper->SetScalarModeToUsePointData ();
+
+        // interpolation OFF, if data is a vtkPolyData that contains only vertices, ON for anything else.
+        vtkPolyData* polyData = vtkPolyData::SafeDownCast (data);
+        bool interpolation = (polyData && polyData->GetNumberOfCells () != polyData->GetNumberOfVerts ());
+
+        mapper->SetInterpolateScalarsBeforeMapping (interpolation);
+        mapper->ScalarVisibilityOn ();
+    }
+    mapper->ImmediateModeRenderingOff ();
+
+    actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, data->GetNumberOfPoints () / 10)));
+    actor->GetProperty ()->SetInterpolationToFlat ();
+    actor->GetProperty ()->BackfaceCullingOn ();
+
+    actor->SetMapper (mapper);
+    
+    Widget widget;
+    widget.impl_->prop = actor;
+    return widget;
 }
 
-void cv::viz::Widget::create()
+void cv::viz::Widget::setRenderingProperty(int property, double value)
 {
-    if (impl_) release();
-    impl_ = new Impl();
-    impl_->ref_counter = 1;
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget type is not supported." && actor);
+    
+    switch (property)
+    {
+        case VIZ_POINT_SIZE:
+        {
+            actor->GetProperty ()->SetPointSize (float (value));
+            actor->Modified ();
+            break;
+        }
+        case VIZ_OPACITY:
+        {
+            actor->GetProperty ()->SetOpacity (value);
+            actor->Modified ();
+            break;
+        }
+            // Turn on/off flag to control whether data is rendered using immediate
+            // mode or note. Immediate mode rendering tends to be slower but it can
+            // handle larger datasets. The default value is immediate mode off. If you
+            // are having problems rendering a large dataset you might want to consider
+            // using immediate more rendering.
+        case VIZ_IMMEDIATE_RENDERING:
+        {
+            actor->GetMapper ()->SetImmediateModeRendering (int (value));
+            actor->Modified ();
+            break;
+        }
+        case VIZ_LINE_WIDTH:
+        {
+            actor->GetProperty ()->SetLineWidth (float (value));
+            actor->Modified ();
+            break;
+        }
+        default:
+            CV_Assert("setPointCloudRenderingProperties: Unknown property");
+    }
 }
 
-void cv::viz::Widget::release()
+double cv::viz::Widget::getRenderingProperty(int property) const
 {
-    if (impl_ && CV_XADD(&impl_->ref_counter, -1) == 1)
+    vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
+    CV_Assert("Widget type is not supported." && actor);
+    
+    double value = 0.0;
+    switch (property)
     {
-        delete impl_;
-        impl_ = 0;
+        case VIZ_POINT_SIZE:
+        {
+            value = actor->GetProperty ()->GetPointSize ();
+            actor->Modified ();
+            break;
+        }
+        case VIZ_OPACITY:
+        {
+            value = actor->GetProperty ()->GetOpacity ();
+            actor->Modified ();
+            break;
+        }
+        case VIZ_LINE_WIDTH:
+        {
+            value = actor->GetProperty ()->GetLineWidth ();
+            actor->Modified ();
+            break;
+        }
+        case VIZ_FONT_SIZE:
+        {
+            vtkTextActor* text_actor = vtkTextActor::SafeDownCast (actor);
+            vtkSmartPointer<vtkTextProperty> tprop = text_actor->GetTextProperty ();
+            tprop->SetFontSize (int (value));
+            text_actor->Modified ();
+            break;
+        }
+        case VIZ_REPRESENTATION:
+        {
+            switch (int (value))
+            {
+                case REPRESENTATION_POINTS:    actor->GetProperty ()->SetRepresentationToPoints (); break;
+                case REPRESENTATION_WIREFRAME: actor->GetProperty ()->SetRepresentationToWireframe (); break;
+                case REPRESENTATION_SURFACE:   actor->GetProperty ()->SetRepresentationToSurface ();  break;
+            }
+            actor->Modified ();
+            break;
+        }
+        case VIZ_SHADING:
+        {
+            switch (int (value))
+            {
+                case SHADING_FLAT: actor->GetProperty ()->SetInterpolationToFlat (); break;
+                case SHADING_GOURAUD:
+                {
+                    if (!actor->GetMapper ()->GetInput ()->GetPointData ()->GetNormals ())
+                    {
+                        vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New ();
+                        normals->SetInput (actor->GetMapper ()->GetInput ());
+                        normals->Update ();
+                        vtkDataSetMapper::SafeDownCast (actor->GetMapper ())->SetInput (normals->GetOutput ());
+                    }
+                    actor->GetProperty ()->SetInterpolationToGouraud ();
+                    break;
+                }
+                case SHADING_PHONG:
+                {
+                    if (!actor->GetMapper ()->GetInput ()->GetPointData ()->GetNormals ())
+                    {
+                        vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New ();
+                        normals->SetInput (actor->GetMapper ()->GetInput ());
+                        normals->Update ();
+                        vtkDataSetMapper::SafeDownCast (actor->GetMapper ())->SetInput (normals->GetOutput ());
+                    }
+                    actor->GetProperty ()->SetInterpolationToPhong ();
+                    break;
+                }
+            }
+            actor->Modified ();
+            break;
+        }
+        default:
+            CV_Assert("getPointCloudRenderingProperties: Unknown property");
     }
+    return value;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -95,7 +239,7 @@ struct cv::viz::Widget3D::MatrixConverter
 void cv::viz::Widget3D::setPose(const Affine3f &pose)
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Widget is not 3D." && actor);
     
     vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
     actor->SetUserMatrix (matrix);
@@ -105,7 +249,7 @@ void cv::viz::Widget3D::setPose(const Affine3f &pose)
 void cv::viz::Widget3D::updatePose(const Affine3f &pose)
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Widget is not 3D." && actor);
     
     vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
     if (!matrix)
@@ -125,7 +269,7 @@ void cv::viz::Widget3D::updatePose(const Affine3f &pose)
 cv::Affine3f cv::viz::Widget3D::getPose() const
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Widget is not 3D." && actor);
     
     vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
     Matx44f matrix_cv = MatrixConverter::convertToMatx(matrix);
@@ -136,7 +280,7 @@ 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));
-    CV_Assert(actor);
+    CV_Assert("Widget type is not supported." && actor);
     
     Color c = vtkcolor(color);
     actor->GetMapper ()->ScalarVisibilityOff ();
@@ -148,7 +292,7 @@ void cv::viz::Widget3D::setColor(const Color &color)
 template<> cv::viz::Widget3D cv::viz::Widget::cast<cv::viz::Widget3D>()
 {
     vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Widget cannot be cast." && actor);
 
     Widget3D widget;
     WidgetAccessor::setProp(widget, actor);
@@ -161,7 +305,7 @@ template<> cv::viz::Widget3D cv::viz::Widget::cast<cv::viz::Widget3D>()
 void cv::viz::Widget2D::setColor(const Color &color)
 {
     vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Widget type is not supported." && actor);
     Color c = vtkcolor(color);
     actor->GetProperty ()->SetColor (c.val);
     actor->Modified ();
@@ -170,7 +314,7 @@ void cv::viz::Widget2D::setColor(const Color &color)
 template<> cv::viz::Widget2D cv::viz::Widget::cast<cv::viz::Widget2D>()
 {
     vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
-    CV_Assert(actor);
+    CV_Assert("Widget cannot be cast." && actor);
 
     Widget2D widget;
     WidgetAccessor::setProp(widget, actor);

samples/cpp/tutorial_code/viz/creating_widgets.cpp

+/**
+ * @file creating_widgets.cpp
+ * @brief Creating custom widgets using VTK
+ * @author Ozan Cagri Tonkal
+ */
+
+#include <opencv2/viz.hpp>
+#include <opencv2/viz/widget_accessor.hpp> 
+#include <iostream>
+
+#include <vtkPoints.h>
+#include <vtkTriangle.h>
+#include <vtkCellArray.h>
+#include <vtkPolyData.h>
+#include <vtkPolyDataMapper.h>
+#include <vtkIdList.h>
+#include <vtkActor.h>
+#include <vtkProp.h>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function help
+ * @brief Display instructions to use this tutorial program
+ */
+void help()
+{
+    cout
+    << "--------------------------------------------------------------------------"   << endl
+    << "This program shows how to create a custom widget. You can create your own "
+    << "widgets by extending Widget2D/Widget3D, and with the help of WidgetAccessor." << endl
+    << "Usage:"                                                                       << endl
+    << "./creating_widgets"                                                           << endl
+    << endl;
+}
+
+/**
+ * @class TriangleWidget
+ * @brief Defining our own 3D Triangle widget
+ */
+class TriangleWidget : public viz::Widget3D
+{
+    public:
+        TriangleWidget(const Point3f &pt1, const Point3f &pt2, const Point3f &pt3, const viz::Color & color = viz::Color::white()); 
+};
+
+/**
+ * @function TriangleWidget::TriangleWidget
+ * @brief Constructor
+ */
+TriangleWidget::TriangleWidget(const Point3f &pt1, const Point3f &pt2, const Point3f &pt3, const viz::Color & color)
+{
+    // Create a triangle
+    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+    points->InsertNextPoint(pt1.x, pt1.y, pt1.z);
+    points->InsertNextPoint(pt2.x, pt2.y, pt2.z);
+    points->InsertNextPoint(pt3.x, pt3.y, pt3.z);
+    
+    vtkSmartPointer<vtkTriangle> triangle = vtkSmartPointer<vtkTriangle>::New();
+    triangle->GetPointIds()->SetId(0,0);
+    triangle->GetPointIds()->SetId(1,1);
+    triangle->GetPointIds()->SetId(2,2);
+    
+    vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
+    cells->InsertNextCell(triangle);
+    
+    // Create a polydata object
+    vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
+    
+    // Add the geometry and topology to the polydata
+    polyData->SetPoints(points);
+    polyData->SetPolys(cells);
+    
+    // Create mapper and actor
+    vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    mapper->SetInput(polyData);
+    
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
+    actor->SetMapper(mapper);
+    
+    // Store this actor in the widget in order that visualizer can access it
+    viz::WidgetAccessor::setProp(*this, actor);
+}
+
+/**
+ * @function main
+ */
+int main()
+{
+    help();
+    
+    /// Create a window
+    viz::Viz3d myWindow("Creating Widgets");
+    
+    /// Create a triangle widget
+    TriangleWidget tw(Point3f(0.0,0.0,0.0), Point3f(1.0,1.0,1.0), Point3f(0.0,1.0,0.0));
+    
+    /// Show widget in the visualizer window
+    myWindow.showWidget("TRIANGLE", tw);
+    
+    /// Start event loop
+    myWindow.spin();
+    
+    return 0;
+}

samples/cpp/tutorial_code/viz/launching_viz.cpp

+/**
+ * @file launching_viz.cpp
+ * @brief Launching visualization window
+ * @author Ozan Cagri Tonkal
+ */
+
+#include <opencv2/viz.hpp>
+#include <iostream>
+
+using namespace cv;
+using namespace std;
+
+/**
+ * @function help
+ * @brief Display instructions to use this tutorial program
+ */
+void help()
+{
+    cout
+    << "--------------------------------------------------------------------------" << endl
+    << "This program shows how to launch a 3D visualization window. You can stop event loop to continue executing. "
+    << "You can access the same window via its name. You can run event loop for a given period of time. " << endl
+    << "Usage:"                                                                     << endl
+    << "./launching_viz"                                                            << endl
+    << endl;
+}
+
+/**
+ * @function main
+ */
+int main()
+{
+    help();
+    /// Create a window
+    viz::Viz3d myWindow("Viz Demo");
+    
+    /// Start event loop
+    myWindow.spin();
+    
+    /// Event loop is over when pressed q, Q, e, E
+    cout << "First event loop is over" << endl;
+    
+    /// Access window via its name
+    viz::Viz3d sameWindow = viz::get("Viz Demo");
+    
+    /// Start event loop
+    sameWindow.spin();
+    
+    /// Event loop is over when pressed q, Q, e, E
+    cout << "Second event loop is over" << endl;
+    
+    /// Event loop is over when pressed q, Q, e, E
+    /// Start event loop once for 1 millisecond
+    sameWindow.spinOnce(1, true);
+    while(!sameWindow.wasStopped())
+    {
+        /// Interact with window
+        
+        /// Event loop for 1 millisecond
+        sameWindow.spinOnce(1, true);
+    }
+    
+    /// Once more event loop is stopped
+    cout << "Last event loop is over" << endl;
+    return 0;
+}