Merge pull request #16 from ozantonkal/implementing_widgets

Implementing widgets

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

@@ -32,22 +32,15 @@ namespace cv
             static Color gray();
         };
 
-
-        struct CV_EXPORTS Vertices
-        {
-            std::vector<unsigned int> vertices;
-        };
-
         class CV_EXPORTS Mesh3d
         {
         public:
-            typedef Ptr<Mesh3d> Ptr;
-
-            Mat cloud, colors;
-            std::vector<Vertices> polygons;
-
-            static Mesh3d::Ptr mesh_load(const String& file);
+            typedef cv::Ptr<Mesh3d> Ptr;
+            Mat cloud, colors, polygons;
+            static cv::viz::Mesh3d::Ptr loadMesh(const String& file);
             
+        private:
+            struct loadMeshImpl;
         };
 
         class CV_EXPORTS KeyboardEvent
@@ -101,7 +94,3 @@ namespace cv
 
     } /* namespace viz */
 } /* namespace cv */
\ No newline at end of file
-
-
-
-

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

@@ -160,6 +160,15 @@ namespace cv
             struct ApplyCloudNormals;
         };
         
+        class CV_EXPORTS MeshWidget : public Widget3D
+        {
+        public:
+            MeshWidget(const Mesh3d &mesh);
+            
+        private:
+            struct CopyImpl;
+        };
+
         template<> CV_EXPORTS Widget2D Widget::cast<Widget2D>();
         template<> CV_EXPORTS Widget3D Widget::cast<Widget3D>();
         template<> CV_EXPORTS LineWidget Widget::cast<LineWidget>();
@@ -176,9 +185,7 @@ namespace cv
         template<> CV_EXPORTS TextWidget Widget::cast<TextWidget>();
         template<> CV_EXPORTS CloudWidget Widget::cast<CloudWidget>();
         template<> CV_EXPORTS CloudNormalsWidget Widget::cast<CloudNormalsWidget>();
+        template<> CV_EXPORTS MeshWidget Widget::cast<MeshWidget>();
 
     } /* namespace viz */
 } /* namespace cv */
\ No newline at end of file
-
-
-

modules/viz/src/cloud_widgets.cpp

 #include "precomp.hpp"
 
