Mentioned methods can now handle size change / offset points directly.
Previous implementation could not handle two reducers connected to each
other.
gitlab #35
Change-Id: I817a4d75290b184f772965ff38c01b3e9ae61c64
protected void activateNextPrev(PipeControlPoint start) throws Exception{
if (!reversed && start.isDualInline())
protected void activateNextPrev(PipeControlPoint start) throws Exception{
if (!reversed && start.isDualInline())
- start = start.getSubPoint().get(0);
+ start = start.getDualSub();
else if (reversed && start.isDualSub())
start = start.parent;
else if (reversed && start.isDualSub())
start = start.parent;
private PipeControlPoint endingToComponent(INode componentNode, Vector3d o, Vector3d d) {
PipelineComponent component = (PipelineComponent)componentNode;
PipeControlPoint pcp = component.getControlPoint();
private PipeControlPoint endingToComponent(INode componentNode, Vector3d o, Vector3d d) {
PipelineComponent component = (PipelineComponent)componentNode;
PipeControlPoint pcp = component.getControlPoint();
+ PipeControlPoint connect = null;
if (component instanceof EndComponent) {
if (pcp.getNext() != null || pcp.getPrevious() != null)
return null;
if (component instanceof EndComponent) {
if (pcp.getNext() != null || pcp.getPrevious() != null)
return null;
} else if (component instanceof TurnComponent) {
if (pcp.getNext() == null || pcp.getPrevious() == null)
} else if (component instanceof TurnComponent) {
if (pcp.getNext() == null || pcp.getPrevious() == null)
- return pcp;
- return null;
+ connect = pcp;
+ else
+ return null;
} else if (component instanceof InlineComponent) {
// TODO : scan all empty pcps of the component and select closest one.
if (pcp.getNext() == null || pcp.getPrevious() == null)
} else if (component instanceof InlineComponent) {
// TODO : scan all empty pcps of the component and select closest one.
if (pcp.getNext() == null || pcp.getPrevious() == null)
- return pcp;
- return null;
+ connect = pcp;
+ else
+ return null;
+ }
+ if (connect != null) {
+ currentPosition.set(connect.getWorldPosition());
+ updateCurrentPoint();
+ setInfoText("Connect to " + component.getName());
+ return connect;
@Override
protected void activateNextPrev(PipeControlPoint start) throws Exception {
if (!reversed && start.isDualInline())
@Override
protected void activateNextPrev(PipeControlPoint start) throws Exception {
if (!reversed && start.isDualInline())
- start = start.getSubPoint().get(0);
+ start = start.getDualSub();
else if (reversed && start.isDualSub())
start = start.parent;
else if (reversed && start.isDualSub())
start = start.parent;
public void updateParameters() {
super.updateParameters();
if (!isVariableLength()) {
public void updateParameters() {
super.updateParameters();
if (!isVariableLength()) {
- Map<String,Object> calculated = getTotalParameters();
- if (calculated.containsKey("length")) {
- controlPoint.setLength((Double)calculated.get("length"));
- }
+ Map<String,Object> calculated = getCalculatedParameters();
+
if (calculated.containsKey("offset")) {
controlPoint.setOffset((Double)calculated.get("offset"));
componentCalculatedOffset = true;
} else {
componentCalculatedOffset = false;
}
if (calculated.containsKey("offset")) {
controlPoint.setOffset((Double)calculated.get("offset"));
componentCalculatedOffset = true;
} else {
componentCalculatedOffset = false;
}
+
+ Map<String,Object> total = getTotalParameters();
+
+ if (total.containsKey("length")) {
+ controlPoint.setLength((Double)total.get("length"));
+ }
+
PipingRules.requestUpdate(getControlPoint());
}
}
PipingRules.requestUpdate(getControlPoint());
}
}
if (!Double.isNaN(controlPoint.getLength()) && controlPoint.isVariableLength())
map.put("length", controlPoint.getLength());
if (controlPoint.isDualInline()) {
if (!Double.isNaN(controlPoint.getLength()) && controlPoint.isVariableLength())
map.put("length", controlPoint.getLength());
if (controlPoint.isDualInline()) {
- PipeControlPoint sub = controlPoint.getSubPoint().get(0);
+ PipeControlPoint sub = controlPoint.getDualSub();
PipeRun pipeRun2 = sub.getPipeRun();
if (pipeRun2 != null) {
map.put("radius2", pipeRun2.getPipeDiameter() * 0.5);
PipeRun pipeRun2 = sub.getPipeRun();
if (pipeRun2 != null) {
map.put("radius2", pipeRun2.getPipeDiameter() * 0.5);
return;
this.alternativePipeRun = pipeRun;
if (getControlPoint().isDualInline()) {
return;
this.alternativePipeRun = pipeRun;
if (getControlPoint().isDualInline()) {
- PipeControlPoint sub = getControlPoint().getSubPoint().get(0);
- if (sub.getParent() != this.alternativePipeRun)
- this.alternativePipeRun.addChild(sub);
+ PipeControlPoint sub = getControlPoint().getDualSub();
+ if (sub.getParent() != this.alternativePipeRun) {
+ if (this.alternativePipeRun != null) {
+ this.alternativePipeRun.addChild(sub);
+ } else if (sub.getPipeRun() != null) {
+ // FIXME : how to handle child point without proper run?
+ sub.getPipeRun().remChild(sub);
+ }
+ }
+
}
firePropertyChanged(Plant3D.URIs.HasAlternativePipeRun);
}
}
firePropertyChanged(Plant3D.URIs.HasAlternativePipeRun);
}
private PipeControlPoint getBranchPoint() {
PipeControlPoint branchPoint;
private PipeControlPoint getBranchPoint() {
PipeControlPoint branchPoint;
- if (getControlPoint().getSubPoint().size() > 0) {
- branchPoint = getControlPoint().getSubPoint().get(0);
+ if (getControlPoint().getChildPoints().size() > 0) {
+ branchPoint = getControlPoint().getChildPoints().get(0);
} else {
if (branch0.getPipeRun() == null)
return null;
} else {
if (branch0.getPipeRun() == null)
return null;
if (pcp.getNext() != nextPCP) {
pcp.setNext(nextPCP);
}
if (pcp.getNext() != nextPCP) {
pcp.setNext(nextPCP);
}
- if (pcp.isDualInline()) {
- PipeControlPoint sub = pcp.getSubPoint().get(0);
- if (sub.getNext() != nextPCP)
- sub.setNext(nextPCP);
- }
+// if (pcp.isDualInline()) {
+// PipeControlPoint sub = pcp.getChildPoints().get(0);
+// if (sub.getNext() != nextPCP)
+// sub.setNext(nextPCP);
+// }
return true;
}
private boolean _connectPrev(PipeControlPoint pcp, PipeControlPoint prevPCP) {
if (prevPCP == null)
return false;
return true;
}
private boolean _connectPrev(PipeControlPoint pcp, PipeControlPoint prevPCP) {
if (prevPCP == null)
return false;
- if (prevPCP.isDualInline())
- prevPCP = prevPCP.getSubPoint().get(0);
+// if (prevPCP.isDualInline())
+// prevPCP = prevPCP.getChildPoints().get(0);
if (pcp.getPrevious() != prevPCP) {
pcp.setPrevious(prevPCP);
}
if (pcp.getPrevious() != prevPCP) {
pcp.setPrevious(prevPCP);
}
- if (pcp.isDualInline()) {
- PipeControlPoint sub = pcp.getSubPoint().get(0);
- if (sub.getPrevious() != prevPCP)
- sub.setPrevious(prevPCP);
- }
+// if (pcp.isDualInline()) {
+// PipeControlPoint sub = pcp.getChildPoints().get(0);
+// if (sub.getPrevious() != prevPCP)
+// sub.setPrevious(prevPCP);
+// }
- } else if (getControlPoint().getSubPoint().size() > 0) { // TODO : this may cause problems? (Removes branch point, before branch has been set?)
+ } else if (getControlPoint().getChildPoints().size() > 0) { // TODO : this may cause problems? (Removes branch point, before branch has been set?)
//getControlPoint().getSubPoint().get(0).remove();
//getControlPoint().children.clear();
return true;
//getControlPoint().getSubPoint().get(0).remove();
//getControlPoint().children.clear();
return true;
private boolean isReverse = false; // definition direction can be swapped
private boolean isDeletable = true; // can be removed by rules
private boolean isSizeChange = false; // changes size of the pipe. The next control point / component is on different PipeRun
private boolean isReverse = false; // definition direction can be swapped
private boolean isDeletable = true; // can be removed by rules
private boolean isSizeChange = false; // changes size of the pipe. The next control point / component is on different PipeRun
- private boolean isSub = false; // child point
+ private boolean isSub = false; // child point for offset / size change
public PipeControlPoint(PipelineComponent component) {
this.component = component;
public PipeControlPoint(PipelineComponent component) {
this.component = component;
}
public void setNext(PipeControlPoint next) {
}
public void setNext(PipeControlPoint next) {
+ if (isSub) {
+ getParentPoint().setNext(next);
+ return;
+ }
+ if (next != null && next.isDualSub())
+ next = next.parent;
+ if (_setNext(next)) {
+ for (PipeControlPoint pcp : children) {
+ if (pcp.isSub)
+ pcp._setNext(next);
+ }
+ updateSubPoint();
+ }
+ }
+
+ public void setPrevious(PipeControlPoint prev) {
+ if (isSub) {
+ getParentPoint().setPrevious(prev);
+ return;
+ }
+ if (prev != null && prev.isDualInline())
+ prev = prev.children.get(0);
+ if (_setPrevious(prev)) {
+ for (PipeControlPoint pcp : children) {
+ if (pcp.isSub)
+ pcp._setPrevious(prev);
+ }
+ updateSubPoint();
+ }
+ }
+
+ protected boolean _setNext(PipeControlPoint next) {
if (isEnd() && previous != null && next != null)
throw new RuntimeException("End control points are allowed to have only one connection");
if (next == this)
throw new RuntimeException("Cannot connect to self");
if (this.next == next)
if (isEnd() && previous != null && next != null)
throw new RuntimeException("End control points are allowed to have only one connection");
if (next == this)
throw new RuntimeException("Cannot connect to self");
if (this.next == next)
if (DEBUG) System.out.println(this + " next " + next);
if (next == null && isVariableAngle() && previous != null && !isRemoved()) {
convertVariableAngleToFixed(Direction.NEXT);
if (DEBUG) System.out.println(this + " next " + next);
if (next == null && isVariableAngle() && previous != null && !isRemoved()) {
convertVariableAngleToFixed(Direction.NEXT);
component.setNext(next != null ? next.component : null);
else
component.setBranch0(next != null ? next.component : null);
component.setNext(next != null ? next.component : null);
else
component.setBranch0(next != null ? next.component : null);
- public void setPrevious(PipeControlPoint previous) {
+ protected boolean _setPrevious(PipeControlPoint previous) {
if (isEnd() && next != null && previous != null)
throw new RuntimeException("End control points are allowed to have only one connection");
if (previous == this)
throw new RuntimeException("Cannot connect to self");
if (this.previous == previous)
if (isEnd() && next != null && previous != null)
throw new RuntimeException("End control points are allowed to have only one connection");
if (previous == this)
throw new RuntimeException("Cannot connect to self");
if (this.previous == previous)
if (DEBUG) System.out.println(this + " previous " + previous);
if (previous == null && isVariableAngle() && next != null && !isRemoved()) {
convertVariableAngleToFixed(Direction.PREVIOUS);
if (DEBUG) System.out.println(this + " previous " + previous);
if (previous == null && isVariableAngle() && next != null && !isRemoved()) {
convertVariableAngleToFixed(Direction.PREVIOUS);
component.setBranch0(previous != null ? previous.component : null);
updateSubPoint();
}
component.setBranch0(previous != null ? previous.component : null);
updateSubPoint();
}
}
private void convertVariableAngleToFixed(Direction direction) {
}
private void convertVariableAngleToFixed(Direction direction) {
public PipeControlPoint parent;
public List<PipeControlPoint> children = new ArrayList<PipeControlPoint>();
public PipeControlPoint parent;
public List<PipeControlPoint> children = new ArrayList<PipeControlPoint>();
- public List<PipeControlPoint> getSubPoint() {
+ public List<PipeControlPoint> getChildPoints() {
this.length = l;
firePropertyChanged("length");
if (isDualInline())
this.length = l;
firePropertyChanged("length");
if (isDualInline())
- getSubPoint().get(0).setLength(l);
+ getDualSub().setLength(l);
}
@GetPropertyValue(name="Turn Angle",tabId="Debug",value="turnAngle")
}
@GetPropertyValue(name="Turn Angle",tabId="Debug",value="turnAngle")
PipeControlPoint offsetCP = null;
if (isOffset()) {
PipeControlPoint offsetCP = null;
if (isOffset()) {
- offsetCP = getSubPoint().get(0);
+ offsetCP = getDualSub();
}
if (previousNext != null && previousNext == next) {
if (previous.isDualInline()) {
}
if (previousNext != null && previousNext == next) {
if (previous.isDualInline()) {
}
if (next.isDualInline()) {
}
if (next.isDualInline()) {
- next.getSubPoint().get(0).setPrevious(this);
+ next.getDualSub().setPrevious(this);
}
} else if (previousPrevious != null && previousPrevious == next) {
// control point were given in reverse order
}
} else if (previousPrevious != null && previousPrevious == next) {
// control point were given in reverse order
offsetCP.setPrevious(next);
}
if (previous.isDualInline()) {
offsetCP.setPrevious(next);
}
if (previous.isDualInline()) {
- previous.getSubPoint().get(0).setPrevious(this);
+ previous.getDualSub().setPrevious(this);
}
this.setPrevious(next);
next.setNext(this);
}
this.setPrevious(next);
next.setNext(this);
pcp.getParentPoint().setNext(this);
}
if (isDualInline()) {
pcp.getParentPoint().setNext(this);
}
if (isDualInline()) {
- getSubPoint().get(0).setPrevious(this);
+ getDualSub().setPrevious(this);
}
} else {
// if direction is previous, user must have given sizechange
}
} else {
// if direction is previous, user must have given sizechange
// we must link pcp to newCP's OffsetPoint
PipeControlPoint nocp = null;
if (isDualInline()) {
// we must link pcp to newCP's OffsetPoint
PipeControlPoint nocp = null;
if (isDualInline()) {
- nocp = getSubPoint().get(0);
nocp.setNext(pcp);
}
if (nocp == null) {
nocp.setNext(pcp);
}
if (nocp == null) {
}
this.setNext(pcp);
if (pcp.isDualInline()) {
}
this.setNext(pcp);
if (pcp.isDualInline()) {
- PipeControlPoint ocp = pcp.getSubPoint().get(0);
+ PipeControlPoint ocp = pcp.getDualSub();
if (nocp == null)
ocp.setPrevious(this);
else
if (nocp == null)
ocp.setPrevious(this);
else
if (next != null) {
PipeControlPoint pcp = this;
if (pcp.isDualInline()) {
if (next != null) {
PipeControlPoint pcp = this;
if (pcp.isDualInline()) {
- pcp = pcp.getSubPoint().get(0);
+ pcp = pcp.getDualSub();
}
Vector3d v = new Vector3d();
v.sub(next.getWorldPosition(),pcp.getWorldPosition());
}
Vector3d v = new Vector3d();
v.sub(next.getWorldPosition(),pcp.getWorldPosition());
if (isInline()) {
PipeControlPoint pcp = this;
if (pcp.isDualInline()) {
if (isInline()) {
PipeControlPoint pcp = this;
if (pcp.isDualInline()) {
- pcp = pcp.getSubPoint().get(0);
+ pcp = pcp.getDualSub();
}
Vector3d v = new Vector3d();
v.sub(pcp.getWorldPosition(),next.getWorldPosition());
}
Vector3d v = new Vector3d();
v.sub(pcp.getWorldPosition(),next.getWorldPosition());
public void getInlineControlPointEnds(Tuple3d p1, Tuple3d p2) {
assert (isInline());
public void getInlineControlPointEnds(Tuple3d p1, Tuple3d p2) {
assert (isInline());
- PipeControlPoint sub = isAxial() ? this : getSubPoint().get(0);
+ PipeControlPoint sub = isAxial() ? this : getDualSub();
Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
Vector3d dir = sub.getPathLegDirection(Direction.NEXT);
Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
Vector3d dir = sub.getPathLegDirection(Direction.NEXT);
}
public void getControlPointEnds(Tuple3d p1, Tuple3d p2) {
}
public void getControlPointEnds(Tuple3d p1, Tuple3d p2) {
- PipeControlPoint sub = isAxial() || isDirected() || isTurn() ? this : getSubPoint().get(0);
+ PipeControlPoint sub = isAxial() || isDirected() || isTurn() ? this : getChildPoints().get(0);
Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
}
public void getEndDirections(Tuple3d v1, Tuple3d v2) {
}
public void getEndDirections(Tuple3d v1, Tuple3d v2) {
- PipeControlPoint sub = isAxial() ? this : getSubPoint().get(0);
+ PipeControlPoint sub = isAxial() ? this : getDualSub();
Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
dir1.normalize();
Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
dir1.normalize();
public void _remove() {
_remove(true);
}
public void _remove() {
_remove(true);
}
+
+
+ public PipeControlPoint getDualSub() {
+ if (isDualInline())
+ return getChildPoints().get(0);
+ else
+ throw new IllegalStateException("Current control point is not dual inline");
+ }
+
public void _remove(boolean renconnect) {
if (component == null && next == null && previous == null)
return;
if (DEBUG) System.out.println(this + " Remove " + renconnect);
public void _remove(boolean renconnect) {
if (component == null && next == null && previous == null)
return;
if (DEBUG) System.out.println(this + " Remove " + renconnect);
- if (isDualInline() || isDualSub()) {
- removeDualPoint();
- return;
- }
if (getParentPoint() != null) {
getParentPoint()._remove(renconnect);
if (getParentPoint() != null) {
getParentPoint()._remove(renconnect);
}
PipeRun pipeRun = getPipeRun();
if (pipeRun == null)
}
PipeRun pipeRun = getPipeRun();
if (pipeRun == null)
boolean link = renconnect;
if (currentNext.isBranchEnd()) {
link = false;
boolean link = renconnect;
if (currentNext.isBranchEnd()) {
link = false;
- // currentNext.setPrevious(null);
- // currentNext.setNext(null);
currentNext.remove();
currentNext = null;
setNext(null);
}
if (currentPrev.isBranchEnd()) {
link = false;
currentNext.remove();
currentNext = null;
setNext(null);
}
if (currentPrev.isBranchEnd()) {
link = false;
- // currentPrev.setPrevious(null);
- // currentPrev.setNext(null);
currentPrev.remove();
currentPrev = null;
setPrevious(null);
}
currentPrev.remove();
currentPrev = null;
setPrevious(null);
}
- if (link && currentPrev.isDirected() && currentNext.isDirected()) {
- link = false;
+ if (link) {
+ if (currentPrev.isDirected() && currentNext.isDirected())
+ link = false;
+ else if (this.isDualInline()) {
+ link = false;
+ } else if (this.isDualSub()) {
+ throw new RuntimeException("_remove() is called for parent point, somehow got to child point. " + this);
+ }
}
if (currentNext == null) {
// Nothing to do
} else if (currentNext.isDualInline()) {
PipeControlPoint sccp = currentNext;
}
if (currentNext == null) {
// Nothing to do
} else if (currentNext.isDualInline()) {
PipeControlPoint sccp = currentNext;
- PipeControlPoint ocp = sccp.getSubPoint().get(0);
+ PipeControlPoint ocp = currentNext.getDualSub();
if (ocp == null) {
throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
}
if (link) {
sccp.setPrevious(currentPrev);
if (ocp == null) {
throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
}
if (link) {
sccp.setPrevious(currentPrev);
- ocp.setPrevious(currentPrev);
+ //ocp.setPrevious(currentPrev);
+ assert(ocp.getPrevious() == currentPrev);
} else {
sccp.setPrevious(null);
} else {
sccp.setPrevious(null);
+ //ocp.setPrevious(null);
+ assert(ocp.getPrevious() == null);
}
setNext(null);
} else if (currentNext.isDualSub()) {
}
setNext(null);
} else if (currentNext.isDualSub()) {
currentNext.setPrevious(null);
}
setNext(null);
currentNext.setPrevious(null);
}
setNext(null);
+ } else if (isDualInline()) {
+ if (currentNext.previous != getDualSub()) {
+ throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
+ }
+ if (link) {
+ currentNext.setPrevious(currentPrev);
+ } else {
+ currentNext.setPrevious(null);
+ }
+ setNext(null);
} else {
throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
}
} else {
throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
}
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
} else if (currentPrev.isDualSub()) {
PipeControlPoint ocp = currentPrev;
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
} else if (currentPrev.isDualSub()) {
PipeControlPoint ocp = currentPrev;
- PipeControlPoint sccp = ocp.getParentPoint();
+ PipeControlPoint sccp = currentPrev.getParentPoint();
if (sccp == null)
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
if (link) {
if (sccp == null)
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
if (link) {
- ocp.setNext(currentNext);
+ //ocp.setNext(currentNext);
sccp.setNext(currentNext);
sccp.setNext(currentNext);
+ assert(ocp.getNext() == currentNext);
+ assert(ocp.getNext() == null);
}
setPrevious(null);
} else if (currentPrev.next == this) {
}
setPrevious(null);
} else if (currentPrev.next == this) {
} else {
// FIXME : pipe run must be split into two parts, since the control point structure is no more continuous.
}
} else {
// FIXME : pipe run must be split into two parts, since the control point structure is no more continuous.
}
- } else if (next != null) {
- if (next.isDualInline()) {
- PipeControlPoint sccp = next;
- PipeControlPoint ocp = sccp.getSubPoint().get(0);
+ } else if (currentNext != null) {
+ if (currentNext.isDualInline()) {
+ PipeControlPoint sccp = currentNext;
+ PipeControlPoint ocp = getDualSub();
if (ocp == null) {
throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
}
sccp.setPrevious(null);
if (ocp == null) {
throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
}
sccp.setPrevious(null);
- ocp.setPrevious(null);
- } else if (next.isDualSub()) {
+ assert(ocp.getPrevious() == null);
+ //ocp.setPrevious(null);
+ } else if (currentNext.isDualSub()) {
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, next control point is offset control point");
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, next control point is offset control point");
- } else if (next.previous == this) {
- next.setPrevious(null);
+ } else if (currentNext.previous == this) {
+ currentNext.setPrevious(null);
+ } else if (isDualInline()) {
+ if (currentNext.previous != getDualSub()) {
+ throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
+ }
+ currentNext.setPrevious(null);
} else {
throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
}
setNext(null);
} else { //(previous != null)
} else {
throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
}
setNext(null);
} else { //(previous != null)
- if(previous.isDualInline()) {
+ if(currentPrev.isDualInline()) {
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
- } else if (previous.isDualSub()) {
- PipeControlPoint ocp = previous;
- PipeControlPoint sccp = ocp.getParentPoint();
+ } else if (currentPrev.isDualSub()) {
+ PipeControlPoint ocp = currentPrev;
+ PipeControlPoint sccp = currentPrev.getParentPoint();
if (sccp == null) {
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
}
if (sccp == null) {
throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
}
- } else if (previous.next == this) {
- previous.setNext(null);
+ assert(ocp.getNext() == null);
+ } else if (currentPrev.next == this) {
+ currentPrev.setNext(null);
} else {
throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
}
} else {
throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
}
if (getPipelineComponent() == null)
return true; // already removed
if (getPipelineComponent().getType().equals("Plant3D.URIs.Builtin_BranchSplitComponent")) {
if (getPipelineComponent() == null)
return true; // already removed
if (getPipelineComponent().getType().equals("Plant3D.URIs.Builtin_BranchSplitComponent")) {
- if (getSubPoint().get(0).getNext() == null && getSubPoint().get(0).getPrevious() == null) {
+ if (getChildPoints().get(0).getNext() == null && getChildPoints().get(0).getPrevious() == null) {
remove();
return true;
}
}
remove();
return true;
}
}
+ return checkRemove(getPipeRun());
- private void checkRemove(PipeRun pipeRun) {
+ private boolean checkRemove(PipeRun pipeRun) {
Collection<PipeControlPoint> points = pipeRun.getControlPoints();
if (points.size() == 0) {
pipeRun.remove();
Collection<PipeControlPoint> points = pipeRun.getControlPoints();
if (points.size() == 0) {
pipeRun.remove();
} else if (points.size() == 1) {
PipeControlPoint pcp = points.iterator().next();
} else if (points.size() == 1) {
PipeControlPoint pcp = points.iterator().next();
- if (pcp.isDeletable())
- pcp._remove();
- }
- }
-
- private void removeDualPoint() {
- if (previous != null)
- previous.setNext(null);
- if (next != null)
- next.setPrevious(null);
- PipeControlPoint ocp;
- PipeControlPoint sccp;
- if (isDualInline()) {
- sccp = this;
- ocp = getSubPoint().get(0);
- } else {
- ocp = this;
- sccp = getParentPoint();
+ if (pcp.isDeletable() && pcp.getNext() == null && pcp.getPrevious() == null) {
+ pcp._remove(); // This call will recursively call also this method...
+ return true;
+ }
- PipeRun p1 = ocp.getPipeRun();
- PipeRun p2 = sccp.getPipeRun();
-
- ocp.removeComponent();
- sccp.removeComponent();
-
- if (p1 != null)
- p1.remChild(ocp);
- if (p2 != null)
- p2.remChild(sccp);
-
- // TODO : now we assume that this is size change, and we do
- if (ocp.next != null)
- ocp.next.setPrevious(null);
- if (ocp.previous != null)
- ocp.previous.setNext(null);
- if (sccp.next != null)
- sccp.next.setPrevious(null);
- if (sccp.previous != null)
- sccp.previous.setNext(null);
- ocp.setNext(null);
- ocp.setPrevious(null);
- sccp.setNext(null);
- sccp.setPrevious(null);
-
- if (p1 != null)
- checkRemove(p1);
- if (p2 != null)
- checkRemove(p2);
}
private void removeSubPoints() {
for (PipeControlPoint p : children) {
}
private void removeSubPoints() {
for (PipeControlPoint p : children) {
- // TODO : this may affect delete routine, since classification of the point changes.
+ p.component = null;
+ //p._remove();
+ PipeControlPoint currentNext = p.getNext();
+ PipeControlPoint currentPrev = p.getPrevious();
+ p._setNext(null);
+ p._setPrevious(null);
+ PipeRun run = p.getPipeRun();
+ if (run != null) {
+ run.remChild(p);
+ checkRemove(run);
+ }
+ if (currentNext != null)
+ if (!currentNext.checkRemove())
+ PipingRules.requestUpdate(currentNext);
+ if (currentPrev != null)
+ if (!currentPrev.checkRemove())
+ PipingRules.requestUpdate(currentPrev);
+
private void updateSubPoint() {
if (isOffset()) {
if (next == null && previous == null) {
private void updateSubPoint() {
if (isOffset()) {
if (next == null && previous == null) {
- for (PipeControlPoint sub : getSubPoint()) {
+ for (PipeControlPoint sub : getChildPoints()) {
sub.setWorldPosition(getWorldPosition());
sub.setWorldOrientation(getWorldOrientation());
}
return;
}
sub.setWorldPosition(getWorldPosition());
sub.setWorldOrientation(getWorldOrientation());
}
return;
}
- for (PipeControlPoint sub : getSubPoint()) {
+ for (PipeControlPoint sub : getChildPoints()) {
Vector3d wp = getWorldPosition();
wp.add(getSizeChangeOffsetVector());
sub.setWorldPosition(wp);
sub.setWorldOrientation(getWorldOrientation());
}
} else {
Vector3d wp = getWorldPosition();
wp.add(getSizeChangeOffsetVector());
sub.setWorldPosition(wp);
sub.setWorldOrientation(getWorldOrientation());
}
} else {
- for (PipeControlPoint sub : getSubPoint()) {
+ for (PipeControlPoint sub : getChildPoints()) {
sub.setWorldPosition(getWorldPosition());
sub.setWorldOrientation(getWorldOrientation());
}
sub.setWorldPosition(getWorldPosition());
sub.setWorldOrientation(getWorldOrientation());
}
System.out.println("PipingRules.insertElbow() " + pcp1 + " " + pcp2 + " " + pos);
if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
System.out.println("PipingRules.insertElbow() " + pcp1 + " " + pcp2 + " " + pos);
if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
- } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getSubPoint().get(0)) {
- pcp1 = pcp1.getSubPoint().get(0);
+ } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) {
+ pcp1 = pcp1.getDualSub();
} else if (pcp1.getPrevious() == pcp2 && pcp2.getNext() == pcp1) {
PipeControlPoint t = pcp1;
pcp1 = pcp2;
pcp2 = t;
} else if (pcp1.getPrevious() == pcp2 && pcp2.getNext() == pcp1) {
PipeControlPoint t = pcp1;
pcp1 = pcp2;
pcp2 = t;
- } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getSubPoint().get(0) && pcp2.getNext() == pcp1) {
+ } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getDualSub() && pcp2.getNext() == pcp1) {
PipeControlPoint t = pcp1;
PipeControlPoint t = pcp1;
- pcp1 = pcp2.getSubPoint().get(0);
+ pcp1 = pcp2.getDualSub();
pcp2 = t;
} else {
throw new RuntimeException();
pcp2 = t;
} else {
throw new RuntimeException();
TurnComponent elbow = ComponentUtils.createTurn((P3DRootNode)pcp1.getRootNode());
PipeControlPoint pcp = elbow.getControlPoint();
if (pcp1.isDualInline())
TurnComponent elbow = ComponentUtils.createTurn((P3DRootNode)pcp1.getRootNode());
PipeControlPoint pcp = elbow.getControlPoint();
if (pcp1.isDualInline())
- pcp1 = pcp1.getSubPoint().get(0);
+ pcp1 = pcp1.getDualSub();
String name = pcp1.getPipeRun().getUniqueName("Elbow");
elbow.setName(name);
pcp1.getPipeRun().addChild(elbow);
String name = pcp1.getPipeRun().getUniqueName("Elbow");
elbow.setName(name);
pcp1.getPipeRun().addChild(elbow);
System.out.println("PipingRules.insertStraight() " + pcp1 + " " + pcp2 + " " + pos);
if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
System.out.println("PipingRules.insertStraight() " + pcp1 + " " + pcp2 + " " + pos);
if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
- } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getSubPoint().get(0)) {
- pcp1 = pcp1.getSubPoint().get(0);
+ } else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) {
+ pcp1 = pcp1.getDualSub();
} else if (pcp1.getPrevious() == pcp2 && pcp2.getNext() == pcp1) {
PipeControlPoint t = pcp1;
pcp1 = pcp2;
pcp2 = t;
} else if (pcp1.getPrevious() == pcp2 && pcp2.getNext() == pcp1) {
PipeControlPoint t = pcp1;
pcp1 = pcp2;
pcp2 = t;
- } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getSubPoint().get(0) && pcp2.getNext() == pcp1) {
+ } else if (pcp2.isDualInline() && pcp1.getPrevious() == pcp2.getDualSub() && pcp2.getNext() == pcp1) {
PipeControlPoint t = pcp1;
PipeControlPoint t = pcp1;
- pcp1 = pcp2.getSubPoint().get(0);
+ pcp1 = pcp2.getDualSub();
pcp2 = t;
} else {
throw new RuntimeException();
pcp2 = t;
} else {
throw new RuntimeException();
InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp1.getRootNode());
PipeControlPoint scp = component.getControlPoint();
if (pcp1.isDualInline())
InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp1.getRootNode());
PipeControlPoint scp = component.getControlPoint();
if (pcp1.isDualInline())
- pcp1 = pcp1.getSubPoint().get(0);
+ pcp1 = pcp1.getDualSub();
String name = pcp1.getPipeRun().getUniqueName("Pipe");
component.setName(name);
pcp1.getPipeRun().addChild(component);
String name = pcp1.getPipeRun().getUniqueName("Pipe");
component.setName(name);
pcp1.getPipeRun().addChild(component);
InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp.getRootNode());
PipeControlPoint scp = component.getControlPoint();
if (pcp.isDualInline() && direction == Direction.NEXT)
InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp.getRootNode());
PipeControlPoint scp = component.getControlPoint();
if (pcp.isDualInline() && direction == Direction.NEXT)
- pcp = pcp.getSubPoint().get(0);
+ pcp = pcp.getDualSub();
String name = pcp.getPipeRun().getUniqueName("Pipe");
component.setName(name);
pcp.getPipeRun().addChild(component);
String name = pcp.getPipeRun().getUniqueName("Pipe");
component.setName(name);
pcp.getPipeRun().addChild(component);
PipeControlPoint next = i < pathLegPoints.size() - 1 ? pathLegPoints.get(i + 1) : null;
if (prev != null && prev.isDualInline())
PipeControlPoint next = i < pathLegPoints.size() - 1 ? pathLegPoints.get(i + 1) : null;
if (prev != null && prev.isDualInline())
- prev = prev.getSubPoint().get(0);
+ prev = prev.getDualSub();
if (icp.isVariableLength()) {
if (icp.isVariableLength()) {
private static void updateOffsetPoint(PipeControlPoint sccp, Vector3d offset) {
Vector3d world = sccp.getWorldPosition();
world.add(offset);
private static void updateOffsetPoint(PipeControlPoint sccp, Vector3d offset) {
Vector3d world = sccp.getWorldPosition();
world.add(offset);
- PipeControlPoint ocp = sccp.getSubPoint().iterator().next();
+ PipeControlPoint ocp = sccp.getDualSub();
ocp.setWorldPosition(world);
}
ocp.setWorldPosition(world);
}
if (canCalc) {
boolean branchUpdate = false;
PipeControlPoint becp = null;
if (canCalc) {
boolean branchUpdate = false;
PipeControlPoint becp = null;
- for (PipeControlPoint pcp : icp.getSubPoint())
+ for (PipeControlPoint pcp : icp.getChildPoints())
if (pcp.isNonDirected()) {
branchUpdate = true;
becp = pcp;
if (pcp.isNonDirected()) {
branchUpdate = true;
becp = pcp;
//if (!ecp.isFixed())
updateControlPointOrientation(ecp);
//if (!ecp.isFixed())
updateControlPointOrientation(ecp);
- for (PipeControlPoint pcp : ecp.getSubPoint()) {
+ for (PipeControlPoint pcp : ecp.getChildPoints()) {
// TODO update position
updatePathLegEndControlPoint(pcp);
}
// TODO update position
updatePathLegEndControlPoint(pcp);
}
System.out.println("PipingRules.updateBranchControlPointBranches() " + bcp);
if (bcp.isDualInline())
return;
System.out.println("PipingRules.updateBranchControlPointBranches() " + bcp);
if (bcp.isDualInline())
return;
- Collection<PipeControlPoint> branches = bcp.getSubPoint();
+ Collection<PipeControlPoint> branches = bcp.getChildPoints();
if (branches.size() == 0) {
if (DEBUG)
System.out.println("No Branches found");
if (branches.size() == 0) {
if (DEBUG)
System.out.println("No Branches found");
while (true) {
List<PipeControlPoint> points = getControlPoints(pipeRun);
PipeControlPoint pcp = points.get(0);
while (true) {
List<PipeControlPoint> points = getControlPoints(pipeRun);
PipeControlPoint pcp = points.get(0);
- if (pcp.isSizeChange() && pcp.getSubPoint().size() > 0) {
+ if (pcp.isSizeChange() && pcp.getChildPoints().size() > 0) {
pipeRun = pcp.getPipeRun();
} else {
break;
pipeRun = pcp.getPipeRun();
} else {
break;
List<PipeControlPoint> points = getControlPoints(pipeRun);
pcps.add(points);
PipeControlPoint pcp = points.get(points.size()-1);
List<PipeControlPoint> points = getControlPoints(pipeRun);
pcps.add(points);
PipeControlPoint pcp = points.get(points.size()-1);
- if (pcp.getSubPoint().size() > 0) {
- pipeRun = pcp.getSubPoint().get(0).getPipeRun();
+ if (pcp.getChildPoints().size() > 0) {
+ pipeRun = pcp.getChildPoints().get(0).getPipeRun();
PipeControlPoint current = list.get(i);
PipeControlPoint currentSub = null;
if (current.isDualInline())
PipeControlPoint current = list.get(i);
PipeControlPoint currentSub = null;
if (current.isDualInline())
- currentSub = current.getSubPoint().get(0);
+ currentSub = current.getDualSub();
if (first) {
PipeControlPoint next = list.get(i+1);
if (next.isDualInline())
if (first) {
PipeControlPoint next = list.get(i+1);
if (next.isDualInline())
- next = next.getSubPoint().get(0);
+ next = next.getDualSub();
if (current.getNext() == next)
current.setNext(null);
current.setPrevious(next);
if (current.getNext() == next)
current.setNext(null);
current.setPrevious(next);
PipeControlPoint prev = list.get(i-1);
PipeControlPoint next = list.get(i+1);
if (next.isDualInline())
PipeControlPoint prev = list.get(i-1);
PipeControlPoint next = list.get(i+1);
if (next.isDualInline())
- next = next.getSubPoint().get(0);
+ next = next.getDualSub();
current.setPrevious(next);
current.setPrevious(next);
if (pcp.getParentPoint() == null) {
PipeControlPoint sub = null;
if (pcp.isDualInline())
if (pcp.getParentPoint() == null) {
PipeControlPoint sub = null;
if (pcp.isDualInline())
- sub = pcp.getSubPoint().get(0);
+ sub = pcp.getDualSub();
PipeControlPoint next = pcp.getNext();
PipeControlPoint prev = pcp.getPrevious();
if (next != null) {
PipeControlPoint next = pcp.getNext();
PipeControlPoint prev = pcp.getPrevious();
if (next != null) {
public static void addSizeChange(boolean reversed, PipeRun pipeRun, PipeRun other, InlineComponent reducer, PipeControlPoint previous, PipeControlPoint next) {
PipeControlPoint pcp = reducer.getControlPoint();
public static void addSizeChange(boolean reversed, PipeRun pipeRun, PipeRun other, InlineComponent reducer, PipeControlPoint previous, PipeControlPoint next) {
PipeControlPoint pcp = reducer.getControlPoint();
- PipeControlPoint ocp = pcp.getSubPoint().get(0);
+ PipeControlPoint ocp = pcp.getDualSub();
if (!reversed) {
String name = pipeRun.getUniqueName("Reducer");
reducer.setName(name);
if (!reversed) {
String name = pipeRun.getUniqueName("Reducer");
reducer.setName(name);
switch (position) {
case NEXT:
if (toPcp.isDualInline()) {
switch (position) {
case NEXT:
if (toPcp.isDualInline()) {
- toPcp = toPcp.getSubPoint().get(0);
+ toPcp = toPcp.getDualSub();
pipeRun = toPcp.getPipeRun();
}
pipeRun = toPcp.getPipeRun();
}
switch (position) {
case NEXT:
if (toPcp.isDualInline())
switch (position) {
case NEXT:
if (toPcp.isDualInline())
- toPcp = toPcp.getSubPoint().get(0);
+ toPcp = toPcp.getDualSub();
newPcp.insert(toPcp, Direction.NEXT);
newPcp.setWorldPosition(pos);
break;
newPcp.insert(toPcp, Direction.NEXT);
newPcp.setWorldPosition(pos);
break;