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

add license headers

Browse Source
This commit is contained in:
Ozan Tonkal 2013-09-08 15:20:02 +02:00
parent c773061457
commit 26005a19bd
18 changed files with 1523 additions and 729 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
modules/viz/include/opencv2/viz.hpp
View File

@ -38,7 +38,7 @@
// the use of this software, even if advised of the possibility of such damage. // the use of this software, even if advised of the possibility of such damage.
// //
// Authors: // Authors:
// * Ozan Tonkal // * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com // * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
// //
// OpenCV Viz module is complete rewrite of // OpenCV Viz module is complete rewrite of
@ -49,12 +49,10 @@
#ifndef __OPENCV_VIZ_HPP__ #ifndef __OPENCV_VIZ_HPP__
#define __OPENCV_VIZ_HPP__ #define __OPENCV_VIZ_HPP__
#include <opencv2/viz/types.hpp> #include <opencv2/viz/types.hpp>
#include <opencv2/viz/widgets.hpp> #include <opencv2/viz/widgets.hpp>
#include <opencv2/viz/viz3d.hpp> #include <opencv2/viz/viz3d.hpp>
namespace cv namespace cv
{ {
namespace viz namespace viz
@ -121,6 +119,4 @@ namespace cv
} /* namespace viz */ } /* namespace viz */
} /* namespace cv */ } /* namespace cv */
#endif /* __OPENCV_VIZ_HPP__ */ #endif /* __OPENCV_VIZ_HPP__ */

71
modules/viz/include/opencv2/viz/types.hpp
View File

@ -1,4 +1,53 @@
#pragma once /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifndef __OPENCV_VIZ_TYPES_HPP__
#define __OPENCV_VIZ_TYPES_HPP__
#include <string> #include <string>
#include <opencv2/core.hpp> #include <opencv2/core.hpp>
@ -55,17 +104,17 @@ namespace cv
//! Create a keyboard event //! Create a keyboard event
//! - Note that action is true if key is pressed, false if released //! - Note that action is true if key is pressed, false if released
KeyboardEvent (bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift); KeyboardEvent(bool action, const std::string& key_sym, unsigned char key, bool alt, bool ctrl, bool shift);
bool isAltPressed () const; bool isAltPressed() const;
bool isCtrlPressed () const; bool isCtrlPressed() const;
bool isShiftPressed () const; bool isShiftPressed() const;
unsigned char getKeyCode () const; unsigned char getKeyCode() const;
const String& getKeySym () const; const String& getKeySym() const;
bool keyDown () const; bool keyDown() const;
bool keyUp () const; bool keyUp() const;
protected: protected:
@ -81,7 +130,7 @@ namespace cv
enum Type { MouseMove = 1, MouseButtonPress, MouseButtonRelease, MouseScrollDown, MouseScrollUp, MouseDblClick } ; enum Type { MouseMove = 1, MouseButtonPress, MouseButtonRelease, MouseScrollDown, MouseScrollUp, MouseDblClick } ;
enum MouseButton { NoButton = 0, LeftButton, MiddleButton, RightButton, VScroll } ; enum MouseButton { NoButton = 0, LeftButton, MiddleButton, RightButton, VScroll } ;
MouseEvent (const Type& type, const MouseButton& button, const Point& p, bool alt, bool ctrl, bool shift); MouseEvent(const Type& type, const MouseButton& button, const Point& p, bool alt, bool ctrl, bool shift);
Type type; Type type;
MouseButton button; MouseButton button;
@ -125,3 +174,5 @@ namespace cv
} /* namespace viz */ } /* namespace viz */
} /* namespace cv */ } /* namespace cv */
#endif

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

@ -1,4 +1,53 @@
#pragma once /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifndef __OPENCV_VIZ_VIZ3D_HPP__
#define __OPENCV_VIZ_VIZ3D_HPP__
#if !defined YES_I_AGREE_THAT_VIZ_API_IS_NOT_STABLE_NOW_AND_BINARY_COMPARTIBILITY_WONT_BE_SUPPORTED #if !defined YES_I_AGREE_THAT_VIZ_API_IS_NOT_STABLE_NOW_AND_BINARY_COMPARTIBILITY_WONT_BE_SUPPORTED
//#error "Viz is in beta state now. Please define macro above to use it" //#error "Viz is in beta state now. Please define macro above to use it"
@ -38,7 +87,7 @@ namespace cv
Affine3f getViewerPose(); Affine3f getViewerPose();
void setViewerPose(const Affine3f &pose); void setViewerPose(const Affine3f &pose);
void resetCameraViewpoint (const String &id); void resetCameraViewpoint(const String &id);
void resetCamera(); void resetCamera();
void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord); void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord);
@ -47,9 +96,9 @@ namespace cv
Size getWindowSize() const; Size getWindowSize() const;
void setWindowSize(const Size &window_size); void setWindowSize(const Size &window_size);
String getWindowName() const; String getWindowName() const;
void saveScreenshot (const String &file); void saveScreenshot(const String &file);
void setWindowPosition (int x, int y); void setWindowPosition(int x, int y);
void setFullScreen (bool mode); void setFullScreen(bool mode);
void setBackgroundColor(const Color& color = Color::black()); void setBackgroundColor(const Color& color = Color::black());
void spin(); void spin();
@ -78,5 +127,4 @@ namespace cv
} /* namespace viz */ } /* namespace viz */
} /* namespace cv */ } /* namespace cv */
#endif

53
modules/viz/include/opencv2/viz/widget_accessor.hpp
View File

@ -1,4 +1,53 @@
#pragma once /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifndef __OPENCV_VIZ_WIDGET_ACCESSOR_HPP__
#define __OPENCV_VIZ_WIDGET_ACCESSOR_HPP__
#include <opencv2/core/cvdef.h> #include <opencv2/core/cvdef.h>
#include <vtkSmartPointer.h> #include <vtkSmartPointer.h>
@ -19,3 +68,5 @@ namespace cv
}; };
} }
} }
#endif

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

@ -1,4 +1,53 @@
#pragma once /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifndef __OPENCV_VIZ_WIDGETS_HPP__
#define __OPENCV_VIZ_WIDGETS_HPP__
#include <opencv2/viz/types.hpp> #include <opencv2/viz/types.hpp>
@ -306,3 +355,5 @@ namespace cv
} /* namespace viz */ } /* namespace viz */
} /* namespace cv */ } /* namespace cv */
#endif

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

