struct CV_EXPORTS WidgetAccessor
{
static vtkSmartPointer<vtkProp> getActor(const Widget &widget);
+ static void setVtkProp(Widget &widget, vtkSmartPointer<vtkProp> actor);
};
}
Widget();
Widget(const Widget &other);
Widget& operator =(const Widget &other);
-
+
~Widget();
- void copyTo(Widget &dst);
-
- void setColor(const Color &color);
+ private:
+ class Impl;
+ Impl *impl_;
+ friend struct WidgetAccessor;
+
+ };
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// The base class for all 3D widgets
+ class CV_EXPORTS Widget3D : public Widget
+ {
+ public:
+ Widget3D();
+
void setPose(const Affine3f &pose);
void updatePose(const Affine3f &pose);
Affine3f getPose() const;
- protected:
- Widget(bool text_widget);
+ void setColor(const Color &color);
private:
- class Impl;
- Impl* impl_;
-
- void create();
- void release();
- void create(bool text_widget);
+ struct MatrixConverter;
- friend struct WidgetAccessor;
};
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// The base class for all 2D widgets
+ class CV_EXPORTS Widget2D : public Widget
+ {
+ public:
+ Widget2D();
+ };
+
-
- class CV_EXPORTS LineWidget : public Widget
+ class CV_EXPORTS LineWidget : public Widget3D
{
public:
LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color = Color::white());
float getLineWidth();
};
- class CV_EXPORTS PlaneWidget : public Widget
+ class CV_EXPORTS PlaneWidget : public Widget3D
{
public:
PlaneWidget(const Vec4f& coefs, double size = 1.0, const Color &color = Color::white());
PlaneWidget(const Vec4f& coefs, const Point3f& pt, double size = 1.0, const Color &color = Color::white());
};
- class CV_EXPORTS SphereWidget : public Widget
+ class CV_EXPORTS SphereWidget : public Widget3D
{
public:
SphereWidget(const cv::Point3f ¢er, float radius, int sphere_resolution = 10, const Color &color = Color::white());
};
- class CV_EXPORTS ArrowWidget : public Widget
+ class CV_EXPORTS ArrowWidget : public Widget3D
{
public:
ArrowWidget(const Point3f& pt1, const Point3f& pt2, const Color &color = Color::white());
};
- class CV_EXPORTS CircleWidget : public Widget
+ class CV_EXPORTS CircleWidget : public Widget3D
{
public:
CircleWidget(const Point3f& pt, double radius, double thickness = 0.01, const Color &color = Color::white());
};
- class CV_EXPORTS CylinderWidget : public Widget
+ class CV_EXPORTS CylinderWidget : public Widget3D
{
public:
CylinderWidget(const Point3f& pt_on_axis, const Point3f& axis_direction, double radius, int numsides = 30, const Color &color = Color::white());
};
- class CV_EXPORTS CubeWidget : public Widget
+ class CV_EXPORTS CubeWidget : public Widget3D
{
public:
CubeWidget(const Point3f& pt_min, const Point3f& pt_max, bool wire_frame = true, const Color &color = Color::white());
};
- class CV_EXPORTS CoordinateSystemWidget : public Widget
+ class CV_EXPORTS CoordinateSystemWidget : public Widget3D
{
public:
CoordinateSystemWidget(double scale, const Affine3f& affine);
};
- class CV_EXPORTS TextWidget : public Widget
+ class CV_EXPORTS TextWidget : public Widget2D
{
public:
TextWidget(const String &text, const Point2i &pos, int font_size = 10, const Color &color = Color::white());
-
- // TODO Overload setColor method, and hide setPose, updatePose, getPose methods
};
- class CV_EXPORTS CloudWidget : public Widget
+ class CV_EXPORTS CloudWidget : public Widget3D
{
public:
CloudWidget(InputArray _cloud, InputArray _colors);
struct CreateCloudWidget;
};
- class CV_EXPORTS CloudNormalsWidget : public Widget
+ class CV_EXPORTS CloudNormalsWidget : public Widget3D
{
public:
CloudNormalsWidget(InputArray _cloud, InputArray _normals, int level = 100, float scale = 0.02f, const Color &color = Color::white());
/// line widget implementation
temp_viz::LineWidget::LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New();
line->SetPoint1 (pt1.x, pt1.y, pt1.z);
line->SetPoint2 (pt2.x, pt2.y, pt2.z);
temp_viz::PlaneWidget::PlaneWidget(const Vec4f& coefs, double size, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New ();
plane->SetNormal (coefs[0], coefs[1], coefs[2]);
double norm = cv::norm(cv::Vec3f(coefs.val));
temp_viz::PlaneWidget::PlaneWidget(const Vec4f& coefs, const Point3f& pt, double size, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New ();
cv::Point3f coefs3(coefs[0], coefs[1], coefs[2]);
double norm_sqr = 1.0 / coefs3.dot (coefs3);
temp_viz::SphereWidget::SphereWidget(const cv::Point3f ¢er, float radius, int sphere_resolution, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New ();
sphere->SetRadius (radius);
sphere->SetCenter (center.x, center.y, center.z);
temp_viz::ArrowWidget::ArrowWidget(const Point3f& pt1, const Point3f& pt2, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New ();
float startPoint[3], endPoint[3];
temp_viz::CircleWidget::CircleWidget(const temp_viz::Point3f& pt, double radius, double thickness, const temp_viz::Color& color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkDiskSource> disk = vtkSmartPointer<vtkDiskSource>::New ();
// Maybe the resolution should be lower e.g. 50 or 25
disk->SetCircumferentialResolution (50);
temp_viz::CylinderWidget::CylinderWidget(const Point3f& pt_on_axis, const Point3f& axis_direction, double radius, int numsides, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
const cv::Point3f pt2 = pt_on_axis + axis_direction;
vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New ();
line->SetPoint1 (pt_on_axis.x, pt_on_axis.y, pt_on_axis.z);
temp_viz::CubeWidget::CubeWidget(const Point3f& pt_min, const Point3f& pt_max, bool wire_frame, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New ();
cube->SetBounds (pt_min.x, pt_max.x, pt_min.y, pt_max.y, pt_min.z, pt_max.z);
temp_viz::CoordinateSystemWidget::CoordinateSystemWidget(double scale, const Affine3f& affine)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New ();
axes->SetOrigin (0, 0, 0);
axes->SetScaleFactor (scale);
///////////////////////////////////////////////////////////////////////////////////////////////
/// text widget implementation
-temp_viz::TextWidget::TextWidget(const String &text, const Point2i &pos, int font_size, const Color &color) : Widget(true)
+temp_viz::TextWidget::TextWidget(const String &text, const Point2i &pos, int font_size, const Color &color)
{
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkTextActor>::New());
+
vtkTextActor *actor = vtkTextActor::SafeDownCast(WidgetAccessor::getActor(*this));
actor->SetPosition (pos.x, pos.y);
actor->SetInput (text.c_str ());
CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
CV_Assert(colors.type() == CV_8UC3 && cloud.size() == colors.size());
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkLODActor * actor = vtkLODActor::SafeDownCast(WidgetAccessor::getActor(*this));
vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
Mat cloud = _cloud.getMat();
CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkLODActor * actor = vtkLODActor::SafeDownCast(WidgetAccessor::getActor(*this));
vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
CV_Assert(cloud.size() == normals.size() && cloud.type() == normals.type());
+ WidgetAccessor::setVtkProp(*this, vtkSmartPointer<vtkLODActor>::New());
+
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
vtkIdType nr_normals = 0;
#include "precomp.hpp"
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// widget implementation
+
class temp_viz::Widget::Impl
{
public:
vtkSmartPointer<vtkProp> actor;
- int ref_counter;
-
- Impl() : actor(vtkSmartPointer<vtkLODActor>::New()) {}
- Impl(bool text_widget)
- {
- if (text_widget)
- actor = vtkSmartPointer<vtkTextActor>::New();
- else
- actor = vtkSmartPointer<vtkLeaderActor2D>::New();
- }
+ Impl() : actor(0) {}
+};
- void setColor(const Color& color)
- {
- vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
- Color c = vtkcolor(color);
- lod_actor->GetMapper ()->ScalarVisibilityOff ();
- lod_actor->GetProperty ()->SetColor (c.val);
- lod_actor->GetProperty ()->SetEdgeColor (c.val);
- lod_actor->GetProperty ()->SetAmbient (0.8);
- lod_actor->GetProperty ()->SetDiffuse (0.8);
- lod_actor->GetProperty ()->SetSpecular (0.8);
- lod_actor->GetProperty ()->SetLighting (0);
- lod_actor->Modified ();
- }
+temp_viz::Widget::Widget() : impl_(0)
+{
+ impl_ = new Impl();
+}
- void setPose(const Affine3f& pose)
- {
- vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
- vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
- lod_actor->SetUserMatrix (matrix);
- lod_actor->Modified ();
- }
+temp_viz::Widget::Widget(const Widget &other) : impl_(other.impl_)
+{
+
+}
- void updatePose(const Affine3f& pose)
+temp_viz::Widget& temp_viz::Widget::operator =(const Widget &other)
+{
+ if (this != &other)
{
- vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
- vtkSmartPointer<vtkMatrix4x4> matrix = lod_actor->GetUserMatrix();
- if (!matrix)
- {
- setPose(pose);
- return ;
- }
- Matx44f matrix_cv = convertToMatx(matrix);
-
- Affine3f updated_pose = pose * Affine3f(matrix_cv);
- matrix = convertToVtkMatrix(updated_pose.matrix);
-
- lod_actor->SetUserMatrix (matrix);
- lod_actor->Modified ();
+ delete impl_;
+ impl_ = other.impl_;
}
+ return *this;
+}
- Affine3f getPose() const
+temp_viz::Widget::~Widget()
+{
+ if (impl_)
{
- vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
- vtkSmartPointer<vtkMatrix4x4> matrix = lod_actor->GetUserMatrix();
- Matx44f matrix_cv = convertToMatx(matrix);
- return Affine3f(matrix_cv);
+ delete impl_;
+ impl_ = 0;
}
+}
-protected:
- static vtkSmartPointer<vtkMatrix4x4> 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;
- }
- static cv::Matx44f 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;
- }
-};
+// class temp_viz::Widget::Impl
+// {
+// public:
+// vtkSmartPointer<vtkProp> actor;
+// int ref_counter;
+//
+// Impl() : actor(vtkSmartPointer<vtkLODActor>::New()) {}
+//
+// Impl(bool text_widget)
+// {
+// if (text_widget)
+// actor = vtkSmartPointer<vtkTextActor>::New();
+// else
+// actor = vtkSmartPointer<vtkLeaderActor2D>::New();
+// }
+//
+// void setColor(const Color& color)
+// {
+// vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
+// Color c = vtkcolor(color);
+// lod_actor->GetMapper ()->ScalarVisibilityOff ();
+// lod_actor->GetProperty ()->SetColor (c.val);
+// lod_actor->GetProperty ()->SetEdgeColor (c.val);
+// lod_actor->GetProperty ()->SetAmbient (0.8);
+// lod_actor->GetProperty ()->SetDiffuse (0.8);
+// lod_actor->GetProperty ()->SetSpecular (0.8);
+// lod_actor->GetProperty ()->SetLighting (0);
+// lod_actor->Modified ();
+// }
+//
+// void setPose(const Affine3f& pose)
+// {
+// vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
+// vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
+// lod_actor->SetUserMatrix (matrix);
+// lod_actor->Modified ();
+// }
+//
+// void updatePose(const Affine3f& pose)
+// {
+// vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
+// vtkSmartPointer<vtkMatrix4x4> matrix = lod_actor->GetUserMatrix();
+// if (!matrix)
+// {
+// setPose(pose);
+// return ;
+// }
+// Matx44f matrix_cv = convertToMatx(matrix);
+//
+// Affine3f updated_pose = pose * Affine3f(matrix_cv);
+// matrix = convertToVtkMatrix(updated_pose.matrix);
+//
+// lod_actor->SetUserMatrix (matrix);
+// lod_actor->Modified ();
+// }
+//
+// Affine3f getPose() const
+// {
+// vtkLODActor *lod_actor = vtkLODActor::SafeDownCast(actor);
+// vtkSmartPointer<vtkMatrix4x4> matrix = lod_actor->GetUserMatrix();
+// Matx44f matrix_cv = convertToMatx(matrix);
+// return Affine3f(matrix_cv);
+// }
+//
+// protected:
+//
+// static vtkSmartPointer<vtkMatrix4x4> 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;
+// }
+//
+// static cv::Matx44f 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;
+// }
+// };
///////////////////////////////////////////////////////////////////////////////////////////////
return widget.impl_->actor;
}
+void temp_viz::WidgetAccessor::setVtkProp(Widget& widget, vtkSmartPointer<vtkProp> actor)
+{
+ widget.impl_->actor = actor;
+}
+
///////////////////////////////////////////////////////////////////////////////////////////////
-/// widget implementaion
+/// widget3D implementation
-temp_viz::Widget::Widget() : impl_(0)
+struct temp_viz::Widget3D::MatrixConverter
{
- create();
-}
+ static cv::Matx44f 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;
+ }
+
+ static vtkSmartPointer<vtkMatrix4x4> 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;
+ }
+};
-temp_viz::Widget::Widget(bool text_widget) : impl_(0)
+temp_viz::Widget3D::Widget3D()
{
- create(text_widget);
+
}
-temp_viz::Widget::Widget(const Widget& other) : impl_(other.impl_)
+void temp_viz::Widget3D::setPose(const Affine3f &pose)
{
- if (impl_)
- CV_XADD(&impl_->ref_counter, 1);
+ vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getActor(*this));
+ CV_Assert(actor);
+
+ vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
+ actor->SetUserMatrix (matrix);
+ actor->Modified ();
}
-temp_viz::Widget& temp_viz::Widget::operator =(const Widget &other)
+void temp_viz::Widget3D::updatePose(const Affine3f &pose)
{
- if (this != &other)
+ vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getActor(*this));
+ CV_Assert(actor);
+
+ vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
+ if (!matrix)
{
- release();
- impl_ = other.impl_;
- if (impl_)
- CV_XADD(&impl_->ref_counter, 1);
+ setPose(pose);
+ return ;
}
- return *this;
-}
+ Matx44f matrix_cv = MatrixConverter::convertToMatx(matrix);
-temp_viz::Widget::~Widget()
-{
- release();
-}
+ Affine3f updated_pose = pose * Affine3f(matrix_cv);
+ matrix = MatrixConverter::convertToVtkMatrix(updated_pose.matrix);
-void temp_viz::Widget::copyTo(Widget& /*dst*/)
-{
- // TODO Deep copy the data if there is any
+ actor->SetUserMatrix (matrix);
+ actor->Modified ();
}
-void temp_viz::Widget::setColor(const Color& color) { impl_->setColor(color); }
-void temp_viz::Widget::setPose(const Affine3f& pose) { impl_->setPose(pose); }
-void temp_viz::Widget::updatePose(const Affine3f& pose) { impl_->updatePose(pose); }
-temp_viz::Affine3f temp_viz::Widget::getPose() const { return impl_->getPose(); }
-
-void temp_viz::Widget::create()
+temp_viz::Affine3f temp_viz::Widget3D::getPose() const
{
- if (impl_)
- release();
- impl_ = new Impl();
- impl_->ref_counter = 1;
+ vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getActor(*this));
+ CV_Assert(actor);
+
+ vtkSmartPointer<vtkMatrix4x4> matrix = actor->GetUserMatrix();
+ Matx44f matrix_cv = MatrixConverter::convertToMatx(matrix);
+ return Affine3f(matrix_cv);
}
-void temp_viz::Widget::release()
+void temp_viz::Widget3D::setColor(const Color &color)
{
- if (impl_ && CV_XADD(&impl_->ref_counter, -1) == 1)
- {
- delete impl_;
- impl_ = 0;
- }
+ // Cast to actor instead of prop3d since prop3d doesn't provide getproperty
+ vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getActor(*this));
+ CV_Assert(actor);
+
+ Color c = vtkcolor(color);
+ actor->GetMapper ()->ScalarVisibilityOff ();
+ actor->GetProperty ()->SetColor (c.val);
+ actor->GetProperty ()->SetEdgeColor (c.val);
+ actor->GetProperty ()->SetAmbient (0.8);
+ actor->GetProperty ()->SetDiffuse (0.8);
+ actor->GetProperty ()->SetSpecular (0.8);
+ actor->GetProperty ()->SetLighting (0);
+ actor->Modified ();
}
-void temp_viz::Widget::create(bool text_widget)
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// widget2D implementation
+
+temp_viz::Widget2D::Widget2D()
{
- if (impl_)
- release();
- impl_ = new Impl(text_widget);
- impl_->ref_counter = 1;
-}
+}
projects / profile / ivi / opencv.git / commitdiff