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

reduced exported interface names (to make IntelliSense hints less littered)

Browse Source
This commit is contained in:
Anatoly Baksheev
2013-12-01 15:25:44 +04:00
parent 44c1d4dfdc
commit f6e9b81188
4 changed files with 447 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -119,8 +119,6 @@ namespace cv
Affine3f getPose() const; Affine3f getPose() const;
void setColor(const Color &color); void setColor(const Color &color);
private:
struct MatrixConverter;
}; };
@@ -145,8 +143,6 @@ namespace cv
public: public:
WPlane(const Vec4f& coefs, float size = 1.f, const Color &color = Color::white()); WPlane(const Vec4f& coefs, float size = 1.f, const Color &color = Color::white());
WPlane(const Vec4f& coefs, const Point3f& pt, float size = 1.f, const Color &color = Color::white()); WPlane(const Vec4f& coefs, const Point3f& pt, float size = 1.f, const Color &color = Color::white());
private:
struct SetSizeImpl;
}; };
class CV_EXPORTS WSphere : public Widget3D class CV_EXPORTS WSphere : public Widget3D
@@ -189,9 +185,6 @@ namespace cv
{ {
public: public:
WPolyLine(InputArray points, const Color &color = Color::white()); WPolyLine(InputArray points, const Color &color = Color::white());
private:
struct CopyImpl;
}; };
class CV_EXPORTS WGrid : public Widget3D class CV_EXPORTS WGrid : public Widget3D
@@ -201,10 +194,6 @@ namespace cv
WGrid(const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white()); WGrid(const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white());
//! Creates grid based on the plane equation //! Creates grid based on the plane equation
WGrid(const Vec4f &coeffs, const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white()); WGrid(const Vec4f &coeffs, const Vec2i &dimensions, const Vec2d &spacing, const Color &color = Color::white());
private:
struct GridImpl;
}; };
class CV_EXPORTS WText3D : public Widget3D class CV_EXPORTS WText3D : public Widget3D
@@ -257,9 +246,6 @@ namespace cv
WCameraPosition(const Matx33f &K, const Mat &img, float scale = 1.f, const Color &color = Color::white()); WCameraPosition(const Matx33f &K, const Mat &img, float scale = 1.f, const Color &color = Color::white());
//! Creates frustum and display given image at the far plane //! Creates frustum and display given image at the far plane
WCameraPosition(const Vec2f &fov, const Mat &img, float scale = 1.f, const Color &color = Color::white()); WCameraPosition(const Vec2f &fov, const Mat &img, float scale = 1.f, const Color &color = Color::white());
private:
struct ProjectImage;
}; };
class CV_EXPORTS WTrajectory : public Widget3D class CV_EXPORTS WTrajectory : public Widget3D
@@ -273,9 +259,6 @@ namespace cv
WTrajectory(const std::vector<Affine3f> &path, const Matx33f &K, float scale = 1.f, const Color &color = Color::white()); WTrajectory(const std::vector<Affine3f> &path, const Matx33f &K, float scale = 1.f, const Color &color = Color::white());
//! Displays trajectory of the given path by frustums //! Displays trajectory of the given path by frustums
WTrajectory(const std::vector<Affine3f> &path, const Vec2f &fov, float scale = 1.f, const Color &color = Color::white()); WTrajectory(const std::vector<Affine3f> &path, const Vec2f &fov, float scale = 1.f, const Color &color = Color::white());
private:
struct ApplyPath;
}; };
class CV_EXPORTS WSpheresTrajectory: public Widget3D class CV_EXPORTS WSpheresTrajectory: public Widget3D
@@ -292,9 +275,6 @@ namespace cv
WCloud(InputArray cloud, InputArray colors); WCloud(InputArray cloud, InputArray colors);
//! All points in cloud have the same color //! All points in cloud have the same color
WCloud(InputArray cloud, const Color &color = Color::white()); WCloud(InputArray cloud, const Color &color = Color::white());
private:
struct CreateCloudWidget;
}; };
class CV_EXPORTS WCloudCollection : public Widget3D class CV_EXPORTS WCloudCollection : public Widget3D
@@ -306,27 +286,18 @@ namespace cv
void addCloud(InputArray cloud, InputArray colors, const Affine3f &pose = Affine3f::Identity()); void addCloud(InputArray cloud, InputArray colors, const Affine3f &pose = Affine3f::Identity());
//! All points in cloud have the same color //! All points in cloud have the same color
void addCloud(InputArray cloud, const Color &color = Color::white(), const Affine3f &pose = Affine3f::Identity()); void addCloud(InputArray cloud, const Color &color = Color::white(), const Affine3f &pose = Affine3f::Identity());
private:
struct CreateCloudWidget;
}; };
class CV_EXPORTS WCloudNormals : public Widget3D class CV_EXPORTS WCloudNormals : public Widget3D
{ {
public: public:
WCloudNormals(InputArray cloud, InputArray normals, int level = 100, float scale = 0.02f, const Color &color = Color::white()); WCloudNormals(InputArray cloud, InputArray normals, int level = 100, float scale = 0.02f, const Color &color = Color::white());
private:
struct ApplyCloudNormals;
}; };
class CV_EXPORTS WMesh : public Widget3D class CV_EXPORTS WMesh : public Widget3D
{ {
public: public:
WMesh(const Mesh3d &mesh); WMesh(const Mesh3d &mesh);
private:
struct CopyImpl;
}; };
template<> CV_EXPORTS Widget2D Widget::cast<Widget2D>(); template<> CV_EXPORTS Widget2D Widget::cast<Widget2D>();

