mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2024-11-25 19:50:38 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

move image copying structure to viz3d_impl: ConvertToVtkImage

Browse Source
This commit is contained in:
ozantonkal 2013-07-24 10:32:21 +02:00
parent 952029a47b
commit 769512db2d
3 changed files with 64 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -155,9 +155,6 @@ namespace cv
ImageOverlayWidget(const Mat &image, const Rect &rect);
void setImage(const Mat &image);
private:
struct CopyImpl;
};
class CV_EXPORTS Image3DWidget : public Widget3D
@ -167,9 +164,6 @@ namespace cv
Image3DWidget(const Vec3f &position, const Vec3f &normal, const Vec3f &up_vector, const Mat &image, const Size &size);
void setImage(const Mat &image);
private:
struct CopyImpl;
};
class CV_EXPORTS CameraPositionWidget : public Widget3D
@ -181,8 +175,6 @@ namespace cv
CameraPositionWidget(const Vec2f &fov, double scale = 1.0, const Color &color = Color::white());
CameraPositionWidget(const Matx33f &K, const Mat &img, double scale = 1.0);
private:
struct CopyImpl;
};
class CV_EXPORTS TrajectoryWidget : public Widget3D

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

@ -629,69 +629,13 @@ cv::String cv::viz::TextWidget::getText() const
///////////////////////////////////////////////////////////////////////////////////////////////
/// image overlay widget implementation
struct cv::viz::ImageOverlayWidget::CopyImpl
{
struct Impl
{
static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
int i_chs = image.channels();
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, irows += i_chs)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
memcpy(vrows, irows, i_chs);
std::swap(vrows[0], vrows[2]); // BGR -> RGB
}
}
output->Modified();
}
static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, ++irows)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
*vrows = *irows;
}
}
output->Modified();
}
};
static void copyImage(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
int i_chs = image.channels();
if (i_chs > 1)
{
// Multi channel images are handled differently because of BGR <-> RGB
Impl::copyImageMultiChannel(image, output);
}
else
{
Impl::copyImageSingleChannel(image, output);
}
}
};
cv::viz::ImageOverlayWidget::ImageOverlayWidget(const Mat &image, const Rect &rect)
{
CV_Assert(!image.empty() && image.depth() == CV_8U);
// Create the vtk image and set its parameters based on input image
vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
vtk_image->SetDimensions(image.cols, image.rows, 1);
vtk_image->SetNumberOfScalarComponents(image.channels());
vtk_image->SetScalarTypeToUnsignedChar();
vtk_image->AllocateScalars();
CopyImpl::copyImage(image, vtk_image);
ConvertToVtkImage::convert(image, vtk_image);
// Need to flip the image as the coordinates are different in OpenCV and VTK
vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@ -734,12 +678,7 @@ void cv::viz::ImageOverlayWidget::setImage(const Mat &image)
// Create the vtk image and set its parameters based on input image
vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
vtk_image->SetDimensions(image.cols, image.rows, 1);
vtk_image->SetNumberOfScalarComponents(image.channels());
vtk_image->SetScalarTypeToUnsignedChar();
vtk_image->AllocateScalars();
CopyImpl::copyImage(image, vtk_image);
ConvertToVtkImage::convert(image, vtk_image);
// Need to flip the image as the coordinates are different in OpenCV and VTK
vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@ -759,69 +698,13 @@ template<> cv::viz::ImageOverlayWidget cv::viz::Widget::cast<cv::viz::ImageOverl
///////////////////////////////////////////////////////////////////////////////////////////////
/// image 3D widget implementation
struct cv::viz::Image3DWidget::CopyImpl
{
struct Impl
{
static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
int i_chs = image.channels();
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, irows += i_chs)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
memcpy(vrows, irows, i_chs);
std::swap(vrows[0], vrows[2]); // BGR -> RGB
}
}
output->Modified();
}
static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, ++irows)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
*vrows = *irows;
}
}
output->Modified();
}
};
static void copyImage(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
int i_chs = image.channels();
if (i_chs > 1)
{
// Multi channel images are handled differently because of BGR <-> RGB
Impl::copyImageMultiChannel(image, output);
}
else
{
Impl::copyImageSingleChannel(image, output);
}
}
};
cv::viz::Image3DWidget::Image3DWidget(const Mat &image, const Size &size)
{
CV_Assert(!image.empty() && image.depth() == CV_8U);
// Create the vtk image and set its parameters based on input image
vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
vtk_image->SetDimensions(image.cols, image.rows, 1);
vtk_image->SetNumberOfScalarComponents(image.channels());
vtk_image->SetScalarTypeToUnsignedChar();
vtk_image->AllocateScalars();
CopyImpl::copyImage(image, vtk_image);
ConvertToVtkImage::convert(image, vtk_image);
// Need to flip the image as the coordinates are different in OpenCV and VTK
vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@ -869,12 +752,7 @@ cv::viz::Image3DWidget::Image3DWidget(const Vec3f &position, const Vec3f &normal
// Create the vtk image and set its parameters based on input image
vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
vtk_image->SetDimensions(image.cols, image.rows, 1);
vtk_image->SetNumberOfScalarComponents(image.channels());
vtk_image->SetScalarTypeToUnsignedChar();
vtk_image->AllocateScalars();
CopyImpl::copyImage(image, vtk_image);
ConvertToVtkImage::convert(image, vtk_image);
// Need to flip the image as the coordinates are different in OpenCV and VTK
vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@ -947,12 +825,7 @@ void cv::viz::Image3DWidget::setImage(const Mat &image)
// Create the vtk image and set its parameters based on input image
vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
vtk_image->SetDimensions(image.cols, image.rows, 1);
vtk_image->SetNumberOfScalarComponents(image.channels());
vtk_image->SetScalarTypeToUnsignedChar();
vtk_image->AllocateScalars();
CopyImpl::copyImage(image, vtk_image);
ConvertToVtkImage::convert(image, vtk_image);
// Need to flip the image as the coordinates are different in OpenCV and VTK
vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();
@ -976,58 +849,6 @@ template<> cv::viz::Image3DWidget cv::viz::Widget::cast<cv::viz::Image3DWidget>(
///////////////////////////////////////////////////////////////////////////////////////////////
/// camera position widget implementation
struct cv::viz::CameraPositionWidget::CopyImpl
{
struct Impl
{
static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
int i_chs = image.channels();
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, irows += i_chs)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
memcpy(vrows, irows, i_chs);
std::swap(vrows[0], vrows[2]); // BGR -> RGB
}
}
output->Modified();
}
static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, ++irows)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
*vrows = *irows;
}
}
output->Modified();
}
};
static void copyImage(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
int i_chs = image.channels();
if (i_chs > 1)
{
// Multi channel images are handled differently because of BGR <-> RGB
Impl::copyImageMultiChannel(image, output);
}
else
{
Impl::copyImageSingleChannel(image, output);
}
}
};
cv::viz::CameraPositionWidget::CameraPositionWidget(double scale)
{
vtkSmartPointer<vtkAxes> axes = vtkSmartPointer<vtkAxes>::New ();
@ -1223,14 +1044,9 @@ cv::viz::CameraPositionWidget::CameraPositionWidget(const Matx33f &K, const Mat
float fovy = 2.0f * atan2(c_y,f_y) * 180 / CV_PI;
float far_end_height = 2.0f * c_y * scale / f_y;
// Create the vtk image and set its parameters based on input image
// Create the vtk image
vtkSmartPointer<vtkImageData> vtk_image = vtkSmartPointer<vtkImageData>::New();
vtk_image->SetDimensions(image.cols, image.rows, 1);
vtk_image->SetNumberOfScalarComponents(image.channels());
vtk_image->SetScalarTypeToUnsignedChar();
vtk_image->AllocateScalars();
CopyImpl::copyImage(image, vtk_image);
ConvertToVtkImage::convert(image, vtk_image);
// Need to flip the image as the coordinates are different in OpenCV and VTK
vtkSmartPointer<vtkImageFlip> flipFilter = vtkSmartPointer<vtkImageFlip>::New();

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

@ -410,6 +410,63 @@ namespace cv
inline Vec3d vtkpoint(const Point3f& point) { return Vec3d(point.x, point.y, point.z); }
template<typename _Tp> inline _Tp normalized(const _Tp& v) { return v * 1/cv::norm(v); }
struct ConvertToVtkImage
{
struct Impl
{
static void copyImageMultiChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
int i_chs = image.channels();
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, irows += i_chs)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
memcpy(vrows, irows, i_chs);
std::swap(vrows[0], vrows[2]); // BGR -> RGB
}
}
output->Modified();
}
static void copyImageSingleChannel(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
for (int i = 0; i < image.rows; ++i)
{
const unsigned char * irows = image.ptr<unsigned char>(i);
for (int j = 0; j < image.cols; ++j, ++irows)
{
unsigned char * vrows = static_cast<unsigned char *>(output->GetScalarPointer(j,i,0));
*vrows = *irows;
}
}
output->Modified();
}
};
static void convert(const Mat &image, vtkSmartPointer<vtkImageData> output)
{
// Create the vtk image
output->SetDimensions(image.cols, image.rows, 1);
output->SetNumberOfScalarComponents(image.channels());
output->SetScalarTypeToUnsignedChar();
output->AllocateScalars();
int i_chs = image.channels();
if (i_chs > 1)
{
// Multi channel images are handled differently because of BGR <-> RGB
Impl::copyImageMultiChannel(image, output);
}
else
{
Impl::copyImageSingleChannel(image, output);
}
}
};
}
}