//! 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));
+ //! constructs camera pose from posiont, focal_point and up_vector (see gluLookAt() for more infromation
CV_EXPORTS Affine3f makeCameraPose(const Vec3f& position, const Vec3f& focal_point, const Vec3f& up_vector);
+
+ //! checks float value for Nan
+ inline bool isNan(float x)
+ {
+ unsigned int *u = reinterpret_cast<unsigned int *>(&x);
+ return ((u[0] & 0x7f800000) == 0x7f800000) && (u[0] & 0x007fffff);
+ }
+
+ //! checks double value for Nan
+ 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);
+ }
+
+ //! checks vectors for Nans
+ 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]); }
+
+ //! checks point for Nans
+ template<typename _Tp> inline bool isNan(const Point3_<_Tp>& p)
+ { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
}
}
+++ /dev/null
-#pragma once
-
-#include <string>
-#include <opencv2/viz/types.hpp>
-
-namespace cv
-{
- namespace viz
- {
- class KeyboardEvent
- {
- 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
- {
- 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 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_ = Alt;
-
- if (ctrl)
- modifiers_ |= Ctrl;
-
- if (shift)
- modifiers_ |= Shift;
-}
-
-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 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)
- key_state = KeyboardEvent::Alt;
-
- if (ctrl)
- key_state |= KeyboardEvent::Ctrl;
-
- if (shift)
- key_state |= KeyboardEvent::Shift;
-}
#pragma once
-#include <vector>
+#include <string>
#include <opencv2/core/cvdef.h>
#include <opencv2/core.hpp>
#include <opencv2/core/affine.hpp>
namespace cv
{
typedef std::string String;
-// //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
{
class CV_EXPORTS Color : public Scalar
};
- /////////////////////////////////////////////////////////////////////////////
- /// Utility functions
+ class CV_EXPORTS KeyboardEvent
+ {
+ 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_;
+ };
- inline Color vtkcolor(const Color& color)
+ class CV_EXPORTS MouseEvent
{
- Color scaled_color = color * (1.0/255.0);
- std::swap(scaled_color[0], scaled_color[2]);
- return scaled_color;
- }
+ public:
+ enum Type { MouseMove = 1, MouseButtonPress, MouseButtonRelease, MouseScrollDown, MouseScrollUp, MouseDblClick } ;
+ enum MouseButton { NoButton = 0, LeftButton, MiddleButton, RightButton, VScroll } ;
- 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); }
+ 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;
+ };
+
+ } /* namespace viz */
+} /* namespace cv */
- 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);
- }
- 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); }
- }
-}
//#error "Viz is in beta state now. Please define macro above to use it"
#endif
-#include <opencv2/core/cvdef.h>
#include <opencv2/core.hpp>
-
-
-#include <string>
#include <opencv2/viz/types.hpp>
#include <opencv2/viz/widgets.hpp>
-#include <opencv2/viz/events.hpp>
namespace cv
{
class CV_EXPORTS Viz3d
{
public:
-
typedef cv::Ptr<Viz3d> Ptr;
+ typedef void (*KeyboardCallback)(const KeyboardEvent&, void*);
+ typedef void (*MouseCallback)(const MouseEvent&, void*);
Viz3d(const String& window_name = String());
~Viz3d();
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");
-
+ //to refactor
+ bool addPolygonMesh(const Mesh3d& mesh, const String& id = "polygon");
+ bool updatePolygonMesh(const Mesh3d& mesh, const String& id = "polygon");
bool addPolylineFromPolygonMesh (const Mesh3d& mesh, const String& id = "polyline");
-
bool addPolygon(const Mat& cloud, const Color& color, const String& id = "polygon");
- void 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);
-
- bool wasStopped() const;
void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
void removeWidget(const String &id);
void setWidgetPose(const String &id, const Affine3f &pose);
void updateWidgetPose(const String &id, const Affine3f &pose);
Affine3f getWidgetPose(const String &id) const;
+
+ void spin();
+ void spinOnce(int time = 1, bool force_redraw = false);
+ bool wasStopped() const;
+
+ void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
+ void registerMouseCallback(MouseCallback callback, void* cookie = 0);
private:
Viz3d(const Viz3d&);
Viz3d& operator=(const Viz3d&);
struct VizImpl;
VizImpl* impl_;
};
- }
-}
+
+ } /* namespace viz */
+} /* namespace cv */
--- /dev/null
+#include "precomp.hpp"
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////
+/// Point Cloud Widget implementation
+
+struct cv::viz::CloudWidget::CreateCloudWidget
+{
+ static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points)
+ {
+ vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New ();
+ vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New ();
+
+ polydata->SetVerts (vertices);
+
+ vtkSmartPointer<vtkPoints> points = polydata->GetPoints();
+ vtkSmartPointer<vtkIdTypeArray> initcells;
+ nr_points = cloud.total();
+
+ if (!points)
+ {
+ points = vtkSmartPointer<vtkPoints>::New ();
+ if (cloud.depth() == CV_32F)
+ points->SetDataTypeToFloat();
+ else if (cloud.depth() == CV_64F)
+ points->SetDataTypeToDouble();
+ polydata->SetPoints (points);
+ }
+ points->SetNumberOfPoints (nr_points);
+
+ if (cloud.depth() == CV_32F)
+ {
+ // Get a pointer to the beginning of the data array
+ Vec3f *data_beg = vtkpoints_data<float>(points);
+ Vec3f *data_end = NanFilter::copy(cloud, data_beg, cloud);
+ nr_points = data_end - data_beg;
+ }
+ else if (cloud.depth() == CV_64F)
+ {
+ // Get a pointer to the beginning of the data array
+ Vec3d *data_beg = vtkpoints_data<double>(points);
+ Vec3d *data_end = NanFilter::copy(cloud, data_beg, cloud);
+ nr_points = data_end - data_beg;
+ }
+ points->SetNumberOfPoints (nr_points);
+
+ // Update cells
+ vtkSmartPointer<vtkIdTypeArray> cells = vertices->GetData ();
+ // If no init cells and cells has not been initialized...
+ if (!cells)
+ cells = vtkSmartPointer<vtkIdTypeArray>::New ();
+
+ // If we have less values then we need to recreate the array
+ if (cells->GetNumberOfTuples () < nr_points)
+ {
+ cells = vtkSmartPointer<vtkIdTypeArray>::New ();
+
+ // If init cells is given, and there's enough data in it, use it
+ if (initcells && initcells->GetNumberOfTuples () >= nr_points)
+ {
+ cells->DeepCopy (initcells);
+ cells->SetNumberOfComponents (2);
+ cells->SetNumberOfTuples (nr_points);
+ }
+ else
+ {
+ // If the number of tuples is still too small, we need to recreate the array
+ cells->SetNumberOfComponents (2);
+ cells->SetNumberOfTuples (nr_points);
+ vtkIdType *cell = cells->GetPointer (0);
+ // Fill it with 1s
+ std::fill_n (cell, nr_points * 2, 1);
+ cell++;
+ for (vtkIdType i = 0; i < nr_points; ++i, cell += 2)
+ *cell = i;
+ // Save the results in initcells
+ initcells = vtkSmartPointer<vtkIdTypeArray>::New ();
+ initcells->DeepCopy (cells);
+ }
+ }
+ else
+ {
+ // The assumption here is that the current set of cells has more data than needed
+ cells->SetNumberOfComponents (2);
+ cells->SetNumberOfTuples (nr_points);
+ }
+
+ // Set the cells and the vertices
+ vertices->SetCells (nr_points, cells);
+ return polydata;
+ }
+};
+
+cv::viz::CloudWidget::CloudWidget(InputArray _cloud, InputArray _colors)
+{
+ Mat cloud = _cloud.getMat();
+ Mat colors = _colors.getMat();
+ CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
+ CV_Assert(colors.type() == CV_8UC3 && cloud.size() == colors.size());
+
+ if (cloud.isContinuous() && colors.isContinuous())
+ {
+ cloud.reshape(cloud.channels(), 1);
+ colors.reshape(colors.channels(), 1);
+ }
+
+ vtkIdType nr_points;
+ vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
+
+ // Filter colors
+ Vec3b* colors_data = new Vec3b[nr_points];
+ NanFilter::copy(colors, colors_data, cloud);
+
+ vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
+ scalars->SetNumberOfComponents (3);
+ scalars->SetNumberOfTuples (nr_points);
+ scalars->SetArray (colors_data->val, 3 * nr_points, 0);
+
+ // Assign the colors
+ polydata->GetPointData ()->SetScalars (scalars);
+
+ vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
+ mapper->SetInput (polydata);
+
+ Vec3d minmax(scalars->GetRange());
+ mapper->SetScalarRange(minmax.val);
+ mapper->SetScalarModeToUsePointData ();
+
+ bool interpolation = (polydata && polydata->GetNumberOfCells () != polydata->GetNumberOfVerts ());
+
+ mapper->SetInterpolateScalarsBeforeMapping (interpolation);
+ mapper->ScalarVisibilityOn ();
+
+ mapper->ImmediateModeRenderingOff ();
+
+ vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
+ actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, polydata->GetNumberOfPoints () / 10)));
+ actor->GetProperty ()->SetInterpolationToFlat ();
+ actor->GetProperty ()->BackfaceCullingOn ();
+ actor->SetMapper (mapper);
+
+ WidgetAccessor::setProp(*this, actor);
+}
+
+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);
+
+
+ vtkIdType nr_points;
+ vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
+
+ vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
+ mapper->SetInput (polydata);
+
+ bool interpolation = (polydata && polydata->GetNumberOfCells () != polydata->GetNumberOfVerts ());
+
+ mapper->SetInterpolateScalarsBeforeMapping (interpolation);
+ mapper->ScalarVisibilityOff ();
+
+ mapper->ImmediateModeRenderingOff ();
+
+ vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
+ actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, polydata->GetNumberOfPoints () / 10)));
+ actor->GetProperty ()->SetInterpolationToFlat ();
+ actor->GetProperty ()->BackfaceCullingOn ();
+ actor->SetMapper (mapper);
+
+ WidgetAccessor::setProp(*this, actor);
+ setColor(color);
+}
+
+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 cv::viz::CloudNormalsWidget::ApplyCloudNormals
+{
+ template<typename _Tp>
+ struct Impl
+ {
+ 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>(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];
+
+ int cch = cloud.channels();
+ vtkIdType cell_count = 0;
+ for (vtkIdType y = 0; y < cloud.rows; y += point_step)
+ {
+ const _Tp *prow = cloud.ptr<_Tp>(y);
+ const _Tp *nrow = normals.ptr<_Tp>(y);
+ for (vtkIdType x = 0; x < cloud.cols; x += point_step * cch)
+ {
+ pts[2 * cell_count * 3 + 0] = prow[x];
+ pts[2 * cell_count * 3 + 1] = prow[x+1];
+ pts[2 * cell_count * 3 + 2] = prow[x+2];
+ pts[2 * cell_count * 3 + 3] = prow[x] + nrow[x] * scale;
+ pts[2 * cell_count * 3 + 4] = prow[x+1] + nrow[x+1] * scale;
+ pts[2 * cell_count * 3 + 5] = prow[x+2] + nrow[x+2] * scale;
+
+ lines->InsertNextCell (2);
+ lines->InsertCellPoint (2 * cell_count);
+ lines->InsertCellPoint (2 * cell_count + 1);
+ cell_count++;
+ }
+ }
+ return lines;
+ }
+
+ 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 ;
+ pts = new _Tp[2 * nr_normals * 3];
+
+ int cch = cloud.channels();
+ const _Tp *p = cloud.ptr<_Tp>();
+ const _Tp *n = normals.ptr<_Tp>();
+ for (vtkIdType i = 0, j = 0; j < nr_normals; j++, i = j * level * cch)
+ {
+
+ pts[2 * j * 3 + 0] = p[i];
+ pts[2 * j * 3 + 1] = p[i+1];
+ pts[2 * j * 3 + 2] = p[i+2];
+ pts[2 * j * 3 + 3] = p[i] + n[i] * scale;
+ pts[2 * j * 3 + 4] = p[i+1] + n[i+1] * scale;
+ pts[2 * j * 3 + 5] = p[i+2] + n[i+2] * scale;
+
+ lines->InsertNextCell (2);
+ lines->InsertCellPoint (2 * j);
+ lines->InsertCellPoint (2 * j + 1);
+ }
+ return lines;
+ }
+ };
+
+ template<typename _Tp>
+ 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);
+ else
+ return ApplyCloudNormals::Impl<_Tp>::applyUnorganized(cloud, normals, level, scale, pts, nr_normals);
+ }
+};
+
+cv::viz::CloudNormalsWidget::CloudNormalsWidget(InputArray _cloud, InputArray _normals, int level, float scale, const Color &color)
+{
+ Mat cloud = _cloud.getMat();
+ Mat normals = _normals.getMat();
+ CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
+ CV_Assert(cloud.size() == normals.size() && cloud.type() == normals.type());
+
+ vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+ vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
+ vtkIdType nr_normals = 0;
+
+ if (cloud.depth() == CV_32F)
+ {
+ points->SetDataTypeToFloat();
+
+ vtkSmartPointer<vtkFloatArray> data = vtkSmartPointer<vtkFloatArray>::New ();
+ data->SetNumberOfComponents (3);
+
+ float* pts = 0;
+ lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals);
+ data->SetArray (&pts[0], 2 * nr_normals * 3, 0);
+ points->SetData (data);
+ }
+ else
+ {
+ points->SetDataTypeToDouble();
+
+ vtkSmartPointer<vtkDoubleArray> data = vtkSmartPointer<vtkDoubleArray>::New ();
+ data->SetNumberOfComponents (3);
+
+ double* pts = 0;
+ lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals);
+ data->SetArray (&pts[0], 2 * nr_normals * 3, 0);
+ points->SetData (data);
+ }
+
+ vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
+ polyData->SetPoints (points);
+ polyData->SetLines (lines);
+
+ vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
+ mapper->SetInput (polyData);
+ mapper->SetColorModeToMapScalars();
+ mapper->SetScalarModeToUsePointData();
+
+ vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
+ actor->SetMapper(mapper);
+ WidgetAccessor::setProp(*this, actor);
+ setColor(color);
+}
+
+template<> cv::viz::CloudNormalsWidget cv::viz::Widget::cast<cv::viz::CloudNormalsWidget>()
+{
+ Widget3D widget = this->cast<Widget3D>();
+ return static_cast<CloudNormalsWidget&>(widget);
+}
#include <common.h>
#include <cstdlib>
#include <opencv2/viz/types.hpp>
+#include "viz3d_impl.hpp"
-/////////////////////////////////////////////////////////////////////////////////////////////
-
-//Eigen::Matrix4d cv::viz::vtkToEigen (vtkMatrix4x4* vtk_matrix)
-//{
-// Eigen::Matrix4d eigen_matrix = Eigen::Matrix4d::Identity ();
-// for (int i=0; i < 4; i++)
-// for (int j=0; j < 4; j++)
-// eigen_matrix (i, j) = vtk_matrix->GetElement (i, j);
-
-// return eigen_matrix;
-//}
-
///////////////////////////////////////////////////////////////////////////////////////////////
//Eigen::Vector2i cv::viz::worldToView (const Eigen::Vector4d &world_pt, const Eigen::Matrix4d &view_projection_matrix, int width, int height)
//{
" ALT + s, S : turn stereo mode on/off\n"
" ALT + f, F : switch between maximized window mode and original size\n"
"\n"
- " SHIFT + left click : select a point\n"
<< std::endl;
break;
}
}
-
-
-
namespace cv
{
namespace viz
vtkStandardNewMacro(InteractorStyle)
}
}
-
#pragma once
#include "viz_types.h"
-#include <opencv2/viz/events.hpp>
+#include <opencv2/viz/types.hpp>
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 InteractorStyle defines an unique, custom VTK based interactory style Viz applications.
+ * Besides defining the rendering style, we also create a list of custom actions
* that are triggered on different keys being pressed:
*
* - p, P : switch to a point-based representation
* - SHIFT + left click : select a point
*
* \author Radu B. Rusu
- * \ingroup visualization
*/
class InteractorStyle : public vtkInteractorStyleTrackballCamera
{
static InteractorStyle *New ();
-
InteractorStyle () {}
virtual ~InteractorStyle () {}
// this macro defines Superclass, the isA functionality and the safe downcast method
- vtkTypeMacro (InteractorStyle, vtkInteractorStyleTrackballCamera);
+ vtkTypeMacro (InteractorStyle, vtkInteractorStyleTrackballCamera)
/** \brief Initialization routine. Must be called before anything else. */
virtual void Initialize ();
- /** \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 Ptr<CloudActorMap>& actors) { actors_ = actors; }
-
- /** \brief Pass a set of renderers to the interactor style.
- * \param[in] rens the vtkRendererCollection to use
- */
void setRenderer (vtkSmartPointer<vtkRenderer>& ren) { renderer_ = ren; }
-
- /** \brief Register a callback function for mouse events
- * \param[in] ccallback function that will be registered as a callback for a mouse event
- * \param[in] cookie for passing user data to callback
- */
void registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie = 0);
-
- /** \brief Register a callback function for keyboard events
- * \param[in] callback a function that will be registered as a callback for a keyboard event
- * \param[in] cookie user data passed to the callback function
- */
void registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void * cookie = 0);
-
- /** \brief Save the current rendered image to disk, as a PNG screenshot.
- * \param[in] file the name of the PNG file
- */
void saveScreenshot (const std::string &file);
/** \brief Change the default keyboard modified from ALT to a different special key.
/** \brief Interactor style internal method. Gets called periodically if a timer is set. */
virtual void OnTimer ();
-
void zoomIn ();
void zoomOut ();
/** \brief True if we're using red-blue colors for anaglyphic stereo, false if magenta-green. */
bool stereo_anaglyph_mask_default_;
- /** \brief The keyboard modifier to use. Default: Alt. */
KeyboardModifier modifier_;
- /** \brief KeyboardEvent callback function pointer*/
void (*keyboardCallback_)(const KeyboardEvent&, void*);
- /** \brief KeyboardEvent callback user data*/
void *keyboard_callback_cookie_;
- /** \brief MouseEvent callback function pointer */
void (*mouseCallback_)(const MouseEvent&, void*);
- /** \brief MouseEvent callback user data */
void *mouse_callback_cookie_;
};
}
#include <opencv2/core.hpp>
#include <opencv2/viz.hpp>
#include "opencv2/viz/widget_accessor.hpp"
-#include <opencv2/calib3d.hpp>
namespace cv
{
// Show it as wireframe
actor->GetProperty ()->SetRepresentationToWireframe ();
WidgetAccessor::setProp(*this, actor);
+ setColor(color);
}
template<> cv::viz::GridWidget cv::viz::Widget::cast<cv::viz::GridWidget>()
CV_Assert(actor);
return actor->GetInput();
}
-
-///////////////////////////////////////////////////////////////////////////////////////////////
-/// point cloud widget implementation
-
-struct cv::viz::CloudWidget::CreateCloudWidget
-{
- static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points)
- {
- vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New ();
- vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New ();
-
- polydata->SetVerts (vertices);
-
- vtkSmartPointer<vtkPoints> points = polydata->GetPoints();
- vtkSmartPointer<vtkIdTypeArray> initcells;
- nr_points = cloud.total();
-
- if (!points)
- {
- points = vtkSmartPointer<vtkPoints>::New ();
- if (cloud.depth() == CV_32F)
- points->SetDataTypeToFloat();
- else if (cloud.depth() == CV_64F)
- points->SetDataTypeToDouble();
- polydata->SetPoints (points);
- }
- points->SetNumberOfPoints (nr_points);
-
- if (cloud.depth() == CV_32F)
- {
- // Get a pointer to the beginning of the data array
- Vec3f *data_beg = vtkpoints_data<float>(points);
- Vec3f *data_end = NanFilter::copy(cloud, data_beg, cloud);
- nr_points = data_end - data_beg;
- }
- else if (cloud.depth() == CV_64F)
- {
- // Get a pointer to the beginning of the data array
- Vec3d *data_beg = vtkpoints_data<double>(points);
- Vec3d *data_end = NanFilter::copy(cloud, data_beg, cloud);
- nr_points = data_end - data_beg;
- }
- points->SetNumberOfPoints (nr_points);
-
- // Update cells
- vtkSmartPointer<vtkIdTypeArray> cells = vertices->GetData ();
- // If no init cells and cells has not been initialized...
- if (!cells)
- cells = vtkSmartPointer<vtkIdTypeArray>::New ();
-
- // If we have less values then we need to recreate the array
- if (cells->GetNumberOfTuples () < nr_points)
- {
- cells = vtkSmartPointer<vtkIdTypeArray>::New ();
-
- // If init cells is given, and there's enough data in it, use it
- if (initcells && initcells->GetNumberOfTuples () >= nr_points)
- {
- cells->DeepCopy (initcells);
- cells->SetNumberOfComponents (2);
- cells->SetNumberOfTuples (nr_points);
- }
- else
- {
- // If the number of tuples is still too small, we need to recreate the array
- cells->SetNumberOfComponents (2);
- cells->SetNumberOfTuples (nr_points);
- vtkIdType *cell = cells->GetPointer (0);
- // Fill it with 1s
- std::fill_n (cell, nr_points * 2, 1);
- cell++;
- for (vtkIdType i = 0; i < nr_points; ++i, cell += 2)
- *cell = i;
- // Save the results in initcells
- initcells = vtkSmartPointer<vtkIdTypeArray>::New ();
- initcells->DeepCopy (cells);
- }
- }
- else
- {
- // The assumption here is that the current set of cells has more data than needed
- cells->SetNumberOfComponents (2);
- cells->SetNumberOfTuples (nr_points);
- }
-
- // Set the cells and the vertices
- vertices->SetCells (nr_points, cells);
- return polydata;
- }
-};
-
-cv::viz::CloudWidget::CloudWidget(InputArray _cloud, InputArray _colors)
-{
- Mat cloud = _cloud.getMat();
- Mat colors = _colors.getMat();
- CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
- CV_Assert(colors.type() == CV_8UC3 && cloud.size() == colors.size());
-
- if (cloud.isContinuous() && colors.isContinuous())
- {
- cloud.reshape(cloud.channels(), 1);
- colors.reshape(colors.channels(), 1);
- }
-
- vtkIdType nr_points;
- vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
-
- // Filter colors
- Vec3b* colors_data = new Vec3b[nr_points];
- NanFilter::copy(colors, colors_data, cloud);
-
- vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
- scalars->SetNumberOfComponents (3);
- scalars->SetNumberOfTuples (nr_points);
- scalars->SetArray (colors_data->val, 3 * nr_points, 0);
-
- // Assign the colors
- polydata->GetPointData ()->SetScalars (scalars);
-
- vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
- mapper->SetInput (polydata);
-
- Vec3d minmax(scalars->GetRange());
- mapper->SetScalarRange(minmax.val);
- mapper->SetScalarModeToUsePointData ();
-
- bool interpolation = (polydata && polydata->GetNumberOfCells () != polydata->GetNumberOfVerts ());
-
- mapper->SetInterpolateScalarsBeforeMapping (interpolation);
- mapper->ScalarVisibilityOn ();
-
- mapper->ImmediateModeRenderingOff ();
-
- vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
- actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, polydata->GetNumberOfPoints () / 10)));
- actor->GetProperty ()->SetInterpolationToFlat ();
- actor->GetProperty ()->BackfaceCullingOn ();
- actor->SetMapper (mapper);
-
- WidgetAccessor::setProp(*this, actor);
-}
-
-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);
-
-
- vtkIdType nr_points;
- vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
-
- vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
- mapper->SetInput (polydata);
-
- bool interpolation = (polydata && polydata->GetNumberOfCells () != polydata->GetNumberOfVerts ());
-
- mapper->SetInterpolateScalarsBeforeMapping (interpolation);
- mapper->ScalarVisibilityOff ();
-
- mapper->ImmediateModeRenderingOff ();
-
- vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
- actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, polydata->GetNumberOfPoints () / 10)));
- actor->GetProperty ()->SetInterpolationToFlat ();
- actor->GetProperty ()->BackfaceCullingOn ();
- actor->SetMapper (mapper);
-
- WidgetAccessor::setProp(*this, actor);
- setColor(color);
-}
-
-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 cv::viz::CloudNormalsWidget::ApplyCloudNormals
-{
- template<typename _Tp>
- struct Impl
- {
- 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>(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];
-
- int cch = cloud.channels();
- vtkIdType cell_count = 0;
- for (vtkIdType y = 0; y < cloud.rows; y += point_step)
- {
- const _Tp *prow = cloud.ptr<_Tp>(y);
- const _Tp *nrow = normals.ptr<_Tp>(y);
- for (vtkIdType x = 0; x < cloud.cols; x += point_step * cch)
- {
- pts[2 * cell_count * 3 + 0] = prow[x];
- pts[2 * cell_count * 3 + 1] = prow[x+1];
- pts[2 * cell_count * 3 + 2] = prow[x+2];
- pts[2 * cell_count * 3 + 3] = prow[x] + nrow[x] * scale;
- pts[2 * cell_count * 3 + 4] = prow[x+1] + nrow[x+1] * scale;
- pts[2 * cell_count * 3 + 5] = prow[x+2] + nrow[x+2] * scale;
-
- lines->InsertNextCell (2);
- lines->InsertCellPoint (2 * cell_count);
- lines->InsertCellPoint (2 * cell_count + 1);
- cell_count++;
- }
- }
- return lines;
- }
-
- 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 ;
- pts = new _Tp[2 * nr_normals * 3];
-
- int cch = cloud.channels();
- const _Tp *p = cloud.ptr<_Tp>();
- const _Tp *n = normals.ptr<_Tp>();
- for (vtkIdType i = 0, j = 0; j < nr_normals; j++, i = j * level * cch)
- {
-
- pts[2 * j * 3 + 0] = p[i];
- pts[2 * j * 3 + 1] = p[i+1];
- pts[2 * j * 3 + 2] = p[i+2];
- pts[2 * j * 3 + 3] = p[i] + n[i] * scale;
- pts[2 * j * 3 + 4] = p[i+1] + n[i+1] * scale;
- pts[2 * j * 3 + 5] = p[i+2] + n[i+2] * scale;
-
- lines->InsertNextCell (2);
- lines->InsertCellPoint (2 * j);
- lines->InsertCellPoint (2 * j + 1);
- }
- return lines;
- }
- };
-
- template<typename _Tp>
- 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);
- else
- return ApplyCloudNormals::Impl<_Tp>::applyUnorganized(cloud, normals, level, scale, pts, nr_normals);
- }
-};
-
-cv::viz::CloudNormalsWidget::CloudNormalsWidget(InputArray _cloud, InputArray _normals, int level, float scale, const Color &color)
-{
- Mat cloud = _cloud.getMat();
- Mat normals = _normals.getMat();
- CV_Assert(cloud.type() == CV_32FC3 || cloud.type() == CV_64FC3 || cloud.type() == CV_32FC4 || cloud.type() == CV_64FC4);
- CV_Assert(cloud.size() == normals.size() && cloud.type() == normals.type());
-
- vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
- vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
- vtkIdType nr_normals = 0;
-
- if (cloud.depth() == CV_32F)
- {
- points->SetDataTypeToFloat();
-
- vtkSmartPointer<vtkFloatArray> data = vtkSmartPointer<vtkFloatArray>::New ();
- data->SetNumberOfComponents (3);
-
- float* pts = 0;
- lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals);
- data->SetArray (&pts[0], 2 * nr_normals * 3, 0);
- points->SetData (data);
- }
- else
- {
- points->SetDataTypeToDouble();
-
- vtkSmartPointer<vtkDoubleArray> data = vtkSmartPointer<vtkDoubleArray>::New ();
- data->SetNumberOfComponents (3);
-
- double* pts = 0;
- lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals);
- data->SetArray (&pts[0], 2 * nr_normals * 3, 0);
- points->SetData (data);
- }
-
- vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
- polyData->SetPoints (points);
- polyData->SetLines (lines);
-
- vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New ();
- mapper->SetInput (polyData);
- mapper->SetColorModeToMapScalars();
- mapper->SetScalarModeToUsePointData();
-
- vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
- actor->SetMapper(mapper);
- WidgetAccessor::setProp(*this, actor);
- setColor(color);
-}
-
-template<> cv::viz::CloudNormalsWidget cv::viz::Widget::cast<cv::viz::CloudNormalsWidget>()
-{
- Widget3D widget = this->cast<Widget3D>();
- return static_cast<CloudNormalsWidget&>(widget);
-}
-
-
cv::viz::Color cv::viz::Color::gray() { return Color(128, 128, 128); }
+////////////////////////////////////////////////////////////////////
+/// cv::viz::KeyboardEvent
+
+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_ = Alt;
+
+ if (ctrl)
+ modifiers_ |= Ctrl;
+
+ if (shift)
+ modifiers_ |= Shift;
+}
+
+bool cv::viz::KeyboardEvent::isAltPressed () const { return (modifiers_ & Alt) != 0; }
+bool cv::viz::KeyboardEvent::isCtrlPressed () const { return (modifiers_ & Ctrl) != 0; }
+bool cv::viz::KeyboardEvent::isShiftPressed () const { return (modifiers_ & Shift) != 0; }
+unsigned char cv::viz::KeyboardEvent::getKeyCode () const { return key_code_; }
+const cv::String& cv::viz::KeyboardEvent::getKeySym () const { return key_sym_; }
+bool cv::viz::KeyboardEvent::keyDown () const { return action_; }
+bool cv::viz::KeyboardEvent::keyUp () const { return !action_; }
+
+////////////////////////////////////////////////////////////////////
+/// cv::viz::MouseEvent
+
+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)
+ key_state = KeyboardEvent::Alt;
+
+ if (ctrl)
+ key_state |= KeyboardEvent::Ctrl;
+
+ if (shift)
+ key_state |= KeyboardEvent::Shift;
+}
#include "viz3d_impl.hpp"
-cv::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)) {}
+cv::viz::Viz3d::~Viz3d() { delete impl_; }
-cv::viz::Viz3d::~Viz3d()
-{
- delete impl_;
-}
-
-void cv::viz::Viz3d::setBackgroundColor(const Color& color)
-{
- impl_->setBackgroundColor(color);
-}
+void cv::viz::Viz3d::setBackgroundColor(const Color& color) { impl_->setBackgroundColor(color); }
bool cv::viz::Viz3d::addPolygonMesh (const Mesh3d& mesh, const String& id)
{
return impl_->addPolygon(cloud, color, id);
}
-void cv::viz::Viz3d::spin()
-{
- impl_->spin();
-}
-
-void cv::viz::Viz3d::spinOnce (int time, bool force_redraw)
-{
- impl_->spinOnce(time, force_redraw);
-}
-
-void cv::viz::Viz3d::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
-{
- impl_->registerKeyboardCallback(callback, cookie);
-}
-
-void cv::viz::Viz3d::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
-{
- impl_->registerMouseCallback(callback, cookie);
-}
-
+void cv::viz::Viz3d::spin() { impl_->spin(); }
+void cv::viz::Viz3d::spinOnce (int time, bool force_redraw) { impl_->spinOnce(time, force_redraw); }
bool cv::viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
-void cv::viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose)
-{
- impl_->showWidget(id, widget, pose);
-}
-
-void cv::viz::Viz3d::removeWidget(const String &id)
-{
- impl_->removeWidget(id);
-}
+void cv::viz::Viz3d::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
+{ impl_->registerKeyboardCallback(callback, cookie); }
-cv::viz::Widget cv::viz::Viz3d::getWidget(const String &id) const
-{
- return impl_->getWidget(id);
-}
+void cv::viz::Viz3d::registerMouseCallback(MouseCallback callback, void* cookie)
+{ impl_->registerMouseCallback(callback, cookie); }
-void cv::viz::Viz3d::setWidgetPose(const String &id, const Affine3f &pose)
-{
- impl_->setWidgetPose(id, pose);
-}
-void cv::viz::Viz3d::updateWidgetPose(const String &id, const Affine3f &pose)
-{
- impl_->updateWidgetPose(id, pose);
-}
-cv::Affine3f cv::viz::Viz3d::getWidgetPose(const String &id) const
-{
- return impl_->getWidgetPose(id);
-}
+void cv::viz::Viz3d::showWidget(const String &id, const Widget &widget, const Affine3f &pose) { impl_->showWidget(id, widget, pose); }
+void cv::viz::Viz3d::removeWidget(const String &id) { impl_->removeWidget(id); }
+cv::viz::Widget cv::viz::Viz3d::getWidget(const String &id) const { return impl_->getWidget(id); }
+void cv::viz::Viz3d::setWidgetPose(const String &id, const Affine3f &pose) { impl_->setWidgetPose(id, pose); }
+void cv::viz::Viz3d::updateWidgetPose(const String &id, const Affine3f &pose) { impl_->updateWidgetPose(id, pose); }
+cv::Affine3f cv::viz::Viz3d::getWidgetPose(const String &id) const { return impl_->getWidgetPose(id); }
#include "precomp.hpp"
-
-#include <opencv2/calib3d.hpp>
#include "viz3d_impl.hpp"
#include <vtkRenderWindowInteractor.h>
void cv::viz::Viz3d::VizImpl::saveScreenshot (const std::string &file) { style_->saveScreenshot (file); }
/////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie)
-{
- style_->registerMouseCallback(callback, cookie);
-}
+void cv::viz::Viz3d::VizImpl::registerMouseCallback(MouseCallback callback, void* cookie)
+{ style_->registerMouseCallback(callback, cookie); }
-/////////////////////////////////////////////////////////////////////////////////////////////
-void cv::viz::Viz3d::VizImpl::registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie)
-{
- style_->registerKeyboardCallback(callback, cookie);
-}
+void cv::viz::Viz3d::VizImpl::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
+{ style_->registerKeyboardCallback(callback, cookie); }
/////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::spin ()
vtk_matrix->SetElement (3, 3, 1.0f);
}
-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> cv::viz::convertToVtkMatrix (const cv::Matx44f &m)
{
vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New();
return vtk_matrix;
}
-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++)
- m(i,k) = vtk_matrix->GetElement (i, k);
-}
-
-
cv::Matx44f cv::viz::convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix)
{
cv::Matx44f 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++)
- m (i,k) = static_cast<float> (vtk_matrix->GetElement (i, k));
-}
-
void cv::viz::Viz3d::VizImpl::setFullScreen (bool mode)
{
#pragma once
-#include <opencv2/core.hpp>
-#include <opencv2/viz/events.hpp>
+#include <opencv2/viz.hpp>
#include "interactor_style.h"
#include "viz_types.h"
#include "common.h"
-#include <opencv2/viz/types.hpp>
-#include <opencv2/core/affine.hpp>
-#include <opencv2/viz/viz3d.hpp>
-
struct cv::viz::Viz3d::VizImpl
{
public:
typedef cv::Ptr<VizImpl> Ptr;
+ typedef Viz3d::KeyboardCallback KeyboardCallback;
+ typedef Viz3d::MouseCallback MouseCallback;
- VizImpl (const String &name = String());
+ VizImpl (const String &name);
virtual ~VizImpl ();
void setFullScreen (bool mode);
void setWindowName (const String &name);
- void registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void* cookie = 0);
- void registerMouseCallback(void (*callback)(const MouseEvent&, void*), void* cookie = 0);
+ void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
+ void registerMouseCallback(MouseCallback callback, void* cookie = 0);
void spin ();
void spinOnce (int time = 1, bool force_redraw = false);
void setWidgetPose(const String &id, const Affine3f &pose);
void updateWidgetPose(const String &id, const Affine3f &pose);
- Affine3f getWidgetPose(const String &id) const;
-
- void all_data();
+ Affine3f getWidgetPose(const String &id) const;
private:
vtkSmartPointer<vtkRenderWindowInteractor> interactor_;
namespace viz
{
//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);
-
vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f &m);
cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix);
* \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
{
ApplyAffine(const ApplyAffine&);
ApplyAffine& operator=(const ApplyAffine&);
};
+
+
+ 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); }
}
}
projects / platform / upstream / opencv.git / commitdiff