import java.util.List;
import java.util.Map;
-import javax.vecmath.Point3d;
import javax.vecmath.Vector3d;
import org.simantics.Simantics;
import org.simantics.db.exception.DatabaseException;
import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.scenegraph.GeometryProvider;
+import org.simantics.g3d.scenegraph.ParametricGeometryProvider;
import org.simantics.layer0.Layer0;
+import org.simantics.plant3d.geometry.ParameterRead;
import org.simantics.plant3d.ontology.Plant3D;
import org.simantics.plant3d.scenegraph.EndComponent;
import org.simantics.plant3d.scenegraph.Equipment;
types.add(Plant3D.URIs.Builtin_ConcentricReducer);
types.add(Plant3D.URIs.Builtin_BranchSplitComponent);
types.add(Plant3D.URIs.Builtin_EccentricReducer);
+ types.add(Plant3D.URIs.Builtin_Elbow45);
+ types.add(Plant3D.URIs.Builtin_Elbow90);
for (String typeURI : types) {
load(graph, typeURI);
}
if (geom != null) {
GeometryProvider provider = graph.adapt(geom, GeometryProvider.class);
+ if (provider instanceof ParametricGeometryProvider) {
+ Map<String,Object> params = graph.syncRequest(new ParameterRead(type));
+ if (params.size() > 0)
+ ((ParametricGeometryProvider)provider).setProperties(params);
+ }
return provider;
}
return null;
return equipment;
}
+ public static Equipment createEquipmentWithNozzles(P3DRootNode root, String typeURI, String nozzleTypeUri) throws Exception {
+ GeometryProvider provider = providers.get(typeURI);
+ if (provider == null) {
+ load(typeURI);
+ provider = providers.get(typeURI);
+ }
+ Equipment equipment = root.createEquipment();
+ equipment.setType(typeURI);
+ equipment.setGeometry(provider);
+ root.addChild(equipment);
+
+ for (int i = 0; i < equipment.numberOfFixedNozzles(); i++) {
+ createNozzle(root, equipment, new Item(nozzleTypeUri, "Nozzle"));
+
+ }
+
+ return equipment;
+ }
+
public static InlineComponent createStraight(P3DRootNode root) throws Exception{
InlineComponent component = root.createInline();
component.setType(Plant3D.URIs.Builtin_Straight);
Equipment equipment = createEquipment(root, equipmentType.getUri());
String n = root.getUniqueName(equipmentType.getName());
equipment.setName(n);
- root.addChild(equipment);
return equipment;
}
-
+ public static Equipment createEquipmentWithNozzles(P3DRootNode root, Item equipmentType, Item nozzleType) throws Exception {
+ Equipment equipment = createEquipmentWithNozzles(root, equipmentType.getUri(), nozzleType.getUri());
+ String n = root.getUniqueName(equipmentType.getName());
+ equipment.setName(n);
+ return equipment;
+ }
public static Nozzle createDefaultNozzle(P3DRootNode root, Equipment equipment) throws Exception {
return createNozzle(root, equipment, new Item(Plant3D.URIs.Builtin_Nozzle, "Nozzle"));
// Variable angle
public Double angle;
+
+ // Rotation angle used with turns and rotated inline.
+ public Double rotationAngle;
public String getTypeUri() {
return typeUri;
public void setAngle(Double angle) {
this.angle = angle;
}
+
+ public Double getRotationAngle() {
+ return rotationAngle;
+ }
+
+ public void setRotationAngle(Double rotationAngle) {
+ this.rotationAngle = rotationAngle;
+ }
}
PositionType insertPosition = inst.insertPosition;
boolean lengthAdjustable = false;
if (newComponent instanceof InlineComponent) {
- lengthAdjustable = ((InlineComponent)newComponent).isVariableLength();
+ lengthAdjustable = ((InlineComponent)newComponent).isVariableLength() || ((InlineComponent)newComponent).isModifialble();
}
boolean insertAdjustable = false;
if (component instanceof InlineComponent) {
switch (position) {
case NEXT:
if (toPcp.isDualInline()) {
- toPcp = toPcp.getSubPoint().get(0);
+ toPcp = toPcp.getDualSub();
pipeRun = toPcp.getPipeRun();
}
pipeRun = toPcp.getPipeRun();
}
break;
+ default:
+ break;
}
Vector3d start = new Vector3d();
Vector3d end = new Vector3d();
case SPLIT:
pos = new Vector3d(toPcp.getWorldPosition());
break;
+ default:
+ break;
}
} else if (toPcp.isDirected()) {
dir = new Vector3d(toPcp.getDirection(Direction.NEXT));
pos = new Vector3d(toPcp.getWorldPosition());
- } else if (toPcp.isTurn() && toPcp.isFixed()) {
+ } else if (toPcp.isTurn() && toPcp.asFixedAngle()) {
dir = new Vector3d(toPcp.getDirection(position == PositionType.NEXT ? Direction.NEXT : Direction.PREVIOUS));
pos = new Vector3d(toPcp.getWorldPosition());
if (!lengthAdjustable) {
newComponent.setName(name);
pipeRun.addChild(newComponent);
- // TODO: these options are not stored into DB. Should they?!
- if (newComponent instanceof InlineComponent && ((InlineComponent)newComponent).isVariableLength()) {
- newPcp.setLength(inst.length);
- } else if (newComponent instanceof TurnComponent && ((TurnComponent)newComponent).isVariableAngle()) {
- newPcp.setTurnAngle(inst.angle);
+
+ if (newComponent instanceof InlineComponent) {
+ InlineComponent inlineComponent = (InlineComponent)newComponent;
+ if (inlineComponent.isVariableLength()|| inlineComponent.isModifialble()) {
+ newPcp.setLength(inst.length);
+ newComponent.setParameter("length", inst.length);
+ }
+ if (inst.rotationAngle != null)
+ ((InlineComponent) newComponent).setRotationAngle(inst.rotationAngle);
+ } else if (newComponent instanceof TurnComponent) {
+ TurnComponent turnComponent = (TurnComponent)newComponent;
+ if (turnComponent.isVariableAngle()) {
+ newPcp.setTurnAngle(inst.angle);
+ newComponent.setParameter("turnAngle", inst.angle);
+ }
+ if (inst.rotationAngle != null)
+ ((TurnComponent) newComponent).setRotationAngle(inst.rotationAngle);
}
+
newComponent.updateParameters();
Vector3d v = new Vector3d(dir);
break;
case SPLIT:
break;
+ default:
+ break;
}
switch (position) {
case NEXT:
if (toPcp.isDualInline())
- toPcp = toPcp.getSubPoint().get(0);
+ toPcp = toPcp.getDualSub();
newPcp.insert(toPcp, Direction.NEXT);
newPcp.setWorldPosition(pos);
break;
break;
case SPLIT:
PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
+ default:
+ break;
}
} else {
PipeRun other = new PipeRun();
PipingRules.addSizeChange(true, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
}
newPcp.setWorldPosition(pos);
+
// TODO : chicken-egg problem
newComponent.updateParameters();
Vector3d v = new Vector3d(dir);
break;
case SPLIT:
break;
+ default:
+ break;
}
newPcp.setWorldPosition(pos);
+ if (inst.rotationAngle != null)
+ ((InlineComponent) newComponent).setRotationAngle(inst.rotationAngle);
}
requiresReverse = true;
}
PipeRun other = endCP.getPipeRun();
- boolean mergeRuns = other == null ? true : pipeRun.equalSpecs(other);
+ boolean mergeRuns = other == null ? true : pipeRun.canMerge(other);
if (requiresReverse) {
// Pipe line must be traversible with next/previous relations without direction change.
PipingRules.reverse(other);
}
+
if (mergeRuns) {
// Runs have compatible specs and must be merged
if (other != null && pipeRun != other)
- PipingRules.merge(pipeRun, other);
+ pipeRun.merge(other);
else if (other == null) {
if (!(endTo instanceof Nozzle)) {
pipeRun.addChild(endTo);
// Runs do not have compatible specs, and a reducer must be attached in between.
InlineComponent reducer = ComponentUtils.createReducer(root);
PipeControlPoint pcp = reducer.getControlPoint();
- PipeControlPoint ocp = pcp.getSubPoint().get(0);
Vector3d endPos = endCP.getWorldPosition();
Vector3d currentPos = currentCP.getWorldPosition();
Code Review / simantics / 3d.git / blobdiff