1 package org.simantics.plant3d.utils;
3 import java.util.ArrayList;
4 import java.util.HashMap;
8 import javax.vecmath.Point3d;
9 import javax.vecmath.Vector3d;
11 import org.simantics.Simantics;
12 import org.simantics.db.ReadGraph;
13 import org.simantics.db.Resource;
14 import org.simantics.db.common.request.ReadRequest;
15 import org.simantics.db.common.utils.NameUtils;
16 import org.simantics.db.exception.DatabaseException;
17 import org.simantics.g3d.math.MathTools;
18 import org.simantics.g3d.scenegraph.GeometryProvider;
19 import org.simantics.layer0.Layer0;
20 import org.simantics.plant3d.ontology.Plant3D;
21 import org.simantics.plant3d.scenegraph.EndComponent;
22 import org.simantics.plant3d.scenegraph.Equipment;
23 import org.simantics.plant3d.scenegraph.InlineComponent;
24 import org.simantics.plant3d.scenegraph.Nozzle;
25 import org.simantics.plant3d.scenegraph.P3DRootNode;
26 import org.simantics.plant3d.scenegraph.PipeRun;
27 import org.simantics.plant3d.scenegraph.PipelineComponent;
28 import org.simantics.plant3d.scenegraph.TurnComponent;
29 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
30 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Direction;
31 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.PositionType;
32 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
34 public class ComponentUtils {
37 private static Map<String,Class<? extends PipelineComponent>> clazzes = new HashMap<String, Class<? extends PipelineComponent>>();
38 private static Map<String,GeometryProvider> providers = new HashMap<String,GeometryProvider>();
39 private static Map<String,String> names = new HashMap<String,String>();
41 public static void preloadCache() {
42 Simantics.getSession().asyncRequest(new ReadRequest() {
45 public void run(ReadGraph graph) throws DatabaseException {
46 List<String> types = new ArrayList<String>();
47 types.add(Plant3D.URIs.Builtin_Straight);
48 types.add(Plant3D.URIs.Builtin_Elbow);
49 types.add(Plant3D.URIs.Builtin_ConcentricReducer);
50 types.add(Plant3D.URIs.Builtin_BranchSplitComponent);
51 types.add(Plant3D.URIs.Builtin_EccentricReducer);
53 for (String typeURI : types) {
60 private static GeometryProvider getProvider(ReadGraph graph, Resource type) throws DatabaseException {
62 Layer0 l0 = Layer0.getInstance(graph);
63 Plant3D p3d = Plant3D.getInstance(graph);
64 Resource geom = graph.getPossibleObject(type,p3d.hasGeometry);
66 for (Resource a : graph.getObjects(type, l0.Asserts)) {
67 if (p3d.hasGeometry.equals(graph.getPossibleObject(a, l0.HasPredicate))) {
68 geom = graph.getPossibleObject(a, l0.HasObject);
74 GeometryProvider provider = graph.adapt(geom, GeometryProvider.class);
80 private static Class<? extends PipelineComponent> getClazz(ReadGraph graph, Resource type) throws DatabaseException {
81 Plant3D p3d = Plant3D.getInstance(graph);
82 if (graph.isInheritedFrom(type, p3d.InlineComponent))
83 return InlineComponent.class;
84 if (graph.isInheritedFrom(type, p3d.TurnComponent))
85 return TurnComponent.class;
86 if (graph.isInheritedFrom(type, p3d.EndComponent))
87 return EndComponent.class;
88 if (graph.isInheritedFrom(type, p3d.Nozzle))
93 private static void load(ReadGraph graph, String typeURI) throws DatabaseException {
94 Plant3D p3d = Plant3D.getInstance(graph);
95 Resource type = graph.getResource(typeURI);
97 GeometryProvider provider = getProvider(graph, type);
98 if (provider != null || graph.hasStatement(type,p3d.NonVisibleComponent)) {
99 providers.put(typeURI, provider);
100 if (graph.isInheritedFrom(type, p3d.PipelineComponent))
101 clazzes.put(typeURI,getClazz(graph, type));
102 names.put(typeURI, NameUtils.getSafeName(graph, type));
105 throw new DatabaseException("Cannot find component for " + typeURI);
108 private static void load(final String typeURI) throws DatabaseException {
109 Simantics.getSession().syncRequest(new ReadRequest() {
112 public void run(ReadGraph graph) throws DatabaseException {
119 * Creates a component
121 * Does not set the name or add the component to a piperun.
127 public static PipelineComponent createComponent(P3DRootNode root, String typeURI) throws Exception {
128 Class<? extends PipelineComponent> type = clazzes.get(typeURI);
129 GeometryProvider provider = providers.get(typeURI);
130 if (type == null || provider == null) {
132 type = clazzes.get(typeURI);
133 provider = providers.get(typeURI);
135 //PipelineComponent component = type.newInstance();
136 PipelineComponent component = null;
137 if (type == InlineComponent.class) {
138 component = root.createInline();
139 } else if (type == TurnComponent.class) {
140 component = root.createTurn();
141 } else if (type == EndComponent.class) {
142 component = root.createTurn();
143 } else if (type == Nozzle.class) {
144 component = root.createNozzle();
146 component.setType(typeURI);
147 component.setGeometry(provider);
152 * Creates a equipment
154 * Does not set the name
162 public static Equipment createEquipment(P3DRootNode root, String typeURI) throws Exception {
163 GeometryProvider provider = providers.get(typeURI);
164 if (provider == null) {
166 provider = providers.get(typeURI);
168 Equipment equipment = root.createEquipment();
169 equipment.setType(typeURI);
170 equipment.setGeometry(provider);
171 root.addChild(equipment);
175 public static InlineComponent createStraight(P3DRootNode root) throws Exception{
176 InlineComponent component = root.createInline();
177 component.setType(Plant3D.URIs.Builtin_Straight);
178 component.setGeometry(providers.get(Plant3D.URIs.Builtin_Straight));
182 public static TurnComponent createTurn(P3DRootNode root) throws Exception {
183 TurnComponent elbow = root.createTurn();
184 elbow.setType(Plant3D.URIs.Builtin_Elbow);
185 elbow.setGeometry(providers.get(Plant3D.URIs.Builtin_Elbow));
189 public static InlineComponent createReducer(P3DRootNode root) throws Exception {
190 InlineComponent component = root.createInline();
191 component.setType(Plant3D.URIs.Builtin_ConcentricReducer);
192 component.setGeometry(providers.get(Plant3D.URIs.Builtin_ConcentricReducer));
196 public static InlineComponent createBranchSplit(P3DRootNode root) throws Exception {
197 InlineComponent component = root.createInline();
198 component.setType(Plant3D.URIs.Builtin_BranchSplitComponent);
202 public static Equipment createEquipment(P3DRootNode root, Item equipmentType) throws Exception {
203 Equipment equipment = createEquipment(root, equipmentType.getUri());
204 String n = root.getUniqueName(equipmentType.getName());
205 equipment.setName(n);
206 root.addChild(equipment);
212 public static Nozzle createDefaultNozzle(P3DRootNode root, Equipment equipment) throws Exception {
213 return createNozzle(root, equipment, new Item(Plant3D.URIs.Builtin_Nozzle, "Nozzle"));
216 public static Nozzle createNozzle(P3DRootNode root, Equipment equipment, Item nozzleType) throws Exception {
217 Nozzle nozzle = root.createNozzle();
218 nozzle.setType(nozzleType.getUri());
219 String n = root.getUniqueName(nozzleType.getName());
221 PipeRun pipeRun = new PipeRun();
222 n = root.getUniqueName("PipeRun");
224 nozzle.setPipeRun(pipeRun);
226 equipment.addChild(nozzle);
227 root.addChild(pipeRun);
228 // root.getNodeMap().commit("Add nozzle " + n);
232 public static class InsertInstruction {
233 public String typeUri;
235 public PositionType position = PositionType.NEXT;
236 public PositionType insertPosition = PositionType.NEXT;
238 // Reducer requires pipe specs
239 public Double diameter;
240 public Double turnRadius;
243 public Double length;
248 public String getTypeUri() {
252 public void setTypeUri(String typeUri) {
253 this.typeUri = typeUri;
256 public PositionType getPosition() {
260 public void setPosition(PositionType position) {
261 this.position = position;
264 public PositionType getInsertPosition() {
265 return insertPosition;
268 public void setInsertPosition(PositionType insertPosition) {
269 this.insertPosition = insertPosition;
272 public Double getDiameter() {
276 public void setDiameter(Double diameter) {
277 this.diameter = diameter;
280 public Double getTurnRadius() {
284 public void setTurnRadius(Double turnRadius) {
285 this.turnRadius = turnRadius;
288 public Double getLength() {
292 public void setLength(Double length) {
293 this.length = length;
296 public Double getAngle() {
300 public void setAngle(Double angle) {
306 public static PipelineComponent addComponent(P3DRootNode root, PipelineComponent component, InsertInstruction inst) throws Exception {
308 PipelineComponent newComponent = ComponentUtils.createComponent(root, inst.typeUri);
309 PipeControlPoint newPcp = newComponent.getControlPoint();
311 PipeControlPoint toPcp = component.getControlPoint();
312 PipeRun pipeRun = toPcp.getPipeRun();
314 String typeName = names.get(inst.typeUri);
315 if (typeName == null)
316 typeName = "Component";
321 PositionType position = inst.position;
322 PositionType insertPosition = inst.insertPosition;
323 boolean lengthAdjustable = false;
324 if (newComponent instanceof InlineComponent) {
325 lengthAdjustable = ((InlineComponent)newComponent).isVariableLength();
327 boolean insertAdjustable = false;
328 if (component instanceof InlineComponent) {
329 insertAdjustable = ((InlineComponent)component).isVariableLength();
331 boolean sizeChange = false;
332 if (newComponent instanceof InlineComponent) {
333 sizeChange = ((InlineComponent)newComponent).isSizeChange();
336 if (toPcp.isInline()) {
339 if (toPcp.isDualInline())
340 toPcp = toPcp.getSubPoint().get(0);
344 if (toPcp.isDualSub())
345 toPcp = toPcp.parent;
347 Vector3d start = new Vector3d();
348 Vector3d end = new Vector3d();
349 dir = new Vector3d();
350 toPcp.getInlineControlPointEnds(start, end, dir);
354 pos = new Vector3d(end);
357 pos = new Vector3d(start);
360 pos = new Vector3d(toPcp.getWorldPosition());
364 } else if (toPcp.isDirected()) {
365 dir = new Vector3d(toPcp.getDirection(Direction.NEXT));
366 pos = new Vector3d(toPcp.getWorldPosition());
367 } else if (toPcp.isTurn() && toPcp.isFixed()) {
368 dir = new Vector3d(toPcp.getDirection(position == PositionType.NEXT ? Direction.NEXT : Direction.PREVIOUS));
369 pos = new Vector3d(toPcp.getWorldPosition());
370 if (!lengthAdjustable) {
371 Vector3d v = new Vector3d(dir);
372 v.scale(toPcp.getInlineLength());
375 if (insertPosition == PositionType.NEXT) {
376 Vector3d v = new Vector3d(dir);
377 v.scale(toPcp.getInlineLength());
379 } else if (insertPosition == PositionType.SPLIT) {
380 // scale 0.5*length so that we don't remove the length twice from the new component
381 Vector3d v = new Vector3d(dir);
382 v.scale(toPcp.getInlineLength()*0.5);
390 String name = component.getPipeRun().getUniqueName(typeName);
391 newComponent.setName(name);
393 pipeRun.addChild(newComponent);
394 // TODO: these options are not stored into DB. Should they?!
395 if (newComponent instanceof InlineComponent && ((InlineComponent)newComponent).isVariableLength()) {
396 newPcp.setLength(inst.length);
397 } else if (newComponent instanceof TurnComponent && ((TurnComponent)newComponent).isVariableAngle()) {
398 newPcp.setTurnAngle(inst.angle);
401 newComponent.updateParameters();
403 Vector3d v = new Vector3d(dir);
404 if (insertAdjustable) {
405 if (insertPosition == PositionType.NEXT)
406 v.scale(newComponent.getControlPoint().getInlineLength());
407 else if (insertPosition == PositionType.SPLIT)
409 else if (insertPosition == PositionType.PREVIOUS)
410 v.scale(-newComponent.getControlPoint().getInlineLength());
412 v.scale(newComponent.getControlPoint().getInlineLength());
427 if (toPcp.isDualInline())
428 toPcp = toPcp.getSubPoint().get(0);
429 newPcp.insert(toPcp, Direction.NEXT);
430 newPcp.setWorldPosition(pos);
433 if (toPcp.isDualSub())
434 toPcp = toPcp.parent;
435 newPcp.insert(toPcp, Direction.PREVIOUS);
436 newPcp.setWorldPosition(pos);
439 PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
442 PipeRun other = new PipeRun();
443 String n = root.getUniqueName("PipeRun");
445 other.setPipeDiameter(inst.diameter);
446 other.setTurnRadius(inst.turnRadius);
447 root.addChild(other);
450 if (position == PositionType.NEXT) {
451 PipingRules.addSizeChange(false, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
452 } else if (position == PositionType.PREVIOUS){
453 PipingRules.addSizeChange(true, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
455 newPcp.setWorldPosition(pos);
456 // TODO : chicken-egg problem
457 newComponent.updateParameters();
458 Vector3d v = new Vector3d(dir);
459 v.scale(newComponent.getControlPoint().getLength()*0.5);
470 newPcp.setWorldPosition(pos);
477 public static boolean connect(PipelineComponent current, PipelineComponent endTo) throws Exception {
478 return connect(current, endTo, null, null);
482 * Connects component to another component
490 public static boolean connect(PipelineComponent current, PipelineComponent endTo, PositionType endType, Vector3d position) throws Exception{
491 PipeControlPoint endCP = endTo.getControlPoint();
493 if (current.getNext() == null)
495 else if (current.getPrevious() == null)
500 PipeRun pipeRun = current.getPipeRun();
501 P3DRootNode root = (P3DRootNode)current.getRootNode();
502 PipeControlPoint currentCP = current.getControlPoint();
504 if (endType == null || endType == PositionType.NEXT || endType == PositionType.PREVIOUS) {
508 boolean requiresReverse = false;
509 if (!reversed && endCP.getPrevious() != null) {
510 if (endCP.getNext() != null)
512 requiresReverse = true;
513 } else if (reversed && endCP.getNext() != null) {
514 if (endCP.getPrevious() != null)
516 requiresReverse = true;
518 PipeRun other = endCP.getPipeRun();
519 boolean mergeRuns = pipeRun.equalSpecs(other);
521 if (requiresReverse) {
522 // Pipe line must be traversible with next/previous relations without direction change.
523 // Now the component, where we are connecting the created pipeline is defined in different order.
524 PipingRules.reverse(other);
528 // Runs have compatible specs and must be merged
529 if (pipeRun != other) // FIXME: temporary workaround.
530 PipingRules.merge(pipeRun, other);
532 currentCP.setNext(endCP);
533 endCP.setPrevious(currentCP);
535 currentCP.setPrevious(endCP);
536 endCP.setNext(currentCP);
539 // Runs do not have compatible specs, and a reducer must be attached in between.
540 InlineComponent reducer = ComponentUtils.createReducer(root);
541 PipeControlPoint pcp = reducer.getControlPoint();
542 PipeControlPoint ocp = pcp.getSubPoint().get(0);
544 Vector3d endPos = endCP.getWorldPosition();
545 Vector3d currentPos = currentCP.getWorldPosition();
546 Vector3d v = new Vector3d(endPos);
551 PipingRules.addSizeChange(reversed, pipeRun, other, reducer, currentCP, endCP);
553 pcp.setWorldPosition(v);
554 reducer.updateParameters();
556 PipingRules.positionUpdate(endCP);
559 } else if (endType == PositionType.SPLIT) {
560 InlineComponent branchSplit = createBranchSplit((InlineComponent)endTo, position);
561 if (branchSplit == null)
563 PipeControlPoint branchSplitCP = branchSplit.getControlPoint();
564 PipeControlPoint pcp = new PipeControlPoint(branchSplit,pipeRun);
565 branchSplitCP.children.add(pcp);
566 pcp.parent = branchSplitCP;
567 pcp.setWorldOrientation(branchSplitCP.getWorldOrientation());
568 pcp.setWorldPosition(branchSplitCP.getWorldPosition());
572 pcp.setPrevious(currentCP);
573 currentCP.setNext(pcp);
575 pcp.setNext(currentCP);
576 currentCP.setPrevious(pcp);
578 PipingRules.positionUpdate(endCP);
584 public static InlineComponent createBranchSplit(InlineComponent component, Vector3d pos) throws Exception{
585 if (!component.isVariableLength())
587 PipeRun pipeRun = component.getPipeRun();
588 Vector3d sStart = new Vector3d();
589 Vector3d sEnd = new Vector3d();
590 component.getControlPoint().getInlineControlPointEnds(sStart, sEnd);
592 if (MathTools.distance(sStart, sEnd) < (pipeRun.getPipeDiameter()*0.5))
596 Vector3d p = MathTools.closestPointOnEdge(new Vector3d(pos), sStart, sEnd);
598 Vector3d v = new Vector3d(sEnd);
601 v.scale(component.getPipeRun().getPipeDiameter()*0.5);
603 } else if (p == sEnd) {
604 Vector3d v = new Vector3d(sStart);
607 v.scale(component.getPipeRun().getPipeDiameter()*0.5);
611 P3DRootNode root = (P3DRootNode)component.getRootNode();
612 InlineComponent branchSplit = ComponentUtils.createBranchSplit(root);
613 String branchName = component.getPipeRun().getUniqueName("Branch");
614 branchSplit.setName(branchName);
615 component.getPipeRun().addChild(branchSplit);
616 PipeControlPoint branchSplitCP = branchSplit.getControlPoint();
617 branchSplitCP.setWorldPosition(p);
618 PipingRules.splitVariableLengthComponent(branchSplit, component, false);