@ -1,3 +1,51 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp" #include "precomp.hpp"
namespace cv namespace cv
@ -15,10 +63,10 @@ struct cv::viz::CloudWidget::CreateCloudWidget
{ {
static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points) static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points)
{ {
vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New (); vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New (); vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New();
polydata->SetVerts (vertices); polydata->SetVerts(vertices);
vtkSmartPointer<vtkPoints> points = polydata->GetPoints(); vtkSmartPointer<vtkPoints> points = polydata->GetPoints();
vtkSmartPointer<vtkIdTypeArray> initcells; vtkSmartPointer<vtkIdTypeArray> initcells;
@ -26,14 +74,14 @@ struct cv::viz::CloudWidget::CreateCloudWidget
if (!points) if (!points)
{ {
points = vtkSmartPointer<vtkPoints>::New (); points = vtkSmartPointer<vtkPoints>::New();
if (cloud.depth() == CV_32F) if (cloud.depth() == CV_32F)
points->SetDataTypeToFloat(); points->SetDataTypeToFloat();
else if (cloud.depth() == CV_64F) else if (cloud.depth() == CV_64F)
points->SetDataTypeToDouble(); points->SetDataTypeToDouble();
polydata->SetPoints (points); polydata->SetPoints(points);
} }
points->SetNumberOfPoints (nr_points); points->SetNumberOfPoints(nr_points);
if (cloud.depth() == CV_32F) if (cloud.depth() == CV_32F)
{ {
@ -49,51 +97,51 @@ struct cv::viz::CloudWidget::CreateCloudWidget
Vec3d *data_end = NanFilter::copy(cloud, data_beg, cloud); Vec3d *data_end = NanFilter::copy(cloud, data_beg, cloud);
nr_points = data_end - data_beg; nr_points = data_end - data_beg;
} }
points->SetNumberOfPoints (nr_points); points->SetNumberOfPoints(nr_points);
// Update cells // Update cells
vtkSmartPointer<vtkIdTypeArray> cells = vertices->GetData (); vtkSmartPointer<vtkIdTypeArray> cells = vertices->GetData();
// If no init cells and cells has not been initialized... // If no init cells and cells has not been initialized...
if (!cells) if (!cells)
cells = vtkSmartPointer<vtkIdTypeArray>::New (); cells = vtkSmartPointer<vtkIdTypeArray>::New();
// If we have less values then we need to recreate the array // If we have less values then we need to recreate the array
if (cells->GetNumberOfTuples () < nr_points) if (cells->GetNumberOfTuples() < nr_points)
{ {
cells = vtkSmartPointer<vtkIdTypeArray>::New (); cells = vtkSmartPointer<vtkIdTypeArray>::New();
// If init cells is given, and there's enough data in it, use it // If init cells is given, and there's enough data in it, use it
if (initcells && initcells->GetNumberOfTuples () >= nr_points) if (initcells && initcells->GetNumberOfTuples() >= nr_points)
{ {
cells->DeepCopy (initcells); cells->DeepCopy(initcells);
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
} }
else else
{ {
// If the number of tuples is still too small, we need to recreate the array // If the number of tuples is still too small, we need to recreate the array
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
vtkIdType *cell = cells->GetPointer (0); vtkIdType *cell = cells->GetPointer(0);
// Fill it with 1s // Fill it with 1s
std::fill_n (cell, nr_points * 2, 1); std::fill_n(cell, nr_points * 2, 1);
cell++; cell++;
for (vtkIdType i = 0; i < nr_points; ++i, cell += 2) for (vtkIdType i = 0; i < nr_points; ++i, cell += 2)
*cell = i; *cell = i;
// Save the results in initcells // Save the results in initcells
initcells = vtkSmartPointer<vtkIdTypeArray>::New (); initcells = vtkSmartPointer<vtkIdTypeArray>::New();
initcells->DeepCopy (cells); initcells->DeepCopy(cells);
} }
} }
else else
{ {
// The assumption here is that the current set of cells has more data than needed // The assumption here is that the current set of cells has more data than needed
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
} }
// Set the cells and the vertices // Set the cells and the vertices
vertices->SetCells (nr_points, cells); vertices->SetCells(nr_points, cells);
return polydata; return polydata;
} }
}; };
@ -118,33 +166,33 @@ cv::viz::CloudWidget::CloudWidget(InputArray _cloud, InputArray _colors)
Vec3b* colors_data = new Vec3b[nr_points]; Vec3b* colors_data = new Vec3b[nr_points];
NanFilter::copyColor(colors, colors_data, cloud); NanFilter::copyColor(colors, colors_data, cloud);
vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New (); vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetNumberOfComponents (3); scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples (nr_points); scalars->SetNumberOfTuples(nr_points);
scalars->SetArray (colors_data->val, 3 * nr_points, 0); scalars->SetArray(colors_data->val, 3 * nr_points, 0);
// Assign the colors // Assign the colors
polydata->GetPointData ()->SetScalars (scalars); polydata->GetPointData()->SetScalars(scalars);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput (polydata); mapper->SetInput(polydata);
Vec3d minmax(scalars->GetRange()); Vec3d minmax(scalars->GetRange());
mapper->SetScalarRange(minmax.val); mapper->SetScalarRange(minmax.val);
mapper->SetScalarModeToUsePointData (); mapper->SetScalarModeToUsePointData();
bool interpolation = (polydata && polydata->GetNumberOfCells () != polydata->GetNumberOfVerts ()); bool interpolation = (polydata && polydata->GetNumberOfCells() != polydata->GetNumberOfVerts());
mapper->SetInterpolateScalarsBeforeMapping (interpolation); mapper->SetInterpolateScalarsBeforeMapping(interpolation);
mapper->ScalarVisibilityOn (); mapper->ScalarVisibilityOn();
mapper->ImmediateModeRenderingOff (); mapper->ImmediateModeRenderingOff();
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, polydata->GetNumberOfPoints () / 10))); actor->SetNumberOfCloudPoints(int(std::max<vtkIdType>(1, polydata->GetNumberOfPoints() / 10)));
actor->GetProperty ()->SetInterpolationToFlat (); actor->GetProperty()->SetInterpolationToFlat();
actor->GetProperty ()->BackfaceCullingOn (); actor->GetProperty()->BackfaceCullingOn();
actor->SetMapper (mapper); actor->SetMapper(mapper);
WidgetAccessor::setProp(*this, actor); WidgetAccessor::setProp(*this, actor);
} }
@ -157,21 +205,21 @@ cv::viz::CloudWidget::CloudWidget(InputArray _cloud, const Color &color)
vtkIdType nr_points; vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points); vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput (polydata); mapper->SetInput(polydata);
bool interpolation = (polydata && polydata->GetNumberOfCells () != polydata->GetNumberOfVerts ()); bool interpolation = (polydata && polydata->GetNumberOfCells() != polydata->GetNumberOfVerts());
mapper->SetInterpolateScalarsBeforeMapping (interpolation); mapper->SetInterpolateScalarsBeforeMapping(interpolation);
mapper->ScalarVisibilityOff (); mapper->ScalarVisibilityOff();
mapper->ImmediateModeRenderingOff (); mapper->ImmediateModeRenderingOff();
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, polydata->GetNumberOfPoints () / 10))); actor->SetNumberOfCloudPoints(int(std::max<vtkIdType>(1, polydata->GetNumberOfPoints() / 10)));
actor->GetProperty ()->SetInterpolationToFlat (); actor->GetProperty()->SetInterpolationToFlat();
actor->GetProperty ()->BackfaceCullingOn (); actor->GetProperty()->BackfaceCullingOn();
actor->SetMapper (mapper); actor->SetMapper(mapper);
WidgetAccessor::setProp(*this, actor); WidgetAccessor::setProp(*this, actor);
setColor(color); setColor(color);
@ -190,10 +238,10 @@ struct cv::viz::CloudCollectionWidget::CreateCloudWidget
{ {
static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points) static inline vtkSmartPointer<vtkPolyData> create(const Mat &cloud, vtkIdType &nr_points)
{ {
vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New (); vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New (); vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New();
polydata->SetVerts (vertices); polydata->SetVerts(vertices);
vtkSmartPointer<vtkPoints> points = polydata->GetPoints(); vtkSmartPointer<vtkPoints> points = polydata->GetPoints();
vtkSmartPointer<vtkIdTypeArray> initcells; vtkSmartPointer<vtkIdTypeArray> initcells;
@ -201,14 +249,14 @@ struct cv::viz::CloudCollectionWidget::CreateCloudWidget
if (!points) if (!points)
{ {
points = vtkSmartPointer<vtkPoints>::New (); points = vtkSmartPointer<vtkPoints>::New();
if (cloud.depth() == CV_32F) if (cloud.depth() == CV_32F)
points->SetDataTypeToFloat(); points->SetDataTypeToFloat();
else if (cloud.depth() == CV_64F) else if (cloud.depth() == CV_64F)
points->SetDataTypeToDouble(); points->SetDataTypeToDouble();
polydata->SetPoints (points); polydata->SetPoints(points);
} }
points->SetNumberOfPoints (nr_points); points->SetNumberOfPoints(nr_points);
if (cloud.depth() == CV_32F) if (cloud.depth() == CV_32F)
{ {
@ -224,51 +272,51 @@ struct cv::viz::CloudCollectionWidget::CreateCloudWidget
Vec3d *data_end = NanFilter::copy(cloud, data_beg, cloud); Vec3d *data_end = NanFilter::copy(cloud, data_beg, cloud);
nr_points = data_end - data_beg; nr_points = data_end - data_beg;
} }
points->SetNumberOfPoints (nr_points); points->SetNumberOfPoints(nr_points);
// Update cells // Update cells
vtkSmartPointer<vtkIdTypeArray> cells = vertices->GetData (); vtkSmartPointer<vtkIdTypeArray> cells = vertices->GetData();
// If no init cells and cells has not been initialized... // If no init cells and cells has not been initialized...
if (!cells) if (!cells)
cells = vtkSmartPointer<vtkIdTypeArray>::New (); cells = vtkSmartPointer<vtkIdTypeArray>::New();
// If we have less values then we need to recreate the array // If we have less values then we need to recreate the array
if (cells->GetNumberOfTuples () < nr_points) if (cells->GetNumberOfTuples() < nr_points)
{ {
cells = vtkSmartPointer<vtkIdTypeArray>::New (); cells = vtkSmartPointer<vtkIdTypeArray>::New();
// If init cells is given, and there's enough data in it, use it // If init cells is given, and there's enough data in it, use it
if (initcells && initcells->GetNumberOfTuples () >= nr_points) if (initcells && initcells->GetNumberOfTuples() >= nr_points)
{ {
cells->DeepCopy (initcells); cells->DeepCopy(initcells);
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
} }
else else
{ {
// If the number of tuples is still too small, we need to recreate the array // If the number of tuples is still too small, we need to recreate the array
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
vtkIdType *cell = cells->GetPointer (0); vtkIdType *cell = cells->GetPointer(0);
// Fill it with 1s // Fill it with 1s
std::fill_n (cell, nr_points * 2, 1); std::fill_n(cell, nr_points * 2, 1);
cell++; cell++;
for (vtkIdType i = 0; i < nr_points; ++i, cell += 2) for (vtkIdType i = 0; i < nr_points; ++i, cell += 2)
*cell = i; *cell = i;
// Save the results in initcells // Save the results in initcells
initcells = vtkSmartPointer<vtkIdTypeArray>::New (); initcells = vtkSmartPointer<vtkIdTypeArray>::New();
initcells->DeepCopy (cells); initcells->DeepCopy(cells);
} }
} }
else else
{ {
// The assumption here is that the current set of cells has more data than needed // The assumption here is that the current set of cells has more data than needed
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
} }
// Set the cells and the vertices // Set the cells and the vertices
vertices->SetCells (nr_points, cells); vertices->SetCells(nr_points, cells);
return polydata; return polydata;
} }
@ -278,19 +326,19 @@ struct cv::viz::CloudCollectionWidget::CreateCloudWidget
if (!mapper) if (!mapper)
{ {
// This is the first cloud // This is the first cloud
vtkSmartPointer<vtkDataSetMapper> mapper_new = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper_new = vtkSmartPointer<vtkDataSetMapper>::New();
mapper_new->SetInputConnection (poly_data->GetProducerPort()); mapper_new->SetInputConnection(poly_data->GetProducerPort());
mapper_new->SetScalarRange(minmax.val); mapper_new->SetScalarRange(minmax.val);
mapper_new->SetScalarModeToUsePointData (); mapper_new->SetScalarModeToUsePointData();
bool interpolation = (poly_data && poly_data->GetNumberOfCells () != poly_data->GetNumberOfVerts ()); bool interpolation = (poly_data && poly_data->GetNumberOfCells() != poly_data->GetNumberOfVerts());
mapper_new->SetInterpolateScalarsBeforeMapping(interpolation); mapper_new->SetInterpolateScalarsBeforeMapping(interpolation);
mapper_new->ScalarVisibilityOn(); mapper_new->ScalarVisibilityOn();
mapper_new->ImmediateModeRenderingOff(); mapper_new->ImmediateModeRenderingOff();
actor->SetNumberOfCloudPoints (int (std::max<vtkIdType>(1, poly_data->GetNumberOfPoints () / 10))); actor->SetNumberOfCloudPoints(int(std::max<vtkIdType>(1, poly_data->GetNumberOfPoints() / 10)));
actor->GetProperty()->SetInterpolationToFlat(); actor->GetProperty()->SetInterpolationToFlat();
actor->GetProperty()->BackfaceCullingOn(); actor->GetProperty()->BackfaceCullingOn();
actor->SetMapper(mapper_new); actor->SetMapper(mapper_new);
@ -307,7 +355,7 @@ struct cv::viz::CloudCollectionWidget::CreateCloudWidget
// Update the number of cloud points // Update the number of cloud points
vtkIdType old_cloud_points = actor->GetNumberOfCloudPoints(); vtkIdType old_cloud_points = actor->GetNumberOfCloudPoints();
actor->SetNumberOfCloudPoints (int (std::max<vtkIdType>(1, old_cloud_points+poly_data->GetNumberOfPoints () / 10))); actor->SetNumberOfCloudPoints(int(std::max<vtkIdType>(1, old_cloud_points+poly_data->GetNumberOfPoints() / 10)));
} }
}; };
@ -338,13 +386,13 @@ void cv::viz::CloudCollectionWidget::addCloud(InputArray _cloud, InputArray _col
Vec3b* colors_data = new Vec3b[nr_points]; Vec3b* colors_data = new Vec3b[nr_points];
NanFilter::copyColor(colors, colors_data, cloud); NanFilter::copyColor(colors, colors_data, cloud);
vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New (); vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetNumberOfComponents (3); scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples (nr_points); scalars->SetNumberOfTuples(nr_points);
scalars->SetArray (colors_data->val, 3 * nr_points, 0); scalars->SetArray(colors_data->val, 3 * nr_points, 0);
// Assign the colors // Assign the colors
polydata->GetPointData ()->SetScalars (scalars); polydata->GetPointData()->SetScalars(scalars);
// Transform the poly data based on the pose // Transform the poly data based on the pose
vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New(); vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
@ -371,15 +419,15 @@ void cv::viz::CloudCollectionWidget::addCloud(InputArray _cloud, const Color &co
vtkIdType nr_points; vtkIdType nr_points;
vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points); vtkSmartPointer<vtkPolyData> polydata = CreateCloudWidget::create(cloud, nr_points);
vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New (); vtkSmartPointer<vtkUnsignedCharArray> scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetNumberOfComponents (3); scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples (nr_points); scalars->SetNumberOfTuples(nr_points);
scalars->FillComponent(0, color[2]); scalars->FillComponent(0, color[2]);
scalars->FillComponent(1, color[1]); scalars->FillComponent(1, color[1]);
scalars->FillComponent(2, color[0]); scalars->FillComponent(2, color[0]);
// Assign the colors // Assign the colors
polydata->GetPointData ()->SetScalars (scalars); polydata->GetPointData()->SetScalars(scalars);
// Transform the poly data based on the pose // Transform the poly data based on the pose
vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New(); vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
@ -415,8 +463,8 @@ struct cv::viz::CloudNormalsWidget::ApplyCloudNormals
static vtkSmartPointer<vtkCellArray> applyOrganized(const Mat &cloud, const Mat& normals, double 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>(std::sqrt(level)); vtkIdType point_step = static_cast<vtkIdType>(std::sqrt(level));
nr_normals = (static_cast<vtkIdType> ((cloud.cols - 1) / point_step) + 1) * nr_normals = (static_cast<vtkIdType>((cloud.cols - 1) / point_step) + 1) *
(static_cast<vtkIdType> ((cloud.rows - 1) / point_step) + 1); (static_cast<vtkIdType>((cloud.rows - 1) / point_step) + 1);
vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
pts = new _Tp[2 * nr_normals * 3]; pts = new _Tp[2 * nr_normals * 3];
@ -436,9 +484,9 @@ struct cv::viz::CloudNormalsWidget::ApplyCloudNormals
pts[2 * cell_count * 3 + 4] = prow[x+1] + nrow[x+1] * 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; pts[2 * cell_count * 3 + 5] = prow[x+2] + nrow[x+2] * scale;
lines->InsertNextCell (2); lines->InsertNextCell(2);
lines->InsertCellPoint (2 * cell_count); lines->InsertCellPoint(2 * cell_count);
lines->InsertCellPoint (2 * cell_count + 1); lines->InsertCellPoint(2 * cell_count + 1);
cell_count++; cell_count++;
} }
} }
@ -464,9 +512,9 @@ struct cv::viz::CloudNormalsWidget::ApplyCloudNormals
pts[2 * j * 3 + 4] = p[i+1] + n[i+1] * 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; pts[2 * j * 3 + 5] = p[i+2] + n[i+2] * scale;
lines->InsertNextCell (2); lines->InsertNextCell(2);
lines->InsertCellPoint (2 * j); lines->InsertCellPoint(2 * j);
lines->InsertCellPoint (2 * j + 1); lines->InsertCellPoint(2 * j + 1);
} }
return lines; return lines;
} }
@ -497,33 +545,33 @@ cv::viz::CloudNormalsWidget::CloudNormalsWidget(InputArray _cloud, InputArray _n
{ {
points->SetDataTypeToFloat(); points->SetDataTypeToFloat();
vtkSmartPointer<vtkFloatArray> data = vtkSmartPointer<vtkFloatArray>::New (); vtkSmartPointer<vtkFloatArray> data = vtkSmartPointer<vtkFloatArray>::New();
data->SetNumberOfComponents (3); data->SetNumberOfComponents(3);
float* pts = 0; float* pts = 0;
lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals); lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals);
data->SetArray (&pts[0], 2 * nr_normals * 3, 0); data->SetArray(&pts[0], 2 * nr_normals * 3, 0);
points->SetData (data); points->SetData(data);
} }
else else
{ {
points->SetDataTypeToDouble(); points->SetDataTypeToDouble();
vtkSmartPointer<vtkDoubleArray> data = vtkSmartPointer<vtkDoubleArray>::New (); vtkSmartPointer<vtkDoubleArray> data = vtkSmartPointer<vtkDoubleArray>::New();
data->SetNumberOfComponents (3); data->SetNumberOfComponents(3);
double* pts = 0; double* pts = 0;
lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals); lines = ApplyCloudNormals::apply(cloud, normals, level, scale, pts, nr_normals);
data->SetArray (&pts[0], 2 * nr_normals * 3, 0); data->SetArray(&pts[0], 2 * nr_normals * 3, 0);
points->SetData (data); points->SetData(data);
} }
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New(); vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
polyData->SetPoints (points); polyData->SetPoints(points);
polyData->SetLines (lines); polyData->SetLines(lines);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput (polyData); mapper->SetInput(polyData);
mapper->SetColorModeToMapScalars(); mapper->SetColorModeToMapScalars();
mapper->SetScalarModeToUsePointData(); mapper->SetScalarModeToUsePointData();
@ -558,7 +606,7 @@ struct cv::viz::MeshWidget::CopyImpl
const _Tp* srow = source.ptr<_Tp>(0); const _Tp* srow = source.ptr<_Tp>(0);
const _Tp* mrow = nan_mask.ptr<_Tp>(0); const _Tp* mrow = nan_mask.ptr<_Tp>(0);
for(int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs) for (int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs)
{ {
if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2])) if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2]))
{ {
@ -577,11 +625,11 @@ cv::viz::MeshWidget::MeshWidget(const Mesh3d &mesh)
CV_Assert(mesh.colors.empty() || (mesh.colors.type() == CV_8UC3 && mesh.cloud.size() == mesh.colors.size())); CV_Assert(mesh.colors.empty() || (mesh.colors.type() == CV_8UC3 && mesh.cloud.size() == mesh.colors.size()));
CV_Assert(!mesh.polygons.empty() && mesh.polygons.type() == CV_32SC1); CV_Assert(!mesh.polygons.empty() && mesh.polygons.type() == CV_32SC1);
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New (); vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkIdType nr_points = mesh.cloud.total(); vtkIdType nr_points = mesh.cloud.total();
Mat look_up_mat(1, nr_points, CV_32SC1); Mat look_up_mat(1, nr_points, CV_32SC1);
int * look_up = look_up_mat.ptr<int>(); int * look_up = look_up_mat.ptr<int>();
points->SetNumberOfPoints (nr_points); points->SetNumberOfPoints(nr_points);
// Copy data from cloud to vtkPoints // Copy data from cloud to vtkPoints
if (mesh.cloud.depth() == CV_32F) if (mesh.cloud.depth() == CV_32F)
@ -607,10 +655,10 @@ cv::viz::MeshWidget::MeshWidget(const Mesh3d &mesh)
colors_data = new Vec3b[nr_points]; colors_data = new Vec3b[nr_points];
NanFilter::copyColor(mesh.colors, colors_data, mesh.cloud); NanFilter::copyColor(mesh.colors, colors_data, mesh.cloud);
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New (); scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetNumberOfComponents (3); scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples (nr_points); scalars->SetNumberOfTuples(nr_points);
scalars->SetArray (colors_data->val, 3 * nr_points, 0); scalars->SetArray(colors_data->val, 3 * nr_points, 0);
} }
points->SetNumberOfPoints(nr_points); points->SetNumberOfPoints(nr_points);
@ -633,36 +681,36 @@ cv::viz::MeshWidget::MeshWidget(const Mesh3d &mesh)
cell_array->InsertCellPoint(look_up[polygons[i++]]); cell_array->InsertCellPoint(look_up[polygons[i++]]);
} }
vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New(); vtkSmartPointer<vtkPolyData> polydata = vtkSmartPointer<vtkPolyData>::New();
cell_array->GetData ()->SetNumberOfValues (idx); cell_array->GetData()->SetNumberOfValues(idx);
cell_array->Squeeze (); cell_array->Squeeze();
polydata->SetStrips (cell_array); polydata->SetStrips(cell_array);
polydata->SetPoints (points); polydata->SetPoints(points);
if (scalars) if (scalars)
polydata->GetPointData ()->SetScalars (scalars); polydata->GetPointData()->SetScalars(scalars);
data = polydata; data = polydata;
} }
else else
{ {
// Only one polygon // Only one polygon
vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New (); vtkSmartPointer<vtkPolygon> polygon = vtkSmartPointer<vtkPolygon>::New();
const int * polygons = mesh.polygons.ptr<int>(); const int * polygons = mesh.polygons.ptr<int>();
int n_points = polygons[0]; int n_points = polygons[0];
polygon->GetPointIds()->SetNumberOfIds(n_points); polygon->GetPointIds()->SetNumberOfIds(n_points);
for (int j = 1; j < n_points+1; ++j) for (int j = 1; j < n_points+1; ++j)
polygon->GetPointIds ()->SetId (j, look_up[polygons[j]]); polygon->GetPointIds()->SetId(j, look_up[polygons[j]]);
vtkSmartPointer<vtkUnstructuredGrid> poly_grid = vtkSmartPointer<vtkUnstructuredGrid>::New(); vtkSmartPointer<vtkUnstructuredGrid> poly_grid = vtkSmartPointer<vtkUnstructuredGrid>::New();
poly_grid->Allocate (1, 1); poly_grid->Allocate(1, 1);
poly_grid->InsertNextCell (polygon->GetCellType (), polygon->GetPointIds ()); poly_grid->InsertNextCell(polygon->GetCellType(), polygon->GetPointIds());
poly_grid->SetPoints (points); poly_grid->SetPoints(points);
poly_grid->Update (); poly_grid->Update();
if (scalars) if (scalars)
poly_grid->GetPointData ()->SetScalars (scalars); poly_grid->GetPointData()->SetScalars(scalars);
data = poly_grid; data = poly_grid;
} }
@ -675,13 +723,13 @@ cv::viz::MeshWidget::MeshWidget(const Mesh3d &mesh)
actor->GetProperty()->EdgeVisibilityOff(); actor->GetProperty()->EdgeVisibilityOff();
actor->GetProperty()->ShadingOff(); actor->GetProperty()->ShadingOff();
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput (data); mapper->SetInput(data);
mapper->ImmediateModeRenderingOff (); mapper->ImmediateModeRenderingOff();
vtkIdType numberOfCloudPoints = nr_points * 0.1; vtkIdType numberOfCloudPoints = nr_points * 0.1;
actor->SetNumberOfCloudPoints (int (numberOfCloudPoints > 1 ? numberOfCloudPoints : 1)); actor->SetNumberOfCloudPoints(int(numberOfCloudPoints > 1 ? numberOfCloudPoints : 1));
actor->SetMapper (mapper); actor->SetMapper(mapper);
WidgetAccessor::setProp(*this, actor); WidgetAccessor::setProp(*this, actor);
} }

459
modules/viz/src/interactor_style.cpp
View File

