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