Merge pull request #2173 from Nerei:viz

CMakeLists.txt

@@ -116,7 +116,7 @@ endif()
 OCV_OPTION(WITH_1394           "Include IEEE1394 support"                    ON   IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_AVFOUNDATION   "Use AVFoundation for Video I/O"              ON   IF IOS)
 OCV_OPTION(WITH_CARBON         "Use Carbon for UI instead of Cocoa"          OFF  IF APPLE )
-OCV_OPTION(WITH_VTK            "Include VTK library support (and build opencv_viz module eiher)"             OFF IF (NOT ANDROID AND NOT IOS) )
+OCV_OPTION(WITH_VTK            "Include VTK library support (and build opencv_viz module eiher)"             ON  IF (NOT ANDROID AND NOT IOS) )
 OCV_OPTION(WITH_CUDA           "Include NVidia Cuda Runtime support"                                         ON  IF (NOT IOS) )
 OCV_OPTION(WITH_CUFFT          "Include NVidia Cuda Fast Fourier Transform (FFT) library support"            ON  IF (NOT IOS) )
 OCV_OPTION(WITH_CUBLAS         "Include NVidia Cuda Basic Linear Algebra Subprograms (BLAS) library support" OFF IF (NOT IOS) )

cmake/OpenCVDetectVTK.cmake

@@ -2,7 +2,7 @@ if(NOT WITH_VTK OR ANDROID OR IOS)
   return()
 endif()
 
-find_package(VTK 6.0 QUIET COMPONENTS vtkRenderingCore vtkInteractionWidgets vtkInteractionStyle vtkIOLegacy vtkIOPLY vtkRenderingFreeType vtkRenderingLOD vtkFiltersTexture NO_MODULE)
+find_package(VTK 6.0 QUIET COMPONENTS vtkRenderingCore vtkInteractionWidgets vtkInteractionStyle vtkIOLegacy vtkIOPLY vtkRenderingFreeType vtkRenderingLOD vtkFiltersTexture vtkIOExport NO_MODULE)
 
 if(NOT DEFINED VTK_FOUND OR NOT VTK_FOUND)
   find_package(VTK 5.10 QUIET COMPONENTS vtkCommon vtkFiltering vtkRendering vtkWidgets vtkImaging NO_MODULE)

doc/tutorials/viz/launching_viz/launching_viz.rst

