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