+ public static PipelineComponent addComponent(P3DRootNode root, PipelineComponent component, InsertInstruction inst) throws Exception {
+
+ PipelineComponent newComponent = ComponentUtils.createComponent(root, inst.typeUri);
+ PipeControlPoint newPcp = newComponent.getControlPoint();
+
+ PipeControlPoint toPcp = component.getControlPoint();
+ PipeRun pipeRun = toPcp.getPipeRun();
+
+ String typeName = names.get(inst.typeUri);
+ if (typeName == null)
+ typeName = "Component";
+
+ Vector3d dir = null;
+ Vector3d pos = null;
+
+ PositionType position = inst.position;
+ PositionType insertPosition = inst.insertPosition;
+ boolean lengthAdjustable = false;
+ if (newComponent instanceof InlineComponent) {
+ lengthAdjustable = ((InlineComponent)newComponent).isVariableLength() || ((InlineComponent)newComponent).isModifialble();
+ }
+ boolean insertAdjustable = false;
+ if (component instanceof InlineComponent) {
+ insertAdjustable = ((InlineComponent)component).isVariableLength();
+ }
+ boolean sizeChange = false;
+ if (newComponent instanceof InlineComponent) {
+ sizeChange = ((InlineComponent)newComponent).isSizeChange();
+ }
+
+ if (toPcp.isInline()) {
+ switch (position) {
+ case NEXT:
+ if (toPcp.isDualInline()) {
+ toPcp = toPcp.getDualSub();
+ pipeRun = toPcp.getPipeRun();
+ }
+
+ break;
+ case PREVIOUS:
+ if (toPcp.isDualSub()) {
+ toPcp = toPcp.parent;
+ pipeRun = toPcp.getPipeRun();
+ }
+ break;
+ default:
+ break;
+ }
+ Vector3d start = new Vector3d();
+ Vector3d end = new Vector3d();
+ dir = new Vector3d();
+ toPcp.getInlineControlPointEnds(start, end, dir);
+ dir.normalize();
+ switch (position) {
+ case NEXT:
+ pos = new Vector3d(end);
+ break;
+ case PREVIOUS:
+ pos = new Vector3d(start);
+ break;
+ 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.asFixedAngle()) {
+ dir = new Vector3d(toPcp.getDirection(position == PositionType.NEXT ? Direction.NEXT : Direction.PREVIOUS));
+ pos = new Vector3d(toPcp.getWorldPosition());
+ if (!lengthAdjustable) {
+ Vector3d v = new Vector3d(dir);
+ v.scale(toPcp.getInlineLength());
+ pos.add(v);
+ } else {
+ if (insertPosition == PositionType.NEXT) {
+ Vector3d v = new Vector3d(dir);
+ v.scale(toPcp.getInlineLength());
+ pos.add(v);
+ } else if (insertPosition == PositionType.SPLIT) {
+ // scale 0.5*length so that we don't remove the length twice from the new component
+ Vector3d v = new Vector3d(dir);
+ v.scale(toPcp.getInlineLength()*0.5);
+ pos.add(v);
+ }
+ }
+ }
+
+
+ if (!sizeChange) {
+ String name = component.getPipeRun().getUniqueName(typeName);
+ newComponent.setName(name);
+
+ pipeRun.addChild(newComponent);
+
+ 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);
+ if (insertAdjustable) {
+ if (insertPosition == PositionType.NEXT)
+ v.scale(newComponent.getControlPoint().getInlineLength());
+ else if (insertPosition == PositionType.SPLIT)
+ v.set(0, 0, 0);
+ else if (insertPosition == PositionType.PREVIOUS)
+ v.scale(-newComponent.getControlPoint().getInlineLength());
+ } else {
+ v.scale(newComponent.getControlPoint().getInlineLength());
+ }
+ switch (position) {
+ case NEXT:
+ pos.add(v);
+ break;
+ case PREVIOUS:
+ pos.sub(v);
+ break;
+ case SPLIT:
+ break;
+ default:
+ break;
+ }
+
+ switch (position) {
+ case NEXT:
+ if (toPcp.isDualInline())
+ toPcp = toPcp.getDualSub();
+ newPcp.insert(toPcp, Direction.NEXT);
+ newPcp.setWorldPosition(pos);
+ break;
+ case PREVIOUS:
+ if (toPcp.isDualSub())
+ toPcp = toPcp.parent;
+ newPcp.insert(toPcp, Direction.PREVIOUS);
+ newPcp.setWorldPosition(pos);
+ break;
+ case SPLIT:
+ PipingRules.splitVariableLengthComponent(newComponent, (InlineComponent)component, true);
+ default:
+ break;
+ }
+ } else {
+ PipeRun other = new PipeRun();
+ String n = root.getUniqueName("PipeRun");
+ other.setName(n);
+ other.setPipeDiameter(inst.diameter);
+ other.setTurnRadius(inst.turnRadius);
+ root.addChild(other);
+
+
+ if (position == PositionType.NEXT) {
+ PipingRules.addSizeChange(false, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
+ } else if (position == PositionType.PREVIOUS){
+ PipingRules.addSizeChange(true, pipeRun, other, (InlineComponent)newComponent, toPcp, null);
+ }
+ newPcp.setWorldPosition(pos);
+
+ // TODO : chicken-egg problem
+ newComponent.updateParameters();
+ Vector3d v = new Vector3d(dir);
+ v.scale(newComponent.getControlPoint().getLength()*0.5);
+ switch (position) {
+ case NEXT:
+ pos.add(v);
+ break;
+ case PREVIOUS:
+ pos.sub(v);
+ break;
+ case SPLIT:
+ break;
+ default:
+ break;
+ }
+ newPcp.setWorldPosition(pos);
+ if (inst.rotationAngle != null)
+ ((InlineComponent) newComponent).setRotationAngle(inst.rotationAngle);
+
+ }
+
+
+ return newComponent;
+ }
+ public static boolean connect(PipelineComponent current, PipelineComponent endTo) throws Exception {
+ return connect(current, endTo, null, null);