@@ -43,7 +43,7 @@ You can download the code from :download:`here <../../../../samples/cpp/tutorial
         cout << "First event loop is over" << endl;
 
         /// Access window via its name
-        viz::Viz3d sameWindow = viz::get("Viz Demo");
+        viz::Viz3d sameWindow = viz::getWindowByName("Viz Demo");
 
         /// Start event loop
         sameWindow.spin();

modules/core/include/opencv2/core/affine.hpp

@@ -55,9 +55,9 @@ namespace cv
     {
     public:
         typedef T float_type;
-        typedef cv::Matx<float_type, 3, 3> Mat3;
-        typedef cv::Matx<float_type, 4, 4> Mat4;
-        typedef cv::Vec<float_type, 3> Vec3;
+        typedef Matx<float_type, 3, 3> Mat3;
+        typedef Matx<float_type, 4, 4> Mat4;
+        typedef Vec<float_type, 3> Vec3;
 
         Affine3();
 
@@ -70,11 +70,11 @@ namespace cv
         //Rodrigues vector
         Affine3(const Vec3& rvec, const Vec3& t = Vec3::all(0));
 
-        //Combines all contructors above. Supports 4x4, 3x3, 1x3, 3x1 sizes of data matrix
-        explicit Affine3(const cv::Mat& data, const Vec3& t = Vec3::all(0));
+        //Combines all contructors above. Supports 4x4, 3x4, 3x3, 1x3, 3x1 sizes of data matrix
+        explicit Affine3(const Mat& data, const Vec3& t = Vec3::all(0));
 
-        //Euler angles
-        Affine3(float_type alpha, float_type beta, float_type gamma, const Vec3& t = Vec3::all(0));
+        //From 16th element array
+        explicit Affine3(const float_type* vals);
 
         static Affine3 Identity();
 
@@ -87,9 +87,6 @@ namespace cv
         //Combines rotation methods above. Suports 3x3, 1x3, 3x1 sizes of data matrix;
         void rotation(const Mat& data);
 
-        //Euler angles
-        void rotation(float_type alpha, float_type beta, float_type gamma);
-
         void linear(const Mat3& L);
         void translation(const Vec3& t);
 
@@ -105,6 +102,9 @@ namespace cv
         // a.rotate(R) is equivalent to Affine(R, 0) * a;
         Affine3 rotate(const Mat3& R) const;
 
+        // a.rotate(R) is equivalent to Affine(rvec, 0) * a;
+        Affine3 rotate(const Vec3& rvec) const;
+
         // a.translate(t) is equivalent to Affine(E, t) * a;
         Affine3 translate(const Vec3& t) const;
 
@@ -113,6 +113,8 @@ namespace cv
 
         template <typename Y> operator Affine3<Y>() const;
 
+        template <typename Y> Affine3<Y> cast() const;
+
         Mat4 matrix;
 
 #if defined EIGEN_WORLD_VERSION && defined EIGEN_GEOMETRY_MODULE_H
@@ -132,10 +134,26 @@ namespace cv
     typedef Affine3<float> Affine3f;
     typedef Affine3<double> Affine3d;
 
-    static cv::Vec3f operator*(const cv::Affine3f& affine, const cv::Vec3f& vector);
-    static cv::Vec3d operator*(const cv::Affine3d& affine, const cv::Vec3d& vector);
-}
+    static Vec3f operator*(const Affine3f& affine, const Vec3f& vector);
+    static Vec3d operator*(const Affine3d& affine, const Vec3d& vector);
+
+    template<typename _Tp> class DataType< Affine3<_Tp> >
+    {
+    public:
+        typedef Affine3<_Tp>                               value_type;
+        typedef Affine3<typename DataType<_Tp>::work_type> work_type;
+        typedef _Tp                                        channel_type;
+
+        enum { generic_type = 0,
+               depth        = DataType<channel_type>::depth,
+               channels     = 16,
+               fmt          = DataType<channel_type>::fmt + ((channels - 1) << 8),
+               type         = CV_MAKETYPE(depth, channels)
+             };
 
+        typedef Vec<channel_type, channels> vec_type;
+    };
+}
 
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -179,6 +197,12 @@ cv::Affine3<T>::Affine3(const cv::Mat& data, const Vec3& t)
         data.copyTo(matrix);
         return;
     }
+    else if (data.cols == 4 && data.rows == 3)
+    {
+        rotation(data(Rect(0, 0, 3, 3)));
+        translation(data(Rect(3, 0, 1, 3)));
+        return;
+    }
 
     rotation(data);
     translation(t);
@@ -187,13 +211,8 @@ cv::Affine3<T>::Affine3(const cv::Mat& data, const Vec3& t)
 }
 
 template<typename T> inline
-cv::Affine3<T>::Affine3(float_type alpha, float_type beta, float_type gamma, const Vec3& t)
-{
-    rotation(alpha, beta, gamma);
-    translation(t);
-    matrix.val[12] = matrix.val[13] = matrix.val[14] = 0;
-    matrix.val[15] = 1;
-}
+cv::Affine3<T>::Affine3(const float_type* vals) : matrix(vals)
+{}
 
 template<typename T> inline
 cv::Affine3<T> cv::Affine3<T>::Identity()
@@ -261,12 +280,6 @@ void cv::Affine3<T>::rotation(const cv::Mat& data)
         CV_Assert(!"Input marix can be 3x3, 1x3 or 3x1");
 }
 
-template<typename T> inline
-void cv::Affine3<T>::rotation(float_type alpha, float_type beta, float_type gamma)
-{
-    rotation(Vec3(alpha, beta, gamma));
-}
-
 template<typename T> inline
 void cv::Affine3<T>::linear(const Mat3& L)
 {
@@ -382,6 +395,12 @@ cv::Affine3<T> cv::Affine3<T>::rotate(const Mat3& R) const
     return result;
 }
 
+template<typename T> inline
+cv::Affine3<T> cv::Affine3<T>::rotate(const Vec3& _rvec) const
+{
+    return rotate(Affine3f(_rvec).rotation());
+}
+
 template<typename T> inline
 cv::Affine3<T> cv::Affine3<T>::translate(const Vec3& t) const
 {
@@ -404,6 +423,12 @@ cv::Affine3<T>::operator Affine3<Y>() const
     return Affine3<Y>(matrix);
 }
 
+template<typename T> template <typename Y> inline
+cv::Affine3<Y> cv::Affine3<T>::cast() const
+{
+    return Affine3<Y>(matrix);
+}
+
 template<typename T> inline
 cv::Affine3<T> cv::operator*(const cv::Affine3<T>& affine1, const cv::Affine3<T>& affine2)
 {

modules/viz/include/opencv2/viz.hpp

@@ -41,9 +41,6 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #ifndef __OPENCV_VIZ_HPP__
@@ -58,17 +55,20 @@ namespace cv
     namespace viz
     {
         //! takes coordiante frame data and builds transfrom to global coordinate frame
-        CV_EXPORTS Affine3f makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin = Vec3f::all(0));
+        CV_EXPORTS Affine3d makeTransformToGlobal(const Vec3d& axis_x, const Vec3d& axis_y, const Vec3d& axis_z, const Vec3d& origin = Vec3d::all(0));
 
         //! 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);
+        CV_EXPORTS Affine3d makeCameraPose(const Vec3d& position, const Vec3d& focal_point, const Vec3d& y_dir);
 
         //! retrieves a window by its name. If no window with such name, then it creates new.
-        CV_EXPORTS Viz3d get(const String &window_name);
+        CV_EXPORTS Viz3d getWindowByName(const String &window_name);
 
-        //! Unregisters all Viz windows from internal database. After it 'get()' will create new windows instead getting existing from the database.
+        //! Unregisters all Viz windows from internal database. After it 'getWindowByName()' will create new windows instead getting existing from the database.
         CV_EXPORTS void unregisterAllWindows();
 
+        //! Displays image in specified window
+        CV_EXPORTS Viz3d imshow(const String& window_name, InputArray image, const Size& window_size = Size(-1, -1));
+
         //! checks float value for Nan
         inline bool isNan(float x)
         {
@@ -91,6 +91,36 @@ namespace cv
         template<typename _Tp> inline bool isNan(const Point3_<_Tp>& p)
         { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
 
+
+        ///////////////////////////////////////////////////////////////////////////////////////////////
+        /// Read/write clouds. Supported formats: ply, xyz, obj and stl (readonly)
+
+        CV_EXPORTS void writeCloud(const String& file, InputArray cloud, InputArray colors = noArray(), InputArray normals = noArray(), bool binary = false);
+        CV_EXPORTS Mat  readCloud (const String& file, OutputArray colors = noArray(), OutputArray normals = noArray());
+
+        ///////////////////////////////////////////////////////////////////////////////////////////////
+        /// Reads mesh. Only ply format is supported now and no texture load support
+
+        CV_EXPORTS Mesh readMesh(const String& file);
+
+        ///////////////////////////////////////////////////////////////////////////////////////////////
+        /// Read/write poses and trajectories
+
+        CV_EXPORTS bool readPose(const String& file, Affine3d& pose, const String& tag = "pose");
+        CV_EXPORTS void writePose(const String& file, const Affine3d& pose, const String& tag = "pose");
+
+        //! takes vector<Affine3<T>> with T = float/dobule and writes to a sequence of files with given filename format
+        CV_EXPORTS void writeTrajectory(InputArray traj, const String& files_format = "pose%05d.xml", int start = 0, const String& tag = "pose");
+
+        //! takes vector<Affine3<T>> with T = float/dobule and loads poses from sequence of files
+        CV_EXPORTS void readTrajectory(OutputArray traj, const String& files_format = "pose%05d.xml", int start = 0, int end = INT_MAX, const String& tag = "pose");
+
+
+        ///////////////////////////////////////////////////////////////////////////////////////////////
+        /// Computing normals for mesh
+
+        CV_EXPORTS void computeNormals(const Mesh& mesh, OutputArray normals);
+
     } /* namespace viz */
 } /* namespace cv */
 

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

@@ -41,9 +41,6 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #ifndef __OPENCV_VIZ_TYPES_HPP__
@@ -77,97 +74,113 @@ namespace cv
             static Color white();
 
             static Color gray();
+
+            static Color mlab();
+
+            static Color navy();
+            static Color olive();
+            static Color maroon();
+            static Color teal();
+            static Color rose();
+            static Color azure();
+            static Color lime();
+            static Color gold();
+            static Color brown();
+            static Color orange();
+            static Color chartreuse();
+            static Color orange_red();
+            static Color purple();
+            static Color indigo();
+
+            static Color pink();
+            static Color cherry();
+            static Color bluberry();
+            static Color raspberry();
+            static Color silver();
+            static Color violet();
+            static Color apricot();
+            static Color turquoise();
+            static Color celestial_blue();
+            static Color amethyst();
+
+            static Color not_set();
         };
 
-        class CV_EXPORTS Mesh3d
+        class CV_EXPORTS Mesh
         {
         public:
+            Mat cloud, colors, normals;
 
-            Mat cloud, colors;
+            //! Raw integer list of the form: (n,id1,id2,...,idn, n,id1,id2,...,idn, ...)
+            //! where n is the number of points in the poligon, and id is a zero-offset index into an associated cloud.
             Mat polygons;
 
-            //! Loads mesh from a given ply file
-            static cv::viz::Mesh3d loadMesh(const String& file);
+            Mat texture, tcoords;
 
-        private:
-            struct loadMeshImpl;
+            //! Loads mesh from a given ply file (no texture load support for now)
+            static Mesh load(const String& file);
         };
 
-        class CV_EXPORTS KeyboardEvent
+        class CV_EXPORTS Camera
         {
         public:
-            static const unsigned int Alt   = 1;
-            static const unsigned int Ctrl  = 2;
-            static const unsigned int Shift = 4;
+            Camera(double fx, double fy, double cx, double cy, const Size &window_size);
+            explicit Camera(const Vec2d &fov, const Size &window_size);
+            explicit Camera(const Matx33d &K, const Size &window_size);
+            explicit Camera(const Matx44d &proj, const Size &window_size);
 
-            //! Create a keyboard event
-            //! - Note that action is true if key is pressed, false if released
-            KeyboardEvent(bool action, const String& key_sym, unsigned char key, bool alt, bool ctrl, bool shift);
+            const Vec2d & getClip() const { return clip_; }
+            void setClip(const Vec2d &clip) { clip_ = clip; }
 
-            bool isAltPressed() const;
-            bool isCtrlPressed() const;
-            bool isShiftPressed() const;
+            const Size & getWindowSize() const { return window_size_; }
+            void setWindowSize(const Size &window_size);
+
+            const Vec2d& getFov() const { return fov_; }
+            void setFov(const Vec2d& fov) { fov_ = fov; }
 
-            unsigned char getKeyCode() const;
+            const Vec2d& getPrincipalPoint() const { return principal_point_; }
+            const Vec2d& getFocalLength() const { return focal_; }
 
-            const String& getKeySym() const;
-            bool keyDown() const;
-            bool keyUp() const;
+            void computeProjectionMatrix(Matx44d &proj) const;
 
-        protected:
+            static Camera KinectCamera(const Size &window_size);
+
+        private:
+            void init(double fx, double fy, double cx, double cy, const Size &window_size);
 
-            bool action_;
-            unsigned int modifiers_;
-            unsigned char key_code_;
-            String key_sym_;
+            Vec2d clip_;
+            Vec2d fov_;
+            Size window_size_;
+            Vec2d principal_point_;
+            Vec2d focal_;
         };
 
-        class CV_EXPORTS MouseEvent
+        class CV_EXPORTS KeyboardEvent
         {
         public:
-            enum Type { MouseMove = 1, MouseButtonPress, MouseButtonRelease, MouseScrollDown, MouseScrollUp, MouseDblClick } ;
-            enum MouseButton { NoButton = 0, LeftButton, MiddleButton, RightButton, VScroll } ;
+            enum { NONE = 0, ALT = 1, CTRL = 2, SHIFT = 4 };
+            enum Action { KEY_UP = 0, KEY_DOWN = 1 };
 
-            MouseEvent(const Type& type, const MouseButton& button, const Point& p, bool alt, bool ctrl, bool shift);
+            KeyboardEvent(Action action, const String& symbol, unsigned char code, int modifiers);
 
-            Type type;
-            MouseButton button;
-            Point pointer;
-            unsigned int key_state;
+            Action action;
+            String symbol;
+            unsigned char code;
+            int modifiers;
         };
 
-        class CV_EXPORTS Camera
+        class CV_EXPORTS MouseEvent
         {
         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);
+            enum Type { MouseMove = 1, MouseButtonPress, MouseButtonRelease, MouseScrollDown, MouseScrollUp, MouseDblClick } ;
+            enum MouseButton { NoButton = 0, LeftButton, MiddleButton, RightButton, VScroll } ;
 
-        private:
-            void init(float f_x, float f_y, float c_x, float c_y, const Size &window_size);
+            MouseEvent(const Type& type, const MouseButton& button, const Point& pointer, int modifiers);
 
-            Vec2d clip_;
-            Vec2f fov_;
-            Size window_size_;
-            Vec2f principal_point_;
-            Vec2f focal_;
+            Type type;
+            MouseButton button;
+            Point pointer;
+            int modifiers;
         };
     } /* namespace viz */
 } /* namespace cv */
@@ -190,5 +203,34 @@ inline cv::viz::Color cv::viz::Color::magenta() { return Color(255,   0, 255); }
 inline cv::viz::Color cv::viz::Color::white()   { return Color(255, 255, 255); }
 inline cv::viz::Color cv::viz::Color::gray()    { return Color(128, 128, 128); }
 
+inline cv::viz::Color cv::viz::Color::mlab()    { return Color(255, 128, 128); }
+
+inline cv::viz::Color cv::viz::Color::navy()       { return Color(0,     0, 128); }
+inline cv::viz::Color cv::viz::Color::olive()      { return Color(0,   128, 128); }
+inline cv::viz::Color cv::viz::Color::maroon()     { return Color(0,     0, 128); }
+inline cv::viz::Color cv::viz::Color::teal()       { return Color(128, 128,   0); }
+inline cv::viz::Color cv::viz::Color::rose()       { return Color(128,   0, 255); }
+inline cv::viz::Color cv::viz::Color::azure()      { return Color(255, 128,   0); }
+inline cv::viz::Color cv::viz::Color::lime()       { return Color(0,   255, 191); }
+inline cv::viz::Color cv::viz::Color::gold()       { return Color(0,   215, 255); }
+inline cv::viz::Color cv::viz::Color::brown()      { return Color(0,    75, 150); }
+inline cv::viz::Color cv::viz::Color::orange()     { return Color(0,   165, 255); }
+inline cv::viz::Color cv::viz::Color::chartreuse() { return Color(0,   255, 128); }
+inline cv::viz::Color cv::viz::Color::orange_red() { return Color(0,    69, 255); }
+inline cv::viz::Color cv::viz::Color::purple()     { return Color(128,   0, 128); }
+inline cv::viz::Color cv::viz::Color::indigo()     { return Color(130,   0,  75); }
+
+inline cv::viz::Color cv::viz::Color::pink()           { return Color(203, 192, 255); }
+inline cv::viz::Color cv::viz::Color::cherry()         { return Color( 99,  29, 222); }
+inline cv::viz::Color cv::viz::Color::bluberry()       { return Color(247, 134,  79); }
+inline cv::viz::Color cv::viz::Color::raspberry()      { return Color( 92,  11, 227); }
+inline cv::viz::Color cv::viz::Color::silver()         { return Color(192, 192, 192); }
+inline cv::viz::Color cv::viz::Color::violet()         { return Color(226,  43, 138); }
+inline cv::viz::Color cv::viz::Color::apricot()        { return Color(177, 206, 251); }
+inline cv::viz::Color cv::viz::Color::turquoise()      { return Color(208, 224,  64); }
+inline cv::viz::Color cv::viz::Color::celestial_blue() { return Color(208, 151,  73); }
+inline cv::viz::Color cv::viz::Color::amethyst()       { return Color(204, 102, 153); }
+
+inline cv::viz::Color cv::viz::Color::not_set()        { return Color(-1, -1, -1); }
 
 #endif

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

@@ -41,9 +41,6 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #ifndef __OPENCV_VIZ_VIZ3D_HPP__
@@ -64,6 +61,7 @@ namespace cv
         class CV_EXPORTS Viz3d
         {
         public:
+            typedef cv::viz::Color Color;
             typedef void (*KeyboardCallback)(const KeyboardEvent&, void*);
             typedef void (*MouseCallback)(const MouseEvent&, void*);
 
@@ -72,19 +70,21 @@ namespace cv
             Viz3d& operator=(const Viz3d&);
             ~Viz3d();
 
-            void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
+            void showWidget(const String &id, const Widget &widget, const Affine3d &pose = Affine3d::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 showImage(InputArray image, const Size& window_size = Size(-1, -1));
+
+            void setWidgetPose(const String &id, const Affine3d &pose);
+            void updateWidgetPose(const String &id, const Affine3d &pose);
+            Affine3d getWidgetPose(const String &id) const;
 
             void setCamera(const Camera &camera);
             Camera getCamera() const;
-            Affine3f getViewerPose();
-            void setViewerPose(const Affine3f &pose);
+            Affine3d getViewerPose();
+            void setViewerPose(const Affine3d &pose);
 
             void resetCameraViewpoint(const String &id);
             void resetCamera();
@@ -96,13 +96,16 @@ namespace cv
             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 setWindowPosition(const Point& window_position);
+            void setFullScreen(bool mode = true);
+            void setBackgroundColor(const Color& color = Color::black(), const Color& color2 = Color::not_set());
+            void setBackgroundTexture(InputArray image = noArray());
+            void setBackgroundMeshLab();
 
             void spin();
             void spinOnce(int time = 1, bool force_redraw = false);
             bool wasStopped() const;
+            void close();
 
             void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
             void registerMouseCallback(MouseCallback callback, void* cookie = 0);
@@ -110,9 +113,6 @@ namespace cv
             void setRenderingProperty(const String &id, int property, double value);
             double getRenderingProperty(const String &id, int property);
 
-            void setDesiredUpdateRate(double rate);
-            double getDesiredUpdateRate();
-
             void setRepresentation(int representation);
         private:
 

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

@@ -41,9 +41,6 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #ifndef __OPENCV_VIZ_WIDGET_ACCESSOR_HPP__

modules/viz/src/interactor_style.hpp

@@ -41,9 +41,6 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #ifndef __OPENCV_VIZ_INTERACTOR_STYLE_H__
@@ -56,9 +53,6 @@ namespace cv
         class InteractorStyle : public vtkInteractorStyleTrackballCamera
         {
         public:
-
-            enum KeyboardModifier { KB_MOD_ALT, KB_MOD_CTRL, KB_MOD_SHIFT };
-
             static InteractorStyle *New();
             virtual ~InteractorStyle() {}
 
@@ -69,31 +63,21 @@ namespace cv
             virtual void Initialize();
 
             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);
             void saveScreenshot(const String &file);
-
-            /** \brief Change the default keyboard modified from ALT to a different special key.*/
-            inline void setKeyboardModifier(const KeyboardModifier &modifier) { modifier_ = modifier; }
+            void exportScene(const String &file);
 
         private:
             /** \brief Set to true after initialization is complete. */
             bool init_;
 
-            vtkSmartPointer<vtkRenderer> renderer_;
             Ptr<WidgetActorMap> widget_actor_map_;
 
             Vec2i win_size_;
             Vec2i win_pos_;
             Vec2i max_win_size_;
 
-            /** \brief A PNG writer for screenshot captures. */
-            vtkSmartPointer<vtkPNGWriter> snapshot_writer_;
-
-            /** \brief Internal window to image filter. Needed by \a snapshot_writer_. */
-            vtkSmartPointer<vtkWindowToImageFilter> wif_;
-
             /** \brief Interactor style internal method. Gets called whenever a key is pressed. */
             virtual void OnChar();
 
@@ -121,17 +105,13 @@ namespace cv
             /** \brief True if we're using red-blue colors for anaglyphic stereo, false if magenta-green. */
             bool stereo_anaglyph_mask_default_;
 
-            KeyboardModifier modifier_;
-
             void (*keyboardCallback_)(const KeyboardEvent&, void*);
             void *keyboard_callback_cookie_;
 
             void (*mouseCallback_)(const MouseEvent&, void*);
             void *mouse_callback_cookie_;
 
-            bool getAltKey();
-            bool getControlKey();
-            bool getShiftKey();
+            int getModifiers();
         };
     }
 }

modules/viz/src/precomp.hpp

@@ -41,9 +41,6 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #ifndef __OPENCV_VIZ_PRECOMP_HPP__
@@ -53,6 +50,8 @@
 #include <ctime>
 #include <list>
 #include <vector>
+#include <iomanip>
+#include <limits>
 
 #include <vtkAppendPolyData.h>
 #include <vtkAssemblyPath.h>
@@ -94,13 +93,13 @@
 #include <vtkInteractorStyleTrackballCamera.h>
 #include <vtkProperty.h>
 #include <vtkCamera.h>
-#include <vtkObjectFactory.h>
 #include <vtkPlanes.h>
 #include <vtkImageFlip.h>
 #include <vtkRenderWindow.h>
 #include <vtkTextProperty.h>
 #include <vtkProperty2D.h>
 #include <vtkLODActor.h>
+#include <vtkActor.h>
 #include <vtkTextActor.h>
 #include <vtkRenderWindowInteractor.h>
 #include <vtkMath.h>
@@ -110,12 +109,50 @@
 #include <vtkPolyDataNormals.h>
 #include <vtkAlgorithmOutput.h>
 #include <vtkImageMapper.h>
+#include <vtkPoints.h>
+#include <vtkInformation.h>
+#include <vtkInformationVector.h>
+#include <vtkObjectFactory.h>
+#include <vtkPolyDataAlgorithm.h>
+#include <vtkMergeFilter.h>
+#include <vtkDataSetWriter.h>
+#include <vtkErrorCode.h>
+#include <vtkPLYWriter.h>
+#include <vtkSTLWriter.h>
+#include <vtkSimplePointsReader.h>
+#include <vtkPLYReader.h>
+#include <vtkOBJReader.h>
+#include <vtkSTLReader.h>
+#include <vtkPNGReader.h>
+#include <vtkOBJExporter.h>
+#include <vtkVRMLExporter.h>
+#include <vtkTensorGlyph.h>
+#include <vtkImageAlgorithm.h>
+#include <vtkTransformFilter.h>
+#include <vtkConeSource.h>
+#include <vtkElevationFilter.h>
+#include <vtkColorTransferFunction.h>
+#include <vtkStreamingDemandDrivenPipeline.h>
+
+#if !defined(_WIN32) || defined(__CYGWIN__)
+# include <unistd.h> /* unlink */
+#else
+# include <io.h> /* unlink */
+#endif
+
+#include <vtk/vtkOBJWriter.h>
+#include <vtk/vtkXYZWriter.h>
+#include <vtk/vtkCloudMatSink.h>
+#include <vtk/vtkCloudMatSource.h>
+#include <vtk/vtkTrajectorySource.h>
+#include <vtk/vtkImageMatSource.h>
 
 #include <opencv2/core.hpp>
 #include <opencv2/viz.hpp>
 #include <opencv2/viz/widget_accessor.hpp>
 #include <opencv2/core/utility.hpp>
 
+
 namespace cv
 {
     namespace viz
@@ -144,11 +181,145 @@ namespace cv
             static VizMap storage;
             friend class Viz3d;
         };
+
+        template<typename _Tp> inline _Tp normalized(const _Tp& v) { return v * 1/norm(v); }
+
+        template<typename _Tp> inline bool isNan(const _Tp* data)
+        {
+            return isNan(data[0]) || isNan(data[1]) || isNan(data[2]);
+        }
+
+        inline vtkSmartPointer<vtkActor> getActor(const Widget3D& widget)
+        {
+            return vtkActor::SafeDownCast(WidgetAccessor::getProp(widget));
+        }
+
+        inline vtkSmartPointer<vtkPolyData> getPolyData(const Widget3D& widget)
+        {
+            vtkSmartPointer<vtkMapper> mapper = getActor(widget)->GetMapper();
+            return vtkPolyData::SafeDownCast(mapper->GetInput());
+        }
+
+        inline vtkSmartPointer<vtkMatrix4x4> vtkmatrix(const cv::Matx44d &matrix)
+        {
+            vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New();
+            vtk_matrix->DeepCopy(matrix.val);
+            return vtk_matrix;
+        }
+
+        inline Color vtkcolor(const Color& color)
+        {
+            Color scaled_color = color * (1.0/255.0);
+            std::swap(scaled_color[0], scaled_color[2]);
+            return scaled_color;
+        }
+
+        inline Vec3d get_random_vec(double from = -10.0, double to = 10.0)
+        {
+            RNG& rng = theRNG();
+            return Vec3d(rng.uniform(from, to), rng.uniform(from, to), rng.uniform(from, to));
+        }
+
+        struct VtkUtils
+        {
+            template<class Filter>
+            static void SetInputData(vtkSmartPointer<Filter> filter, vtkPolyData* polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->SetInput(polydata);
+            #else
+                filter->SetInputData(polydata);
+            #endif
+            }
+            template<class Filter>
+            static void SetSourceData(vtkSmartPointer<Filter> filter, vtkPolyData* polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->SetSource(polydata);
+            #else
+                filter->SetSourceData(polydata);
+            #endif
+            }
+
+            template<class Filter>
+            static void SetInputData(vtkSmartPointer<Filter> filter, vtkImageData* polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->SetInput(polydata);
+            #else
+                filter->SetInputData(polydata);
+            #endif
+            }
+
+            template<class Filter>
+            static void AddInputData(vtkSmartPointer<Filter> filter, vtkPolyData *polydata)
+            {
+            #if VTK_MAJOR_VERSION <= 5
+                filter->AddInput(polydata);
+            #else
+                filter->AddInputData(polydata);
+            #endif
+            }
+
+            static vtkSmartPointer<vtkUnsignedCharArray> FillScalars(size_t size, const Color& color)
+            {
+                Vec3b rgb = Vec3d(color[2], color[1], color[0]);
+                Vec3b* color_data = new Vec3b[size];
+                std::fill(color_data, color_data + size, rgb);
+
+                vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
+                scalars->SetName("Colors");
+                scalars->SetNumberOfComponents(3);
+                scalars->SetNumberOfTuples(size);
+                scalars->SetArray(color_data->val, size * 3, 0);
+                return scalars;
+            }
+
+            static vtkSmartPointer<vtkPolyData> ComputeNormals(vtkSmartPointer<vtkPolyData> polydata)
+            {
+                vtkSmartPointer<vtkPolyDataNormals> normals_generator = vtkSmartPointer<vtkPolyDataNormals>::New();
+                normals_generator->ComputePointNormalsOn();
+                normals_generator->ComputeCellNormalsOff();
+                normals_generator->SetFeatureAngle(0.1);
+                normals_generator->SetSplitting(0);
+                normals_generator->SetConsistency(1);
+                normals_generator->SetAutoOrientNormals(0);
+                normals_generator->SetFlipNormals(0);
+                normals_generator->SetNonManifoldTraversal(1);
+                VtkUtils::SetInputData(normals_generator, polydata);
+                normals_generator->Update();
+                return normals_generator->GetOutput();
+            }
+
+            static vtkSmartPointer<vtkPolyData> TransformPolydata(vtkSmartPointer<vtkAlgorithmOutput> algorithm_output_port, const Affine3d& pose)
+            {
+                vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+                transform->SetMatrix(vtkmatrix(pose.matrix));
+
+                vtkSmartPointer<vtkTransformPolyDataFilter> transform_filter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+                transform_filter->SetTransform(transform);
+                transform_filter->SetInputConnection(algorithm_output_port);
+                transform_filter->Update();
+                return transform_filter->GetOutput();
+            }
+
+            static vtkSmartPointer<vtkPolyData> TransformPolydata(vtkSmartPointer<vtkPolyData> polydata, const Affine3d& pose)
+            {
+                vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
+                transform->SetMatrix(vtkmatrix(pose.matrix));
+
+                vtkSmartPointer<vtkTransformPolyDataFilter> transform_filter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+                VtkUtils::SetInputData(transform_filter, polydata);
+                transform_filter->SetTransform(transform);
+                transform_filter->Update();
+                return transform_filter->GetOutput();
+            }
+        };
     }
 }
 
 #include "interactor_style.hpp"
-#include "viz3d_impl.hpp"
+#include "vizimpl.hpp"
 
 
 #endif

modules/viz/src/viz3d.cpp

@@ -41,9 +41,6 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #include "precomp.hpp"
@@ -104,6 +101,7 @@ void cv::viz::Viz3d::release()
 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(); }
+void cv::viz::Viz3d::close() { impl_->close(); }
 
 void cv::viz::Viz3d::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
 { impl_->registerKeyboardCallback(callback, cookie); }
@@ -111,18 +109,21 @@ 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::showWidget(const String &id, const Widget &widget, const Affine3d &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); }
+
+void cv::viz::Viz3d::showImage(InputArray image, const Size& window_size) { impl_->showImage(image, window_size); }
+
+void cv::viz::Viz3d::setWidgetPose(const String &id, const Affine3d &pose) { impl_->setWidgetPose(id, pose); }
+void cv::viz::Viz3d::updateWidgetPose(const String &id, const Affine3d &pose) { impl_->updateWidgetPose(id, pose); }
+cv::Affine3d cv::viz::Viz3d::getWidgetPose(const String &id) const { return impl_->getWidgetPose(id); }
 
 void cv::viz::Viz3d::setCamera(const Camera &camera) { impl_->setCamera(camera); }
 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::setViewerPose(const Affine3d &pose) { impl_->setViewerPose(pose); }
+cv::Affine3d 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(); }
@@ -131,17 +132,17 @@ void cv::viz::Viz3d::convertToWindowCoordinates(const Point3d &pt, Point3d &wind
 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); }
+void cv::viz::Viz3d::setWindowSize(const Size &window_size) { impl_->setWindowSize(window_size); }
 cv::String cv::viz::Viz3d::getWindowName() const { return impl_->getWindowName(); }
 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::setWindowPosition(const Point& window_position) { impl_->setWindowPosition(window_position); }
 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::setBackgroundColor(const Color& color, const Color& color2) { impl_->setBackgroundColor(color, color2); }
+
+void cv::viz::Viz3d::setBackgroundTexture(InputArray image) { impl_->setBackgroundTexture(image); }
+void cv::viz::Viz3d::setBackgroundMeshLab() {impl_->setBackgroundMeshLab(); }
 
 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 rate) { impl_->setDesiredUpdateRate(rate); }
-double cv::viz::Viz3d::getDesiredUpdateRate() { return impl_->getDesiredUpdateRate(); }
-
 void cv::viz::Viz3d::setRepresentation(int representation) { impl_->setRepresentation(representation); }

modules/viz/src/viz.cpp → modules/viz/src/vizcore.cpp

@@ -41,71 +41,29 @@
 //  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
 #include "precomp.hpp"
 
-cv::Affine3f cv::viz::makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin)
+cv::Affine3d cv::viz::makeTransformToGlobal(const Vec3d& axis_x, const Vec3d& axis_y, const Vec3d& axis_z, const Vec3d& origin)
 {
-    Affine3f::Mat3 R(axis_x[0], axis_y[0], axis_z[0],
+    Affine3d::Mat3 R(axis_x[0], axis_y[0], axis_z[0],
                      axis_x[1], axis_y[1], axis_z[1],
                      axis_x[2], axis_y[2], axis_z[2]);
 
-    return Affine3f(R, origin);
+    return Affine3d(R, origin);
 }
 
-cv::Affine3f cv::viz::makeCameraPose(const Vec3f& position, const Vec3f& focal_point, const Vec3f& y_dir)
+cv::Affine3d cv::viz::makeCameraPose(const Vec3d& position, const Vec3d& focal_point, const Vec3d& y_dir)
 {
     // Compute the transformation matrix for drawing the camera frame in a scene
-    Vec3f n = normalize(focal_point - position);
-    Vec3f u = normalize(y_dir.cross(n));
-    Vec3f v = n.cross(u);
+    Vec3d n = normalize(focal_point - position);
+    Vec3d u = normalize(y_dir.cross(n));
+    Vec3d v = n.cross(u);
 
     return makeTransformToGlobal(u, v, n, position);
 }
 
-vtkSmartPointer<vtkMatrix4x4> cv::viz::convertToVtkMatrix(const cv::Matx44f &m)
-{
-    vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New();
-    for (int i = 0; i < 4; i++)
-        for (int k = 0; k < 4; k++)
-            vtk_matrix->SetElement(i, k, m(i, k));
-    return vtk_matrix;
-}
-
-cv::Matx44f cv::viz::convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
-{
-    cv::Matx44f m;
-    for (int i = 0; i < 4; i++)
-        for (int k = 0; k < 4; k++)
-            m(i, k) = vtk_matrix->GetElement(i, k);
-    return m;
-}
-
-namespace cv { namespace viz
-{
-    template<typename _Tp> Vec<_Tp, 3>* vtkpoints_data(vtkSmartPointer<vtkPoints>& points);
-
-    template<> Vec3f* vtkpoints_data<float>(vtkSmartPointer<vtkPoints>& points)
-    {
-        CV_Assert(points->GetDataType() == VTK_FLOAT);
-        vtkDataArray *data = points->GetData();
-        float *pointer = static_cast<vtkFloatArray*>(data)->GetPointer(0);
-        return reinterpret_cast<Vec3f*>(pointer);
-    }
-
-    template<> Vec3d* vtkpoints_data<double>(vtkSmartPointer<vtkPoints>& points)
-    {
-        CV_Assert(points->GetDataType() == VTK_DOUBLE);
-        vtkDataArray *data = points->GetData();
-        double *pointer = static_cast<vtkDoubleArray*>(data)->GetPointer(0);
-        return reinterpret_cast<Vec3d*>(pointer);
-    }
-}}
-
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// VizStorage implementation
 
@@ -161,5 +119,194 @@ cv::String cv::viz::VizStorage::generateWindowName(const String &window_name)
     return output;
 }
 
-cv::viz::Viz3d cv::viz::get(const String &window_name) { return Viz3d (window_name); }
+cv::viz::Viz3d cv::viz::getWindowByName(const String &window_name) { return Viz3d (window_name); }
 void cv::viz::unregisterAllWindows() { VizStorage::unregisterAll(); }
+
+cv::viz::Viz3d cv::viz::imshow(const String& window_name, InputArray image, const Size& window_size)
+{
+    Viz3d viz = getWindowByName(window_name);
+    viz.showImage(image, window_size);
+    return viz;
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Read/write clouds. Supported formats: ply, stl, xyz, obj
+
+void cv::viz::writeCloud(const String& file, InputArray cloud, InputArray colors, InputArray normals, bool binary)
+{
+    CV_Assert(file.size() > 4 && "Extention is required");
+    String extention = file.substr(file.size()-4);
+
+    vtkSmartPointer<vtkCloudMatSource> source = vtkSmartPointer<vtkCloudMatSource>::New();
+    source->SetColorCloudNormals(cloud, colors, normals);
+
+    vtkSmartPointer<vtkWriter> writer;
+    if (extention == ".xyz")
+    {
+        writer = vtkSmartPointer<vtkXYZWriter>::New();
+        vtkXYZWriter::SafeDownCast(writer)->SetFileName(file.c_str());
+    }
+    else if (extention == ".ply")
+    {
+        writer = vtkSmartPointer<vtkPLYWriter>::New();
+        vtkPLYWriter::SafeDownCast(writer)->SetFileName(file.c_str());
+        vtkPLYWriter::SafeDownCast(writer)->SetFileType(binary ? VTK_BINARY : VTK_ASCII);
+        vtkPLYWriter::SafeDownCast(writer)->SetArrayName("Colors");
+    }
+    else if (extention == ".obj")
+    {
+        writer = vtkSmartPointer<vtkOBJWriter>::New();
+        vtkOBJWriter::SafeDownCast(writer)->SetFileName(file.c_str());
+    }
+    else
+        CV_Assert(!"Unsupported format");
+
+    writer->SetInputConnection(source->GetOutputPort());
+    writer->Write();
+}
+
+cv::Mat cv::viz::readCloud(const String& file, OutputArray colors, OutputArray normals)
+{
+    CV_Assert(file.size() > 4 && "Extention is required");
+    String extention = file.substr(file.size()-4);
+
+    vtkSmartPointer<vtkPolyDataAlgorithm> reader;
+    if (extention == ".xyz")
+    {
+        reader = vtkSmartPointer<vtkSimplePointsReader>::New();
+        vtkSimplePointsReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else if (extention == ".ply")
+    {
+        reader = vtkSmartPointer<vtkPLYReader>::New();
+        CV_Assert(vtkPLYReader::CanReadFile(file.c_str()));
+        vtkPLYReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else if (extention == ".obj")
+    {
+        reader = vtkSmartPointer<vtkOBJReader>::New();
+        vtkOBJReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else if (extention == ".stl")
+    {
+        reader = vtkSmartPointer<vtkSTLReader>::New();
+        vtkSTLReader::SafeDownCast(reader)->SetFileName(file.c_str());
+    }
+    else
+        CV_Assert(!"Unsupported format");
+
+    cv::Mat cloud;
+
+    vtkSmartPointer<vtkCloudMatSink> sink = vtkSmartPointer<vtkCloudMatSink>::New();
+    sink->SetInputConnection(reader->GetOutputPort());
+    sink->SetOutput(cloud, colors, normals);
+    sink->Write();
+
+    return cloud;
+}
+
+cv::viz::Mesh cv::viz::readMesh(const String& file) { return Mesh::load(file); }
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Read/write poses and trajectories
+
+bool cv::viz::readPose(const String& file, Affine3d& pose, const String& tag)
+{
+    FileStorage fs(file, FileStorage::READ);
+    if (!fs.isOpened())
+        return false;
+
+    Mat hdr(pose.matrix, false);
+    fs[tag] >> hdr;
+    if (hdr.empty() || hdr.cols != pose.matrix.cols || hdr.rows != pose.matrix.rows)
+        return false;
+
+    hdr.convertTo(pose.matrix, CV_64F);
+    return true;
+}
+
+void cv::viz::writePose(const String& file, const Affine3d& pose, const String& tag)
+{
+    FileStorage fs(file, FileStorage::WRITE);
+    fs << tag << Mat(pose.matrix, false);
+}
+
+void cv::viz::readTrajectory(OutputArray _traj, const String& files_format, int start, int end, const String& tag)
+{
+    CV_Assert(_traj.kind() == _InputArray::STD_VECTOR || _traj.kind() == _InputArray::MAT);
+
+    start = max(0, std::min(start, end));
+    end = std::max(start, end);
+
+    std::vector<Affine3d> traj;
+
+    for(int i = start; i < end; ++i)
+    {
+        Affine3d affine;
+        bool ok = readPose(cv::format(files_format.c_str(), i), affine, tag);
+        if (!ok)
+            break;
+
+        traj.push_back(affine);
+    }
+
+    Mat(traj).convertTo(_traj, _traj.depth());
+}
+
+void cv::viz::writeTrajectory(InputArray _traj, const String& files_format, int start, const String& tag)
+{
+    if (_traj.kind() == _InputArray::STD_VECTOR_MAT)
+    {
+        std::vector<Mat>& v = *(std::vector<Mat>*)_traj.getObj();
+
+        for(size_t i = 0, index = max(0, start); i < v.size(); ++i, ++index)
+        {
+            Affine3d affine;
+            Mat pose = v[i];
+            CV_Assert(pose.type() == CV_32FC(16) || pose.type() == CV_64FC(16));
+            pose.copyTo(affine.matrix);
+            writePose(cv::format(files_format.c_str(), index), affine, tag);
+        }
+        return;
+    }
+
+    if (_traj.kind() == _InputArray::STD_VECTOR || _traj.kind() == _InputArray::MAT)
+    {
+        CV_Assert(_traj.type() == CV_32FC(16) || _traj.type() == CV_64FC(16));
+
+        Mat traj = _traj.getMat();
+
+        if (traj.depth() == CV_32F)
+            for(size_t i = 0, index = max(0, start); i < traj.total(); ++i, ++index)
+                writePose(cv::format(files_format.c_str(), index), traj.at<Affine3f>(i), tag);
+
+        if (traj.depth() == CV_64F)
+            for(size_t i = 0, index = max(0, start); i < traj.total(); ++i, ++index)
+                writePose(cv::format(files_format.c_str(), index), traj.at<Affine3d>(i), tag);
+    }
+
+    CV_Assert(!"Unsupported array kind");
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Computing normals for mesh
+
+void cv::viz::computeNormals(const Mesh& mesh, OutputArray _normals)
+{
+    vtkSmartPointer<vtkPolyData> polydata = getPolyData(WMesh(mesh));
+    vtkSmartPointer<vtkPolyData> with_normals = VtkUtils::ComputeNormals(polydata);
+
+    vtkSmartPointer<vtkDataArray> generic_normals = with_normals->GetPointData()->GetNormals();
+    if(generic_normals)
+    {
+        Mat normals(1, generic_normals->GetNumberOfTuples(), CV_64FC3);
+        Vec3d *optr = normals.ptr<Vec3d>();
+
+        for(int i = 0; i < generic_normals->GetNumberOfTuples(); ++i, ++optr)
+            generic_normals->GetTuple(i, optr->val);
+
+        normals.convertTo(_normals, mesh.cloud.type());
+    }
+    else
+        _normals.release();
+}

modules/viz/src/vtk/vtkCloudMatSink.h

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                           License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+// Authors:
+//  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
+//
+//M*/
+
+#ifndef __vtkCloudMatSink_h
+#define __vtkCloudMatSink_h
+
+#include <opencv2/core.hpp>
+#include <vtkPolyDataWriter.h>
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkCloudMatSink : public vtkPolyDataWriter
+        {
+        public:
+          static vtkCloudMatSink *New();
+          vtkTypeMacro(vtkCloudMatSink,vtkPolyDataWriter)
+          void PrintSelf(ostream& os, vtkIndent indent);
+
+          void SetOutput(OutputArray cloud, OutputArray colors = noArray(), OutputArray normals = noArray(), OutputArray tcoords = noArray());
+
+        protected:
+          vtkCloudMatSink();
+          ~vtkCloudMatSink();
+
+          void WriteData();
+
+          _OutputArray cloud, colors, normals, tcoords;
+
+        private:
+          vtkCloudMatSink(const vtkCloudMatSink&);  // Not implemented.
+          void operator=(const vtkCloudMatSink&);  // Not implemented.
+        };
+    }
+}
+
+#endif

modules/viz/src/precomp.cpp → modules/viz/src/vtk/vtkOBJWriter.h

@@ -38,12 +38,42 @@
 // the use of this software, even if advised of the possibility of such damage.
 //
 // Authors:
-//  * Ozan Tonkal, ozantonkal@gmail.com
 //  * Anatoly Baksheev, Itseez Inc.  myname.mysurname <> mycompany.com
 //
-//  OpenCV Viz module is complete rewrite of
-//  PCL visualization module (www.pointclouds.org)
-//
 //M*/
 
-#include "precomp.hpp"
+#ifndef __vtkOBJWriter_h
+#define __vtkOBJWriter_h
+
+#include <vtkPolyDataWriter.h>
+
+namespace cv
+{
+    namespace viz
+    {
+        class vtkOBJWriter : public vtkPolyDataWriter
+        {
+        public:
+          static vtkOBJWriter *New();
+          vtkTypeMacro(vtkOBJWriter,vtkPolyDataWriter)
+          void PrintSelf(ostream& os, vtkIndent indent);
+
+          vtkGetMacro(DecimalPrecision, int);
+          vtkSetMacro(DecimalPrecision, int);
+
+        protected:
+          vtkOBJWriter();
+          ~vtkOBJWriter();
+
+          void WriteData();
+
+          int DecimalPrecision;
+
+        private:
+          vtkOBJWriter(const vtkOBJWriter&);  // Not implemented.
+          void operator=(const vtkOBJWriter&);  // Not implemented.
+        };
+    }
+}
+
+#endif