54
modules/viz/src/cloud_widgets.cpp
View File

@@ -59,8 +59,10 @@ namespace cv
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// Point Cloud Widget implementation /// Point Cloud Widget implementation
struct cv::viz::WCloud::CreateCloudWidget namespace cv { namespace viz { namespace
{ {
struct CloudUtils
{
static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points) static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points)
{ {
vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New(); vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
@@ -144,7 +146,9 @@ struct cv::viz::WCloud::CreateCloudWidget
vertices->SetCells(nr_points, cells); vertices->SetCells(nr_points, cells);
return polydata; return polydata;
} }
}; };
}}}
cv::viz::WCloud::WCloud(InputArray _cloud, InputArray _colors) cv::viz::WCloud::WCloud(InputArray _cloud, InputArray _colors)
{ {
@@ -160,7 +164,7 @@ cv::viz::WCloud::WCloud(InputArray _cloud, InputArray _colors)
} }
vtkIdType nr_points; vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points); vtkSmartPointer<vtkPolyData> polydata = CloudUtils::create(cloud, nr_points);
// Filter colors // Filter colors
Vec3b* colors_data = new Vec3b[nr_points]; Vec3b* colors_data = new Vec3b[nr_points];
@@ -207,7 +211,7 @@ cv::viz::WCloud::WCloud(InputArray _cloud, const Color &color)
CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4); CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
vtkIdType nr_points; vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points); vtkSmartPointer<vtkPolyData> polydata = CloudUtils::create(cloud, nr_points);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New(); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
#if VTK_MAJOR_VERSION <= 5 #if VTK_MAJOR_VERSION <= 5
@@ -242,8 +246,10 @@ template<> cv::viz::WCloud cv::viz::Widget::cast<cv::viz::WCloud>()
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// Cloud Collection Widget implementation /// Cloud Collection Widget implementation
struct cv::viz::WCloudCollection::CreateCloudWidget namespace cv { namespace viz { namespace
{ {
struct CloudCollectionUtils
{
static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points) static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points)
{ {
vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New(); vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
@@ -374,7 +380,8 @@ struct cv::viz::WCloudCollection::CreateCloudWidget
vtkIdType old_cloud_points = actor->GetNumberOfCloudPoints(); vtkIdType old_cloud_points = actor->GetNumberOfCloudPoints();
actor->SetNumberOfCloudPoints(int(std::max<vtkIdType>(1, old_cloud_points+poly_data->GetNumberOfPoints() / 10))); actor->SetNumberOfCloudPoints(int(std::max<vtkIdType>(1, old_cloud_points+poly_data->GetNumberOfPoints() / 10)));
} }
}; };
}}}
cv::viz::WCloudCollection::WCloudCollection() cv::viz::WCloudCollection::WCloudCollection()
{ {
@@ -397,7 +404,7 @@ void cv::viz::WCloudCollection::addCloud(InputArray _cloud, InputArray _colors,
} }
vtkIdType nr_points; vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points); vtkSmartPointer<vtkPolyData> polydata = CloudCollectionUtils::create(cloud, nr_points);
// Filter colors // Filter colors
Vec3b* colors_data = new Vec3b[nr_points]; Vec3b* colors_data = new Vec3b[nr_points];
@@ -429,7 +436,7 @@ void cv::viz::WCloudCollection::addCloud(InputArray _cloud, InputArray _colors,
CV_Assert("Incompatible widget type." && actor); CV_Assert("Incompatible widget type." && actor);
Vec3d minmax(scalars->GetRange()); Vec3d minmax(scalars->GetRange());
CreateCloudWidget::createMapper(actor, transform_filter->GetOutput(), minmax); CloudCollectionUtils::createMapper(actor, transform_filter->GetOutput(), minmax);
} }
void cv::viz::WCloudCollection::addCloud(InputArray _cloud, const Color &color, const Affine3f &pose) void cv::viz::WCloudCollection::addCloud(InputArray _cloud, const Color &color, const Affine3f &pose)
@@ -438,7 +445,7 @@ void cv::viz::WCloudCollection::addCloud(InputArray _cloud, const Color &color,
CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4); CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
vtkIdType nr_points; vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points); vtkSmartPointer<vtkPolyData> polydata = CloudCollectionUtils::create(cloud, nr_points);
vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New(); vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetNumberOfComponents(3); scalars->SetNumberOfComponents(3);
@@ -468,7 +475,7 @@ void cv::viz::WCloudCollection::addCloud(InputArray _cloud, const Color &color,
CV_Assert("Incompatible widget type." && actor); CV_Assert("Incompatible widget type." && actor);
Vec3d minmax(scalars->GetRange()); Vec3d minmax(scalars->GetRange());
CreateCloudWidget::createMapper(actor, transform_filter->GetOutput(), minmax); CloudCollectionUtils::createMapper(actor, transform_filter->GetOutput(), minmax);
} }
template<> cv::viz::WCloudCollection cv::viz::Widget::cast<cv::viz::WCloudCollection>() template<> cv::viz::WCloudCollection cv::viz::Widget::cast<cv::viz::WCloudCollection>()
@@ -480,8 +487,10 @@ template<> cv::viz::WCloudCollection cv::viz::Widget::cast<cv::viz::WCloudCollec
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// Cloud Normals Widget implementation /// Cloud Normals Widget implementation
struct cv::viz::WCloudNormals::ApplyCloudNormals namespace cv { namespace viz { namespace
{ {
struct CloudNormalsUtils
{
template<typename _Tp> template<typename _Tp>
struct Impl struct Impl
{ {
@@ -549,11 +558,13 @@ struct cv::viz::WCloudNormals::ApplyCloudNormals
static inline vtkSmartPointer<vtkCellArray> apply(const Mat &cloud, const Mat& normals, int level, float scale, _Tp *&pts, vtkIdType &nr_normals) static inline vtkSmartPointer<vtkCellArray> apply(const Mat &cloud, const Mat& normals, int level, float scale, _Tp *&pts, vtkIdType &nr_normals)
{ {
if (cloud.cols > 1 && cloud.rows > 1) if (cloud.cols > 1 && cloud.rows > 1)
return ApplyCloudNormals::Impl<_Tp>::applyOrganized(cloud, normals, level, scale, pts, nr_normals); return CloudNormalsUtils::Impl<_Tp>::applyOrganized(cloud, normals, level, scale, pts, nr_normals);
else else
return ApplyCloudNormals::Impl<_Tp>::applyUnorganized(cloud, normals, level, scale, pts, nr_normals); return CloudNormalsUtils::Impl<_Tp>::applyUnorganized(cloud, normals, level, scale, pts, nr_normals);
} }
}; };
}}}
cv::viz::WCloudNormals::WCloudNormals(InputArray _cloud, InputArray _normals, int level, float scale, const Color &color) cv::viz::WCloudNormals::WCloudNormals(InputArray _cloud, InputArray _normals, int level, float scale, const Color &color)
{ {
@@ -574,7 +585,7 @@ cv::viz::WCloudNormals::WCloudNormals(InputArray _cloud, InputArray _normals, in
data->SetNumberOfComponents(3); data->SetNumberOfComponents(3);
float* pts = 0; float* pts = 0;
lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals); lines = CloudNormalsUtils::apply(cloud, normals, level, scale, pts, nr_normals);
data->SetArray(&pts[0], 2 * nr_normals * 3, 0); data->SetArray(&pts[0], 2 * nr_normals * 3, 0);
points->SetData(data); points->SetData(data);
} }
@@ -586,7 +597,7 @@ cv::viz::WCloudNormals::WCloudNormals(InputArray _cloud, InputArray _normals, in
data->SetNumberOfComponents(3); data->SetNumberOfComponents(3);
double* pts = 0; double* pts = 0;
lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals); lines = CloudNormalsUtils::apply(cloud, normals, level, scale, pts, nr_normals);
data->SetArray(&pts[0], 2 * nr_normals * 3, 0); data->SetArray(&pts[0], 2 * nr_normals * 3, 0);
points->SetData(data); points->SetData(data);
} }
@@ -619,8 +630,10 @@ template<> cv::viz::WCloudNormals cv::viz::Widget::cast<cv::viz::WCloudNormals>(
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// Mesh Widget implementation /// Mesh Widget implementation
struct cv::viz::WMesh::CopyImpl namespace cv { namespace viz { namespace
{ {
struct MeshUtils
{
template<typename _Tp> template<typename _Tp>
static Vec<_Tp, 3> * copy(const Mat &source, Vec<_Tp, 3> *output, int *look_up, const Mat &nan_mask) static Vec<_Tp, 3> * copy(const Mat &source, Vec<_Tp, 3> *output, int *look_up, const Mat &nan_mask)
{ {
@@ -646,7 +659,8 @@ struct cv::viz::WMesh::CopyImpl
} }
return output; return output;
} }
}; };
}}}
cv::viz::WMesh::WMesh(const Mesh3d &mesh) cv::viz::WMesh::WMesh(const Mesh3d &mesh)
{ {
@@ -665,14 +679,14 @@ cv::viz::WMesh::WMesh(const Mesh3d &mesh)
{ {
points->SetDataTypeToFloat(); points->SetDataTypeToFloat();
Vec3f *data_beg = vtkpoints_data<float>(points); Vec3f *data_beg = vtkpoints_data<float>(points);
Vec3f *data_end = CopyImpl::copy(mesh.cloud, data_beg, look_up, mesh.cloud); Vec3f *data_end = MeshUtils::copy(mesh.cloud, data_beg, look_up, mesh.cloud);
nr_points = data_end - data_beg; nr_points = data_end - data_beg;
} }
else else
{ {
points->SetDataTypeToDouble(); points->SetDataTypeToDouble();
Vec3d *data_beg = vtkpoints_data<double>(points); Vec3d *data_beg = vtkpoints_data<double>(points);
Vec3d *data_end = CopyImpl::copy(mesh.cloud, data_beg, look_up, mesh.cloud); Vec3d *data_end = MeshUtils::copy(mesh.cloud, data_beg, look_up, mesh.cloud);
nr_points = data_end - data_beg; nr_points = data_end - data_beg;
} }

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

@@ -84,8 +84,10 @@ template<> cv::viz::WLine cv::viz::Widget::cast<cv::viz::WLine>()
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// plane widget implementation /// plane widget implementation
struct cv::viz::WPlane::SetSizeImpl namespace cv { namespace viz { namespace
{ {
struct PlaneUtils
{
template<typename _Tp> template<typename _Tp>
static vtkSmartPointer<vtkTransformPolyDataFilter> setSize(const Vec<_Tp, 3> &center, vtkSmartPointer<vtkAlgorithmOutput> poly_data_port, double size) static vtkSmartPointer<vtkTransformPolyDataFilter> setSize(const Vec<_Tp, 3> &center, vtkSmartPointer<vtkAlgorithmOutput> poly_data_port, double size)
{ {
@@ -102,7 +104,8 @@ struct cv::viz::WPlane::SetSizeImpl
return transform_filter; return transform_filter;
} }
}; };
}}}
cv::viz::WPlane::WPlane(const Vec4f& coefs, float size, const Color &color) cv::viz::WPlane::WPlane(const Vec4f& coefs, float size, const Color &color)
{ {
@@ -115,7 +118,7 @@ cv::viz::WPlane::WPlane(const Vec4f& coefs, float size, const Color &color)
plane->GetOrigin(p_center.val); plane->GetOrigin(p_center.val);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New(); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInputConnection(SetSizeImpl::setSize(p_center, plane->GetOutputPort(), size)->GetOutputPort()); mapper->SetInputConnection(PlaneUtils::setSize(p_center, plane->GetOutputPort(), size)->GetOutputPort());
vtkSmartPointer<vizActor> actor = vtkSmartPointer<vizActor>::New(); vtkSmartPointer<vizActor> actor = vtkSmartPointer<vizActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@@ -136,7 +139,7 @@ cv::viz::WPlane::WPlane(const Vec4f& coefs, const Point3f& pt, float size, const
plane->SetCenter(p_center[0], p_center[1], p_center[2]); plane->SetCenter(p_center[0], p_center[1], p_center[2]);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New(); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInputConnection(SetSizeImpl::setSize(p_center, plane->GetOutputPort(), size)->GetOutputPort()); mapper->SetInputConnection(PlaneUtils::setSize(p_center, plane->GetOutputPort(), size)->GetOutputPort());
vtkSmartPointer<vizActor> actor = vtkSmartPointer<vizActor>::New(); vtkSmartPointer<vizActor> actor = vtkSmartPointer<vizActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@@ -406,8 +409,10 @@ template<> cv::viz::WCoordinateSystem cv::viz::Widget::cast<cv::viz::WCoordinate
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// polyline widget implementation /// polyline widget implementation
struct cv::viz::WPolyLine::CopyImpl namespace cv { namespace viz { namespace
{ {
struct PolyLineUtils
{
template<typename _Tp> template<typename _Tp>
static void copy(const Mat& source, Vec<_Tp, 3> *output, vtkSmartPointer<vtkPolyLine> polyLine) static void copy(const Mat& source, Vec<_Tp, 3> *output, vtkSmartPointer<vtkPolyLine> polyLine)
{ {
@@ -424,7 +429,8 @@ struct cv::viz::WPolyLine::CopyImpl
} }
} }
} }
}; };
}}}
cv::viz::WPolyLine::WPolyLine(InputArray _pointData, const Color &color) cv::viz::WPolyLine::WPolyLine(InputArray _pointData, const Color &color)
{ {
@@ -448,13 +454,13 @@ cv::viz::WPolyLine::WPolyLine(InputArray _pointData, const Color &color)
{ {
// Get a pointer to the beginning of the data array // Get a pointer to the beginning of the data array
Vec3f *data_beg = vtkpoints_data<float>(points); Vec3f *data_beg = vtkpoints_data<float>(points);
CopyImpl::copy(pointData, data_beg, polyLine); PolyLineUtils::copy(pointData, data_beg, polyLine);
} }
else if (pointData.depth() == CV_64F) else if (pointData.depth() == CV_64F)
{ {
// Get a pointer to the beginning of the data array // Get a pointer to the beginning of the data array
Vec3d *data_beg = vtkpoints_data<double>(points); Vec3d *data_beg = vtkpoints_data<double>(points);
CopyImpl::copy(pointData, data_beg, polyLine); PolyLineUtils::copy(pointData, data_beg, polyLine);
} }
vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
@@ -486,8 +492,10 @@ template<> cv::viz::WPolyLine cv::viz::Widget::cast<cv::viz::WPolyLine>()
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// grid widget implementation /// grid widget implementation
struct cv::viz::WGrid::GridImpl namespace cv { namespace viz { namespace
{ {
struct GridUtils
{
static vtkSmartPointer<vtkPolyData> createGrid(const Vec2i &dimensions, const Vec2d &spacing) static vtkSmartPointer<vtkPolyData> createGrid(const Vec2i &dimensions, const Vec2d &spacing)
{ {
// Create the grid using image data // Create the grid using image data
@@ -511,11 +519,12 @@ struct cv::viz::WGrid::GridImpl
filter->Update(); filter->Update();
return filter->GetOutput(); return filter->GetOutput();
} }
}; };
}}}
cv::viz::WGrid::WGrid(const Vec2i &dimensions, const Vec2d &spacing, const Color &color) cv::viz::WGrid::WGrid(const Vec2i &dimensions, const Vec2d &spacing, const Color &color)
{ {
vtkSmartPointer<vtkPolyData> grid = GridImpl::createGrid(dimensions, spacing); vtkSmartPointer<vtkPolyData> grid = GridUtils::createGrid(dimensions, spacing);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New(); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
#if VTK_MAJOR_VERSION <= 5 #if VTK_MAJOR_VERSION <= 5
@@ -533,7 +542,7 @@ cv::viz::WGrid::WGrid(const Vec2i &dimensions, const Vec2d &spacing, const Color
cv::viz::WGrid::WGrid(const Vec4f &coefs, const Vec2i &dimensions, const Vec2d &spacing, const Color &color) cv::viz::WGrid::WGrid(const Vec4f &coefs, const Vec2i &dimensions, const Vec2d &spacing, const Color &color)
{ {
vtkSmartPointer<vtkPolyData> grid = GridImpl::createGrid(dimensions, spacing); vtkSmartPointer<vtkPolyData> grid = GridUtils::createGrid(dimensions, spacing);
// Estimate the transform to set the normal based on the coefficients // Estimate the transform to set the normal based on the coefficients
Vec3f normal(coefs[0], coefs[1], coefs[2]); Vec3f normal(coefs[0], coefs[1], coefs[2]);
@@ -938,8 +947,10 @@ template<> cv::viz::WImage3D cv::viz::Widget::cast<cv::viz::WImage3D>()
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// camera position widget implementation /// camera position widget implementation
struct cv::viz::WCameraPosition::ProjectImage namespace cv { namespace viz { namespace
{ {
struct CameraPositionUtils
{
static void projectImage(float fovy, float far_end_height, const Mat &image, static void projectImage(float fovy, float far_end_height, const Mat &image,
double scale, const Color &color, vtkSmartPointer<vtkActor> actor) double scale, const Color &color, vtkSmartPointer<vtkActor> actor)
{ {
@@ -1030,7 +1041,8 @@ struct cv::viz::WCameraPosition::ProjectImage
actor->SetMapper(planeMapper); actor->SetMapper(planeMapper);
actor->SetTexture(texture); actor->SetTexture(texture);
} }
}; };
}}}
cv::viz::WCameraPosition::WCameraPosition(float scale) cv::viz::WCameraPosition::WCameraPosition(float scale)
{ {
@@ -1164,7 +1176,7 @@ cv::viz::WCameraPosition::WCameraPosition(const Matx33f &K, const Mat &image, fl
float far_end_height = 2.0f * c_y * scale / f_y; float far_end_height = 2.0f * c_y * scale / f_y;
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New(); vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
ProjectImage::projectImage(fovy, far_end_height, image, scale, color, actor); CameraPositionUtils::projectImage(fovy, far_end_height, image, scale, color, actor);
WidgetAccessor::setProp(*this, actor); WidgetAccessor::setProp(*this, actor);
} }
@@ -1175,7 +1187,7 @@ cv::viz::WCameraPosition::WCameraPosition(const Vec2f &fov, const Mat &image, fl
float far_end_height = 2.0 * scale * tan(fov[1] * 0.5); float far_end_height = 2.0 * scale * tan(fov[1] * 0.5);
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New(); vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
ProjectImage::projectImage(fovy, far_end_height, image, scale, color, actor); CameraPositionUtils::projectImage(fovy, far_end_height, image, scale, color, actor);
WidgetAccessor::setProp(*this, actor); WidgetAccessor::setProp(*this, actor);
} }
@@ -1188,8 +1200,10 @@ template<> cv::viz::WCameraPosition cv::viz::Widget::cast<cv::viz::WCameraPositi
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// trajectory widget implementation /// trajectory widget implementation
struct cv::viz::WTrajectory::ApplyPath namespace cv { namespace viz { namespace
{ {
struct TrajectoryUtils
{
static void applyPath(vtkSmartPointer<vtkPolyData> poly_data, vtkSmartPointer<vtkAppendPolyData> append_filter, const std::vector<Affine3f> &path) static void applyPath(vtkSmartPointer<vtkPolyData> poly_data, vtkSmartPointer<vtkAppendPolyData> append_filter, const std::vector<Affine3f> &path)
{ {
vtkIdType nr_points = path.size(); vtkIdType nr_points = path.size();
@@ -1218,7 +1232,8 @@ struct cv::viz::WTrajectory::ApplyPath
append_filter->AddInputConnection(filter->GetOutputPort()); append_filter->AddInputConnection(filter->GetOutputPort());
} }
} }
}; };
}}}
cv::viz::WTrajectory::WTrajectory(const std::vector<Affine3f> &path, int display_mode, const Color &color, float scale) cv::viz::WTrajectory::WTrajectory(const std::vector<Affine3f> &path, int display_mode, const Color &color, float scale)
{ {
@@ -1303,7 +1318,7 @@ cv::viz::WTrajectory::WTrajectory(const std::vector<Affine3f> &path, int display
axes_tubes->SetNumberOfSides(6); axes_tubes->SetNumberOfSides(6);
axes_tubes->Update(); axes_tubes->Update();
ApplyPath::applyPath(axes_tubes->GetOutput(), appendFilter, path); TrajectoryUtils::applyPath(axes_tubes->GetOutput(), appendFilter, path);
} }
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New(); vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
@@ -1348,7 +1363,7 @@ cv::viz::WTrajectory::WTrajectory(const std::vector<Affine3f> &path, const Matx3
filter->Update(); filter->Update();
vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New(); vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
ApplyPath::applyPath(filter->GetOutput(), appendFilter, path); TrajectoryUtils::applyPath(filter->GetOutput(), appendFilter, path);
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New(); vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(appendFilter->GetOutputPort()); mapper->SetInputConnection(appendFilter->GetOutputPort());
@@ -1388,7 +1403,7 @@ cv::viz::WTrajectory::WTrajectory(const std::vector<Affine3f> &path, const Vec2f
filter->Update(); filter->Update();
vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New(); vtkSmartPointer<vtkAppendPolyData> appendFilter = vtkSmartPointer<vtkAppendPolyData>::New();
ApplyPath::applyPath(filter->GetOutput(), appendFilter, path); TrajectoryUtils::applyPath(filter->GetOutput(), appendFilter, path);
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New(); vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(appendFilter->GetOutputPort()); mapper->SetInputConnection(appendFilter->GetOutputPort());

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

@@ -303,27 +303,6 @@ void cv::viz::WidgetAccessor::setProp(Widget& widget, vtkSmartPointer<vtkProp> p
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// widget3D implementation /// widget3D implementation
struct cv::viz::Widget3D::MatrixConverter
{
static Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
{
Matx44f m;
for (int i = 0; i < 4; i++)
for (int k = 0; k < 4; k++)
m(i, k) = vtk_matrix->GetElement(i, k);
return m;
}
static vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix(const 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;
}
};
void cv::viz::Widget3D::setPose(const Affine3f &pose) void cv::viz::Widget3D::setPose(const Affine3f &pose)
{ {
vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this)); vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
@@ -345,10 +324,9 @@ void cv::viz::Widget3D::updatePose(const Affine3f &pose)
setPose(pose); setPose(pose);
return ; return ;
} }
Matx44f matrix_cv = MatrixConverter::convertToMatx(matrix);
Affine3f updated_pose = pose * Affine3f(matrix_cv); Affine3f updated_pose = pose * Affine3f(convertToMatx(matrix));
matrix = MatrixConverter::convertToVtkMatrix(updated_pose.matrix); matrix = convertToVtkMatrix(updated_pose.matrix);
actor->SetUserMatrix(matrix); actor->SetUserMatrix(matrix);
actor->Modified(); actor->Modified();
@@ -358,10 +336,7 @@ cv::Affine3f cv::viz::Widget3D::getPose() const
{ {
vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this)); vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert("Widget is not 3D." && actor); CV_Assert("Widget is not 3D." && actor);
return Affine3f(convertToMatx(actor->GetUserMatrix()));
vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
Matx44f matrix_cv = MatrixConverter::convertToMatx(matrix);
return Affine3f(matrix_cv);
} }
void cv::viz::Widget3D::setColor(const Color &color) void cv::viz::Widget3D::setColor(const Color &color)