-/*******************************************************************************\r
- * Copyright (c) 2012, 2013 Association for Decentralized Information Management in\r
- * Industry THTH ry.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.opencascade.vtk;\r
-\r
-import java.util.ArrayList;\r
-import java.util.Collection;\r
-import java.util.List;\r
-\r
-import org.jcae.opencascade.jni.BRepMesh_IncrementalMesh;\r
-import org.jcae.opencascade.jni.TopAbs_ShapeEnum;\r
-import org.jcae.opencascade.jni.TopExp_Explorer;\r
-import org.jcae.opencascade.jni.TopoDS_Face;\r
-import org.jcae.opencascade.jni.TopoDS_Shape;\r
-import org.simantics.opencascade.OCCTTool;\r
-import org.simantics.utils.datastructures.Pair;\r
-import org.simantics.utils.threads.AWTThread;\r
-import org.simantics.utils.threads.ThreadUtils;\r
-\r
-import vtk.vtkActor;\r
-import vtk.vtkAlgorithmOutput;\r
-import vtk.vtkCleanPolyData;\r
-import vtk.vtkDataSetMapper;\r
-import vtk.vtkFeatureEdges;\r
-import vtk.vtkGlyph3D;\r
-import vtk.vtkPanel;\r
-import vtk.vtkPolyData;\r
-import vtk.vtkPolyDataMapper;\r
-import vtk.vtkPolyDataNormals;\r
-import vtk.vtkPolyDataSilhouette;\r
-import vtk.vtkProp3D;\r
-import vtk.vtkProperty;\r
-import vtk.vtkRenderer;\r
-import vtk.vtkSphereSource;\r
-\r
-public class vtkSolidObject {\r
- \r
- public static double deflection = 0.001;\r
- \r
- public static double featureAngle = 30;\r
- public static boolean computeNormals = true;\r
- public static boolean cleanPart = false;\r
- public static boolean mergePoints = false;\r
- \r
- private vtkPanel panel;\r
- private TopoDS_Shape shape;\r
- \r
- private List<vtkProp3D> actors = new ArrayList<vtkProp3D>(2);\r
- \r
- private List<vtkProp3D> solid = new ArrayList<vtkProp3D>(1);\r
- private List<vtkProp3D> edges = new ArrayList<vtkProp3D>(1);\r
- private vtkActor silhouette = null;\r
- \r
- private boolean errors = false;\r
- \r
- public vtkSolidObject(vtkPanel panel,TopoDS_Shape shape) {\r
- this.shape = shape;\r
- this.panel = panel;\r
- }\r
- \r
- public void visualizeSolid(boolean showEdges, boolean showVertices) {\r
- visualizeSolid(true, showEdges, showVertices);\r
- }\r
- \r
- public void visualizeSolid(boolean showFaces, boolean showEdges, boolean showVertices) {\r
- visualizeSolid(showFaces, showEdges, showVertices, false);\r
- }\r
- \r
- public void visualizeSolid(boolean showFaces, boolean showEdges, boolean showVertices, boolean showSilhouette) {\r
- clearActorsAWT();\r
- errors = false;\r
- Pair<vtkPolyData, Boolean> res = createSolidMesh(shape);\r
- if (res == null) {\r
- errors = true;\r
- return;\r
- }\r
- vtkPolyData data = res.first;\r
- if (!res.second)\r
- errors = true;\r
- if (showFaces) {\r
- solid.add(createActor(data)); \r
- }\r
- if (showEdges) {\r
- vtkActor edge = createEdgesActor(data);\r
- edges.add(edge); \r
- if (showVertices) {\r
- actors.add(createVerticesActor(edge));\r
- }\r
- }\r
- if (showSilhouette) {\r
- silhouette = createSilhouette(panel.GetRenderer(), data);\r
- }\r
- actors.addAll(solid);\r
- actors.addAll(edges);\r
- if (silhouette != null)\r
- actors.add(silhouette);\r
- data.Delete();\r
- showActorsAWT();\r
- }\r
- \r
- public void visualizeFaces(boolean showEdges, boolean showVertices) {\r
- errors = false;\r
- clearActorsAWT();\r
- Collection<vtkPolyData> datas = createFaceMeshes(shape);\r
- for (vtkPolyData data : datas) {\r
- if (data == null) {\r
- errors = true;\r
- continue;\r
- }\r
- \r
- solid.add(createActor(data));\r
- \r
- if (showEdges) {\r
- vtkActor edgesActor = createEdgesActor(data); \r
- edges.add(edgesActor);\r
- if (showVertices) {\r
- actors.add(createVerticesActor(edgesActor));\r
- }\r
- }\r
- data.Delete();\r
- }\r
- actors.addAll(solid);\r
- actors.addAll(edges);\r
- \r
- showActorsAWT();\r
- }\r
- \r
- public boolean hasErrors() {\r
- return errors;\r
- }\r
- \r
- public List<vtkProp3D> getActors() {\r
- assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());\r
- return actors;\r
- }\r
- \r
- public List<vtkProp3D> getSolid() {\r
- assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());\r
- return solid;\r
- }\r
- \r
- public List<vtkProp3D> getEdges() {\r
- assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());\r
- return edges;\r
- }\r
- \r
- public vtkActor getSilhouette() {\r
- assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());\r
- return silhouette;\r
- }\r
- \r
- public void showActorsAWT() {\r
- assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());\r
- vtkRenderer ren = panel.GetRenderer();\r
- for (vtkProp3D act : actors) {\r
- ren.AddActor(act);\r
- }\r
- }\r
- \r
- public void showActors() {\r
- ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {\r
- \r
- @Override\r
- public void run() {\r
- showActorsAWT();\r
- }\r
- });\r
- }\r
- \r
- public void clearActorsAWT() {\r
- assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());\r
- if (actors.size() == 0)\r
- return;\r
- vtkRenderer ren = panel.GetRenderer();\r
- for (vtkProp3D act : actors) {\r
- if (act.GetVTKId() != 0) {\r
- ren.RemoveActor(act);\r
- act.Delete();\r
- }\r
- }\r
- actors.clear();\r
- solid.clear();\r
- edges.clear();\r
- }\r
- \r
- private void clearActorsAWT(List<vtkProp3D> actors) {\r
- assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());\r
- \r
- if (actors.size() == 0)\r
- return;\r
- vtkRenderer ren = panel.GetRenderer();\r
- panel.lock();\r
- for (vtkProp3D act : actors) {\r
- if (act.GetVTKId() != 0) {\r
- ren.RemoveActor(act);\r
- act.Delete();\r
- }\r
- }\r
- panel.unlock();\r
- }\r
- \r
- public void clearActors() {\r
- if (actors.size() == 0)\r
- return;\r
- final List<vtkProp3D> temp = new ArrayList<vtkProp3D>(actors.size());\r
- temp.addAll(actors);\r
- actors.clear();\r
- solid.clear();\r
- edges.clear();\r
- ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {\r
- \r
- @Override\r
- public void run() {\r
- clearActorsAWT(temp);\r
- }\r
- });\r
- }\r
- \r
- public void dispose() {\r
- if (shape != null) {\r
- shape.delete();\r
- shape = null;\r
- }\r
- clearActors();\r
- }\r
- \r
- public void delete() {\r
- if (shape != null) {\r
- shape.delete();\r
- shape = null;\r
- }\r
- clearActorsAWT();\r
- }\r
- \r
- private static double TOLERANCE = 0.01;\r
- \r
- public static Pair<vtkPolyData, Boolean> createSolidMesh(TopoDS_Shape shape) {\r
- \r
- boolean success = true;\r
- \r
- double volume = OCCTTool.getBoundingBoxDiagonal(shape);\r
- if (volume < TOLERANCE)\r
- return null;\r
- \r
- BRepMesh_IncrementalMesh mesh = new BRepMesh_IncrementalMesh(shape,deflection*volume);\r
- \r
- TopExp_Explorer expFace = new TopExp_Explorer();\r
- \r
- List<Double> meshPoints = new ArrayList<Double>();\r
- List<Integer> meshTriangles = new ArrayList<Integer>();\r
- for (expFace.init(shape, TopAbs_ShapeEnum.FACE); expFace.more(); expFace.next()) {\r
- TopoDS_Face face = (TopoDS_Face) expFace.current();\r
- if (!OCCTTool.appendToMesh(face, meshPoints, meshTriangles))\r
- success = false;\r
- face.delete();\r
- }\r
- if (meshPoints.size() == 0 || meshTriangles.size() == 0)\r
- return null;\r
- \r
- vtkPolyData data = VTKOCCTool.createPartGrid(meshPoints, meshTriangles);\r
- \r
- expFace.delete();\r
- mesh.delete();\r
- \r
- return new Pair<vtkPolyData, Boolean>(data, success);\r
- }\r
- \r
- public static Collection<vtkPolyData> createFaceMeshes(TopoDS_Shape shape) {\r
- \r
- double volume = OCCTTool.getBoundingBoxDiagonal(shape);\r
- Collection<vtkPolyData> faces = new ArrayList<vtkPolyData>();\r
- \r
- if (volume > TOLERANCE) {\r
- \r
- BRepMesh_IncrementalMesh mesh = new BRepMesh_IncrementalMesh(shape,deflection*volume);\r
- \r
- TopExp_Explorer expFace = new TopExp_Explorer();\r
- \r
- \r
- for (expFace.init(shape, TopAbs_ShapeEnum.FACE); expFace.more(); expFace.next()) {\r
- TopoDS_Face face = (TopoDS_Face) expFace.current();\r
- vtkPolyData data = VTKOCCTool.createPartGrid(face);\r
- face.delete();\r
- faces.add(data);\r
- }\r
- \r
- expFace.delete();\r
- mesh.delete();\r
- }\r
- \r
- return faces;\r
- }\r
- \r
- \r
- \r
- public static vtkActor createActor(vtkPolyData partGrid) {\r
- \r
- \r
- vtkDataSetMapper partMapper = new vtkDataSetMapper();\r
- \r
- vtkCleanPolyData partCleaner = null; \r
- if (cleanPart)\r
- {\r
- partCleaner = new vtkCleanPolyData();\r
- partCleaner.SetInput(partGrid);\r
- if(mergePoints) {\r
- partCleaner.PointMergingOn();\r
- } else {\r
- partCleaner.PointMergingOff();\r
- }\r
- }\r
- \r
- if (computeNormals)\r
- {\r
- vtkPolyDataNormals partNormals = new vtkPolyDataNormals();\r
- \r
- if (cleanPart)\r
- {\r
- vtkAlgorithmOutput out = partCleaner.GetOutputPort();\r
- partNormals.SetInputConnection(out);\r
- out.Delete();\r
- }\r
- else partNormals.SetInput(partGrid);\r
- \r
- partNormals.SetFeatureAngle(featureAngle); // this do not have to be neccesarily called\r
- vtkAlgorithmOutput out = partNormals.GetOutputPort();\r
- partMapper.SetInputConnection(out);\r
- out.Delete();\r
- partNormals.Delete(); \r
- }\r
- else\r
- {\r
- if (cleanPart) {\r
- vtkAlgorithmOutput out = partCleaner.GetOutputPort();\r
- partMapper.SetInputConnection(out); // metoda 2, ne tak pekne, viz http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681\r
- out.Delete();\r
- }\r
- else partMapper.SetInput(partGrid); // metoda 1, ne tak pekne stinovani, viz: http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681\r
- }\r
- partMapper.ScalarVisibilityOn();\r
- \r
- vtkActor partActor = new vtkActor();\r
- // partActor.SetPickable(1);\r
- vtkProperty prop = partActor.GetProperty();\r
- prop.SetColor(1, 1, 0);\r
- prop.Delete();\r
- partActor.SetMapper(partMapper);\r
- \r
- partMapper.Delete();\r
- \r
- if (cleanPart)\r
- partCleaner.Delete();\r
- \r
- return partActor;\r
- }\r
- \r
- public static vtkActor createEdgesActor(vtkPolyData partGrid) {\r
- vtkCleanPolyData partCleaner = null; \r
- \r
- if (cleanPart)\r
- {\r
- partCleaner = new vtkCleanPolyData();\r
- partCleaner.SetInput(partGrid);\r
- if(mergePoints) {\r
- partCleaner.PointMergingOn();\r
- } else {\r
- partCleaner.PointMergingOff();\r
- }\r
- }\r
- \r
- vtkFeatureEdges partEdges = new vtkFeatureEdges();\r
- if (cleanPart) {\r
- vtkAlgorithmOutput out = partCleaner.GetOutputPort();\r
- partEdges.SetInputConnection(out);\r
- out.Delete();\r
- }\r
- else partEdges.SetInput(partGrid); \r
- // partEdges.SetFeatureAngle(featureAngle); // this do not have to be neccesarily called\r
- partEdges.FeatureEdgesOn();\r
- partEdges.BoundaryEdgesOn();\r
- partEdges.NonManifoldEdgesOn();\r
- partEdges.ManifoldEdgesOn();\r
- \r
- vtkDataSetMapper partEdgesMapper = new vtkDataSetMapper();\r
- vtkAlgorithmOutput out = partEdges.GetOutputPort();\r
- partEdgesMapper.SetInputConnection(out);\r
- out.Delete();\r
- partEdgesMapper.SetResolveCoincidentTopologyToPolygonOffset();\r
- partEdgesMapper.ScalarVisibilityOff();\r
- \r
- vtkActor partEdgesActor = new vtkActor();\r
- \r
- vtkProperty prop = partEdgesActor.GetProperty();\r
- prop.SetColor(0, 0, 0);\r
- prop.SetLineWidth(2.0);\r
- prop.Delete();\r
- partEdgesActor.SetMapper(partEdgesMapper);\r
-\r
- partEdgesMapper.Delete();\r
- partEdges.Delete();\r
- \r
- if (cleanPart)\r
- partCleaner.Delete();\r
- \r
- return partEdgesActor;\r
- }\r
- \r
- public static vtkActor createVerticesActor(vtkActor partEdgesActor) {\r
- vtkDataSetMapper partEdgesMapper = (vtkDataSetMapper) partEdgesActor.GetMapper();\r
- vtkAlgorithmOutput out = partEdgesMapper.GetInputConnection(0, 0);\r
- vtkFeatureEdges partEdges = (vtkFeatureEdges)out.GetProducer();\r
- \r
- vtkActor edgePointsActor = createVerticesActor(partEdges);\r
- \r
- partEdges.Delete();\r
- //out.Delete();\r
- partEdgesMapper.Delete();\r
- return edgePointsActor;\r
- }\r
- \r
- public static vtkActor createVerticesActor(vtkFeatureEdges partEdges) {\r
- EdgePointsFilter edgePoints = new EdgePointsFilter();\r
- \r
- \r
- vtkAlgorithmOutput out = partEdges.GetOutputPort();\r
- edgePoints.SetInputConnection(out);\r
- out.Delete();\r
- \r
- vtkSphereSource sphereSource = new vtkSphereSource();\r
- vtkGlyph3D glyph3D = new vtkGlyph3D();\r
- out = sphereSource.GetOutputPort();\r
- glyph3D.SetSourceConnection(out);\r
- out.Delete();\r
- \r
- out = edgePoints.GetOutputPort();\r
- glyph3D.SetInputConnection(out);\r
- out.Delete();\r
- \r
- glyph3D.SetScaleFactor(0.03);\r
- \r
- glyph3D.Update();\r
- \r
- vtkPolyDataMapper partEdgePointsMapper = new vtkPolyDataMapper();\r
- out = glyph3D.GetOutputPort();\r
- partEdgePointsMapper.SetInputConnection(out);\r
- out.Delete();\r
- \r
- vtkActor edgePointsActor = new vtkActor();\r
- \r
- vtkProperty prop = edgePointsActor.GetProperty();\r
- prop.SetColor(0, 0, 1);\r
- prop.Delete();\r
- edgePointsActor.SetMapper(partEdgePointsMapper);\r
- \r
- edgePointsActor.PickableOn();\r
-\r
- \r
- partEdgePointsMapper.Delete();\r
- edgePoints.Delete();\r
- sphereSource.Delete();\r
- \r
- return edgePointsActor;\r
- }\r
- \r
- public static vtkActor createSilhouette(vtkRenderer ren, vtkPolyData data) {\r
- \r
- \r
- vtkPolyDataSilhouette silhouette = new vtkPolyDataSilhouette();\r
- \r
- silhouette.SetInput(data);\r
- silhouette.SetCamera(ren.GetActiveCamera());\r
- silhouette.SetEnableFeatureAngle(0);\r
- vtkPolyDataMapper mapper = new vtkPolyDataMapper();\r
- \r
- mapper.SetInputConnection(silhouette.GetOutputPort());\r
- \r
- vtkActor actor = new vtkActor();\r
- actor.SetMapper(mapper);\r
- \r
- actor.GetProperty().SetColor(0,0,1);\r
- actor.GetProperty().SetLineWidth(6);\r
- \r
- return actor;\r
- \r
- \r
- \r
- }\r
-\r
-}\r
+/*******************************************************************************
+ * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
+ * Industry THTH ry.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * VTT Technical Research Centre of Finland - initial API and implementation
+ *******************************************************************************/
+package org.simantics.opencascade.vtk;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.jcae.opencascade.jni.BRepMesh_IncrementalMesh;
+import org.jcae.opencascade.jni.TopAbs_ShapeEnum;
+import org.jcae.opencascade.jni.TopExp_Explorer;
+import org.jcae.opencascade.jni.TopoDS_Face;
+import org.jcae.opencascade.jni.TopoDS_Shape;
+import org.simantics.opencascade.OCCTTool;
+import org.simantics.utils.datastructures.Pair;
+import org.simantics.utils.threads.AWTThread;
+import org.simantics.utils.threads.ThreadUtils;
+
+import vtk.vtkActor;
+import vtk.vtkAlgorithmOutput;
+import vtk.vtkCleanPolyData;
+import vtk.vtkDataSetMapper;
+import vtk.vtkFeatureEdges;
+import vtk.vtkGlyph3D;
+import vtk.vtkPanel;
+import vtk.vtkPolyData;
+import vtk.vtkPolyDataMapper;
+import vtk.vtkPolyDataNormals;
+import vtk.vtkPolyDataSilhouette;
+import vtk.vtkProp3D;
+import vtk.vtkProperty;
+import vtk.vtkRenderer;
+import vtk.vtkSphereSource;
+
+public class vtkSolidObject {
+
+ public static double deflection = 0.001;
+
+ public static double featureAngle = 30;
+ public static boolean computeNormals = true;
+ public static boolean cleanPart = false;
+ public static boolean mergePoints = false;
+
+ private vtkPanel panel;
+ private TopoDS_Shape shape;
+
+ private List<vtkProp3D> actors = new ArrayList<vtkProp3D>(2);
+
+ private List<vtkProp3D> solid = new ArrayList<vtkProp3D>(1);
+ private List<vtkProp3D> edges = new ArrayList<vtkProp3D>(1);
+ private vtkActor silhouette = null;
+
+ private boolean errors = false;
+
+ public vtkSolidObject(vtkPanel panel,TopoDS_Shape shape) {
+ this.shape = shape;
+ this.panel = panel;
+ }
+
+ public void visualizeSolid(boolean showEdges, boolean showVertices) {
+ visualizeSolid(true, showEdges, showVertices);
+ }
+
+ public void visualizeSolid(boolean showFaces, boolean showEdges, boolean showVertices) {
+ visualizeSolid(showFaces, showEdges, showVertices, false);
+ }
+
+ public void visualizeSolid(boolean showFaces, boolean showEdges, boolean showVertices, boolean showSilhouette) {
+ clearActorsAWT();
+ errors = false;
+ Pair<vtkPolyData, Boolean> res = createSolidMesh(shape);
+ if (res == null) {
+ errors = true;
+ return;
+ }
+ vtkPolyData data = res.first;
+ if (!res.second)
+ errors = true;
+ if (showFaces) {
+ solid.add(createActor(data));
+ }
+ if (showEdges) {
+ vtkActor edge = createEdgesActor(data);
+ edges.add(edge);
+ if (showVertices) {
+ actors.add(createVerticesActor(edge));
+ }
+ }
+ if (showSilhouette) {
+ silhouette = createSilhouette(panel.GetRenderer(), data);
+ }
+ actors.addAll(solid);
+ actors.addAll(edges);
+ if (silhouette != null)
+ actors.add(silhouette);
+ data.Delete();
+ showActorsAWT();
+ }
+
+ public void visualizeFaces(boolean showEdges, boolean showVertices) {
+ errors = false;
+ clearActorsAWT();
+ Collection<vtkPolyData> datas = createFaceMeshes(shape);
+ for (vtkPolyData data : datas) {
+ if (data == null) {
+ errors = true;
+ continue;
+ }
+
+ solid.add(createActor(data));
+
+ if (showEdges) {
+ vtkActor edgesActor = createEdgesActor(data);
+ edges.add(edgesActor);
+ if (showVertices) {
+ actors.add(createVerticesActor(edgesActor));
+ }
+ }
+ data.Delete();
+ }
+ actors.addAll(solid);
+ actors.addAll(edges);
+
+ showActorsAWT();
+ }
+
+ public boolean hasErrors() {
+ return errors;
+ }
+
+ public List<vtkProp3D> getActors() {
+ assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());
+ return actors;
+ }
+
+ public List<vtkProp3D> getSolid() {
+ assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());
+ return solid;
+ }
+
+ public List<vtkProp3D> getEdges() {
+ assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());
+ return edges;
+ }
+
+ public vtkActor getSilhouette() {
+ assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());
+ return silhouette;
+ }
+
+ public void showActorsAWT() {
+ assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());
+ vtkRenderer ren = panel.GetRenderer();
+ for (vtkProp3D act : actors) {
+ ren.AddActor(act);
+ }
+ }
+
+ public void showActors() {
+ ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {
+
+ @Override
+ public void run() {
+ showActorsAWT();
+ }
+ });
+ }
+
+ public void clearActorsAWT() {
+ assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());
+ if (actors.size() == 0)
+ return;
+ vtkRenderer ren = panel.GetRenderer();
+ for (vtkProp3D act : actors) {
+ if (act.GetVTKId() != 0) {
+ ren.RemoveActor(act);
+ act.Delete();
+ }
+ }
+ actors.clear();
+ solid.clear();
+ edges.clear();
+ }
+
+ private void clearActorsAWT(List<vtkProp3D> actors) {
+ assert (Thread.currentThread() == AWTThread.getThreadAccess().getThread());
+
+ if (actors.size() == 0)
+ return;
+ vtkRenderer ren = panel.GetRenderer();
+ panel.lock();
+ for (vtkProp3D act : actors) {
+ if (act.GetVTKId() != 0) {
+ ren.RemoveActor(act);
+ act.Delete();
+ }
+ }
+ panel.unlock();
+ }
+
+ public void clearActors() {
+ if (actors.size() == 0)
+ return;
+ final List<vtkProp3D> temp = new ArrayList<vtkProp3D>(actors.size());
+ temp.addAll(actors);
+ actors.clear();
+ solid.clear();
+ edges.clear();
+ ThreadUtils.asyncExec(AWTThread.getThreadAccess(), new Runnable() {
+
+ @Override
+ public void run() {
+ clearActorsAWT(temp);
+ }
+ });
+ }
+
+ public void dispose() {
+ if (shape != null) {
+ shape.delete();
+ shape = null;
+ }
+ clearActors();
+ }
+
+ public void delete() {
+ if (shape != null) {
+ shape.delete();
+ shape = null;
+ }
+ clearActorsAWT();
+ }
+
+ private static double TOLERANCE = 0.01;
+
+ public static Pair<vtkPolyData, Boolean> createSolidMesh(TopoDS_Shape shape) {
+
+ boolean success = true;
+
+ double volume = OCCTTool.getBoundingBoxDiagonal(shape);
+ if (volume < TOLERANCE)
+ return null;
+
+ BRepMesh_IncrementalMesh mesh = new BRepMesh_IncrementalMesh(shape,deflection*volume);
+
+ TopExp_Explorer expFace = new TopExp_Explorer();
+
+ List<Double> meshPoints = new ArrayList<Double>();
+ List<Integer> meshTriangles = new ArrayList<Integer>();
+ for (expFace.init(shape, TopAbs_ShapeEnum.FACE); expFace.more(); expFace.next()) {
+ TopoDS_Face face = (TopoDS_Face) expFace.current();
+ if (!OCCTTool.appendToMesh(face, meshPoints, meshTriangles))
+ success = false;
+ face.delete();
+ }
+ if (meshPoints.size() == 0 || meshTriangles.size() == 0)
+ return null;
+
+ vtkPolyData data = VTKOCCTool.createPartGrid(meshPoints, meshTriangles);
+
+ expFace.delete();
+ mesh.delete();
+
+ return new Pair<vtkPolyData, Boolean>(data, success);
+ }
+
+ public static Collection<vtkPolyData> createFaceMeshes(TopoDS_Shape shape) {
+
+ double volume = OCCTTool.getBoundingBoxDiagonal(shape);
+ Collection<vtkPolyData> faces = new ArrayList<vtkPolyData>();
+
+ if (volume > TOLERANCE) {
+
+ BRepMesh_IncrementalMesh mesh = new BRepMesh_IncrementalMesh(shape,deflection*volume);
+
+ TopExp_Explorer expFace = new TopExp_Explorer();
+
+
+ for (expFace.init(shape, TopAbs_ShapeEnum.FACE); expFace.more(); expFace.next()) {
+ TopoDS_Face face = (TopoDS_Face) expFace.current();
+ vtkPolyData data = VTKOCCTool.createPartGrid(face);
+ face.delete();
+ faces.add(data);
+ }
+
+ expFace.delete();
+ mesh.delete();
+ }
+
+ return faces;
+ }
+
+
+
+ public static vtkActor createActor(vtkPolyData partGrid) {
+
+
+ vtkDataSetMapper partMapper = new vtkDataSetMapper();
+
+ vtkCleanPolyData partCleaner = null;
+ if (cleanPart)
+ {
+ partCleaner = new vtkCleanPolyData();
+ partCleaner.SetInputData(partGrid);
+ if(mergePoints) {
+ partCleaner.PointMergingOn();
+ } else {
+ partCleaner.PointMergingOff();
+ }
+ }
+
+ if (computeNormals)
+ {
+ vtkPolyDataNormals partNormals = new vtkPolyDataNormals();
+
+ if (cleanPart)
+ {
+ vtkAlgorithmOutput out = partCleaner.GetOutputPort();
+ partNormals.SetInputConnection(out);
+ out.Delete();
+ }
+ else partNormals.SetInputData(partGrid);
+
+ partNormals.SetFeatureAngle(featureAngle); // this do not have to be neccesarily called
+ vtkAlgorithmOutput out = partNormals.GetOutputPort();
+ partMapper.SetInputConnection(out);
+ out.Delete();
+ partNormals.Delete();
+ }
+ else
+ {
+ if (cleanPart) {
+ vtkAlgorithmOutput out = partCleaner.GetOutputPort();
+ partMapper.SetInputConnection(out); // metoda 2, ne tak pekne, viz http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681
+ out.Delete();
+ }
+ else partMapper.SetInputData(partGrid); // metoda 1, ne tak pekne stinovani, viz: http://www.codeguru.com/cpp/g-m/opengl/article.php/c2681
+ }
+ partMapper.ScalarVisibilityOn();
+
+ vtkActor partActor = new vtkActor();
+ // partActor.SetPickable(1);
+ vtkProperty prop = partActor.GetProperty();
+ prop.SetColor(1, 1, 0);
+ prop.Delete();
+ partActor.SetMapper(partMapper);
+
+ partMapper.Delete();
+
+ if (cleanPart)
+ partCleaner.Delete();
+
+ return partActor;
+ }
+
+ public static vtkActor createEdgesActor(vtkPolyData partGrid) {
+ vtkCleanPolyData partCleaner = null;
+
+ if (cleanPart)
+ {
+ partCleaner = new vtkCleanPolyData();
+ partCleaner.SetInputData(partGrid);
+ if(mergePoints) {
+ partCleaner.PointMergingOn();
+ } else {
+ partCleaner.PointMergingOff();
+ }
+ }
+
+ vtkFeatureEdges partEdges = new vtkFeatureEdges();
+ if (cleanPart) {
+ vtkAlgorithmOutput out = partCleaner.GetOutputPort();
+ partEdges.SetInputConnection(out);
+ out.Delete();
+ }
+ else partEdges.SetInputData(partGrid);
+ // partEdges.SetFeatureAngle(featureAngle); // this do not have to be neccesarily called
+ partEdges.FeatureEdgesOn();
+ partEdges.BoundaryEdgesOn();
+ partEdges.NonManifoldEdgesOn();
+ partEdges.ManifoldEdgesOn();
+
+ vtkDataSetMapper partEdgesMapper = new vtkDataSetMapper();
+ vtkAlgorithmOutput out = partEdges.GetOutputPort();
+ partEdgesMapper.SetInputConnection(out);
+ out.Delete();
+ partEdgesMapper.SetResolveCoincidentTopologyToPolygonOffset();
+ partEdgesMapper.ScalarVisibilityOff();
+
+ vtkActor partEdgesActor = new vtkActor();
+
+ vtkProperty prop = partEdgesActor.GetProperty();
+ prop.SetColor(0, 0, 0);
+ prop.SetLineWidth(2.0);
+ prop.Delete();
+ partEdgesActor.SetMapper(partEdgesMapper);
+
+ partEdgesMapper.Delete();
+ partEdges.Delete();
+
+ if (cleanPart)
+ partCleaner.Delete();
+
+ return partEdgesActor;
+ }
+
+ public static vtkActor createVerticesActor(vtkActor partEdgesActor) {
+ vtkDataSetMapper partEdgesMapper = (vtkDataSetMapper) partEdgesActor.GetMapper();
+ vtkAlgorithmOutput out = partEdgesMapper.GetInputConnection(0, 0);
+ vtkFeatureEdges partEdges = (vtkFeatureEdges)out.GetProducer();
+
+ vtkActor edgePointsActor = createVerticesActor(partEdges);
+
+ partEdges.Delete();
+ //out.Delete();
+ partEdgesMapper.Delete();
+ return edgePointsActor;
+ }
+
+ public static vtkActor createVerticesActor(vtkFeatureEdges partEdges) {
+ EdgePointsFilter edgePoints = new EdgePointsFilter();
+
+
+ vtkAlgorithmOutput out = partEdges.GetOutputPort();
+ edgePoints.SetInputConnection(out);
+ out.Delete();
+
+ vtkSphereSource sphereSource = new vtkSphereSource();
+ vtkGlyph3D glyph3D = new vtkGlyph3D();
+ out = sphereSource.GetOutputPort();
+ glyph3D.SetSourceConnection(out);
+ out.Delete();
+
+ out = edgePoints.GetOutputPort();
+ glyph3D.SetInputConnection(out);
+ out.Delete();
+
+ glyph3D.SetScaleFactor(0.03);
+
+ glyph3D.Update();
+
+ vtkPolyDataMapper partEdgePointsMapper = new vtkPolyDataMapper();
+ out = glyph3D.GetOutputPort();
+ partEdgePointsMapper.SetInputConnection(out);
+ out.Delete();
+
+ vtkActor edgePointsActor = new vtkActor();
+
+ vtkProperty prop = edgePointsActor.GetProperty();
+ prop.SetColor(0, 0, 1);
+ prop.Delete();
+ edgePointsActor.SetMapper(partEdgePointsMapper);
+
+ edgePointsActor.PickableOn();
+
+
+ partEdgePointsMapper.Delete();
+ edgePoints.Delete();
+ sphereSource.Delete();
+
+ return edgePointsActor;
+ }
+
+ public static vtkActor createSilhouette(vtkRenderer ren, vtkPolyData data) {
+
+
+ vtkPolyDataSilhouette silhouette = new vtkPolyDataSilhouette();
+
+ silhouette.SetInputData(data);
+ silhouette.SetCamera(ren.GetActiveCamera());
+ silhouette.SetEnableFeatureAngle(0);
+ vtkPolyDataMapper mapper = new vtkPolyDataMapper();
+
+ mapper.SetInputConnection(silhouette.GetOutputPort());
+
+ vtkActor actor = new vtkActor();
+ actor.SetMapper(mapper);
+
+ actor.GetProperty().SetColor(0,0,1);
+ actor.GetProperty().SetLineWidth(6);
+
+ return actor;
+
+
+
+ }
+
+}
Code Review / simantics / 3d.git / blobdiff