@ -1,10 +1,58 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp" #include "precomp.hpp"
#include "interactor_style.h" #include "interactor_style.h"
using namespace cv; using namespace cv;
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::Initialize () void cv::viz::InteractorStyle::Initialize()
{ {
modifier_ = cv::viz::InteractorStyle::KB_MOD_ALT; modifier_ = cv::viz::InteractorStyle::KB_MOD_ALT;
// Set windows size (width, height) to unknown (-1) // Set windows size (width, height) to unknown (-1)
@ -13,9 +61,9 @@ void cv::viz::InteractorStyle::Initialize ()
max_win_size_ = Vec2i(-1, -1); max_win_size_ = Vec2i(-1, -1);
// Create the image filter and PNG writer objects // Create the image filter and PNG writer objects
wif_ = vtkSmartPointer<vtkWindowToImageFilter>::New (); wif_ = vtkSmartPointer<vtkWindowToImageFilter>::New();
snapshot_writer_ = vtkSmartPointer<vtkPNGWriter>::New (); snapshot_writer_ = vtkSmartPointer<vtkPNGWriter>::New();
snapshot_writer_->SetInputConnection (wif_->GetOutputPort ()); snapshot_writer_->SetInputConnection(wif_->GetOutputPort());
init_ = true; init_ = true;
stereo_anaglyph_mask_default_ = true; stereo_anaglyph_mask_default_ = true;
@ -30,72 +78,72 @@ void cv::viz::InteractorStyle::Initialize ()
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::saveScreenshot (const std::string &file) void cv::viz::InteractorStyle::saveScreenshot(const std::string &file)
{ {
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]); FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
wif_->SetInput (Interactor->GetRenderWindow ()); wif_->SetInput(Interactor->GetRenderWindow());
wif_->Modified (); // Update the WindowToImageFilter wif_->Modified(); // Update the WindowToImageFilter
snapshot_writer_->Modified (); snapshot_writer_->Modified();
snapshot_writer_->SetFileName (file.c_str ()); snapshot_writer_->SetFileName(file.c_str());
snapshot_writer_->Write (); snapshot_writer_->Write();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::zoomIn () void cv::viz::InteractorStyle::zoomIn()
{ {
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]); FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
// Zoom in // Zoom in
StartDolly (); StartDolly();
double factor = 10.0 * 0.2 * .5; double factor = 10.0 * 0.2 * .5;
Dolly (std::pow (1.1, factor)); Dolly(std::pow(1.1, factor));
EndDolly (); EndDolly();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::zoomOut () void cv::viz::InteractorStyle::zoomOut()
{ {
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]); FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
// Zoom out // Zoom out
StartDolly (); StartDolly();
double factor = 10.0 * -0.2 * .5; double factor = 10.0 * -0.2 * .5;
Dolly (std::pow (1.1, factor)); Dolly(std::pow(1.1, factor));
EndDolly (); EndDolly();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnChar () void cv::viz::InteractorStyle::OnChar()
{ {
// Make sure we ignore the same events we handle in OnKeyDown to avoid calling things twice // Make sure we ignore the same events we handle in OnKeyDown to avoid calling things twice
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]); FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
if (Interactor->GetKeyCode () >= '0' && Interactor->GetKeyCode () <= '9') if (Interactor->GetKeyCode() >= '0' && Interactor->GetKeyCode() <= '9')
return; return;
std::string key (Interactor->GetKeySym ()); std::string key(Interactor->GetKeySym());
if (key.find ("XF86ZoomIn") != std::string::npos) if (key.find("XF86ZoomIn") != std::string::npos)
zoomIn (); zoomIn();
else if (key.find ("XF86ZoomOut") != std::string::npos) else if (key.find("XF86ZoomOut") != std::string::npos)
zoomOut (); zoomOut();
int keymod = false; int keymod = false;
switch (modifier_) switch (modifier_)
{ {
case KB_MOD_ALT: case KB_MOD_ALT:
{ {
keymod = Interactor->GetAltKey (); keymod = Interactor->GetAltKey();
break; break;
} }
case KB_MOD_CTRL: case KB_MOD_CTRL:
{ {
keymod = Interactor->GetControlKey (); keymod = Interactor->GetControlKey();
break; break;
} }
case KB_MOD_SHIFT: case KB_MOD_SHIFT:
{ {
keymod = Interactor->GetShiftKey (); keymod = Interactor->GetShiftKey();
break; break;
} }
} }
switch (Interactor->GetKeyCode ()) switch (Interactor->GetKeyCode())
{ {
// All of the options below simply exit // All of the options below simply exit
case 'h': case 'H': case 'h': case 'H':
@ -118,12 +166,12 @@ void cv::viz::InteractorStyle::OnChar ()
case 's': case 'S': case 's': case 'S':
{ {
if (!keymod) if (!keymod)
Superclass::OnChar (); Superclass::OnChar();
break; break;
} }
default: default:
{ {
Superclass::OnChar (); Superclass::OnChar();
break; break;
} }
} }
@ -147,30 +195,30 @@ void cv::viz::InteractorStyle::registerKeyboardCallback(void (*callback)(const K
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void void
cv::viz::InteractorStyle::OnKeyDown () cv::viz::InteractorStyle::OnKeyDown()
{ {
CV_Assert("Interactor style not initialized. Please call Initialize () before continuing" && init_); CV_Assert("Interactor style not initialized. Please call Initialize() before continuing" && init_);
CV_Assert("No renderer given! Use SetRendererCollection () before continuing." && renderer_); CV_Assert("No renderer given! Use SetRendererCollection() before continuing." && renderer_);
FindPokedRenderer (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1]); FindPokedRenderer(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1]);
if (wif_->GetInput () == NULL) if (wif_->GetInput() == NULL)
{ {
wif_->SetInput (Interactor->GetRenderWindow ()); wif_->SetInput(Interactor->GetRenderWindow());
wif_->Modified (); wif_->Modified();
snapshot_writer_->Modified (); snapshot_writer_->Modified();
} }
// Save the initial windows width/height // Save the initial windows width/height
if (win_size_[0] == -1 || win_size_[1] == -1) if (win_size_[0] == -1 || win_size_[1] == -1)
win_size_ = Vec2i(Interactor->GetRenderWindow ()->GetSize ()); win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize());
// Get the status of special keys (Cltr+Alt+Shift) // Get the status of special keys (Cltr+Alt+Shift)
bool shift = Interactor->GetShiftKey (); bool shift = Interactor->GetShiftKey();
bool ctrl = Interactor->GetControlKey (); bool ctrl = Interactor->GetControlKey();
bool alt = Interactor->GetAltKey (); bool alt = Interactor->GetAltKey();
bool keymod = false; bool keymod = false;
switch (modifier_) switch (modifier_)
@ -180,13 +228,13 @@ cv::viz::InteractorStyle::OnKeyDown ()
case KB_MOD_SHIFT: keymod = shift; break; case KB_MOD_SHIFT: keymod = shift; break;
} }
std::string key (Interactor->GetKeySym ()); std::string key(Interactor->GetKeySym());
if (key.find ("XF86ZoomIn") != std::string::npos) if (key.find("XF86ZoomIn") != std::string::npos)
zoomIn (); zoomIn();
else if (key.find ("XF86ZoomOut") != std::string::npos) else if (key.find("XF86ZoomOut") != std::string::npos)
zoomOut (); zoomOut();
switch (Interactor->GetKeyCode ()) switch (Interactor->GetKeyCode())
{ {
case 'h': case 'H': case 'h': case 'H':
{ {
@ -218,14 +266,14 @@ cv::viz::InteractorStyle::OnKeyDown ()
// Switch representation to points // Switch representation to points
case 'p': case 'P': case 'p': case 'P':
{ {
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors (); vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors();
vtkCollectionSimpleIterator ait; vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); ) for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); )
{ {
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); ) for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); )
{ {
vtkActor* apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ()); vtkActor* apart = reinterpret_cast <vtkActor*>(path->GetLastNode()->GetViewProp());
apart->GetProperty ()->SetRepresentationToPoints (); apart->GetProperty()->SetRepresentationToPoints();
} }
} }
break; break;
@ -234,27 +282,27 @@ cv::viz::InteractorStyle::OnKeyDown ()
case 'j': case 'J': case 'j': case 'J':
{ {
char cam_fn[80], snapshot_fn[80]; char cam_fn[80], snapshot_fn[80];
unsigned t = static_cast<unsigned> (time (0)); unsigned t = static_cast<unsigned>(time(0));
sprintf (snapshot_fn, "screenshot-%d.png" , t); sprintf(snapshot_fn, "screenshot-%d.png" , t);
saveScreenshot (snapshot_fn); saveScreenshot(snapshot_fn);
sprintf (cam_fn, "screenshot-%d.cam", t); sprintf(cam_fn, "screenshot-%d.cam", t);
ofstream ofs_cam; ofstream ofs_cam;
ofs_cam.open (cam_fn); ofs_cam.open(cam_fn);
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera (); vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->GetActiveCamera();
double clip[2], focal[3], pos[3], view[3]; double clip[2], focal[3], pos[3], view[3];
cam->GetClippingRange (clip); cam->GetClippingRange(clip);
cam->GetFocalPoint (focal); cam->GetFocalPoint(focal);
cam->GetPosition (pos); cam->GetPosition(pos);
cam->GetViewUp (view); cam->GetViewUp(view);
int *win_pos = Interactor->GetRenderWindow ()->GetPosition (); int *win_pos = Interactor->GetRenderWindow()->GetPosition();
int *win_size = Interactor->GetRenderWindow ()->GetSize (); int *win_size = Interactor->GetRenderWindow()->GetSize();
ofs_cam << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" << ofs_cam << clip[0] << "," << clip[1] << "/" << focal[0] << "," << focal[1] << "," << focal[2] << "/" <<
pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" << pos[0] << "," << pos[1] << "," << pos[2] << "/" << view[0] << "," << view[1] << "," << view[2] << "/" <<
cam->GetViewAngle () / 180.0 * CV_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1] cam->GetViewAngle() / 180.0 * CV_PI << "/" << win_size[0] << "," << win_size[1] << "/" << win_pos[0] << "," << win_pos[1]
<< endl; << endl;
ofs_cam.close (); ofs_cam.close();
std::cout << "Screenshot (" << snapshot_fn << ") and camera information (" << cam_fn << ") successfully captured." << std::endl; std::cout << "Screenshot (" << snapshot_fn << ") and camera information (" << cam_fn << ") successfully captured." << std::endl;
break; break;
@ -262,14 +310,14 @@ cv::viz::InteractorStyle::OnKeyDown ()
// display current camera settings/parameters // display current camera settings/parameters
case 'c': case 'C': case 'c': case 'C':
{ {
vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow ()->GetRenderers ()->GetFirstRenderer ()->GetActiveCamera (); vtkSmartPointer<vtkCamera> cam = Interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->GetActiveCamera();
Vec2d clip; Vec2d clip;
Vec3d focal, pose, view; Vec3d focal, pose, view;
cam->GetClippingRange (clip.val); cam->GetClippingRange(clip.val);
cam->GetFocalPoint (focal.val); cam->GetFocalPoint(focal.val);
cam->GetPosition (pose.val); cam->GetPosition(pose.val);
cam->GetViewUp (view.val); cam->GetViewUp(view.val);
Vec2i win_pos(Interactor->GetRenderWindow()->GetPosition()); Vec2i win_pos(Interactor->GetRenderWindow()->GetPosition());
Vec2i win_size(Interactor->GetRenderWindow()->GetSize()); Vec2i win_size(Interactor->GetRenderWindow()->GetSize());
@ -286,20 +334,20 @@ cv::viz::InteractorStyle::OnKeyDown ()
} }
case 43: // KEY_PLUS case 43: // KEY_PLUS
{ {
if(alt) if (alt)
zoomIn (); zoomIn();
else else
{ {
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors (); vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors();
vtkCollectionSimpleIterator ait; vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); ) for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); )
{ {
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); ) for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); )
{ {
vtkActor* apart = reinterpret_cast <vtkActor*> (path->GetLastNode ()->GetViewProp ()); vtkActor* apart = reinterpret_cast <vtkActor*>(path->GetLastNode()->GetViewProp());
float psize = apart->GetProperty ()->GetPointSize (); float psize = apart->GetProperty()->GetPointSize();
if (psize < 63.0f) if (psize < 63.0f)
apart->GetProperty ()->SetPointSize (psize + 1.0f); apart->GetProperty()->SetPointSize(psize + 1.0f);
} }
} }
} }
@ -307,20 +355,20 @@ cv::viz::InteractorStyle::OnKeyDown ()
} }
case 45: // KEY_MINUS case 45: // KEY_MINUS
{ {
if(alt) if (alt)
zoomOut (); zoomOut();
else else
{ {
vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors (); vtkSmartPointer<vtkActorCollection> ac = CurrentRenderer->GetActors();
vtkCollectionSimpleIterator ait; vtkCollectionSimpleIterator ait;
for (ac->InitTraversal (ait); vtkActor* actor = ac->GetNextActor (ait); ) for (ac->InitTraversal(ait); vtkActor* actor = ac->GetNextActor(ait); )
{ {
for (actor->InitPathTraversal (); vtkAssemblyPath* path = actor->GetNextPath (); ) for (actor->InitPathTraversal(); vtkAssemblyPath* path = actor->GetNextPath(); )
{ {
vtkActor* apart = static_cast<vtkActor*> (path->GetLastNode ()->GetViewProp ()); vtkActor* apart = static_cast<vtkActor*>(path->GetLastNode()->GetViewProp());
float psize = apart->GetProperty ()->GetPointSize (); float psize = apart->GetProperty()->GetPointSize();
if (psize > 1.0f) if (psize > 1.0f)
apart->GetProperty ()->SetPointSize (psize - 1.0f); apart->GetProperty()->SetPointSize(psize - 1.0f);
} }
} }
} }
@ -331,39 +379,39 @@ cv::viz::InteractorStyle::OnKeyDown ()
{ {
if (keymod) if (keymod)
{ {
Vec2i screen_size(Interactor->GetRenderWindow ()->GetScreenSize ()); Vec2i screen_size(Interactor->GetRenderWindow()->GetScreenSize());
Vec2i win_size(Interactor->GetRenderWindow ()->GetSize ()); Vec2i win_size(Interactor->GetRenderWindow()->GetSize());
// Is window size = max? // Is window size = max?
if (win_size == max_win_size_) if (win_size == max_win_size_)
{ {
Interactor->GetRenderWindow ()->SetSize (win_size_.val); Interactor->GetRenderWindow()->SetSize(win_size_.val);
Interactor->GetRenderWindow ()->SetPosition (win_pos_.val); Interactor->GetRenderWindow()->SetPosition(win_pos_.val);
Interactor->GetRenderWindow ()->Render (); Interactor->GetRenderWindow()->Render();
Interactor->Render (); Interactor->Render();
} }
// Set to max // Set to max
else else
{ {
win_pos_ = Vec2i(Interactor->GetRenderWindow ()->GetPosition ()); win_pos_ = Vec2i(Interactor->GetRenderWindow()->GetPosition());
win_size_ = win_size; win_size_ = win_size;
Interactor->GetRenderWindow ()->SetSize (screen_size.val); Interactor->GetRenderWindow()->SetSize(screen_size.val);
Interactor->GetRenderWindow ()->Render (); Interactor->GetRenderWindow()->Render();
Interactor->Render (); Interactor->Render();
max_win_size_ = Vec2i(Interactor->GetRenderWindow ()->GetSize ()); max_win_size_ = Vec2i(Interactor->GetRenderWindow()->GetSize());
} }
} }
else else
{ {
AnimState = VTKIS_ANIM_ON; AnimState = VTKIS_ANIM_ON;
vtkAssemblyPath *path = NULL; vtkAssemblyPath *path = NULL;
Interactor->GetPicker ()->Pick (Interactor->GetEventPosition ()[0], Interactor->GetEventPosition ()[1], 0.0, CurrentRenderer); Interactor->GetPicker()->Pick(Interactor->GetEventPosition()[0], Interactor->GetEventPosition()[1], 0.0, CurrentRenderer);
vtkAbstractPropPicker *picker; vtkAbstractPropPicker *picker;
if ((picker = vtkAbstractPropPicker::SafeDownCast (Interactor->GetPicker ()))) if ((picker = vtkAbstractPropPicker::SafeDownCast(Interactor->GetPicker())))
path = picker->GetPath (); path = picker->GetPath();
if (path != NULL) if (path != NULL)
Interactor->FlyTo (CurrentRenderer, picker->GetPickPosition ()); Interactor->FlyTo(CurrentRenderer, picker->GetPickPosition());
AnimState = VTKIS_ANIM_OFF; AnimState = VTKIS_ANIM_OFF;
} }
break; break;
@ -373,37 +421,37 @@ cv::viz::InteractorStyle::OnKeyDown ()
{ {
if (keymod) if (keymod)
{ {
int stereo_render = Interactor->GetRenderWindow ()->GetStereoRender (); int stereo_render = Interactor->GetRenderWindow()->GetStereoRender();
if (!stereo_render) if (!stereo_render)
{ {
if (stereo_anaglyph_mask_default_) if (stereo_anaglyph_mask_default_)
{ {
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (4, 3); Interactor->GetRenderWindow()->SetAnaglyphColorMask(4, 3);
stereo_anaglyph_mask_default_ = false; stereo_anaglyph_mask_default_ = false;
} }
else else
{ {
Interactor->GetRenderWindow ()->SetAnaglyphColorMask (2, 5); Interactor->GetRenderWindow()->SetAnaglyphColorMask(2, 5);
stereo_anaglyph_mask_default_ = true; stereo_anaglyph_mask_default_ = true;
} }
} }
Interactor->GetRenderWindow ()->SetStereoRender (!stereo_render); Interactor->GetRenderWindow()->SetStereoRender(!stereo_render);
Interactor->GetRenderWindow ()->Render (); Interactor->GetRenderWindow()->Render();
Interactor->Render (); Interactor->Render();
} }
else else
Superclass::OnKeyDown (); Superclass::OnKeyDown();
break; break;
} }
case 'o': case 'O': case 'o': case 'O':
{ {
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera (); vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
int flag = cam->GetParallelProjection (); int flag = cam->GetParallelProjection();
cam->SetParallelProjection (!flag); cam->SetParallelProjection(!flag);
CurrentRenderer->SetActiveCamera (cam); CurrentRenderer->SetActiveCamera(cam);
CurrentRenderer->Render (); CurrentRenderer->Render();
break; break;
} }
@ -412,20 +460,20 @@ cv::viz::InteractorStyle::OnKeyDown ()
{ {
if (!keymod) if (!keymod)
{ {
Superclass::OnKeyDown (); Superclass::OnKeyDown();
break; break;
} }
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera (); vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
static WidgetActorMap::iterator it = widget_actor_map_->begin (); static WidgetActorMap::iterator it = widget_actor_map_->begin();
// it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault. // it might be that some actors don't have a valid transformation set -> we skip them to avoid a seg fault.
bool found_transformation = false; bool found_transformation = false;
for (size_t idx = 0; idx < widget_actor_map_->size (); ++idx, ++it) for (size_t idx = 0; idx < widget_actor_map_->size(); ++idx, ++it)
{ {
if (it == widget_actor_map_->end ()) if (it == widget_actor_map_->end())
it = widget_actor_map_->begin (); it = widget_actor_map_->begin();
vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second); vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second);
if (actor && actor->GetUserMatrix()) if (actor && actor->GetUserMatrix())
@ -439,219 +487,218 @@ cv::viz::InteractorStyle::OnKeyDown ()
if (found_transformation) if (found_transformation)
{ {
vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second); vtkProp3D * actor = vtkProp3D::SafeDownCast(it->second);
cam->SetPosition (actor->GetUserMatrix()->GetElement (0, 3), cam->SetPosition(actor->GetUserMatrix()->GetElement(0, 3),
actor->GetUserMatrix()->GetElement (1, 3), actor->GetUserMatrix()->GetElement(1, 3),
actor->GetUserMatrix()->GetElement (2, 3)); actor->GetUserMatrix()->GetElement(2, 3));
cam->SetFocalPoint (actor->GetUserMatrix()->GetElement (0, 3) - actor->GetUserMatrix()->GetElement (0, 2), cam->SetFocalPoint(actor->GetUserMatrix()->GetElement(0, 3) - actor->GetUserMatrix()->GetElement(0, 2),
actor->GetUserMatrix()->GetElement (1, 3) - actor->GetUserMatrix()->GetElement (1, 2), actor->GetUserMatrix()->GetElement(1, 3) - actor->GetUserMatrix()->GetElement(1, 2),
actor->GetUserMatrix()->GetElement (2, 3) - actor->GetUserMatrix()->GetElement (2, 2)); actor->GetUserMatrix()->GetElement(2, 3) - actor->GetUserMatrix()->GetElement(2, 2));
cam->SetViewUp (actor->GetUserMatrix()->GetElement (0, 1), cam->SetViewUp(actor->GetUserMatrix()->GetElement(0, 1),
actor->GetUserMatrix()->GetElement (1, 1), actor->GetUserMatrix()->GetElement(1, 1),
actor->GetUserMatrix()->GetElement (2, 1)); actor->GetUserMatrix()->GetElement(2, 1));
} }
else else
{ {
cam->SetPosition (0, 0, 0); cam->SetPosition(0, 0, 0);
cam->SetFocalPoint (0, 0, 1); cam->SetFocalPoint(0, 0, 1);
cam->SetViewUp (0, -1, 0); cam->SetViewUp(0, -1, 0);
} }
// go to the next actor for the next key-press event. // go to the next actor for the next key-press event.
if (it != widget_actor_map_->end ()) if (it != widget_actor_map_->end())
++it; ++it;
else else
it = widget_actor_map_->begin (); it = widget_actor_map_->begin();
CurrentRenderer->SetActiveCamera (cam); CurrentRenderer->SetActiveCamera(cam);
CurrentRenderer->ResetCameraClippingRange (); CurrentRenderer->ResetCameraClippingRange();
CurrentRenderer->Render (); CurrentRenderer->Render();
break; break;
} }
case 'q': case 'Q': case 'q': case 'Q':
{ {
Interactor->ExitCallback (); Interactor->ExitCallback();
return; return;
} }
default: default:
{ {
Superclass::OnKeyDown (); Superclass::OnKeyDown();
break; break;
} }
} }
KeyboardEvent event (true, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); KeyboardEvent event(true, Interactor->GetKeySym(), Interactor->GetKeyCode(), Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
// Check if there is a keyboard callback registered // Check if there is a keyboard callback registered
if (keyboardCallback_) if (keyboardCallback_)
keyboardCallback_(event, keyboard_callback_cookie_); keyboardCallback_(event, keyboard_callback_cookie_);
renderer_->Render (); renderer_->Render();
Interactor->Render (); Interactor->Render();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnKeyUp () void cv::viz::InteractorStyle::OnKeyUp()
{ {
KeyboardEvent event (false, Interactor->GetKeySym (), Interactor->GetKeyCode (), Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); KeyboardEvent event(false, Interactor->GetKeySym(), Interactor->GetKeyCode(), Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
// Check if there is a keyboard callback registered // Check if there is a keyboard callback registered
if (keyboardCallback_) if (keyboardCallback_)
keyboardCallback_(event, keyboard_callback_cookie_); keyboardCallback_(event, keyboard_callback_cookie_);
Superclass::OnKeyUp (); Superclass::OnKeyUp();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnMouseMove () void cv::viz::InteractorStyle::OnMouseMove()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseMove, MouseEvent::NoButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(MouseEvent::MouseMove, MouseEvent::NoButton, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
Superclass::OnMouseMove (); Superclass::OnMouseMove();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnLeftButtonDown () void cv::viz::InteractorStyle::OnLeftButtonDown()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick; MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
MouseEvent event (type, MouseEvent::LeftButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(type, MouseEvent::LeftButton, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
Superclass::OnLeftButtonDown (); Superclass::OnLeftButtonDown();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnLeftButtonUp () void cv::viz::InteractorStyle::OnLeftButtonUp()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::LeftButton, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
Superclass::OnLeftButtonUp (); Superclass::OnLeftButtonUp();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnMiddleButtonDown () void cv::viz::InteractorStyle::OnMiddleButtonDown()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick; MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
MouseEvent event (type, MouseEvent::MiddleButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(type, MouseEvent::MiddleButton, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
Superclass::OnMiddleButtonDown (); Superclass::OnMiddleButtonDown();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnMiddleButtonUp () void cv::viz::InteractorStyle::OnMiddleButtonUp()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::MiddleButton, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
Superclass::OnMiddleButtonUp (); Superclass::OnMiddleButtonUp();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnRightButtonDown () void cv::viz::InteractorStyle::OnRightButtonDown()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick; MouseEvent::Type type = (Interactor->GetRepeatCount() == 0) ? MouseEvent::MouseButtonPress : MouseEvent::MouseDblClick;
MouseEvent event (type, MouseEvent::RightButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(type, MouseEvent::RightButton, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
Superclass::OnRightButtonDown (); Superclass::OnRightButtonDown();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnRightButtonUp () void cv::viz::InteractorStyle::OnRightButtonUp()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseButtonRelease, MouseEvent::RightButton, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(MouseEvent::MouseButtonRelease, MouseEvent::RightButton, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
Superclass::OnRightButtonUp (); Superclass::OnRightButtonUp();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnMouseWheelForward () void cv::viz::InteractorStyle::OnMouseWheelForward()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseScrollUp, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(MouseEvent::MouseScrollUp, MouseEvent::VScroll, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
// If a mouse callback registered, call it! // If a mouse callback registered, call it!
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
if (Interactor->GetRepeatCount () && mouseCallback_) if (Interactor->GetRepeatCount() && mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
if (Interactor->GetAltKey ()) if (Interactor->GetAltKey())
{ {
// zoom // zoom
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera (); vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
double opening_angle = cam->GetViewAngle (); double opening_angle = cam->GetViewAngle();
if (opening_angle > 15.0) if (opening_angle > 15.0)
opening_angle -= 1.0; opening_angle -= 1.0;
cam->SetViewAngle (opening_angle); cam->SetViewAngle(opening_angle);
cam->Modified (); cam->Modified();
CurrentRenderer->SetActiveCamera (cam); CurrentRenderer->SetActiveCamera(cam);
CurrentRenderer->ResetCameraClippingRange (); CurrentRenderer->ResetCameraClippingRange();
CurrentRenderer->Modified (); CurrentRenderer->Modified();
CurrentRenderer->Render (); CurrentRenderer->Render();
renderer_->Render (); renderer_->Render();
Interactor->Render (); Interactor->Render();
} }
else else
Superclass::OnMouseWheelForward (); Superclass::OnMouseWheelForward();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnMouseWheelBackward () void cv::viz::InteractorStyle::OnMouseWheelBackward()
{ {
Vec2i p(Interactor->GetEventPosition()); Vec2i p(Interactor->GetEventPosition());
MouseEvent event (MouseEvent::MouseScrollDown, MouseEvent::VScroll, p, Interactor->GetAltKey (), Interactor->GetControlKey (), Interactor->GetShiftKey ()); MouseEvent event(MouseEvent::MouseScrollDown, MouseEvent::VScroll, p, Interactor->GetAltKey(), Interactor->GetControlKey(), Interactor->GetShiftKey());
// If a mouse callback registered, call it! // If a mouse callback registered, call it!
if (mouseCallback_) if (mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
if (Interactor->GetRepeatCount () && mouseCallback_) if (Interactor->GetRepeatCount() && mouseCallback_)
mouseCallback_(event, mouse_callback_cookie_); mouseCallback_(event, mouse_callback_cookie_);
if (Interactor->GetAltKey ()) if (Interactor->GetAltKey())
{ {
// zoom // zoom
vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera (); vtkSmartPointer<vtkCamera> cam = CurrentRenderer->GetActiveCamera();
double opening_angle = cam->GetViewAngle (); double opening_angle = cam->GetViewAngle();
if (opening_angle < 170.0) if (opening_angle < 170.0)
opening_angle += 1.0; opening_angle += 1.0;
cam->SetViewAngle (opening_angle); cam->SetViewAngle(opening_angle);
cam->Modified (); cam->Modified();
CurrentRenderer->SetActiveCamera (cam); CurrentRenderer->SetActiveCamera(cam);
CurrentRenderer->ResetCameraClippingRange (); CurrentRenderer->ResetCameraClippingRange();
CurrentRenderer->Modified (); CurrentRenderer->Modified();
CurrentRenderer->Render (); CurrentRenderer->Render();
renderer_->Render (); renderer_->Render();
Interactor->Render (); Interactor->Render();
} }
else else
Superclass::OnMouseWheelBackward (); Superclass::OnMouseWheelBackward();
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::InteractorStyle::OnTimer () void cv::viz::InteractorStyle::OnTimer()
{ {
CV_Assert("Interactor style not initialized." && init_); CV_Assert("Interactor style not initialized." && init_);
CV_Assert("Renderer has not been set." && renderer_); CV_Assert("Renderer has not been set." && renderer_);
renderer_->Render (); renderer_->Render();
Interactor->Render (); Interactor->Render();
} }
namespace cv namespace cv
{ {
namespace viz namespace viz

133
modules/viz/src/interactor_style.h
View File

@ -1,4 +1,53 @@
#pragma once /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifndef __OPENCV_VIZ_INTERACTOR_STYLE_H__
#define __OPENCV_VIZ_INTERACTOR_STYLE_H__
#include <opencv2/viz/types.hpp> #include <opencv2/viz/types.hpp>
@ -6,27 +55,6 @@ namespace cv
{ {
namespace viz namespace viz
{ {
/** \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
* - w, W : switch to a wireframe-based representation (where available)
* - s, S : switch to a surface-based representation (where available)
* - j, J : take a .PNG snapshot of the current window view
* - c, C : display current camera/window parameters
* - f, F : fly to point mode
* - e, E : exit the interactor
* - q, Q : stop and call VTK's TerminateApp
* - + / - : increment/decrement overall point size
* - r, R [+ ALT] : reset camera [to viewpoint = {0, 0, 0} -> center_{x, y, z}]
* - ALT + s, S : turn stereo mode on/off
* - ALT + f, F : switch between maximized window mode and original size
* -
* - SHIFT + left click : select a point
*
* \author Radu B. Rusu
*/
class InteractorStyle : public vtkInteractorStyleTrackballCamera class InteractorStyle : public vtkInteractorStyleTrackballCamera
{ {
public: public:
@ -38,37 +66,31 @@ namespace cv
KB_MOD_SHIFT KB_MOD_SHIFT
}; };
static InteractorStyle *New (); static InteractorStyle *New();
InteractorStyle () {} InteractorStyle() {}
virtual ~InteractorStyle () {} virtual ~InteractorStyle() {}
// this macro defines Superclass, the isA functionality and the safe downcast method // 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. */ /** \brief Initialization routine. Must be called before anything else. */
virtual void Initialize (); virtual void Initialize();
inline void setWidgetActorMap (const Ptr<WidgetActorMap>& actors) { widget_actor_map_ = actors; } inline void setWidgetActorMap(const Ptr<WidgetActorMap>& actors) { widget_actor_map_ = actors; }
void setRenderer (vtkSmartPointer<vtkRenderer>& ren) { renderer_ = ren; } void setRenderer(vtkSmartPointer<vtkRenderer>& ren) { renderer_ = ren; }
void registerMouseCallback(void (*callback)(const MouseEvent&, 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 registerKeyboardCallback(void (*callback)(const KeyboardEvent&, void*), void * cookie = 0);
void saveScreenshot (const std::string &file); void saveScreenshot(const std::string &file);
/** \brief Change the default keyboard modified from ALT to a different special key.*/
inline void setKeyboardModifier(const KeyboardModifier &modifier) { modifier_ = modifier; }
/** \brief Change the default keyboard modified from ALT to a different special key.
* Allowed values are:
* - KB_MOD_ALT
* - KB_MOD_CTRL
* - KB_MOD_SHIFT
* \param[in] modifier the new keyboard modifier
*/
inline void setKeyboardModifier (const KeyboardModifier &modifier) { modifier_ = modifier; }
protected: protected:
/** \brief Set to true after initialization is complete. */ /** \brief Set to true after initialization is complete. */
bool init_; bool init_;
/** \brief Collection of vtkRenderers stored internally. */ /** \brief Collection of vtkRenderers stored internally. */
//vtkSmartPointer<vtkRendererCollection> rens_;
vtkSmartPointer<vtkRenderer> renderer_; vtkSmartPointer<vtkRenderer> renderer_;
/** \brief Actor map stored internally. */ /** \brief Actor map stored internally. */
@ -85,32 +107,33 @@ namespace cv
/** \brief A PNG writer for screenshot captures. */ /** \brief A PNG writer for screenshot captures. */
vtkSmartPointer<vtkPNGWriter> snapshot_writer_; vtkSmartPointer<vtkPNGWriter> snapshot_writer_;
/** \brief Internal window to image filter. Needed by \a snapshot_writer_. */ /** \brief Internal window to image filter. Needed by \a snapshot_writer_. */
vtkSmartPointer<vtkWindowToImageFilter> wif_; vtkSmartPointer<vtkWindowToImageFilter> wif_;
/** \brief Interactor style internal method. Gets called whenever a key is pressed. */ /** \brief Interactor style internal method. Gets called whenever a key is pressed. */
virtual void OnChar (); virtual void OnChar();
// Keyboard events // Keyboard events
virtual void OnKeyDown (); virtual void OnKeyDown();
virtual void OnKeyUp (); virtual void OnKeyUp();
// mouse button events // mouse button events
virtual void OnMouseMove (); virtual void OnMouseMove();
virtual void OnLeftButtonDown (); virtual void OnLeftButtonDown();
virtual void OnLeftButtonUp (); virtual void OnLeftButtonUp();
virtual void OnMiddleButtonDown (); virtual void OnMiddleButtonDown();
virtual void OnMiddleButtonUp (); virtual void OnMiddleButtonUp();
virtual void OnRightButtonDown (); virtual void OnRightButtonDown();
virtual void OnRightButtonUp (); virtual void OnRightButtonUp();
virtual void OnMouseWheelForward (); virtual void OnMouseWheelForward();
virtual void OnMouseWheelBackward (); virtual void OnMouseWheelBackward();
/** \brief Interactor style internal method. Gets called periodically if a timer is set. */ /** \brief Interactor style internal method. Gets called periodically if a timer is set. */
virtual void OnTimer (); virtual void OnTimer();
void zoomIn (); void zoomIn();
void zoomOut (); void zoomOut();
/** \brief True if we're using red-blue colors for anaglyphic stereo, false if magenta-green. */ /** \brief True if we're using red-blue colors for anaglyphic stereo, false if magenta-green. */
bool stereo_anaglyph_mask_default_; bool stereo_anaglyph_mask_default_;
@ -125,3 +148,5 @@ namespace cv
}; };
} }
} }
#endif

48
modules/viz/src/precomp.cpp
View File

@ -1 +1,49 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp" #include "precomp.hpp"

53
modules/viz/src/precomp.hpp
View File

@ -1,4 +1,53 @@
#pragma once /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifndef __OPENCV_VIZ_PRECOMP_HPP__
#define __OPENCV_VIZ_PRECOMP_HPP__
#include <map> #include <map>
#include <ctime> #include <ctime>
@ -89,3 +138,5 @@ namespace cv
#include <opencv2/viz.hpp> #include <opencv2/viz.hpp>
#include <opencv2/viz/types.hpp> #include <opencv2/viz/types.hpp>
#include "opencv2/viz/widget_accessor.hpp" #include "opencv2/viz/widget_accessor.hpp"
#endif

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

@ -1,3 +1,51 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp" #include "precomp.hpp"
namespace cv namespace cv
@ -13,12 +61,12 @@ namespace cv
cv::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(); vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New();
line->SetPoint1 (pt1.x, pt1.y, pt1.z); line->SetPoint1(pt1.x, pt1.y, pt1.z);
line->SetPoint2 (pt2.x, pt2.y, pt2.z); line->SetPoint2(pt2.x, pt2.y, pt2.z);
line->Update (); line->Update();
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput(line->GetOutput ()); mapper->SetInput(line->GetOutput());
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@ -58,15 +106,15 @@ struct cv::viz::PlaneWidget::SetSizeImpl
cv::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 (); vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New();
plane->SetNormal (coefs[0], coefs[1], coefs[2]); plane->SetNormal(coefs[0], coefs[1], coefs[2]);
double norm = cv::norm(Vec3f(coefs.val)); double norm = cv::norm(Vec3f(coefs.val));
plane->Push (-coefs[3] / norm); plane->Push(-coefs[3] / norm);
Vec3d p_center; Vec3d p_center;
plane->GetOrigin(p_center.val); plane->GetOrigin(p_center.val);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput(SetSizeImpl::setSize(p_center, plane->GetOutput(), size)); mapper->SetInput(SetSizeImpl::setSize(p_center, plane->GetOutput(), size));
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
@ -78,16 +126,16 @@ cv::viz::PlaneWidget::PlaneWidget(const Vec4f& coefs, double size, const Color &
cv::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 (); vtkSmartPointer<vtkPlaneSource> plane = vtkSmartPointer<vtkPlaneSource>::New();
Point3f coefs3(coefs[0], coefs[1], coefs[2]); Point3f coefs3(coefs[0], coefs[1], coefs[2]);
double norm_sqr = 1.0 / coefs3.dot (coefs3); double norm_sqr = 1.0 / coefs3.dot(coefs3);
plane->SetNormal(coefs[0], coefs[1], coefs[2]); plane->SetNormal(coefs[0], coefs[1], coefs[2]);
double t = coefs3.dot(pt) + coefs[3]; double t = coefs3.dot(pt) + coefs[3];
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]); plane->SetCenter(p_center[0], p_center[1], p_center[2]);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput(SetSizeImpl::setSize(p_center, plane->GetOutput(), size)); mapper->SetInput(SetSizeImpl::setSize(p_center, plane->GetOutput(), size));
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
@ -108,16 +156,16 @@ template<> cv::viz::PlaneWidget cv::viz::Widget::cast<cv::viz::PlaneWidget>()
cv::viz::SphereWidget::SphereWidget(const Point3f &center, float radius, int sphere_resolution, const Color &color) cv::viz::SphereWidget::SphereWidget(const Point3f &center, float radius, int sphere_resolution, const Color &color)
{ {
vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New (); vtkSmartPointer<vtkSphereSource> sphere = vtkSmartPointer<vtkSphereSource>::New();
sphere->SetRadius (radius); sphere->SetRadius(radius);
sphere->SetCenter (center.x, center.y, center.z); sphere->SetCenter(center.x, center.y, center.z);
sphere->SetPhiResolution (sphere_resolution); sphere->SetPhiResolution(sphere_resolution);
sphere->SetThetaResolution (sphere_resolution); sphere->SetThetaResolution(sphere_resolution);
sphere->LatLongTessellationOff (); sphere->LatLongTessellationOff();
sphere->Update (); sphere->Update();
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput(sphere->GetOutput ()); mapper->SetInput(sphere->GetOutput());
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@ -137,7 +185,7 @@ template<> cv::viz::SphereWidget cv::viz::Widget::cast<cv::viz::SphereWidget>()
cv::viz::ArrowWidget::ArrowWidget(const Point3f& pt1, const Point3f& pt2, double thickness, const Color &color) cv::viz::ArrowWidget::ArrowWidget(const Point3f& pt1, const Point3f& pt2, double thickness, const Color &color)
{ {
vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New (); vtkSmartPointer<vtkArrowSource> arrowSource = vtkSmartPointer<vtkArrowSource>::New();
arrowSource->SetShaftRadius(thickness); arrowSource->SetShaftRadius(thickness);
// The thickness and radius of the tip are adjusted based on the thickness of the arrow // The thickness and radius of the tip are adjusted based on the thickness of the arrow
arrowSource->SetTipRadius(thickness * 3.0); arrowSource->SetTipRadius(thickness * 3.0);
@ -189,8 +237,8 @@ cv::viz::ArrowWidget::ArrowWidget(const Point3f& pt1, const Point3f& pt2, double
transformPD->SetTransform(transform); transformPD->SetTransform(transform);
transformPD->SetInputConnection(arrowSource->GetOutputPort()); transformPD->SetInputConnection(arrowSource->GetOutputPort());
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput(transformPD->GetOutput ()); mapper->SetInput(transformPD->GetOutput());
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@ -210,23 +258,23 @@ template<> cv::viz::ArrowWidget cv::viz::Widget::cast<cv::viz::ArrowWidget>()
cv::viz::CircleWidget::CircleWidget(const Point3f& pt, double radius, double thickness, const Color& color) cv::viz::CircleWidget::CircleWidget(const Point3f& pt, double radius, double thickness, const Color& color)
{ {
vtkSmartPointer<vtkDiskSource> disk = vtkSmartPointer<vtkDiskSource>::New (); vtkSmartPointer<vtkDiskSource> disk = vtkSmartPointer<vtkDiskSource>::New();
// Maybe the resolution should be lower e.g. 50 or 25 // Maybe the resolution should be lower e.g. 50 or 25
disk->SetCircumferentialResolution (50); disk->SetCircumferentialResolution(50);
disk->SetInnerRadius (radius - thickness); disk->SetInnerRadius(radius - thickness);
disk->SetOuterRadius (radius + thickness); disk->SetOuterRadius(radius + thickness);
// Set the circle origin // Set the circle origin
vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New (); vtkSmartPointer<vtkTransform> t = vtkSmartPointer<vtkTransform>::New();
t->Identity (); t->Identity();
t->Translate (pt.x, pt.y, pt.z); t->Translate(pt.x, pt.y, pt.z);
vtkSmartPointer<vtkTransformPolyDataFilter> tf = vtkSmartPointer<vtkTransformPolyDataFilter>::New (); vtkSmartPointer<vtkTransformPolyDataFilter> tf = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
tf->SetTransform (t); tf->SetTransform(t);
tf->SetInputConnection (disk->GetOutputPort ()); tf->SetInputConnection(disk->GetOutputPort());
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput(tf->GetOutput ()); mapper->SetInput(tf->GetOutput());
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@ -247,19 +295,19 @@ template<> cv::viz::CircleWidget cv::viz::Widget::cast<cv::viz::CircleWidget>()
cv::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 Point3f pt2 = pt_on_axis + axis_direction; const Point3f pt2 = pt_on_axis + axis_direction;
vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New (); vtkSmartPointer<vtkLineSource> line = vtkSmartPointer<vtkLineSource>::New();
line->SetPoint1 (pt_on_axis.x, pt_on_axis.y, pt_on_axis.z); line->SetPoint1(pt_on_axis.x, pt_on_axis.y, pt_on_axis.z);
line->SetPoint2 (pt2.x, pt2.y, pt2.z); line->SetPoint2(pt2.x, pt2.y, pt2.z);
vtkSmartPointer<vtkTubeFilter> tuber = vtkSmartPointer<vtkTubeFilter>::New (); vtkSmartPointer<vtkTubeFilter> tuber = vtkSmartPointer<vtkTubeFilter>::New();
tuber->SetInputConnection (line->GetOutputPort ()); tuber->SetInputConnection(line->GetOutputPort());
tuber->SetRadius (radius); tuber->SetRadius(radius);
tuber->SetNumberOfSides (numsides); tuber->SetNumberOfSides(numsides);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput(tuber->GetOutput ()); mapper->SetInput(tuber->GetOutput());
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New (); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
WidgetAccessor::setProp(*this, actor); WidgetAccessor::setProp(*this, actor);
@ -277,18 +325,18 @@ template<> cv::viz::CylinderWidget cv::viz::Widget::cast<cv::viz::CylinderWidget
cv::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<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
if (wire_frame) if (wire_frame)
{ {
vtkSmartPointer<vtkOutlineSource> cube = vtkSmartPointer<vtkOutlineSource>::New(); vtkSmartPointer<vtkOutlineSource> cube = vtkSmartPointer<vtkOutlineSource>::New();
cube->SetBounds (pt_min.x, pt_max.x, pt_min.y, pt_max.y, pt_min.z, pt_max.z); cube->SetBounds(pt_min.x, pt_max.x, pt_min.y, pt_max.y, pt_min.z, pt_max.z);
mapper->SetInput(cube->GetOutput ()); mapper->SetInput(cube->GetOutput());
} }
else else
{ {
vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New (); vtkSmartPointer<vtkCubeSource> cube = vtkSmartPointer<vtkCubeSource>::New();
cube->SetBounds (pt_min.x, pt_max.x, pt_min.y, pt_max.y, pt_min.z, pt_max.z); cube->SetBounds(pt_min.x, pt_max.x, pt_min.y, pt_max.y, pt_min.z, pt_max.z);
mapper->SetInput(cube->GetOutput ()); mapper->SetInput(cube->GetOutput());
} }
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
@ -309,31 +357,31 @@ template<> cv::viz::CubeWidget cv::viz::Widget::cast<cv::viz::CubeWidget>()
cv::viz::CoordinateSystemWidget::CoordinateSystemWidget(double scale) cv::viz::CoordinateSystemWidget::CoordinateSystemWidget(double scale)
{ {
vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New (); vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
axes->SetOrigin (0, 0, 0); axes->SetOrigin(0, 0, 0);
axes->SetScaleFactor (scale); axes->SetScaleFactor(scale);
vtkSmartPointer<vtkFloatArray> axes_colors = vtkSmartPointer<vtkFloatArray>::New (); vtkSmartPointer<vtkFloatArray> axes_colors = vtkSmartPointer<vtkFloatArray>::New();
axes_colors->Allocate (6); axes_colors->Allocate(6);
axes_colors->InsertNextValue (0.0); axes_colors->InsertNextValue(0.0);
axes_colors->InsertNextValue (0.0); axes_colors->InsertNextValue(0.0);
axes_colors->InsertNextValue (0.5); axes_colors->InsertNextValue(0.5);
axes_colors->InsertNextValue (0.5); axes_colors->InsertNextValue(0.5);
axes_colors->InsertNextValue (1.0); axes_colors->InsertNextValue(1.0);
axes_colors->InsertNextValue (1.0); axes_colors->InsertNextValue(1.0);
vtkSmartPointer<vtkPolyData> axes_data = axes->GetOutput (); vtkSmartPointer<vtkPolyData> axes_data = axes->GetOutput();
axes_data->Update (); axes_data->Update();
axes_data->GetPointData ()->SetScalars (axes_colors); axes_data->GetPointData()->SetScalars(axes_colors);
vtkSmartPointer<vtkTubeFilter> axes_tubes = vtkSmartPointer<vtkTubeFilter>::New (); vtkSmartPointer<vtkTubeFilter> axes_tubes = vtkSmartPointer<vtkTubeFilter>::New();
axes_tubes->SetInput (axes_data); axes_tubes->SetInput(axes_data);
axes_tubes->SetRadius (axes->GetScaleFactor () / 50.0); axes_tubes->SetRadius(axes->GetScaleFactor() / 50.0);
axes_tubes->SetNumberOfSides (6); axes_tubes->SetNumberOfSides(6);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetScalarModeToUsePointData (); mapper->SetScalarModeToUsePointData();
mapper->SetInput(axes_tubes->GetOutput ()); mapper->SetInput(axes_tubes->GetOutput());
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@ -357,11 +405,11 @@ struct cv::viz::PolyLineWidget::CopyImpl
{ {
int s_chs = source.channels(); int s_chs = source.channels();
for(int y = 0, id = 0; y < source.rows; ++y) for (int y = 0, id = 0; y < source.rows; ++y)
{ {
const _Tp* srow = source.ptr<_Tp>(y); const _Tp* srow = source.ptr<_Tp>(y);
for(int x = 0; x < source.cols; ++x, srow += s_chs, ++id) for (int x = 0; x < source.cols; ++x, srow += s_chs, ++id)
{ {
*output++ = Vec<_Tp, 3>(srow); *output++ = Vec<_Tp, 3>(srow);
polyLine->GetPointIds()->SetId(id,id); polyLine->GetPointIds()->SetId(id,id);
@ -376,9 +424,9 @@ cv::viz::PolyLineWidget::PolyLineWidget(InputArray _pointData, const Color &colo
CV_Assert(pointData.type() == CV_32FC3 || pointData.type() == CV_32FC4 || pointData.type() == CV_64FC3 || pointData.type() == CV_64FC4); CV_Assert(pointData.type() == CV_32FC3 || pointData.type() == CV_32FC4 || pointData.type() == CV_64FC3 || pointData.type() == CV_64FC4);
vtkIdType nr_points = pointData.total(); vtkIdType nr_points = pointData.total();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New (); vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New (); vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New (); vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
if (pointData.depth() == CV_32F) if (pointData.depth() == CV_32F)
points->SetDataTypeToFloat(); points->SetDataTypeToFloat();
@ -528,7 +576,7 @@ cv::viz::Text3DWidget::Text3DWidget(const String &text, const Point3f &position,
textSource->Update(); textSource->Update();
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New(); vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection (textSource->GetOutputPort()); mapper->SetInputConnection(textSource->GetOutputPort());
if (face_camera) if (face_camera)
{ {
@ -588,17 +636,17 @@ template<> cv::viz::Text3DWidget cv::viz::Widget::cast<cv::viz::Text3DWidget>()
cv::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(); vtkSmartPointer<vtkTextActor> actor = vtkSmartPointer<vtkTextActor>::New();
actor->SetPosition (pos.x, pos.y); actor->SetPosition(pos.x, pos.y);
actor->SetInput (text.c_str ()); actor->SetInput(text.c_str());
vtkSmartPointer<vtkTextProperty> tprop = actor->GetTextProperty (); vtkSmartPointer<vtkTextProperty> tprop = actor->GetTextProperty();
tprop->SetFontSize (font_size); tprop->SetFontSize(font_size);
tprop->SetFontFamilyToArial (); tprop->SetFontFamilyToArial();
tprop->SetJustificationToLeft (); tprop->SetJustificationToLeft();
tprop->BoldOn (); tprop->BoldOn();
Color c = vtkcolor(color); Color c = vtkcolor(color);
tprop->SetColor (c.val); tprop->SetColor(c.val);
WidgetAccessor::setProp(*this, actor); WidgetAccessor::setProp(*this, actor);
} }
@ -938,31 +986,31 @@ struct cv::viz::CameraPositionWidget::ProjectImage
cv::viz::CameraPositionWidget::CameraPositionWidget(double scale) cv::viz::CameraPositionWidget::CameraPositionWidget(double scale)
{ {
vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New (); vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
axes->SetOrigin (0, 0, 0); axes->SetOrigin(0, 0, 0);
axes->SetScaleFactor (scale); axes->SetScaleFactor(scale);
vtkSmartPointer<vtkFloatArray> axes_colors = vtkSmartPointer<vtkFloatArray>::New (); vtkSmartPointer<vtkFloatArray> axes_colors = vtkSmartPointer<vtkFloatArray>::New();
axes_colors->Allocate (6); axes_colors->Allocate(6);
axes_colors->InsertNextValue (0.0); axes_colors->InsertNextValue(0.0);
axes_colors->InsertNextValue (0.0); axes_colors->InsertNextValue(0.0);
axes_colors->InsertNextValue (0.5); axes_colors->InsertNextValue(0.5);
axes_colors->InsertNextValue (0.5); axes_colors->InsertNextValue(0.5);
axes_colors->InsertNextValue (1.0); axes_colors->InsertNextValue(1.0);
axes_colors->InsertNextValue (1.0); axes_colors->InsertNextValue(1.0);
vtkSmartPointer<vtkPolyData> axes_data = axes->GetOutput (); vtkSmartPointer<vtkPolyData> axes_data = axes->GetOutput();
axes_data->Update (); axes_data->Update();
axes_data->GetPointData ()->SetScalars (axes_colors); axes_data->GetPointData()->SetScalars(axes_colors);
vtkSmartPointer<vtkTubeFilter> axes_tubes = vtkSmartPointer<vtkTubeFilter>::New (); vtkSmartPointer<vtkTubeFilter> axes_tubes = vtkSmartPointer<vtkTubeFilter>::New();
axes_tubes->SetInput (axes_data); axes_tubes->SetInput(axes_data);
axes_tubes->SetRadius (axes->GetScaleFactor () / 50.0); axes_tubes->SetRadius(axes->GetScaleFactor() / 50.0);
axes_tubes->SetNumberOfSides (6); axes_tubes->SetNumberOfSides(6);
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetScalarModeToUsePointData (); mapper->SetScalarModeToUsePointData();
mapper->SetInput(axes_tubes->GetOutput ()); mapper->SetInput(axes_tubes->GetOutput());
vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New(); vtkSmartPointer<vtkLODActor> actor = vtkSmartPointer<vtkLODActor>::New();
actor->SetMapper(mapper); actor->SetMapper(mapper);
@ -1122,9 +1170,9 @@ cv::viz::TrajectoryWidget::TrajectoryWidget(const std::vector<Affine3f> &path, i
// Create a poly line along the path // Create a poly line along the path
vtkIdType nr_points = path.size(); vtkIdType nr_points = path.size();
vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New (); vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New (); vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New (); vtkSmartPointer<vtkPolyLine> polyLine = vtkSmartPointer<vtkPolyLine>::New();
points->SetDataTypeToFloat(); points->SetDataTypeToFloat();
points->SetNumberOfPoints(nr_points); points->SetNumberOfPoints(nr_points);
@ -1161,10 +1209,10 @@ cv::viz::TrajectoryWidget::TrajectoryWidget(const std::vector<Affine3f> &path, i
{ {
// Create frames and transform along the path // Create frames and transform along the path
vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New(); vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New();
axes->SetOrigin (0, 0, 0); axes->SetOrigin(0, 0, 0);
axes->SetScaleFactor (scale); axes->SetScaleFactor(scale);
vtkSmartPointer<vtkUnsignedCharArray> axes_colors = vtkSmartPointer<vtkUnsignedCharArray>::New (); vtkSmartPointer<vtkUnsignedCharArray> axes_colors = vtkSmartPointer<vtkUnsignedCharArray>::New();
axes_colors->SetNumberOfComponents(3); axes_colors->SetNumberOfComponents(3);
axes_colors->InsertNextTuple3(255,0,0); axes_colors->InsertNextTuple3(255,0,0);
axes_colors->InsertNextTuple3(255,0,0); axes_colors->InsertNextTuple3(255,0,0);
@ -1173,21 +1221,21 @@ cv::viz::TrajectoryWidget::TrajectoryWidget(const std::vector<Affine3f> &path, i
axes_colors->InsertNextTuple3(0,0,255); axes_colors->InsertNextTuple3(0,0,255);
axes_colors->InsertNextTuple3(0,0,255); axes_colors->InsertNextTuple3(0,0,255);
vtkSmartPointer<vtkPolyData> axes_data = axes->GetOutput (); vtkSmartPointer<vtkPolyData> axes_data = axes->GetOutput();
axes_data->Update (); axes_data->Update();
axes_data->GetPointData ()->SetScalars (axes_colors); axes_data->GetPointData()->SetScalars(axes_colors);
vtkSmartPointer<vtkTubeFilter> axes_tubes = vtkSmartPointer<vtkTubeFilter>::New (); vtkSmartPointer<vtkTubeFilter> axes_tubes = vtkSmartPointer<vtkTubeFilter>::New();
axes_tubes->SetInput (axes_data); axes_tubes->SetInput(axes_data);
axes_tubes->SetRadius (axes->GetScaleFactor() / 50.0); axes_tubes->SetRadius(axes->GetScaleFactor() / 50.0);
axes_tubes->SetNumberOfSides (6); axes_tubes->SetNumberOfSides(6);
axes_tubes->Update(); axes_tubes->Update();
ApplyPath::applyPath(axes_tubes->GetOutput(), appendFilter, path); ApplyPath::applyPath(axes_tubes->GetOutput(), appendFilter, path);
} }
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New(); vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetScalarModeToUsePointData (); mapper->SetScalarModeToUsePointData();
mapper->SetInput(appendFilter->GetOutput()); mapper->SetInput(appendFilter->GetOutput());
vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New(); vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
@ -1329,7 +1377,7 @@ cv::viz::SpheresTrajectoryWidget::SpheresTrajectoryWidget(const std::vector<Affi
Point3f new_pos = path[i].translation(); Point3f new_pos = path[i].translation();
vtkSmartPointer<vtkSphereSource> sphere_source = vtkSmartPointer<vtkSphereSource>::New(); vtkSmartPointer<vtkSphereSource> sphere_source = vtkSmartPointer<vtkSphereSource>::New();
sphere_source->SetCenter (new_pos.x, new_pos.y, new_pos.z); sphere_source->SetCenter(new_pos.x, new_pos.y, new_pos.z);
if (i == 0) if (i == 0)
{ {
sphere_source->SetRadius(init_sphere_radius); sphere_source->SetRadius(init_sphere_radius);

92
modules/viz/src/types.cpp
View File

@ -1,3 +1,51 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp" #include "precomp.hpp"
////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////
@ -23,8 +71,8 @@ cv::viz::Color cv::viz::Color::gray() { return Color(128, 128, 128); }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
/// cv::viz::KeyboardEvent /// cv::viz::KeyboardEvent
cv::viz::KeyboardEvent::KeyboardEvent (bool _action, const std::string& _key_sym, unsigned char key, bool alt, bool ctrl, bool shift) 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) : action_(_action), modifiers_(0), key_code_(key), key_sym_(_key_sym)
{ {
if (alt) if (alt)
modifiers_ = Alt; modifiers_ = Alt;
@ -36,18 +84,18 @@ cv::viz::KeyboardEvent::KeyboardEvent (bool _action, const std::string& _key_sym
modifiers_ |= Shift; modifiers_ |= Shift;
} }
bool cv::viz::KeyboardEvent::isAltPressed () const { return (modifiers_ & Alt) != 0; } bool cv::viz::KeyboardEvent::isAltPressed() const { return (modifiers_ & Alt) != 0; }
bool cv::viz::KeyboardEvent::isCtrlPressed () const { return (modifiers_ & Ctrl) != 0; } bool cv::viz::KeyboardEvent::isCtrlPressed() const { return (modifiers_ & Ctrl) != 0; }
bool cv::viz::KeyboardEvent::isShiftPressed () const { return (modifiers_ & Shift) != 0; } bool cv::viz::KeyboardEvent::isShiftPressed() const { return (modifiers_ & Shift) != 0; }
unsigned char cv::viz::KeyboardEvent::getKeyCode () const { return key_code_; } unsigned char cv::viz::KeyboardEvent::getKeyCode() const { return key_code_; }
const cv::String& cv::viz::KeyboardEvent::getKeySym () const { return key_sym_; } const cv::String& cv::viz::KeyboardEvent::getKeySym() const { return key_sym_; }
bool cv::viz::KeyboardEvent::keyDown () const { return action_; } bool cv::viz::KeyboardEvent::keyDown() const { return action_; }
bool cv::viz::KeyboardEvent::keyUp () const { return !action_; } bool cv::viz::KeyboardEvent::keyUp() const { return !action_; }
//////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////
/// cv::viz::MouseEvent /// cv::viz::MouseEvent
cv::viz::MouseEvent::MouseEvent (const Type& _type, const MouseButton& _button, const Point& _p, bool alt, bool ctrl, bool shift) 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) : type(_type), button(_button), pointer(_p), key_state(0)
{ {
if (alt) if (alt)
@ -73,19 +121,19 @@ struct cv::viz::Mesh3d::loadMeshImpl
reader->SetFileName(file.c_str()); reader->SetFileName(file.c_str());
reader->Update(); reader->Update();
vtkSmartPointer<vtkPolyData> poly_data = reader->GetOutput (); vtkSmartPointer<vtkPolyData> poly_data = reader->GetOutput();
CV_Assert("File does not exist or file format is not supported." && poly_data); CV_Assert("File does not exist or file format is not supported." && poly_data);
vtkSmartPointer<vtkPoints> mesh_points = poly_data->GetPoints (); vtkSmartPointer<vtkPoints> mesh_points = poly_data->GetPoints();
vtkIdType nr_points = mesh_points->GetNumberOfPoints (); vtkIdType nr_points = mesh_points->GetNumberOfPoints();
mesh.cloud.create(1, nr_points, CV_32FC3); mesh.cloud.create(1, nr_points, CV_32FC3);
Vec3f *mesh_cloud = mesh.cloud.ptr<Vec3f>(); Vec3f *mesh_cloud = mesh.cloud.ptr<Vec3f>();
for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints (); i++) for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints(); i++)
{ {
Vec3d point; Vec3d point;
mesh_points->GetPoint (i, point.val); mesh_points->GetPoint(i, point.val);
mesh_cloud[i] = point; mesh_cloud[i] = point;
} }
@ -94,15 +142,15 @@ struct cv::viz::Mesh3d::loadMeshImpl
if (poly_data->GetPointData()) if (poly_data->GetPointData())
poly_colors = vtkUnsignedCharArray::SafeDownCast(poly_data->GetPointData()->GetScalars()); poly_colors = vtkUnsignedCharArray::SafeDownCast(poly_data->GetPointData()->GetScalars());
if (poly_colors && (poly_colors->GetNumberOfComponents () == 3)) if (poly_colors && (poly_colors->GetNumberOfComponents() == 3))
{ {
mesh.colors.create(1, nr_points, CV_8UC3); mesh.colors.create(1, nr_points, CV_8UC3);
Vec3b *mesh_colors = mesh.colors.ptr<cv::Vec3b>(); Vec3b *mesh_colors = mesh.colors.ptr<cv::Vec3b>();
for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints (); i++) for (vtkIdType i = 0; i < mesh_points->GetNumberOfPoints(); i++)
{ {
Vec3b point_color; Vec3b point_color;
poly_colors->GetTupleValue (i, point_color.val); poly_colors->GetTupleValue(i, point_color.val);
std::swap(point_color[0], point_color[2]); // RGB -> BGR std::swap(point_color[0], point_color[2]); // RGB -> BGR
mesh_colors[i] = point_color; mesh_colors[i] = point_color;
@ -114,17 +162,17 @@ struct cv::viz::Mesh3d::loadMeshImpl
// Now handle the polygons // Now handle the polygons
vtkIdType* cell_points; vtkIdType* cell_points;
vtkIdType nr_cell_points; vtkIdType nr_cell_points;
vtkCellArray * mesh_polygons = poly_data->GetPolys (); vtkCellArray * mesh_polygons = poly_data->GetPolys();
mesh_polygons->InitTraversal (); mesh_polygons->InitTraversal();
mesh.polygons.create(1, mesh_polygons->GetSize(), CV_32SC1); mesh.polygons.create(1, mesh_polygons->GetSize(), CV_32SC1);
int* polygons = mesh.polygons.ptr<int>(); int* polygons = mesh.polygons.ptr<int>();
while (mesh_polygons->GetNextCell (nr_cell_points, cell_points)) while (mesh_polygons->GetNextCell(nr_cell_points, cell_points))
{ {
*polygons++ = nr_cell_points; *polygons++ = nr_cell_points;
for (int i = 0; i < nr_cell_points; ++i) for (int i = 0; i < nr_cell_points; ++i)
*polygons++ = static_cast<int> (cell_points[i]); *polygons++ = static_cast<int>(cell_points[i]);
} }
return mesh; return mesh;

53
modules/viz/src/viz.cpp
View File

@ -1,5 +1,52 @@
#include "precomp.hpp" /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp"
cv::Affine3f cv::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)
{ {
@ -44,7 +91,7 @@ cv::Affine3f cv::viz::makeCameraPose(const Vec3f& position, const Vec3f& focal_p
return pose_mat; return pose_mat;
} }
vtkSmartPointer<vtkMatrix4x4> cv::viz::convertToVtkMatrix (const cv::Matx44f &m) vtkSmartPointer<vtkMatrix4x4> cv::viz::convertToVtkMatrix(const cv::Matx44f &m)
{ {
vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New(); vtkSmartPointer<vtkMatrix4x4> vtk_matrix = vtkSmartPointer<vtkMatrix4x4>::New();
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
@ -58,7 +105,7 @@ cv::Matx44f cv::viz::convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matr
cv::Matx44f m; cv::Matx44f m;
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
for (int k = 0; k < 4; k++) for (int k = 0; k < 4; k++)
m(i, k) = vtk_matrix->GetElement (i, k); m(i, k) = vtk_matrix->GetElement(i, k);
return m; return m;
} }

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

@ -1,7 +1,54 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include <opencv2/viz/viz3d.hpp> #include <opencv2/viz/viz3d.hpp>
#include "viz3d_impl.hpp" #include "viz3d_impl.hpp"
cv::viz::Viz3d::Viz3d(const String& window_name) : impl_(0) { create(window_name); } cv::viz::Viz3d::Viz3d(const String& window_name) : impl_(0) { create(window_name); }
cv::viz::Viz3d::Viz3d(const Viz3d& other) : impl_(other.impl_) cv::viz::Viz3d::Viz3d(const Viz3d& other) : impl_(other.impl_)
@ -45,7 +92,7 @@ void cv::viz::Viz3d::release()
} }
void cv::viz::Viz3d::spin() { impl_->spin(); } 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::spinOnce(int time, bool force_redraw) { impl_->spinOnce(time, force_redraw); }
bool cv::viz::Viz3d::wasStopped() const { return impl_->wasStopped(); } bool cv::viz::Viz3d::wasStopped() const { return impl_->wasStopped(); }
void cv::viz::Viz3d::registerKeyboardCallback(KeyboardCallback callback, void* cookie) void cv::viz::Viz3d::registerKeyboardCallback(KeyboardCallback callback, void* cookie)
@ -67,7 +114,7 @@ cv::viz::Camera cv::viz::Viz3d::getCamera() const { return impl_->getCamera(); }
void cv::viz::Viz3d::setViewerPose(const Affine3f &pose) { impl_->setViewerPose(pose); } void cv::viz::Viz3d::setViewerPose(const Affine3f &pose) { impl_->setViewerPose(pose); }
cv::Affine3f cv::viz::Viz3d::getViewerPose() { return impl_->getViewerPose(); } cv::Affine3f cv::viz::Viz3d::getViewerPose() { return impl_->getViewerPose(); }
void cv::viz::Viz3d::resetCameraViewpoint (const String &id) { impl_->resetCameraViewpoint(id); } void cv::viz::Viz3d::resetCameraViewpoint(const String &id) { impl_->resetCameraViewpoint(id); }
void cv::viz::Viz3d::resetCamera() { impl_->resetCamera(); } void cv::viz::Viz3d::resetCamera() { impl_->resetCamera(); }
void cv::viz::Viz3d::convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord) { impl_->convertToWindowCoordinates(pt, window_coord); } void cv::viz::Viz3d::convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord) { impl_->convertToWindowCoordinates(pt, window_coord); }
@ -76,9 +123,9 @@ void cv::viz::Viz3d::converTo3DRay(const Point3d &window_coord, Point3d &origin,
cv::Size cv::viz::Viz3d::getWindowSize() const { return impl_->getWindowSize(); } cv::Size cv::viz::Viz3d::getWindowSize() const { return impl_->getWindowSize(); }
void cv::viz::Viz3d::setWindowSize(const Size &window_size) { impl_->setWindowSize(window_size.width, window_size.height); } void cv::viz::Viz3d::setWindowSize(const Size &window_size) { impl_->setWindowSize(window_size.width, window_size.height); }
cv::String cv::viz::Viz3d::getWindowName() const { return impl_->getWindowName(); } cv::String cv::viz::Viz3d::getWindowName() const { return impl_->getWindowName(); }
void cv::viz::Viz3d::saveScreenshot (const String &file) { impl_->saveScreenshot(file); } void cv::viz::Viz3d::saveScreenshot(const String &file) { impl_->saveScreenshot(file); }
void cv::viz::Viz3d::setWindowPosition (int x, int y) { impl_->setWindowPosition(x,y); } void cv::viz::Viz3d::setWindowPosition(int x, int y) { impl_->setWindowPosition(x,y); }
void cv::viz::Viz3d::setFullScreen (bool mode) { impl_->setFullScreen(mode); } void cv::viz::Viz3d::setFullScreen(bool mode) { impl_->setFullScreen(mode); }
void cv::viz::Viz3d::setBackgroundColor(const Color& color) { impl_->setBackgroundColor(color); } void cv::viz::Viz3d::setBackgroundColor(const Color& color) { impl_->setBackgroundColor(color); }
void cv::viz::Viz3d::setRenderingProperty(const String &id, int property, double value) { getWidget(id).setRenderingProperty(property, value); } void cv::viz::Viz3d::setRenderingProperty(const String &id, int property, double value) { getWidget(id).setRenderingProperty(property, value); }

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

@ -1,81 +1,129 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp" #include "precomp.hpp"
#include "viz3d_impl.hpp" #include "viz3d_impl.hpp"
#include <vtkRenderWindowInteractor.h> #include <vtkRenderWindowInteractor.h>
#if 1 || !defined __APPLE__ #if 1 || !defined __APPLE__
vtkRenderWindowInteractor* vtkRenderWindowInteractorFixNew () vtkRenderWindowInteractor* vtkRenderWindowInteractorFixNew()
{ {
return vtkRenderWindowInteractor::New(); return vtkRenderWindowInteractor::New();
} }
#endif #endif
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
cv::viz::Viz3d::VizImpl::VizImpl (const std::string &name) cv::viz::Viz3d::VizImpl::VizImpl(const std::string &name)
: style_ (vtkSmartPointer<cv::viz::InteractorStyle>::New ()) : style_(vtkSmartPointer<cv::viz::InteractorStyle>::New())
, widget_actor_map_ (new WidgetActorMap) , widget_actor_map_(new WidgetActorMap)
, s_lastDone_(0.0) , s_lastDone_(0.0)
{ {
renderer_ = vtkSmartPointer<vtkRenderer>::New (); renderer_ = vtkSmartPointer<vtkRenderer>::New();
// Create a RendererWindow // Create a RendererWindow
window_ = vtkSmartPointer<vtkRenderWindow>::New (); window_ = vtkSmartPointer<vtkRenderWindow>::New();
// Set the window size as 1/2 of the screen size // Set the window size as 1/2 of the screen size
cv::Vec2i window_size = cv::Vec2i(window_->GetScreenSize()) / 2; cv::Vec2i window_size = cv::Vec2i(window_->GetScreenSize()) / 2;
window_->SetSize (window_size.val); window_->SetSize(window_size.val);
window_->AddRenderer (renderer_); window_->AddRenderer(renderer_);
// Create the interactor style // Create the interactor style
style_->Initialize (); style_->Initialize();
style_->setRenderer (renderer_); style_->setRenderer(renderer_);
style_->setWidgetActorMap (widget_actor_map_); style_->setWidgetActorMap(widget_actor_map_);
style_->UseTimersOn (); style_->UseTimersOn();
///////////////////////////////////////////////// /////////////////////////////////////////////////
interactor_ = vtkSmartPointer <vtkRenderWindowInteractor>::Take (vtkRenderWindowInteractorFixNew ()); interactor_ = vtkSmartPointer <vtkRenderWindowInteractor>::Take(vtkRenderWindowInteractorFixNew());
window_->AlphaBitPlanesOff (); window_->AlphaBitPlanesOff();
window_->PointSmoothingOff (); window_->PointSmoothingOff();
window_->LineSmoothingOff (); window_->LineSmoothingOff();
window_->PolygonSmoothingOff (); window_->PolygonSmoothingOff();
window_->SwapBuffersOn (); window_->SwapBuffersOn();
window_->SetStereoTypeToAnaglyph (); window_->SetStereoTypeToAnaglyph();
interactor_->SetRenderWindow (window_); interactor_->SetRenderWindow(window_);
interactor_->SetInteractorStyle (style_); interactor_->SetInteractorStyle(style_);
interactor_->SetDesiredUpdateRate (30.0); interactor_->SetDesiredUpdateRate(30.0);
// Initialize and create timer, also create window // Initialize and create timer, also create window
interactor_->Initialize (); interactor_->Initialize();
timer_id_ = interactor_->CreateRepeatingTimer (5000L); timer_id_ = interactor_->CreateRepeatingTimer(5000L);
// Set a simple PointPicker // Set a simple PointPicker
vtkSmartPointer<vtkPointPicker> pp = vtkSmartPointer<vtkPointPicker>::New (); vtkSmartPointer<vtkPointPicker> pp = vtkSmartPointer<vtkPointPicker>::New();
pp->SetTolerance (pp->GetTolerance () * 2); pp->SetTolerance(pp->GetTolerance() * 2);
interactor_->SetPicker (pp); interactor_->SetPicker(pp);
exit_main_loop_timer_callback_ = vtkSmartPointer<ExitMainLoopTimerCallback>::New (); exit_main_loop_timer_callback_ = vtkSmartPointer<ExitMainLoopTimerCallback>::New();
exit_main_loop_timer_callback_->viz_ = this; exit_main_loop_timer_callback_->viz_ = this;
exit_main_loop_timer_callback_->right_timer_id = -1; exit_main_loop_timer_callback_->right_timer_id = -1;
interactor_->AddObserver (vtkCommand::TimerEvent, exit_main_loop_timer_callback_); interactor_->AddObserver(vtkCommand::TimerEvent, exit_main_loop_timer_callback_);
exit_callback_ = vtkSmartPointer<ExitCallback>::New (); exit_callback_ = vtkSmartPointer<ExitCallback>::New();
exit_callback_->viz_ = this; exit_callback_->viz_ = this;
interactor_->AddObserver (vtkCommand::ExitEvent, exit_callback_); interactor_->AddObserver(vtkCommand::ExitEvent, exit_callback_);
resetStoppedFlag (); resetStoppedFlag();
////////////////////////////// //////////////////////////////
String window_name; String window_name;
VizAccessor::generateWindowName(name, window_name); VizAccessor::generateWindowName(name, window_name);
window_->SetWindowName (window_name.c_str ()); window_->SetWindowName(window_name.c_str());
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
cv::viz::Viz3d::VizImpl::~VizImpl () cv::viz::Viz3d::VizImpl::~VizImpl()
{ {
if (interactor_) if (interactor_)
interactor_->DestroyTimer(timer_id_); interactor_->DestroyTimer(timer_id_);
@ -98,7 +146,7 @@ void cv::viz::Viz3d::VizImpl::showWidget(const String &id, const Widget &widget,
{ {
// If the actor is 3D, apply pose // If the actor is 3D, apply pose
vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix); vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
actor->SetUserMatrix (matrix); actor->SetUserMatrix(matrix);
actor->Modified(); actor->Modified();
} }
// If the actor is a vtkFollower, then it should always face the camera // If the actor is a vtkFollower, then it should always face the camera
@ -118,7 +166,7 @@ void cv::viz::Viz3d::VizImpl::removeWidget(const String &id)
WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id); WidgetActorMap::iterator wam_itr = widget_actor_map_->find(id);
bool exists = wam_itr != widget_actor_map_->end(); bool exists = wam_itr != widget_actor_map_->end();
CV_Assert("Widget does not exist." && exists); CV_Assert("Widget does not exist." && exists);
CV_Assert("Widget could not be removed." && removeActorFromRenderer (wam_itr->second)); CV_Assert("Widget could not be removed." && removeActorFromRenderer(wam_itr->second));
widget_actor_map_->erase(wam_itr); widget_actor_map_->erase(wam_itr);
} }
@ -145,8 +193,8 @@ void cv::viz::Viz3d::VizImpl::setWidgetPose(const String &id, const Affine3f &po
CV_Assert("Widget is not 3D." && actor); CV_Assert("Widget is not 3D." && actor);
vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix); vtkSmartPointer<vtkMatrix4x4> matrix = convertToVtkMatrix(pose.matrix);
actor->SetUserMatrix (matrix); actor->SetUserMatrix(matrix);
actor->Modified (); actor->Modified();
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
@ -169,8 +217,8 @@ void cv::viz::Viz3d::VizImpl::updateWidgetPose(const String &id, const Affine3f
Affine3f updated_pose = pose * Affine3f(matrix_cv); Affine3f updated_pose = pose * Affine3f(matrix_cv);
matrix = convertToVtkMatrix(updated_pose.matrix); matrix = convertToVtkMatrix(updated_pose.matrix);
actor->SetUserMatrix (matrix); actor->SetUserMatrix(matrix);
actor->Modified (); actor->Modified();
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
@ -204,7 +252,7 @@ double cv::viz::Viz3d::VizImpl::getDesiredUpdateRate()
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
void cv::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 cv::viz::Viz3d::VizImpl::registerMouseCallback(MouseCallback callback, void* cookie) void cv::viz::Viz3d::VizImpl::registerMouseCallback(MouseCallback callback, void* cookie)
@ -214,33 +262,33 @@ void cv::viz::Viz3d::VizImpl::registerKeyboardCallback(KeyboardCallback callback
{ style_->registerKeyboardCallback(callback, cookie); } { style_->registerKeyboardCallback(callback, cookie); }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::spin () void cv::viz::Viz3d::VizImpl::spin()
{ {
resetStoppedFlag (); resetStoppedFlag();
window_->Render (); window_->Render();
interactor_->Start (); interactor_->Start();
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::spinOnce (int time, bool force_redraw) void cv::viz::Viz3d::VizImpl::spinOnce(int time, bool force_redraw)
{ {
resetStoppedFlag (); resetStoppedFlag();
if (time <= 0) if (time <= 0)
time = 1; time = 1;
if (force_redraw) if (force_redraw)
interactor_->Render (); interactor_->Render();
double s_now_ = cv::getTickCount() / cv::getTickFrequency(); double s_now_ = cv::getTickCount() / cv::getTickFrequency();
if (s_lastDone_ > s_now_) if (s_lastDone_ > s_now_)
s_lastDone_ = s_now_; s_lastDone_ = s_now_;
if ((s_now_ - s_lastDone_) > (1.0 / interactor_->GetDesiredUpdateRate ())) if ((s_now_ - s_lastDone_) > (1.0 / interactor_->GetDesiredUpdateRate()))
{ {
exit_main_loop_timer_callback_->right_timer_id = interactor_->CreateRepeatingTimer (time); exit_main_loop_timer_callback_->right_timer_id = interactor_->CreateRepeatingTimer(time);
interactor_->Start (); interactor_->Start();
interactor_->DestroyTimer (exit_main_loop_timer_callback_->right_timer_id); interactor_->DestroyTimer(exit_main_loop_timer_callback_->right_timer_id);
s_lastDone_ = s_now_; s_lastDone_ = s_now_;
} }
} }
@ -253,67 +301,63 @@ void cv::viz::Viz3d::VizImpl::removeAllWidgets()
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
bool cv::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); vtkProp* actor_to_remove = vtkProp::SafeDownCast(actor);
vtkPropCollection* actors = renderer_->GetViewProps (); vtkPropCollection* actors = renderer_->GetViewProps();
actors->InitTraversal (); actors->InitTraversal();
vtkProp* current_actor = NULL; vtkProp* current_actor = NULL;
while ((current_actor = actors->GetNextProp ()) != NULL) while ((current_actor = actors->GetNextProp()) != NULL)
{ {
if (current_actor != actor_to_remove) if (current_actor != actor_to_remove)
continue; continue;
renderer_->RemoveActor (actor); renderer_->RemoveActor(actor);
return true; return true;
} }
return false; return false;
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
void cv::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) if (!actor)
actor = vtkSmartPointer<vtkLODActor>::New (); actor = vtkSmartPointer<vtkLODActor>::New();
vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New (); vtkSmartPointer<vtkDataSetMapper> mapper = vtkSmartPointer<vtkDataSetMapper>::New();
mapper->SetInput (data); mapper->SetInput(data);
if (use_scalars) if (use_scalars)
{ {
vtkSmartPointer<vtkDataArray> scalars = data->GetPointData ()->GetScalars (); vtkSmartPointer<vtkDataArray> scalars = data->GetPointData()->GetScalars();
if (scalars) if (scalars)
{ {
cv::Vec3d minmax(scalars->GetRange()); cv::Vec3d minmax(scalars->GetRange());
mapper->SetScalarRange(minmax.val); mapper->SetScalarRange(minmax.val);
mapper->SetScalarModeToUsePointData (); mapper->SetScalarModeToUsePointData();
// interpolation OFF, if data is a vtkPolyData that contains only vertices, ON for anything else. // interpolation OFF, if data is a vtkPolyData that contains only vertices, ON for anything else.
vtkPolyData* polyData = vtkPolyData::SafeDownCast (data); vtkPolyData* polyData = vtkPolyData::SafeDownCast(data);
bool interpolation = (polyData && polyData->GetNumberOfCells () != polyData->GetNumberOfVerts ()); bool interpolation = (polyData && polyData->GetNumberOfCells() != polyData->GetNumberOfVerts());
mapper->SetInterpolateScalarsBeforeMapping (interpolation); mapper->SetInterpolateScalarsBeforeMapping(interpolation);
mapper->ScalarVisibilityOn (); mapper->ScalarVisibilityOn();
} }
} }
mapper->ImmediateModeRenderingOff (); mapper->ImmediateModeRenderingOff();
actor->SetNumberOfCloudPoints (int (std::max<vtkIdType> (1, data->GetNumberOfPoints () / 10))); actor->SetNumberOfCloudPoints(int(std::max<vtkIdType>(1, data->GetNumberOfPoints() / 10)));
actor->GetProperty ()->SetInterpolationToFlat (); actor->GetProperty()->SetInterpolationToFlat();
actor->GetProperty()->BackfaceCullingOn();
/// FIXME disabling backface culling due to known VTK bug: vtkTextActors are not actor->SetMapper(mapper);
/// shown when there is a vtkActor with backface culling on present in the scene
/// Please see VTK bug tracker for more details: http://www.vtk.org/Bug/view.php?id=12588
// actor->GetProperty ()->BackfaceCullingOn ();
actor->SetMapper (mapper);
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::setBackgroundColor (const Color& color) void cv::viz::Viz3d::VizImpl::setBackgroundColor(const Color& color)
{ {
Color c = vtkcolor(color); Color c = vtkcolor(color);
renderer_->SetBackground (c.val); renderer_->SetBackground(c.val);
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
@ -322,7 +366,7 @@ void cv::viz::Viz3d::VizImpl::setCamera(const Camera &camera)
vtkCamera& active_camera = *renderer_->GetActiveCamera(); vtkCamera& active_camera = *renderer_->GetActiveCamera();
// Set the intrinsic parameters of the camera // Set the intrinsic parameters of the camera
window_->SetSize (camera.getWindowSize().width, camera.getWindowSize().height); window_->SetSize(camera.getWindowSize().width, camera.getWindowSize().height);
double aspect_ratio = static_cast<double>(camera.getWindowSize().width)/static_cast<double>(camera.getWindowSize().height); double aspect_ratio = static_cast<double>(camera.getWindowSize().width)/static_cast<double>(camera.getWindowSize().height);
Matx44f proj_mat; Matx44f proj_mat;
@ -353,18 +397,18 @@ cv::viz::Camera cv::viz::Viz3d::VizImpl::getCamera() const
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::setViewerPose(const Affine3f &pose) void cv::viz::Viz3d::VizImpl::setViewerPose(const Affine3f &pose)
{ {
vtkCamera& camera = *renderer_->GetActiveCamera (); vtkCamera& camera = *renderer_->GetActiveCamera();
// Position = extrinsic translation // Position = extrinsic translation
cv::Vec3f pos_vec = pose.translation(); cv::Vec3f pos_vec = pose.translation();
// Rotate the view vector // Rotate the view vector
cv::Matx33f rotation = pose.rotation(); cv::Matx33f rotation = pose.rotation();
cv::Vec3f y_axis (0.f, 1.f, 0.f); cv::Vec3f y_axis(0.f, 1.f, 0.f);
cv::Vec3f up_vec (rotation * y_axis); cv::Vec3f up_vec(rotation * y_axis);
// Compute the new focal point // Compute the new focal point
cv::Vec3f z_axis (0.f, 0.f, 1.f); cv::Vec3f z_axis(0.f, 0.f, 1.f);
cv::Vec3f focal_vec = pos_vec + rotation * z_axis; cv::Vec3f focal_vec = pos_vec + rotation * z_axis;
camera.SetPosition(pos_vec[0], pos_vec[1], pos_vec[2]); camera.SetPosition(pos_vec[0], pos_vec[1], pos_vec[2]);
@ -373,9 +417,9 @@ void cv::viz::Viz3d::VizImpl::setViewerPose(const Affine3f &pose)
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
cv::Affine3f cv::viz::Viz3d::VizImpl::getViewerPose () cv::Affine3f cv::viz::Viz3d::VizImpl::getViewerPose()
{ {
vtkCamera& camera = *renderer_->GetActiveCamera (); vtkCamera& camera = *renderer_->GetActiveCamera();
Vec3d pos(camera.GetPosition()); Vec3d pos(camera.GetPosition());
Vec3d view_up(camera.GetViewUp()); Vec3d view_up(camera.GetViewUp());
@ -423,11 +467,11 @@ void cv::viz::Viz3d::VizImpl::converTo3DRay(const Point3d &window_coord, Point3d
} }
///////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::resetCameraViewpoint (const String &id) void cv::viz::Viz3d::VizImpl::resetCameraViewpoint(const String &id)
{ {
vtkSmartPointer<vtkMatrix4x4> camera_pose; vtkSmartPointer<vtkMatrix4x4> camera_pose;
static WidgetActorMap::iterator it = widget_actor_map_->find (id); static WidgetActorMap::iterator it = widget_actor_map_->find(id);
if (it != widget_actor_map_->end ()) if (it != widget_actor_map_->end())
{ {
vtkProp3D *actor = vtkProp3D::SafeDownCast(it->second); vtkProp3D *actor = vtkProp3D::SafeDownCast(it->second);
CV_Assert("Widget is not 3D." && actor); CV_Assert("Widget is not 3D." && actor);
@ -439,22 +483,22 @@ void cv::viz::Viz3d::VizImpl::resetCameraViewpoint (const String &id)
// Prevent a segfault // Prevent a segfault
if (!camera_pose) return; if (!camera_pose) return;
vtkSmartPointer<vtkCamera> cam = renderer_->GetActiveCamera (); vtkSmartPointer<vtkCamera> cam = renderer_->GetActiveCamera();
cam->SetPosition (camera_pose->GetElement (0, 3), cam->SetPosition(camera_pose->GetElement(0, 3),
camera_pose->GetElement (1, 3), camera_pose->GetElement(1, 3),
camera_pose->GetElement (2, 3)); camera_pose->GetElement(2, 3));
cam->SetFocalPoint (camera_pose->GetElement (0, 3) - camera_pose->GetElement (0, 2), cam->SetFocalPoint(camera_pose->GetElement(0, 3) - camera_pose->GetElement(0, 2),
camera_pose->GetElement (1, 3) - camera_pose->GetElement (1, 2), camera_pose->GetElement(1, 3) - camera_pose->GetElement(1, 2),
camera_pose->GetElement (2, 3) - camera_pose->GetElement (2, 2)); camera_pose->GetElement(2, 3) - camera_pose->GetElement(2, 2));
cam->SetViewUp (camera_pose->GetElement (0, 1), cam->SetViewUp(camera_pose->GetElement(0, 1),
camera_pose->GetElement (1, 1), camera_pose->GetElement(1, 1),
camera_pose->GetElement (2, 1)); camera_pose->GetElement(2, 1));
renderer_->SetActiveCamera (cam); renderer_->SetActiveCamera(cam);
renderer_->ResetCameraClippingRange (); renderer_->ResetCameraClippingRange();
renderer_->Render (); renderer_->Render();
} }
/////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////
@ -493,53 +537,53 @@ void cv::viz::Viz3d::VizImpl::setRepresentation(int representation)
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::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 no init cells and cells has not been initialized...
if (!cells) if (!cells)
cells = vtkSmartPointer<vtkIdTypeArray>::New (); cells = vtkSmartPointer<vtkIdTypeArray>::New();
// If we have less values then we need to recreate the array // If we have less values then we need to recreate the array
if (cells->GetNumberOfTuples () < nr_points) if (cells->GetNumberOfTuples() < nr_points)
{ {
cells = vtkSmartPointer<vtkIdTypeArray>::New (); cells = vtkSmartPointer<vtkIdTypeArray>::New();
// If init cells is given, and there's enough data in it, use it // If init cells is given, and there's enough data in it, use it
if (initcells && initcells->GetNumberOfTuples () >= nr_points) if (initcells && initcells->GetNumberOfTuples() >= nr_points)
{ {
cells->DeepCopy (initcells); cells->DeepCopy(initcells);
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
} }
else else
{ {
// If the number of tuples is still too small, we need to recreate the array // If the number of tuples is still too small, we need to recreate the array
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
vtkIdType *cell = cells->GetPointer (0); vtkIdType *cell = cells->GetPointer(0);
// Fill it with 1s // Fill it with 1s
std::fill_n (cell, nr_points * 2, 1); std::fill_n(cell, nr_points * 2, 1);
cell++; cell++;
for (vtkIdType i = 0; i < nr_points; ++i, cell += 2) for (vtkIdType i = 0; i < nr_points; ++i, cell += 2)
*cell = i; *cell = i;
// Save the results in initcells // Save the results in initcells
initcells = vtkSmartPointer<vtkIdTypeArray>::New (); initcells = vtkSmartPointer<vtkIdTypeArray>::New();
initcells->DeepCopy (cells); initcells->DeepCopy(cells);
} }
} }
else else
{ {
// The assumption here is that the current set of cells has more data than needed // The assumption here is that the current set of cells has more data than needed
cells->SetNumberOfComponents (2); cells->SetNumberOfComponents(2);
cells->SetNumberOfTuples (nr_points); cells->SetNumberOfTuples(nr_points);
} }
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::setFullScreen (bool mode) void cv::viz::Viz3d::VizImpl::setFullScreen(bool mode)
{ {
if (window_) if (window_)
window_->SetFullScreen (mode); window_->SetFullScreen(mode);
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
@ -549,6 +593,6 @@ cv::String cv::viz::Viz3d::VizImpl::getWindowName() const
} }
////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////
void cv::viz::Viz3d::VizImpl::setWindowPosition (int x, int y) { window_->SetPosition (x, y); } void cv::viz::Viz3d::VizImpl::setWindowPosition(int x, int y) { window_->SetPosition(x, y); }
void cv::viz::Viz3d::VizImpl::setWindowSize (int xw, int yw) { window_->SetSize (xw, yw); } void cv::viz::Viz3d::VizImpl::setWindowSize(int xw, int yw) { window_->SetSize(xw, yw); }
cv::Size cv::viz::Viz3d::VizImpl::getWindowSize() const { return Size(window_->GetSize()[0], window_->GetSize()[1]); } cv::Size cv::viz::Viz3d::VizImpl::getWindowSize() const { return Size(window_->GetSize()[0], window_->GetSize()[1]); }

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

@ -1,4 +1,53 @@
#pragma once /*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifndef __OPENCV_VIZ_VIZ3D_IMPL_HPP__
#define __OPENCV_VIZ_VIZ3D_IMPL_HPP__
#include <opencv2/viz.hpp> #include <opencv2/viz.hpp>
#include "interactor_style.h" #include "interactor_style.h"
@ -12,8 +61,8 @@ public:
int ref_counter; int ref_counter;
VizImpl (const String &name); VizImpl(const String &name);
virtual ~VizImpl (); virtual ~VizImpl();
void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity()); void showWidget(const String &id, const Widget &widget, const Affine3f &pose = Affine3f::Identity());
void removeWidget(const String &id); void removeWidget(const String &id);
@ -28,19 +77,19 @@ public:
double getDesiredUpdateRate(); double getDesiredUpdateRate();
/** \brief Returns true when the user tried to close the window */ /** \brief Returns true when the user tried to close the window */
bool wasStopped () const { if (interactor_ != NULL) return (stopped_); else return true; } bool wasStopped() const { if (interactor_ != NULL) return (stopped_); else return true; }
/** \brief Set the stopped flag back to false */ /** \brief Set the stopped flag back to false */
void resetStoppedFlag () { if (interactor_ != NULL) stopped_ = false; } void resetStoppedFlag() { if (interactor_ != NULL) stopped_ = false; }
/** \brief Stop the interaction and close the visualizaton window. */ /** \brief Stop the interaction and close the visualizaton window. */
void close () void close()
{ {
stopped_ = true; stopped_ = true;
if (interactor_) if (interactor_)
{ {
interactor_->GetRenderWindow()->Finalize(); interactor_->GetRenderWindow()->Finalize();
interactor_->TerminateApp (); // This tends to close the window... interactor_->TerminateApp(); // This tends to close the window...
} }
} }
@ -49,8 +98,7 @@ public:
void setCamera(const Camera &camera); void setCamera(const Camera &camera);
Camera getCamera() const; Camera getCamera() const;
/** \brief Reset the camera direction from {0, 0, 0} to the center_{x, y, z} of a given dataset. /** \brief Reset the camera to a given widget */
* \param[in] id the point cloud object id (default: cloud) */
void resetCameraViewpoint(const String& id); void resetCameraViewpoint(const String& id);
void resetCamera(); void resetCamera();
@ -60,16 +108,16 @@ public:
void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord); void convertToWindowCoordinates(const Point3d &pt, Point3d &window_coord);
void converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction); void converTo3DRay(const Point3d &window_coord, Point3d &origin, Vec3d &direction);
void saveScreenshot (const String &file); void saveScreenshot(const String &file);
void setWindowPosition (int x, int y); void setWindowPosition(int x, int y);
Size getWindowSize() const; Size getWindowSize() const;
void setWindowSize (int xw, int yw); void setWindowSize(int xw, int yw);
void setFullScreen (bool mode); void setFullScreen(bool mode);
String getWindowName() const; String getWindowName() const;
void setBackgroundColor (const Color& color); void setBackgroundColor(const Color& color);
void spin (); void spin();
void spinOnce (int time = 1, bool force_redraw = false); void spinOnce(int time = 1, bool force_redraw = false);
void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0); void registerKeyboardCallback(KeyboardCallback callback, void* cookie = 0);
void registerMouseCallback(MouseCallback callback, void* cookie = 0); void registerMouseCallback(MouseCallback callback, void* cookie = 0);
@ -88,12 +136,12 @@ private:
if (event_id != vtkCommand::TimerEvent) if (event_id != vtkCommand::TimerEvent)
return; return;
int timer_id = *reinterpret_cast<int*> (call_data); int timer_id = *reinterpret_cast<int*>(call_data);
if (timer_id != right_timer_id) if (timer_id != right_timer_id)
return; return;
// Stop vtk loop and send notification to app to wake it up // Stop vtk loop and send notification to app to wake it up
viz_->interactor_->TerminateApp (); viz_->interactor_->TerminateApp();
} }
int right_timer_id; int right_timer_id;
VizImpl* viz_; VizImpl* viz_;
@ -101,17 +149,17 @@ private:
struct ExitCallback : public vtkCommand struct ExitCallback : public vtkCommand
{ {
static ExitCallback* New () static ExitCallback* New()
{ {
return new ExitCallback; return new ExitCallback;
} }
virtual void Execute (vtkObject*, unsigned long event_id, void*) virtual void Execute(vtkObject*, unsigned long event_id, void*)
{ {
if (event_id == vtkCommand::ExitEvent) if (event_id == vtkCommand::ExitEvent)
{ {
viz_->stopped_ = true; viz_->stopped_ = true;
viz_->interactor_->GetRenderWindow()->Finalize(); viz_->interactor_->GetRenderWindow()->Finalize();
viz_->interactor_->TerminateApp (); viz_->interactor_->TerminateApp();
} }
} }
VizImpl* viz_; VizImpl* viz_;
@ -141,14 +189,14 @@ private:
/** \brief Boolean that holds whether or not the camera parameters were manually initialized*/ /** \brief Boolean that holds whether or not the camera parameters were manually initialized*/
bool camera_set_; bool camera_set_;
bool removeActorFromRenderer (const vtkSmartPointer<vtkProp> &actor); bool removeActorFromRenderer(const vtkSmartPointer<vtkProp> &actor);
/** \brief Internal method. Creates a vtk actor from a vtk polydata object. /** \brief Internal method. Creates a vtk actor from a vtk polydata object.
* \param[in] data the vtk polydata object to create an actor for * \param[in] data the vtk polydata object to create an actor for
* \param[out] actor the resultant vtk actor object * \param[out] actor the resultant vtk actor object
* \param[in] use_scalars set scalar properties to the mapper if it exists in the data. Default: true. * \param[in] use_scalars set scalar properties to the mapper if it exists in the data. Default: true.
*/ */
void createActorFromVTKDataSet (const vtkSmartPointer<vtkDataSet> &data, vtkSmartPointer<vtkLODActor> &actor, bool use_scalars = true); void createActorFromVTKDataSet(const vtkSmartPointer<vtkDataSet> &data, vtkSmartPointer<vtkLODActor> &actor, bool use_scalars = true);
/** \brief Updates a set of cells (vtkIdTypeArray) if the number of points in a cloud changes /** \brief Updates a set of cells (vtkIdTypeArray) if the number of points in a cloud changes
* \param[out] cells the vtkIdTypeArray object (set of cells) to update * \param[out] cells the vtkIdTypeArray object (set of cells) to update
@ -158,7 +206,7 @@ private:
* \param[in] nr_points the number of points in the new cloud. This dictates how many cells we need to * \param[in] nr_points the number of points in the new cloud. This dictates how many cells we need to
* generate * generate
*/ */
void updateCells (vtkSmartPointer<vtkIdTypeArray> &cells, vtkSmartPointer<vtkIdTypeArray> &initcells, vtkIdType nr_points); void updateCells(vtkSmartPointer<vtkIdTypeArray> &cells, vtkSmartPointer<vtkIdTypeArray> &initcells, vtkIdType nr_points);
}; };
@ -167,7 +215,7 @@ namespace cv
{ {
namespace viz namespace viz
{ {
vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix (const cv::Matx44f &m); vtkSmartPointer<vtkMatrix4x4> convertToVtkMatrix(const cv::Matx44f &m);
cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix); cv::Matx44f convertToMatx(const vtkSmartPointer<vtkMatrix4x4>& vtk_matrix);
struct NanFilter struct NanFilter
@ -186,12 +234,12 @@ namespace cv
int s_chs = source.channels(); int s_chs = source.channels();
int m_chs = nan_mask.channels(); int m_chs = nan_mask.channels();
for(int y = 0; y < source.rows; ++y) for (int y = 0; y < source.rows; ++y)
{ {
const _Tp* srow = source.ptr<_Tp>(y); const _Tp* srow = source.ptr<_Tp>(y);
const _Msk* mrow = nan_mask.ptr<_Msk>(y); const _Msk* mrow = nan_mask.ptr<_Msk>(y);
for(int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs) for (int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs)
if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2])) if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2]))
*output++ = _Out(srow); *output++ = _Out(srow);
} }
@ -207,12 +255,12 @@ namespace cv
int s_chs = source.channels(); int s_chs = source.channels();
int m_chs = nan_mask.channels(); int m_chs = nan_mask.channels();
for(int y = 0; y < source.rows; ++y) for (int y = 0; y < source.rows; ++y)
{ {
const _Tp* srow = source.ptr<_Tp>(y); const _Tp* srow = source.ptr<_Tp>(y);
const _Msk* mrow = nan_mask.ptr<_Msk>(y); const _Msk* mrow = nan_mask.ptr<_Msk>(y);
for(int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs) for (int x = 0; x < source.cols; ++x, srow += s_chs, mrow += m_chs)
if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2])) if (!isNan(mrow[0]) && !isNan(mrow[1]) && !isNan(mrow[2]))
{ {
*output = _Out(srow); *output = _Out(srow);
@ -338,6 +386,6 @@ namespace cv
} }
}; };
} }
} }
#endif

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

@ -1,3 +1,51 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#include "precomp.hpp" #include "precomp.hpp"
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////

48
modules/viz/test/test_precomp.hpp
View File

@ -1,3 +1,51 @@
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of the copyright holders may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
// Authors:
// * Ozan Tonkal, ozantonkal@gmail.com
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
// OpenCV Viz module is complete rewrite of
// PCL visualization module (www.pointclouds.org)
//
//M*/
#ifdef __GNUC__ #ifdef __GNUC__
# pragma GCC diagnostic ignored "-Wmissing-declarations" # pragma GCC diagnostic ignored "-Wmissing-declarations"
# if defined __clang__ || defined __APPLE__ # if defined __clang__ || defined __APPLE__