2 // 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)
4 #include "bbcreaVtkCreateMeshFromPoints.h"
5 #include "bbcreaVtkPackage.h"
7 #include "vtkTriangleStrip.h"
8 #include "vtkTriangle.h"
14 BBTK_ADD_BLACK_BOX_TO_PACKAGE(creaVtk,CreateMeshFromPoints)
15 BBTK_BLACK_BOX_IMPLEMENTATION(CreateMeshFromPoints,bbtk::AtomicBlackBox);
17 // 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)
19 void CreateMeshFromPoints::Process()
22 // THE MAIN PROCESSING METHOD BODY
23 // Here we simply set the input 'In' value to the output 'Out'
24 // And print out the output value
25 // INPUT/OUTPUT ACCESSORS ARE OF THE FORM :
26 // void bbSet{Input|Output}NAME(const TYPE&)
27 // const TYPE& bbGet{Input|Output}NAME() const
29 // * NAME is the name of the input/output
30 // (the one provided in the attribute 'name' of the tag 'input')
31 // * TYPE is the C++ type of the input/output
32 // (the one provided in the attribute 'type' of the tag 'input')
34 // bbSetOutputOut( bbGetInputIn() );
35 // std::cout << "Output value = " <<bbGetOutputOut() << std::endl;
37 std::vector<double> lstX = bbGetInputLstX();
38 std::vector<double> lstY = bbGetInputLstY();
39 std::vector<double> lstZ = bbGetInputLstZ();
40 std::vector<int> lstIndexs = bbGetInputLstIndexs();
41 double pointsCentroid[3];
42 if ( (lstIndexs.size()<1) || (lstX.size()==0) || (lstX.size()!=lstY.size()) || (lstY.size()!=lstZ.size()) )
44 printf("Warning! CreateMeshFromPoints::Process: List of points X Y Z and LstIndexes is not correct\n");
47 int ii,sizeSegment1,sizeSegment2;
49 // vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
50 if (points!=NULL) points->Delete();
51 points = vtkPoints::New();
52 int i,sizeLstX = lstX.size();
53 for (i=0;i<sizeLstX;i++)
55 points->InsertNextPoint(lstX[i],lstY[i],lstZ[i]);
56 pointsCentroid[0] += lstX[i];
57 pointsCentroid[1] += lstY[i];
58 pointsCentroid[2] += lstZ[i];
60 pointsCentroid[0] /= sizeLstX;
61 pointsCentroid[1] /= sizeLstX;
62 pointsCentroid[2] /= sizeLstX;
64 if ((bbGetInputCloseSurface()==true) && (lstIndexs.size()>=2) )
66 //check if initial and end points are the same in all splines (splines are in line shape and not U shape)
67 //to not apply changes because clean polydata will take care of it.
69 bool differentPoints = false;
70 for(i=0; i < lstIndexs.size() && !differentPoints;i++){
71 bool sameStart = lstX[count] != lstX[count+lstIndexs[i]-1] && lstY[count] != lstY[count+lstIndexs[i]-1] && lstZ[count] != lstZ[count+lstIndexs[i]-1];
72 bool sameEnd = lstX[count] != lstX[count+lstIndexs[i]-1] && lstY[count] != lstY[count+lstIndexs[i]-1] && lstZ[count] != lstZ[count+lstIndexs[i]-1];
73 if(!(sameStart && sameEnd)) differentPoints = true;
74 count += lstIndexs[i];
76 //Correct surface normals if needed
79 double pointSurf1[3], pointSurf2[3], pointSurf3[3];
80 double vect1[3], vect2[3];
81 double surfNormal[3], vectorCenter[3];
82 double dotNormalSurf = 0;
83 for(int pIndex = 0; pIndex < lstIndexs[0]-1; pIndex++)
85 pointSurf1[0] = lstX[pIndex];
86 pointSurf1[1] = lstY[pIndex];
87 pointSurf1[2] = lstZ[pIndex];
88 vtkMath::Subtract(pointsCentroid, pointSurf1, vectorCenter);
89 pointSurf2[0] = lstX[pIndex+lstIndexs[1]];
90 pointSurf2[1] = lstY[pIndex+lstIndexs[1]];
91 pointSurf2[2] = lstZ[pIndex+lstIndexs[1]];
92 pointSurf3[0] = lstX[pIndex+1];
93 pointSurf3[1] = lstY[pIndex+1];
94 pointSurf3[2] = lstZ[pIndex+1];
95 vtkMath::Subtract(pointSurf2, pointSurf1, vect1);
96 vtkMath::Subtract(pointSurf3, pointSurf1, vect2);
97 vtkMath::Cross(vect1, vect2, surfNormal);
98 dotNormalSurf += vtkMath::Dot(surfNormal, vectorCenter);
101 if(dotNormalSurf > 0){
103 points = vtkPoints::New();
104 for(int splineI = 0; splineI < lstIndexs.size(); splineI++){
105 for (i=lstIndexs[splineI]-1; i >= 0;i--)
107 points->InsertNextPoint(lstX[splineI*lstIndexs[0]+i],lstY[splineI*lstIndexs[0]+i],lstZ[splineI*lstIndexs[0]+i]);
110 } // if dotNormalSurf
111 }// if differentPoints
115 // vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
116 if (cells!=NULL) cells->Delete();
117 cells = vtkCellArray::New();
119 int maxSegment1,maxSegment2;
122 int sizeLstIdexes=lstIndexs.size();
123 for (i=0; i<sizeLstIdexes-1; i++ )
125 sizeSegment1 = lstIndexs[i];
126 sizeSegment2 = lstIndexs[i+1];
127 vtkSmartPointer<vtkTriangleStrip> triangleStrip = vtkSmartPointer<vtkTriangleStrip>::New();
128 triangleStrip->GetPointIds()->SetNumberOfIds(sizeSegment1+sizeSegment2);
129 maxElements=sizeSegment1;
130 if (maxElements<sizeSegment2) maxElements=sizeSegment2;
131 maxSegment1 = iGeneral+sizeSegment1;
132 maxSegment2 = iGeneral+sizeSegment1+sizeSegment2;
134 iSeg2 = iGeneral+sizeSegment1;
135 for (ii=0; ii<maxElements; ii++)
137 triangleStrip->GetPointIds()->SetId(ii*2 ,iSeg1);
138 triangleStrip->GetPointIds()->SetId(ii*2+1,iSeg2);
141 if (iSeg1>=maxSegment1) { iSeg1=maxSegment1-1; }
142 if (iSeg2>=maxSegment2) { iSeg2=maxSegment2-1; }
144 iGeneral=iGeneral+sizeSegment1;
145 cells->InsertNextCell(triangleStrip);
149 if(bbGetInputCloseSurface())
151 int lastId1 = lstIndexs[0]-1;
152 int lastId2 = sizeLstX - 1;
153 int firstId2 = sizeLstX - lstIndexs[sizeLstIdexes - 1];
154 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;
155 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;
157 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;
158 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;
160 //false = Open Contour
161 //true = Closed Contour
162 if(!face1open && !face2open)
164 // isClosedCont = true;
165 CloseContourSides(lstIndexs, true, true);
167 else if(!altFace1open && !altFace2open)
169 // isClosedCont = true;
170 CloseContourSides(lstIndexs, false, true);
173 CloseOpenContourSurface(lstIndexs);
177 // vtkPolyData *polydata = vtkPolyData::New();
178 if (polydata!=NULL) polydata->Delete();
179 polydata = vtkPolyData::New();
180 polydata->SetPoints(points);
181 polydata->SetStrips(cells);
182 // vtkCleanPolyData *clean=vtkCleanPolyData::New();
183 if (clean!=NULL) clean->Delete();
184 clean = vtkCleanPolyData::New();
185 clean->SetInputData(polydata);
187 // vtkTriangleFilter *triangle = vtkTriangleFilter::New();
188 if (triangle!=NULL) triangle->Delete();
189 triangle = vtkTriangleFilter::New();
190 triangle->SetInputData( clean->GetOutput() );
192 bbSetOutputOut( triangle->GetOutput() );
193 // bbSetOutputOut( clean->GetOutput() );
195 //printf("PG CreateMeshFromPoints::Process: End\n");
198 * Closes the sides of the contour
199 * iterates in one way or the other, depending on the order of the points and calculated vectors.
200 * uPointOrder: Points are order in a U shape
201 * lstIndexs: number of points on each spline
203 void CreateMeshFromPoints::CloseContourSides(std::vector<int> lstIndexs, bool uPointOrder, bool isClosedCont){
204 int sizeLstIdexes = lstIndexs.size();
205 int sizePoints = bbGetInputLstX().size();
207 int firstIndex, end, centroidId, numPointsFace, contraryId;
208 int increment = uPointOrder?1:sizeLstIdexes;
210 int numProcessFaces = sizeLstIdexes > 1?2:1;
211 for(int facesIdx = 0; facesIdx < numProcessFaces; facesIdx++){
212 std::fill(std::begin(centroid), std::end(centroid), 0);
216 numPointsFace = uPointOrder?lstIndexs[0]: sizeLstIdexes;
217 end = uPointOrder?firstIndex + numPointsFace:sizePoints - lstIndexs[sizeLstIdexes - 1] + 1;
218 contraryId = sizePoints-1;
220 firstIndex = uPointOrder?sizePoints - lstIndexs[sizeLstIdexes-1]:lstIndexs[0]-1;
221 numPointsFace = uPointOrder?lstIndexs[sizeLstIdexes-1]:sizeLstIdexes;
222 end = uPointOrder?firstIndex + numPointsFace:sizePoints;
225 if(numPointsFace > 1)
227 bool validCentroid = CalcValidCentroid(centroid, firstIndex, end, increment, numPointsFace);
230 bool normalOrder = isPointingCorrectly(firstIndex, firstIndex+increment, centroid, contraryId);
231 centroidId = points->InsertNextPoint(centroid[0], centroid[1], centroid[2]);
232 //vtkSmartPointer<vtkTriangleStrip> triangleStrip = vtkSmartPointer<vtkTriangleStrip>::New();
233 //triangleStrip->GetPointIds()->SetNumberOfIds(numPointsFace*2 + (!isClosedCont?2:0));
234 //int triangleIndex = 0;
237 int initial = firstIndex;
238 for(int index = initial; index < end; index+=increment){
239 if(index+increment >= end && !isClosedCont){
240 vtkNew<vtkTriangle> triangle;
241 triangle->GetPointIds()->SetId(0, index);
242 triangle->GetPointIds()->SetId(1, initial);
243 triangle->GetPointIds()->SetId(2, centroidId);
244 cells->InsertNextCell(triangle);
245 }else if(index+increment < end){
246 vtkNew<vtkTriangle> triangle;
247 triangle->GetPointIds()->SetId(0, index);
248 triangle->GetPointIds()->SetId(1, index+increment);
249 triangle->GetPointIds()->SetId(2, centroidId);
250 cells->InsertNextCell(triangle);
253 triangleStrip->GetPointIds()->SetId(triangleIndex,index);
254 triangleStrip->GetPointIds()->SetId(triangleIndex+1,centroidId);//1
255 if(index+increment >= end && !isClosedCont){
256 triangleStrip->GetPointIds()->SetId(triangleIndex+2,initial);//2
257 triangleStrip->GetPointIds()->SetId(triangleIndex+3,centroidId);//3
262 //cells->InsertNextCell(triangleStrip);
264 int initial = firstIndex-1;
265 int triangleStripStart = end-1;
266 for(int index = triangleStripStart; index > initial; index-=increment){
267 if(index-increment <= initial && !isClosedCont){
268 vtkNew<vtkTriangle> triangle;
269 triangle->GetPointIds()->SetId(0, index);
270 triangle->GetPointIds()->SetId(1, triangleStripStart);
271 triangle->GetPointIds()->SetId(2, centroidId);
272 cells->InsertNextCell(triangle);
273 }else if(index-increment > initial){
274 vtkNew<vtkTriangle> triangle;
275 triangle->GetPointIds()->SetId(0, index);
276 triangle->GetPointIds()->SetId(1, index-increment);
277 triangle->GetPointIds()->SetId(2, centroidId);
278 cells->InsertNextCell(triangle);
289 * Checks if the normal from firstPointId, secPointId and centroid points away
290 * from the vector centroid to contrPointId.
291 * Used to check that the order used to create the new polygons is correct.
293 bool CreateMeshFromPoints::isPointingCorrectly( int firstPointId, int secPointId, double(¢roid)[3], int contrPointId) {
295 double firstPoint[3], secPoint[3], contrPoint[3];
296 points->GetPoint(firstPointId, firstPoint);
297 points->GetPoint(secPointId, secPoint);
299 double firstVect[3], secVect[3], normal[3], contrVect[3];
301 vtkMath::Subtract(firstPoint, centroid, firstVect);
302 vtkMath::Subtract(secPoint, centroid, secVect);
304 points->GetPoint(contrPointId, contrPoint);
305 vtkMath::Subtract(contrPoint, centroid, contrVect);
307 vtkMath::Cross(firstVect, secVect, normal);
309 dotCalc = vtkMath::Dot(normal, contrVect);
315 * Checks if the order of the points represent a curved spline (U shape) or the points resemble a straight spline.
316 * Now it checks the angle between each point and the vector that goes from the last point to the first.
318 * Previous version checked the curvature between 3 points in the spline, but this created problems when the straight lines
319 * had curves in the middle, increasing the curvature although they are not in the U shape.
321 bool CreateMeshFromPoints::CheckLinePointOrder(){
322 int sizePoints = bbGetInputLstX().size();
323 std::vector<int> lstIndexs = bbGetInputLstIndexs();
324 double point1[3], point2[3], point3[3];
326 double firstAngleSum = 0;
327 double secondAngleSum = 0;
329 points->GetPoint(0, point1);
330 points->GetPoint((lstIndexs[0]-1), point3);
333 vtkMath::Subtract(point3, point1, firstVect);
334 for(int i = 0; i < lstIndexs[0]; i++){
335 points->GetPoint(i, point2);
336 vtkMath::Subtract(point2, point1, secVect);
337 firstAngleSum += vtkMath::SignedAngleBetweenVectors(firstVect, secVect, firstVect);
339 points->GetPoint((sizePoints-lstIndexs[0]), point3);
340 vtkMath::Subtract(point3, point1, firstVect);
341 for(int i = 0; i < sizePoints; i+=lstIndexs.size()){
342 points->GetPoint(i, point2);
343 vtkMath::Subtract(point2, point1, secVect);
344 secondAngleSum += vtkMath::SignedAngleBetweenVectors(firstVect, secVect, firstVect);
347 return firstAngleSum < secondAngleSum;
351 * Closes an open contour
352 * lstIndexs: number of points on each spline
354 void CreateMeshFromPoints::CloseOpenContourSurface(std::vector<int> lstIndexs){
355 bool linePointOrder = CheckLinePointOrder();
356 CloseContourSides(lstIndexs, !linePointOrder, false);
357 CloseContourBottom(!linePointOrder);
361 * Calculates centroid and checks if points are collinear.
362 * centroid: array to store calculation
363 * start: start index of points to use
364 * end: end index of points to use
365 * increment: increment to be used in point iteration
366 * numPoints: number of points used to calculate the centroid.
367 * Returns a bool indicating the validity of the centroid calculated.
368 * False = invalid centroid = all points are the same.
370 bool CreateMeshFromPoints::CalcValidCentroid(double(¢roid)[3], int start, int end, int increment, int numPoints){
371 double currPoint[3] = {}, prevPoint[3] = {}, middlePoint[3] = {}, firstPoint[3] = {};
372 double vector1[3], vector2[3];
373 bool samePoint = true;
374 int splineMidPoint = numPoints/2;
375 bool collinear = true;
377 points->GetPoint(start, firstPoint);
378 points->GetPoint(splineMidPoint, middlePoint);
379 vtkMath::Subtract(middlePoint, firstPoint, vector1);
381 for(int i = start; i < end; i+=increment){
382 points->GetPoint(i, currPoint);
383 if(samePoint && i > start && (currPoint[0] != prevPoint[0] || currPoint[1] != prevPoint[1] || currPoint[2] != prevPoint[2])){
387 vtkMath::Subtract(currPoint, firstPoint, vector2);
388 double angle = vtkMath::AngleBetweenVectors(vector1, vector2);
389 if(angle > 0.0001 && collinear){
393 centroid[0] += currPoint[0];
394 centroid[1] += currPoint[1];
395 centroid[2] += currPoint[2];
396 std::copy(std::begin(currPoint), std::end(currPoint), prevPoint);
399 centroid[0] /= numPoints;
400 centroid[1] /= numPoints;
401 centroid[2] /= numPoints;
403 return !samePoint && !collinear;
407 * Closes the bottom of the given countour.
408 * Should only be used when its an open contour.
409 * uPointOrder: points are ordered in U shape
411 void CreateMeshFromPoints::CloseContourBottom(bool uPointOrder){
412 std::vector<int> lstIndexs = bbGetInputLstIndexs();
413 int sizeLstIdexes = lstIndexs.size();
414 int sizeLstX = bbGetInputLstX().size();
416 vtkSmartPointer<vtkTriangleStrip> triangleStripBottom = vtkSmartPointer<vtkTriangleStrip>::New();
417 triangleStripBottom->GetPointIds()->SetNumberOfIds(sizeLstIdexes*2);
419 double originPoint[3];
420 points->GetPoint(0, originPoint);
421 int middleMeshPoint = uPointOrder?lstIndexs[0]/2:lstIndexs[0]*sizeLstIdexes/2;
423 bool normalOrder = isPointingCorrectly(uPointOrder?lstIndexs[0]-1:sizeLstX-lstIndexs[0], uPointOrder?lstIndexs[0]:1, originPoint, middleMeshPoint);
425 int triangleIndex = 0, currentId = 0, nextId = 0;
426 for(int splineIndex = 0; splineIndex < sizeLstIdexes;splineIndex++){
427 nextId = uPointOrder?currentId + lstIndexs[splineIndex] - 1:sizeLstX - sizeLstIdexes + splineIndex;
430 triangleStripBottom->GetPointIds()->SetId(triangleIndex, currentId);
431 triangleStripBottom->GetPointIds()->SetId(triangleIndex+1, nextId);
434 triangleStripBottom->GetPointIds()->SetId(triangleIndex, nextId);
435 triangleStripBottom->GetPointIds()->SetId(triangleIndex+1, currentId);
437 currentId = uPointOrder?nextId + 1: splineIndex+1;
440 cells->InsertNextCell(triangleStripBottom);
444 // 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)
446 void CreateMeshFromPoints::bbUserSetDefaultValues()
449 // SET HERE THE DEFAULT INPUT/OUTPUT VALUES OF YOUR BOX
450 // Here we initialize the input 'In' to 0
452 bbSetInputCloseSurface(false);
460 // 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)
462 void CreateMeshFromPoints::bbUserInitializeProcessing()
465 // THE INITIALIZATION METHOD BODY :
467 // but this is where you should allocate the internal/output pointers
473 // 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)
475 void CreateMeshFromPoints::bbUserFinalizeProcessing()
478 // THE FINALIZATION METHOD BODY :
480 // but this is where you should desallocate the internal/output pointers
485 // EO namespace bbcreaVtk