bool vtkImageDataTest::Run(bool on)
{
lemon::test<> t;
vtkImageData* img = MakeImageData(W, H, L);
int ijk[3] = {1, 1, 1};
t.is(img->ComputePointId(ijk), vtkIdType(W*H+W+1), "Verify Point Id");
t.is(img->ComputeCellId(ijk), vtkIdType((W-1)*(H-1)+W), "Verify Cell Id");
t.is(img->FindPoint(X0+DX/3.0, Y0+DY/3.0, Z0+DZ/3.0), vtkIdType(0), "Verify FindPoint");
t.is(img->GetActualMemorySize(), 4*2*W*H*L/1024, "Verify ActualMemorySize");
t.is(img->GetBounds()[0], X0, "GetBounds()[0]");
t.is(img->GetBounds()[5], Z0+DZ*(L-1), "GetBounds()[1]");
t.is(img->GetDataDimension(), 3, "GetDataDimension");
t.ok(img->GetDataReleased()==0, "GetDataReleased"); // "==0" used to remove warning
t.is(img->GetDimensions()[2], L, "GetDimension");
t.is(img->GetMaximumNumberOfPieces(), -1, "GetMaximumNumberOfPieces");
t.is(img->GetOrigin()[0], X0, "GetOrigin");
t.is(((unsigned long*)img->GetScalarPointer())[W*H*1+W*2+3], (1+2+3)*100, "verify stored data");
t.is(img->GetScalarSize(), 4, "verify GetScalerSize is 4 byte (long)");
t.is(img->GetSpacing()[0], DX, "verify get spacing");
img->Initialize();
t.is(img->GetDimensions()[0], 0, "dimension is reset after Initialize()");
img->SetDimensions(W, H, L);
t.is(img->GetExtent()[1], W-1, "equivalency of SetDimensions and SetExtend()");
img->Delete();
vtkImageDataTest test;
// vtkFilteringTestPipelineTemplate<vtkImageDataTest> pipeline(test);
// pipeline.StartInteraction();
return true;
}
template <typename PointT> void
pcl::visualization::PointCloudColorHandlerRGBCloud<PointT>::getColor (vtkSmartPointer<vtkDataArray> &scalars) const
{
if (!capable_)
return;
if (!scalars)
scalars = vtkSmartPointer<vtkUnsignedCharArray>::New ();
scalars->SetNumberOfComponents (3);
vtkIdType nr_points = vtkIdType (cloud_->points.size ());
reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->SetNumberOfTuples (nr_points);
unsigned char* colors = reinterpret_cast<vtkUnsignedCharArray*>(&(*scalars))->GetPointer (0);
// Color every point
if (nr_points != int (rgb_->points.size ()))
std::fill (colors, colors + nr_points * 3, static_cast<unsigned char> (0xFF));
else
for (vtkIdType cp = 0; cp < nr_points; ++cp)
{
int idx = cp * 3;
colors[idx + 0] = rgb_->points[cp].r;
colors[idx + 1] = rgb_->points[cp].g;
colors[idx + 2] = rgb_->points[cp].b;
}
}
// ----------------------------------------------------------------------------
void ctkVTKChartView::removePlot(vtkPlot* plot)
{
Q_D(ctkVTKChartView);
vtkIdType index = this->plotIndex(plot);
if (index == vtkIdType(-1))
{
return;
}
d->Chart->RemovePlot(index);
emit this->plotRemoved(plot);
this->onChartUpdated();
}
vtkSmartPointer<vtkPolyDataMapper> pointGrid()
{
/* Creating a poly data object of 10x10x10 points */
vtkSmartPointer<vtkPolyData> data = vtkPolyData::New();
size_t width = 5;
size_t height = 5;
size_t depth = 5;
vtkSmartPointer<vtkPoints> vertices = vtkPoints::New();
for (size_t i = 0; i < width; ++i)
for (size_t j = 0; j < height; ++j)
for (size_t k = 0; k < depth; ++k)
vertices->InsertPoint(i * height * depth + j * depth + k,
i * 10.0, j * 10.0, k * 10.0);
data->SetPoints(vertices);
vtkSmartPointer<vtkCellArray> points = vtkCellArray::New();
for (vtkIdType i = 0; i < vtkIdType(width * height * depth); ++i)
points->InsertNextCell(1, &i);
data->SetVerts(points);
/* Adding the radii of spheres as a point dataset */
/* Creating the radii array */
vtkSmartPointer<vtkFloatArray> radii =
vtkSmartPointer<vtkFloatArray>::New();
radii->SetName("radii");
radii->SetNumberOfTuples(width * height * depth);
for (size_t i = 0; i < width; ++i)
for (size_t j = 0; j < height; ++j)
for (size_t k = 0; k < depth; ++k)
{
float a = float(i) / (width - 1) - 0.5;
float b = float(j) / (height - 1) - 0.5;
float c = float(k) / (depth - 1) - 0.5;
float radius = 8 - 5 * 2 * sqrt(a * a + b * b + c * c);
radii->SetTuple(i * height * depth + j * depth + k, &radius);
}
data->GetPointData()->AddArray(radii);
vtkSmartPointer<vtkPolyDataMapper> mapper = vtkPolyDataMapper::New();
/* Assigning the data object directly to the poly mapper */
mapper->SetInputDataObject(data);
mapper->MapDataArrayToVertexAttribute(
"radiusAttrib", "radii", vtkDataObject::FIELD_ASSOCIATION_POINTS, -1);
return mapper;
}
inline void randPSurface(vtkPolyData * polydata, std::vector<double> * cumulativeAreas, double totalArea,
Eigen::Vector4f& p)
{
float r = static_cast<float> (uniform_deviate(rand()) * totalArea);
std::vector<double>::iterator low = std::lower_bound(cumulativeAreas->begin(), cumulativeAreas->end(), r);
vtkIdType el = vtkIdType(low - cumulativeAreas->begin());
double A[3], B[3], C[3];
vtkIdType npts = 0;
vtkIdType *ptIds = NULL;
polydata->GetCellPoints(el, npts, ptIds);
polydata->GetPoint(ptIds[0], A);
polydata->GetPoint(ptIds[1], B);
polydata->GetPoint(ptIds[2], C);
randomPointTriangle(float(A[0]), float(A[1]), float(A[2]), float(B[0]), float(B[1]), float(B[2]), float(C[0]),
float(C[1]), float(C[2]), p);
}
bool HexReader::getEdges()
{
// All line breaks and comments are removed
// so there is no nice structure
edgesDict = getEntry("edges",fileContents);
if(!edgesDict.isEmpty())
{
//remove edges( and the terminating )
edgesDict.replace(QRegExp("edges[\\s,\\n]*\\("),"");
int index=edgesDict.lastIndexOf(")");
edgesDict = edgesDict.left(index);
edgesDict = edgesDict.simplified();
//each entry starts with the type
QRegExp typeReg = QRegExp("[a-z]+",Qt::CaseInsensitive);
while(edgesDict.contains(typeReg)) //while? och capa med right?
{
index = edgesDict.indexOf(typeReg);
QString type=typeReg.cap(0);
int length = typeReg.matchedLength();
//nextInd = -1 if there are no more matches
int nextInd = edgesDict.indexOf(typeReg,index+length);
//returns the entire string if nextInd=-1
QString edgeDict=edgesDict.mid(index,nextInd-index);
//fix edgesDict for next iteration
if(nextInd > -1)
edgesDict=edgesDict.mid(nextInd-1);//what I think right(nextInd) should do
else
edgesDict="";
//get vertIds
QStringList edgeDictList =
edgeDict.simplified().split(" ");
if(edgeDictList.size() < 3) //6?
{
badEdgeEntry(edgeDict);
continue;
}
bool ok0,ok1;
vtkIdType vId0 =
vtkIdType(edgeDictList.at(1).toInt(&ok0));
vtkIdType vId1 =
vtkIdType(edgeDictList.at(2).toInt(&ok1));
vtkIdType eId = findEge(vId0,vId1);
if(eId < 0)
{
badEdgeEntry(edgeDict);
continue;
}
HexEdge *e = HexEdge::SafeDownCast(
readEdges->GetItemAsObject(eId));
if(!(ok0 && ok1))
{
badEdgeEntry(edgeDict);
continue;
}
if(type == "line")
{
//do nothin'
}
else if(type == "arc")
{
double pos[3];
int pInd0 = edgeDict.indexOf("(");
int pInd1 = edgeDict.indexOf(")");
// QString foo = edgeDict.mid(pInd0+1,pInd1-1);
QStringList vertList = edgeDict.mid(pInd0+1,pInd1-pInd0-1)
.simplified().split(" ",QString::SkipEmptyParts);
ok1=true;ok0=true;
pos[0]=vertList.at(0).toDouble(&ok1);
ok0=ok0 & ok1;
pos[1]=vertList.at(1).toDouble(&ok1);
ok0=ok0 & ok1;
pos[2]=vertList.at(2).toDouble(&ok1);
ok0=ok0 & ok1;
e->setType(HexEdge::ARC);
e->setControlPoint(0,pos);
e->redrawedge();
if(!ok0)
{
badEdgeEntry(edgeDict);
continue;
}
}
else
{
badEdgeEntry(edgeDict);
continue;
}
}
return true;
}
else
{
return false;
}
}
/* MAIN FUNCTION */
void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[]){
/* ************** Inputs *******************/
double *v; // Vertices
unsigned int *f; // Faces
/* ************** Others ******************* */
unsigned int nV, nF, i, j;
// Initialize vtk variables
vtkPolyData *surf = vtkPolyData::New();
vtkPoints *sverts = vtkPoints::New();
vtkCellArray *sfaces = vtkCellArray::New();
/* Inputs */
v = mxGetPr(prhs[0]);
f = (unsigned int*)mxGetPr(prhs[1]);
nV = mxGetM(prhs[0]);
nF = mxGetM(prhs[1]);
// Load the point, cell, and data attributes.
for (i=0; i<nV; i++) sverts->InsertPoint(i,v[i],v[nV+i],v[2*nV+i]);
for (i=0; i<nF; i++)
{
sfaces->InsertNextCell(3);
for(j=0;j<3;j++)
sfaces->InsertCellPoint((vtkIdType(f[j*nF+i]-1)));
}
// We now assign the pieces to the vtkPolyData.
surf->SetPoints(sverts);
surf->SetPolys(sfaces);
sverts->Delete();
sfaces->Delete();
vtkPolyDataNormals *pipefinal = vtkPolyDataNormals::New();
pipefinal->SetInput(surf);
pipefinal->ConsistencyOn();
pipefinal->SplittingOff();
pipefinal->NonManifoldTraversalOn();
pipefinal->Update();
/* ************** Outputs *******************/
// Field data for output structure
mxArray *out_verts, *out_faces;
double *out_vertsptr, *out_facesptr;
// field names for output structure
const char *field_names[] = {"vertices", "faces"};
/* ************** Others ******************* */
unsigned int n0,numscalars,numverts,numfaces,count,facecount,nidx;
double pt[3];
int dims[2] = {1, 1},vert_field,face_field;
vtkPoints *pts;
vtkCellArray *polys;
vtkIdTypeArray *faces;
// Get hold of vertices and faces
// Vertices
pts = pipefinal->GetOutput()->GetPoints();
//pts = surf->GetPoints();
numverts = pts->GetNumberOfPoints();
out_verts = mxCreateDoubleMatrix(numverts,3,mxREAL);
out_vertsptr = mxGetPr(out_verts);
for(n0=0;n0<numverts;n0++)
{
pts->GetPoint(n0,pt);
out_vertsptr[n0] = pt[0];
out_vertsptr[numverts+n0] = pt[1];
out_vertsptr[2*numverts+n0] = pt[2];
}
// Faces
polys = pipefinal->GetOutput()->GetPolys();
//polys = surf->GetPolys();
faces = (vtkIdTypeArray*)polys->GetData();
numfaces = polys->GetNumberOfCells();
out_faces = mxCreateDoubleMatrix(numfaces,3,mxREAL);
out_facesptr = mxGetPr(out_faces);
count = 0;
facecount = 0;
nidx = 0;
while(facecount<numfaces)
{
nidx = faces->GetValue(count++);
for(n0=0;n0<nidx;n0++)
if (n0<3)
// Add one to the output as faces are indexed by 0..(n-1)
out_facesptr[n0*numfaces+facecount] = faces->GetValue(count++)+1;
else
// Print warning if face contains more than 3 vertices (non-triangular)
mexPrintf("Warning: Face[%d] has more than 3 vertices[%d].\n",facecount+1,count++);
facecount++;
}
// Create the output structure
plhs[0] = mxCreateStructArray(2, dims, 2, field_names);
vert_field = mxGetFieldNumber(plhs[0],"vertices");
face_field = mxGetFieldNumber(plhs[0],"faces");
mxSetFieldByNumber(plhs[0],0,vert_field,out_verts);
mxSetFieldByNumber(plhs[0],0,face_field,out_faces);
surf->Delete();
pipefinal->Delete();
}
/**
Create the vtkStructuredGrid from the provided workspace
@param progressUpdating: Reporting object to pass progress information up the stack.
@return fully constructed vtkDataSet.
*/
vtkDataSet* vtkMDQuadFactory::create(ProgressAction& progressUpdating) const
{
vtkDataSet* product = tryDelegatingCreation<IMDEventWorkspace, 2>(m_workspace, progressUpdating);
if(product != NULL)
{
return product;
}
else
{
IMDEventWorkspace_sptr imdws = this->castAndCheck<IMDEventWorkspace, 2>(m_workspace);
// Acquire a scoped read-only lock to the workspace (prevent segfault from algos modifying ws)
Mantid::Kernel::ReadLock lock(*imdws);
const size_t nDims = imdws->getNumDims();
size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
/*
Write mask array with correct order for each internal dimension.
*/
bool* masks = new bool[nDims];
for(size_t i_dim = 0; i_dim < nDims; ++i_dim)
{
bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
masks[i_dim] = !bIntegrated; //TRUE for unmaksed, integrated dimensions are masked.
}
//Ensure destruction in any event.
boost::scoped_ptr<IMDIterator> it(imdws->createIterator());
// Create 4 points per box.
vtkPoints *points = vtkPoints::New();
points->SetNumberOfPoints(it->getDataSize() * 4);
// One scalar per box
vtkFloatArray * signals = vtkFloatArray::New();
signals->Allocate(it->getDataSize());
signals->SetName(m_scalarName.c_str());
signals->SetNumberOfComponents(1);
size_t nVertexes;
vtkUnstructuredGrid *visualDataSet = vtkUnstructuredGrid::New();
visualDataSet->Allocate(it->getDataSize());
vtkIdList * quadPointList = vtkIdList::New();
quadPointList->SetNumberOfIds(4);
Mantid::API::CoordTransform* transform = NULL;
if (m_useTransform)
{
transform = imdws->getTransformToOriginal();
}
Mantid::coord_t out[2];
bool* useBox = new bool[it->getDataSize()];
double progressFactor = 0.5/double(it->getDataSize());
double progressOffset = 0.5;
size_t iBox = 0;
do
{
progressUpdating.eventRaised(progressFactor * double(iBox));
Mantid::signal_t signal_normalized= it->getNormalizedSignal();
if (!isSpecial( signal_normalized ) && m_thresholdRange->inRange(signal_normalized))
{
useBox[iBox] = true;
signals->InsertNextValue(static_cast<float>(signal_normalized));
coord_t* coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
delete [] coords;
coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
//Iterate through all coordinates. Candidate for speed improvement.
for(size_t v = 0; v < nVertexes; ++v)
{
coord_t * coord = coords + v*2;
size_t id = iBox*4 + v;
if(m_useTransform)
{
transform->apply(coord, out);
points->SetPoint(id, out[0], out[1], 0);
}
else
{
points->SetPoint(id, coord[0], coord[1], 0);
}
}
// Free memory
delete [] coords;
} // valid number of vertexes returned
else
{
useBox[iBox] = false;
}
++iBox;
} while (it->next());
delete[] masks;
for(size_t ii = 0; ii < it->getDataSize() ; ++ii)
{
progressUpdating.eventRaised((progressFactor * double(ii)) + progressOffset);
if (useBox[ii] == true)
{
vtkIdType pointIds = vtkIdType(ii * 4);
quadPointList->SetId(0, pointIds + 0); //xyx
quadPointList->SetId(1, pointIds + 1); //dxyz
quadPointList->SetId(2, pointIds + 3); //dxdyz
quadPointList->SetId(3, pointIds + 2); //xdyz
visualDataSet->InsertNextCell(VTK_QUAD, quadPointList);
} // valid number of vertexes returned
}
delete[] useBox;
signals->Squeeze();
points->Squeeze();
visualDataSet->SetPoints(points);
visualDataSet->GetCellData()->SetScalars(signals);
visualDataSet->Squeeze();
signals->Delete();
points->Delete();
quadPointList->Delete();
return visualDataSet;
}
}
/**
Create the vtkStructuredGrid from the provided workspace
@param progressUpdating: Reporting object to pass progress information up the
stack.
@return fully constructed vtkDataSet.
*/
vtkSmartPointer<vtkDataSet>
vtkMDQuadFactory::create(ProgressAction &progressUpdating) const {
auto product = tryDelegatingCreation<IMDEventWorkspace, 2>(m_workspace,
progressUpdating);
if (product != nullptr) {
return product;
} else {
g_log.warning() << "Factory " << this->getFactoryTypeName()
<< " is being used. You are viewing data with less than "
"three dimensions in the VSI. \n";
IMDEventWorkspace_sptr imdws =
this->castAndCheck<IMDEventWorkspace, 2>(m_workspace);
// Acquire a scoped read-only lock to the workspace (prevent segfault from
// algos modifying ws)
Mantid::Kernel::ReadLock lock(*imdws);
const size_t nDims = imdws->getNumDims();
size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
/*
Write mask array with correct order for each internal dimension.
*/
auto masks = Mantid::Kernel::make_unique<bool[]>(nDims);
for (size_t i_dim = 0; i_dim < nDims; ++i_dim) {
bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
masks[i_dim] =
!bIntegrated; // TRUE for unmaksed, integrated dimensions are masked.
}
// Make iterator, which will use the desired normalization. Ensure
// destruction in any eventuality.
boost::scoped_ptr<IMDIterator> it(
createIteratorWithNormalization(m_normalizationOption, imdws.get()));
// Create 4 points per box.
vtkNew<vtkPoints> points;
points->SetNumberOfPoints(it->getDataSize() * 4);
// One scalar per box
vtkNew<vtkFloatArray> signals;
signals->Allocate(it->getDataSize());
signals->SetName(vtkDataSetFactory::ScalarName.c_str());
signals->SetNumberOfComponents(1);
size_t nVertexes;
auto visualDataSet = vtkSmartPointer<vtkUnstructuredGrid>::New();
visualDataSet->Allocate(it->getDataSize());
vtkNew<vtkIdList> quadPointList;
quadPointList->SetNumberOfIds(4);
Mantid::API::CoordTransform const *transform = NULL;
if (m_useTransform) {
transform = imdws->getTransformToOriginal();
}
Mantid::coord_t out[2];
auto useBox = std::vector<bool>(it->getDataSize());
double progressFactor = 0.5 / double(it->getDataSize());
double progressOffset = 0.5;
size_t iBox = 0;
do {
progressUpdating.eventRaised(progressFactor * double(iBox));
Mantid::signal_t signal = it->getNormalizedSignal();
if (std::isfinite(signal) && m_thresholdRange->inRange(signal)) {
useBox[iBox] = true;
signals->InsertNextValue(static_cast<float>(signal));
auto coords = std::unique_ptr<coord_t[]>(
it->getVertexesArray(nVertexes, nNonIntegrated, masks.get()));
// Iterate through all coordinates. Candidate for speed improvement.
for (size_t v = 0; v < nVertexes; ++v) {
coord_t *coord = coords.get() + v * 2;
size_t id = iBox * 4 + v;
if (m_useTransform) {
transform->apply(coord, out);
points->SetPoint(id, out[0], out[1], 0);
} else {
points->SetPoint(id, coord[0], coord[1], 0);
}
}
} // valid number of vertexes returned
else {
useBox[iBox] = false;
}
++iBox;
} while (it->next());
for (size_t ii = 0; ii < it->getDataSize(); ++ii) {
progressUpdating.eventRaised((progressFactor * double(ii)) +
progressOffset);
if (useBox[ii] == true) {
vtkIdType pointIds = vtkIdType(ii * 4);
quadPointList->SetId(0, pointIds + 0); // xyx
quadPointList->SetId(1, pointIds + 1); // dxyz
quadPointList->SetId(2, pointIds + 3); // dxdyz
quadPointList->SetId(3, pointIds + 2); // xdyz
visualDataSet->InsertNextCell(VTK_QUAD, quadPointList.GetPointer());
} // valid number of vertexes returned
}
signals->Squeeze();
points->Squeeze();
visualDataSet->SetPoints(points.GetPointer());
visualDataSet->GetCellData()->SetScalars(signals.GetPointer());
visualDataSet->Squeeze();
// Hedge against empty data sets
if (visualDataSet->GetNumberOfPoints() <= 0) {
vtkNullUnstructuredGrid nullGrid;
visualDataSet = nullGrid.createNullData();
}
vtkSmartPointer<vtkDataSet> dataSet = visualDataSet;
return dataSet;
}
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
/* ************** Inputs *******************/
double *v; // Vertices
unsigned int *f; // Faces
double factor1,factor2; // Parameters: Reduction Factor
int interact; // whether or not to interact
/* ************** Outputs *******************/
// Field data for output structure
mxArray *out_verts, *out_faces;
double *out_vertsptr, *out_facesptr;
// field names for output structure
const char *field_names[] = {"vertices", "faces"};
/* ************** Others ******************* */
unsigned int nV, nF, i, j;
unsigned int n0,numscalars,numverts,numfaces,count,facecount,nidx;
double pt[3];
int dims[2] = {1, 1},vert_field,face_field;
// Initialize vtk variables
vtkPolyData *surf = vtkPolyData::New();
vtkPoints *sverts = vtkPoints::New();
vtkCellArray *sfaces = vtkCellArray::New();
vtkSmoothPolyDataFilter *smoother = vtkSmoothPolyDataFilter::New();
//vtkDecimate *decimate = vtkDecimate::New();
vtkDecimatePro *decimate = vtkDecimatePro::New();
vtkPolyDataConnectivityFilter *connector = vtkPolyDataConnectivityFilter::New();
vtkPoints *pts;
vtkCellArray *polys;
vtkIdTypeArray *faces;
/* Inputs */
v = mxGetPr(prhs[0]);
f = (unsigned int*)mxGetPr(prhs[1]);
factor1 = *mxGetPr(prhs[2]);
factor2 = *mxGetPr(prhs[3]);
nV = mxGetM(prhs[0]);
nF = mxGetM(prhs[1]);
if (nrhs==5)
interact = (int)(*mxGetPr(prhs[4]));
else
interact = 0;
// Load the point, cell, and data attributes.
for (i=0; i<nV; i++) sverts->InsertPoint(i,v[i],v[nV+i],v[2*nV+i]);
for (i=0; i<nF; i++)
{
sfaces->InsertNextCell(3);
for(j=0;j<3;j++)
sfaces->InsertCellPoint((vtkIdType(f[j*nF+i]-1)));
}
// We now assign the pieces to the vtkPolyData.
surf->SetPoints(sverts);
sverts->Delete();
surf->SetPolys(sfaces);
sfaces->Delete();
// decimate the mesh
//decimate->SetInput(skinExtractor->GetOutput());
decimate->SetInput(surf);
decimate->SetPreserveTopology(int(factor2));
decimate->SetTargetReduction(factor1);
//decimate->SetMaximumCost(factor1);
//decimate->SetMaximumCollapsedEdges(int(factor2));
//decimate->SetInitialFeatureAngle(45);
//decimate->SetMaximumIterations(20);
//decimate->SetMaximumSubIterations(2);
//decimate->PreserveEdgesOn();
//decimate->SetInitialError(.0002);
//decimate->SetErrorIncrement(.0005);
// smooth the mesh
smoother->SetInput(decimate->GetOutput());
smoother->SetNumberOfIterations(10);
smoother->SetRelaxationFactor(0.1);
smoother->SetFeatureAngle(60);
smoother->FeatureEdgeSmoothingOff();
smoother->BoundarySmoothingOff();
smoother->SetConvergence(0);
//extract largest connected region to get a manifold surface
connector->SetInput(smoother->GetOutput());
connector->SetExtractionModeToLargestRegion();
connector->Update();
// Get hold of vertices and faces
// Vertices
pts = connector->GetOutput()->GetPoints();
//pts = surf->GetPoints();
numverts = pts->GetNumberOfPoints();
out_verts = mxCreateDoubleMatrix(numverts,3,mxREAL);
out_vertsptr = mxGetPr(out_verts);
for(n0=0;n0<numverts;n0++)
{
pts->GetPoint(n0,pt);
out_vertsptr[n0] = pt[0];
out_vertsptr[numverts+n0] = pt[1];
out_vertsptr[2*numverts+n0] = pt[2];
}
// Faces
polys = connector->GetOutput()->GetPolys();
//polys = surf->GetPolys();
faces = (vtkIdTypeArray*)polys->GetData();
numfaces = polys->GetNumberOfCells();
out_faces = mxCreateDoubleMatrix(numfaces,3,mxREAL);
out_facesptr = mxGetPr(out_faces);
count = 0;
facecount = 0;
nidx = 0;
while(facecount<numfaces)
{
nidx = faces->GetValue(count++);
for(n0=0;n0<nidx;n0++)
if (n0<3)
// Add one to the output as faces are indexed by 0..(n-1)
out_facesptr[n0*numfaces+facecount] = faces->GetValue(count++)+1;
else
// Print warning if face contains more than 3 vertices (non-triangular)
mexPrintf("Warning: Face[%d] has more than 3 vertices[%d].\n",facecount+1,count++);
facecount++;
}
// Create the output structure
plhs[0] = mxCreateStructArray(2, dims, NUMBER_OF_FIELDS, field_names);
vert_field = mxGetFieldNumber(plhs[0],"vertices");
face_field = mxGetFieldNumber(plhs[0],"faces");
mxSetFieldByNumber(plhs[0],0,vert_field,out_verts);
mxSetFieldByNumber(plhs[0],0,face_field,out_faces);
// Clean up. Delete all vtk objects
surf->Delete();
decimate->Delete();
smoother->Delete();
connector->Delete();
}
