bbtk_creaVtk_PKG/src/bbcreaVtkCreateMeshFromPoints.cxx

   1 //=====
   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)
   3 //=====
   4 #include "bbcreaVtkCreateMeshFromPoints.h"
   5 #include "bbcreaVtkPackage.h"
   6
   7 #include "vtkTriangleStrip.h"
   8 #include <vtkMath.h>
   9
  10 namespace bbcreaVtk
  11 {
  12
  13 BBTK_ADD_BLACK_BOX_TO_PACKAGE(creaVtk,CreateMeshFromPoints)
  14 BBTK_BLACK_BOX_IMPLEMENTATION(CreateMeshFromPoints,bbtk::AtomicBlackBox);
  15 //=====
  16 // 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)
  17 //=====
  18 void CreateMeshFromPoints::Process()
  19 {
  20
  21 // THE MAIN PROCESSING METHOD BODY
  22 //   Here we simply set the input 'In' value to the output 'Out'
  23 //   And print out the output value
  24 // INPUT/OUTPUT ACCESSORS ARE OF THE FORM :
  25 //    void bbSet{Input|Output}NAME(const TYPE&)
  26 //    const TYPE& bbGet{Input|Output}NAME() const
  27 //    Where :
  28 //    * NAME is the name of the input/output
  29 //      (the one provided in the attribute 'name' of the tag 'input')
  30 //    * TYPE is the C++ type of the input/output
  31 //      (the one provided in the attribute 'type' of the tag 'input')
  32
  33 //    bbSetOutputOut( bbGetInputIn() );
  34 //    std::cout << "Output value = " <<bbGetOutputOut() << std::endl;
  35
  36                 std::vector<double> lstX                = bbGetInputLstX();
  37                 std::vector<double> lstY                = bbGetInputLstY();
  38                 std::vector<double> lstZ                = bbGetInputLstZ();
  39                 std::vector<int> lstIndexs              = bbGetInputLstIndexs();
  40                 if ( (lstIndexs.size()<=1) || (lstX.size()==0) || (lstX.size()!=lstY.size()) || (lstY.size()!=lstZ.size()) )
  41                 {
  42                         printf("Warning! CreateMeshFromPoints::Process: List of points X Y Z  and LstIndexes is not correct\n");
  43                         bbSetOutputOut(NULL);
  44                 } else  {
  45                         int ii,sizeSegment1,sizeSegment2;
  46                         int endSegment;
  47 //                      vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  48                         if (points!=NULL) points->Delete();
  49                         points = vtkPoints::New();
  50                         int i,sizeLstX  =       lstX.size();
  51                         for (i=0;i<sizeLstX;i++)
  52                         {
  53                                 points->InsertNextPoint(lstX[i],lstY[i],lstZ[i]);
  54                         } // for i
  55 //                      vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
  56                         if (cells!=NULL) cells->Delete();
  57                         cells = vtkCellArray::New();
  58                         int maxElements;
  59                         int maxSegment1,maxSegment2;
  60                         int iSeg1,iSeg2;
  61                         int iGeneral    =       0;
  62                         int     sizeLstIdexes=lstIndexs.size();
  63                         for (i=0; i<sizeLstIdexes-1; i++ )
  64                         {
  65                                 sizeSegment1 = lstIndexs[i];
  66                                 sizeSegment2 = lstIndexs[i+1];
  67                                 vtkSmartPointer<vtkTriangleStrip> triangleStrip = vtkSmartPointer<vtkTriangleStrip>::New();
  68                                 triangleStrip->GetPointIds()->SetNumberOfIds(sizeSegment1+sizeSegment2);
  69                                 maxElements=sizeSegment1;
  70                                 if (maxElements<sizeSegment2) maxElements=sizeSegment2;
  71                                 maxSegment1     = iGeneral+sizeSegment1;
  72                                 maxSegment2     = iGeneral+sizeSegment1+sizeSegment2;
  73                                 iSeg1           = iGeneral;
  74                                 iSeg2           = iGeneral+sizeSegment1;
  75                                 for (ii=0; ii<maxElements; ii++)
  76                                 {
  77                                         triangleStrip->GetPointIds()->SetId(ii*2  ,iSeg1);
  78                                         triangleStrip->GetPointIds()->SetId(ii*2+1,iSeg2);
  79                                         iSeg1++;
  80                                         iSeg2++;
  81                     if (iSeg1>=maxSegment1) { iSeg1=maxSegment1-1; }
  82                     if (iSeg2>=maxSegment2) { iSeg2=maxSegment2-1; }
  83                                 } // for ii
  84                                 iGeneral=iGeneral+sizeSegment1;
  85                                 cells->InsertNextCell(triangleStrip);
  86                         } //for  LstIndexs
  87
  88                         int lastId1 = lstIndexs[0]-1;
  89                         int lastId2 = sizeLstX - 1;
  90                         int firstId2 = sizeLstX - lstIndexs[sizeLstIdexes - 1];
  91                         bool face1open = lstX[0] != lstX[lastId1] && lstY[0] != lstY[lastId1] && lstZ[0] != lstZ[lastId1];
  92                         bool face2open = lstX[firstId2] != lstX[lastId2] && lstY[firstId2] != lstY[lastId2] && lstZ[firstId2] != lstZ[lastId2];
  93
  94                         if(bbGetInputCloseSurface())
  95                         {
  96                                 //false = Open Contour
  97                                 //true = Closed Contour
  98                                 if(!face1open && !face2open)
  99                                 {
 100                                         CloseContourSides(lstIndexs, true);
 101                                 }else{
 102                                         CloseOpenContourSurface(lstIndexs);
 103                                 }
 104                         }
 105
 106 //                      vtkPolyData *polydata = vtkPolyData::New();
 107                         if (polydata!=NULL) polydata->Delete();
 108                         polydata = vtkPolyData::New();
 109                         polydata->SetPoints(points);
 110                         polydata->SetStrips(cells);
 111 //                      vtkCleanPolyData *clean=vtkCleanPolyData::New();
 112                         if (clean!=NULL) clean->Delete();
 113                         clean = vtkCleanPolyData::New();
 114                         clean->SetInputData(polydata);
 115                         clean->Update();
 116 //                      vtkTriangleFilter *triangle = vtkTriangleFilter::New();
 117                         if (triangle!=NULL) triangle->Delete();
 118                         triangle = vtkTriangleFilter::New();
 119                         triangle->SetInputData( clean->GetOutput() );
 120                         triangle->Update();
 121             bbSetOutputOut( triangle->GetOutput() );
 122             //            bbSetOutputOut( clean->GetOutput() );
 123                 }// if listXYZ size
 124                 //printf("PG CreateMeshFromPoints::Process: End\n");
 125 }
 126
 127 /**
 128 * Closes the sides of the contour
 129 * iterates in one way or the other, depending on the order of the points and calculated vectors.
 130 * uPointOrder: Points are order in a U shape
 131 * lstIndexs: number of points on each spline
 132 */
 133 void CreateMeshFromPoints::CloseContourSides(std::vector<int> lstIndexs, bool uPointOrder){
 134         int     sizeLstIdexes = lstIndexs.size();
 135         int sizePoints = bbGetInputLstX().size();
 136
 137         int firstIndex, end, centroidId, numPointsFace, contraryId;
 138         int increment = uPointOrder?1:sizeLstIdexes;
 139         double centroid[3];
 140
 141         for(int facesIdx = 0; facesIdx < 2; facesIdx++){
 142                 std::fill(std::begin(centroid), std::end(centroid), 0);
 143                 if(facesIdx == 0)
 144                 {
 145                         firstIndex = 0;
 146                         numPointsFace = uPointOrder?lstIndexs[0]: sizeLstIdexes;
 147                         end = uPointOrder?firstIndex + numPointsFace:sizePoints - lstIndexs[sizeLstIdexes - 1] + 1;
 148                         contraryId = sizePoints-1;
 149                 }else{
 150                         firstIndex = uPointOrder?sizePoints - lstIndexs[sizeLstIdexes-1]:lstIndexs[0]-1;
 151                         numPointsFace = uPointOrder?lstIndexs[sizeLstIdexes-1]:sizeLstIdexes;
 152                         end = uPointOrder?firstIndex + numPointsFace:sizePoints;
 153                         contraryId = 0;
 154                 }
 155                 if(numPointsFace > 1)
 156                 {
 157                         bool validCentroid = CalcValidCentroid(centroid, firstIndex, end, increment, numPointsFace);
 158                         if(validCentroid)
 159                         {
 160                                 bool normalOrder    = isPointingCorrectly(firstIndex, firstIndex+increment, centroid, contraryId);
 161                                 centroidId          = points->InsertNextPoint(centroid[0], centroid[1], centroid[2]);
 162                                 vtkSmartPointer<vtkTriangleStrip> triangleStrip1 = vtkSmartPointer<vtkTriangleStrip>::New();
 163                                 triangleStrip1->GetPointIds()->SetNumberOfIds(numPointsFace*2+1);
 164                                 if( normalOrder )
 165                 {
 166                                         int initial = firstIndex;
 167                                         int triangleIndex = 0;
 168                                         for(int index = initial; index < end; index+=increment){
 169                                                 triangleStrip1->GetPointIds()->SetId(triangleIndex,index);
 170                                                 if(index+increment >= end){
 171                                                         triangleStrip1->GetPointIds()->SetId(triangleIndex+1,initial);//2
 172                                                         triangleStrip1->GetPointIds()->SetId(triangleIndex+2,centroidId);//3
 173                                                 }
 174                                                 else{
 175                                                         triangleStrip1->GetPointIds()->SetId(triangleIndex+1,centroidId);//1
 176                                                 }
 177                                                 triangleIndex+=2;
 178                                         }
 179                                         cells->InsertNextCell(triangleStrip1);
 180                                 } else {
 181                                         int initial = firstIndex-1;
 182                                         int triangleIndex = 0;
 183                                         int triangleStripStart = end-1;
 184                                         for(int index = triangleStripStart; index > initial; index-=increment){
 185                                                 triangleStrip1->GetPointIds()->SetId(triangleIndex,index);
 186                                                 if(index-increment <= initial){
 187                                                         triangleStrip1->GetPointIds()->SetId(triangleIndex+1,triangleStripStart);
 188                                                         triangleStrip1->GetPointIds()->SetId(triangleIndex+2,centroidId);
 189                                                 }else{
 190                                                         triangleStrip1->GetPointIds()->SetId(triangleIndex+1,centroidId);
 191                                                 }
 192                                                 triangleIndex+=2;
 193                                         }
 194                                         cells->InsertNextCell(triangleStrip1);
 195                                 }
 196                         }//if validCentroid
 197                 }//if numPointsFace
 198         }//for facesIdx
 199
 200 }
 201
 202 /**
 203 * Checks if the normal from firstPointId, secPointId and centroid points away
 204 * from the vector centroid to contrPointId.
 205 * Used to check that the order used to create the new polygons is correct.
 206 */
 207 bool CreateMeshFromPoints::isPointingCorrectly( int firstPointId, int secPointId, double(&centroid)[3], int contrPointId) {
 208
 209         double firstPoint[3], secPoint[3], contrPoint[3];
 210         points->GetPoint(firstPointId, firstPoint);
 211         points->GetPoint(secPointId, secPoint);
 212
 213         double firstVect[3], secVect[3], normal[3], contrVect[3];
 214
 215         vtkMath::Subtract(firstPoint, centroid, firstVect);
 216         vtkMath::Subtract(secPoint, centroid, secVect);
 217
 218         points->GetPoint(contrPointId, contrPoint);
 219         vtkMath::Subtract(contrPoint, centroid, contrVect);
 220
 221         vtkMath::Cross(firstVect, secVect, normal);
 222         double dotCalc;
 223         dotCalc = vtkMath::Dot(normal, contrVect);
 224
 225         return dotCalc<0;
 226 }
 227
 228 /**
 229 * Checks if points on each side of the shapes represent a curve.
 230 */
 231 bool CreateMeshFromPoints::CheckLinePointOrder(){
 232         int sizePoints = bbGetInputLstX().size();
 233         std::vector<int> lstIndexs = bbGetInputLstIndexs();
 234         double point1[3], point2[3], point3[3];
 235         double center[3];
 236         double firstRadiusSum = 0;
 237         double secondRadiusSum = 0;
 238         for(int i = 0; i < lstIndexs[0] && lstIndexs[0] > 9; i+=5){
 239                 if(i+10 < lstIndexs[0]){
 240                         points->GetPoint(i, point1);
 241                         points->GetPoint(i+5, point2);
 242                         points->GetPoint(i+10, point3);
 243                         firstRadiusSum += vtkMath::Solve3PointCircle(point1, point2, point3, center);
 244                 }
 245         }
 246
 247         for(int i = 0; i < sizePoints && lstIndexs.size() > 9; i+=(lstIndexs.size()*5)){
 248                 if(i+(10*lstIndexs.size()) < sizePoints){
 249                         points->GetPoint(i, point1);
 250                         points->GetPoint(i+(5*lstIndexs.size()), point2);
 251                         points->GetPoint(i+(10*lstIndexs.size()), point3);
 252                         secondRadiusSum += vtkMath::Solve3PointCircle(point1, point2, point3, center);
 253                 }
 254         }
 255         //cout << firstRadiusSum << endl;
 256         //cout << secondRadiusSum << endl;
 257         return firstRadiusSum > secondRadiusSum;
 258 }
 259
 260 /**
 261 * Closes an open contour
 262 * lstIndexs: number of points on each spline
 263 */
 264 void CreateMeshFromPoints::CloseOpenContourSurface(std::vector<int> lstIndexs){
 265         bool linePointOrder = CheckLinePointOrder();
 266         CloseContourSides(lstIndexs, !linePointOrder);
 267         CloseContourBottom(!linePointOrder);
 268 }
 269
 270 /**
 271 * Calculates centroid and checks if points are collinear.
 272 * centroid: array to store calculation
 273 * start: start index of points to use
 274 * end: end index of points to use
 275 * increment: increment to be used in point iteration
 276 * numPoints: number of points used to calculate the centroid.
 277 * Returns a bool indicating the validity of the centroid calculated.
 278 * False = invalid centroid = all points are the same.
 279 */
 280 bool CreateMeshFromPoints::CalcValidCentroid(double(&centroid)[3], int start, int end, int increment, int numPoints){
 281         double currPoint[3] = {}, prevPoint[3] = {}, middlePoint[3] = {}, firstPoint[3] = {};
 282         double vector1[3], vector2[3];
 283         bool samePoint = true;
 284         int splineMidPoint = numPoints/2;
 285         bool collinear = true;
 286
 287         points->GetPoint(start, firstPoint);
 288         points->GetPoint(splineMidPoint, middlePoint);
 289         vtkMath::Subtract(middlePoint, firstPoint, vector1);
 290
 291         for(int i = start; i < end; i+=increment){
 292                 points->GetPoint(i, currPoint);
 293                 if(samePoint && i > start && (currPoint[0] != prevPoint[0] || currPoint[1] != prevPoint[1] || currPoint[2] != prevPoint[2])){
 294                         samePoint = false;
 295                 }
 296
 297                 vtkMath::Subtract(currPoint, firstPoint, vector2);
 298                 double angle = vtkMath::AngleBetweenVectors(vector1, vector2);
 299                 if(angle > 0.0001 && collinear){
 300                         collinear = false;
 301                 }
 302
 303                 centroid[0] += currPoint[0];
 304                 centroid[1] += currPoint[1];
 305                 centroid[2] += currPoint[2];
 306                 std::copy(std::begin(currPoint), std::end(currPoint), prevPoint);
 307         }
 308
 309         centroid[0] /= numPoints;
 310         centroid[1] /= numPoints;
 311         centroid[2] /= numPoints;
 312
 313         return !samePoint && !collinear;
 314 }
 315
 316 /**
 317 * Closes the bottom of the given countour.
 318 * Should only be used when its an open contour.
 319 * uPointOrder: points are ordered in U shape
 320 */
 321 void CreateMeshFromPoints::CloseContourBottom(bool uPointOrder){
 322         std::vector<int> lstIndexs = bbGetInputLstIndexs();
 323         int sizeLstIdexes = lstIndexs.size();
 324         int sizeLstX = bbGetInputLstX().size();
 325
 326         vtkSmartPointer<vtkTriangleStrip> triangleStripBottom = vtkSmartPointer<vtkTriangleStrip>::New();
 327         triangleStripBottom->GetPointIds()->SetNumberOfIds(sizeLstIdexes*2);
 328         int triangleIndex = 0, currentId = 0, nextId = 0;
 329         for(int splineIndex = 0; splineIndex < sizeLstIdexes;splineIndex++){
 330                 triangleStripBottom->GetPointIds()->SetId(triangleIndex, currentId);
 331                 nextId = uPointOrder?currentId + lstIndexs[splineIndex] - 1:sizeLstX - sizeLstIdexes + splineIndex;
 332                 triangleStripBottom->GetPointIds()->SetId(triangleIndex+1, nextId);
 333                 triangleIndex+=2;
 334                 currentId = uPointOrder?nextId + 1: splineIndex+1;
 335         }
 336         cells->InsertNextCell(triangleStripBottom);
 337 }
 338
 339 //=====
 340 // 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)
 341 //=====
 342 void CreateMeshFromPoints::bbUserSetDefaultValues()
 343 {
 344
 345 //  SET HERE THE DEFAULT INPUT/OUTPUT VALUES OF YOUR BOX
 346 //    Here we initialize the input 'In' to 0
 347 //   bbSetInputIn(0);
 348         bbSetInputCloseSurface(false);
 349         points          = NULL;
 350         cells           = NULL;
 351         polydata        = NULL;
 352         clean           = NULL;
 353         triangle        = NULL;
 354 }
 355 //=====
 356 // 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)
 357 //=====
 358 void CreateMeshFromPoints::bbUserInitializeProcessing()
 359 {
 360
 361 //  THE INITIALIZATION METHOD BODY :
 362 //    Here does nothing
 363 //    but this is where you should allocate the internal/output pointers
 364 //    if any
 365
 366
 367 }
 368 //=====
 369 // 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)
 370 //=====
 371 void CreateMeshFromPoints::bbUserFinalizeProcessing()
 372 {
 373
 374 //  THE FINALIZATION METHOD BODY :
 375 //    Here does nothing
 376 //    but this is where you should desallocate the internal/output pointers
 377 //    if any
 378
 379 }
 380 }
 381 // EO namespace bbcreaVtk
 382
 383