+namespace cv
+{
+    namespace viz
+    {
+        template<typename _Tp> Vec<_Tp, 3>* vtkpoints_data(vtkSmartPointer<vtkPoints>& points);
+    }
+}
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// Point Cloud Widget implementation
@@ -311,3 +318,155 @@ template<> cv::viz::CloudNormalsWidget cv::viz::Widget::cast<cv::viz::CloudNorma
     Widget3D widget = this->cast<Widget3D>();
     return static_cast<CloudNormalsWidget&>(widget);
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Mesh Widget implementation
+
+struct cv::viz::MeshWidget::CopyImpl
+{
+    template<typename _Tp>
+    static Vec<_Tp, 3> * copy(const Mat &source, Vec<_Tp, 3> *output, int *look_up, const Mat &nan_mask)
+    {
+        CV_Assert(DataDepth<_Tp>::value == source.depth() && source.size() == nan_mask.size());
+        CV_Assert(nan_mask.channels() == 3 || nan_mask.channels() == 4);
+        CV_DbgAssert(DataDepth<_Msk>::value == nan_mask.depth());
+
+        int s_chs = source.channels();
+        int m_chs = nan_mask.channels();
+
+        int index = 0;
+        const _Tp* srow = source.ptr<_Tp>(0);
+        const _Tp* mrow = nan_mask.ptr<_Tp>(0);
+        
+        for(int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs)
+        {
+            if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2]))
+            {
+                look_up[x] = index;
+                *output++ = Vec<_Tp, 3>(srow);
+                ++index;
+            }
+        }
+        return output;
+    }
+};
+
+cv::viz::MeshWidget::MeshWidget(const Mesh3d &mesh)
+{
+    CV_Assert(mesh.cloud.rows == 1 && (mesh.cloud.type() == CV_32FC3 || mesh.cloud.type() == CV_64FC3 || mesh.cloud.type() == CV_32FC4 || mesh.cloud.type() == CV_64FC4));
+    CV_Assert(mesh.colors.empty() || (mesh.colors.type() == CV_8UC3 && mesh.cloud.size() == mesh.colors.size()));
+    CV_Assert(!mesh.polygons.empty() && mesh.polygons.type() == CV_32SC1);
+    
+    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New ();
+    vtkIdType nr_points = mesh.cloud.total();
+    int * look_up = new int[nr_points];
+    points->SetNumberOfPoints (nr_points);
+      
+    // Copy data from cloud to vtkPoints
+    if (mesh.cloud.depth() == CV_32F)
+    {
+        points->SetDataTypeToFloat();
+        Vec3f *data_beg = vtkpoints_data<float>(points);
+        Vec3f *data_end = CopyImpl::copy(mesh.cloud, data_beg, look_up, mesh.cloud);
+        nr_points = data_end - data_beg;
+    }
+    else
+    {
+        points->SetDataTypeToDouble();
+        Vec3d *data_beg = vtkpoints_data<double>(points);
+        Vec3d *data_end = CopyImpl::copy(mesh.cloud, data_beg, look_up, mesh.cloud);
+        nr_points = data_end - data_beg;
+    }
+    
+    vtkSmartPointer<vtkUnsignedCharArray> scalars;
+    
+    if (!mesh.colors.empty())
+    {
+        Vec3b * colors_data = 0;
+        colors_data = new Vec3b[nr_points];
+        NanFilter::copy(mesh.colors, colors_data, mesh.cloud);
+        
+        scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
+        scalars->SetNumberOfComponents (3);
+        scalars->SetNumberOfTuples (nr_points);
+        scalars->SetArray (colors_data->val, 3 * nr_points, 0);
+    }
+    
+    points->SetNumberOfPoints(nr_points);
+    
+    vtkSmartPointer<vtkPointSet> data;
+    
+    if (mesh.polygons.size().area() > 1)
+    {
+        vtkSmartPointer<vtkCellArray> cell_array = vtkSmartPointer<vtkCellArray>::New();
+        const int * polygons = mesh.polygons.ptr<int>();
+        
+        int idx = 0;
+        int poly_size = mesh.polygons.total();
+        for (int i = 0; i < poly_size; ++idx)
+        {
+            int n_points = polygons[i++];
+            
+            cell_array->InsertNextCell(n_points);
+            for (int j = 0; j < n_points; ++j, ++idx)
+                cell_array->InsertCellPoint(look_up[polygons[i++]]);
+        }
+        vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
+        cell_array->GetData ()->SetNumberOfValues (idx);
+        cell_array->Squeeze ();
+        polydata->SetStrips (cell_array);
+        polydata->SetPoints (points);
+
+        if (scalars)
+            polydata->GetPointData ()->SetScalars (scalars);
+        
+        data = polydata;
+    }
+    else
+    {
+        // Only one polygon
+        vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New ();
+        const int * polygons = mesh.polygons.ptr<int>();
+        int n_points = polygons[0];
+        
+        polygon->GetPointIds()->SetNumberOfIds(n_points);
+        
+        for (int j = 1; j < n_points+1; ++j)
+            polygon->GetPointIds ()->SetId (j, look_up[polygons[j]]);
+        
+        vtkSmartPointer<vtkUnstructuredGrid> poly_grid = vtkSmartPointer<vtkUnstructuredGrid>::New();
+        poly_grid->Allocate (1, 1);
+        poly_grid->InsertNextCell (polygon->GetCellType (), polygon->GetPointIds ());
+        poly_grid->SetPoints (points);
+        poly_grid->Update ();
+        
+        if (scalars)
+            poly_grid->GetPointData ()->SetScalars (scalars);
+        
+        data = poly_grid;
+    }
+
+    vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
+
+    actor->GetProperty()->SetRepresentationToSurface();
+    actor->GetProperty()->BackfaceCullingOff(); // Backface culling is off for higher efficiency
+    actor->GetProperty()->SetInterpolationToFlat();
+    actor->GetProperty()->EdgeVisibilityOff();
+    actor->GetProperty()->ShadingOff();
+    
+    vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
+    mapper->SetInput (data);
+    mapper->ImmediateModeRenderingOff ();
+    
+    vtkIdType numberOfCloudPoints = nr_points * 0.1;
+    actor->SetNumberOfCloudPoints (int (numberOfCloudPoints > 1 ? numberOfCloudPoints : 1));
+    actor->SetMapper (mapper);
+    
+    WidgetAccessor::setProp(*this, actor);
+}
+
+template<> CV_EXPORTS cv::viz::MeshWidget cv::viz::Widget::cast<cv::viz::MeshWidget>()
+{
+    Widget3D widget = this->cast<Widget3D>();
+    return static_cast<MeshWidget&>(widget);
+}
\ No newline at end of file

