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