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
9 * VTT Technical Research Centre of Finland - initial API and implementation
\r
10 *******************************************************************************/
\r
11 package org.simantics.processeditor.common;
\r
13 import java.util.Collection;
\r
15 import javax.vecmath.Point3d;
\r
16 import javax.vecmath.Vector3d;
\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
37 public class PipingTools2 {
\r
38 private static final boolean DEBUG = false;
\r
39 public enum Direction{NEXT,PREVIOUS};
\r
44 * Reverses a piperun by swapping all previous/next connections
\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
52 // List<PipeControlPoint> list = new ArrayList<PipeControlPoint>();
\r
53 // PipeControlPoint pcp = cps.iterator().next();
\r
55 // PipeControlPoint temp = pcp.getPrevious();
\r
56 // while (temp != null) {
\r
57 // list.add(0,temp);
\r
58 // temp = temp.getPrevious();
\r
60 // temp = pcp.getNext();
\r
61 // while (temp != null) {
\r
63 // temp = temp.getNext();
\r
65 // // now list contains control points in sorted 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
75 // list.get(0).setNext(null);
\r
76 // list.get(list.size() - 1).setPrevious(null);
\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
86 * Returns Nozzle of a directed control point
\r
90 public static Nozzle getNozzle(PipeControlPoint dcp) {
\r
91 assert (dcp.isInstanceOf(ProcessResource.plant3Dresource.DirectedControlPoint));
\r
92 IEntity e = dcp.getControlPointOf();
\r
95 assert (e.isInstanceOf(ProcessResource.plant3Dresource.Nozzle));
\r
96 return new Nozzle(e);
\r
100 * Instantiates new pipeline component and all necessary control points for it.
\r
102 * @param typeResource
\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
126 if (component.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.HasLength) != null) {
\r
127 setStatement(componentPCP, ProcessResource.plant3Dresource.HasLength, component.getSingleRelatedObject(ProcessResource.plant3Dresource.HasLength));
\r
129 componentPCP.setLocalOrientation(component.getLocalOrientation());
\r
130 componentPCP.setWorldOrientation(component.getWorldOrientation());
\r
132 componentPCP.setLocalPosition(component.getLocalPosition());
\r
133 componentPCP.setWorldPosition(component.getWorldPosition());
\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
138 // TODO : instantiate subpoints
\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
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
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
171 IEntity type = EntityFactory.create(graph, typeResource);
\r
172 IEntity geometricModel = type.getSingleRelatedObject(ProcessResource.plant3Dresource.HasGraphics);
\r
174 Collection<IEntity> sizingProperties = geometricModel.getRelatedObjects(ProcessResource.g3dResource.HasSizingParameter);
\r
175 Collection<Statement> equipmentProperties = equipment.getRelatedStatements(ProcessResource.builtins.HasProperty);
\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
190 IEntity rel = getOrCreateRel(graph,name);
\r
191 equipment.setRelatedScalarDouble(rel, 1.0);
\r
195 // TODO : create nozzles if needed
\r
200 private static IEntity getOrCreateRel(Graph graph, String name) {
\r
201 IEntity rel = null;
\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
208 relLib = graph.getResourceByURI("http://www.vtt.fi/Simantics/Plant3D/1.0#Relations");
\r
209 } catch (Exception e2) {
\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
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
233 throw new RuntimeException("Cannot find proper type for library component " + component.getResource() );
\r
240 * Splits existing VariableLengthComponent with another component.
\r
241 * Result is two VariableLengthComponents and inserted component between them.
\r
243 * Note : world position of newComponent must be set before this method may be called.
\r
245 * @param newComponent
\r
246 * @param splittingComponent
\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
257 /* there are many different cases to insert new component when
\r
258 it splits existing VariableLengthinlineComponent.
\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
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
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
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
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
287 dir.scale(length * 0.5);
\r
288 Point3d vn = new Point3d(comp);
\r
289 Point3d vp = new Point3d(comp);
\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
297 IEntity type = getLibraryComponentType(splittingComponent);
\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
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
327 * Attaches newComponent into connectedComponent's connectedControlPoint
\r
328 * @param newComponent
\r
329 * @param connectedComponent
\r
330 * @param connectedControlPoint
\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
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
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
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
363 // assert (connectedParentPoint == null); // if direction is prev, connection done to parentpoint
\r
364 // if (newSubPoint != null) {
\r
370 private void insertEndComponent() {
\r
372 Graph coreTC = parent.getGraph();
\r
374 if (replace == null)
\r
375 checkForEndInsertion();
\r
376 if (replace == null) {
\r
377 ErrorLogger.defaultLogError("Cannot insert end component",null);
\r
381 G3DNode p = straight.getHasParent();
\r
383 ErrorLogger.defaultLogError("Straight pipe has no parent", new Exception("ASSERT!"));
\r
386 Pipeline pipeline = PipelineFactory.create(p);
\r
387 coreTC.startTransaction(this);
\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
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
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
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
423 private void insertComponent(Point3d startPoint) {
\r
425 Graph coreTC = parent.getGraph();
\r
426 G3DNode p = straight.getHasParent();
\r
428 ErrorLogger.defaultLogError("Straight pipe has no parent", new Exception("ASSERT!"));
\r
431 Pipeline pipeline = PipelineFactory.create(p);
\r
432 coreTC.startTransaction(this);
\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
456 line.removeFromParent();
\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
476 old insert reducer code
\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
488 if (elbowResource != null) {
\r
489 pipeComponents.remove(elbowResource);
\r
490 pipeline.getHasSubnodesSet().remove(elbowResource);
\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
505 graph.commitChanges(CommitMessage.CHANGE_MESSAGE);
\r
507 Reducer reducer = null;
\r
508 Pipeline newPipeline = PipelineFactory.instantiate(graph);
\r
509 OffsetControlPoint offsetControlPoint = OffsetControlPointFactory.instantiate(graph);
\r
511 reducer = ConcentricReducerFactory.instantiate(graph);
\r
513 reducer = EccentricReducerFactory.instantiate(graph);
\r
515 graph.commitChanges(CommitMessage.CHANGE_MESSAGE);
\r
516 SizeChangeControlPoint sccp = SizeChangeControlPointFactory.create(pcp.getResource());
\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
525 reducer.setLocalPosition(sccp.getLocalPosition());
\r
526 reducer.setWorldPosition(sccp.getWorldPosition());
\r
528 reducer.setBottomRadiusValue(pipeline.getPipeRadiusValue());
\r
530 reducer.setPipeRadius(pipeline.getPipeRadius());
\r
531 reducer.setTopRadiusValue(newPipeRadius);
\r
532 newPipeline.setPipeRadiusValue(newPipeRadius);
\r
533 newPipeline.setTurnRadiusValue(newPipeTurnRadius);
\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
539 //newPipeline.getHasControlPointSet().add(pcp);
\r
540 sccp.setHasOffsetPoint(offsetControlPoint);
\r
541 offsetControlPoint.setOffsetPointOf(sccp);
\r
543 reducer.setHasControlPoint(sccp);
\r
544 graph.commitChanges(CommitMessage.CHANGE_MESSAGE);
\r
546 sccp.setNextComponentOffsetValue(reducerLength*0.5);
\r
547 sccp.setPreviousComponentOffsetValue(reducerLength*0.5);
\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
553 // linking sccp and ocp offsets
\r
554 offsetControlPoint.setNextComponentOffset(sccp.getNextComponentOffset());
\r
555 offsetControlPoint.setPreviousComponentOffset(sccp.getPreviousComponentOffset());
\r
558 offsetControlPoint.setPreviousPoint(sccp.getPreviousPoint());
\r
559 offsetControlPoint.setNextPoint(sccp.getNextPoint());
\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
567 //Point3d World = GraphicsNodeTools.getTranslation(sccp.getLocalPosition());
\r
568 GraphicsNodeTools.setTranslation(offsetControlPoint.getLocalPosition(), local);
\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
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
579 graph.commitTransaction(CommitMessage.TRANSACTION_MESSAGE);
\r
588 * Returns direction of a nozzle
\r
592 public static Vector3d getNozzleDirection(IEntity nozzle) {
\r
593 return ControlPointTools.getNozzleDirection(nozzle.getSingleRelatedObject(ProcessResource.g3dResource.HasWorldOrientation));
\r
597 * Returns true if a nozzle is not connected to a pipe
\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
610 assert (pcp.getAtMostOneRelatedObject(ProcessResource.plant3Dresource.ControlPointOfPipeRun) != null);
\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
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
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
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
637 * Liks piperun's specs to nozzle's specs
\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
646 piperun.addStatement(ProcessResource.plant3Dresource.HasControlPoints, nozzle.getSingleRelatedObject(ProcessResource.plant3Dresource.HasControlPoint));
\r
647 setStatement(nozzle, ProcessResource.plant3Dresource.HasPipeDiameter, diam);
\r
651 * Unlinks piperun's specs from nozzle's specs.
\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
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
668 private static void setStatement(IEntity subject, Resource relation, IEntity object) {
\r
669 subject.removeRelatedStatements(relation);
\r
670 subject.addStatement(relation, object);
\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