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