org.simantics.proconf.processeditor/src/fi/vtt/simantics/processeditor/common/PipingTools2.java

   1 package fi.vtt.simantics.processeditor.common;\r
   2 \r
   3 import java.util.Collection;\r
   4 \r
   5 import javax.vecmath.Point3d;\r
   6 import javax.vecmath.Vector3d;\r
   7 \r
   8 import org.simantics.db.Graph;\r
   9 import org.simantics.db.Resource;\r
  10 import org.simantics.layer0.utils.EntityFactory;\r
  11 import org.simantics.layer0.utils.IEntity;\r
  12 import org.simantics.layer0.utils.Statement;\r
  13 import org.simantics.layer0.utils.instantiation.Instance;\r
  14 import org.simantics.layer0.utils.instantiation.InstanceFactory;\r
  15 import org.simantics.proconf.g3d.base.G3DTools;\r
  16 import org.simantics.proconf.g3d.stubs.G3DNode;\r
  17 \r
  18 import fi.vtt.simantics.processeditor.ProcessResource;\r
  19 import fi.vtt.simantics.processeditor.actions.PositionType;\r
  20 import fi.vtt.simantics.processeditor.stubs.Equipment;\r
  21 import fi.vtt.simantics.processeditor.stubs.InlineComponent;\r
  22 import fi.vtt.simantics.processeditor.stubs.Nozzle;\r
  23 import fi.vtt.simantics.processeditor.stubs.PipeControlPoint;\r
  24 import fi.vtt.simantics.processeditor.stubs.PipeRun;\r
  25 import fi.vtt.simantics.processeditor.stubs.PipelineComponent;\r
  26 \r
  27 public class PipingTools2 {\r
  28         private static final boolean DEBUG = false;\r
  29         public enum Direction{NEXT,PREVIOUS};\r
  30         \r
  31 \r
  32         \r
  33         /**\r
  34          * Reverses a piperun by swapping all previous/next connections\r
  35          * @param pipeRun\r
  36          */\r
  37         public static void reversePipeRun(IEntity pipeRun) {\r
  38 //              //FIXME : reducers / size-change / offset-control points\r
  39 //      RelationTypeSet<PipeControlPoint> cps = pipeRun.getHasControlPointSet();\r
  40 //      if (cps.size() == 0)\r
  41 //              return;\r
  42 //      List<PipeControlPoint> list = new ArrayList<PipeControlPoint>();\r
  43 //      PipeControlPoint pcp = cps.iterator().next();\r
  44 //      list.add(pcp);\r
  45 //      PipeControlPoint temp = pcp.getPrevious();\r
  46 //      while (temp != null) {\r
  47 //              list.add(0,temp);\r
  48 //              temp = temp.getPrevious();\r
  49 //      }\r
  50 //      temp = pcp.getNext();\r
  51 //      while (temp != null) {\r
  52 //              list.add(temp);\r
  53 //              temp = temp.getNext();\r
  54 //      }\r
  55 //      // now list contains control points in sorted order.\r
  56 //      // switch order\r
  57 //      for (int i = 0; i < list.size() - 1; i++) {\r
  58 //              PipeControlPoint pcp1 = list.get(i);\r
  59 //              PipeControlPoint pcp2 = list.get(i+1);\r
  60 //              pcp1.setPrevious(pcp2);\r
  61 //              pcp2.setNext(pcp1);\r
  62 //\r
  63 //      }\r
  64 //      // fix ends\r
  65 //      list.get(0).setNext(null);\r
  66 //      list.get(list.size() - 1).setPrevious(null);\r
  67 \r
  68         }\r
  69 \r
  70         public static IEntity getPipeRun(IEntity component) {\r
  71                 assert(component.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
  72                 return component.getSingleRelatedObject(ProcessResource.g3dResource.HasParent);\r
  73         }\r
  74         \r
  75          /**\r
  76      * Returns Nozzle of a directed control point\r
  77      * @param dcp\r
  78      * @return\r
  79      */\r
  80     public static Nozzle getNozzle(PipeControlPoint dcp) {\r
  81         assert (dcp.isInstanceOf(ProcessResource.plant3Dresource.DirectedControlPoint));\r
  82         IEntity e = dcp.getControlPointOf();\r
  83         if (e == null)\r
  84                 return null;\r
  85         assert (e.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
  86         return new Nozzle(e);\r
  87     }\r
  88         \r
  89         /**\r
  90          * Instantiates new pipeline component and all necessary control points for it.\r
  91          * @param graph\r
  92          * @param typeResource\r
  93          * @return\r
  94          */\r
  95         public static PipelineComponent instantiatePipelineComponent(Graph graph, Resource pipeRunResource, Resource typeResource) {\r
  96                 IEntity pipeRun = EntityFactory.create(graph,pipeRunResource);\r
  97                 Instance ins = InstanceFactory.getInstanceOfType(graph, typeResource);\r
  98         Resource instance = ins.instantiate(graph);\r
  99         PipelineComponent component = new PipelineComponent(graph,instance);\r
 100         G3DTools.resetTransformation(component);\r
 101         // copy control point\r
 102         Collection<Resource> pcps = graph.getObjects(typeResource, ProcessResource.plant3Dresource.HasControlPoint);\r
 103         assert(pcps.size() == 1);\r
 104         Collection<Resource> types = graph.getObjects(pcps.iterator().next(), ProcessResource.builtins.InstanceOf);\r
 105         PipeControlPoint componentPCP = new PipeControlPoint(graph,InstanceFactory.instantiate(graph, types));\r
 106         component.addStatement(ProcessResource.plant3Dresource.HasControlPoint, componentPCP);\r
 107         pipeRun.addStatement(ProcessResource.g3dResource.HasChild, component);\r
 108         pipeRun.addStatement(ProcessResource.plant3Dresource.HasControlPoints, componentPCP);\r
 109         component.setPipeDiameter(pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
 110         if (component.isInstanceOf(ProcessResource.plant3Dresource.VariableAngleTurnComponent)) {\r
 111                 setStatement(component, ProcessResource.plant3Dresource.HasTurnRadius, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnRadius));\r
 112                 setStatement(componentPCP, ProcessResource.plant3Dresource.HasTurnRadius, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnRadius));\r
 113                 setStatement(component, ProcessResource.plant3Dresource.HasTurnAngle, componentPCP.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnAngle));\r
 114                 setStatement(component, ProcessResource.plant3Dresource.HasTurnAxis, componentPCP.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnAxis));                 \r
 115         }\r
 116         if (component.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasLength) != null) {\r
 117                 setStatement(componentPCP, ProcessResource.plant3Dresource.HasLength, component.getSingleRelatedObject(ProcessResource.plant3Dresource.HasLength));\r
 118         }\r
 119         componentPCP.setLocalOrientation(component.getLocalOrientation());\r
 120         componentPCP.setWorldOrientation(component.getWorldOrientation());\r
 121         \r
 122         componentPCP.setLocalPosition(component.getLocalPosition());\r
 123         componentPCP.setWorldPosition(component.getWorldPosition());\r
 124         \r
 125         setStatement(componentPCP, ProcessResource.plant3Dresource.HasPipeDiameter, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
 126         setStatement(component, ProcessResource.plant3Dresource.HasPipeDiameter, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
 127         \r
 128         // TODO : instantiate subpoints\r
 129         \r
 130         \r
 131         return component;\r
 132         }\r
 133         \r
 134         public static Nozzle instantiateNozzle(Graph graph, Resource typeResource) {\r
 135                 Instance ins = InstanceFactory.getInstanceOfType(graph, typeResource);\r
 136         Resource instance = ins.instantiate(graph);\r
 137         Nozzle n = new Nozzle(graph,instance);\r
 138         G3DTools.resetTransformation(n);\r
 139         \r
 140         // copy control point\r
 141         Collection<Resource> pcps = graph.getObjects(typeResource, ProcessResource.plant3Dresource.HasControlPoint);\r
 142         assert(pcps.size() == 1);\r
 143         Collection<Resource> types = graph.getObjects(pcps.iterator().next(), ProcessResource.builtins.InstanceOf);\r
 144         PipeControlPoint nozzlePCP = new PipeControlPoint(graph,InstanceFactory.instantiate(graph, types));\r
 145         n.addStatement(ProcessResource.plant3Dresource.HasControlPoint, nozzlePCP);\r
 146         nozzlePCP.setLocalOrientation(n.getLocalOrientation());\r
 147         nozzlePCP.setWorldOrientation(n.getWorldOrientation());\r
 148         nozzlePCP.setLocalPosition(n.getLocalPosition());\r
 149         nozzlePCP.setWorldPosition(n.getWorldPosition());\r
 150         setStatement(nozzlePCP, ProcessResource.plant3Dresource.HasPipeDiameter, n.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
 151         nozzlePCP.setPipeDiameter(0.2);\r
 152         return n;\r
 153         }\r
 154         \r
 155         public static Equipment instantiateEquipment(Graph graph, Resource typeResource) {\r
 156                 Instance ins = InstanceFactory.getInstanceOfType(graph, typeResource);\r
 157         Resource instance = ins.instantiate(graph);\r
 158         Equipment equipment = new Equipment(graph, instance);\r
 159         G3DTools.resetTransformation(equipment);\r
 160         \r
 161         IEntity type = EntityFactory.create(graph, typeResource);\r
 162         IEntity geometricModel = type.getSingleRelatedObject(ProcessResource.plant3Dresource.HasGraphics);\r
 163         \r
 164         Collection<IEntity> sizingProperties = geometricModel.getRelatedObjects(ProcessResource.g3dResource.HasSizingParameter);\r
 165         Collection<Statement> equipmentProperties = equipment.getRelatedStatements(ProcessResource.builtins.HasProperty);\r
 166                 \r
 167         for (IEntity e : sizingProperties) {\r
 168                 String name = e.getName();\r
 169                 String pName = "Has " + name;\r
 170                 boolean found = false;\r
 171                 for (Statement s : equipmentProperties) {\r
 172                         IEntity predicate = s.getPredicate();\r
 173                         String predicateName = predicate.getName();\r
 174                         if (predicateName.equals(pName)) {\r
 175                                 found = true;\r
 176                                 break;\r
 177                         }\r
 178                 }\r
 179                 if(!found) {\r
 180                         IEntity rel = getOrCreateRel(graph,name);\r
 181                         equipment.setRelatedScalarDouble(rel, 1.0);\r
 182                 }\r
 183         }\r
 184         \r
 185         // TODO : create nozzles if needed\r
 186         \r
 187         return equipment;\r
 188         }\r
 189         \r
 190         private static IEntity getOrCreateRel(Graph graph, String name) {\r
 191                 IEntity rel = null;\r
 192                 try {\r
 193                         Resource relr = graph.getResourceByURI("http://www.vtt.fi/Simantics/Plant3D/1.0/Relations#Has" + name);\r
 194                         rel = EntityFactory.create(graph,relr);\r
 195                 } catch (Exception e) {\r
 196                         Resource relLib = null;\r
 197                         try {\r
 198                                 relLib = graph.getResourceByURI("http://www.vtt.fi/Simantics/Plant3D/1.0#Relations");\r
 199                         } catch (Exception e2) {\r
 200                                 \r
 201                         }\r
 202                         Resource relr = graph.newResource();\r
 203                         rel = EntityFactory.create(graph, relr);\r
 204                         rel.addStatement(ProcessResource.builtins.SubrelationOf, ProcessResource.g3dResource.HasNonTransformation);\r
 205                         rel.setName("Has " + name);\r
 206                         Resource irelr = graph.newResource();\r
 207                         graph.addStatement(relr,ProcessResource.builtins.InverseOf,irelr);\r
 208                         graph.addStatement(relLib, ProcessResource.builtins.ConsistsOf, relr);\r
 209                 }\r
 210                 return rel;\r
 211         }\r
 212         \r
 213         public static IEntity getLibraryComponentType(IEntity component) {\r
 214                 assert(component.isInstanceOf(ProcessResource.plant3Dresource.LibraryComponent));\r
 215                 // IEntity.getTypes() returns all types, but we want the closest type.\r
 216                 Collection<IEntity> types = component.getRelatedObjects(ProcessResource.builtins.InstanceOf);//component.getTypes();\r
 217                 IEntity type = null;\r
 218                 for (IEntity t : types) {\r
 219                         if (t.isInheritedFrom(ProcessResource.plant3Dresource.LibraryComponent)) {\r
 220                                 if (type == null)\r
 221                                         type = t;\r
 222                                 else\r
 223                                         throw new RuntimeException("Cannot find proper type for library component " + component.getResource() );\r
 224                         }\r
 225                 }\r
 226                 return type;\r
 227         }\r
 228         \r
 229         /**\r
 230          * Splits existing VariableLengthComponent with another component.\r
 231          * Result is two VariableLengthComponents and inserted component between them.\r
 232          * \r
 233          * Note : world position of newComponent must be set before this method may be called.\r
 234          * \r
 235          * @param newComponent\r
 236          * @param splittingComponent\r
 237          */\r
 238         public static void splitVariableLengthComponent(IEntity newComponent, IEntity splittingComponent) {\r
 239                 assert(splittingComponent.isInstanceOf(ProcessResource.plant3Dresource.VariableLengthInlineComponent));\r
 240                 assert(newComponent.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
 241                 assert(!newComponent.isInstanceOf(ProcessResource.plant3Dresource.VariableLengthInlineComponent));\r
 242                 IEntity newCP = newComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
 243                 IEntity splittingCP = splittingComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
 244                 IEntity nextCP = splittingCP.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasNext);\r
 245                 IEntity prevCP = splittingCP.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasPrevious);\r
 246                 \r
 247                 /* there are many different cases to insert new component when\r
 248                    it splits existing VariableLengthinlineComponent.\r
 249             \r
 250                1. VariableLengthComponet is connected from both sides:\r
 251                   - insert new component between VariableLength component and component connected to it\r
 252                   - insert new VariableLengthComponent between inserted component and component selected in previous step\r
 253                 \r
 254                    2. VariableLengthComponent is connected from one side\r
 255                      - Use previous case or:\r
 256                      - Insert new component to empty end\r
 257                      - Insert new VariableLength component to inserted components empty end\r
 258                      \r
 259                    3. VariableLength is not connected to any component.\r
 260                      - Should not be possible, at least in current implementation.\r
 261                      - Could be done using second case\r
 262 \r
 263                 */\r
 264                 \r
 265                 if (nextCP == null && prevCP == null) {\r
 266                         // this should not be possible\r
 267                         throw new RuntimeException("VariableLengthComponent " + splittingComponent.getResource() + " is not connected to anything.");\r
 268                 }\r
 269                 \r
 270                 Point3d next = ControlPointTools.getRealPosition(splittingCP, PositionType.NEXT);\r
 271                 Point3d prev = ControlPointTools.getRealPosition(splittingCP, PositionType.PREVIOUS);\r
 272                 Point3d comp = G3DTools.getPoint(newComponent.getSingleRelatedObject(ProcessResource.g3dResource.HasWorldPosition));\r
 273                 double length = newComponent.getSingleRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength);\r
 274                 Vector3d dir = new Vector3d(next);\r
 275                 dir.sub(prev);\r
 276                 dir.normalize();\r
 277                 dir.scale(length * 0.5);\r
 278                 Point3d vn = new Point3d(comp);\r
 279                 Point3d vp = new Point3d(comp);\r
 280                 vn.add(dir);\r
 281                 vp.sub(dir);\r
 282                 double ln = vn.distance(next);\r
 283                 double lp = vp.distance(prev);\r
 284                 vp.interpolate(prev, 0.5);\r
 285                 vn.interpolate(next, 0.5);\r
 286                 \r
 287                 IEntity type = getLibraryComponentType(splittingComponent);\r
 288                 \r
 289                 IEntity newVariableLengthComponent = instantiatePipelineComponent(splittingComponent.getGraph(), getPipeRun(splittingComponent).getResource(), type.getResource());\r
 290                 IEntity newVariableLengthCP = newVariableLengthComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
 291                 if (nextCP == null) {\r
 292                         ControlPointTools.insertControlPoint(newCP, splittingCP,Direction.NEXT);\r
 293                         ControlPointTools.insertControlPoint(newVariableLengthCP, newCP,Direction.NEXT);\r
 294                         ControlPointTools.setWorldPosition(splittingCP, vp);\r
 295                         splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);\r
 296                         ControlPointTools.setWorldPosition(newVariableLengthCP, vn);    \r
 297                         newVariableLengthComponent.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln);\r
 298                 } else if (prevCP == null) {\r
 299                         ControlPointTools.insertControlPoint(newCP, splittingCP,Direction.PREVIOUS);\r
 300                         ControlPointTools.insertControlPoint(newVariableLengthCP, newCP,Direction.PREVIOUS);\r
 301                         ControlPointTools.setWorldPosition(splittingCP, vn);\r
 302                         splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln);\r
 303                         ControlPointTools.setWorldPosition(newVariableLengthCP, vp);\r
 304                         newVariableLengthComponent.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);\r
 305                 } else {\r
 306                         ControlPointTools.insertControlPoint(newCP,splittingCP,nextCP);\r
 307                         ControlPointTools.insertControlPoint(newVariableLengthCP, newCP,nextCP);\r
 308                         ControlPointTools.setWorldPosition(splittingCP, vp);\r
 309                         splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);\r
 310                         ControlPointTools.setWorldPosition(newVariableLengthCP, vn);\r
 311                         newVariableLengthComponent.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln);\r
 312                 }\r
 313 \r
 314         }\r
 315         \r
 316         /**\r
 317          * Attaches newComponent into connectedComponent's connectedControlPoint\r
 318          * @param newComponent\r
 319          * @param connectedComponent\r
 320          * @param connectedControlPoint\r
 321          */\r
 322         public static void insertComponent(IEntity newComponent, IEntity connectedComponent, IEntity connectedControlPoint, Direction direction) {\r
 323             assert (newComponent.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
 324             assert (connectedComponent.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
 325             // TODO : piperun check is more complicated, since newComponent and connectedComponent may be SizeChangeComponents \r
 326             //assert (getPipeRun(connectedComponent).equals(getPipeRun(newComponent)));\r
 327             \r
 328             // new control point and its subpoint\r
 329             IEntity newControlPoint = newComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
 330             ControlPointTools.insertControlPoint(newControlPoint, connectedControlPoint, direction);\r
 331 //          IEntity newSubPoint = null;\r
 332 //          if (newControlPoint.isInstanceOf(ProcessResource.plant3Dresource.DualInlineControlPoint))\r
 333 //              newSubPoint = newControlPoint.getSingleRelatedObject(ProcessResource.plant3Dresource.HasSubPoint);\r
 334 //          \r
 335 //          // connected components parent or subpoint \r
 336 //          IEntity connectedSubPoint = null;\r
 337 //          IEntity connectedParentPoint = null;\r
 338 //          if (connectedControlPoint.isInstanceOf(ProcessResource.plant3Dresource.DualInlineControlPoint))\r
 339 //              connectedSubPoint = connectedControlPoint.getSingleRelatedObject(ProcessResource.plant3Dresource.HasSubPoint);\r
 340 //          else if (connectedControlPoint.isInstanceOf(ProcessResource.plant3Dresource.DualSubControlPoint))\r
 341 //              connectedParentPoint = connectedControlPoint.getSingleRelatedObject(ProcessResource.plant3Dresource.SubPointOf);\r
 342 //          \r
 343 //          if (direction == Direction.NEXT) {\r
 344 //              assert (connectedSubPoint == null); // if direction is next, connection done to subpoint\r
 345 //              setStatement(connectedControlPoint, ProcessResource.plant3Dresource.HasNext, newControlPoint);\r
 346 //              if (connectedParentPoint != null)\r
 347 //                      setStatement(connectedParentPoint, ProcessResource.plant3Dresource.HasNext, newControlPoint);\r
 348 //              setStatement(newControlPoint, ProcessResource.plant3Dresource.HasPrevious, connectedControlPoint);\r
 349 //              if (newSubPoint != null)\r
 350 //                      setStatement(newSubPoint, ProcessResource.plant3Dresource.HasPrevious, connectedControlPoint);\r
 351 //              \r
 352 //          } else {\r
 353 //              assert (connectedParentPoint == null); // if direction is prev, connection done to parentpoint\r
 354 //              if (newSubPoint != null) {\r
 355 //                      \r
 356 //              }\r
 357 //          }\r
 358                 \r
 359                 /*\r
 360             private void insertEndComponent() {\r
 361                 activated = false;\r
 362                 Graph coreTC = parent.getGraph();\r
 363                 \r
 364                 if (replace == null)\r
 365                         checkForEndInsertion();\r
 366                 if (replace == null) {\r
 367                         ErrorLogger.defaultLogError("Cannot insert end component",null);\r
 368                         end();\r
 369                         return;\r
 370                 }\r
 371                 G3DNode p = straight.getHasParent();\r
 372                 if (p == null) {\r
 373                     ErrorLogger.defaultLogError("Straight pipe has no parent", new Exception("ASSERT!"));\r
 374 \r
 375                 } else {\r
 376                     Pipeline pipeline = PipelineFactory.create(p);\r
 377                     coreTC.startTransaction(this);\r
 378                     try {\r
 379                         Vector3d startPoint = GraphicsNodeTools.getVector(replace.getLocalPosition());\r
 380                         EndComponentControlPoint ecp = EndComponentControlPointFactory.instantiate(coreTC);\r
 381                         coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 382                         pipeline.getHasControlPointSet().remove(replace);\r
 383                         // create dummy node\r
 384                         //PipeControlPoint pcp = PipeControlPointFactory.instantiate(coreTC);\r
 385                         replace.setNextPoint(null);\r
 386                         replace.setPreviousPoint(null);\r
 387                         pipeline.getHasControlPointSet().add(ecp);\r
 388                         if (next) {\r
 389                                 straight.getHasControlPoint().getPreviousPoint().setNextPoint(ecp);\r
 390                                 straight.getHasControlPoint().setNextPoint(ecp);\r
 391                                 ecp.setPreviousPoint(straight.getHasControlPoint().getPreviousPoint());\r
 392                                 //ecp.setNextPoint(null);\r
 393                         } else {\r
 394                                 straight.getHasControlPoint().getNextPoint().setPreviousPoint(ecp);\r
 395                                 straight.getHasControlPoint().setPreviousPoint(ecp);\r
 396                                 ecp.setNextPoint(straight.getHasControlPoint().getNextPoint());\r
 397                                 //ecp.setPreviousPoint(null);\r
 398                         }\r
 399                         G3DTools.setTranslation(ecp.getLocalPosition(), startPoint);\r
 400                         // FIXME : component should specify how much space it needs\r
 401                         createAndLink(coreTC, pipeline, ecp);\r
 402                         coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 403                         coreTC.commitTransaction(CommitMessage.TRANSACTION_MESSAGE);\r
 404                     } catch (TransactionException e) {\r
 405                         ErrorLogger.defaultLogError("Cannot insert component", e);\r
 406                         coreTC.cancelTransaction();\r
 407                     }\r
 408                 }\r
 409                 \r
 410                 end();\r
 411             }\r
 412             \r
 413             private void insertComponent(Point3d startPoint) {\r
 414                 activated = false;\r
 415                 Graph coreTC = parent.getGraph();\r
 416                 G3DNode p = straight.getHasParent();\r
 417                 if (p == null) {\r
 418                     ErrorLogger.defaultLogError("Straight pipe has no parent", new Exception("ASSERT!"));\r
 419 \r
 420                 } else {\r
 421                     Pipeline pipeline = PipelineFactory.create(p);\r
 422                     coreTC.startTransaction(this);\r
 423                     try {\r
 424                         InlineComponentControlPoint icp = InlineComponentControlPointFactory.instantiate(coreTC);\r
 425                         coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 426                         PipeControlPoint scp = straight.getHasControlPoint();\r
 427                         // it shouldn't matter whitch control point to use, next or previous.\r
 428                         PipingTools.insertControlPoint(pipeline, icp, scp, scp.getNextPoint());\r
 429                         //PipingTools.insertControlPoint(straight, icp);\r
 430                         pipeline.getHasControlPointSet().add(icp);\r
 431                         G3DTools.setTranslation(icp.getLocalPosition(), startPoint);\r
 432                         // FIXME : component should specify how much space it needs\r
 433                         icp.setNextComponentOffsetValue(pipeline.getPipeRadiusValue());\r
 434                         icp.setPreviousComponentOffsetValue(pipeline.getPipeRadiusValue());\r
 435                         PipingTools.setSame(pipeline.getPipeRadius(), icp.getNextComponentOffset());\r
 436                         PipingTools.setSame(pipeline.getPipeRadius(), icp.getPreviousComponentOffset());\r
 437                         createAndLink(coreTC, pipeline, icp);\r
 438                         coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 439                         coreTC.commitTransaction(CommitMessage.TRANSACTION_MESSAGE);\r
 440                     } catch (TransactionException e) {\r
 441                         ErrorLogger.defaultLogError("Cannot insert component", e);\r
 442                         coreTC.cancelTransaction();\r
 443                     }\r
 444                 }\r
 445 \r
 446                 line.removeFromParent();\r
 447                 \r
 448                 end();\r
 449                 \r
 450             }\r
 451            \r
 452             \r
 453             private void createAndLink(Graph coreTC, Pipeline pipeline, PipeControlPoint icp) throws TransactionException {\r
 454                 PipelineComponent component = PipelineComponentFactory.create(OntologyUtils.instantiate(typeResource));\r
 455                 coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 456                 component.setHasControlPoint(icp);\r
 457                 component.setLocalPosition(icp.getLocalPosition());\r
 458                 pipeline.getHasSubnodesSet().add(component);\r
 459                 component.setPipeRadius(pipeline.getPipeRadius());\r
 460                 component.setHasGraphics(GraphicsModelFactory.create(modelResource));\r
 461                 \r
 462             }\r
 463              */\r
 464                 \r
 465                 /*\r
 466                         old insert reducer code\r
 467                         \r
 468                                         Pipeline pipeline = PipingTools.getPipeline(straight);\r
 469                         // pcp is Turn Control Point and we'll have to change it's type to Size Change Control Point\r
 470                         // First we'll remove its unnecessary properties and elbow connected to it,\r
 471                         RelationTypeSet<Entity> pipeComponents = pcp.getControlPointOfSet();\r
 472                         Resource elbowResource = null;\r
 473                         for (Entity e : pipeComponents) {\r
 474                                 if (e.getResource().isInstanceOf(GlobalIdMap.get(PSK3DModelingOntologyMapping.ELBOW))) {\r
 475                                         elbowResource = e.getResource();\r
 476                                 }\r
 477                         }\r
 478                         if (elbowResource != null) {\r
 479                                 pipeComponents.remove(elbowResource);\r
 480                                 pipeline.getHasSubnodesSet().remove(elbowResource);\r
 481                         }\r
 482                         RelationSet rs = pcp.getResource().getRelatedResourcesWithRelationIds(GlobalIdMap.get(PSK3DModelingOntologyMapping.HAS_TURN_ANGLE));\r
 483                         RelationReference rr = rs.getRelations()[0];\r
 484                         pcp.getResource().removeRelationById(rr.getObjectId(),rr.getRelationId());\r
 485                         rs = pcp.getResource().getRelatedResourcesWithRelationIds(GlobalIdMap.get(PSK3DModelingOntologyMapping.HAS_COMPONENT_OFFSET));\r
 486                         rr = rs.getRelations()[0];\r
 487                         pcp.getResource().removeRelationById(rr.getObjectId(),rr.getRelationId());\r
 488                         rs = pcp.getResource().getRelatedResourcesWithRelationIds(GlobalIdMap.get(Builtins.InstanceOf));\r
 489                         rr = rs.getRelations()[0];\r
 490                         //pcp.getResource().removeRelationById(type[0], GlobalIdMap.get(Builtins.InstanceOf));\r
 491                         pcp.getResource().removeRelationById(rr.getObjectId(),rr.getRelationId());\r
 492                         Resource sccpType = graph.getResource(PSK3DModelingOntologyMapping.SIZE_CHANGE_CONTROL_POINT);\r
 493                         pcp.createRelation(sccpType, graph.getResource(Builtins.InstanceOf));\r
 494                         \r
 495                         graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 496                         \r
 497                         Reducer reducer = null;\r
 498                         Pipeline newPipeline = PipelineFactory.instantiate(graph);\r
 499                         OffsetControlPoint offsetControlPoint = OffsetControlPointFactory.instantiate(graph);\r
 500                         if (i == 0) {\r
 501                                 reducer = ConcentricReducerFactory.instantiate(graph);\r
 502                         } else {\r
 503                                 reducer = EccentricReducerFactory.instantiate(graph);\r
 504                         }       \r
 505                         graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 506                         SizeChangeControlPoint sccp = SizeChangeControlPointFactory.create(pcp.getResource());\r
 507                         \r
 508                         \r
 509                         // FIXME : lenght, pipe radius and turn angle from specs + let the user choose spec for new pipeline\r
 510                         double reducerLength = 0.3;\r
 511                         reducer.setLengthValue(reducerLength);\r
 512                         double newPipeRadius = pipelineDialog.getPipeRadius();\r
 513                         double newPipeTurnRadius = pipelineDialog.getTurnRadius();\r
 514 \r
 515                         reducer.setLocalPosition(sccp.getLocalPosition());\r
 516                         reducer.setWorldPosition(sccp.getWorldPosition());\r
 517                         \r
 518                         reducer.setBottomRadiusValue(pipeline.getPipeRadiusValue());\r
 519                         \r
 520                         reducer.setPipeRadius(pipeline.getPipeRadius());\r
 521                         reducer.setTopRadiusValue(newPipeRadius);\r
 522                         newPipeline.setPipeRadiusValue(newPipeRadius);\r
 523                         newPipeline.setTurnRadiusValue(newPipeTurnRadius);\r
 524                         \r
 525                         // reducer is adjuste by pipelines' radiis\r
 526                         PipingTools.setSame(pipeline.getPipeRadius(), reducer.getBottomRadius());\r
 527                         PipingTools.setSame(newPipeline.getPipeRadius(), reducer.getTopRadius());\r
 528                         \r
 529                         //newPipeline.getHasControlPointSet().add(pcp);\r
 530                         sccp.setHasOffsetPoint(offsetControlPoint);\r
 531                         offsetControlPoint.setOffsetPointOf(sccp);\r
 532                         \r
 533                         reducer.setHasControlPoint(sccp);\r
 534                         graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 535                         \r
 536                         sccp.setNextComponentOffsetValue(reducerLength*0.5);\r
 537                         sccp.setPreviousComponentOffsetValue(reducerLength*0.5);\r
 538                         \r
 539                         // offsets are calculated from reducers length\r
 540                         PipingTools.setHalf(reducer.getLength(), sccp.getNextComponentOffset());\r
 541                         PipingTools.setHalf(reducer.getLength(), sccp.getPreviousComponentOffset());\r
 542                         \r
 543                         // linking sccp and ocp offsets\r
 544                         offsetControlPoint.setNextComponentOffset(sccp.getNextComponentOffset());\r
 545                         offsetControlPoint.setPreviousComponentOffset(sccp.getPreviousComponentOffset());\r
 546                         \r
 547                         \r
 548                         offsetControlPoint.setPreviousPoint(sccp.getPreviousPoint());\r
 549                         offsetControlPoint.setNextPoint(sccp.getNextPoint());\r
 550                         if (i == 1) {\r
 551                                 // FIXME : link offset value\r
 552                                 sccp.setOffsetValue(reducer.getBottomRadiusValue() - reducer.getTopRadiusValue());              \r
 553                                 sccp.setAngle(((EccentricReducer)reducer).getAngle());\r
 554                                 Vector3d v = PipingTools.getSizeChangeOffsetVector(sccp);\r
 555                                 Point3d local = GraphicsNodeTools.getTranslation(sccp.getLocalPosition());\r
 556                                 local.add(v);\r
 557                                 //Point3d World = GraphicsNodeTools.getTranslation(sccp.getLocalPosition());\r
 558                                 GraphicsNodeTools.setTranslation(offsetControlPoint.getLocalPosition(), local);\r
 559                         } else {\r
 560                                 // FIXME : is it possible that pipelines are in different coordinate systems \r
 561                                 offsetControlPoint.setLocalPosition(sccp.getLocalPosition());\r
 562                                 offsetControlPoint.setWorldPosition(sccp.getWorldPosition());\r
 563                         }\r
 564                         ((TestProcessEditor)parent).getPlant().getHasSubnodesSet().add(newPipeline);\r
 565                         pipeline.getHasSubnodesSet().add(reducer);\r
 566                         newPipeline.getHasControlPointSet().add(offsetControlPoint);\r
 567                         graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
 568                         \r
 569                         graph.commitTransaction(CommitMessage.TRANSACTION_MESSAGE);\r
 570                         \r
 571                         */\r
 572                 \r
 573                 \r
 574                  \r
 575         }\r
 576         \r
 577         /**\r
 578          * Returns direction of a nozzle\r
 579          * @param nozzle\r
 580          * @return\r
 581          */\r
 582         public static Vector3d getNozzleDirection(IEntity nozzle) {\r
 583                 return ControlPointTools.getNozzleDirection(nozzle.getSingleRelatedObject(ProcessResource.g3dResource.HasWorldOrientation));\r
 584         }\r
 585         \r
 586         /**\r
 587          * Returns true if a nozzle is not connected to a pipe\r
 588          * @param nozzle\r
 589          * @return\r
 590          */\r
 591         public static boolean isFreeNozzle(IEntity nozzle) {\r
 592                 assert (nozzle.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
 593                 IEntity pcp = nozzle.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
 594                 IEntity next = pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasNext);\r
 595                 IEntity previous = pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasPrevious);\r
 596                 if (next == null && previous == null) {\r
 597                         assert (pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.ControlPointOfPipeRun) == null);\r
 598                         return true;\r
 599                 }\r
 600                 assert (pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.ControlPointOfPipeRun) != null);\r
 601                 return false;\r
 602         }\r
 603         \r
 604         public static void getInlineComponentEnds(IEntity inlineComponent, Point3d p1, Point3d p2) {\r
 605                 assert(inlineComponent.isInstanceOf(ProcessResource.plant3Dresource.InlineComponent));\r
 606                 ControlPointTools.getInlineControlPointEnds(inlineComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint), p1, p2);\r
 607         }\r
 608         \r
 609         public static void getInlineComponentEnds(IEntity inlineComponent, Point3d p1, Point3d p2, Vector3d dir) {\r
 610                 assert(inlineComponent.isInstanceOf(ProcessResource.plant3Dresource.InlineComponent));\r
 611                 ControlPointTools.getInlineControlPointEnds(inlineComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint), p1, p2,dir);\r
 612         }\r
 613         \r
 614         public static void getInlineComponentEnds(IEntity inlineComponent, Point3d center, Point3d p1, Point3d p2, Vector3d dir) {\r
 615                 assert(inlineComponent.isInstanceOf(ProcessResource.plant3Dresource.InlineComponent));\r
 616                 ControlPointTools.getInlineControlPointEnds(inlineComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint), center, p1, p2,dir);\r
 617         }\r
 618         \r
 619         public static void removePipeRun(PipeRun pipeRun) {\r
 620         if (DEBUG) System.out.println("PipingTools.removePipeRun() " + pipeRun.getResource());\r
 621         G3DNode parent = pipeRun.getParent();\r
 622         if (parent != null)\r
 623                 parent.getChild().remove(pipeRun);\r
 624 \r
 625     }\r
 626         /**\r
 627          * Liks piperun's specs to nozzle's specs\r
 628          * @param nozzle\r
 629          * @param piperun\r
 630          */\r
 631         public static void linkNozzleAndPipeRun(IEntity nozzle, IEntity piperun) {\r
 632                 assert(nozzle.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
 633                 assert(piperun.isInstanceOf(ProcessResource.plant3Dresource.PipeRun));\r
 634                 IEntity diam = piperun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter); \r
 635         \r
 636         piperun.addStatement(ProcessResource.plant3Dresource.HasControlPoints, nozzle.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint));\r
 637         setStatement(nozzle, ProcessResource.plant3Dresource.HasPipeDiameter, diam);\r
 638         }\r
 639         \r
 640         /**\r
 641          * Unlinks piperun's specs from nozzle's specs.\r
 642          * @param nozzle\r
 643          * @param piperun\r
 644          */\r
 645         public static void unlinkNozzleAndPiperun(IEntity nozzle, IEntity piperun) {\r
 646                 assert(nozzle.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
 647                 assert(piperun.isInstanceOf(ProcessResource.plant3Dresource.PipeRun));\r
 648                 \r
 649                 piperun.removeStatement(ProcessResource.plant3Dresource.HasControlPoints, nozzle.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint));      \r
 650                 // get current diameter\r
 651                 double diam = nozzle.getSingleRelatedScalarDouble(ProcessResource.plant3Dresource.HasPipeDiameter);\r
 652                 // remove link to shared diameter resource\r
 653                 nozzle.removeRelatedStatements(ProcessResource.plant3Dresource.HasPipeDiameter);\r
 654                 // create new reource for diameter\r
 655                 nozzle.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasPipeDiameter, diam);\r
 656         }\r
 657         \r
 658         private static void setStatement(IEntity subject, Resource relation, IEntity object) {\r
 659         subject.removeRelatedStatements(relation);\r
 660         subject.addStatement(relation, object);\r
 661     }\r
 662         \r
 663         public static void getInlineMovement(InlineComponent ic, Point3d start, Point3d end) {\r
 664                 PipeControlPoint pcp = ic.getControlPoint();\r
 665                 ControlPointTools.getInlineMovement(pcp, start, end);\r
 666         }\r
 667 \r
 668 }\r