modules/viz/src/mesh_load.cpp

-#include "precomp.hpp"
-
-#include <vtkPLYReader.h>
-#include <vtkSmartPointer.h>
-#include <vtkPolyData.h>
-#include <vtkPointData.h>
-#include <vtkCellArray.h>
-
-cv::viz::Mesh3d::Ptr cv::viz::Mesh3d::mesh_load(const String& file)
-{
-    Mesh3d::Ptr mesh = new Mesh3d();
-
-    vtkSmartPointer<vtkPLYReader> reader = vtkSmartPointer<vtkPLYReader>::New();
-    reader->SetFileName(file.c_str());
-    reader->Update();
-    vtkSmartPointer<vtkPolyData> poly_data = reader->GetOutput ();
-
-    typedef unsigned int uint32_t;
-    mesh->polygons.clear();
-
-    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);
-
-    double point_xyz[3];
-    for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints (); i++)
-    {
-        mesh_points->GetPoint (i, &point_xyz[0]);
-        mesh->cloud.ptr<cv::Point3f>()[i] = cv::Point3d(point_xyz[0], point_xyz[1], point_xyz[2]);;
-    }
-
-    // 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
-    if (poly_colors && (poly_colors->GetNumberOfComponents () == 3))
-    {
-        mesh->colors.create(1, nr_points, CV_8UC3);
-        unsigned char point_color[3];
-
-        for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints (); i++)
-        {
-            poly_colors->GetTupleValue (i, &point_color[0]);
-
-            //RGB or BGR?????
-            mesh->colors.ptr<cv::Vec3b>()[i] = cv::Vec3b(point_color[0], point_color[1], point_color[2]);
-        }
-    }
-    else
-        mesh->colors.release();
-
-    // Now handle the polygons
-    mesh->polygons.resize (nr_polygons);
-    vtkIdType* cell_points;
-    vtkIdType nr_cell_points;
-    vtkCellArray * mesh_polygons = poly_data->GetPolys ();
-    mesh_polygons->InitTraversal ();
-    int id_poly = 0;
-    while (mesh_polygons->GetNextCell (nr_cell_points, cell_points))
-    {
-        mesh->polygons[id_poly].vertices.resize (nr_cell_points);
-        for (int i = 0; i < nr_cell_points; ++i)
-            mesh->polygons[id_poly].vertices[i] = static_cast<int> (cell_points[i]);
-        ++id_poly;
-    }
-
-    return mesh;
-}

modules/viz/src/precomp.hpp

@@ -156,27 +156,3 @@
 #include <opencv2/core.hpp>
 #include <opencv2/viz.hpp>
 #include "opencv2/viz/widget_accessor.hpp"
-
-namespace cv
-{
-    namespace viz
-    {
-        template<typename _Tp> Vec<_Tp, 3>* vtkpoints_data(vtkSmartPointer<vtkPoints>& points);
-
-        template<> static inline Vec3f* vtkpoints_data<float>(vtkSmartPointer<vtkPoints>& points)
-        {
-            CV_Assert(points->GetDataType() == VTK_FLOAT);
-            vtkDataArray *data = points->GetData();
-            float *pointer = static_cast<vtkFloatArray*>(data)->GetPointer(0);
-            return reinterpret_cast<Vec3f*>(pointer);
-        }
-
-        template<> static inline 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);
-        }
-    }
-}

modules/viz/src/shape_widgets.cpp

 #include "precomp.hpp"
 
