org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/GeometryNode.java

   1 package org.simantics.plant3d.scenegraph;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.Collections;
   6 import java.util.HashMap;
   7 import java.util.List;
   8 import java.util.Map;
   9
  10 import org.jcae.opencascade.jni.TopoDS_Shape;
  11 import org.simantics.g3d.math.MathTools;
  12 import org.simantics.g3d.scenegraph.NodeHighlighter;
  13 import org.simantics.g3d.vtk.utils.vtkUtil;
  14 import org.simantics.objmap.graph.annotations.RelatedGetObj;
  15 import org.simantics.objmap.graph.annotations.RelatedSetObj;
  16 import org.simantics.opencascade.OccTriangulator;
  17 import org.simantics.opencascade.ParametricSolidModelProvider;
  18 import org.simantics.opencascade.SolidModelProvider;
  19 import org.simantics.opencascade.vtk.vtkSolidObject;
  20 import org.simantics.plant3d.ontology.Plant3D;
  21
  22 import vtk.vtkActor;
  23 import vtk.vtkPanel;
  24 import vtk.vtkProp3D;
  25 import vtk.vtkProperty;
  26 import vtk.vtkRenderer;
  27
  28 public abstract class GeometryNode extends P3DNode implements ParameterizedNode, NodeHighlighter {
  29
  30         private TopoDS_Shape solidModel;
  31         private vtkSolidObject solidObject;
  32
  33         private Map<String,Object> currentParameters;
  34         private Map<String,Object> calculatedParameters;
  35
  36         private boolean parametersUpdated = true;
  37
  38         public GeometryNode() {
  39                 currentParameters = new HashMap<String, Object>();
  40                 calculatedParameters = new HashMap<String, Object>();
  41         }
  42
  43         @Override
  44         public void visualize(vtkPanel panel) {
  45                 if (solidModelProvider != null) {
  46
  47                         updateParameters();
  48                         if (solidModel == null || parametersUpdated) {
  49                                 createGeometry();
  50                         }
  51                 }
  52                 if ((solidObject == null || parametersUpdated) && solidModel != null) {
  53                         solidObject = new vtkSolidObject(panel, solidModel);
  54                 }
  55                 if (solidObject != null) {
  56                         solidObject.visualizeSolid(true,true, false,false);
  57                         updateVisuals(true, true);
  58                 }
  59                 parametersUpdated = false;
  60
  61         }
  62
  63         public void updateParameters() {
  64                 if (solidModelProvider instanceof ParametricSolidModelProvider) {
  65                         ((ParametricSolidModelProvider)solidModelProvider).setProperties(currentParameters);
  66                         ((ParametricSolidModelProvider)solidModelProvider).updateCalculatedProperties(calculatedParameters);
  67                 }
  68         }
  69
  70         private void createGeometry() {
  71                 Collection<TopoDS_Shape> shapes;
  72                 try {
  73                         shapes = solidModelProvider.getModel();
  74                         if (shapes.size() == 1) {
  75                                 solidModel = shapes.iterator().next();
  76                         } else {
  77                                 solidModel = OccTriangulator.makeCompound(shapes.toArray(new TopoDS_Shape[shapes.size()]));
  78                                 for (TopoDS_Shape shape : shapes) {
  79                                         shape.delete();
  80                                 }
  81                         }
  82 //                              shapes.clear();
  83                 } catch (Exception e) {
  84                         // TODO Auto-generated catch block
  85                         e.printStackTrace();
  86                 }
  87         }
  88
  89         public Map<String, Object> getParameterMap() {
  90                 return Collections.unmodifiableMap(currentParameters);
  91         }
  92
  93         public Map<String, Object> getCalculatedParameters() {
  94                 return calculatedParameters;
  95         }
  96
  97         public void setParametersUpdated(boolean parametersUpdated) {
  98                 this.parametersUpdated = parametersUpdated;
  99         }
 100
 101         public void setParameterMap(Map<String, Object> parameters) {
 102                 for (String id : parameters.keySet()) {
 103                         Object currentValue = currentParameters.get(id);
 104                         Object newValue = parameters.get(id);
 105                         if (currentValue == newValue)
 106                                 continue;
 107                         if (currentValue instanceof Double) {
 108                                 if (Math.abs((Double)currentValue-(Double)newValue) < MathTools.NEAR_ZERO)
 109                                         continue;
 110                         }
 111                         currentParameters.put(id, newValue);
 112                         parametersUpdated = true;
 113                         firePropertyChanged(id);
 114                 }
 115         }
 116
 117         private SolidModelProvider solidModelProvider;
 118
 119         @RelatedGetObj(Plant3D.URIs.hasGeometry)
 120         public SolidModelProvider getGeometry() {
 121                 return solidModelProvider;
 122         }
 123
 124         @RelatedSetObj(Plant3D.URIs.hasGeometry)
 125         public void setGeometry(final SolidModelProvider provider) {
 126                 if (provider != null && provider.equals(solidModelProvider))
 127                         return;
 128
 129                 if (solidModelProvider != null) {
 130                         deleteData();
 131                 }
 132                 solidModelProvider = provider;
 133                 firePropertyChanged(Plant3D.URIs.hasGeometry);
 134         }
 135
 136         private void deleteData() {
 137                 solidModelProvider = null;
 138                 if (solidObject != null) {
 139                         solidObject.clearActors();
 140                         solidObject = null;
 141                 }
 142                 if (solidModel != null) {
 143                         solidModel.delete();
 144                         solidModel = null;
 145                 }
 146         }
 147
 148         @Override
 149         public Collection<vtkProp3D> getActors() {
 150                 List<vtkProp3D> list = new ArrayList<vtkProp3D>();
 151                 if (solidObject != null)
 152                         list.addAll(solidObject.getActors());
 153                 return list;
 154         }
 155
 156         @Override
 157         public void stopVisualize() {
 158                 if (solidObject != null) {
 159                         solidObject.clearActorsAWT();
 160                         solidObject = null;
 161                 }
 162                 if (solidModel != null) {
 163                         solidModel.delete();
 164                         solidModel = null;
 165                 }
 166
 167         }
 168
 169         private boolean selected = false;
 170         private boolean hover = false;
 171
 172         @Override
 173         public void highlight(HighlightEventType type) {
 174                 if (type == HighlightEventType.Selection || type == HighlightEventType.ClearSelection) {
 175                         selected = type == HighlightEventType.Selection;
 176 //                      hingeA.visualizeSolid(selected,true,false);
 177 //                      hingeB.visualizeSolid(selected,true,false);
 178                         updateVisuals(true, false);
 179 //                      update(null);
 180                 } else {
 181                         hover = type == HighlightEventType.Hover;
 182                         updateVisuals(false, true);
 183                 }
 184
 185
 186         }
 187
 188         protected double[] getSelectedColor() {
 189                 return new double[]{1,0,0};
 190         }
 191
 192         protected double[] getColor() {
 193                 return new double[]{1,1,0};
 194         }
 195
 196         private void updateVisuals(boolean s, boolean h) {
 197                 if (solidObject != null) {
 198                         if (s) {
 199                                 double color[];
 200                                 if (selected) {
 201                                         color = getSelectedColor();
 202
 203                                 } else {
 204                                         color = getColor();
 205
 206                                 }
 207                                 for (vtkProp3D prop : solidObject.getSolid()) {
 208                                         vtkProperty property = ((vtkActor)prop).GetProperty();
 209                                         property.SetColor(color);
 210                                         property.Delete();
 211                                 }
 212                         }
 213                         if (h) {
 214                                 double color[] = new double[]{0,0,0};
 215                                 if (hover)
 216                                         color = new double[]{1,0,1};
 217                                 for (vtkProp3D prop : solidObject.getEdges()) {
 218                                         vtkProperty property = ((vtkActor)prop).GetProperty();
 219                                         property.SetColor(color);
 220                                         property.Delete();
 221                                 }
 222
 223                         }
 224                 } else {
 225 //                      if (s) {
 226 //                              axes.addToRenderer();
 227 //                              axes.setAxesVisibility(selected);
 228 //                      }
 229                 }
 230         }
 231
 232         public void update(vtkRenderer ren) {
 233                 vtkUtil.updateTransform(getActors(), getWorldPosition(), getWorldOrientation());
 234         }
 235
 236         public TopoDS_Shape getSolidModel() {
 237                 return solidModel;
 238         }
 239 }