#include <opencv2/viz/viz3d.hpp>
-namespace temp_viz
+namespace cv
{
- //! takes coordiante frame data and builds transfrom to global coordinate frame
- CV_EXPORTS Affine3f makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin = Vec3f::all(0));
+ namespace viz
+ {
+ //! takes coordiante frame data and builds transfrom to global coordinate frame
+ CV_EXPORTS Affine3f makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin = Vec3f::all(0));
- CV_EXPORTS Affine3f makeCameraPose(const Vec3f& position, const Vec3f& focal_point, const Vec3f& up_vector);
+ CV_EXPORTS Affine3f makeCameraPose(const Vec3f& position, const Vec3f& focal_point, const Vec3f& up_vector);
+ }
}
#include <string>
#include <opencv2/viz/types.hpp>
-namespace temp_viz
+namespace cv
{
- class KeyboardEvent
+ namespace viz
{
- public:
- static const unsigned int Alt = 1;
- static const unsigned int Ctrl = 2;
- static const unsigned int Shift = 4;
-
- /** \brief Constructor
- * \param[in] action true for key was pressed, false for released
- * \param[in] key_sym the key-name that caused the action
- * \param[in] key the key code that caused the action
- * \param[in] alt whether the alt key was pressed at the time where this event was triggered
- * \param[in] ctrl whether the ctrl was pressed at the time where this event was triggered
- * \param[in] shift whether the shift was pressed at the time where this event was triggered
- */
- KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift);
-
- bool isAltPressed () const;
- bool isCtrlPressed () const;
- bool isShiftPressed () const;
-
- unsigned char getKeyCode () const;
-
- const String& getKeySym () const;
- bool keyDown () const;
- bool keyUp () const;
-
- protected:
-
- bool action_;
- unsigned int modifiers_;
- unsigned char key_code_;
- String key_sym_;
- };
-
- class MouseEvent
- {
- public:
- enum Type
+ class KeyboardEvent
{
- MouseMove = 1,
- MouseButtonPress,
- MouseButtonRelease,
- MouseScrollDown,
- MouseScrollUp,
- MouseDblClick
- } ;
-
- enum MouseButton
+ public:
+ static const unsigned int Alt = 1;
+ static const unsigned int Ctrl = 2;
+ static const unsigned int Shift = 4;
+
+ /** \brief Constructor
+ * \param[in] action true for key was pressed, false for released
+ * \param[in] key_sym the key-name that caused the action
+ * \param[in] key the key code that caused the action
+ * \param[in] alt whether the alt key was pressed at the time where this event was triggered
+ * \param[in] ctrl whether the ctrl was pressed at the time where this event was triggered
+ * \param[in] shift whether the shift was pressed at the time where this event was triggered
+ */
+ KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift);
+
+ bool isAltPressed () const;
+ bool isCtrlPressed () const;
+ bool isShiftPressed () const;
+
+ unsigned char getKeyCode () const;
+
+ const String& getKeySym () const;
+ bool keyDown () const;
+ bool keyUp () const;
+
+ protected:
+
+ bool action_;
+ unsigned int modifiers_;
+ unsigned char key_code_;
+ String key_sym_;
+ };
+
+ class MouseEvent
{
- NoButton = 0,
- LeftButton,
- MiddleButton,
- RightButton,
- VScroll /*other buttons, scroll wheels etc. may follow*/
- } ;
-
- MouseEvent (const Type& type, const MouseButton& button, const Point& p, bool alt, bool ctrl, bool shift);
-
-
- Type type;
- MouseButton button;
- Point pointer;
- unsigned int key_state;
- };
+ public:
+ enum Type
+ {
+ MouseMove = 1,
+ MouseButtonPress,
+ MouseButtonRelease,
+ MouseScrollDown,
+ MouseScrollUp,
+ MouseDblClick
+ } ;
+
+ enum MouseButton
+ {
+ NoButton = 0,
+ LeftButton,
+ MiddleButton,
+ RightButton,
+ VScroll /*other buttons, scroll wheels etc. may follow*/
+ } ;
+
+ MouseEvent (const Type& type, const MouseButton& button, const Point& p, bool alt, bool ctrl, bool shift);
+
+
+ Type type;
+ MouseButton button;
+ Point pointer;
+ unsigned int key_state;
+ };
+ }
}
////////////////////////////////////////////////////////////////////
/// Implementation
-inline temp_viz::KeyboardEvent::KeyboardEvent (bool _action, const std::string& _key_sym, unsigned char key, bool alt, bool ctrl, bool shift)
+inline cv::viz::KeyboardEvent::KeyboardEvent (bool _action, const std::string& _key_sym, unsigned char key, bool alt, bool ctrl, bool shift)
: action_ (_action), modifiers_ (0), key_code_(key), key_sym_ (_key_sym)
{
if (alt)
modifiers_ |= Shift;
}
-inline bool temp_viz::KeyboardEvent::isAltPressed () const { return (modifiers_ & Alt) != 0; }
-inline bool temp_viz::KeyboardEvent::isCtrlPressed () const { return (modifiers_ & Ctrl) != 0; }
-inline bool temp_viz::KeyboardEvent::isShiftPressed () const { return (modifiers_ & Shift) != 0; }
-inline unsigned char temp_viz::KeyboardEvent::getKeyCode () const { return key_code_; }
-inline const temp_viz::String& temp_viz::KeyboardEvent::getKeySym () const { return key_sym_; }
-inline bool temp_viz::KeyboardEvent::keyDown () const { return action_; }
-inline bool temp_viz::KeyboardEvent::keyUp () const { return !action_; }
+inline bool cv::viz::KeyboardEvent::isAltPressed () const { return (modifiers_ & Alt) != 0; }
+inline bool cv::viz::KeyboardEvent::isCtrlPressed () const { return (modifiers_ & Ctrl) != 0; }
+inline bool cv::viz::KeyboardEvent::isShiftPressed () const { return (modifiers_ & Shift) != 0; }
+inline unsigned char cv::viz::KeyboardEvent::getKeyCode () const { return key_code_; }
+inline const cv::String& cv::viz::KeyboardEvent::getKeySym () const { return key_sym_; }
+inline bool cv::viz::KeyboardEvent::keyDown () const { return action_; }
+inline bool cv::viz::KeyboardEvent::keyUp () const { return !action_; }
-inline temp_viz::MouseEvent::MouseEvent (const Type& _type, const MouseButton& _button, const Point& _p, bool alt, bool ctrl, bool shift)
+inline cv::viz::MouseEvent::MouseEvent (const Type& _type, const MouseButton& _button, const Point& _p, bool alt, bool ctrl, bool shift)
: type(_type), button(_button), pointer(_p), key_state(0)
{
if (alt)
#include <opencv2/core.hpp>
#include <opencv2/core/affine.hpp>
-namespace temp_viz
+namespace cv
{
- //qt creator hack
- typedef cv::Scalar Scalar;
- typedef cv::Mat Mat;
typedef std::string String;
-
- typedef cv::Vec3d Vec3d;
- typedef cv::Vec3f Vec3f;
- typedef cv::Vec4d Vec4d;
- typedef cv::Vec4f Vec4f;
- typedef cv::Vec2d Vec2d;
- typedef cv::Vec2i Vec2i;
- typedef cv::Vec3b Vec3b;
- typedef cv::Matx33d Matx33d;
- typedef cv::Affine3f Affine3f;
- typedef cv::Affine3d Affine3d;
- typedef cv::Point2i Point2i;
- typedef cv::Point3f Point3f;
- typedef cv::Point3d Point3d;
- typedef cv::Matx44d Matx44d;
- typedef cv::Matx44f Matx44f;
- typedef cv::Size Size;
- typedef cv::Point Point;
- typedef cv::InputArray InputArray;
- using cv::Point3_;
- using cv::Vec;
- using cv::Mat_;
- using cv::DataDepth;
- using cv::DataType;
-
- class CV_EXPORTS Color : public Scalar
+// //qt creator hack
+// typedef cv::Scalar Scalar;
+// typedef cv::Mat Mat;
+// typedef std::string String;
+
+// typedef cv::Vec3d Vec3d;
+// typedef cv::Vec3f Vec3f;
+// typedef cv::Vec4d Vec4d;
+// typedef cv::Vec4f Vec4f;
+// typedef cv::Vec2d Vec2d;
+// typedef cv::Vec2i Vec2i;
+// typedef cv::Vec3b Vec3b;
+// typedef cv::Matx33d Matx33d;
+// typedef cv::Affine3f Affine3f;
+// typedef cv::Affine3d Affine3d;
+// typedef cv::Point2i Point2i;
+// typedef cv::Point3f Point3f;
+// typedef cv::Point3d Point3d;
+// typedef cv::Matx44d Matx44d;
+// typedef cv::Matx44f Matx44f;
+// typedef cv::Size Size;
+// typedef cv::Point Point;
+// typedef cv::InputArray InputArray;
+// using cv::Point3_;
+// using cv::Vec;
+// using cv::Mat_;
+// using cv::DataDepth;
+// using cv::DataType;
+// using cv::Ptr;
+ namespace viz
{
- public:
- Color();
- Color(double gray);
- Color(double blue, double green, double red);
+ class CV_EXPORTS Color : public Scalar
+ {
+ public:
+ Color();
+ Color(double gray);
+ Color(double blue, double green, double red);
- Color(const Scalar& color);
+ Color(const Scalar& color);
- static Color black();
- static Color blue();
- static Color green();
- static Color cyan();
+ static Color black();
+ static Color blue();
+ static Color green();
+ static Color cyan();
- static Color red();
- static Color magenta();
- static Color yellow();
- static Color white();
+ static Color red();
+ static Color magenta();
+ static Color yellow();
+ static Color white();
- static Color gray();
- };
+ static Color gray();
+ };
- struct CV_EXPORTS Vertices
- {
- std::vector<unsigned int> vertices;
- };
+ struct CV_EXPORTS Vertices
+ {
+ std::vector<unsigned int> vertices;
+ };
- class CV_EXPORTS Mesh3d
- {
- public:
- typedef Ptr<Mesh3d> Ptr;
+ class CV_EXPORTS Mesh3d
+ {
+ public:
+ typedef Ptr<Mesh3d> Ptr;
- Mat cloud, colors;
- std::vector<Vertices> polygons;
+ Mat cloud, colors;
+ std::vector<Vertices> polygons;
- static Mesh3d::Ptr mesh_load(const String& file);
+ static Mesh3d::Ptr mesh_load(const String& file);
- };
+ };
- /////////////////////////////////////////////////////////////////////////////
- /// Utility functions
+ /////////////////////////////////////////////////////////////////////////////
+ /// Utility functions
- inline Color vtkcolor(const Color& color)
- {
- Color scaled_color = color * (1.0/255.0);
- std::swap(scaled_color[0], scaled_color[2]);
- return scaled_color;
- }
+ inline Color vtkcolor(const Color& color)
+ {
+ Color scaled_color = color * (1.0/255.0);
+ std::swap(scaled_color[0], scaled_color[2]);
+ return scaled_color;
+ }
- inline Vec3d vtkpoint(const Point3f& point) { return Vec3d(point.x, point.y, point.z); }
- template<typename _Tp> inline _Tp normalized(const _Tp& v) { return v * 1/cv::norm(v); }
-
- inline bool isNan(float x)
- {
- unsigned int *u = reinterpret_cast<unsigned int *>(&x);
- return ((u[0] & 0x7f800000) == 0x7f800000) && (u[0] & 0x007fffff);
- }
-
- inline bool isNan(double x)
- {
- unsigned int *u = reinterpret_cast<unsigned int *>(&x);
- return (u[1] & 0x7ff00000) == 0x7ff00000 && (u[0] != 0 || (u[1] & 0x000fffff) != 0);
- }
+ inline Vec3d vtkpoint(const Point3f& point) { return Vec3d(point.x, point.y, point.z); }
+ template<typename _Tp> inline _Tp normalized(const _Tp& v) { return v * 1/cv::norm(v); }
+
+ inline bool isNan(float x)
+ {
+ unsigned int *u = reinterpret_cast<unsigned int *>(&x);
+ return ((u[0] & 0x7f800000) == 0x7f800000) && (u[0] & 0x007fffff);
+ }
- template<typename _Tp, int cn> inline bool isNan(const Vec<_Tp, cn>& v)
- { return isNan(v.val[0]) || isNan(v.val[1]) || isNan(v.val[2]); }
+ inline bool isNan(double x)
+ {
+ unsigned int *u = reinterpret_cast<unsigned int *>(&x);
+ return (u[1] & 0x7ff00000) == 0x7ff00000 && (u[0] != 0 || (u[1] & 0x000fffff) != 0);
+ }
- template<typename _Tp> inline bool isNan(const Point3_<_Tp>& p)
- { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
+ template<typename _Tp, int cn> inline bool isNan(const Vec<_Tp, cn>& v)
+ { return isNan(v.val[0]) || isNan(v.val[1]) || isNan(v.val[2]); }
+
+ template<typename _Tp> inline bool isNan(const Point3_<_Tp>& p)
+ { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
+ }
}
#include <opencv2/viz/widgets.hpp>
#include <opencv2/viz/events.hpp>
-namespace temp_viz
+namespace cv
{
- class CV_EXPORTS Viz3d
+ namespace viz
{
- public:
+ class CV_EXPORTS Viz3d
+ {
+ public:
- typedef cv::Ptr<Viz3d> Ptr;
+ typedef cv::Ptr<Viz3d> Ptr;
- Viz3d(const String& window_name = String());
- ~Viz3d();
+ Viz3d(const String& window_name = String());
+ ~Viz3d();
- void setBackgroundColor(const Color& color = Color::black());
+ void setBackgroundColor(const Color& color = Color::black());
- bool addPolygonMesh (const Mesh3d& mesh, const String& id = "polygon");
- bool updatePolygonMesh (const Mesh3d& mesh, const String& id = "polygon");
+ 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 addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id = "polyline");
- bool addPolygon(const Mat& cloud, const Color& color, const String& id = "polygon");
+ bool addPolygon(const Mat& cloud, const Color& color, const String& id = "polygon");
- void spin ();
- void spinOnce (int time = 1, bool force_redraw = false);
+ void spin ();
+ void spinOnce (int time = 1, bool force_redraw = false);
- void registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie = 0);
- void registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie = 0);
+ void registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie = 0);
+ void registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie = 0);
- bool wasStopped() const;
-
- void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
- void removeWidget(const String &id);
- Widget getWidget(const String &id) const;
-
- void setWidgetPose(const String &id, const Affine3f &pose);
- void updateWidgetPose(const String &id, const Affine3f &pose);
- Affine3f getWidgetPose(const String &id) const;
- private:
- Viz3d(const Viz3d&);
- Viz3d& operator=(const Viz3d&);
+ bool wasStopped() const;
- struct VizImpl;
- VizImpl* impl_;
- };
+ void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
+ void removeWidget(const String &id);
+ Widget getWidget(const String &id) const;
+
+ void setWidgetPose(const String &id, const Affine3f &pose);
+ void updateWidgetPose(const String &id, const Affine3f &pose);
+ Affine3f getWidgetPose(const String &id) const;
+ private:
+ Viz3d(const Viz3d&);
+ Viz3d& operator=(const Viz3d&);
+
+ struct VizImpl;
+ VizImpl* impl_;
+ };
+ }
}
#include <vtkSmartPointer.h>
#include <vtkProp.h>
-namespace temp_viz
+namespace cv
{
- class Widget;
-
- //The class is only that depends on VTK in its interface.
- //It is indended for those users who want to develop own widgets system using VTK library API.
- struct CV_EXPORTS WidgetAccessor
+ namespace viz
{
- static vtkSmartPointer<vtkProp> getProp(const Widget &widget);
- static void setProp(Widget &widget, vtkSmartPointer<vtkProp> prop);
- };
+ class Widget;
+
+ //The class is only that depends on VTK in its interface.
+ //It is indended for those users who want to develop own widgets system using VTK library API.
+ struct CV_EXPORTS WidgetAccessor
+ {
+ static vtkSmartPointer<vtkProp> getProp(const Widget &widget);
+ static void setProp(Widget &widget, vtkSmartPointer<vtkProp> prop);
+ };
+ }
}
#include <opencv2/viz/types.hpp>
-namespace temp_viz
+namespace cv
{
- /////////////////////////////////////////////////////////////////////////////
- /// The base class for all widgets
- class CV_EXPORTS Widget
- {
- public:
- Widget();
- Widget(const Widget &other);
- Widget& operator =(const Widget &other);
-
- ~Widget();
-
- template<typename _W> _W cast();
- private:
- class Impl;
- Impl *impl_;
- friend struct WidgetAccessor;
-
- void create();
- void release();
- };
-
- /////////////////////////////////////////////////////////////////////////////
- /// 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;
-
- void setColor(const Color &color);
-
- private:
- struct MatrixConverter;
-
- };
-
- /////////////////////////////////////////////////////////////////////////////
- /// The base class for all 2D widgets
- class CV_EXPORTS Widget2D : public Widget
- {
- public:
- Widget2D() {}
-
- void setColor(const Color &color);
- };
-
- class CV_EXPORTS LineWidget : public Widget3D
- {
- public:
- LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color = Color::white());
-
- void setLineWidth(float line_width);
- float getLineWidth();
- };
-
- 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 Widget3D
- {
- public:
- SphereWidget(const cv::Point3f ¢er, float radius, int sphere_resolution = 10, const Color &color = Color::white());
- };
-
- class CV_EXPORTS ArrowWidget : public Widget3D
- {
- public:
- ArrowWidget(const Point3f& pt1, const Point3f& pt2, const Color &color = Color::white());
- };
+ namespace viz
+ {
+ /////////////////////////////////////////////////////////////////////////////
+ /// The base class for all widgets
+ class CV_EXPORTS Widget
+ {
+ public:
+ Widget();
+ Widget(const Widget &other);
+ Widget& operator =(const Widget &other);
- 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 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 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 Widget3D
- {
- public:
- CoordinateSystemWidget(double scale = 1.0);
- };
-
- class CV_EXPORTS PolyLineWidget : public Widget3D
- {
- public:
- PolyLineWidget(InputArray points, const Color &color = Color::white());
-
- private:
- struct CopyImpl;
- };
-
- class CV_EXPORTS GridWidget : public Widget3D
- {
- public:
- GridWidget(Vec2i dimensions, Vec2d spacing, const Color &color = Color::white());
- };
-
- class CV_EXPORTS Text3DWidget : public Widget3D
- {
- public:
- Text3DWidget(const String &text, const Point3f &position, double text_scale = 1.0, const Color &color = Color::white());
-
- void setText(const String &text);
- String getText() const;
- };
-
- class CV_EXPORTS TextWidget : public Widget2D
- {
- public:
- TextWidget(const String &text, const Point2i &pos, int font_size = 10, const Color &color = Color::white());
-
- void setText(const String &text);
- String getText() const;
- };
-
- class CV_EXPORTS CloudWidget : public Widget3D
- {
- public:
- CloudWidget(InputArray cloud, InputArray colors);
- CloudWidget(InputArray cloud, const Color &color = Color::white());
-
- private:
- struct CreateCloudWidget;
- };
-
- class CV_EXPORTS CloudNormalsWidget : public Widget3D
- {
- public:
- CloudNormalsWidget(InputArray cloud, InputArray normals, int level = 100, float scale = 0.02f, const Color &color = Color::white());
-
- private:
- struct ApplyCloudNormals;
- };
-
- template<> CV_EXPORTS Widget2D Widget::cast<Widget2D>();
- template<> CV_EXPORTS Widget3D Widget::cast<Widget3D>();
- template<> CV_EXPORTS LineWidget Widget::cast<LineWidget>();
- template<> CV_EXPORTS PlaneWidget Widget::cast<PlaneWidget>();
- template<> CV_EXPORTS SphereWidget Widget::cast<SphereWidget>();
- template<> CV_EXPORTS CylinderWidget Widget::cast<CylinderWidget>();
- template<> CV_EXPORTS ArrowWidget Widget::cast<ArrowWidget>();
- template<> CV_EXPORTS CircleWidget Widget::cast<CircleWidget>();
- template<> CV_EXPORTS CubeWidget Widget::cast<CubeWidget>();
- template<> CV_EXPORTS CoordinateSystemWidget Widget::cast<CoordinateSystemWidget>();
- template<> CV_EXPORTS PolyLineWidget Widget::cast<PolyLineWidget>();
- template<> CV_EXPORTS GridWidget Widget::cast<GridWidget>();
- template<> CV_EXPORTS Text3DWidget Widget::cast<Text3DWidget>();
- template<> CV_EXPORTS TextWidget Widget::cast<TextWidget>();
- template<> CV_EXPORTS CloudWidget Widget::cast<CloudWidget>();
- template<> CV_EXPORTS CloudNormalsWidget Widget::cast<CloudNormalsWidget>();
-}
+ ~Widget();
+
+ template<typename _W> _W cast();
+ private:
+ class Impl;
+ Impl *impl_;
+ friend struct WidgetAccessor;
+
+ void create();
+ void release();
+ };
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// 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;
+
+ void setColor(const Color &color);
+
+ private:
+ struct MatrixConverter;
+
+ };
+
+ /////////////////////////////////////////////////////////////////////////////
+ /// The base class for all 2D widgets
+ class CV_EXPORTS Widget2D : public Widget
+ {
+ public:
+ Widget2D() {}
+
+ void setColor(const Color &color);
+ };
+
+ class CV_EXPORTS LineWidget : public Widget3D
+ {
+ public:
+ LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color = Color::white());
+
+ void setLineWidth(float line_width);
+ float getLineWidth();
+ };
+
+ 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 Widget3D
+ {
+ public:
+ SphereWidget(const cv::Point3f ¢er, float radius, int sphere_resolution = 10, const Color &color = Color::white());
+ };
+
+ class CV_EXPORTS ArrowWidget : public Widget3D
+ {
+ public:
+ ArrowWidget(const Point3f& pt1, const Point3f& pt2, const Color &color = Color::white());
+ };
+
+ 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 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 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 Widget3D
+ {
+ public:
+ CoordinateSystemWidget(double scale = 1.0);
+ };
+
+ class CV_EXPORTS PolyLineWidget : public Widget3D
+ {
+ public:
+ PolyLineWidget(InputArray points, const Color &color = Color::white());
+
+ private:
+ struct CopyImpl;
+ };
+
+ class CV_EXPORTS GridWidget : public Widget3D
+ {
+ public:
+ GridWidget(Vec2i dimensions, Vec2d spacing, const Color &color = Color::white());
+ };
+
+ class CV_EXPORTS Text3DWidget : public Widget3D
+ {
+ public:
+ Text3DWidget(const String &text, const Point3f &position, double text_scale = 1.0, const Color &color = Color::white());
+
+ void setText(const String &text);
+ String getText() const;
+ };
+
+ class CV_EXPORTS TextWidget : public Widget2D
+ {
+ public:
+ TextWidget(const String &text, const Point2i &pos, int font_size = 10, const Color &color = Color::white());
+
+ void setText(const String &text);
+ String getText() const;
+ };
+
+ class CV_EXPORTS CloudWidget : public Widget3D
+ {
+ public:
+ CloudWidget(InputArray cloud, InputArray colors);
+ CloudWidget(InputArray cloud, const Color &color = Color::white());
+
+ private:
+ struct CreateCloudWidget;
+ };
+
+ class CV_EXPORTS CloudNormalsWidget : public Widget3D
+ {
+ public:
+ CloudNormalsWidget(InputArray cloud, InputArray normals, int level = 100, float scale = 0.02f, const Color &color = Color::white());
+
+ private:
+ struct ApplyCloudNormals;
+ };
+
+ template<> CV_EXPORTS Widget2D Widget::cast<Widget2D>();
+ template<> CV_EXPORTS Widget3D Widget::cast<Widget3D>();
+ template<> CV_EXPORTS LineWidget Widget::cast<LineWidget>();
+ template<> CV_EXPORTS PlaneWidget Widget::cast<PlaneWidget>();
+ template<> CV_EXPORTS SphereWidget Widget::cast<SphereWidget>();
+ template<> CV_EXPORTS CylinderWidget Widget::cast<CylinderWidget>();
+ template<> CV_EXPORTS ArrowWidget Widget::cast<ArrowWidget>();
+ template<> CV_EXPORTS CircleWidget Widget::cast<CircleWidget>();
+ template<> CV_EXPORTS CubeWidget Widget::cast<CubeWidget>();
+ template<> CV_EXPORTS CoordinateSystemWidget Widget::cast<CoordinateSystemWidget>();
+ template<> CV_EXPORTS PolyLineWidget Widget::cast<PolyLineWidget>();
+ template<> CV_EXPORTS GridWidget Widget::cast<GridWidget>();
+ template<> CV_EXPORTS Text3DWidget Widget::cast<Text3DWidget>();
+ template<> CV_EXPORTS TextWidget Widget::cast<TextWidget>();
+ template<> CV_EXPORTS CloudWidget Widget::cast<CloudWidget>();
+ template<> CV_EXPORTS CloudNormalsWidget Widget::cast<CloudNormalsWidget>();
+
+ } /* namespace viz */
+} /* namespace cv */
/////////////////////////////////////////////////////////////////////////////////////////////
-//Eigen::Matrix4d temp_viz::vtkToEigen (vtkMatrix4x4* vtk_matrix)
+//Eigen::Matrix4d cv::viz::vtkToEigen (vtkMatrix4x4* vtk_matrix)
//{
// Eigen::Matrix4d eigen_matrix = Eigen::Matrix4d::Identity ();
// for (int i=0; i < 4; i++)
//}
///////////////////////////////////////////////////////////////////////////////////////////////
-//Eigen::Vector2i temp_viz::worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
+//Eigen::Vector2i cv::viz::worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
//{
// // Transform world to clipping coordinates
// Eigen::Vector4d world (view_projection_matrix * world_pt);
//}
/////////////////////////////////////////////////////////////////////////////////////////////
-//void temp_viz::getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24])
+//void cv::viz::getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24])
//{
// // Set up the normals
// Eigen::Vector4d normals[6];
// }
//}
-//int temp_viz::cullFrustum (double frustum[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb)
+//int cv::viz::cullFrustum (double frustum[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb)
//{
// int result = PCL_INSIDE_FRUSTUM;
//}
//void
-//temp_viz::getModelViewPosition (Eigen::Matrix4d model_view_matrix, Eigen::Vector3d &position)
+//cv::viz::getModelViewPosition (Eigen::Matrix4d model_view_matrix, Eigen::Vector3d &position)
//{
// //Compute eye or position from model view matrix
// Eigen::Matrix4d inverse_model_view_matrix = model_view_matrix.inverse();
/////////////////////////////////////////////////////////////////////////////////////////////
//float
-//temp_viz::viewScreenArea (
+//cv::viz::viewScreenArea (
// const Eigen::Vector3d &eye,
// const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb,
// const Eigen::Matrix4d &view_projection_matrix, int width, int height)
// for (int i = 0; i < num; i++)
// {
// Eigen::Vector4d world_pt = bounding_box[hull_vertex_table[pos][i]];
-// Eigen::Vector2i screen_pt = temp_viz::worldToView(world_pt, view_projection_matrix, width, height);
+// Eigen::Vector2i screen_pt = cv::viz::worldToView(world_pt, view_projection_matrix, width, height);
// // cout << "point[" << i << "]: " << screen_pt.x() << " " << screen_pt.y() << endl;
// dst[i] = Eigen::Vector2d(screen_pt.x (), screen_pt.y ());
// }
//}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Camera::computeViewMatrix (Affine3d& view_mat) const
+void cv::viz::Camera::computeViewMatrix (Affine3d& view_mat) const
{
//constructs view matrix from camera pos, view up, and the point it is looking at
//this code is based off of gluLookAt http://www.opengl.org/wiki/GluLookAt_code
}
///////////////////////////////////////////////////////////////////////
-void temp_viz::Camera::computeProjectionMatrix (Matx44d& proj) const
+void cv::viz::Camera::computeProjectionMatrix (Matx44d& proj) const
{
double top = clip[0] * tan (0.5 * fovy);
double left = -(top * window_size[0]) / window_size[1];
#include <opencv2/core/cvdef.h>
#include <opencv2/core.hpp>
#include <opencv2/viz/types.hpp>
-//#include <vtkMatrix4x4.h>
-namespace temp_viz
+namespace cv
{
- //CV_EXPORTS Eigen::Matrix4d vtkToEigen (vtkMatrix4x4* vtk_matrix);
- //CV_EXPORTS Eigen::Vector2i worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
- //CV_EXPORTS void getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24]);
+ namespace viz
+ {
+ //CV_EXPORTS Eigen::Matrix4d vtkToEigen (vtkMatrix4x4* vtk_matrix);
+ //CV_EXPORTS Eigen::Vector2i worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
+ //CV_EXPORTS void getViewFrustum (const Eigen::Matrix4d &view_projection_matrix, double planes[24]);
-// enum FrustumCull
-// {
-// PCL_INSIDE_FRUSTUM,
-// PCL_INTERSECT_FRUSTUM,
-// PCL_OUTSIDE_FRUSTUM
-// };
+ // enum FrustumCull
+ // {
+ // PCL_INSIDE_FRUSTUM,
+ // PCL_INTERSECT_FRUSTUM,
+ // PCL_OUTSIDE_FRUSTUM
+ // };
- //CV_EXPORTS int cullFrustum (double planes[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb);
- //CV_EXPORTS float viewScreenArea (const Eigen::Vector3d &eye, const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
+ //CV_EXPORTS int cullFrustum (double planes[24], const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb);
+ //CV_EXPORTS float viewScreenArea (const Eigen::Vector3d &eye, const Eigen::Vector3d &min_bb, const Eigen::Vector3d &max_bb, const Eigen::Matrix4d &view_projection_matrix, int width, int height);
- enum RenderingProperties
- {
- VIZ_POINT_SIZE,
- VIZ_OPACITY,
- VIZ_LINE_WIDTH,
- VIZ_FONT_SIZE,
- VIZ_COLOR,
- VIZ_REPRESENTATION,
- VIZ_IMMEDIATE_RENDERING,
- VIZ_SHADING
- };
-
- enum RenderingRepresentationProperties
- {
- REPRESENTATION_POINTS,
- REPRESENTATION_WIREFRAME,
- REPRESENTATION_SURFACE
- };
-
- enum ShadingRepresentationProperties
- {
- SHADING_FLAT,
- SHADING_GOURAUD,
- SHADING_PHONG
- };
+ enum RenderingProperties
+ {
+ VIZ_POINT_SIZE,
+ VIZ_OPACITY,
+ VIZ_LINE_WIDTH,
+ VIZ_FONT_SIZE,
+ VIZ_COLOR,
+ VIZ_REPRESENTATION,
+ VIZ_IMMEDIATE_RENDERING,
+ VIZ_SHADING
+ };
+
+ enum RenderingRepresentationProperties
+ {
+ REPRESENTATION_POINTS,
+ REPRESENTATION_WIREFRAME,
+ REPRESENTATION_SURFACE
+ };
- class CV_EXPORTS Camera
- {
- public:
- /** Focal point or lookAt. The view direction can be obtained by (focal-pos).normalized () */
- Vec3d focal;
-
- /** \brief Position of the camera. */
- Vec3d pos;
-
- /** \brief Up vector of the camera. */
- Vec3d view_up;
-
- /** \brief Near/far clipping planes depths */
- Vec2d clip;
-
- /** \brief Field of view angle in y direction (radians). */
- double fovy;
-
- // the following variables are the actual position and size of the window on the screen and NOT the viewport!
- // except for the size, which is the same the viewport is assumed to be centered and same size as the window.
- Vec2i window_size;
- Vec2i window_pos;
-
- /** \brief Computes View matrix for Camera (Based on gluLookAt)
- * \param[out] view_mat the resultant matrix
- */
- void computeViewMatrix(Affine3d& view_mat) const;
-
- /** \brief Computes Projection Matrix for Camera
- * \param[out] proj the resultant matrix
- */
- void computeProjectionMatrix(Matx44d& proj) const;
-
- /** \brief converts point to window coordiantes
- * \param[in] pt xyz point to be converted
- * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
- *
- * This function computes the projection and view matrix every time.
- * It is very inefficient to use this for every point in the point cloud!
- */
- void cvtWindowCoordinates (const cv::Point3f& pt, Vec4d& window_cord) const
+ enum ShadingRepresentationProperties
{
- Affine3d view;
- computeViewMatrix (view);
-
- Matx44d proj;
- computeProjectionMatrix (proj);
- cvtWindowCoordinates (pt, proj * view.matrix, window_cord);
- return;
- }
-
- /** \brief converts point to window coordiantes
- * \param[in] pt xyz point to be converted
- * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
- * \param[in] composite_mat composite transformation matrix (proj*view)
- *
- * Use this function to compute window coordinates with a precomputed
- * transformation function. The typical composite matrix will be
- * the projection matrix * the view matrix. However, additional
- * matrices like a camera disortion matrix can also be added.
- */
- void cvtWindowCoordinates (const Point3f& pt, const Matx44d& composite_mat, Vec4d& window_cord) const
+ SHADING_FLAT,
+ SHADING_GOURAUD,
+ SHADING_PHONG
+ };
+
+ class CV_EXPORTS Camera
{
- Vec4d pte (pt.x, pt.y, pt.z, 1);
- window_cord = composite_mat * pte;
- window_cord = window_cord/window_cord[3];
-
- window_cord[0] = (window_cord[0]+1.0) / 2.0*window_size[0];
- window_cord[1] = (window_cord[1]+1.0) / 2.0*window_size[1];
- window_cord[2] = (window_cord[2]+1.0) / 2.0;
- }
- };
+ public:
+ /** Focal point or lookAt. The view direction can be obtained by (focal-pos).normalized () */
+ Vec3d focal;
+
+ /** \brief Position of the camera. */
+ Vec3d pos;
+
+ /** \brief Up vector of the camera. */
+ Vec3d view_up;
+
+ /** \brief Near/far clipping planes depths */
+ Vec2d clip;
+
+ /** \brief Field of view angle in y direction (radians). */
+ double fovy;
+
+ // the following variables are the actual position and size of the window on the screen and NOT the viewport!
+ // except for the size, which is the same the viewport is assumed to be centered and same size as the window.
+ Vec2i window_size;
+ Vec2i window_pos;
+
+ /** \brief Computes View matrix for Camera (Based on gluLookAt)
+ * \param[out] view_mat the resultant matrix
+ */
+ void computeViewMatrix(Affine3d& view_mat) const;
+
+ /** \brief Computes Projection Matrix for Camera
+ * \param[out] proj the resultant matrix
+ */
+ void computeProjectionMatrix(Matx44d& proj) const;
+
+ /** \brief converts point to window coordiantes
+ * \param[in] pt xyz point to be converted
+ * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
+ *
+ * This function computes the projection and view matrix every time.
+ * It is very inefficient to use this for every point in the point cloud!
+ */
+ void cvtWindowCoordinates (const cv::Point3f& pt, Vec4d& window_cord) const
+ {
+ Affine3d view;
+ computeViewMatrix (view);
+
+ Matx44d proj;
+ computeProjectionMatrix (proj);
+ cvtWindowCoordinates (pt, proj * view.matrix, window_cord);
+ return;
+ }
+
+ /** \brief converts point to window coordiantes
+ * \param[in] pt xyz point to be converted
+ * \param[out] window_cord vector containing the pts' window X,Y, Z and 1
+ * \param[in] composite_mat composite transformation matrix (proj*view)
+ *
+ * Use this function to compute window coordinates with a precomputed
+ * transformation function. The typical composite matrix will be
+ * the projection matrix * the view matrix. However, additional
+ * matrices like a camera disortion matrix can also be added.
+ */
+ void cvtWindowCoordinates (const Point3f& pt, const Matx44d& composite_mat, Vec4d& window_cord) const
+ {
+ Vec4d pte (pt.x, pt.y, pt.z, 1);
+ window_cord = composite_mat * pte;
+ window_cord = window_cord/window_cord[3];
+
+ window_cord[0] = (window_cord[0]+1.0) / 2.0*window_size[0];
+ window_cord[1] = (window_cord[1]+1.0) / 2.0*window_size[1];
+ window_cord[2] = (window_cord[2]+1.0) / 2.0;
+ }
+ };
+
+ }
}
using namespace cv;
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::Initialize ()
+void cv::viz::InteractorStyle::Initialize ()
{
- modifier_ = temp_viz::InteractorStyle::KB_MOD_ALT;
+ modifier_ = cv::viz::InteractorStyle::KB_MOD_ALT;
// Set windows size (width, height) to unknown (-1)
win_size_ = Vec2i(-1, -1);
win_pos_ = Vec2i(0, 0);
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::saveScreenshot (const std::string &file)
+void cv::viz::InteractorStyle::saveScreenshot (const std::string &file)
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
wif_->SetInput (Interactor->GetRenderWindow ());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::zoomIn ()
+void cv::viz::InteractorStyle::zoomIn ()
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
// Zoom in
StartDolly ();
double factor = 10.0 * 0.2 * .5;
- Dolly (pow (1.1, factor));
+ Dolly (std::pow (1.1, factor));
EndDolly ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::zoomOut ()
+void cv::viz::InteractorStyle::zoomOut ()
{
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
// Zoom out
StartDolly ();
double factor = 10.0 * -0.2 * .5;
- Dolly (pow (1.1, factor));
+ Dolly (std::pow (1.1, factor));
EndDolly ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnChar ()
+void cv::viz::InteractorStyle::OnChar ()
{
// Make sure we ignore the same events we handle in OnKeyDown to avoid calling things twice
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]);
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
+void cv::viz::InteractorStyle::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
{
// Register the callback function and store the user data
mouseCallback_ = callback;
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void *cookie)
+void cv::viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void *cookie)
{
// Register the callback function and store the user data
keyboardCallback_ = callback;
//////////////////////////////////////////////////////////////////////////////////////////////
void
-temp_viz::InteractorStyle::OnKeyDown ()
+cv::viz::InteractorStyle::OnKeyDown ()
{
if (!init_)
{
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnKeyUp ()
+void cv::viz::InteractorStyle::OnKeyUp ()
{
KeyboardEvent event (false, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
// Check if there is a keyboard callback registered
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMouseMove ()
+void cv::viz::InteractorStyle::OnMouseMove ()
{
Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseMove, MouseEvent::NoButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnLeftButtonDown ()
+void cv::viz::InteractorStyle::OnLeftButtonDown ()
{
Vec2i p(Interactor->GetEventPosition());
MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnLeftButtonUp ()
+void cv::viz::InteractorStyle::OnLeftButtonUp ()
{
Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMiddleButtonDown ()
+void cv::viz::InteractorStyle::OnMiddleButtonDown ()
{
Vec2i p(Interactor->GetEventPosition());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMiddleButtonUp ()
+void cv::viz::InteractorStyle::OnMiddleButtonUp ()
{
Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnRightButtonDown ()
+void cv::viz::InteractorStyle::OnRightButtonDown ()
{
Vec2i p(Interactor->GetEventPosition());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnRightButtonUp ()
+void cv::viz::InteractorStyle::OnRightButtonUp ()
{
Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::RightButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMouseWheelForward ()
+void cv::viz::InteractorStyle::OnMouseWheelForward ()
{
Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseScrollUp, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnMouseWheelBackward ()
+void cv::viz::InteractorStyle::OnMouseWheelBackward ()
{
Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseScrollDown, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ());
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::InteractorStyle::OnTimer ()
+void cv::viz::InteractorStyle::OnTimer ()
{
if (!init_)
{
}
-namespace temp_viz
-{
- // Standard VTK macro for *New ()
- vtkStandardNewMacro (InteractorStyle);
+
+
+namespace cv
+{
+ namespace viz
+ {
+ //Standard VTK macro for *New()
+ vtkStandardNewMacro(InteractorStyle)
+ }
}
#include "viz_types.h"
#include <opencv2/viz/events.hpp>
-namespace temp_viz
+namespace cv
{
+ namespace viz
+ {
/** \brief PCLVisualizerInteractorStyle defines an unique, custom VTK
* based interactory style for PCL Visualizer applications. Besides
* defining the rendering style, we also create a list of custom actions
/** \brief Pass a pointer to the actor map
* \param[in] actors the actor map that will be used with this style
*/
- inline void setCloudActorMap (const cv::Ptr<CloudActorMap>& actors) { actors_ = actors; }
+ inline void setCloudActorMap (const Ptr<CloudActorMap>& actors) { actors_ = actors; }
/** \brief Pass a set of renderers to the interactor style.
* \param[in] rens the vtkRendererCollection to use
/** \brief MouseEvent callback user data */
void *mouse_callback_cookie_;
};
+ }
}
#include <vtkPointData.h>
#include <vtkCellArray.h>
-temp_viz::Mesh3d::Ptr temp_viz::Mesh3d::mesh_load(const String& file)
+cv::viz::Mesh3d::Ptr cv::viz::Mesh3d::mesh_load(const String& file)
{
Mesh3d::Ptr mesh = new Mesh3d();
#include "opencv2/viz/widget_accessor.hpp"
#include <opencv2/calib3d.hpp>
-namespace temp_viz
+namespace cv
{
- template<typename _Tp> Vec<_Tp, 3>* vtkpoints_data(vtkSmartPointer<vtkPoints>& points);
-
- template<> static inline Vec3f* vtkpoints_data<float>(vtkSmartPointer<vtkPoints>& points)
+ namespace viz
{
- CV_Assert(points->GetDataType() == VTK_FLOAT);
- vtkDataArray *data = points->GetData();
- float *pointer = static_cast<vtkFloatArray*>(data)->GetPointer(0);
- return reinterpret_cast<Vec3f*>(pointer);
- }
+ template<typename _Tp> Vec<_Tp, 3>* vtkpoints_data(vtkSmartPointer<vtkPoints>& points);
- 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);
+ 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);
+ }
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// line widget implementation
-temp_viz::LineWidget::LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color)
+cv::viz::LineWidget::LineWidget(const Point3f &pt1, const Point3f &pt2, const Color &color)
{
vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New();
line->SetPoint1 (pt1.x, pt1.y, pt1.z);
setColor(color);
}
-void temp_viz::LineWidget::setLineWidth(float line_width)
+void cv::viz::LineWidget::setLineWidth(float line_width)
{
vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
actor->GetProperty()->SetLineWidth(line_width);
}
-float temp_viz::LineWidget::getLineWidth()
+float cv::viz::LineWidget::getLineWidth()
{
vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
return actor->GetProperty()->GetLineWidth();
}
-template<> temp_viz::LineWidget temp_viz::Widget::cast<temp_viz::LineWidget>()
+template<> cv::viz::LineWidget cv::viz::Widget::cast<cv::viz::LineWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<LineWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// plane widget implementation
-temp_viz::PlaneWidget::PlaneWidget(const Vec4f& coefs, double size, const Color &color)
+cv::viz::PlaneWidget::PlaneWidget(const Vec4f& coefs, double size, const Color &color)
{
vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New ();
plane->SetNormal (coefs[0], coefs[1], coefs[2]);
- double norm = cv::norm(cv::Vec3f(coefs.val));
+ double norm = cv::norm(Vec3f(coefs.val));
plane->Push (-coefs[3] / norm);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
setColor(color);
}
-temp_viz::PlaneWidget::PlaneWidget(const Vec4f& coefs, const Point3f& pt, double size, const Color &color)
+cv::viz::PlaneWidget::PlaneWidget(const Vec4f& coefs, const Point3f& pt, double size, const Color &color)
{
vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New ();
- cv::Point3f coefs3(coefs[0], coefs[1], coefs[2]);
+ Point3f coefs3(coefs[0], coefs[1], coefs[2]);
double norm_sqr = 1.0 / coefs3.dot (coefs3);
plane->SetNormal(coefs[0], coefs[1], coefs[2]);
double t = coefs3.dot(pt) + coefs[3];
- cv::Vec3f p_center = pt - coefs3 * t * norm_sqr;
+ Vec3f p_center = pt - coefs3 * t * norm_sqr;
plane->SetCenter (p_center[0], p_center[1], p_center[2]);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
setColor(color);
}
-template<> temp_viz::PlaneWidget temp_viz::Widget::cast<temp_viz::PlaneWidget>()
+template<> cv::viz::PlaneWidget cv::viz::Widget::cast<cv::viz::PlaneWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<PlaneWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// sphere widget implementation
-temp_viz::SphereWidget::SphereWidget(const cv::Point3f ¢er, float radius, int sphere_resolution, const Color &color)
+cv::viz::SphereWidget::SphereWidget(const Point3f ¢er, float radius, int sphere_resolution, const Color &color)
{
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New ();
sphere->SetRadius (radius);
setColor(color);
}
-template<> temp_viz::SphereWidget temp_viz::Widget::cast<temp_viz::SphereWidget>()
+template<> cv::viz::SphereWidget cv::viz::Widget::cast<cv::viz::SphereWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<SphereWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// arrow widget implementation
-temp_viz::ArrowWidget::ArrowWidget(const Point3f& pt1, const Point3f& pt2, const Color &color)
+cv::viz::ArrowWidget::ArrowWidget(const Point3f& pt1, const Point3f& pt2, const Color &color)
{
vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New ();
setColor(color);
}
-template<> temp_viz::ArrowWidget temp_viz::Widget::cast<temp_viz::ArrowWidget>()
+template<> cv::viz::ArrowWidget cv::viz::Widget::cast<cv::viz::ArrowWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<ArrowWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// circle widget implementation
-temp_viz::CircleWidget::CircleWidget(const temp_viz::Point3f& pt, double radius, double thickness, const temp_viz::Color& color)
+cv::viz::CircleWidget::CircleWidget(const Point3f& pt, double radius, double thickness, const Color& color)
{
vtkSmartPointer<vtkDiskSource> disk = vtkSmartPointer<vtkDiskSource>::New ();
// Maybe the resolution should be lower e.g. 50 or 25
setColor(color);
}
-template<> temp_viz::CircleWidget temp_viz::Widget::cast<temp_viz::CircleWidget>()
+template<> cv::viz::CircleWidget cv::viz::Widget::cast<cv::viz::CircleWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<CircleWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// cylinder widget implementation
-temp_viz::CylinderWidget::CylinderWidget(const Point3f& pt_on_axis, const Point3f& axis_direction, double radius, int numsides, const Color &color)
+cv::viz::CylinderWidget::CylinderWidget(const Point3f& pt_on_axis, const Point3f& axis_direction, double radius, int numsides, const Color &color)
{
- const cv::Point3f pt2 = pt_on_axis + axis_direction;
+ const 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);
line->SetPoint2 (pt2.x, pt2.y, pt2.z);
setColor(color);
}
-template<> temp_viz::CylinderWidget temp_viz::Widget::cast<temp_viz::CylinderWidget>()
+template<> cv::viz::CylinderWidget cv::viz::Widget::cast<cv::viz::CylinderWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<CylinderWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// cylinder widget implementation
-temp_viz::CubeWidget::CubeWidget(const Point3f& pt_min, const Point3f& pt_max, bool wire_frame, const Color &color)
+cv::viz::CubeWidget::CubeWidget(const Point3f& pt_min, const Point3f& pt_max, bool wire_frame, const Color &color)
{
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);
setColor(color);
}
-template<> temp_viz::CubeWidget temp_viz::Widget::cast<temp_viz::CubeWidget>()
+template<> cv::viz::CubeWidget cv::viz::Widget::cast<cv::viz::CubeWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<CubeWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// coordinate system widget implementation
-temp_viz::CoordinateSystemWidget::CoordinateSystemWidget(double scale)
+cv::viz::CoordinateSystemWidget::CoordinateSystemWidget(double scale)
{
vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New ();
axes->SetOrigin (0, 0, 0);
WidgetAccessor::setProp(*this, actor);
}
-template<> temp_viz::CoordinateSystemWidget temp_viz::Widget::cast<temp_viz::CoordinateSystemWidget>()
+template<> cv::viz::CoordinateSystemWidget cv::viz::Widget::cast<cv::viz::CoordinateSystemWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<CoordinateSystemWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// polyline widget implementation
-struct temp_viz::PolyLineWidget::CopyImpl
+struct cv::viz::PolyLineWidget::CopyImpl
{
template<typename _Tp>
static void copy(const Mat& source, Vec<_Tp, 3> *output, vtkSmartPointer<vtkPolyLine> polyLine)
}
};
-temp_viz::PolyLineWidget::PolyLineWidget(InputArray _pointData, const Color &color)
+cv::viz::PolyLineWidget::PolyLineWidget(InputArray _pointData, const Color &color)
{
Mat pointData = _pointData.getMat();
CV_Assert(pointData.type() == CV_32FC3 || pointData.type() == CV_32FC4 || pointData.type() == CV_64FC3 || pointData.type() == CV_64FC4);
setColor(color);
}
-template<> temp_viz::PolyLineWidget temp_viz::Widget::cast<temp_viz::PolyLineWidget>()
+template<> cv::viz::PolyLineWidget cv::viz::Widget::cast<cv::viz::PolyLineWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<PolyLineWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// grid widget implementation
-temp_viz::GridWidget::GridWidget(Vec2i dimensions, Vec2d spacing, const Color &color)
+cv::viz::GridWidget::GridWidget(Vec2i dimensions, Vec2d spacing, const Color &color)
{
// Create the grid using image data
vtkSmartPointer<vtkImageData> grid = vtkSmartPointer<vtkImageData>::New();
WidgetAccessor::setProp(*this, actor);
}
-template<> temp_viz::GridWidget temp_viz::Widget::cast<temp_viz::GridWidget>()
+template<> cv::viz::GridWidget cv::viz::Widget::cast<cv::viz::GridWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<GridWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// text3D widget implementation
-temp_viz::Text3DWidget::Text3DWidget(const String &text, const Point3f &position, double text_scale, const Color &color)
+cv::viz::Text3DWidget::Text3DWidget(const String &text, const Point3f &position, double text_scale, const Color &color)
{
vtkSmartPointer<vtkVectorText> textSource = vtkSmartPointer<vtkVectorText>::New ();
textSource->SetText (text.c_str());
setColor(color);
}
-void temp_viz::Text3DWidget::setText(const String &text)
+void cv::viz::Text3DWidget::setText(const String &text)
{
vtkFollower *actor = vtkFollower::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
textSource->Update();
}
-temp_viz::String temp_viz::Text3DWidget::getText() const
+cv::String cv::viz::Text3DWidget::getText() const
{
vtkFollower *actor = vtkFollower::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
return textSource->GetText();
}
-template<> temp_viz::Text3DWidget temp_viz::Widget::cast<temp_viz::Text3DWidget>()
+template<> cv::viz::Text3DWidget cv::viz::Widget::cast<cv::viz::Text3DWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<Text3DWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// text widget implementation
-temp_viz::TextWidget::TextWidget(const String &text, const Point2i &pos, int font_size, const Color &color)
+cv::viz::TextWidget::TextWidget(const String &text, const Point2i &pos, int font_size, const Color &color)
{
vtkSmartPointer<vtkTextActor> actor = vtkSmartPointer<vtkTextActor>::New();
actor->SetPosition (pos.x, pos.y);
WidgetAccessor::setProp(*this, actor);
}
-template<> temp_viz::TextWidget temp_viz::Widget::cast<temp_viz::TextWidget>()
+template<> cv::viz::TextWidget cv::viz::Widget::cast<cv::viz::TextWidget>()
{
Widget2D widget = this->cast<Widget2D>();
return static_cast<TextWidget&>(widget);
}
-void temp_viz::TextWidget::setText(const String &text)
+void cv::viz::TextWidget::setText(const String &text)
{
vtkTextActor *actor = vtkTextActor::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
actor->SetInput(text.c_str());
}
-temp_viz::String temp_viz::TextWidget::getText() const
+cv::String cv::viz::TextWidget::getText() const
{
vtkTextActor *actor = vtkTextActor::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
///////////////////////////////////////////////////////////////////////////////////////////////
/// point cloud widget implementation
-struct temp_viz::CloudWidget::CreateCloudWidget
+struct cv::viz::CloudWidget::CreateCloudWidget
{
static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points)
{
}
};
-temp_viz::CloudWidget::CloudWidget(InputArray _cloud, InputArray _colors)
+cv::viz::CloudWidget::CloudWidget(InputArray _cloud, InputArray _colors)
{
Mat cloud = _cloud.getMat();
Mat colors = _colors.getMat();
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
mapper->SetInput (polydata);
- cv::Vec3d minmax(scalars->GetRange());
+ Vec3d minmax(scalars->GetRange());
mapper->SetScalarRange(minmax.val);
mapper->SetScalarModeToUsePointData ();
WidgetAccessor::setProp(*this, actor);
}
-temp_viz::CloudWidget::CloudWidget(InputArray _cloud, const Color &color)
+cv::viz::CloudWidget::CloudWidget(InputArray _cloud, const Color &color)
{
Mat cloud = _cloud.getMat();
CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
setColor(color);
}
-template<> temp_viz::CloudWidget temp_viz::Widget::cast<temp_viz::CloudWidget>()
+template<> cv::viz::CloudWidget cv::viz::Widget::cast<cv::viz::CloudWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<CloudWidget&>(widget);
///////////////////////////////////////////////////////////////////////////////////////////////
/// cloud normals widget implementation
-struct temp_viz::CloudNormalsWidget::ApplyCloudNormals
+struct cv::viz::CloudNormalsWidget::ApplyCloudNormals
{
template<typename _Tp>
struct Impl
{
- static vtkSmartPointer<vtkCellArray> applyOrganized(const cv::Mat &cloud, const cv::Mat& normals,
- int level, float scale, _Tp *&pts, vtkIdType &nr_normals)
+ static vtkSmartPointer<vtkCellArray> applyOrganized(const Mat &cloud, const Mat& normals, double level, float scale, _Tp *&pts, vtkIdType &nr_normals)
{
- vtkIdType point_step = static_cast<vtkIdType> (sqrt (double (level)));
- nr_normals = (static_cast<vtkIdType> ((cloud.cols - 1)/ point_step) + 1) *
- (static_cast<vtkIdType> ((cloud.rows - 1) / point_step) + 1);
+ vtkIdType point_step = static_cast<vtkIdType>(std::sqrt(level));
+ nr_normals = (static_cast<vtkIdType> ((cloud.cols - 1) / point_step) + 1) *
+ (static_cast<vtkIdType> ((cloud.rows - 1) / point_step) + 1);
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
pts = new _Tp[2 * nr_normals * 3];
return lines;
}
- static vtkSmartPointer<vtkCellArray> applyUnorganized(const cv::Mat &cloud, const cv::Mat& normals,
- int level, float scale, _Tp *&pts, vtkIdType &nr_normals)
+ static vtkSmartPointer<vtkCellArray> applyUnorganized(const Mat &cloud, const Mat& normals, int level, float scale, _Tp *&pts, vtkIdType &nr_normals)
{
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
nr_normals = (cloud.size().area() - 1) / level + 1 ;
};
template<typename _Tp>
- static inline vtkSmartPointer<vtkCellArray> apply(const cv::Mat &cloud, const cv::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)
return ApplyCloudNormals::Impl<_Tp>::applyOrganized(cloud, normals, level, scale, pts, nr_normals);
}
};
-temp_viz::CloudNormalsWidget::CloudNormalsWidget(InputArray _cloud, InputArray _normals, int level, float scale, const Color &color)
+cv::viz::CloudNormalsWidget::CloudNormalsWidget(InputArray _cloud, InputArray _normals, int level, float scale, const Color &color)
{
Mat cloud = _cloud.getMat();
Mat normals = _normals.getMat();
setColor(color);
}
-template<> temp_viz::CloudNormalsWidget temp_viz::Widget::cast<temp_viz::CloudNormalsWidget>()
+template<> cv::viz::CloudNormalsWidget cv::viz::Widget::cast<cv::viz::CloudNormalsWidget>()
{
Widget3D widget = this->cast<Widget3D>();
return static_cast<CloudNormalsWidget&>(widget);
//////////////////////////////////////////////////////////////////////////////////////////////////////
/// cv::viz::Color
-temp_viz::Color::Color() : Scalar(0, 0, 0) {}
-temp_viz::Color::Color(double gray) : Scalar(gray, gray, gray) {}
-temp_viz::Color::Color(double blue, double green, double red) : Scalar(blue, green, red) {}
-temp_viz::Color::Color(const Scalar& color) : Scalar(color) {}
+cv::viz::Color::Color() : Scalar(0, 0, 0) {}
+cv::viz::Color::Color(double gray) : Scalar(gray, gray, gray) {}
+cv::viz::Color::Color(double blue, double green, double red) : Scalar(blue, green, red) {}
+cv::viz::Color::Color(const Scalar& color) : Scalar(color) {}
-temp_viz::Color temp_viz::Color::black() { return Color( 0, 0, 0); }
-temp_viz::Color temp_viz::Color::green() { return Color( 0, 255, 0); }
-temp_viz::Color temp_viz::Color::blue() { return Color(255, 0, 0); }
-temp_viz::Color temp_viz::Color::cyan() { return Color(255, 255, 0); }
+cv::viz::Color cv::viz::Color::black() { return Color( 0, 0, 0); }
+cv::viz::Color cv::viz::Color::green() { return Color( 0, 255, 0); }
+cv::viz::Color cv::viz::Color::blue() { return Color(255, 0, 0); }
+cv::viz::Color cv::viz::Color::cyan() { return Color(255, 255, 0); }
-temp_viz::Color temp_viz::Color::red() { return Color( 0, 0, 255); }
-temp_viz::Color temp_viz::Color::magenta() { return Color( 0, 255, 255); }
-temp_viz::Color temp_viz::Color::yellow() { return Color(255, 0, 255); }
-temp_viz::Color temp_viz::Color::white() { return Color(255, 255, 255); }
+cv::viz::Color cv::viz::Color::red() { return Color( 0, 0, 255); }
+cv::viz::Color cv::viz::Color::magenta() { return Color( 0, 255, 255); }
+cv::viz::Color cv::viz::Color::yellow() { return Color(255, 0, 255); }
+cv::viz::Color cv::viz::Color::white() { return Color(255, 255, 255); }
-temp_viz::Color temp_viz::Color::gray() { return Color(128, 128, 128); }
+cv::viz::Color cv::viz::Color::gray() { return Color(128, 128, 128); }
#include "precomp.hpp"
-cv::Affine3f temp_viz::makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin)
+cv::Affine3f cv::viz::makeTransformToGlobal(const Vec3f& axis_x, const Vec3f& axis_y, const Vec3f& axis_z, const Vec3f& origin)
{
Affine3f::Mat3 R;
R.val[0] = axis_x.val[0];
#include "viz3d_impl.hpp"
-temp_viz::Viz3d::Viz3d(const String& window_name) : impl_(new VizImpl(window_name))
+cv::viz::Viz3d::Viz3d(const String& window_name) : impl_(new VizImpl(window_name))
{
}
-temp_viz::Viz3d::~Viz3d()
+cv::viz::Viz3d::~Viz3d()
{
delete impl_;
}
-void temp_viz::Viz3d::setBackgroundColor(const Color& color)
+void cv::viz::Viz3d::setBackgroundColor(const Color& color)
{
impl_->setBackgroundColor(color);
}
-bool temp_viz::Viz3d::addPolygonMesh (const Mesh3d& mesh, const String& id)
+bool cv::viz::Viz3d::addPolygonMesh (const Mesh3d& mesh, const String& id)
{
return impl_->addPolygonMesh(mesh, Mat(), id);
}
-bool temp_viz::Viz3d::updatePolygonMesh (const Mesh3d& mesh, const String& id)
+bool cv::viz::Viz3d::updatePolygonMesh (const Mesh3d& mesh, const String& id)
{
return impl_->updatePolygonMesh(mesh, Mat(), id);
}
-bool temp_viz::Viz3d::addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id)
+bool cv::viz::Viz3d::addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id)
{
return impl_->addPolylineFromPolygonMesh(mesh, id);
}
-bool temp_viz::Viz3d::addPolygon(const Mat& cloud, const Color& color, const String& id)
+bool cv::viz::Viz3d::addPolygon(const Mat& cloud, const Color& color, const String& id)
{
return impl_->addPolygon(cloud, color, id);
}
-void temp_viz::Viz3d::spin()
+void cv::viz::Viz3d::spin()
{
impl_->spin();
}
-void temp_viz::Viz3d::spinOnce (int time, bool force_redraw)
+void cv::viz::Viz3d::spinOnce (int time, bool force_redraw)
{
impl_->spinOnce(time, force_redraw);
}
-void temp_viz::Viz3d::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
+void cv::viz::Viz3d::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
{
impl_->registerKeyboardCallback(callback, cookie);
}
-void temp_viz::Viz3d::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
+void cv::viz::Viz3d::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
{
impl_->registerMouseCallback(callback, cookie);
}
-bool temp_viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
+bool cv::viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
-void temp_viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
+void cv::viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
{
impl_->showWidget(id, widget, pose);
}
-void temp_viz::Viz3d::removeWidget(const String &id)
+void cv::viz::Viz3d::removeWidget(const String &id)
{
impl_->removeWidget(id);
}
-temp_viz::Widget temp_viz::Viz3d::getWidget(const String &id) const
+cv::viz::Widget cv::viz::Viz3d::getWidget(const String &id) const
{
return impl_->getWidget(id);
}
-void temp_viz::Viz3d::setWidgetPose(const String &id, const Affine3f &pose)
+void cv::viz::Viz3d::setWidgetPose(const String &id, const Affine3f &pose)
{
impl_->setWidgetPose(id, pose);
}
-void temp_viz::Viz3d::updateWidgetPose(const String &id, const Affine3f &pose)
+void cv::viz::Viz3d::updateWidgetPose(const String &id, const Affine3f &pose)
{
impl_->updateWidgetPose(id, pose);
}
-temp_viz::Affine3f temp_viz::Viz3d::getWidgetPose(const String &id) const
+cv::Affine3f cv::viz::Viz3d::getWidgetPose(const String &id) const
{
return impl_->getWidgetPose(id);
}
#include <opencv2/viz/viz3d.hpp>
-struct temp_viz::Viz3d::VizImpl
+struct cv::viz::Viz3d::VizImpl
{
public:
typedef cv::Ptr<VizImpl> Ptr;
-namespace temp_viz
+namespace cv
{
+ namespace viz
+ {
+ //void getTransformationMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternionf& orientation, Eigen::Matrix4f &transformation);
-//void getTransformationMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternionf& orientation, Eigen::Matrix4f &transformation);
-
-//void convertToVtkMatrix (const Eigen::Matrix4f &m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
-
-void convertToVtkMatrix (const cv::Matx44f& m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
-void convertToCvMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, cv::Matx44f &m);
+ //void convertToVtkMatrix (const Eigen::Matrix4f &m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
-vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f &m);
-cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix);
+ void convertToVtkMatrix (const cv::Matx44f& m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
+ void convertToCvMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, cv::Matx44f &m);
-/** \brief Convert origin and orientation to vtkMatrix4x4
- * \param[in] origin the point cloud origin
- * \param[in] orientation the point cloud orientation
- * \param[out] vtk_matrix the resultant VTK 4x4 matrix
- */
-void convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<float> &orientation, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
-void convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, Eigen::Matrix4f &m);
+ vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f &m);
+ cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix);
+ /** \brief Convert origin and orientation to vtkMatrix4x4
+ * \param[in] origin the point cloud origin
+ * \param[in] orientation the point cloud orientation
+ * \param[out] vtk_matrix the resultant VTK 4x4 matrix
+ */
+ void convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<float> &orientation, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix);
+ void convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, Eigen::Matrix4f &m);
-struct NanFilter
-{
- template<typename _Tp, typename _Msk>
- struct Impl
- {
- typedef Vec<_Tp, 3> _Out;
- static _Out* copy(const Mat& source, _Out* output, const Mat& nan_mask)
+ struct NanFilter
{
- 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();
-
- for(int y = 0; y < source.rows; ++y)
+ template<typename _Tp, typename _Msk>
+ struct Impl
{
- const _Tp* srow = source.ptr<_Tp>(y);
- const _Msk* mrow = nan_mask.ptr<_Msk>(y);
-
- for(int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs)
- if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2]))
- *output++ = _Out(srow);
- }
- return output;
- }
- };
+ typedef Vec<_Tp, 3> _Out;
+
+ static _Out* copy(const Mat& source, _Out* output, 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();
+
+ for(int y = 0; y < source.rows; ++y)
+ {
+ const _Tp* srow = source.ptr<_Tp>(y);
+ const _Msk* mrow = nan_mask.ptr<_Msk>(y);
+
+ for(int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs)
+ if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2]))
+ *output++ = _Out(srow);
+ }
+ return output;
+ }
+ };
+
+ template<typename _Tp>
+ static inline Vec<_Tp, 3>* copy(const Mat& source, Vec<_Tp, 3>* output, const Mat& nan_mask)
+ {
+ CV_Assert(nan_mask.depth() == CV_32F || nan_mask.depth() == CV_64F);
- template<typename _Tp>
- static inline Vec<_Tp, 3>* copy(const Mat& source, Vec<_Tp, 3>* output, const Mat& nan_mask)
- {
- CV_Assert(nan_mask.depth() == CV_32F || nan_mask.depth() == CV_64F);
+ typedef Vec<_Tp, 3>* (*copy_func)(const Mat&, Vec<_Tp, 3>*, const Mat&);
+ const static copy_func table[2] = { &NanFilter::Impl<_Tp, float>::copy, &NanFilter::Impl<_Tp, double>::copy };
- typedef Vec<_Tp, 3>* (*copy_func)(const Mat&, Vec<_Tp, 3>*, const Mat&);
- const static copy_func table[2] = { &NanFilter::Impl<_Tp, float>::copy, &NanFilter::Impl<_Tp, double>::copy };
+ return table[nan_mask.depth() - 5](source, output, nan_mask);
+ }
+ };
- return table[nan_mask.depth() - 5](source, output, nan_mask);
- }
-};
+ struct ApplyAffine
+ {
+ const Affine3f& affine_;
+ ApplyAffine(const Affine3f& affine) : affine_(affine) {}
-struct ApplyAffine
-{
- const Affine3f& affine_;
- ApplyAffine(const Affine3f& affine) : affine_(affine) {}
+ template<typename _Tp> Point3_<_Tp> operator()(const Point3_<_Tp>& p) const { return affine_ * p; }
- template<typename _Tp> Point3_<_Tp> operator()(const Point3_<_Tp>& p) const { return affine_ * p; }
+ template<typename _Tp> Vec<_Tp, 3> operator()(const Vec<_Tp, 3>& v) const
+ {
+ const float* m = affine_.matrix.val;
- template<typename _Tp> Vec<_Tp, 3> operator()(const Vec<_Tp, 3>& v) const
- {
- const float* m = affine_.matrix.val;
+ Vec<_Tp, 3> result;
+ result[0] = (_Tp)(m[0] * v[0] + m[1] * v[1] + m[ 2] * v[2] + m[ 3]);
+ result[1] = (_Tp)(m[4] * v[0] + m[5] * v[1] + m[ 6] * v[2] + m[ 7]);
+ result[2] = (_Tp)(m[8] * v[0] + m[9] * v[1] + m[10] * v[2] + m[11]);
+ return result;
+ }
- Vec<_Tp, 3> result;
- result[0] = (_Tp)(m[0] * v[0] + m[1] * v[1] + m[ 2] * v[2] + m[ 3]);
- result[1] = (_Tp)(m[4] * v[0] + m[5] * v[1] + m[ 6] * v[2] + m[ 7]);
- result[2] = (_Tp)(m[8] * v[0] + m[9] * v[1] + m[10] * v[2] + m[11]);
- return result;
+ private:
+ ApplyAffine(const ApplyAffine&);
+ ApplyAffine& operator=(const ApplyAffine&);
+ };
}
-private:
- ApplyAffine(const ApplyAffine&);
- ApplyAffine& operator=(const ApplyAffine&);
-};
-
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////
-temp_viz::Viz3d::VizImpl::VizImpl (const std::string &name)
- : style_ (vtkSmartPointer<temp_viz::InteractorStyle>::New ())
+cv::viz::Viz3d::VizImpl::VizImpl (const std::string &name)
+ : style_ (vtkSmartPointer<cv::viz::InteractorStyle>::New ())
, cloud_actor_map_ (new CloudActorMap)
, shape_actor_map_ (new ShapeActorMap)
, widget_actor_map_ (new WidgetActorMap)
}
/////////////////////////////////////////////////////////////////////////////////////////////
-temp_viz::Viz3d::VizImpl::~VizImpl ()
+cv::viz::Viz3d::VizImpl::~VizImpl ()
{
if (interactor_ != NULL)
interactor_->DestroyTimer (timer_id_);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::saveScreenshot (const std::string &file) { style_->saveScreenshot (file); }
+void cv::viz::Viz3d::VizImpl::saveScreenshot (const std::string &file) { style_->saveScreenshot (file); }
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
+void cv::viz::Viz3d::VizImpl::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
{
style_->registerMouseCallback(callback, cookie);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
+void cv::viz::Viz3d::VizImpl::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
{
style_->registerKeyboardCallback(callback, cookie);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::spin ()
+void cv::viz::Viz3d::VizImpl::spin ()
{
resetStoppedFlag ();
window_->Render ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::spinOnce (int time, bool force_redraw)
+void cv::viz::Viz3d::VizImpl::spinOnce (int time, bool force_redraw)
{
resetStoppedFlag ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removePointCloud (const std::string &id)
+bool cv::viz::Viz3d::VizImpl::removePointCloud (const std::string &id)
{
CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
if (am_it == cloud_actor_map_->end ())
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removeShape (const std::string &id)
+bool cv::viz::Viz3d::VizImpl::removeShape (const std::string &id)
{
// Check to see if the given ID entry exists
ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removeText3D (const std::string &id)
+bool cv::viz::Viz3d::VizImpl::removeText3D (const std::string &id)
{
// Check to see if the given ID entry exists
ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removeAllPointClouds ()
+bool cv::viz::Viz3d::VizImpl::removeAllPointClouds ()
{
// Check to see if the given ID entry exists
CloudActorMap::iterator am_it = cloud_actor_map_->begin ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removeAllShapes ()
+bool cv::viz::Viz3d::VizImpl::removeAllShapes ()
{
// Check to see if the given ID entry exists
ShapeActorMap::iterator am_it = shape_actor_map_->begin ();
//////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkLODActor> &actor)
+bool cv::viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkLODActor> &actor)
{
vtkLODActor* actor_to_remove = vtkLODActor::SafeDownCast (actor);
}
//////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkActor> &actor)
+bool cv::viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkActor> &actor)
{
vtkActor* actor_to_remove = vtkActor::SafeDownCast (actor);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkProp> &actor)
+bool cv::viz::Viz3d::VizImpl::removeActorFromRenderer (const vtkSmartPointer<vtkProp> &actor)
{
vtkProp* actor_to_remove = vtkProp::SafeDownCast(actor);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::createActorFromVTKDataSet (const vtkSmartPointer<vtkDataSet> &data, vtkSmartPointer<vtkLODActor> &actor, bool use_scalars)
+void cv::viz::Viz3d::VizImpl::createActorFromVTKDataSet (const vtkSmartPointer<vtkDataSet> &data, vtkSmartPointer<vtkLODActor> &actor, bool use_scalars)
{
if (!actor)
actor = vtkSmartPointer<vtkLODActor>::New ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setBackgroundColor (const Color& color)
+void cv::viz::Viz3d::VizImpl::setBackgroundColor (const Color& color)
{
Color c = vtkcolor(color);
renderer_->SetBackground (c.val);
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::getPointCloudRenderingProperties (int property, double &value, const std::string &id)
+bool cv::viz::Viz3d::VizImpl::getPointCloudRenderingProperties (int property, double &value, const std::string &id)
{
CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
if (am_it == cloud_actor_map_->end ())
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::setPointCloudRenderingProperties (int property, double value, const std::string &id)
+bool cv::viz::Viz3d::VizImpl::setPointCloudRenderingProperties (int property, double value, const std::string &id)
{
CloudActorMap::iterator am_it = cloud_actor_map_->find (id);
if (am_it == cloud_actor_map_->end ())
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::setPointCloudSelected (const bool selected, const std::string &id)
+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 ())
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::setShapeRenderingProperties (int property, double value, const std::string &id)
+bool cv::viz::Viz3d::VizImpl::setShapeRenderingProperties (int property, double value, const std::string &id)
{
ShapeActorMap::iterator am_it = shape_actor_map_->find (id);
if (am_it == shape_actor_map_->end ())
{
if (!actor->GetMapper ()->GetInput ()->GetPointData ()->GetNormals ())
{
- std::cout << "[temp_viz::PCLVisualizer::setShapeRenderingProperties] Normals do not exist in the dataset, but Gouraud shading was requested. Estimating normals...\n" << std::endl;
+ std::cout << "[cv::viz::PCLVisualizer::setShapeRenderingProperties] Normals do not exist in the dataset, but Gouraud shading was requested. Estimating normals...\n" << std::endl;
vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New ();
normals->SetInput (actor->GetMapper ()->GetInput ());
{
if (!actor->GetMapper ()->GetInput ()->GetPointData ()->GetNormals ())
{
- std::cout << "[temp_viz::PCLVisualizer::setShapeRenderingProperties] Normals do not exist in the dataset, but Phong shading was requested. Estimating normals...\n" << std::endl;
+ std::cout << "[cv::viz::PCLVisualizer::setShapeRenderingProperties] Normals do not exist in the dataset, but Phong shading was requested. Estimating normals...\n" << std::endl;
vtkSmartPointer<vtkPolyDataNormals> normals = vtkSmartPointer<vtkPolyDataNormals>::New ();
normals->SetInput (actor->GetMapper ()->GetInput ());
normals->Update ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::initCameraParameters ()
+void cv::viz::Viz3d::VizImpl::initCameraParameters ()
{
Camera camera_temp;
// Set default camera parameters to something meaningful
}
/////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::cameraParamsSet () const { return (camera_set_); }
+bool cv::viz::Viz3d::VizImpl::cameraParamsSet () const { return (camera_set_); }
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::updateCamera ()
+void cv::viz::Viz3d::VizImpl::updateCamera ()
{
- std::cout << "[temp_viz::PCLVisualizer::updateCamera()] This method was deprecated, just re-rendering all scenes now." << std::endl;
+ std::cout << "[cv::viz::PCLVisualizer::updateCamera()] This method was deprecated, just re-rendering all scenes now." << std::endl;
//rens_->InitTraversal ();
// Update the camera parameters
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::getCameras (temp_viz::Camera& camera)
+void cv::viz::Viz3d::VizImpl::getCameras (cv::viz::Camera& camera)
{
vtkCamera* active_camera = renderer_->GetActiveCamera ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-cv::Affine3f temp_viz::Viz3d::VizImpl::getViewerPose ()
+cv::Affine3f cv::viz::Viz3d::VizImpl::getViewerPose ()
{
vtkCamera& camera = *renderer_->GetActiveCamera ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::resetCamera ()
+void cv::viz::Viz3d::VizImpl::resetCamera ()
{
renderer_->ResetCamera ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setCameraPosition (const cv::Vec3d& pos, const cv::Vec3d& view, const cv::Vec3d& up)
+void cv::viz::Viz3d::VizImpl::setCameraPosition (const cv::Vec3d& pos, const cv::Vec3d& view, const cv::Vec3d& up)
{
vtkSmartPointer<vtkCamera> cam = renderer_->GetActiveCamera ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setCameraPosition (double pos_x, double pos_y, double pos_z, double up_x, double up_y, double up_z)
+void cv::viz::Viz3d::VizImpl::setCameraPosition (double pos_x, double pos_y, double pos_z, double up_x, double up_y, double up_z)
{
//rens_->InitTraversal ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setCameraParameters (const cv::Matx33f& intrinsics, const cv::Affine3f& extrinsics)
+void cv::viz::Viz3d::VizImpl::setCameraParameters (const cv::Matx33f& intrinsics, const cv::Affine3f& extrinsics)
{
// Position = extrinsic translation
cv::Vec3f pos_vec = extrinsics.translation();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setCameraParameters (const temp_viz::Camera &camera)
+void cv::viz::Viz3d::VizImpl::setCameraParameters (const cv::viz::Camera &camera)
{
//rens_->InitTraversal ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setCameraClipDistances (double near, double far)
+void cv::viz::Viz3d::VizImpl::setCameraClipDistances (double near, double far)
{
//rens_->InitTraversal ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setCameraFieldOfView (double fovy)
+void cv::viz::Viz3d::VizImpl::setCameraFieldOfView (double fovy)
{
//rens_->InitTraversal ();
}
/////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::resetCameraViewpoint (const std::string &id)
+void cv::viz::Viz3d::VizImpl::resetCameraViewpoint (const std::string &id)
{
vtkSmartPointer<vtkMatrix4x4> camera_pose;
static CloudActorMap::iterator it = cloud_actor_map_->find (id);
}
////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, const std::string & id)
+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 ())
}
////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::addModelFromPolyData (vtkSmartPointer<vtkPolyData> polydata, vtkSmartPointer<vtkTransform> transform, const std::string & id)
+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 ())
////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::addModelFromPLYFile (const std::string &filename, const std::string &id)
+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 ())
}
////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::addModelFromPLYFile (const std::string &filename, vtkSmartPointer<vtkTransform> transform, const std::string &id)
+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 (true);
}
-bool temp_viz::Viz3d::VizImpl::addPolylineFromPolygonMesh (const Mesh3d& mesh, const std::string &id)
+bool cv::viz::Viz3d::VizImpl::addPolylineFromPolygonMesh (const Mesh3d& mesh, const std::string &id)
{
CV_Assert(mesh.cloud.rows == 1 && mesh.cloud.type() == CV_32FC3);
///////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setRepresentationToSurfaceForAllActors ()
+void cv::viz::Viz3d::VizImpl::setRepresentationToSurfaceForAllActors ()
{
vtkActorCollection * actors = renderer_->GetActors ();
actors->InitTraversal ();
}
///////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setRepresentationToPointsForAllActors ()
+void cv::viz::Viz3d::VizImpl::setRepresentationToPointsForAllActors ()
{
vtkActorCollection * actors = renderer_->GetActors ();
actors->InitTraversal ();
}
///////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::setRepresentationToWireframeForAllActors ()
+void cv::viz::Viz3d::VizImpl::setRepresentationToWireframeForAllActors ()
{
vtkActorCollection * actors = renderer_->GetActors ();
actors->InitTraversal ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::updateCells (vtkSmartPointer<vtkIdTypeArray> &cells, vtkSmartPointer<vtkIdTypeArray> &initcells, vtkIdType nr_points)
+void cv::viz::Viz3d::VizImpl::updateCells (vtkSmartPointer<vtkIdTypeArray> &cells, vtkSmartPointer<vtkIdTypeArray> &initcells, vtkIdType nr_points)
{
// If no init cells and cells has not been initialized...
if (!cells)
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::allocVtkPolyData (vtkSmartPointer<vtkAppendPolyData> &polydata)
+void cv::viz::Viz3d::VizImpl::allocVtkPolyData (vtkSmartPointer<vtkAppendPolyData> &polydata)
{
polydata = vtkSmartPointer<vtkAppendPolyData>::New ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::allocVtkPolyData (vtkSmartPointer<vtkPolyData> &polydata)
+void cv::viz::Viz3d::VizImpl::allocVtkPolyData (vtkSmartPointer<vtkPolyData> &polydata)
{
polydata = vtkSmartPointer<vtkPolyData>::New ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::Viz3d::VizImpl::allocVtkUnstructuredGrid (vtkSmartPointer<vtkUnstructuredGrid> &polydata)
+void cv::viz::Viz3d::VizImpl::allocVtkUnstructuredGrid (vtkSmartPointer<vtkUnstructuredGrid> &polydata)
{
polydata = vtkSmartPointer<vtkUnstructuredGrid>::New ();
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<float> &orientation, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix)
+void cv::viz::convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<float> &orientation, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix)
{
// set rotation
Eigen::Matrix3f rot = orientation.toRotationMatrix ();
vtk_matrix->SetElement (3, 3, 1.0f);
}
-void temp_viz::convertToVtkMatrix (const cv::Matx44f &m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix)
+void cv::viz::convertToVtkMatrix (const Matx44f &m, vtkSmartPointer<vtkMatrix4x4> &vtk_matrix)
{
for (int i = 0; i < 4; i++)
for (int k = 0; k < 4; k++)
vtk_matrix->SetElement (i, k, m (i, k));
}
-vtkSmartPointer<vtkMatrix4x4> temp_viz::convertToVtkMatrix (const cv::Matx44f &m)
+vtkSmartPointer<vtkMatrix4x4> cv::viz::convertToVtkMatrix (const cv::Matx44f &m)
{
vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New();
for (int i = 0; i < 4; i++)
return vtk_matrix;
}
-void temp_viz::convertToCvMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, cv::Matx44f &m)
+void cv::viz::convertToCvMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, cv::Matx44f &m)
{
for (int i = 0; i < 4; i++)
for (int k = 0; k < 4; k++)
}
-cv::Matx44f temp_viz::convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
+cv::Matx44f cv::viz::convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
{
cv::Matx44f m;
for (int i = 0; i < 4; i++)
}
//////////////////////////////////////////////////////////////////////////////////////////////
-void temp_viz::convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, Eigen::Matrix4f &m)
+void cv::viz::convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, Eigen::Matrix4f &m)
{
for (int i = 0; i < 4; i++)
for (int k = 0; k < 4; k++)
}
-void temp_viz::Viz3d::VizImpl::setFullScreen (bool mode)
+void cv::viz::Viz3d::VizImpl::setFullScreen (bool mode)
{
if (window_)
window_->SetFullScreen (mode);
}
-void temp_viz::Viz3d::VizImpl::setWindowName (const std::string &name)
+void cv::viz::Viz3d::VizImpl::setWindowName (const std::string &name)
{
if (window_)
window_->SetWindowName (name.c_str ());
}
-void temp_viz::Viz3d::VizImpl::setPosition (int x, int y) { window_->SetPosition (x, y); }
-void temp_viz::Viz3d::VizImpl::setSize (int xw, int yw) { window_->SetSize (xw, yw); }
+void cv::viz::Viz3d::VizImpl::setPosition (int x, int y) { window_->SetPosition (x, y); }
+void cv::viz::Viz3d::VizImpl::setSize (int xw, int yw) { window_->SetSize (xw, yw); }
-bool temp_viz::Viz3d::VizImpl::addPolygonMesh (const Mesh3d& mesh, const Mat& mask, const std::string &id)
+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));
// std::vector<sensor_msgs::PointField> fields;
- // rgb_idx = temp_viz::getFieldIndex (*cloud, "rgb", fields);
+ // rgb_idx = cv::viz::getFieldIndex (*cloud, "rgb", fields);
// if (rgb_idx == -1)
- // rgb_idx = temp_viz::getFieldIndex (*cloud, "rgba", fields);
+ // rgb_idx = cv::viz::getFieldIndex (*cloud, "rgba", fields);
vtkSmartPointer<vtkUnsignedCharArray> colors_array;
#if 1
for(int i = 0; i < mesh.colors.cols; ++i)
colors_array->InsertNextTupleValue(&data[i*3]);
- // temp_viz::RGB rgb_data;
+ // cv::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));
+ // memcpy (&rgb_data, reinterpret_cast<const char*> (&cloud->points[i]) + fields[rgb_idx].offset, sizeof (cv::viz::RGB));
// unsigned char color[3];
// color[0] = rgb_data.r;
// color[1] = rgb_data.g;
}
-bool temp_viz::Viz3d::VizImpl::updatePolygonMesh (const Mesh3d& mesh, const cv::Mat& mask, const std::string &id)
+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));
}
////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::addArrow (const cv::Point3f &p1, const cv::Point3f &p2, const Color& color, bool display_length, const std::string &id)
+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);
return (true);
}
////////////////////////////////////////////////////////////////////////////////////////////
-bool temp_viz::Viz3d::VizImpl::addArrow (const cv::Point3f &p1, const cv::Point3f &p2, const Color& color_line, const Color& color_text, const std::string &id)
+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);
return (true);
}
-bool temp_viz::Viz3d::VizImpl::addPolygon (const cv::Mat& cloud, const Color& color, const std::string &id)
+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);
return (true);
}
-void temp_viz::Viz3d::VizImpl::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
+void cv::viz::Viz3d::VizImpl::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
{
WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
bool exists = wam_itr != widget_actor_map_->end();
(*widget_actor_map_)[id].actor = WidgetAccessor::getProp(widget);
}
-void temp_viz::Viz3d::VizImpl::removeWidget(const String &id)
+void cv::viz::Viz3d::VizImpl::removeWidget(const String &id)
{
WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
bool exists = wam_itr != widget_actor_map_->end();
widget_actor_map_->erase(wam_itr);
}
-temp_viz::Widget temp_viz::Viz3d::VizImpl::getWidget(const String &id) const
+cv::viz::Widget cv::viz::Viz3d::VizImpl::getWidget(const String &id) const
{
WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
bool exists = wam_itr != widget_actor_map_->end();
return widget;
}
-void temp_viz::Viz3d::VizImpl::setWidgetPose(const String &id, const Affine3f &pose)
+void cv::viz::Viz3d::VizImpl::setWidgetPose(const String &id, const Affine3f &pose)
{
WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
bool exists = wam_itr != widget_actor_map_->end();
actor->Modified ();
}
-void temp_viz::Viz3d::VizImpl::updateWidgetPose(const String &id, const Affine3f &pose)
+void cv::viz::Viz3d::VizImpl::updateWidgetPose(const String &id, const Affine3f &pose)
{
WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
bool exists = wam_itr != widget_actor_map_->end();
actor->Modified ();
}
-temp_viz::Affine3f temp_viz::Viz3d::VizImpl::getWidgetPose(const String &id) const
+cv::Affine3f cv::viz::Viz3d::VizImpl::getWidgetPose(const String &id) const
{
WidgetActorMap::const_iterator wam_itr = widget_actor_map_->find(id);
bool exists = wam_itr != widget_actor_map_->end();
#include "precomp.hpp"
-namespace temp_viz
+namespace cv
{
- struct CV_EXPORTS CloudActor
+ namespace viz
{
- /** \brief The actor holding the data to render. */
- vtkSmartPointer<vtkLODActor> actor;
+ struct CV_EXPORTS CloudActor
+ {
+ /** \brief The actor holding the data to render. */
+ vtkSmartPointer<vtkLODActor> actor;
- /** \brief The viewpoint transformation matrix. */
- vtkSmartPointer<vtkMatrix4x4> viewpoint_transformation_;
+ /** \brief The viewpoint transformation matrix. */
+ vtkSmartPointer<vtkMatrix4x4> viewpoint_transformation_;
- /** \brief Internal cell array. Used for optimizing updatePointCloud. */
- vtkSmartPointer<vtkIdTypeArray> cells;
- };
-
- // TODO This will be used to contain both cloud and shape actors
- struct CV_EXPORTS WidgetActor
- {
- vtkSmartPointer<vtkProp> actor;
- vtkSmartPointer<vtkMatrix4x4> viewpoint_transformation_;
- vtkSmartPointer<vtkIdTypeArray> cells;
- };
+ /** \brief Internal cell array. Used for optimizing updatePointCloud. */
+ vtkSmartPointer<vtkIdTypeArray> cells;
+ };
+
+ // TODO This will be used to contain both cloud and shape actors
+ struct CV_EXPORTS WidgetActor
+ {
+ vtkSmartPointer<vtkProp> actor;
+ vtkSmartPointer<vtkMatrix4x4> viewpoint_transformation_;
+ vtkSmartPointer<vtkIdTypeArray> cells;
+ };
- typedef std::map<std::string, CloudActor> CloudActorMap;
- typedef std::map<std::string, vtkSmartPointer<vtkProp> > ShapeActorMap;
- typedef std::map<std::string, WidgetActor> WidgetActorMap;
+ typedef std::map<std::string, CloudActor> CloudActorMap;
+ typedef std::map<std::string, vtkSmartPointer<vtkProp> > ShapeActorMap;
+ typedef std::map<std::string, WidgetActor> WidgetActorMap;
+ }
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// widget implementation
-class temp_viz::Widget::Impl
+class cv::viz::Widget::Impl
{
public:
vtkSmartPointer<vtkProp> prop;
Impl() : prop(0) {}
};
-temp_viz::Widget::Widget() : impl_(0)
+cv::viz::Widget::Widget() : impl_(0)
{
create();
}
-temp_viz::Widget::Widget(const Widget &other) : impl_(other.impl_)
+cv::viz::Widget::Widget(const Widget &other) : impl_(other.impl_)
{
if (impl_) CV_XADD(&impl_->ref_counter, 1);
}
-temp_viz::Widget& temp_viz::Widget::operator=(const Widget &other)
+cv::viz::Widget& cv::viz::Widget::operator=(const Widget &other)
{
if (this != &other)
{
return *this;
}
-temp_viz::Widget::~Widget()
+cv::viz::Widget::~Widget()
{
release();
}
-void temp_viz::Widget::create()
+void cv::viz::Widget::create()
{
if (impl_) release();
impl_ = new Impl();
impl_->ref_counter = 1;
}
-void temp_viz::Widget::release()
+void cv::viz::Widget::release()
{
if (impl_ && CV_XADD(&impl_->ref_counter, -1) == 1)
{
///////////////////////////////////////////////////////////////////////////////////////////////
/// widget accessor implementaion
-vtkSmartPointer<vtkProp> temp_viz::WidgetAccessor::getProp(const Widget& widget)
+vtkSmartPointer<vtkProp> cv::viz::WidgetAccessor::getProp(const Widget& widget)
{
return widget.impl_->prop;
}
-void temp_viz::WidgetAccessor::setProp(Widget& widget, vtkSmartPointer<vtkProp> prop)
+void cv::viz::WidgetAccessor::setProp(Widget& widget, vtkSmartPointer<vtkProp> prop)
{
widget.impl_->prop = prop;
}
///////////////////////////////////////////////////////////////////////////////////////////////
/// widget3D implementation
-struct temp_viz::Widget3D::MatrixConverter
+struct cv::viz::Widget3D::MatrixConverter
{
- static cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
+ static Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
{
- cv::Matx44f m;
+ 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)
+ static vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const Matx44f& m)
{
vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New ();
for (int i = 0; i < 4; i++)
}
};
-void temp_viz::Widget3D::setPose(const Affine3f &pose)
+void cv::viz::Widget3D::setPose(const Affine3f &pose)
{
vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
actor->Modified ();
}
-void temp_viz::Widget3D::updatePose(const Affine3f &pose)
+void cv::viz::Widget3D::updatePose(const Affine3f &pose)
{
vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
actor->Modified ();
}
-temp_viz::Affine3f temp_viz::Widget3D::getPose() const
+cv::Affine3f cv::viz::Widget3D::getPose() const
{
vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
return Affine3f(matrix_cv);
}
-void temp_viz::Widget3D::setColor(const Color &color)
+void cv::viz::Widget3D::setColor(const Color &color)
{
// Cast to actor instead of prop3d since prop3d doesn't provide getproperty
vtkActor *actor = vtkActor::SafeDownCast(WidgetAccessor::getProp(*this));
actor->Modified ();
}
-template<> temp_viz::Widget3D temp_viz::Widget::cast<temp_viz::Widget3D>()
+template<> cv::viz::Widget3D cv::viz::Widget::cast<cv::viz::Widget3D>()
{
vtkProp3D *actor = vtkProp3D::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
///////////////////////////////////////////////////////////////////////////////////////////////
/// widget2D implementation
-void temp_viz::Widget2D::setColor(const Color &color)
+void cv::viz::Widget2D::setColor(const Color &color)
{
vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
actor->Modified ();
}
-template<> temp_viz::Widget2D temp_viz::Widget::cast<temp_viz::Widget2D>()
+template<> cv::viz::Widget2D cv::viz::Widget::cast<cv::viz::Widget2D>()
{
vtkActor2D *actor = vtkActor2D::SafeDownCast(WidgetAccessor::getProp(*this));
CV_Assert(actor);
projects / profile / ivi / opencv.git / commitdiff