+++ /dev/null
-/*******************************************************************************\r
- * Copyright (c) 2007- VTT Technical Research Centre of Finland.\r
- * All rights reserved. This program and the accompanying materials\r
- * are made available under the terms of the Eclipse Public License v1.0\r
- * which accompanies this distribution, and is available at\r
- * http://www.eclipse.org/legal/epl-v10.html\r
- *\r
- * Contributors:\r
- * VTT Technical Research Centre of Finland - initial API and implementation\r
- *******************************************************************************/\r
-package org.simantics.processeditor.common;\r
-\r
-import java.util.Collection;\r
-\r
-import javax.vecmath.Point3d;\r
-import javax.vecmath.Vector3d;\r
-\r
-import org.simantics.db.Graph;\r
-import org.simantics.db.Resource;\r
-import org.simantics.layer0.utils.EntityFactory;\r
-import org.simantics.layer0.utils.IEntity;\r
-import org.simantics.layer0.utils.Statement;\r
-import org.simantics.layer0.utils.instantiation.Instance;\r
-import org.simantics.layer0.utils.instantiation.InstanceFactory;\r
-import org.simantics.processeditor.ProcessResource;\r
-import org.simantics.processeditor.actions.PositionType;\r
-import org.simantics.processeditor.stubs.Equipment;\r
-import org.simantics.processeditor.stubs.InlineComponent;\r
-import org.simantics.processeditor.stubs.Nozzle;\r
-import org.simantics.processeditor.stubs.PipeControlPoint;\r
-import org.simantics.processeditor.stubs.PipeRun;\r
-import org.simantics.processeditor.stubs.PipelineComponent;\r
-import org.simantics.proconf.g3d.base.G3DTools;\r
-import org.simantics.proconf.g3d.stubs.G3DNode;\r
-\r
-\r
-public class PipingTools2 {\r
- private static final boolean DEBUG = false;\r
- public enum Direction{NEXT,PREVIOUS};\r
- \r
-\r
- \r
- /**\r
- * Reverses a piperun by swapping all previous/next connections\r
- * @param pipeRun\r
- */\r
- public static void reversePipeRun(IEntity pipeRun) {\r
-// //FIXME : reducers / size-change / offset-control points\r
-// RelationTypeSet<PipeControlPoint> cps = pipeRun.getHasControlPointSet();\r
-// if (cps.size() == 0)\r
-// return;\r
-// List<PipeControlPoint> list = new ArrayList<PipeControlPoint>();\r
-// PipeControlPoint pcp = cps.iterator().next();\r
-// list.add(pcp);\r
-// PipeControlPoint temp = pcp.getPrevious();\r
-// while (temp != null) {\r
-// list.add(0,temp);\r
-// temp = temp.getPrevious();\r
-// }\r
-// temp = pcp.getNext();\r
-// while (temp != null) {\r
-// list.add(temp);\r
-// temp = temp.getNext();\r
-// }\r
-// // now list contains control points in sorted order.\r
-// // switch order\r
-// for (int i = 0; i < list.size() - 1; i++) {\r
-// PipeControlPoint pcp1 = list.get(i);\r
-// PipeControlPoint pcp2 = list.get(i+1);\r
-// pcp1.setPrevious(pcp2);\r
-// pcp2.setNext(pcp1);\r
-//\r
-// }\r
-// // fix ends\r
-// list.get(0).setNext(null);\r
-// list.get(list.size() - 1).setPrevious(null);\r
-\r
- }\r
-\r
- public static IEntity getPipeRun(IEntity component) {\r
- assert(component.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
- return component.getSingleRelatedObject(ProcessResource.g3dResource.HasParent);\r
- }\r
- \r
- /**\r
- * Returns Nozzle of a directed control point\r
- * @param dcp\r
- * @return\r
- */\r
- public static Nozzle getNozzle(PipeControlPoint dcp) {\r
- assert (dcp.isInstanceOf(ProcessResource.plant3Dresource.DirectedControlPoint));\r
- IEntity e = dcp.getControlPointOf();\r
- if (e == null)\r
- return null;\r
- assert (e.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
- return new Nozzle(e);\r
- }\r
- \r
- /**\r
- * Instantiates new pipeline component and all necessary control points for it.\r
- * @param graph\r
- * @param typeResource\r
- * @return\r
- */\r
- public static PipelineComponent instantiatePipelineComponent(Graph graph, Resource pipeRunResource, Resource typeResource) {\r
- IEntity pipeRun = EntityFactory.create(graph,pipeRunResource);\r
- Instance ins = InstanceFactory.getInstanceOfType(graph, typeResource);\r
- Resource instance = ins.instantiate(graph);\r
- PipelineComponent component = new PipelineComponent(graph,instance);\r
- G3DTools.resetTransformation(component);\r
- // copy control point\r
- Collection<Resource> pcps = graph.getObjects(typeResource, ProcessResource.plant3Dresource.HasControlPoint);\r
- assert(pcps.size() == 1);\r
- Collection<Resource> types = graph.getObjects(pcps.iterator().next(), ProcessResource.builtins.InstanceOf);\r
- PipeControlPoint componentPCP = new PipeControlPoint(graph,InstanceFactory.instantiate(graph, types));\r
- component.addStatement(ProcessResource.plant3Dresource.HasControlPoint, componentPCP);\r
- pipeRun.addStatement(ProcessResource.g3dResource.HasChild, component);\r
- pipeRun.addStatement(ProcessResource.plant3Dresource.HasControlPoints, componentPCP);\r
- component.setPipeDiameter(pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
- if (component.isInstanceOf(ProcessResource.plant3Dresource.VariableAngleTurnComponent)) {\r
- setStatement(component, ProcessResource.plant3Dresource.HasTurnRadius, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnRadius));\r
- setStatement(componentPCP, ProcessResource.plant3Dresource.HasTurnRadius, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnRadius));\r
- setStatement(component, ProcessResource.plant3Dresource.HasTurnAngle, componentPCP.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnAngle));\r
- setStatement(component, ProcessResource.plant3Dresource.HasTurnAxis, componentPCP.getSingleRelatedObject(ProcessResource.plant3Dresource.HasTurnAxis)); \r
- }\r
- if (component.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasLength) != null) {\r
- setStatement(componentPCP, ProcessResource.plant3Dresource.HasLength, component.getSingleRelatedObject(ProcessResource.plant3Dresource.HasLength));\r
- }\r
- componentPCP.setLocalOrientation(component.getLocalOrientation());\r
- componentPCP.setWorldOrientation(component.getWorldOrientation());\r
- \r
- componentPCP.setLocalPosition(component.getLocalPosition());\r
- componentPCP.setWorldPosition(component.getWorldPosition());\r
- \r
- setStatement(componentPCP, ProcessResource.plant3Dresource.HasPipeDiameter, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
- setStatement(component, ProcessResource.plant3Dresource.HasPipeDiameter, pipeRun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
- \r
- // TODO : instantiate subpoints\r
- \r
- \r
- return component;\r
- }\r
- \r
- public static Nozzle instantiateNozzle(Graph graph, Resource typeResource) {\r
- Instance ins = InstanceFactory.getInstanceOfType(graph, typeResource);\r
- Resource instance = ins.instantiate(graph);\r
- Nozzle n = new Nozzle(graph,instance);\r
- G3DTools.resetTransformation(n);\r
- \r
- // copy control point\r
- Collection<Resource> pcps = graph.getObjects(typeResource, ProcessResource.plant3Dresource.HasControlPoint);\r
- assert(pcps.size() == 1);\r
- Collection<Resource> types = graph.getObjects(pcps.iterator().next(), ProcessResource.builtins.InstanceOf);\r
- PipeControlPoint nozzlePCP = new PipeControlPoint(graph,InstanceFactory.instantiate(graph, types));\r
- n.addStatement(ProcessResource.plant3Dresource.HasControlPoint, nozzlePCP);\r
- nozzlePCP.setLocalOrientation(n.getLocalOrientation());\r
- nozzlePCP.setWorldOrientation(n.getWorldOrientation());\r
- nozzlePCP.setLocalPosition(n.getLocalPosition());\r
- nozzlePCP.setWorldPosition(n.getWorldPosition());\r
- setStatement(nozzlePCP, ProcessResource.plant3Dresource.HasPipeDiameter, n.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter));\r
- nozzlePCP.setPipeDiameter(0.2);\r
- return n;\r
- }\r
- \r
- public static Equipment instantiateEquipment(Graph graph, Resource typeResource) {\r
- Instance ins = InstanceFactory.getInstanceOfType(graph, typeResource);\r
- Resource instance = ins.instantiate(graph);\r
- Equipment equipment = new Equipment(graph, instance);\r
- G3DTools.resetTransformation(equipment);\r
- \r
- IEntity type = EntityFactory.create(graph, typeResource);\r
- IEntity geometricModel = type.getSingleRelatedObject(ProcessResource.plant3Dresource.HasGraphics);\r
- \r
- Collection<IEntity> sizingProperties = geometricModel.getRelatedObjects(ProcessResource.g3dResource.HasSizingParameter);\r
- Collection<Statement> equipmentProperties = equipment.getRelatedStatements(ProcessResource.builtins.HasProperty);\r
- \r
- for (IEntity e : sizingProperties) {\r
- String name = e.getName();\r
- String pName = "Has " + name;\r
- boolean found = false;\r
- for (Statement s : equipmentProperties) {\r
- IEntity predicate = s.getPredicate();\r
- String predicateName = predicate.getName();\r
- if (predicateName.equals(pName)) {\r
- found = true;\r
- break;\r
- }\r
- }\r
- if(!found) {\r
- IEntity rel = getOrCreateRel(graph,name);\r
- equipment.setRelatedScalarDouble(rel, 1.0);\r
- }\r
- }\r
- \r
- // TODO : create nozzles if needed\r
- \r
- return equipment;\r
- }\r
- \r
- private static IEntity getOrCreateRel(Graph graph, String name) {\r
- IEntity rel = null;\r
- try {\r
- Resource relr = graph.getResourceByURI("http://www.vtt.fi/Simantics/Plant3D/1.0/Relations#Has" + name);\r
- rel = EntityFactory.create(graph,relr);\r
- } catch (Exception e) {\r
- Resource relLib = null;\r
- try {\r
- relLib = graph.getResourceByURI("http://www.vtt.fi/Simantics/Plant3D/1.0#Relations");\r
- } catch (Exception e2) {\r
- \r
- }\r
- Resource relr = graph.newResource();\r
- rel = EntityFactory.create(graph, relr);\r
- rel.addStatement(ProcessResource.builtins.SubrelationOf, ProcessResource.g3dResource.HasNonTransformation);\r
- rel.setName("Has " + name);\r
- Resource irelr = graph.newResource();\r
- graph.addStatement(relr,ProcessResource.builtins.InverseOf,irelr);\r
- graph.addStatement(relLib, ProcessResource.builtins.ConsistsOf, relr);\r
- }\r
- return rel;\r
- }\r
- \r
- public static IEntity getLibraryComponentType(IEntity component) {\r
- assert(component.isInstanceOf(ProcessResource.plant3Dresource.LibraryComponent));\r
- // IEntity.getTypes() returns all types, but we want the closest type.\r
- Collection<IEntity> types = component.getRelatedObjects(ProcessResource.builtins.InstanceOf);//component.getTypes();\r
- IEntity type = null;\r
- for (IEntity t : types) {\r
- if (t.isInheritedFrom(ProcessResource.plant3Dresource.LibraryComponent)) {\r
- if (type == null)\r
- type = t;\r
- else\r
- throw new RuntimeException("Cannot find proper type for library component " + component.getResource() );\r
- }\r
- }\r
- return type;\r
- }\r
- \r
- /**\r
- * Splits existing VariableLengthComponent with another component.\r
- * Result is two VariableLengthComponents and inserted component between them.\r
- * \r
- * Note : world position of newComponent must be set before this method may be called.\r
- * \r
- * @param newComponent\r
- * @param splittingComponent\r
- */\r
- public static void splitVariableLengthComponent(IEntity newComponent, IEntity splittingComponent) {\r
- assert(splittingComponent.isInstanceOf(ProcessResource.plant3Dresource.VariableLengthInlineComponent));\r
- assert(newComponent.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
- assert(!newComponent.isInstanceOf(ProcessResource.plant3Dresource.VariableLengthInlineComponent));\r
- IEntity newCP = newComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
- IEntity splittingCP = splittingComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
- IEntity nextCP = splittingCP.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasNext);\r
- IEntity prevCP = splittingCP.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasPrevious);\r
- \r
- /* there are many different cases to insert new component when\r
- it splits existing VariableLengthinlineComponent.\r
- \r
- 1. VariableLengthComponet is connected from both sides:\r
- - insert new component between VariableLength component and component connected to it\r
- - insert new VariableLengthComponent between inserted component and component selected in previous step\r
- \r
- 2. VariableLengthComponent is connected from one side\r
- - Use previous case or:\r
- - Insert new component to empty end\r
- - Insert new VariableLength component to inserted components empty end\r
- \r
- 3. VariableLength is not connected to any component.\r
- - Should not be possible, at least in current implementation.\r
- - Could be done using second case\r
-\r
- */\r
- \r
- if (nextCP == null && prevCP == null) {\r
- // this should not be possible\r
- throw new RuntimeException("VariableLengthComponent " + splittingComponent.getResource() + " is not connected to anything.");\r
- }\r
- \r
- Point3d next = ControlPointTools.getRealPosition(splittingCP, PositionType.NEXT);\r
- Point3d prev = ControlPointTools.getRealPosition(splittingCP, PositionType.PREVIOUS);\r
- Point3d comp = G3DTools.getPoint(newComponent.getSingleRelatedObject(ProcessResource.g3dResource.HasWorldPosition));\r
- double length = newComponent.getSingleRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength);\r
- Vector3d dir = new Vector3d(next);\r
- dir.sub(prev);\r
- dir.normalize();\r
- dir.scale(length * 0.5);\r
- Point3d vn = new Point3d(comp);\r
- Point3d vp = new Point3d(comp);\r
- vn.add(dir);\r
- vp.sub(dir);\r
- double ln = vn.distance(next);\r
- double lp = vp.distance(prev);\r
- vp.interpolate(prev, 0.5);\r
- vn.interpolate(next, 0.5);\r
- \r
- IEntity type = getLibraryComponentType(splittingComponent);\r
- \r
- IEntity newVariableLengthComponent = instantiatePipelineComponent(splittingComponent.getGraph(), getPipeRun(splittingComponent).getResource(), type.getResource());\r
- IEntity newVariableLengthCP = newVariableLengthComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
- if (nextCP == null) {\r
- ControlPointTools.insertControlPoint(newCP, splittingCP,Direction.NEXT);\r
- ControlPointTools.insertControlPoint(newVariableLengthCP, newCP,Direction.NEXT);\r
- ControlPointTools.setWorldPosition(splittingCP, vp);\r
- splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);\r
- ControlPointTools.setWorldPosition(newVariableLengthCP, vn); \r
- newVariableLengthComponent.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln);\r
- } else if (prevCP == null) {\r
- ControlPointTools.insertControlPoint(newCP, splittingCP,Direction.PREVIOUS);\r
- ControlPointTools.insertControlPoint(newVariableLengthCP, newCP,Direction.PREVIOUS);\r
- ControlPointTools.setWorldPosition(splittingCP, vn);\r
- splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln);\r
- ControlPointTools.setWorldPosition(newVariableLengthCP, vp);\r
- newVariableLengthComponent.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);\r
- } else {\r
- ControlPointTools.insertControlPoint(newCP,splittingCP,nextCP);\r
- ControlPointTools.insertControlPoint(newVariableLengthCP, newCP,nextCP);\r
- ControlPointTools.setWorldPosition(splittingCP, vp);\r
- splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp);\r
- ControlPointTools.setWorldPosition(newVariableLengthCP, vn);\r
- newVariableLengthComponent.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln);\r
- }\r
-\r
- }\r
- \r
- /**\r
- * Attaches newComponent into connectedComponent's connectedControlPoint\r
- * @param newComponent\r
- * @param connectedComponent\r
- * @param connectedControlPoint\r
- */\r
- public static void insertComponent(IEntity newComponent, IEntity connectedComponent, IEntity connectedControlPoint, Direction direction) {\r
- assert (newComponent.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
- assert (connectedComponent.isInstanceOf(ProcessResource.plant3Dresource.PipelineComponent));\r
- // TODO : piperun check is more complicated, since newComponent and connectedComponent may be SizeChangeComponents \r
- //assert (getPipeRun(connectedComponent).equals(getPipeRun(newComponent)));\r
- \r
- // new control point and its subpoint\r
- IEntity newControlPoint = newComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
- ControlPointTools.insertControlPoint(newControlPoint, connectedControlPoint, direction);\r
-// IEntity newSubPoint = null;\r
-// if (newControlPoint.isInstanceOf(ProcessResource.plant3Dresource.DualInlineControlPoint))\r
-// newSubPoint = newControlPoint.getSingleRelatedObject(ProcessResource.plant3Dresource.HasSubPoint);\r
-// \r
-// // connected components parent or subpoint \r
-// IEntity connectedSubPoint = null;\r
-// IEntity connectedParentPoint = null;\r
-// if (connectedControlPoint.isInstanceOf(ProcessResource.plant3Dresource.DualInlineControlPoint))\r
-// connectedSubPoint = connectedControlPoint.getSingleRelatedObject(ProcessResource.plant3Dresource.HasSubPoint);\r
-// else if (connectedControlPoint.isInstanceOf(ProcessResource.plant3Dresource.DualSubControlPoint))\r
-// connectedParentPoint = connectedControlPoint.getSingleRelatedObject(ProcessResource.plant3Dresource.SubPointOf);\r
-// \r
-// if (direction == Direction.NEXT) {\r
-// assert (connectedSubPoint == null); // if direction is next, connection done to subpoint\r
-// setStatement(connectedControlPoint, ProcessResource.plant3Dresource.HasNext, newControlPoint);\r
-// if (connectedParentPoint != null)\r
-// setStatement(connectedParentPoint, ProcessResource.plant3Dresource.HasNext, newControlPoint);\r
-// setStatement(newControlPoint, ProcessResource.plant3Dresource.HasPrevious, connectedControlPoint);\r
-// if (newSubPoint != null)\r
-// setStatement(newSubPoint, ProcessResource.plant3Dresource.HasPrevious, connectedControlPoint);\r
-// \r
-// } else {\r
-// assert (connectedParentPoint == null); // if direction is prev, connection done to parentpoint\r
-// if (newSubPoint != null) {\r
-// \r
-// }\r
-// }\r
- \r
- /*\r
- private void insertEndComponent() {\r
- activated = false;\r
- Graph coreTC = parent.getGraph();\r
- \r
- if (replace == null)\r
- checkForEndInsertion();\r
- if (replace == null) {\r
- ErrorLogger.defaultLogError("Cannot insert end component",null);\r
- end();\r
- return;\r
- }\r
- G3DNode p = straight.getHasParent();\r
- if (p == null) {\r
- ErrorLogger.defaultLogError("Straight pipe has no parent", new Exception("ASSERT!"));\r
-\r
- } else {\r
- Pipeline pipeline = PipelineFactory.create(p);\r
- coreTC.startTransaction(this);\r
- try {\r
- Vector3d startPoint = GraphicsNodeTools.getVector(replace.getLocalPosition());\r
- EndComponentControlPoint ecp = EndComponentControlPointFactory.instantiate(coreTC);\r
- coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- pipeline.getHasControlPointSet().remove(replace);\r
- // create dummy node\r
- //PipeControlPoint pcp = PipeControlPointFactory.instantiate(coreTC);\r
- replace.setNextPoint(null);\r
- replace.setPreviousPoint(null);\r
- pipeline.getHasControlPointSet().add(ecp);\r
- if (next) {\r
- straight.getHasControlPoint().getPreviousPoint().setNextPoint(ecp);\r
- straight.getHasControlPoint().setNextPoint(ecp);\r
- ecp.setPreviousPoint(straight.getHasControlPoint().getPreviousPoint());\r
- //ecp.setNextPoint(null);\r
- } else {\r
- straight.getHasControlPoint().getNextPoint().setPreviousPoint(ecp);\r
- straight.getHasControlPoint().setPreviousPoint(ecp);\r
- ecp.setNextPoint(straight.getHasControlPoint().getNextPoint());\r
- //ecp.setPreviousPoint(null);\r
- }\r
- G3DTools.setTranslation(ecp.getLocalPosition(), startPoint);\r
- // FIXME : component should specify how much space it needs\r
- createAndLink(coreTC, pipeline, ecp);\r
- coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- coreTC.commitTransaction(CommitMessage.TRANSACTION_MESSAGE);\r
- } catch (TransactionException e) {\r
- ErrorLogger.defaultLogError("Cannot insert component", e);\r
- coreTC.cancelTransaction();\r
- }\r
- }\r
- \r
- end();\r
- }\r
- \r
- private void insertComponent(Point3d startPoint) {\r
- activated = false;\r
- Graph coreTC = parent.getGraph();\r
- G3DNode p = straight.getHasParent();\r
- if (p == null) {\r
- ErrorLogger.defaultLogError("Straight pipe has no parent", new Exception("ASSERT!"));\r
-\r
- } else {\r
- Pipeline pipeline = PipelineFactory.create(p);\r
- coreTC.startTransaction(this);\r
- try {\r
- InlineComponentControlPoint icp = InlineComponentControlPointFactory.instantiate(coreTC);\r
- coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- PipeControlPoint scp = straight.getHasControlPoint();\r
- // it shouldn't matter whitch control point to use, next or previous.\r
- PipingTools.insertControlPoint(pipeline, icp, scp, scp.getNextPoint());\r
- //PipingTools.insertControlPoint(straight, icp);\r
- pipeline.getHasControlPointSet().add(icp);\r
- G3DTools.setTranslation(icp.getLocalPosition(), startPoint);\r
- // FIXME : component should specify how much space it needs\r
- icp.setNextComponentOffsetValue(pipeline.getPipeRadiusValue());\r
- icp.setPreviousComponentOffsetValue(pipeline.getPipeRadiusValue());\r
- PipingTools.setSame(pipeline.getPipeRadius(), icp.getNextComponentOffset());\r
- PipingTools.setSame(pipeline.getPipeRadius(), icp.getPreviousComponentOffset());\r
- createAndLink(coreTC, pipeline, icp);\r
- coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- coreTC.commitTransaction(CommitMessage.TRANSACTION_MESSAGE);\r
- } catch (TransactionException e) {\r
- ErrorLogger.defaultLogError("Cannot insert component", e);\r
- coreTC.cancelTransaction();\r
- }\r
- }\r
-\r
- line.removeFromParent();\r
- \r
- end();\r
- \r
- }\r
- \r
- \r
- private void createAndLink(Graph coreTC, Pipeline pipeline, PipeControlPoint icp) throws TransactionException {\r
- PipelineComponent component = PipelineComponentFactory.create(OntologyUtils.instantiate(typeResource));\r
- coreTC.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- component.setHasControlPoint(icp);\r
- component.setLocalPosition(icp.getLocalPosition());\r
- pipeline.getHasSubnodesSet().add(component);\r
- component.setPipeRadius(pipeline.getPipeRadius());\r
- component.setHasGraphics(GraphicsModelFactory.create(modelResource));\r
- \r
- }\r
- */\r
- \r
- /*\r
- old insert reducer code\r
- \r
- Pipeline pipeline = PipingTools.getPipeline(straight);\r
- // pcp is Turn Control Point and we'll have to change it's type to Size Change Control Point\r
- // First we'll remove its unnecessary properties and elbow connected to it,\r
- RelationTypeSet<Entity> pipeComponents = pcp.getControlPointOfSet();\r
- Resource elbowResource = null;\r
- for (Entity e : pipeComponents) {\r
- if (e.getResource().isInstanceOf(GlobalIdMap.get(PSK3DModelingOntologyMapping.ELBOW))) {\r
- elbowResource = e.getResource();\r
- }\r
- }\r
- if (elbowResource != null) {\r
- pipeComponents.remove(elbowResource);\r
- pipeline.getHasSubnodesSet().remove(elbowResource);\r
- }\r
- RelationSet rs = pcp.getResource().getRelatedResourcesWithRelationIds(GlobalIdMap.get(PSK3DModelingOntologyMapping.HAS_TURN_ANGLE));\r
- RelationReference rr = rs.getRelations()[0];\r
- pcp.getResource().removeRelationById(rr.getObjectId(),rr.getRelationId());\r
- rs = pcp.getResource().getRelatedResourcesWithRelationIds(GlobalIdMap.get(PSK3DModelingOntologyMapping.HAS_COMPONENT_OFFSET));\r
- rr = rs.getRelations()[0];\r
- pcp.getResource().removeRelationById(rr.getObjectId(),rr.getRelationId());\r
- rs = pcp.getResource().getRelatedResourcesWithRelationIds(GlobalIdMap.get(Builtins.InstanceOf));\r
- rr = rs.getRelations()[0];\r
- //pcp.getResource().removeRelationById(type[0], GlobalIdMap.get(Builtins.InstanceOf));\r
- pcp.getResource().removeRelationById(rr.getObjectId(),rr.getRelationId());\r
- Resource sccpType = graph.getResource(PSK3DModelingOntologyMapping.SIZE_CHANGE_CONTROL_POINT);\r
- pcp.createRelation(sccpType, graph.getResource(Builtins.InstanceOf));\r
- \r
- graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- \r
- Reducer reducer = null;\r
- Pipeline newPipeline = PipelineFactory.instantiate(graph);\r
- OffsetControlPoint offsetControlPoint = OffsetControlPointFactory.instantiate(graph);\r
- if (i == 0) {\r
- reducer = ConcentricReducerFactory.instantiate(graph);\r
- } else {\r
- reducer = EccentricReducerFactory.instantiate(graph);\r
- } \r
- graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- SizeChangeControlPoint sccp = SizeChangeControlPointFactory.create(pcp.getResource());\r
- \r
- \r
- // FIXME : lenght, pipe radius and turn angle from specs + let the user choose spec for new pipeline\r
- double reducerLength = 0.3;\r
- reducer.setLengthValue(reducerLength);\r
- double newPipeRadius = pipelineDialog.getPipeRadius();\r
- double newPipeTurnRadius = pipelineDialog.getTurnRadius();\r
-\r
- reducer.setLocalPosition(sccp.getLocalPosition());\r
- reducer.setWorldPosition(sccp.getWorldPosition());\r
- \r
- reducer.setBottomRadiusValue(pipeline.getPipeRadiusValue());\r
- \r
- reducer.setPipeRadius(pipeline.getPipeRadius());\r
- reducer.setTopRadiusValue(newPipeRadius);\r
- newPipeline.setPipeRadiusValue(newPipeRadius);\r
- newPipeline.setTurnRadiusValue(newPipeTurnRadius);\r
- \r
- // reducer is adjuste by pipelines' radiis\r
- PipingTools.setSame(pipeline.getPipeRadius(), reducer.getBottomRadius());\r
- PipingTools.setSame(newPipeline.getPipeRadius(), reducer.getTopRadius());\r
- \r
- //newPipeline.getHasControlPointSet().add(pcp);\r
- sccp.setHasOffsetPoint(offsetControlPoint);\r
- offsetControlPoint.setOffsetPointOf(sccp);\r
- \r
- reducer.setHasControlPoint(sccp);\r
- graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- \r
- sccp.setNextComponentOffsetValue(reducerLength*0.5);\r
- sccp.setPreviousComponentOffsetValue(reducerLength*0.5);\r
- \r
- // offsets are calculated from reducers length\r
- PipingTools.setHalf(reducer.getLength(), sccp.getNextComponentOffset());\r
- PipingTools.setHalf(reducer.getLength(), sccp.getPreviousComponentOffset());\r
- \r
- // linking sccp and ocp offsets\r
- offsetControlPoint.setNextComponentOffset(sccp.getNextComponentOffset());\r
- offsetControlPoint.setPreviousComponentOffset(sccp.getPreviousComponentOffset());\r
- \r
- \r
- offsetControlPoint.setPreviousPoint(sccp.getPreviousPoint());\r
- offsetControlPoint.setNextPoint(sccp.getNextPoint());\r
- if (i == 1) {\r
- // FIXME : link offset value\r
- sccp.setOffsetValue(reducer.getBottomRadiusValue() - reducer.getTopRadiusValue()); \r
- sccp.setAngle(((EccentricReducer)reducer).getAngle());\r
- Vector3d v = PipingTools.getSizeChangeOffsetVector(sccp);\r
- Point3d local = GraphicsNodeTools.getTranslation(sccp.getLocalPosition());\r
- local.add(v);\r
- //Point3d World = GraphicsNodeTools.getTranslation(sccp.getLocalPosition());\r
- GraphicsNodeTools.setTranslation(offsetControlPoint.getLocalPosition(), local);\r
- } else {\r
- // FIXME : is it possible that pipelines are in different coordinate systems \r
- offsetControlPoint.setLocalPosition(sccp.getLocalPosition());\r
- offsetControlPoint.setWorldPosition(sccp.getWorldPosition());\r
- }\r
- ((TestProcessEditor)parent).getPlant().getHasSubnodesSet().add(newPipeline);\r
- pipeline.getHasSubnodesSet().add(reducer);\r
- newPipeline.getHasControlPointSet().add(offsetControlPoint);\r
- graph.commitChanges(CommitMessage.CHANGE_MESSAGE);\r
- \r
- graph.commitTransaction(CommitMessage.TRANSACTION_MESSAGE);\r
- \r
- */\r
- \r
- \r
- \r
- }\r
- \r
- /**\r
- * Returns direction of a nozzle\r
- * @param nozzle\r
- * @return\r
- */\r
- public static Vector3d getNozzleDirection(IEntity nozzle) {\r
- return ControlPointTools.getNozzleDirection(nozzle.getSingleRelatedObject(ProcessResource.g3dResource.HasWorldOrientation));\r
- }\r
- \r
- /**\r
- * Returns true if a nozzle is not connected to a pipe\r
- * @param nozzle\r
- * @return\r
- */\r
- public static boolean isFreeNozzle(IEntity nozzle) {\r
- assert (nozzle.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
- IEntity pcp = nozzle.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint);\r
- IEntity next = pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasNext);\r
- IEntity previous = pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasPrevious);\r
- if (next == null && previous == null) {\r
- assert (pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.ControlPointOfPipeRun) == null);\r
- return true;\r
- }\r
- assert (pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.ControlPointOfPipeRun) != null);\r
- return false;\r
- }\r
- \r
- public static void getInlineComponentEnds(IEntity inlineComponent, Point3d p1, Point3d p2) {\r
- assert(inlineComponent.isInstanceOf(ProcessResource.plant3Dresource.InlineComponent));\r
- ControlPointTools.getInlineControlPointEnds(inlineComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint), p1, p2);\r
- }\r
- \r
- public static void getInlineComponentEnds(IEntity inlineComponent, Point3d p1, Point3d p2, Vector3d dir) {\r
- assert(inlineComponent.isInstanceOf(ProcessResource.plant3Dresource.InlineComponent));\r
- ControlPointTools.getInlineControlPointEnds(inlineComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint), p1, p2,dir);\r
- }\r
- \r
- public static void getInlineComponentEnds(IEntity inlineComponent, Point3d center, Point3d p1, Point3d p2, Vector3d dir) {\r
- assert(inlineComponent.isInstanceOf(ProcessResource.plant3Dresource.InlineComponent));\r
- ControlPointTools.getInlineControlPointEnds(inlineComponent.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint), center, p1, p2,dir);\r
- }\r
- \r
- public static void removePipeRun(PipeRun pipeRun) {\r
- if (DEBUG) System.out.println("PipingTools.removePipeRun() " + pipeRun.getResource());\r
- G3DNode parent = pipeRun.getParent();\r
- if (parent != null)\r
- parent.getChild().remove(pipeRun);\r
-\r
- }\r
- /**\r
- * Liks piperun's specs to nozzle's specs\r
- * @param nozzle\r
- * @param piperun\r
- */\r
- public static void linkNozzleAndPipeRun(IEntity nozzle, IEntity piperun) {\r
- assert(nozzle.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
- assert(piperun.isInstanceOf(ProcessResource.plant3Dresource.PipeRun));\r
- IEntity diam = piperun.getSingleRelatedObject(ProcessResource.plant3Dresource.HasPipeDiameter); \r
- \r
- piperun.addStatement(ProcessResource.plant3Dresource.HasControlPoints, nozzle.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint));\r
- setStatement(nozzle, ProcessResource.plant3Dresource.HasPipeDiameter, diam);\r
- }\r
- \r
- /**\r
- * Unlinks piperun's specs from nozzle's specs.\r
- * @param nozzle\r
- * @param piperun\r
- */\r
- public static void unlinkNozzleAndPiperun(IEntity nozzle, IEntity piperun) {\r
- assert(nozzle.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));\r
- assert(piperun.isInstanceOf(ProcessResource.plant3Dresource.PipeRun));\r
- \r
- piperun.removeStatement(ProcessResource.plant3Dresource.HasControlPoints, nozzle.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint)); \r
- // get current diameter\r
- double diam = nozzle.getSingleRelatedScalarDouble(ProcessResource.plant3Dresource.HasPipeDiameter);\r
- // remove link to shared diameter resource\r
- nozzle.removeRelatedStatements(ProcessResource.plant3Dresource.HasPipeDiameter);\r
- // create new reource for diameter\r
- nozzle.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasPipeDiameter, diam);\r
- }\r
- \r
- private static void setStatement(IEntity subject, Resource relation, IEntity object) {\r
- subject.removeRelatedStatements(relation);\r
- subject.addStatement(relation, object);\r
- }\r
- \r
- public static void getInlineMovement(InlineComponent ic, Point3d start, Point3d end) {\r
- PipeControlPoint pcp = ic.getControlPoint();\r
- ControlPointTools.getInlineMovement(pcp, start, end);\r
- }\r
-\r
-}\r
Code Review / simantics / 3d.git / blobdiff