1 package org.simantics.plant3d.utils;
3 import java.util.ArrayList;
4 import java.util.HashMap;
8 import javax.vecmath.Vector3d;
10 import org.simantics.Simantics;
11 import org.simantics.db.ReadGraph;
12 import org.simantics.db.Resource;
13 import org.simantics.db.common.request.ReadRequest;
14 import org.simantics.db.common.utils.NameUtils;
15 import org.simantics.db.exception.DatabaseException;
16 import org.simantics.g3d.math.MathTools;
17 import org.simantics.g3d.scenegraph.GeometryProvider;
18 import org.simantics.g3d.scenegraph.ParametricGeometryProvider;
19 import org.simantics.layer0.Layer0;
20 import org.simantics.plant3d.geometry.ParameterRead;
21 import org.simantics.plant3d.ontology.Plant3D;
22 import org.simantics.plant3d.scenegraph.EndComponent;
23 import org.simantics.plant3d.scenegraph.Equipment;
24 import org.simantics.plant3d.scenegraph.InlineComponent;
25 import org.simantics.plant3d.scenegraph.Nozzle;
26 import org.simantics.plant3d.scenegraph.P3DRootNode;
27 import org.simantics.plant3d.scenegraph.PipeRun;
28 import org.simantics.plant3d.scenegraph.PipelineComponent;
29 import org.simantics.plant3d.scenegraph.TurnComponent;
30 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
31 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Direction;
32 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
33 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
35 public class ComponentUtils {
38 private static Map<String,Class<? extends PipelineComponent>> clazzes = new HashMap<String, Class<? extends PipelineComponent>>();
39 private static Map<String,GeometryProvider> providers = new HashMap<String,GeometryProvider>();
40 private static Map<String,String> names = new HashMap<String,String>();
42 public static void preloadCache() {
43 Simantics.getSession().asyncRequest(new ReadRequest() {
46 public void run(ReadGraph graph) throws DatabaseException {
47 List<String> types = new ArrayList<String>();
48 types.add(Plant3D.URIs.Builtin_Straight);
49 types.add(Plant3D.URIs.Builtin_Elbow);
50 types.add(Plant3D.URIs.Builtin_ConcentricReducer);
51 types.add(Plant3D.URIs.Builtin_BranchSplitComponent);
52 types.add(Plant3D.URIs.Builtin_EccentricReducer);
53 types.add(Plant3D.URIs.Builtin_Elbow45);
54 types.add(Plant3D.URIs.Builtin_Elbow90);
56 for (String typeURI : types) {
63 private static GeometryProvider getProvider(ReadGraph graph, Resource type) throws DatabaseException {
65 Layer0 l0 = Layer0.getInstance(graph);
66 Plant3D p3d = Plant3D.getInstance(graph);
67 Resource geom = graph.getPossibleObject(type,p3d.hasGeometry);
69 for (Resource a : graph.getObjects(type, l0.Asserts)) {
70 if (p3d.hasGeometry.equals(graph.getPossibleObject(a, l0.HasPredicate))) {
71 geom = graph.getPossibleObject(a, l0.HasObject);
77 GeometryProvider provider = graph.adapt(geom, GeometryProvider.class);
78 if (provider instanceof ParametricGeometryProvider) {
79 Map<String,Object> params = graph.syncRequest(new ParameterRead(type));
80 if (params.size() > 0)
81 ((ParametricGeometryProvider)provider).setProperties(params);
88 private static Class<? extends PipelineComponent> getClazz(ReadGraph graph, Resource type) throws DatabaseException {
89 Plant3D p3d = Plant3D.getInstance(graph);
90 if (graph.isInheritedFrom(type, p3d.InlineComponent))
91 return InlineComponent.class;
92 if (graph.isInheritedFrom(type, p3d.TurnComponent))
93 return TurnComponent.class;
94 if (graph.isInheritedFrom(type, p3d.EndComponent))
95 return EndComponent.class;
96 if (graph.isInheritedFrom(type, p3d.Nozzle))
101 private static void load(ReadGraph graph, String typeURI) throws DatabaseException {
102 Plant3D p3d = Plant3D.getInstance(graph);
103 Resource type = graph.getResource(typeURI);
105 GeometryProvider provider = getProvider(graph, type);
106 if (provider != null || graph.hasStatement(type,p3d.NonVisibleComponent)) {
107 providers.put(typeURI, provider);
108 if (graph.isInheritedFrom(type, p3d.PipelineComponent))
109 clazzes.put(typeURI,getClazz(graph, type));
110 names.put(typeURI, NameUtils.getSafeName(graph, type));
113 throw new DatabaseException("Cannot find component for " + typeURI);
116 private static void load(final String typeURI) throws DatabaseException {
117 Simantics.getSession().syncRequest(new ReadRequest() {
120 public void run(ReadGraph graph) throws DatabaseException {
127 * Creates a component
129 * Does not set the name or add the component to a piperun.
135 public static PipelineComponent createComponent(P3DRootNode root, String typeURI) throws Exception {
136 Class<? extends PipelineComponent> type = clazzes.get(typeURI);
137 GeometryProvider provider = providers.get(typeURI);
138 if (type == null || provider == null) {
140 type = clazzes.get(typeURI);
141 provider = providers.get(typeURI);
143 //PipelineComponent component = type.newInstance();
144 PipelineComponent component = null;
145 if (type == InlineComponent.class) {
146 component = root.createInline();
147 } else if (type == TurnComponent.class) {
148 component = root.createTurn();
149 } else if (type == EndComponent.class) {
150 component = root.createTurn();
151 } else if (type == Nozzle.class) {
152 component = root.createNozzle();
154 component.setType(typeURI);
155 component.setGeometry(provider);
160 * Creates a equipment
162 * Does not set the name
170 public static Equipment createEquipment(P3DRootNode root, String typeURI) throws Exception {
171 GeometryProvider provider = providers.get(typeURI);
172 if (provider == null) {
174 provider = providers.get(typeURI);
176 Equipment equipment = root.createEquipment();
177 equipment.setType(typeURI);
178 equipment.setGeometry(provider);
179 root.addChild(equipment);
183 public static Equipment createEquipmentWithNozzles(P3DRootNode root, String typeURI, String nozzleTypeUri) throws Exception {
184 GeometryProvider provider = providers.get(typeURI);
185 if (provider == null) {
187 provider = providers.get(typeURI);
189 Equipment equipment = root.createEquipment();
190 equipment.setType(typeURI);
191 equipment.setGeometry(provider);
192 root.addChild(equipment);
194 for (int i = 0; i < equipment.numberOfFixedNozzles(); i++) {
195 createNozzle(root, equipment, new Item(nozzleTypeUri, "Nozzle"));
202 public static InlineComponent createStraight(P3DRootNode root) throws Exception{
203 InlineComponent component = root.createInline();
204 component.setType(Plant3D.URIs.Builtin_Straight);
205 component.setGeometry(providers.get(Plant3D.URIs.Builtin_Straight));
209 public static TurnComponent createTurn(P3DRootNode root) throws Exception {
210 TurnComponent elbow = root.createTurn();
211 elbow.setType(Plant3D.URIs.Builtin_Elbow);
212 elbow.setGeometry(providers.get(Plant3D.URIs.Builtin_Elbow));
216 public static InlineComponent createReducer(P3DRootNode root) throws Exception {
217 InlineComponent component = root.createInline();
218 component.setType(Plant3D.URIs.Builtin_ConcentricReducer);
219 component.setGeometry(providers.get(Plant3D.URIs.Builtin_ConcentricReducer));
223 public static InlineComponent createBranchSplit(P3DRootNode root) throws Exception {
224 InlineComponent component = root.createInline();
225 component.setType(Plant3D.URIs.Builtin_BranchSplitComponent);
229 public static Equipment createEquipment(P3DRootNode root, Item equipmentType) throws Exception {
230 Equipment equipment = createEquipment(root, equipmentType.getUri());
231 String n = root.getUniqueName(equipmentType.getName());
232 equipment.setName(n);
236 public static Equipment createEquipmentWithNozzles(P3DRootNode root, Item equipmentType, Item nozzleType) throws Exception {
237 Equipment equipment = createEquipmentWithNozzles(root, equipmentType.getUri(), nozzleType.getUri());
238 String n = root.getUniqueName(equipmentType.getName());
239 equipment.setName(n);
243 public static Nozzle createDefaultNozzle(P3DRootNode root, Equipment equipment) throws Exception {
244 return createNozzle(root, equipment, new Item(Plant3D.URIs.Builtin_Nozzle, "Nozzle"));
247 public static Nozzle createNozzle(P3DRootNode root, Equipment equipment, Item nozzleType) throws Exception {
248 Nozzle nozzle = root.createNozzle();
249 nozzle.setType(nozzleType.getUri());
250 String n = root.getUniqueName(nozzleType.getName());
252 PipeRun pipeRun = new PipeRun();
253 n = root.getUniqueName("PipeRun");
255 nozzle.setPipeRun(pipeRun);
257 equipment.addChild(nozzle);
258 root.addChild(pipeRun);
259 // root.getNodeMap().commit("Add nozzle " + n);
263 public static class InsertInstruction {
264 public String typeUri;
266 public PositionType position = PositionType.NEXT;
267 public PositionType insertPosition = PositionType.NEXT;
269 // Reducer requires pipe specs
270 public Double diameter;
271 public Double turnRadius;
274 public Double length;
279 public String getTypeUri() {
283 public void setTypeUri(String typeUri) {
284 this.typeUri = typeUri;
287 public PositionType getPosition() {
291 public void setPosition(PositionType position) {
292 this.position = position;
295 public PositionType getInsertPosition() {
296 return insertPosition;
299 public void setInsertPosition(PositionType insertPosition) {
300 this.insertPosition = insertPosition;
303 public Double getDiameter() {
307 public void setDiameter(Double diameter) {
308 this.diameter = diameter;
311 public Double getTurnRadius() {
315 public void setTurnRadius(Double turnRadius) {
316 this.turnRadius = turnRadius;
319 public Double getLength() {
323 public void setLength(Double length) {
324 this.length = length;
327 public Double getAngle() {
331 public void setAngle(Double angle) {
337 public static PipelineComponent addComponent(P3DRootNode root, PipelineComponent component, InsertInstruction inst) throws Exception {
339 PipelineComponent newComponent = ComponentUtils.createComponent(root, inst.typeUri);
340 PipeControlPoint newPcp = newComponent.getControlPoint();
342 PipeControlPoint toPcp = component.getControlPoint();
343 PipeRun pipeRun = toPcp.getPipeRun();
345 String typeName = names.get(inst.typeUri);
346 if (typeName == null)
347 typeName = "Component";
352 PositionType position = inst.position;
353 PositionType insertPosition = inst.insertPosition;
354 boolean lengthAdjustable = false;
355 if (newComponent instanceof InlineComponent) {
356 lengthAdjustable = ((InlineComponent)newComponent).isVariableLength() || ((InlineComponent)newComponent).isModifialble();
358 boolean insertAdjustable = false;
359 if (component instanceof InlineComponent) {
360 insertAdjustable = ((InlineComponent)component).isVariableLength();
362 boolean sizeChange = false;
363 if (newComponent instanceof InlineComponent) {
364 sizeChange = ((InlineComponent)newComponent).isSizeChange();
367 if (toPcp.isInline()) {
370 if (toPcp.isDualInline()) {
371 toPcp = toPcp.getDualSub();
372 pipeRun = toPcp.getPipeRun();
377 if (toPcp.isDualSub()) {
378 toPcp = toPcp.parent;
379 pipeRun = toPcp.getPipeRun();
385 Vector3d start = new Vector3d();
386 Vector3d end = new Vector3d();
387 dir = new Vector3d();
388 toPcp.getInlineControlPointEnds(start, end, dir);
392 pos = new Vector3d(end);
395 pos = new Vector3d(start);
398 pos = new Vector3d(toPcp.getWorldPosition());
404 } else if (toPcp.isDirected()) {
405 dir = new Vector3d(toPcp.getDirection(Direction.NEXT));
406 pos = new Vector3d(toPcp.getWorldPosition());
407 } else if (toPcp.isTurn() && toPcp.asFixedAngle()) {
408 dir = new Vector3d(toPcp.getDirection(position == PositionType.NEXT ? Direction.NEXT : Direction.PREVIOUS));
409 pos = new Vector3d(toPcp.getWorldPosition());
410 if (!lengthAdjustable) {
411 Vector3d v = new Vector3d(dir);
412 v.scale(toPcp.getInlineLength());
415 if (insertPosition == PositionType.NEXT) {
416 Vector3d v = new Vector3d(dir);
417 v.scale(toPcp.getInlineLength());
419 } else if (insertPosition == PositionType.SPLIT) {
420 // scale 0.5*length so that we don't remove the length twice from the new component
421 Vector3d v = new Vector3d(dir);
422 v.scale(toPcp.getInlineLength()*0.5);
430 String name = component.getPipeRun().getUniqueName(typeName);
431 newComponent.setName(name);
433 pipeRun.addChild(newComponent);
435 if (newComponent instanceof InlineComponent) {
436 InlineComponent inlineComponent = (InlineComponent)newComponent;
437 if (inlineComponent.isVariableLength()|| inlineComponent.isModifialble()) {
438 newPcp.setLength(inst.length);
439 newComponent.setParameter("length", inst.length);
441 } else if (newComponent instanceof TurnComponent) {
442 TurnComponent turnComponent = (TurnComponent)newComponent;
443 if (turnComponent.isVariableAngle()) {
444 newPcp.setTurnAngle(inst.angle);
445 newComponent.setParameter("turnAngle", inst.angle);
449 newComponent.updateParameters();
451 Vector3d v = new Vector3d(dir);
452 if (insertAdjustable) {
453 if (insertPosition == PositionType.NEXT)
454 v.scale(newComponent.getControlPoint().getInlineLength());
455 else if (insertPosition == PositionType.SPLIT)
457 else if (insertPosition == PositionType.PREVIOUS)
458 v.scale(-newComponent.getControlPoint().getInlineLength());
460 v.scale(newComponent.getControlPoint().getInlineLength());
477 if (toPcp.isDualInline())
478 toPcp = toPcp.getDualSub();
479 newPcp.insert(toPcp, Direction.NEXT);
480 newPcp.setWorldPosition(pos);
483 if (toPcp.isDualSub())
484 toPcp = toPcp.parent;
485 newPcp.insert(toPcp, Direction.PREVIOUS);
486 newPcp.setWorldPosition(pos);
489 PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
494 PipeRun other = new PipeRun();
495 String n = root.getUniqueName("PipeRun");
497 other.setPipeDiameter(inst.diameter);
498 other.setTurnRadius(inst.turnRadius);
499 root.addChild(other);
502 if (position == PositionType.NEXT) {
503 PipingRules.addSizeChange(false, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
504 } else if (position == PositionType.PREVIOUS){
505 PipingRules.addSizeChange(true, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
507 newPcp.setWorldPosition(pos);
508 // TODO : chicken-egg problem
509 newComponent.updateParameters();
510 Vector3d v = new Vector3d(dir);
511 v.scale(newComponent.getControlPoint().getLength()*0.5);
524 newPcp.setWorldPosition(pos);
531 public static boolean connect(PipelineComponent current, PipelineComponent endTo) throws Exception {
532 return connect(current, endTo, null, null);
536 * Connects component to another component
544 public static boolean connect(PipelineComponent current, PipelineComponent endTo, PositionType endType, Vector3d position) throws Exception{
545 PipeControlPoint endCP = endTo.getControlPoint();
547 if (current.getNext() == null)
549 else if (current.getPrevious() == null)
554 PipeRun pipeRun = current.getPipeRun();
555 P3DRootNode root = (P3DRootNode)current.getRootNode();
556 PipeControlPoint currentCP = current.getControlPoint();
558 if (endType == null || endType == PositionType.NEXT || endType == PositionType.PREVIOUS) {
562 boolean requiresReverse = false;
563 if (!reversed && endCP.getPrevious() != null) {
564 if (endCP.getNext() != null)
566 requiresReverse = true;
567 } else if (reversed && endCP.getNext() != null) {
568 if (endCP.getPrevious() != null)
570 requiresReverse = true;
572 PipeRun other = endCP.getPipeRun();
573 boolean mergeRuns = other == null ? true : pipeRun.canMerge(other);
575 if (requiresReverse) {
576 // Pipe line must be traversible with next/previous relations without direction change.
577 // Now the component, where we are connecting the created pipeline is defined in different order.
578 PipingRules.reverse(other);
583 // Runs have compatible specs and must be merged
584 if (other != null && pipeRun != other)
585 pipeRun.merge(other);
586 else if (other == null) {
587 if (!(endTo instanceof Nozzle)) {
588 pipeRun.addChild(endTo);
590 endTo.setPipeRun(pipeRun);
594 currentCP.setNext(endCP);
595 endCP.setPrevious(currentCP);
597 currentCP.setPrevious(endCP);
598 endCP.setNext(currentCP);
601 // Runs do not have compatible specs, and a reducer must be attached in between.
602 InlineComponent reducer = ComponentUtils.createReducer(root);
603 PipeControlPoint pcp = reducer.getControlPoint();
605 Vector3d endPos = endCP.getWorldPosition();
606 Vector3d currentPos = currentCP.getWorldPosition();
607 Vector3d v = new Vector3d(endPos);
612 PipingRules.addSizeChange(reversed, pipeRun, other, reducer, currentCP, endCP);
614 pcp.setWorldPosition(v);
615 reducer.updateParameters();
617 PipingRules.positionUpdate(endCP);
620 } else if (endType == PositionType.SPLIT) {
621 InlineComponent branchSplit = createBranchSplit((InlineComponent)endTo, position);
622 if (branchSplit == null)
624 PipeControlPoint branchSplitCP = branchSplit.getControlPoint();
625 PipeControlPoint pcp = new PipeControlPoint(branchSplit,pipeRun);
626 branchSplitCP.children.add(pcp);
627 pcp.parent = branchSplitCP;
628 pcp.setWorldOrientation(branchSplitCP.getWorldOrientation());
629 pcp.setWorldPosition(branchSplitCP.getWorldPosition());
633 pcp.setPrevious(currentCP);
634 currentCP.setNext(pcp);
636 pcp.setNext(currentCP);
637 currentCP.setPrevious(pcp);
639 PipingRules.positionUpdate(endCP);
645 public static InlineComponent createBranchSplit(InlineComponent component, Vector3d pos) throws Exception{
646 if (!component.isVariableLength())
648 PipeRun pipeRun = component.getPipeRun();
649 Vector3d sStart = new Vector3d();
650 Vector3d sEnd = new Vector3d();
651 component.getControlPoint().getInlineControlPointEnds(sStart, sEnd);
653 if (MathTools.distance(sStart, sEnd) < (pipeRun.getPipeDiameter()*0.5))
657 Vector3d p = MathTools.closestPointOnEdge(new Vector3d(pos), sStart, sEnd);
659 Vector3d v = new Vector3d(sEnd);
662 v.scale(component.getPipeRun().getPipeDiameter()*0.5);
664 } else if (p == sEnd) {
665 Vector3d v = new Vector3d(sStart);
668 v.scale(component.getPipeRun().getPipeDiameter()*0.5);
672 P3DRootNode root = (P3DRootNode)component.getRootNode();
673 InlineComponent branchSplit = ComponentUtils.createBranchSplit(root);
674 String branchName = component.getPipeRun().getUniqueName("Branch");
675 branchSplit.setName(branchName);
676 component.getPipeRun().addChild(branchSplit);
677 PipeControlPoint branchSplitCP = branchSplit.getControlPoint();
678 branchSplitCP.setWorldPosition(p);
679 PipingRules.splitVariableLengthComponent(branchSplit, component, false);