generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

move frompolyfile to widget class as static method, remove addpolygon and its alikes

Browse Source
This commit is contained in:
ozantonkal
2013-08-22 19:42:19 +02:00
committed by Ozan Tonkal
parent 0bbaf5d47a
commit b032b4dded
7 changed files with 43 additions and 681 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
modules/viz/include/opencv2/viz/viz3d.hpp
View File

@@ -27,13 +27,6 @@ namespace cv
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;

2
modules/viz/include/opencv2/viz/widgets.hpp
View File

@@ -17,6 +17,8 @@ namespace cv
Widget(const Widget &other);
Widget& operator =(const Widget &other);
static Widget fromPlyFile(const String &file_name);
~Widget();
template<typename _W> _W cast();

1
modules/viz/src/shape_widgets.cpp
View File

@@ -969,7 +969,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);

20
modules/viz/src/viz3d.cpp
View File

@@ -44,26 +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(); }

609
modules/viz/src/viz3d_impl.cpp
View File

@@ -331,29 +331,6 @@ bool cv::viz::Viz3d::VizImpl::setPointCloudRenderingProperties (int property, do
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)
{
@@ -618,148 +595,6 @@ 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*/)
{
// 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);
}
///////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::setRepresentationToSurfaceForAllActors ()
{
@@ -883,450 +718,6 @@ void cv::viz::Viz3d::VizImpl::setWindowPosition (int x, int y) { window_->SetPos
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);

43
modules/viz/src/viz3d_impl.hpp
View File

@@ -19,30 +19,11 @@ public:
void removeAllWidgets();
//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" );
/** \brief Returns true when the user tried to close the window */
bool wasStopped () const { if (interactor_ != NULL) return (stopped_); else return true; }
@@ -60,30 +41,6 @@ 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();

40
modules/viz/src/widget.cpp
View File

@@ -54,6 +54,46 @@ void cv::viz::Widget::release()
}
}
cv::viz::Widget cv::viz::Widget::fromPlyFile(const String &file_name)
{
vtkSmartPointer<vtkPLYReader> reader = vtkSmartPointer<vtkPLYReader>::New ();
reader->SetFileName (file_name.c_str ());
vtkSmartPointer<vtkDataSet> data = reader->GetOutput();
CV_Assert(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;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// widget accessor implementaion