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

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