#include "bbcreaVtkCreateMeshFromPoints.h"
#include "bbcreaVtkPackage.h"
-#include "vtkPoints.h"
#include "vtkTriangleStrip.h"
-#include "vtkCellArray.h"
-
-#include "vtkCleanPolyData.h"
-
+#include "vtkTriangle.h"
+#include <vtkMath.h>
namespace bbcreaVtk
{
// bbSetOutputOut( bbGetInputIn() );
// std::cout << "Output value = " <<bbGetOutputOut() << std::endl;
-
-printf("EED CreateMeshFromPoints::Process Start\n");
-
-
std::vector<double> lstX = bbGetInputLstX();
std::vector<double> lstY = bbGetInputLstY();
std::vector<double> lstZ = bbGetInputLstZ();
std::vector<int> lstIndexs = bbGetInputLstIndexs();
-
-
- if ( (lstIndexs.size()<=1) || (lstX.size()==0) || (lstX.size()!=lstY.size()) || (lstY.size()!=lstZ.size()) )
+ if ( (lstIndexs.size()<1) || (lstX.size()==0) || (lstX.size()!=lstY.size()) || (lstY.size()!=lstZ.size()) )
{
- printf("Warnning! CreateMeshFromPoints::Process: List of points X Y Z and LstIndexes is not correct\n");
+ printf("Warning! CreateMeshFromPoints::Process: List of points X Y Z and LstIndexes is not correct\n");
+ bbSetOutputOut(NULL);
} else {
-
int ii,sizeSegment1,sizeSegment2;
int endSegment;
-
- vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+// vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
+ if (points!=NULL) points->Delete();
+ points = vtkPoints::New();
int i,sizeLstX = lstX.size();
for (i=0;i<sizeLstX;i++)
{
points->InsertNextPoint(lstX[i],lstY[i],lstZ[i]);
} // for i
-
- vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
+// vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
+ if (cells!=NULL) cells->Delete();
+ cells = vtkCellArray::New();
int maxElements;
int maxSegment1,maxSegment2;
int iSeg1,iSeg2;
-
int iGeneral = 0;
int sizeLstIdexes=lstIndexs.size();
- for (i=0; i<sizeLstIdexes-1;i++)
+ for (i=0; i<sizeLstIdexes-1; i++ )
{
- sizeSegment1=lstIndexs[i];
- sizeSegment2=lstIndexs[i+1];
-
+ sizeSegment1 = lstIndexs[i];
+ sizeSegment2 = lstIndexs[i+1];
vtkSmartPointer<vtkTriangleStrip> triangleStrip = vtkSmartPointer<vtkTriangleStrip>::New();
triangleStrip->GetPointIds()->SetNumberOfIds(sizeSegment1+sizeSegment2);
-
maxElements=sizeSegment1;
if (maxElements<sizeSegment2) maxElements=sizeSegment2;
- maxSegment1=iGeneral+sizeSegment1;
- maxSegment2=iGeneral+sizeSegment1+sizeSegment2;
- iSeg1=iGeneral;
- iSeg2=iGeneral+sizeSegment1;
+ maxSegment1 = iGeneral+sizeSegment1;
+ maxSegment2 = iGeneral+sizeSegment1+sizeSegment2;
+ iSeg1 = iGeneral;
+ iSeg2 = iGeneral+sizeSegment1;
for (ii=0; ii<maxElements; ii++)
{
triangleStrip->GetPointIds()->SetId(ii*2 ,iSeg1);
triangleStrip->GetPointIds()->SetId(ii*2+1,iSeg2);
iSeg1++;
iSeg2++;
- if (iSeg1>=maxSegment1) iSeg1=maxSegment1-1;
- if (iSeg2>=maxSegment2) iSeg2=maxSegment2-1;
+ if (iSeg1>=maxSegment1) { iSeg1=maxSegment1-1; }
+ if (iSeg2>=maxSegment2) { iSeg2=maxSegment2-1; }
} // for ii
iGeneral=iGeneral+sizeSegment1;
cells->InsertNextCell(triangleStrip);
-
} //for LstIndexs
- vtkPolyData *polydata = vtkPolyData::New();
+ if(bbGetInputCloseSurface())
+ {
+ int lastId1 = lstIndexs[0]-1;
+ int lastId2 = sizeLstX - 1;
+ int firstId2 = sizeLstX - lstIndexs[sizeLstIdexes - 1];
+ bool face1open = std::fabs(lstX[0] - lstX[lastId1]) > 0.0001 && std::fabs(lstY[0] - lstY[lastId1]) > 0.0001 && std::fabs(lstZ[0] - lstZ[lastId1]) > 0.0001;
+ bool face2open = std::fabs(lstX[firstId2] - lstX[lastId2]) > 0.0001 && std::fabs(lstY[firstId2] - lstY[lastId2]) > 0.0001 && std::fabs(lstZ[firstId2] - lstZ[lastId2]) > 0.0001;
+
+ bool altFace1open = std::fabs(lstX[0] - lstX[firstId2]) > 0.0001 && std::fabs(lstY[0] - lstY[firstId2]) > 0.0001 && std::fabs(lstZ[0] - lstZ[firstId2]) > 0.0001;
+ bool altFace2open = std::fabs(lstX[lastId1] - lstX[lastId2]) > 0.0001 && std::fabs(lstY[lastId1] - lstY[lastId2]) > 0.0001 && std::fabs(lstZ[lastId1] - lstZ[lastId2]) > 0.0001;
+
+ //false = Open Contour
+ //true = Closed Contour
+ if(!face1open && !face2open)
+ {
+// isClosedCont = true;
+ CloseContourSides(lstIndexs, true, true);
+ }
+ else if(!altFace1open && !altFace2open)
+ {
+// isClosedCont = true;
+ CloseContourSides(lstIndexs, false, true);
+ }
+ else{
+ CloseOpenContourSurface(lstIndexs);
+ }
+ }
+
+// vtkPolyData *polydata = vtkPolyData::New();
+ if (polydata!=NULL) polydata->Delete();
+ polydata = vtkPolyData::New();
polydata->SetPoints(points);
polydata->SetStrips(cells);
-
- vtkCleanPolyData *clean=vtkCleanPolyData::New();
+// vtkCleanPolyData *clean=vtkCleanPolyData::New();
+ if (clean!=NULL) clean->Delete();
+ clean = vtkCleanPolyData::New();
clean->SetInputData(polydata);
clean->Update();
+// vtkTriangleFilter *triangle = vtkTriangleFilter::New();
+ if (triangle!=NULL) triangle->Delete();
+ triangle = vtkTriangleFilter::New();
+ triangle->SetInputData( clean->GetOutput() );
+ triangle->Update();
+ bbSetOutputOut( triangle->GetOutput() );
+ // bbSetOutputOut( clean->GetOutput() );
+ }// if listXYZ size
+ //printf("PG CreateMeshFromPoints::Process: End\n");
+}
+/**
+* Closes the sides of the contour
+* iterates in one way or the other, depending on the order of the points and calculated vectors.
+* uPointOrder: Points are order in a U shape
+* lstIndexs: number of points on each spline
+*/
+void CreateMeshFromPoints::CloseContourSides(std::vector<int> lstIndexs, bool uPointOrder, bool isClosedCont){
+ int sizeLstIdexes = lstIndexs.size();
+ int sizePoints = bbGetInputLstX().size();
+
+ int firstIndex, end, centroidId, numPointsFace, contraryId;
+ int increment = uPointOrder?1:sizeLstIdexes;
+ double centroid[3];
+ int numProcessFaces = sizeLstIdexes > 1?2:1;
+ for(int facesIdx = 0; facesIdx < numProcessFaces; facesIdx++){
+ std::fill(std::begin(centroid), std::end(centroid), 0);
+ if(facesIdx == 0)
+ {
+ firstIndex = 0;
+ numPointsFace = uPointOrder?lstIndexs[0]: sizeLstIdexes;
+ end = uPointOrder?firstIndex + numPointsFace:sizePoints - lstIndexs[sizeLstIdexes - 1] + 1;
+ contraryId = sizePoints-1;
+ }else{
+ firstIndex = uPointOrder?sizePoints - lstIndexs[sizeLstIdexes-1]:lstIndexs[0]-1;
+ numPointsFace = uPointOrder?lstIndexs[sizeLstIdexes-1]:sizeLstIdexes;
+ end = uPointOrder?firstIndex + numPointsFace:sizePoints;
+ contraryId = 0;
+ }
+ if(numPointsFace > 1)
+ {
+ bool validCentroid = CalcValidCentroid(centroid, firstIndex, end, increment, numPointsFace);
+ if(validCentroid)
+ {
+ bool normalOrder = isPointingCorrectly(firstIndex, firstIndex+increment, centroid, contraryId);
+ centroidId = points->InsertNextPoint(centroid[0], centroid[1], centroid[2]);
+ if( normalOrder )
+ {
+ int initial = firstIndex;
+ for(int index = initial; index < end; index+=increment){
+ if(index+increment >= end && !isClosedCont){
+ vtkNew<vtkTriangle> triangle;
+ triangle->GetPointIds()->SetId(0, index);
+ triangle->GetPointIds()->SetId(1, initial);
+ triangle->GetPointIds()->SetId(2, centroidId);
+ cells->InsertNextCell(triangle);
+ }else if(index+increment < end){
+ vtkNew<vtkTriangle> triangle;
+ triangle->GetPointIds()->SetId(0, index);
+ triangle->GetPointIds()->SetId(1, index+increment);
+ triangle->GetPointIds()->SetId(2, centroidId);
+ cells->InsertNextCell(triangle);
+ }
+ }
+ } else {
+ int initial = firstIndex-1;
+ int triangleStripStart = end-1;
+ for(int index = triangleStripStart; index > initial; index-=increment){
+ if(index-increment <= initial && !isClosedCont){
+ vtkNew<vtkTriangle> triangle;
+ triangle->GetPointIds()->SetId(0, index);
+ triangle->GetPointIds()->SetId(1, triangleStripStart);
+ triangle->GetPointIds()->SetId(2, centroidId);
+ cells->InsertNextCell(triangle);
+ }else if(index-increment > initial){
+ vtkNew<vtkTriangle> triangle;
+ triangle->GetPointIds()->SetId(0, index);
+ triangle->GetPointIds()->SetId(1, index-increment);
+ triangle->GetPointIds()->SetId(2, centroidId);
+ cells->InsertNextCell(triangle);
+ }
+ }
+ }
+ }//if validCentroid
+ }//if numPointsFace
+ }//for facesIdx
+
+}
- bbSetOutputOut( clean->GetOutput() );
+/**
+* Checks if the normal from firstPointId, secPointId and centroid points away
+* from the vector centroid to contrPointId.
+* Used to check that the order used to create the new polygons is correct.
+*/
+bool CreateMeshFromPoints::isPointingCorrectly( int firstPointId, int secPointId, double(¢roid)[3], int contrPointId) {
+
+ double firstPoint[3], secPoint[3], contrPoint[3];
+ points->GetPoint(firstPointId, firstPoint);
+ points->GetPoint(secPointId, secPoint);
+
+ double firstVect[3], secVect[3], normal[3], contrVect[3];
+
+ vtkMath::Subtract(firstPoint, centroid, firstVect);
+ vtkMath::Subtract(secPoint, centroid, secVect);
+
+ points->GetPoint(contrPointId, contrPoint);
+ vtkMath::Subtract(contrPoint, centroid, contrVect);
+
+ vtkMath::Cross(firstVect, secVect, normal);
+ double dotCalc;
+ dotCalc = vtkMath::Dot(normal, contrVect);
+
+ return dotCalc<0;
+}
- }// if listXYZ size
+/**
+* Checks if points on each side of the shapes represent a curve.
+*/
+bool CreateMeshFromPoints::CheckLinePointOrder(){
+ int sizePoints = bbGetInputLstX().size();
+ std::vector<int> lstIndexs = bbGetInputLstIndexs();
+ double point1[3], point2[3], point3[3];
+ double center[3];
+ double firstRadiusSum = 0;
+ double secondRadiusSum = 0;
+ for(int i = 0; i < lstIndexs[0] && lstIndexs[0] > 9; i+=5){
+ if(i+10 < lstIndexs[0]){
+ points->GetPoint(i, point1);
+ points->GetPoint(i+5, point2);
+ points->GetPoint(i+10, point3);
+ firstRadiusSum += vtkMath::Solve3PointCircle(point1, point2, point3, center);
+ }
+ }
+
+ for(int i = 0; i < sizePoints && lstIndexs.size() > 9; i+=(lstIndexs.size()*5)){
+ if(i+(10*lstIndexs.size()) < sizePoints){
+ points->GetPoint(i, point1);
+ points->GetPoint(i+(5*lstIndexs.size()), point2);
+ points->GetPoint(i+(10*lstIndexs.size()), point3);
+ secondRadiusSum += vtkMath::Solve3PointCircle(point1, point2, point3, center);
+ }
+ }
+
+ return firstRadiusSum > secondRadiusSum;
+}
-printf("EED CreateMeshFromPoints::Process End\n");
+/**
+* Closes an open contour
+* lstIndexs: number of points on each spline
+*/
+void CreateMeshFromPoints::CloseOpenContourSurface(std::vector<int> lstIndexs){
+ bool linePointOrder = CheckLinePointOrder();
+ CloseContourSides(lstIndexs, !linePointOrder, false);
+ CloseContourBottom(!linePointOrder);
+}
+/**
+* Calculates centroid and checks if points are collinear.
+* centroid: array to store calculation
+* start: start index of points to use
+* end: end index of points to use
+* increment: increment to be used in point iteration
+* numPoints: number of points used to calculate the centroid.
+* Returns a bool indicating the validity of the centroid calculated.
+* False = invalid centroid = all points are the same.
+*/
+bool CreateMeshFromPoints::CalcValidCentroid(double(¢roid)[3], int start, int end, int increment, int numPoints){
+ double currPoint[3] = {}, prevPoint[3] = {}, middlePoint[3] = {}, firstPoint[3] = {};
+ double vector1[3], vector2[3];
+ bool samePoint = true;
+ int splineMidPoint = numPoints/2;
+ bool collinear = true;
+
+ points->GetPoint(start, firstPoint);
+ points->GetPoint(splineMidPoint, middlePoint);
+ vtkMath::Subtract(middlePoint, firstPoint, vector1);
+
+ for(int i = start; i < end; i+=increment){
+ points->GetPoint(i, currPoint);
+ if(samePoint && i > start && (currPoint[0] != prevPoint[0] || currPoint[1] != prevPoint[1] || currPoint[2] != prevPoint[2])){
+ samePoint = false;
+ }
+
+ vtkMath::Subtract(currPoint, firstPoint, vector2);
+ double angle = vtkMath::AngleBetweenVectors(vector1, vector2);
+ if(angle > 0.0001 && collinear){
+ collinear = false;
+ }
+
+ centroid[0] += currPoint[0];
+ centroid[1] += currPoint[1];
+ centroid[2] += currPoint[2];
+ std::copy(std::begin(currPoint), std::end(currPoint), prevPoint);
+ }
+
+ centroid[0] /= numPoints;
+ centroid[1] /= numPoints;
+ centroid[2] /= numPoints;
+
+ return !samePoint && !collinear;
+}
+/**
+* Closes the bottom of the given countour.
+* Should only be used when its an open contour.
+* uPointOrder: points are ordered in U shape
+*/
+void CreateMeshFromPoints::CloseContourBottom(bool uPointOrder){
+ std::vector<int> lstIndexs = bbGetInputLstIndexs();
+ int sizeLstIdexes = lstIndexs.size();
+ int sizeLstX = bbGetInputLstX().size();
+
+ vtkSmartPointer<vtkTriangleStrip> triangleStripBottom = vtkSmartPointer<vtkTriangleStrip>::New();
+ triangleStripBottom->GetPointIds()->SetNumberOfIds(sizeLstIdexes*2);
+ int triangleIndex = 0, currentId = 0, nextId = 0;
+ for(int splineIndex = 0; splineIndex < sizeLstIdexes;splineIndex++){
+ triangleStripBottom->GetPointIds()->SetId(triangleIndex, currentId);
+ nextId = uPointOrder?currentId + lstIndexs[splineIndex] - 1:sizeLstX - sizeLstIdexes + splineIndex;
+ triangleStripBottom->GetPointIds()->SetId(triangleIndex+1, nextId);
+ triangleIndex+=2;
+ currentId = uPointOrder?nextId + 1: splineIndex+1;
+ }
+ cells->InsertNextCell(triangleStripBottom);
}
+
//=====
// Before editing this file, make sure it's a file of your own (i.e.: it wasn't generated from xml description; if so : your modifications will be lost)
//=====
// SET HERE THE DEFAULT INPUT/OUTPUT VALUES OF YOUR BOX
// Here we initialize the input 'In' to 0
// bbSetInputIn(0);
-
+ bbSetInputCloseSurface(false);
+ points = NULL;
+ cells = NULL;
+ polydata = NULL;
+ clean = NULL;
+ triangle = NULL;
}
//=====
// Before editing this file, make sure it's a file of your own (i.e.: it wasn't generated from xml description; if so : your modifications will be lost)
git://git.creatis.insa-lyon.fr / creaVtk.git / blobdiff