org.simantics.plant3d/src/org/simantics/plant3d/scl/P3DScriptNodeMap.java

   1 package org.simantics.plant3d.scl;
   2
   3 import java.util.HashSet;
   4 import java.util.Set;
   5
   6 import org.simantics.db.ReadGraph;
   7 import org.simantics.db.Session;
   8 import org.simantics.db.exception.DatabaseException;
   9 import org.simantics.g3d.ontology.G3D;
  10 import org.simantics.g3d.scenegraph.base.INode;
  11 import org.simantics.g3d.scenegraph.base.ParentNode;
  12 import org.simantics.g3d.scl.ScriptNodeMap;
  13 import org.simantics.g3d.vtk.common.VtkView;
  14 import org.simantics.objmap.graph.IMapping;
  15 import org.simantics.plant3d.ontology.Plant3D;
  16 import org.simantics.plant3d.scenegraph.IP3DNode;
  17 import org.simantics.plant3d.scenegraph.IP3DVisualNode;
  18 import org.simantics.plant3d.scenegraph.P3DParentNode;
  19 import org.simantics.plant3d.scenegraph.P3DRootNode;
  20 import org.simantics.plant3d.scenegraph.ParameterizedNode;
  21 import org.simantics.plant3d.scenegraph.PipeRun;
  22 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
  23 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
  24
  25 import vtk.vtkProp3D;
  26
  27 public class P3DScriptNodeMap extends ScriptNodeMap<INode>{
  28
  29         private static final boolean DEBUG = false;
  30
  31         public P3DScriptNodeMap(Session session, IMapping mapping, P3DRootNode rootNode) {
  32                 super(session,mapping,rootNode);
  33                 //rootNode.setNodeMap(this);
  34         }
  35
  36         @Override
  37         protected void updateActor(INode n, Set<String> ids) {
  38                 if (DEBUG) System.out.println("P3DNodeMap update " + n);
  39                 if (!(n instanceof IP3DVisualNode)) {
  40                         if (n instanceof PipeControlPoint) {
  41                                 n = ((PipeControlPoint)n).getPipelineComponent();
  42                                 if (n == null)
  43                                         return;
  44                         } else {
  45                                 return;
  46                         }
  47                 }
  48
  49                 IP3DVisualNode node = (IP3DVisualNode)n;
  50
  51                 if (DEBUG) {
  52                         System.out.print("P3DNodeMap update " + node);
  53                         for (String s : ids)
  54                                 System.out.print(" " + s);
  55                         System.out.println();
  56                 }
  57
  58                 if (ids.contains(Plant3D.URIs.hasGeometry)) {
  59                         //node.visualize(view);
  60                         //updateRenderObjectsFor(node);
  61                         updateTransform(node);
  62                 }
  63                 if (n instanceof ParameterizedNode) {
  64                         ParameterizedNode geom = (ParameterizedNode)n;
  65                         for (String id : geom.getParameterMap().keySet()) {
  66                                 if (ids.contains(id)) {
  67 //                    node.visualize(view);
  68 //                    updateRenderObjectsFor(node);
  69                                         updateTransform(node);
  70                                         break;
  71                                 }
  72                         }
  73                 } else if (n instanceof PipeRun) {
  74                         // FIXME: may require rule based update!
  75                         PipeRun run = (PipeRun)n;
  76                         Set<String> ids2 = new HashSet<String>();
  77                         ids2.add(Plant3D.URIs.hasGeometry);
  78                         for (PipeControlPoint pcp : run.getControlPoints()) {
  79                                 updateActor(pcp, ids2);
  80                         }
  81                 }
  82
  83                 if (ids.contains(G3D.URIs.hasPosition) ||
  84                         ids.contains(G3D.URIs.hasOrientation) ||
  85                         ids.contains(G3D.URIs.hasWorldPosition) ||
  86                         ids.contains(G3D.URIs.hasWorldOrientation)) {
  87                         updateTransform(node);
  88                 }
  89         }
  90
  91         private void updateTransform(IP3DNode node) {
  92                 if (DEBUG) System.out.println("P3DNodeMap update Transform " + node);
  93
  94
  95                 if (node instanceof ParentNode<?>) {
  96                         ParentNode<IP3DNode> p = (ParentNode<IP3DNode>)node;
  97                         for (IP3DNode n : p.getNodes())
  98                                 updateTransform(n);
  99                 }
 100         }
 101
 102         @Override
 103         protected void removeActor(INode n) {
 104                 if (DEBUG) System.out.println("P3DNodeMap.removeActor " + n);
 105                 if (!(n instanceof IP3DVisualNode))
 106                         return;
 107                 IP3DVisualNode node = (IP3DVisualNode)n;
 108 //        remActor(node);
 109
 110                 if (node instanceof P3DParentNode<?>) {
 111                         for (IP3DNode n2 : ((P3DParentNode<?>)node).getNodes())
 112                                 if (n2 instanceof IP3DVisualNode)
 113                                         removeActor((IP3DVisualNode)n2);
 114                 }
 115         }
 116
 117         @Override
 118         protected void addActor(INode n) {
 119                 if (DEBUG) System.out.println("P3DNodeMap.addActor " + n);
 120                 if (!(n instanceof IP3DVisualNode))
 121                         return;
 122                 IP3DVisualNode node = (IP3DVisualNode)n;
 123
 124 //        if (hasActor(node))
 125 //            return;
 126
 127                 if (node instanceof P3DParentNode<?>) {
 128                         for (IP3DNode n2 : ((P3DParentNode<?>)node).getNodes())
 129                                 if (n2 instanceof IP3DVisualNode)
 130                                         addActor((IP3DVisualNode)n2);
 131                 }
 132
 133                 updateTransform(node);
 134         }
 135
 136         @Override
 137         protected void update(ReadGraph graph) throws DatabaseException {
 138                 validate();
 139 //      System.out.println("Graph updates");
 140                 super.update(graph);
 141                 validate();
 142         }
 143
 144         @Override
 145         public void commit(String commitMessage) {
 146                 validate();
 147 //      System.out.println("Graph commit");
 148                 super.commit(commitMessage);
 149
 150         }
 151         @Override
 152         protected void doCommit() throws DatabaseException{
 153 //      System.out.println("Do commit");
 154                 validate();
 155                 super.doCommit();
 156         }
 157
 158         private void validate() {
 159                 for (INode node : rootNode.getNodes()) {
 160                         if (node instanceof PipeRun)
 161                                 PipingRules.validate((PipeRun)node);
 162                 }
 163         }
 164
 165         @Override
 166         public void update() throws DatabaseException {
 167                 try {
 168                         boolean b = true;
 169                         while (b) {
 170                                 updateCycle();
 171                                 b = PipingRules.update();
 172                         }
 173                 } catch (Exception e) {
 174                         e.printStackTrace();
 175                 }
 176                 super.update();
 177         }
 178
 179 }