org.simantics.opencascade.vtk/src/org/simantics/opencascade/vtk/VTKOCCTool.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
   3  * Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.opencascade.vtk;
  13
  14 import java.util.List;
  15
  16 import javax.vecmath.Matrix4d;
  17 import javax.vecmath.Point3d;
  18
  19 import org.jcae.opencascade.jni.BRepMesh_IncrementalMesh;
  20 import org.jcae.opencascade.jni.BRep_Tool;
  21 import org.jcae.opencascade.jni.GP_Trsf;
  22 import org.jcae.opencascade.jni.Poly_Triangulation;
  23 import org.jcae.opencascade.jni.TopAbs_Orientation;
  24 import org.jcae.opencascade.jni.TopAbs_ShapeEnum;
  25 import org.jcae.opencascade.jni.TopExp_Explorer;
  26 import org.jcae.opencascade.jni.TopLoc_Location;
  27 import org.jcae.opencascade.jni.TopoDS_Face;
  28 import org.jcae.opencascade.jni.TopoDS_Shape;
  29 import org.simantics.opencascade.OCCTTool;
  30
  31 import vtk.vtkActor;
  32 import vtk.vtkAlgorithmOutput;
  33 import vtk.vtkAppendPolyData;
  34 import vtk.vtkAssembly;
  35 import vtk.vtkCleanPolyData;
  36 import vtk.vtkDataSetMapper;
  37 import vtk.vtkFeatureEdges;
  38 import vtk.vtkGlyph3D;
  39 import vtk.vtkIdList;
  40 import vtk.vtkPoints;
  41 import vtk.vtkPolyData;
  42 import vtk.vtkPolyDataMapper;
  43 import vtk.vtkPolyDataNormals;
  44 import vtk.vtkProp;
  45 import vtk.vtkPropCollection;
  46 import vtk.vtkProperty;
  47 import vtk.vtkSphereSource;
  48 import vtk.vtkTriangle;
  49
  50 public class VTKOCCTool {
  51         public static vtkAssembly vtkTestAssembly() {
  52                 vtkAssembly assemblies = new vtkAssembly();
  53                 vtkPolyData partGrid = createTestPartGrid();
  54                 gridToAssembly(assemblies, partGrid);
  55                 return assemblies;
  56         }
  57
  58         public static vtkAssembly vtkOCCShapeToAssembly(TopoDS_Shape shape) {
  59                 double deflection = 0.001;
  60
  61                 if (deflection <= 0.0) {
  62                         deflection = 0.0005;
  63                         System.out.println("Bad value for deflection. Using: " + deflection);
  64                 }
  65
  66                 // FIXME : leaks memory!
  67                 //BRepTools.clean(shape);
  68
  69                 double mass = OCCTTool.getMass(shape);
  70
  71                 if (mass < 1.0e-12) {
  72                         System.out.println("Non 3D-shape detected");
  73                         System.out.println("The cad import features are currently limited to 3D models.");
  74                 }
  75
  76                 double length = OCCTTool.getBoundingBoxDiagonal(shape);
  77                 deflection *= length; // use relative units
  78
  79                 BRepMesh_IncrementalMesh mesh = new BRepMesh_IncrementalMesh(shape,deflection);
  80
  81                 int faceNumber = 0;
  82                 TopExp_Explorer expFace = new TopExp_Explorer();
  83
  84                 vtkAssembly assemblies = new vtkAssembly();
  85                 for (expFace.init(shape, TopAbs_ShapeEnum.FACE); expFace.more(); expFace.next()) {
  86                         TopoDS_Face face = (TopoDS_Face) expFace.current();
  87                         vtkPolyData partGrid = createPartGrid(face);
  88                         face.delete();
  89                         if (partGrid == null)
  90                                 continue;
  91                         faceNumber++;
  92                         //gridToAssembly(assemblies, partGrid, stlSurfaceData, stlEdgeData);
  93                         gridToAssembly(assemblies, partGrid);
  94
  95                 }
  96                 expFace.delete();
  97                 mesh.delete();
  98
  99                 if (faceNumber == 0) {
 100                         System.out
 101                         .println("Cad import: error: no surface triangulation was generated.");
 102                         return null;
 103                 }
 104
 105                 return assemblies;
 106         }
 107
 108         private static void gridToAssembly(vtkAssembly assemblies, vtkPolyData partGrid, vtkAppendPolyData stlSurfaceData, vtkAppendPolyData stlEdgeData) {
 109
 110                 double featureAngle = 30;
 111
 112
 113                 vtkDataSetMapper partMapper = new vtkDataSetMapper();
 114
 115                 boolean computeNormals = true;
 116                 boolean cleanPart = true;
 117                 boolean mergePoints = false;
 118
 119                 vtkCleanPolyData partCleaner = new vtkCleanPolyData();
 120                 if (cleanPart)
 121                 {
 122                         partCleaner.SetInputData(partGrid);
 123                         if(mergePoints) {
 124                                 partCleaner.PointMergingOn();
 125                         } else {
 126                                 partCleaner.PointMergingOff();
 127                         }
 128                 }
 129
 130                 if (computeNormals)
 131                 {
 132                         vtkPolyDataNormals partNormals = new vtkPolyDataNormals();
 133
 134                         if (cleanPart)
 135                         {
 136                                 partNormals.SetInputConnection(partCleaner.GetOutputPort());
 137                         }
 138                         else partNormals.SetInputData(partGrid);
 139
 140                         partNormals.SetFeatureAngle(featureAngle); // this do not have to be neccesarily called
 141                         partMapper.SetInputConnection(partNormals.GetOutputPort());
 142                         partNormals.Delete();
 143                 }
 144                 else
 145                 {
 146                         if (cleanPart) partMapper.SetInputConnection(partCleaner.GetOutputPort()); // metoda 2, ne tak pekne, viz http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681
 147                         else partMapper.SetInputData(partGrid); // metoda 1, ne tak pekne stinovani, viz: http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681
 148                 }
 149                 partMapper.ScalarVisibilityOn();
 150
 151                 vtkActor partActor = new vtkActor();
 152
 153                 partActor.SetPickable(1);
 154                 partActor.GetProperty().SetColor(1, 1, 0);
 155                 partActor.SetMapper(partMapper);
 156
 157                 // EDGES OF PARTS DETECTION
 158                 vtkFeatureEdges partEdges = new vtkFeatureEdges();
 159                 if (cleanPart) partEdges.SetInputConnection(partCleaner.GetOutputPort());
 160                 else partEdges.SetInputData(partGrid);
 161                 partEdges.SetFeatureAngle(featureAngle);  // this do not have to be neccesarily called
 162                 partEdges.FeatureEdgesOn();
 163                 partEdges.BoundaryEdgesOn();
 164                 partEdges.NonManifoldEdgesOn();
 165                 partEdges.ManifoldEdgesOn();
 166
 167                 vtkDataSetMapper partEdgesMapper = new vtkDataSetMapper();
 168                 partEdgesMapper.SetInputConnection(partEdges.GetOutputPort());
 169                 partEdgesMapper.SetResolveCoincidentTopologyToPolygonOffset();
 170                 partEdgesMapper.ScalarVisibilityOff();
 171
 172                 vtkActor partEdgesActor = new vtkActor();
 173                 partEdgesActor.SetPickable(0);
 174                 partEdgesActor.GetProperty().SetColor(1, 0, 1);
 175                 partEdgesActor.SetMapper(partEdgesMapper);
 176
 177
 178                 // Add triangles and edges to STL structures:
 179                 //--------------------------------------------
 180                 if (cleanPart) stlSurfaceData.AddInputData(partCleaner.GetOutput());
 181                 else stlSurfaceData.AddInputData(partGrid);
 182                 stlEdgeData.AddInputData(partEdges.GetOutput());
 183
 184                 assemblies.AddPart(partActor);
 185                 assemblies.AddPart(partEdgesActor);
 186
 187                 // Clean up:
 188                 //----------
 189                 partEdgesActor.Delete();
 190                 partEdgesMapper.Delete();
 191                 partEdges.Delete();
 192                 partActor.Delete();
 193                 partMapper.Delete();
 194                 partGrid.Delete();
 195                 partCleaner.Delete();
 196         }
 197
 198         public static void gridToAssembly(vtkAssembly assemblies, vtkPolyData partGrid) {
 199
 200                 double featureAngle = 30;
 201
 202
 203                 vtkDataSetMapper partMapper = new vtkDataSetMapper();
 204
 205                 boolean computeNormals = true;
 206                 boolean cleanPart = false;
 207                 boolean mergePoints = false;
 208
 209                 vtkCleanPolyData partCleaner = new vtkCleanPolyData();
 210                 if (cleanPart)
 211                 {
 212                         partCleaner.SetInputData(partGrid);
 213                         if(mergePoints) {
 214                                 partCleaner.PointMergingOn();
 215                         } else {
 216                                 partCleaner.PointMergingOff();
 217                         }
 218                 }
 219
 220                 if (computeNormals)
 221                 {
 222                         vtkPolyDataNormals partNormals = new vtkPolyDataNormals();
 223
 224                         if (cleanPart)
 225                         {
 226                                 vtkAlgorithmOutput out = partCleaner.GetOutputPort();
 227                                 partNormals.SetInputConnection(out);
 228                                 out.Delete();
 229                         }
 230                         else partNormals.SetInputData(partGrid);
 231
 232                         partNormals.SetFeatureAngle(featureAngle); // this do not have to be neccesarily called
 233                         vtkAlgorithmOutput out = partNormals.GetOutputPort();
 234                         partMapper.SetInputConnection(out);
 235                         out.Delete();
 236                         partNormals.Delete();
 237                 }
 238                 else
 239                 {
 240                         if (cleanPart) {
 241                                 vtkAlgorithmOutput out = partCleaner.GetOutputPort();
 242                                 partMapper.SetInputConnection(out); // metoda 2, ne tak pekne, viz http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681
 243                                 out.Delete();
 244                         }
 245                         else partMapper.SetInputData(partGrid); // metoda 1, ne tak pekne stinovani, viz: http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681
 246                 }
 247                 partMapper.ScalarVisibilityOn();
 248
 249                 vtkActor partActor = new vtkActor();
 250                 partActor.SetPickable(1);
 251                 vtkProperty prop = partActor.GetProperty();
 252                 prop.SetColor(1, 1, 0);
 253                 prop.Delete();
 254                 partActor.SetMapper(partMapper);
 255
 256                 assemblies.AddPart(partActor);
 257
 258                 {
 259                         // EDGES OF PARTS DETECTION
 260                         vtkFeatureEdges partEdges = new vtkFeatureEdges();
 261                         if (cleanPart) {
 262                                 vtkAlgorithmOutput out = partCleaner.GetOutputPort();
 263                                 partEdges.SetInputConnection(out);
 264                                 out.Delete();
 265                         }
 266                         else partEdges.SetInputData(partGrid);
 267                         // partEdges.SetFeatureAngle(featureAngle);  // this do not have to be neccesarily called
 268                         partEdges.FeatureEdgesOn();
 269                         partEdges.BoundaryEdgesOn();
 270                         partEdges.NonManifoldEdgesOn();
 271                         partEdges.ManifoldEdgesOn();
 272
 273                         vtkDataSetMapper partEdgesMapper = new vtkDataSetMapper();
 274                         vtkAlgorithmOutput out = partEdges.GetOutputPort();
 275                         partEdgesMapper.SetInputConnection(out);
 276                         out.Delete();
 277                         partEdgesMapper.SetResolveCoincidentTopologyToPolygonOffset();
 278                         partEdgesMapper.ScalarVisibilityOff();
 279
 280                         vtkActor partEdgesActor = new vtkActor();
 281
 282                         prop = partEdgesActor.GetProperty();
 283                         prop.SetColor(0, 0, 0);
 284                         prop.SetLineWidth(2.0);
 285                         prop.Delete();
 286                         partEdgesActor.SetMapper(partEdgesMapper);
 287                         partEdgesActor.PickableOn();
 288
 289                         assemblies.AddPart(partEdgesActor);
 290
 291                         {
 292
 293                                 EdgePointsFilter edgePoints = new EdgePointsFilter();
 294
 295
 296                                 out = partEdges.GetOutputPort();
 297                                 edgePoints.SetInputConnection(out);
 298                                 out.Delete();
 299
 300                                 //                  vtkDataSetMapper partEdgePointsMapper = new vtkDataSetMapper();
 301                                 //                  out = edgePoints.GetOutputPort();
 302                                 //                  partEdgePointsMapper.SetInputConnection(out);
 303                                 //                  out.Delete();
 304
 305                                 //                  vtkVertexGlyphFilter glyphFilter = new vtkVertexGlyphFilter();
 306                                 //                  out = edgePoints.GetOutputPort();
 307                                 //                  glyphFilter.SetInputConnection(out);
 308                                 //                  glyphFilter.Update();
 309                                 //                  out.Delete();
 310                                 //
 311                                 //                  vtkPolyDataMapper partEdgePointsMapper = new vtkPolyDataMapper();
 312                                 //                  out = glyphFilter.GetOutputPort();
 313                                 //                  partEdgePointsMapper.SetInputConnection(out);
 314                                 //                  out.Delete();
 315
 316                                 vtkSphereSource sphereSource = new vtkSphereSource();
 317                                 vtkGlyph3D glyph3D = new vtkGlyph3D();
 318                                 out = sphereSource.GetOutputPort();
 319                                 glyph3D.SetSourceConnection(out);
 320                                 out.Delete();
 321
 322                                 out = edgePoints.GetOutputPort();
 323                                 glyph3D.SetInputConnection(out);
 324                                 out.Delete();
 325
 326                                 //glyph3D.ScalingOff();
 327                                 glyph3D.SetScaleFactor(0.03);
 328
 329                                 glyph3D.Update();
 330
 331                                 vtkPolyDataMapper partEdgePointsMapper = new vtkPolyDataMapper();
 332                                 out = glyph3D.GetOutputPort();
 333                                 partEdgePointsMapper.SetInputConnection(out);
 334                                 out.Delete();
 335
 336                                 vtkActor edgePointsActor = new vtkActor();
 337
 338                                 prop = edgePointsActor.GetProperty();
 339                                 prop.SetColor(0, 0, 1);
 340                                 //prop.SetPointSize(10.0);
 341                                 //prop.SetRepresentationToPoints();
 342                                 prop.Delete();
 343                                 edgePointsActor.SetMapper(partEdgePointsMapper);
 344
 345                                 edgePointsActor.PickableOn();
 346                                 assemblies.AddPart(edgePointsActor);
 347
 348
 349                                 edgePointsActor.Delete();
 350                                 partEdgePointsMapper.Delete();
 351                                 // edgePoints.Delete();
 352                         }
 353                         // Clean up:
 354                         //----------
 355                         partEdgesActor.Delete();
 356                         partEdgesMapper.Delete();
 357                         partEdges.Delete();
 358                 }
 359
 360                 partActor.Delete();
 361                 partMapper.Delete();
 362                 partGrid.Delete();
 363                 partCleaner.Delete();
 364         }
 365
 366
 367
 368         public static vtkPolyData createPartGrid ( TopoDS_Face face)
 369         {
 370                 TopLoc_Location Location = new TopLoc_Location();
 371
 372                 Poly_Triangulation triangulation = BRep_Tool.triangulation(face, Location);
 373
 374                 if(triangulation == null) {
 375                         Location.delete();
 376                         System.out.println("Encountered empty triangulation after face");
 377                         return null;
 378                 }
 379
 380                 boolean reverse = face.orientation()==TopAbs_Orientation.REVERSED;
 381
 382                 int[]triangles = triangulation.triangles();
 383                 double[]nodes = triangulation.nodes();
 384
 385                 int nofTriangles = triangulation.nbTriangles();
 386                 int nofNodes = triangulation.nbNodes();
 387
 388                 triangulation.delete();
 389
 390                 if(nofTriangles < 1) {
 391                         System.out.println("No triangles for mesh on face");
 392                         Location.delete();
 393                         return null;
 394                 }
 395
 396                 if(nofNodes < 1) {
 397                         System.out.println("No nodes for mesh on face:");
 398                         Location.delete();
 399                         return null;
 400                 }
 401                 //System.out.println("v " + nofNodes + " t " +nofTriangles);
 402                 vtkPolyData partGrid = new vtkPolyData();
 403                 partGrid.Allocate(nofTriangles, nofTriangles);
 404
 405                 vtkTriangle triangle = new vtkTriangle();
 406                 vtkIdList list = triangle.GetPointIds();
 407                 for(int i = 0; i < nofTriangles; i++)
 408                 {
 409                         int n0, n1, n2;
 410                         if (!reverse) {
 411                                 n0 = triangles[3 * i];
 412                                 n1 = triangles[3 * i + 1];
 413                                 n2 = triangles[3 * i + 2];
 414                         } else {
 415                                 n0 = triangles[3 * i + 2];
 416                                 n1 = triangles[3 * i + 1];
 417                                 n2 = triangles[3 * i];
 418                         }
 419
 420                         list.SetId(0, n0);
 421                         list.SetId(1, n1);
 422                         list.SetId(2, n2);
 423                         partGrid.InsertNextCell(triangle.GetCellType(), list);
 424
 425                 }
 426                 list.Delete();
 427                 triangle.Delete();
 428
 429                 GP_Trsf transformation = Location.transformation();
 430                 Location.delete();
 431
 432                 double d_mat[] = new double[16];
 433                 double d_p[] = new double[3];
 434                 transformation.getValues(d_mat);
 435                 Matrix4d mat = new Matrix4d(d_mat);
 436
 437                 vtkPoints partPoints = new vtkPoints();
 438
 439                 for(int i = 0; i < nofNodes; i++) {
 440                         // FIXME: GP_Trsf.transform(double[]) leaks memory
 441
 442                         //double xyz[] = new double[]{nodes[3 * i], nodes[3 * i + 1], nodes[3 * i + 2]};
 443                         //transformation.transforms(xyz);
 444                         //partPoints.InsertPoint(i, xyz);
 445                         Point3d p = new Point3d(nodes[3 * i], nodes[3 * i + 1], nodes[3 * i + 2]);
 446                         mat.transform(p);
 447                         d_p[0] = p.x;
 448                         d_p[1] = p.y;
 449                         d_p[2] = p.z;
 450                         partPoints.InsertPoint(i, d_p);
 451                 }
 452
 453                 transformation.delete();
 454
 455                 partGrid.SetPoints(partPoints);
 456                 partPoints.Delete();
 457
 458                 return partGrid;
 459         }
 460
 461
 462
 463         public static vtkPolyData createPartGrid ( List<Double> meshPoints, List<Integer> meshTriangles)
 464         {
 465
 466
 467
 468
 469
 470                 int nofTriangles = meshTriangles.size() / 3;
 471                 int nofNodes = meshPoints.size() /3;
 472
 473
 474                 if(nofTriangles < 1) {
 475                         System.out.println("No triangles for mesh on face");
 476                         return null;
 477                 }
 478
 479                 if(nofNodes < 1) {
 480                         System.out.println("No nodes for mesh on face:");
 481                         return null;
 482                 }
 483                 //System.out.println("v " + nofNodes + " t " +nofTriangles);
 484                 vtkPolyData partGrid = new vtkPolyData();
 485                 partGrid.Allocate(nofTriangles, nofTriangles);
 486
 487                 vtkTriangle triangle = new vtkTriangle();
 488                 vtkIdList list = triangle.GetPointIds();
 489                 for(int i = 0; i < nofTriangles; i++)
 490                 {
 491                         int n0, n1, n2;
 492                         n0 = meshTriangles.get(3 * i);
 493                         n1 = meshTriangles.get(3 * i + 1);
 494                         n2 = meshTriangles.get(3 * i + 2);
 495
 496
 497                         list.SetId(0, n0);
 498                         list.SetId(1, n1);
 499                         list.SetId(2, n2);
 500                         partGrid.InsertNextCell(triangle.GetCellType(), list);
 501
 502                 }
 503                 list.Delete();
 504                 triangle.Delete();
 505
 506
 507
 508                 double d_p[] = new double[3];
 509
 510
 511                 vtkPoints partPoints = new vtkPoints();
 512
 513                 for(int i = 0; i < nofNodes; i++) {
 514
 515                         d_p[0] = meshPoints.get(3*i);
 516                         d_p[1] = meshPoints.get(3*i+1);
 517                         d_p[2] = meshPoints.get(3*i+2);
 518                         partPoints.InsertPoint(i, d_p);
 519                 }
 520
 521                 partGrid.SetPoints(partPoints);
 522                 partPoints.Delete();
 523
 524                 return partGrid;
 525         }
 526
 527         private static vtkPolyData createTestPartGrid ()
 528         {
 529                 int size = 64;
 530
 531                 double[] nodes = new double[(size+1)*(size+1)*3];
 532                 int[] triangles = new int[3 * size * size * 2];
 533
 534                 double es = 1.0;
 535                 for (int i = 0; i <= size; i++) {
 536                         for (int j = 0; j <= size; j++) {
 537                                 int index = j * size + i;
 538                                 index *= 3;
 539                                 double x = (double)i * es;
 540                                 double y = (Math.sin((double)i/(double)size)  + Math.sin((double)j/(double)size)) * es;
 541                                 double z = (double)j * es;
 542                                 nodes[index] = x;
 543                                 nodes[index+1] = y;
 544                                 nodes[index+2] = z;
 545                         }
 546                 }
 547
 548                 for (int i = 0; i < size; i++) {
 549                         for (int j = 0; j < size; j++) {
 550                                 int index = j * size + i;
 551                                 index *= 3;
 552                                 index *= 2;
 553                                 triangles[index  ] = (j     * (size+1) + i  );
 554                                 triangles[index+1] = (j     * (size+1) + i+1);
 555                                 triangles[index+2] = ((j+1) * (size+1) + i  );
 556                                 triangles[index+3] = ((j+1) * (size+1) + i  );
 557                                 triangles[index+4] = ((j  ) * (size+1) + i +1 );
 558                                 triangles[index+5] = ((j+1) * (size+1) + i +1 );
 559                         }
 560                 }
 561
 562                 int nofTriangles = triangles.length / 3;
 563                 int nofNodes = nodes.length / 3;
 564
 565                 if(nofTriangles < 1) {
 566
 567                         return null;
 568                 }
 569
 570                 if(nofNodes < 1) {
 571
 572                         return null;
 573                 }
 574                 //System.out.println("v " + nofNodes + " t " +nofTriangles);
 575                 vtkPolyData partGrid = new vtkPolyData();
 576                 partGrid.Allocate(nofTriangles, nofTriangles);
 577
 578                 vtkTriangle triangle = new vtkTriangle();
 579                 vtkIdList list = triangle.GetPointIds();
 580                 for(int i = 0; i < nofTriangles; i++)
 581                 {
 582                         int n0, n1, n2;
 583                         n0 = triangles[3 * i]; n1 = triangles[3 * i + 1]; n2 = triangles[3 * i + 2]; // triangles(i).Get(n0, n1, n2);
 584
 585                         //          if(face.orientation() != TopAbs_Orientation.FORWARD) {
 586                         //              int tmp = n2; n2 = n1; n1 = tmp;
 587                         //          }
 588
 589                         list.SetId(0, n0);
 590                         list.SetId(1, n1);
 591                         list.SetId(2, n2);
 592                         partGrid.InsertNextCell(triangle.GetCellType(), list);
 593
 594                 }
 595                 list.Delete();
 596                 triangle.Delete();
 597
 598                 vtkPoints partPoints = new vtkPoints();
 599                 for(int i = 0; i < nofNodes; i++) {
 600                         double xyz[] = new double[]{nodes[3 * i], nodes[3 * i + 1], nodes[3 * i + 2]};
 601                         partPoints.InsertPoint(i, xyz);
 602                 }
 603
 604                 partGrid.SetPoints(partPoints);
 605
 606                 partPoints.Delete();
 607
 608                 return partGrid;
 609         }
 610
 611         public static void test() {
 612                 TopoDS_Shape shape = null;
 613                 //shape = OccTriangulator.makeCylinder(new double[]{0,0,0}, new double[]{0,1,0}, 1, 1);
 614                 for (int t = 0; t < 5000; t++) {
 615                         //shape = OccTriangulator.makeCylinder(new double[]{0,0,0}, new double[]{0,1,0}, 1, 1);
 616                         int test = 2;
 617                         if (test == 0) {
 618                                 vtkAssembly ass = VTKOCCTool.vtkOCCShapeToAssembly(shape);
 619                                 vtkPropCollection col;
 620                                 col = ass.GetParts();
 621                                 for (int i = 0; i < col.GetNumberOfItems(); i++)
 622                                 {
 623                                         vtkProp prop = (vtkProp) col.GetItemAsObject(i);
 624                                         //System.out.println(prop.Print());
 625                                         prop.Delete();
 626                                 }
 627                                 col.Delete();
 628                                 ass.Delete();
 629                         }
 630                         else if (test == 1) {
 631                                 //BRepTools.clean(shape);
 632
 633
 634                                 vtkAssembly ass = new vtkAssembly();
 635
 636                                 double vol = OCCTTool.getBoundingBoxDiagonal(shape);
 637                                 double d = 0.001 * vol;
 638                                 BRepMesh_IncrementalMesh mesh = new BRepMesh_IncrementalMesh(shape,d);
 639                                 TopExp_Explorer expFace = new TopExp_Explorer();
 640                                 for (expFace.init(shape, TopAbs_ShapeEnum.FACE); expFace.more(); expFace.next()) {
 641                                         TopoDS_Face face = (TopoDS_Face) expFace.current();
 642                                         {
 643                                                 //                                              TopLoc_Location Location = new TopLoc_Location();
 644                                                 //                                              Poly_Triangulation triangulation = BRep_Tool.triangulation(face, Location);
 645                                                 //                                              if (triangulation != null) {
 646                                                 //
 647                                                 //                                                      int[]triangles = triangulation.triangles();
 648                                                 //                                              double[]nodes = triangulation.nodes();
 649                                                 //                                              int nofTriangles = triangulation.nbTriangles();
 650                                                 //                                              int nofNodes = triangulation.nbNodes();
 651                                                 //
 652                                                 //                                              triangulation.delete();
 653                                                 //
 654                                                 //                                              GP_Trsf transformation = Location.transformation();
 655                                                 //                                              double d_mat[] = new double[16];
 656                                                 //                                              transformation.getValues(d_mat);
 657                                                 //                                              Matrix4d mat = new Matrix4d(d_mat);
 658                                                 //                                              for(int i = 0; i < nofNodes; i++) {
 659                                                 //                                                  //double xyz[] = new double[]{nodes[3 * i], nodes[3 * i + 1], nodes[3 * i + 2]};
 660                                                 //                                                  Point3d p = new Point3d(nodes[3 * i], nodes[3 * i + 1], nodes[3 * i + 2]);
 661                                                 //                                                      //transformation.transforms(xyz);
 662                                                 //                                                  mat.transform(p);
 663                                                 //                                              }
 664                                                 //                                              transformation.delete();
 665                                                 //                                              }
 666                                                 //
 667                                                 //                                              Location.delete();
 668                                                 vtkPolyData data = VTKOCCTool.createPartGrid(face);
 669                                                 VTKOCCTool.gridToAssembly(ass, data);
 670                                                 //data.Delete();
 671                                         }
 672                                         face.delete();
 673                                 }
 674                                 expFace.delete();
 675                                 mesh.delete();
 676
 677                                 vtkPropCollection col;
 678                                 col = ass.GetParts();
 679                                 for (int i = 0; i < col.GetNumberOfItems(); i++)
 680                                 {
 681                                         vtkProp prop = (vtkProp) col.GetItemAsObject(i);
 682                                         //System.out.println(prop.Print());
 683                                         prop.Delete();
 684                                 }
 685                                 col.Delete();
 686                                 ass.Delete();
 687                         } else if (test == 2) {
 688                                 double[] pointStruct = new double[]{0,0,0}, dirStruct = new double[]{0,1,0};
 689                                 double radius = 1.0;
 690                                 double height = 1.0;
 691
 692                                 double[] axe = new double[6];
 693
 694                                 System.arraycopy(pointStruct, 0, axe, 0, 3);
 695                                 System.arraycopy(dirStruct, 0, axe, 3, 3);
 696                                 org.jcae.opencascade.jni.BRepPrimAPI_MakeCylinder cyl = new org.jcae.opencascade.jni.BRepPrimAPI_MakeCylinder(axe, radius, height, 2 * Math.PI);
 697                                 org.jcae.opencascade.jni.TopoDS_Shape tds = cyl.shape();
 698                                 cyl.delete();
 699
 700                                 double vol = OCCTTool.getBoundingBoxDiagonal(tds);
 701                                 double d = 0.001 * vol;
 702                                 BRepMesh_IncrementalMesh mesh = new BRepMesh_IncrementalMesh(tds,d);
 703 //                              TopExp_Explorer expFace = new TopExp_Explorer();
 704 //                              for (expFace.init(tds, TopAbs_ShapeEnum.FACE); expFace.more(); expFace.next()) {
 705 //                                      TopoDS_Face face = (TopoDS_Face) expFace.current();
 706 //                                      {
 707 //
 708 //                                      }
 709 //                                      face.delete();
 710 //                              }
 711                                 mesh.delete();
 712
 713                                 tds.delete();
 714                         }
 715                         //shape.delete();
 716                         System.out.println(t);
 717                 }
 718                 //shape.delete();
 719         }
 720 }