+namespace cv
+{
+    namespace viz
+    {
+        template<typename _Tp> Vec<_Tp, 3>* vtkpoints_data(vtkSmartPointer<vtkPoints>& points);
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////////////////////
 /// line widget implementation
 cv::viz::LineWidget::LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color)

modules/viz/src/types.cpp

@@ -59,3 +59,87 @@ cv::viz::MouseEvent::MouseEvent (const Type& _type, const MouseButton& _button,
     if (shift)
         key_state |= KeyboardEvent::Shift;
 }
+
+////////////////////////////////////////////////////////////////////
+/// cv::viz::Mesh3d
+
+struct cv::viz::Mesh3d::loadMeshImpl
+{
+    static cv::viz::Mesh3d::Ptr loadMesh(const String &file)
+    {
+        Mesh3d::Ptr mesh = new Mesh3d();
+
+        vtkSmartPointer<vtkPLYReader> reader = vtkSmartPointer<vtkPLYReader>::New();
+        reader->SetFileName(file.c_str());
+        reader->Update();
+        vtkSmartPointer<vtkPolyData> poly_data = reader->GetOutput ();
+
+        typedef unsigned int uint32_t;
+        
+        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);
+
+        double point_xyz[3];
+        for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints (); i++)
+        {
+            mesh_points->GetPoint (i, &point_xyz[0]);
+            mesh->cloud.ptr<cv::Point3f>()[i] = cv::Point3d(point_xyz[0], point_xyz[1], point_xyz[2]);;
+        }
+
+        // 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
+        if (poly_colors && (poly_colors->GetNumberOfComponents () == 3))
+        {
+            mesh->colors.create(1, nr_points, CV_8UC3);
+            unsigned char point_color[3];
+
+            for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints (); i++)
+            {
+                poly_colors->GetTupleValue (i, &point_color[0]);
+
+                //RGB or BGR?????
+                mesh->colors.ptr<cv::Vec3b>()[i] = cv::Vec3b(point_color[0], point_color[1], point_color[2]);
+            }
+        }
+        else
+            mesh->colors.release();
+
+        // Now handle the polygons
+        vtkIdType* cell_points;
+        vtkIdType nr_cell_points;
+        vtkCellArray * mesh_polygons = poly_data->GetPolys ();
+        mesh_polygons->InitTraversal ();
+        int id_poly = 0;
+        
+        mesh->polygons.create(1, mesh_polygons->GetSize(), CV_32SC1);
+        
+        int * polygons = mesh->polygons.ptr<int>();
+        while (mesh_polygons->GetNextCell (nr_cell_points, cell_points))
+        {
+            *polygons++ = nr_cell_points;
+            for (int i = 0; i < nr_cell_points; ++i)
+                *polygons++ = static_cast<int> (cell_points[i]);
+        }
+
+        return mesh;
+    }
+};
+
+cv::viz::Mesh3d::Ptr cv::viz::Mesh3d::loadMesh(const String& file)
+{
+    return loadMeshImpl::loadMesh(file);
+}

modules/viz/src/viz.cpp

@@ -37,3 +37,27 @@ cv::Matx44f cv::viz::convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matr
             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);
+        }
+    }
+}
\ No newline at end of file

modules/viz/src/widget.cpp

+
 #include "precomp.hpp"
 
 ///////////////////////////////////////////////////////////////////////////////////////////////

modules/viz/test/test_viz3d.cpp

@@ -128,16 +128,23 @@ TEST(Viz_viz3d, accuracy)
     viz.showWidget("polyline", plw);
 //     lw = v.getWidget("polyline").cast<viz::LineWidget>();
     
+    viz::Mesh3d::Ptr mesh = cv::viz::Mesh3d::loadMesh("horse.ply");
+    
+    viz::MeshWidget mw(*mesh);
+    viz.showWidget("mesh", mw);
+    
     viz.spin();
 
     //viz::GridWidget gw(viz::Vec2i(100,100), viz::Vec2d(1,1));
     //v.showWidget("grid", gw);
-    lw = viz.getWidget("grid").cast<cv::viz::LineWidget>();
+//     lw = viz.getWidget("grid").cast<cv::viz::LineWidget>();
     
     //viz::Text3DWidget t3w("OpenCV", cv::Point3f(0.0, 2.0, 0.0), 1.0, viz::Color(255,255,0));
     //v.showWidget("txt3d", t3w);
+
 //     float grid_x_angle = 0.0;
     
+    
     while(!viz.wasStopped())
     {
         // Creating new point cloud with id cloud1