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