Skip to content

O
opencv
Commit 84d6fe39 authored by Anatoly Baksheev's avatar Anatoly Baksheev
Browse files
Options

reading/writing clouds functionality

parent 80ab6e88
Hide whitespace changes
Inline Side-by-side
Showing with 515 additions and 310 deletions
modules/viz/include/opencv2/viz.hpp
View file @ 84d6fe39
...@@ -92,6 +92,12 @@ namespace cv ...@@ -92,6 +92,12 @@ namespace cv
{ return isNan(p.x) || isNan(p.y) || isNan(p.z); } { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
///////////////////////////////////////////////////////////////////////////////////////////////
/// Read/write clouds. Supported formats: ply, stl, xyz, obj
CV_EXPORTS void writeCloud(const String& file, InputArray cloud, InputArray colors = noArray());
CV_EXPORTS Mat readCloud (const String& file, OutputArray colors = cv::noArray());
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// Read/write poses and trajectories /// Read/write poses and trajectories
......
modules/viz/src/clouds.cpp
View file @ 84d6fe39
...@@ -69,9 +69,8 @@ cv::viz::WCloud::WCloud(InputArray _cloud, InputArray _colors) ...@@ -69,9 +69,8 @@ cv::viz::WCloud::WCloud(InputArray _cloud, InputArray _colors)
colors = colors.reshape(colors.channels(), 1); colors = colors.reshape(colors.channels(), 1);
} }
vtkSmartPointer<vtkCloudColorMatSource> cloud_source = vtkSmartPointer<vtkCloudColorMatSource>::New(); vtkSmartPointer<vtkCloudMatSource> cloud_source = vtkSmartPointer<vtkCloudMatSource>::New();
cloud_source->SetCloud(cloud); cloud_source->SetColorCloud(cloud, colors);
cloud_source->SetColors(colors, cloud);
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New(); vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
mapper->SetInputConnection(cloud_source->GetOutputPort()); mapper->SetInputConnection(cloud_source->GetOutputPort());
......
modules/viz/src/precomp.hpp
View file @ 84d6fe39
...@@ -50,6 +50,7 @@ ...@@ -50,6 +50,7 @@
#include <ctime> #include <ctime>
#include <list> #include <list>
#include <vector> #include <vector>
#include <iomanip>
#include <vtkAppendPolyData.h> #include <vtkAppendPolyData.h>
#include <vtkAssemblyPath.h> #include <vtkAssemblyPath.h>
...@@ -113,16 +114,31 @@ ...@@ -113,16 +114,31 @@
#include <vtkObjectFactory.h> #include <vtkObjectFactory.h>
#include <vtkPolyDataAlgorithm.h> #include <vtkPolyDataAlgorithm.h>
#include <vtkMergeFilter.h> #include <vtkMergeFilter.h>
#include <vtkDataSetWriter.h>
#include <vtkErrorCode.h>
#include <vtkPLYWriter.h>
#include <vtkSTLWriter.h>
#include <vtkSimplePointsReader.h>
#include <vtkPLYReader.h>
#include <vtkOBJReader.h>
#include <vtkSTLReader.h>
#if !defined(_WIN32) || defined(__CYGWIN__)
# include <unistd.h> /* unlink */
#else
# include <io.h> /* unlink */
#endif
#include <vtk/vtkCloudMatSource.h> #include <vtk/vtkCloudMatSource.h>
#include <vtk/vtkColorMatSource.h> #include <vtk/vtkOBJWriter.h>
#include <vtk/vtkCloudColorMatSource.h> #include <vtk/vtkXYZWriter.h>
#include <opencv2/core.hpp> #include <opencv2/core.hpp>
#include <opencv2/viz.hpp> #include <opencv2/viz.hpp>
#include <opencv2/viz/widget_accessor.hpp> #include <opencv2/viz/widget_accessor.hpp>
#include <opencv2/core/utility.hpp> #include <opencv2/core/utility.hpp>
namespace cv namespace cv
{ {
namespace viz namespace viz
......
modules/viz/src/vizcore.cpp
View file @ 84d6fe39
...@@ -161,6 +161,118 @@ cv::String cv::viz::VizStorage::generateWindowName(const String &window_name) ...@@ -161,6 +161,118 @@ cv::String cv::viz::VizStorage::generateWindowName(const String &window_name)
cv::viz::Viz3d cv::viz::get(const String &window_name) { return Viz3d (window_name); } cv::viz::Viz3d cv::viz::get(const String &window_name) { return Viz3d (window_name); }
void cv::viz::unregisterAllWindows() { VizStorage::unregisterAll(); } void cv::viz::unregisterAllWindows() { VizStorage::unregisterAll(); }
///////////////////////////////////////////////////////////////////////////////////////////////
/// Read/write clouds. Supported formats: ply, stl, xyz, obj
void cv::viz::writeCloud(const String& file, InputArray _cloud, InputArray _colors)
{
CV_Assert(file.size() > 4 && "Extention is required");
String extention = file.substr(file.size()-4);
Mat cloud = _cloud.getMat();
Mat colors = _colors.getMat();
vtkSmartPointer<vtkCloudMatSource> source = vtkSmartPointer<vtkCloudMatSource>::New();
source->SetColorCloud(cloud, colors);
vtkSmartPointer<vtkWriter> writer;
if (extention == ".xyz")
{
writer = vtkSmartPointer<vtkXYZWriter>::New();
vtkPLYWriter::SafeDownCast(writer)->SetFileName(file.c_str());
}
else if (extention == ".ply")
{
writer = vtkSmartPointer<vtkPLYWriter>::New();
vtkPLYWriter::SafeDownCast(writer)->SetFileName(file.c_str());
}
else if (extention == ".obj")
{
writer = vtkSmartPointer<vtkOBJWriter>::New();
vtkOBJWriter::SafeDownCast(writer)->SetFileName(file.c_str());
}
else if (extention == ".stl")
{
writer = vtkSmartPointer<vtkSTLWriter>::New();
vtkSTLWriter::SafeDownCast(writer)->SetFileName(file.c_str());
}
else
CV_Assert(!"Unsupported format");
writer->SetInputConnection(source->GetOutputPort());
writer->Write();
}
cv::Mat cv::viz::readCloud(const String& file, OutputArray colors)
{
CV_Assert(file.size() > 4 && "Extention is required");
String extention = file.substr(file.size()-4);
vtkSmartPointer<vtkPolyDataAlgorithm> reader;
if (extention == ".xyz")
{
reader = vtkSmartPointer<vtkSimplePointsReader>::New();
vtkSimplePointsReader::SafeDownCast(reader)->SetFileName(file.c_str());
}
else if (extention == ".ply")
{
reader = vtkSmartPointer<vtkPLYReader>::New();
CV_Assert(vtkPLYReader::CanReadFile(file.c_str()));
vtkPLYReader::SafeDownCast(reader)->SetFileName(file.c_str());
}
else if (extention == ".obj")
{
reader = vtkSmartPointer<vtkOBJReader>::New();
vtkOBJReader::SafeDownCast(reader)->SetFileName(file.c_str());
}
else if (extention == ".stl")
{
reader = vtkSmartPointer<vtkSTLReader>::New();
vtkSTLReader::SafeDownCast(reader)->SetFileName(file.c_str());
}
else
CV_Assert(!"Unsupported format");
reader->Update();
vtkSmartPointer<vtkPolyData> poly_data = reader->GetOutput();
vtkSmartPointer<vtkPoints> points = poly_data->GetPoints();
int vtktype = points->GetDataType();
CV_Assert(vtktype == VTK_FLOAT || vtktype == VTK_DOUBLE);
Mat cloud(1, points->GetNumberOfPoints(), vtktype == VTK_FLOAT ? CV_32FC3 : CV_64FC3);
Vec3d *ddata = cloud.ptr<Vec3d>();
Vec3f *fdata = cloud.ptr<Vec3f>();
if (cloud.depth() == CV_32F)
for(size_t i = 0; i < cloud.total(); ++i)
*fdata++ = Vec3d(points->GetPoint(i));
if (cloud.depth() == CV_64F)
for(size_t i = 0; i < cloud.total(); ++i)
*ddata++ = Vec3d(points->GetPoint(i));
vtkSmartPointer<vtkDataArray> scalars = poly_data->GetPointData() ? poly_data->GetPointData()->GetScalars() : 0;
if (colors.needed() && scalars)
{
int channels = scalars->GetNumberOfComponents();
int vtktype = scalars->GetDataType();
CV_Assert((channels == 3 || channels == 4) && "Only 3- or 4-channel color data support is implemented");
CV_Assert(cloud.total() == (size_t)scalars->GetNumberOfTuples());
Mat buffer(cloud.size(), CV_64FC(channels));
Vec3d *cptr = buffer.ptr<Vec3d>();
for(size_t i = 0; i < colors.total(); ++i)
*cptr++ = Vec3d(scalars->GetTuple(i));
buffer.convertTo(colors, CV_8U, vtktype == VTK_FLOAT || VTK_FLOAT == VTK_DOUBLE ? 255.0 : 1.0);
}
else
colors.release();
return cloud;
}
/////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////
/// Read/write poses and trajectories /// Read/write poses and trajectories
......
modules/viz/src/vtk/vtkCloudColorMatSource.cpp deleted 100644 → 0
View file @ 80ab6e88
/*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:
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
//M*/
#include "precomp.hpp"
namespace cv { namespace viz
{
vtkStandardNewMacro(vtkCloudColorMatSource);
struct IsNotNan
{
template<typename _Tp>
bool operator()(const _Tp* data) const
{
return !isNan(data[0]) && !isNan(data[1]) && !isNan(data[2]);
}
};
}}
cv::viz::vtkCloudColorMatSource::vtkCloudColorMatSource() { SetNumberOfInputPorts(0); }
cv::viz::vtkCloudColorMatSource::~vtkCloudColorMatSource() {}
void cv::viz::vtkCloudColorMatSource::SetCloud(const Mat& cloud)
{
CV_Assert(cloud.depth() == CV_32F || cloud.depth() == CV_64F);
CV_Assert(cloud.channels() == 3 || cloud.channels() == 4);
int total = cloud.depth() == CV_32F ? filterNanCopy<float >(cloud, VTK_FLOAT)
: filterNanCopy<double>(cloud, VTK_DOUBLE);
vertices = vtkSmartPointer<vtkCellArray>::New();
vertices->Allocate(vertices->EstimateSize(1, total));
vertices->InsertNextCell(total);
for(int i = 0; i < total; ++i)
vertices->InsertCellPoint(i);
}
void cv::viz::vtkCloudColorMatSource::SetColors(const Mat &colors, const Mat &cloud_mask)
{
CV_Assert(colors.depth() == CV_8U && colors.channels() <= 4 && colors.channels() != 2);
CV_Assert(cloud_mask.depth() == CV_32F || cloud_mask.depth() == CV_64F);
CV_Assert(colors.size() == cloud_mask.size());
if (cloud_mask.depth() == CV_32F)
filterNanCopy<float, IsNotNan>(colors, cloud_mask);
else if (cloud_mask.depth() == CV_64F)
filterNanCopy<double, IsNotNan>(colors, cloud_mask);
}
int cv::viz::vtkCloudColorMatSource::RequestData(vtkInformation *vtkNotUsed(request), vtkInformationVector **vtkNotUsed(inputVector), vtkInformationVector *outputVector)
{
vtkInformation *outInfo = outputVector->GetInformationObject(0);
vtkPolyData *output = vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT()));
output->SetPoints(points);
output->SetVerts(vertices);
output->GetPointData()->SetScalars(scalars);
return 1;
}
template<typename _Tp>
int cv::viz::vtkCloudColorMatSource::filterNanCopy(const Mat& source, int dataType)
{
CV_DbgAssert(DataType<_Tp>::depth == source.depth());
points = vtkSmartPointer<vtkPoints>::New();
points->SetDataType(dataType);
points->Allocate(source.total());
points->SetNumberOfPoints(source.total());
int cn = source.channels();
int total = 0;
for (int y = 0; y < source.rows; ++y)
{
const _Tp* srow = source.ptr<_Tp>(y);
const _Tp* send = srow + source.cols * cn;
for (; srow != send; srow += cn)
if (!isNan(srow[0]) && !isNan(srow[1]) && !isNan(srow[2]))
points->SetPoint(total++, srow);
}
points->SetNumberOfPoints(total);
points->Squeeze();
return total;
}
template<typename _Msk, class _NanPred>
void cv::viz::vtkCloudColorMatSource::filterNanCopy(const Mat& colors, const Mat& mask)
{
Mat buffer(colors.size(), CV_8UC3);
Vec3b* pos = buffer.ptr<Vec3b>();
int s_chs = colors.channels();
int m_chs = mask.channels();
_NanPred pred;
for (int y = 0; y < colors.rows; ++y)
{
const unsigned char* srow = colors.ptr<unsigned char>(y);
const unsigned char* send = srow + colors.cols * colors.channels();
const _Msk* mrow = mask.empty() ? 0 : mask.ptr<_Msk>(y);
if (colors.channels() == 1)
{
for (; srow != send; srow += s_chs, mrow += m_chs)
if (pred(mrow))
*pos++ = Vec3b(srow[0], srow[0], srow[0]);
}
else
for (; srow != send; srow += s_chs, mrow += m_chs)
if (pred(mrow))
*pos++ = Vec3b(srow[2], srow[1], srow[0]);
}
int total = pos - buffer.ptr<Vec3b>();
Vec3b* array = new Vec3b[total];
std::copy(buffer.ptr<Vec3b>(), pos, array);
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetName("colors");
scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples(total);
scalars->SetArray(array->val, total * 3, 0);
}
modules/viz/src/vtk/vtkCloudMatSource.cpp
View file @ 84d6fe39
...@@ -47,6 +47,14 @@ ...@@ -47,6 +47,14 @@
namespace cv { namespace viz namespace cv { namespace viz
{ {
vtkStandardNewMacro(vtkCloudMatSource); vtkStandardNewMacro(vtkCloudMatSource);
struct IsNotNan
{
template<typename _Tp> bool operator()(const _Tp* data) const
{
return !isNan(data[0]) && !isNan(data[1]) && !isNan(data[2]);
}
};
}} }}
cv::viz::vtkCloudMatSource::vtkCloudMatSource() { SetNumberOfInputPorts(0); } cv::viz::vtkCloudMatSource::vtkCloudMatSource() { SetNumberOfInputPorts(0); }
...@@ -67,6 +75,22 @@ void cv::viz::vtkCloudMatSource::SetCloud(const Mat& cloud) ...@@ -67,6 +75,22 @@ void cv::viz::vtkCloudMatSource::SetCloud(const Mat& cloud)
vertices->InsertCellPoint(i); vertices->InsertCellPoint(i);
} }
void cv::viz::vtkCloudMatSource::SetColorCloud(const Mat &cloud, const Mat &colors)
{
vtkCloudMatSource::SetCloud(cloud);
if (colors.empty())
return;
CV_Assert(colors.depth() == CV_8U && colors.channels() <= 4 && colors.channels() != 2);
CV_Assert(colors.size() == cloud.size());
if (cloud.depth() == CV_32F)
filterNanColorsCopy<float, IsNotNan>(colors, cloud);
else if (cloud.depth() == CV_64F)
filterNanColorsCopy<double, IsNotNan>(colors, cloud);
}
int cv::viz::vtkCloudMatSource::RequestData(vtkInformation *vtkNotUsed(request), vtkInformationVector **vtkNotUsed(inputVector), vtkInformationVector *outputVector) int cv::viz::vtkCloudMatSource::RequestData(vtkInformation *vtkNotUsed(request), vtkInformationVector **vtkNotUsed(inputVector), vtkInformationVector *outputVector)
{ {
vtkInformation *outInfo = outputVector->GetInformationObject(0); vtkInformation *outInfo = outputVector->GetInformationObject(0);
...@@ -74,6 +98,8 @@ int cv::viz::vtkCloudMatSource::RequestData(vtkInformation *vtkNotUsed(request), ...@@ -74,6 +98,8 @@ int cv::viz::vtkCloudMatSource::RequestData(vtkInformation *vtkNotUsed(request),
output->SetPoints(points); output->SetPoints(points);
output->SetVerts(vertices); output->SetVerts(vertices);
if (scalars)
output->GetPointData()->SetScalars(scalars);
return 1; return 1;
} }
...@@ -103,3 +129,45 @@ int cv::viz::vtkCloudMatSource::filterNanCopy(const Mat& source, int dataType) ...@@ -103,3 +129,45 @@ int cv::viz::vtkCloudMatSource::filterNanCopy(const Mat& source, int dataType)
} }
template<typename _Msk, class _NanPred>
void cv::viz::vtkCloudMatSource::filterNanColorsCopy(const Mat& colors, const Mat& mask)
{
Mat buffer(colors.size(), CV_8UC3);
Vec3b* pos = buffer.ptr<Vec3b>();
int s_chs = colors.channels();
int m_chs = mask.channels();
_NanPred pred;
for (int y = 0; y < colors.rows; ++y)
{
const unsigned char* srow = colors.ptr<unsigned char>(y);
const unsigned char* send = srow + colors.cols * colors.channels();
const _Msk* mrow = mask.empty() ? 0 : mask.ptr<_Msk>(y);
if (colors.channels() == 1)
{
for (; srow != send; srow += s_chs, mrow += m_chs)
if (pred(mrow))
*pos++ = Vec3b(srow[0], srow[0], srow[0]);
}
else
for (; srow != send; srow += s_chs, mrow += m_chs)
if (pred(mrow))
*pos++ = Vec3b(srow[2], srow[1], srow[0]);
}
int total = pos - buffer.ptr<Vec3b>();
Vec3b* array = new Vec3b[total];
std::copy(buffer.ptr<Vec3b>(), pos, array);
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetName("colors");
scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples(total);
scalars->SetArray(array->val, total * 3, 0);
}
modules/viz/src/vtk/vtkCloudMatSource.h
View file @ 84d6fe39
...@@ -62,6 +62,7 @@ namespace cv ...@@ -62,6 +62,7 @@ namespace cv
vtkTypeMacro(vtkCloudMatSource,vtkPolyDataAlgorithm); vtkTypeMacro(vtkCloudMatSource,vtkPolyDataAlgorithm);
virtual void SetCloud(const Mat& cloud); virtual void SetCloud(const Mat& cloud);
virtual void SetColorCloud(const Mat &cloud, const Mat &colors = cv::Mat());
protected: protected:
vtkCloudMatSource(); vtkCloudMatSource();
...@@ -71,11 +72,15 @@ namespace cv ...@@ -71,11 +72,15 @@ namespace cv
vtkSmartPointer<vtkPoints> points; vtkSmartPointer<vtkPoints> points;
vtkSmartPointer<vtkCellArray> vertices; vtkSmartPointer<vtkCellArray> vertices;
vtkSmartPointer<vtkUnsignedCharArray> scalars;
private: private:
vtkCloudMatSource(const vtkCloudMatSource&); // Not implemented. vtkCloudMatSource(const vtkCloudMatSource&); // Not implemented.
void operator=(const vtkCloudMatSource&); // Not implemented. void operator=(const vtkCloudMatSource&); // Not implemented.
template<typename _Tp> int filterNanCopy(const Mat& source, int dataType); template<typename _Tp> int filterNanCopy(const Mat& source, int dataType);
template<typename _Msk, class _NanPred>
void filterNanColorsCopy(const Mat& colors, const Mat& mask);
}; };
} }
} }
......
modules/viz/src/vtk/vtkOBJWriter.cpp 0 → 100644
View file @ 84d6fe39
/*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:
// * Anatoly Baksheev, Itseez Inc. myname.mysurname <> mycompany.com
//
//M*/
#include "precomp.hpp"
namespace cv { namespace viz
{
vtkStandardNewMacro(vtkOBJWriter);
}}
cv::viz::vtkOBJWriter::vtkOBJWriter()
{
std::ofstream fout; // only used to extract the default precision
this->DecimalPrecision = fout.precision();
this->FileName = NULL;
this->FileType = VTK_ASCII;
}
cv::viz::vtkOBJWriter::~vtkOBJWriter(){}
void cv::viz::vtkOBJWriter::WriteData()
{
vtkPolyData *input = this->GetInput();
if (!input)
return;
std::ostream *outfilep = this->OpenVTKFile();
if (!outfilep)
return;
std::ostream& outfile = *outfilep;
//write header
outfile << "# wavefront obj file written by the visualization toolkit" << std::endl << std::endl;
outfile << "mtllib NONE" << std::endl << std::endl;
// write out the points
for (int i = 0; i < input->GetNumberOfPoints(); i++)
{
Vec3d p;
input->GetPoint(i, p.val);
outfile << std::setprecision(this->DecimalPrecision) << "v " << p[0] << " " << p[1] << " " << p[2] << std::endl;
}
const int idStart = 1;
// write out the point data
vtkSmartPointer<vtkDataArray> normals = input->GetPointData()->GetNormals();
if(normals)
{
for (int i = 0; i < normals->GetNumberOfTuples(); i++)
{
Vec3d p;
normals->GetTuple(i, p.val);
outfile << std::setprecision(this->DecimalPrecision) << "vn " << p[0] << " " << p[1] << " " << p[2] << std::endl;
}
}
vtkSmartPointer<vtkDataArray> tcoords = input->GetPointData()->GetTCoords();
if (tcoords)
{
for (int i = 0; i < tcoords->GetNumberOfTuples(); i++)
{
Vec2d p;
tcoords->GetTuple(i, p.val);
outfile << std::setprecision(this->DecimalPrecision) << "vt " << p[0] << " " << p[1] << std::endl;
}
}
// write out a group name and material
outfile << std::endl << "g grp" << idStart << std::endl;
outfile << "usemtl mtlNONE" << std::endl;
// write out verts if any
if (input->GetNumberOfVerts() > 0)
{
vtkIdType npts = 0, *index = 0;
vtkCellArray *cells = input->GetVerts();
for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
{
outfile << "p ";
for (int i = 0; i < npts; i++)
outfile << index[i] + idStart << " ";
outfile << std::endl;
}
}
// write out lines if any
if (input->GetNumberOfLines() > 0)
{
vtkIdType npts = 0, *index = 0;
vtkCellArray *cells = input->GetLines();
for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
{
outfile << "l ";
if (tcoords)
{
for (int i = 0; i < npts; i++)
outfile << index[i] + idStart << "/" << index[i] + idStart << " ";
}
else
for (int i = 0; i < npts; i++)
outfile << index[i] + idStart << " ";
outfile << std::endl;
}
}
// write out polys if any
if (input->GetNumberOfPolys() > 0)
{
vtkIdType npts = 0, *index = 0;
vtkCellArray *cells = input->GetPolys();
for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
{
outfile << "f ";
for (int i = 0; i < npts; i++)
{
if (normals)
{
if (tcoords)
outfile << index[i] + idStart << "/" << index[i] + idStart << "/" << index[i] + idStart << " ";
else
outfile << index[i] + idStart << "//" << index[i] + idStart << " ";
}
else
{
if (tcoords)
outfile << index[i] + idStart << " " << index[i] + idStart << " ";
else
outfile << index[i] + idStart << " ";
}
}
outfile << std::endl;
}
}
// write out tstrips if any
if (input->GetNumberOfStrips() > 0)
{
vtkIdType npts = 0, *index = 0;
vtkCellArray *cells = input->GetStrips();
for (cells->InitTraversal(); cells->GetNextCell(npts, index); )
{
for (int i = 2, i1, i2; i < npts; ++i)
{
if (i % 2)
{
i1 = i - 1;
i2 = i - 2;
}
else
{
i1 = i - 1;
i2 = i - 2;
}
if(normals)
{
if (tcoords)
{
outfile << "f " << index[i1] + idStart << "/" << index[i1] + idStart << "/" << index[i1] + idStart << " "
<< index[i2]+ idStart << "/" << index[i2] + idStart << "/" << index[i2] + idStart << " "
<< index[i] + idStart << "/" << index[i] + idStart << "/" << index[i] + idStart << std::endl;
}
else
{
outfile << "f " << index[i1] + idStart << "//" << index[i1] + idStart << " " << index[i2] + idStart
<< "//" << index[i2] + idStart << " " << index[i] + idStart << "//" << index[i] + idStart << std::endl;
}
}
else
{
if (tcoords)
{
outfile << "f " << index[i1] + idStart << "/" << index[i1] + idStart << " " << index[i2] + idStart
<< "/" << index[i2] + idStart << " " << index[i] + idStart << "/" << index[i] + idStart << std::endl;
}
else
outfile << "f " << index[i1] + idStart << " " << index[i2] + idStart << " " << index[i] + idStart << std::endl;
}
} /* for (int i = 2; i < npts; ++i) */
}
} /* if (input->GetNumberOfStrips() > 0) */
this->CloseVTKFile(outfilep);
// Delete the file if an error occurred
if (this->ErrorCode == vtkErrorCode::OutOfDiskSpaceError)
{
vtkErrorMacro("Ran out of disk space; deleting file: " << this->FileName);
unlink(this->FileName);
}
}
void cv::viz::vtkOBJWriter::PrintSelf(ostream& os, vtkIndent indent)
{
Superclass::PrintSelf(os, indent);
os << indent << "DecimalPrecision: " << DecimalPrecision << "\n";
}
modules/viz/src/vtk/vtkColorMatSource.h → modules/viz/src/vtk/vtkOBJWriter.h
View file @ 84d6fe39
...@@ -42,39 +42,36 @@ ...@@ -42,39 +42,36 @@
// //
//M*/ //M*/
#ifndef __vtkColorMatSource_h #ifndef __vtkOBJWriter_h
#define __vtkColorMatSource_h #define __vtkOBJWriter_h
#include <opencv2/core/mat.hpp> #include <vtkPolyDataWriter.h>
#include <vtkPolyDataAlgorithm.h>
#include <vtkSmartPointer.h>
namespace cv namespace cv
{ {
namespace viz namespace viz
{ {
class vtkColorMatSource : public vtkPolyDataAlgorithm class vtkOBJWriter : public vtkPolyDataWriter
{ {
public: public:
static vtkColorMatSource *New(); static vtkOBJWriter *New();
vtkTypeMacro(vtkColorMatSource,vtkPolyDataAlgorithm); vtkTypeMacro(vtkOBJWriter,vtkPolyDataWriter);
void PrintSelf(ostream& os, vtkIndent indent);
virtual void SetColors(const Mat &colors, const Mat &cloud_mask = Mat());
vtkGetMacro(DecimalPrecision, int);
vtkSetMacro(DecimalPrecision, int);
protected: protected:
vtkColorMatSource(); vtkOBJWriter();
~vtkColorMatSource(); ~vtkOBJWriter();
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *); void WriteData();
vtkSmartPointer<vtkUnsignedCharArray> scalars; int DecimalPrecision;
private:
vtkColorMatSource(const vtkColorMatSource&); // Not implemented.
void operator=(const vtkColorMatSource&); // Not implemented.
template<typename _Msk, class _NanPred> private:
void filterNanCopy(const Mat& colors, const Mat& mask); vtkOBJWriter(const vtkOBJWriter&); // Not implemented.
void operator=(const vtkOBJWriter&); // Not implemented.
}; };
} }
} }
......
modules/viz/src/vtk/vtkColorMatSource.cpp → modules/viz/src/vtk/vtkXYZWriter.cpp
View file @ 84d6fe39
...@@ -46,87 +46,48 @@ ...@@ -46,87 +46,48 @@
namespace cv { namespace viz namespace cv { namespace viz
{ {
vtkStandardNewMacro(vtkColorMatSource); vtkStandardNewMacro(vtkXYZWriter);
struct IsNotNan
{
template<typename _Tp>
bool operator()(const _Tp* data) const
{
return !isNan(data[0]) && !isNan(data[1]) && !isNan(data[2]);
}
};
struct AllOk
{
template<typename _Tp>
bool operator()(const _Tp*) const { return true; }
};
}} }}
cv::viz::vtkColorMatSource::vtkColorMatSource() { SetNumberOfInputPorts(0); } cv::viz::vtkXYZWriter::vtkXYZWriter()
cv::viz::vtkColorMatSource::~vtkColorMatSource() {}
void cv::viz::vtkColorMatSource::SetColors(const Mat &colors, const Mat& mask)
{
CV_Assert(colors.depth() == CV_8U && colors.channels() <= 4 && colors.channels() != 2);
CV_Assert(mask.empty() || mask.depth() == CV_32F || mask.depth() == CV_64F);
if (!mask.empty() && mask.depth() == CV_32F)
filterNanCopy<float, IsNotNan>(colors, mask);
else if (!mask.empty() && mask.depth() == CV_64F)
filterNanCopy<double, IsNotNan>(colors, mask);
else /* mask.empty() */
filterNanCopy<double, AllOk>(colors, mask);
}
int cv::viz::vtkColorMatSource::RequestData(vtkInformation *vtkNotUsed(request), vtkInformationVector **vtkNotUsed(inputVector), vtkInformationVector *outputVector)
{ {
vtkInformation *outInfo = outputVector->GetInformationObject(0); std::ofstream fout; // only used to extract the default precision
vtkPolyData *output = vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT())); this->DecimalPrecision = fout.precision();
output->GetPointData()->SetScalars(scalars);
return 1;
} }
template<typename _Msk, class _NanPred> void cv::viz::vtkXYZWriter::WriteData()
void cv::viz::vtkColorMatSource::filterNanCopy(const Mat& colors, const Mat& cloud_mask)
{ {
Mat buffer(colors.size(), CV_8UC3); vtkPolyData *input = this->GetInput();
Vec3b* pos = buffer.ptr<Vec3b>(); if (!input)
return;
int s_chs = colors.channels(); // OpenVTKFile() will report any errors that happen
int m_chs = cloud_mask.channels(); ostream *outfilep = this->OpenVTKFile();
if (!outfilep)
return;
_NanPred pred; ostream &outfile = *outfilep;
for (int y = 0; y < colors.rows; ++y) for(vtkIdType i = 0; i < input->GetNumberOfPoints(); ++i)
{ {
const unsigned char* srow = colors.ptr<unsigned char>(y); Vec3d p;
const unsigned char* send = srow + colors.cols * colors.channels(); input->GetPoint(i, p.val);
const _Msk* mrow = cloud_mask.empty() ? 0 : cloud_mask.ptr<_Msk>(y); outfile << std::setprecision(this->DecimalPrecision) << p[0] << " " << p[1] << " " << p[2] << std::endl;
}
if (colors.channels() == 1) // Close the file
{ this->CloseVTKFile(outfilep);
for (; srow != send; srow += s_chs, mrow += m_chs)
if (pred(mrow))
*pos++ = Vec3b(srow[0], srow[0], srow[0]);
}
else
for (; srow != send; srow += s_chs, mrow += m_chs)
if (pred(mrow))
*pos++ = Vec3b(srow[2], srow[1], srow[0]);
// Delete the file if an error occurred
if (this->ErrorCode == vtkErrorCode::OutOfDiskSpaceError)
{
vtkErrorMacro("Ran out of disk space; deleting file: " << this->FileName);
unlink(this->FileName);
} }
}
int total = pos - buffer.ptr<Vec3b>(); void cv::viz::vtkXYZWriter::PrintSelf(ostream& os, vtkIndent indent)
Vec3b* array = new Vec3b[total]; {
std::copy(buffer.ptr<Vec3b>(), pos, array); this->Superclass::PrintSelf(os,indent);
os << indent << "DecimalPrecision: " << this->DecimalPrecision << "\n";
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New();
scalars->SetName("colors");
scalars->SetNumberOfComponents(3);
scalars->SetNumberOfTuples(total);
scalars->SetArray(array->val, total * 3, 0);
} }
modules/viz/src/vtk/vtkCloudColorMatSource.h → modules/viz/src/vtk/vtkXYZWriter.h
View file @ 84d6fe39
...@@ -42,47 +42,37 @@ ...@@ -42,47 +42,37 @@
// //
//M*/ //M*/
#ifndef __vtkCloudColorMatSource_h #ifndef __vtkXYZWriter_h
#define __vtkCloudColorMatSource_h #define __vtkXYZWriter_h
#include <opencv2/core/mat.hpp> #include "vtkPolyDataWriter.h"
#include <vtkPolyDataAlgorithm.h>
#include <vtkSmartPointer.h>
#include <vtkPoints.h>
#include <vtkCellArray.h>
namespace cv namespace cv
{ {
namespace viz namespace viz
{ {
class vtkCloudColorMatSource : public vtkPolyDataAlgorithm class vtkXYZWriter : public vtkPolyDataWriter
{ {
public: public:
static vtkCloudColorMatSource *New(); static vtkXYZWriter *New();
vtkTypeMacro(vtkCloudColorMatSource,vtkPolyDataAlgorithm); vtkTypeMacro(vtkXYZWriter,vtkPolyDataWriter);
void PrintSelf(ostream& os, vtkIndent indent);
virtual void SetCloud(const Mat& cloud); vtkGetMacro(DecimalPrecision, int);
virtual void SetColors(const Mat &colors, const Mat &cloud_mask); vtkSetMacro(DecimalPrecision, int);
protected: protected:
vtkCloudColorMatSource(); vtkXYZWriter();
~vtkCloudColorMatSource(); ~vtkXYZWriter(){}
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *); void WriteData();
vtkSmartPointer<vtkPoints> points; int DecimalPrecision;
vtkSmartPointer<vtkCellArray> vertices;
vtkSmartPointer<vtkUnsignedCharArray> scalars;
private:
vtkCloudColorMatSource(const vtkCloudColorMatSource&); // Not implemented.
void operator=(const vtkCloudColorMatSource&); // Not implemented.
template<typename _Tp> int filterNanCopy(const Mat& source, int dataType);
template<typename _Msk, class _NanPred> private:
void filterNanCopy(const Mat& colors, const Mat& mask); vtkXYZWriter(const vtkXYZWriter&); // Not implemented.
void operator=(const vtkXYZWriter&); // Not implemented.
}; };
} }
} }
#endif #endif
modules/viz/test/test_tutorial3.cpp
View file @ 84d6fe39
...@@ -3,28 +3,6 @@ ...@@ -3,28 +3,6 @@
using namespace cv; using namespace cv;
using namespace std; using namespace std;
/**
* @function cvcloud_load
* @brief load bunny.ply
*/
Mat cvcloud_load()
{
Mat cloud(1, 20000, CV_32FC3);
ifstream ifs("d:/cloud_dragon.ply");
string str;
for(size_t i = 0; i < 12; ++i)
getline(ifs, str);
Point3f* data = cloud.ptr<cv::Point3f>();
//float dummy1, dummy2;
for(size_t i = 0; i < 20000; ++i)
ifs >> data[i].x >> data[i].y >> data[i].z;// >> dummy1 >> dummy2;
//cloud *= 5.0f;
return cloud;
}
/** /**
* @function main * @function main
*/ */
...@@ -47,7 +25,7 @@ void tutorial3(bool camera_pov) ...@@ -47,7 +25,7 @@ void tutorial3(bool camera_pov)
Affine3f transform = viz::makeTransformToGlobal(Vec3f(0.0f,-1.0f,0.0f), Vec3f(-1.0f,0.0f,0.0f), Vec3f(0.0f,0.0f,-1.0f), cam_pos); Affine3f transform = viz::makeTransformToGlobal(Vec3f(0.0f,-1.0f,0.0f), Vec3f(-1.0f,0.0f,0.0f), Vec3f(0.0f,0.0f,-1.0f), cam_pos);
/// Create a cloud widget. /// Create a cloud widget.
Mat bunny_cloud = cvcloud_load(); Mat bunny_cloud = viz::readCloud("d:/cloud_dragon.ply");
viz::WCloud cloud_widget(bunny_cloud, viz::Color::green()); viz::WCloud cloud_widget(bunny_cloud, viz::Color::green());
/// Pose of the widget in camera frame /// Pose of the widget in camera frame
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment