]> gerrit.simantics Code Review - simantics/3d.git/blob - org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipeControlPoint.java
Revised update logic for inline components
[simantics/3d.git] / org.simantics.plant3d / src / org / simantics / plant3d / scenegraph / controlpoint / PipeControlPoint.java
1 package org.simantics.plant3d.scenegraph.controlpoint;
2
3 import java.util.ArrayList;
4 import java.util.Arrays;
5 import java.util.Collection;
6 import java.util.List;
7
8 import javax.vecmath.AxisAngle4d;
9 import javax.vecmath.Matrix3d;
10 import javax.vecmath.Point3d;
11 import javax.vecmath.Quat4d;
12 import javax.vecmath.Tuple3d;
13 import javax.vecmath.Vector3d;
14
15 import org.simantics.g3d.math.MathTools;
16 import org.simantics.g3d.property.annotations.GetPropertyValue;
17 import org.simantics.g3d.scenegraph.G3DNode;
18 import org.simantics.plant3d.scenegraph.IP3DNode;
19 import org.simantics.plant3d.scenegraph.Nozzle;
20 import org.simantics.plant3d.scenegraph.P3DRootNode;
21 import org.simantics.plant3d.scenegraph.PipeRun;
22 import org.simantics.plant3d.scenegraph.PipelineComponent;
23
24 import vtk.vtkRenderer;
25
26
27 public class PipeControlPoint extends G3DNode implements IP3DNode {
28
29         private static boolean DEBUG = false;
30
31         public enum PointType{INLINE,TURN,END};
32         public enum Direction{NEXT,PREVIOUS};
33         public enum PositionType {SPLIT,NEXT,PREVIOUS,PORT}
34
35         private PipelineComponent component;
36
37         private PointType type;
38         private boolean isFixed = true;        // In-line: fixed-length Turn: fixed-angle
39         private boolean isMod = false;         // Can user modify fixed value manually 
40         private boolean isRotate = false;      // rotates around path leg axis.
41         private boolean isReverse = false;     // definition direction can be swapped
42         private boolean isDeletable = true;    // can be removed by rules
43         private boolean isSizeChange = false;  // changes size of the pipe. The next control point / component is on different PipeRun
44         private boolean isSub = false;         // child point for offset / size change
45
46         private boolean disposed = false;
47         
48         public PipeControlPoint(PipelineComponent component) {
49                 this.component = component;
50                 if (component.getPipeRun() != null)
51                         component.getPipeRun().addChild(this);
52
53         }
54
55         public PipeControlPoint(PipelineComponent component, PipeRun piperun) {
56                 this.component = component;
57                 piperun.addChild(this);
58         }
59
60         @Override
61         public void update(vtkRenderer ren) {
62                 try {
63                         PipingRules.requestUpdate(this);
64                 } catch (Exception e) {
65                         e.printStackTrace();
66                 }
67
68         }
69
70         public PipeRun getPipeRun() {
71                 return (PipeRun)getParent();
72         }
73
74         public PipelineComponent getPipelineComponent() {
75                 return component;
76         }
77
78         public PointType getType() {
79                 return type;
80         }
81
82         public void setType(PointType type) {
83                 this.type = type;
84         }
85
86         @GetPropertyValue(name="Fixed",tabId="Debug",value="fixed")
87         public boolean isFixed() {
88                 return isFixed;
89         }
90
91         public void setFixed(boolean fixed) {
92                 this.isFixed = fixed;
93         }
94         
95         @GetPropertyValue(name="Mod",tabId="Debug",value="mod")
96         public boolean isMod() {
97         return isMod;
98     }
99     
100     public void setMod(boolean isMod) {
101         this.isMod = isMod;
102     }
103
104         @GetPropertyValue(name="Rotate",tabId="Debug",value="rotate")
105         public boolean isRotate() {
106                 return isRotate;
107         }
108
109         public void setRotate(boolean rotate) {
110                 this.isRotate = rotate;
111         }
112
113         @GetPropertyValue(name="Reverse",tabId="Debug",value="reverse")
114         public boolean isReverse() {
115                 return isReverse;
116         }
117
118         public void setReverse(boolean reverse) {
119                 this.isReverse = reverse;
120         }
121
122         public void setSub(boolean sub) {
123                 this.isSub = sub;
124         }
125
126         @GetPropertyValue(name="Deletable",tabId="Debug",value="deletable")
127         public boolean isDeletable() {
128                 return isDeletable;
129         }
130
131         public void setDeletable(boolean deletable) {
132                 this.isDeletable = deletable;
133         }
134
135         public boolean isPathLegEnd() {
136                 return type != PointType.INLINE;
137         }
138
139         public boolean isEnd() {
140                 return type == PointType.END;
141         }
142
143         public boolean isTurn() {
144                 return type == PointType.TURN;
145         }
146
147         public boolean isInline() {
148                 return type == PointType.INLINE;
149         }
150         
151         public boolean asPathLegEnd() {
152             // Ends and Turns are path leg ends by default, but also unconnected inline are path leg ends.
153             return isPathLegEnd() || getNext() == null || getPrevious() == null;
154         }
155
156         /**
157          * True for end components, if control point defines absolute position direction, which rules cannot modify. 
158          * This is typical for nozzles.
159          * @return
160          */
161         public boolean isDirected() {
162                 return isFixed && isEnd();
163         }
164
165         /**
166      * True for end components, if control is opposite to directed, and rules can modify position and orientation.
167      * This is typical for caps, and other end components.
168      * @return
169      */
170         public boolean isNonDirected() {
171                 return !isFixed && isEnd();
172         }
173
174         public boolean isVariableLength() {
175                 return !isFixed && isInline();
176         }
177         
178         /**
179          * Fixed length in-line component is such that piping rules cannot modify the length.
180          * @return
181          */
182         public boolean isFixedLength() {
183         return isFixed && isInline();
184     }
185
186         public boolean isVariableAngle() {
187                 return !isFixed && isTurn();
188         }
189         
190         /**
191          * Fixed angle turn component is such that piping rules cannot modify the angle.
192          * @return
193          */
194         public boolean isFixedAngle() {
195         return isFixed && isTurn();
196     }
197         
198         /**
199          * Does the turn behave like fixed angle?
200          * For variable angle turns, the turn angle is defined by connected components, and without them, we must handle the component as fixed angle. 
201          * @return
202          */
203         public boolean asFixedAngle() {
204         return isTurn() && (isFixed || next == null || previous == null);
205     }
206
207         public boolean isBranchEnd() {
208                 return isDeletable && isEnd();
209         }
210
211         public boolean isOffset() {
212                 return offset != null;
213         }
214
215         public boolean isDualSub() {
216                 return parent != null && isSub;
217         }
218
219         public boolean isDualInline() {
220                 return children.size() == 1 && children.get(0).isDualSub();
221         }
222
223         public boolean isAxial() {
224                 return isInline() && !isDualInline();
225         }
226
227         public boolean isSizeChange() {
228                 return isSizeChange;
229                 //              if (children.size() == 0)
230                 //                      return false;
231                 //              if (!isDualInline())
232                 //                      return false;
233                 //              return getPipeRun() != children.get(0).getPipeRun();
234         }
235
236         public void setSizeChange(boolean isSizeChange) {
237                 this.isSizeChange = isSizeChange;
238         }
239
240
241         private PipeControlPoint next;
242         private PipeControlPoint previous;
243
244         public PipeControlPoint getNext() {
245                 return next;
246         }
247
248         public PipeControlPoint getPrevious() {
249                 return previous;
250         }
251
252         public void setNext(PipeControlPoint next) {
253             if (isSub) {
254                 getParentPoint().setNext(next);
255                 return;
256             }
257             if (next != null && next.isDualSub())
258                 next = next.parent;
259             if (_setNext(next)) {
260                 for (PipeControlPoint pcp : children) {
261                 if (pcp.isSub)
262                     pcp._setNext(next);
263             }
264                 updateSubPoint();
265             }
266         }
267         
268         public void setPrevious(PipeControlPoint prev) {
269         if (isSub) {
270             getParentPoint().setPrevious(prev);
271             return;
272         }
273         if (prev != null && prev.isDualInline())
274             prev = prev.children.get(0);
275         if (_setPrevious(prev)) {
276             for (PipeControlPoint pcp : children) {
277                 if (pcp.isSub)
278                     pcp._setPrevious(prev);
279             }
280             updateSubPoint();
281         }
282     }
283         
284         protected boolean _setNext(PipeControlPoint next) {
285                 if (isEnd() && previous != null && next != null)
286                         throw new RuntimeException("End control points are allowed to have only one connection");
287                 if (next == this)
288                         throw new RuntimeException("Cannot connect to self");
289                 if (this.next == next)
290                         return false;
291                 if (DEBUG) System.out.println(this + " next " + next);
292                 if (next == null && isVariableAngle() && previous != null && !isRemoved()) {
293                     convertVariableAngleToFixed(Direction.NEXT);
294                 }
295                 this.next = next;
296                 if (component != null) {
297                         if (parent == null || isSub)
298                                 component.setNext(next != null ? next.component : null);
299                         else
300                                 component.setBranch0(next != null ? next.component : null);
301                         
302                 }
303                 return true;
304         }
305
306         protected boolean _setPrevious(PipeControlPoint previous) {
307                 if (isEnd() && next != null && previous != null)
308                         throw new RuntimeException("End control points are allowed to have only one connection");
309                 if (previous == this)
310                         throw new RuntimeException("Cannot connect to self");
311                 if (this.previous == previous)
312                         return false;
313                 if (DEBUG) System.out.println(this + " previous " + previous);
314                 if (previous == null && isVariableAngle() && next != null && !isRemoved()) {
315             convertVariableAngleToFixed(Direction.PREVIOUS);
316         }
317                 this.previous = previous;
318                 if (component != null) {
319                         if (parent == null || isSub)
320                                 component.setPrevious(previous != null ? previous.component : null);
321                         else
322                                 component.setBranch0(previous != null ? previous.component : null);
323                         updateSubPoint();
324                 }
325                 return true;
326         }
327         
328         private void convertVariableAngleToFixed(Direction direction) {
329             // We are removing reference, which transforms variable angle to fixed angle.
330         // Since fixed angle is defined differently, we need to calculate fixed angle parameters based on current data
331         // We need to calculate turnAngle and rotationAngle
332             Vector3d dirOut = getPathLegDirection(direction == Direction.NEXT ? Direction.NEXT : Direction.PREVIOUS);
333         Vector3d dir = getPathLegDirection(direction == Direction.NEXT ? Direction.PREVIOUS : Direction.NEXT);
334         dir.negate();
335         dirOut.normalize();
336         dir.normalize();
337         double angle = dir.angle(dirOut);
338         //super._setNext(null);
339         if (direction == Direction.NEXT)
340             next = null;
341         else
342             previous = null;
343         setRotationAngle(0.0);
344         setReversed(direction == Direction.NEXT ? false : true);
345         Vector3d dirOutN = getPathLegDirection(direction == Direction.NEXT ? Direction.NEXT : Direction.PREVIOUS);
346         dirOutN.normalize();
347         AxisAngle4d aa = new AxisAngle4d();
348         if (MathTools.createRotation(dirOutN, dirOut, dir, aa)) {
349             setRotationAngle(aa.angle);
350             setTurnAngle(angle);
351             if (DEBUG) System.out.println("convertToFixed " + dir + " " + dirOut + " " +dirOutN + " " +angle + " "+ aa.angle);
352         }
353         }
354
355         public PipeControlPoint parent;
356         public List<PipeControlPoint> children = new ArrayList<PipeControlPoint>();
357
358         public List<PipeControlPoint> getChildPoints() {
359                 return children;
360         }
361
362         public PipeControlPoint getParentPoint() {
363                 return parent;
364         }
365
366
367         private double length;
368         private Double turnAngle;
369         private Vector3d turnAxis;
370
371         private Double offset;
372         private Double rotationAngle;
373         private Boolean reversed;
374
375         @GetPropertyValue(name="Length",tabId="Debug",value="length")
376         public double getLength() {
377                 return length;
378         }
379
380         public void setLength(double l) {
381                 if (Double.isInfinite(l) || Double.isNaN(l)) {
382                         return;
383                 }
384                 if (Math.abs(this.length-l) < MathTools.NEAR_ZERO)
385                         return;
386                 this.length = l;
387                 firePropertyChanged("length");
388                 if (isDualInline())
389                     getDualSub().setLength(l);
390         }
391
392         @GetPropertyValue(name="Turn Angle",tabId="Debug",value="turnAngle")
393         public Double getTurnAngle() {
394                 return turnAngle;
395         }
396
397         @GetPropertyValue(name="Turn Axis",tabId="Debug",value="turnAxis")
398         public Vector3d getTurnAxis() {
399                 return turnAxis;
400         }
401
402         @GetPropertyValue(name="Offset",tabId="Debug",value="offset")
403         public Double getOffset() {
404                 return offset;
405         }
406
407         @GetPropertyValue(name="Rotation Angle",tabId="Debug",value="rotationAngle")
408         public Double getRotationAngle() {
409             if (isRotate || asFixedAngle())
410                 return rotationAngle;
411             return null;
412         }
413
414         @GetPropertyValue(name="Reversed",tabId="Debug",value="reversed")
415         public Boolean getReversed() {
416                 return reversed;
417         }
418
419         public boolean _getReversed() {
420                 if (reversed == null)
421                         return false;
422                 return reversed;
423         }
424
425         public void setTurnAngle(Double turnAngle) {
426                 if (turnAngle == null || Double.isInfinite(turnAngle) || Double.isNaN(turnAngle)) {
427                         return;
428                 }
429                 if (this.turnAngle != null && Math.abs(this.turnAngle-turnAngle) < MathTools.NEAR_ZERO)
430                         return;
431                 this.turnAngle = turnAngle;
432                 firePropertyChanged("turnAngle");
433         }
434
435         public void setTurnAxis(Vector3d turnAxis) {
436                 if (this.turnAxis != null && MathTools.equals(turnAxis, this.turnAxis))
437                         return;
438                 this.turnAxis = turnAxis;
439                 firePropertyChanged("turnAxis");
440         }
441
442         public void setOffset(Double offset) {
443                 if (Double.isInfinite(offset) || Double.isNaN(offset)) {
444                         return;
445                 }
446                 if (this.offset != null && Math.abs(this.offset-offset) < MathTools.NEAR_ZERO)
447                         return;
448                 this.offset = offset;
449                 firePropertyChanged("offset");
450         }
451
452         public void setRotationAngle(Double rotationAngle) {
453                 if (Double.isInfinite(rotationAngle) || Double.isNaN(rotationAngle)) {
454                         return;
455                 }
456                 if (this.rotationAngle != null && Math.abs(this.rotationAngle-rotationAngle) < MathTools.NEAR_ZERO)
457                         return;
458                 this.rotationAngle = rotationAngle;
459                 firePropertyChanged("rotationAngle");
460         }
461
462         public void setReversed(Boolean reversed) {
463                 this.reversed = reversed;
464                 firePropertyChanged("reversed");
465         }
466
467         public Vector3d getSizeChangeOffsetVector(Vector3d dir) {
468                 Quat4d q;
469                 if (rotationAngle == null)
470                         q = getControlPointOrientationQuat(dir, 0.0);
471                 else
472                         q = getControlPointOrientationQuat(dir, rotationAngle);
473                 Vector3d v = new Vector3d(0.0,offset,0.0);
474                 Vector3d offset = new Vector3d();
475                 MathTools.rotate(q, v, offset);
476                 return offset;
477         }
478
479         public Vector3d getSizeChangeOffsetVector() {
480                 Quat4d q;
481                 if (rotationAngle == null)
482                         q = getControlPointOrientationQuat(0.0);
483                 else
484                         q = getControlPointOrientationQuat(rotationAngle);
485                 Vector3d v = new Vector3d(0.0,offset,0.0);
486                 Vector3d offset = new Vector3d();
487                 MathTools.rotate(q, v, offset);
488                 return offset;
489         }
490
491         @GetPropertyValue(name="Next",tabId="Debug",value="next")
492         private String getNextString() {
493                 if (next == null)
494                         return null;
495                 return next.toString();
496         }
497
498         @GetPropertyValue(name="Previous",tabId="Debug",value="previous")
499         private String getPrevString() {
500                 if (previous == null)
501                         return null;
502                 return previous.toString();
503         }
504
505         @GetPropertyValue(name="Sub",tabId="Debug",value="sub")
506         private String getSubString() {
507                 if (children.size() == 0)
508                         return "";
509                 return Arrays.toString(children.toArray());
510         }
511
512         @GetPropertyValue(name="Type",tabId="Debug",value="type")
513         public String getTypeString() {
514                 return type.name();
515         }
516
517         public Quat4d getControlPointOrientationQuat(double angle) {
518
519                 if (turnAxis == null) {
520                         Vector3d dir = getPathLegDirection(Direction.NEXT);
521                         if (dir.lengthSquared() > MathTools.NEAR_ZERO)
522                                 dir.normalize();
523                         return getControlPointOrientationQuat(dir, angle);
524                 } else {
525                         Vector3d dir = getPathLegDirection(Direction.PREVIOUS);
526                         dir.negate();
527                         if (dir.lengthSquared() > MathTools.NEAR_ZERO)
528                                 dir.normalize();
529                         return getControlPointOrientationQuat(dir, turnAxis, angle);
530                 }
531         }
532         
533         public Quat4d getControlPointOrientationQuat(Vector3d dir, double angle, boolean reversed) {
534             if (turnAxis == null) {
535             if (dir.lengthSquared() > MathTools.NEAR_ZERO)
536                 dir.normalize();
537             Quat4d q =  getControlPointOrientationQuat(dir, angle);
538             if (reversed) {
539                 Quat4d q2 = new Quat4d();
540                 q2.set(new AxisAngle4d(MathTools.Y_AXIS, Math.PI));
541                 q.mulInverse(q2);
542             }
543             return q;
544         } else {
545             if (dir.lengthSquared() > MathTools.NEAR_ZERO)
546                 dir.normalize();
547             return getControlPointOrientationQuat(dir, turnAxis, angle);
548         }
549         }
550
551         public Quat4d getControlPointOrientationQuat(double angle, boolean reversed) {
552
553                 if (turnAxis == null) {
554                         Vector3d dir = getPathLegDirection(Direction.NEXT);
555                         return getControlPointOrientationQuat(dir, angle, reversed);
556                 } else {
557                         Vector3d dir = getPathLegDirection(Direction.PREVIOUS);
558                         dir.negate();
559                         return getControlPointOrientationQuat(dir, angle, reversed);
560                 }
561         }
562
563
564
565         public static Quat4d getControlPointOrientationQuat(Vector3d dir, double angle) {
566                 if (dir.lengthSquared() < MathTools.NEAR_ZERO)
567                         return MathTools.getIdentityQuat();
568
569
570                 Vector3d up = new Vector3d(0.0, 1.0, 0.0);
571                 double a = up.angle(dir);
572                 if (a < 0.1 || (Math.PI - a) < 0.1) {
573                         up.set(1.0, 0.0, 0.0);
574                 }
575
576
577                 return getControlPointOrientationQuat(dir, up, angle);
578         }
579
580         public static Quat4d getControlPointOrientationQuat(Vector3d dir, Vector3d up,  double angle) {
581                 if (dir.lengthSquared() < MathTools.NEAR_ZERO)
582                         return MathTools.getIdentityQuat();
583
584                 final Vector3d front = new Vector3d(1.0,0.0,0.0);
585
586                 Quat4d q1 = new Quat4d();
587
588
589                 Vector3d right = new Vector3d();
590
591                 right.cross(dir, up);
592                 up.cross(right, dir);
593                 right.normalize();
594                 up.normalize();
595
596                 Matrix3d m = new Matrix3d();
597                 m.m00 = dir.x;
598                 m.m10 = dir.y;
599                 m.m20 = dir.z;
600                 m.m01 = up.x;
601                 m.m11 = up.y;
602                 m.m21 = up.z;
603                 m.m02 = right.x;
604                 m.m12 = right.y;
605                 m.m22 = right.z;
606
607                 //q1.set(m); MathTools contains more stable conversion
608                 MathTools.getQuat(m, q1);
609
610                 //                      if (DEBUG) System.out.println("PipingTools.getPipeComponentOrientationQuat() " + dir+ " " + up + " " + right);
611
612                 Quat4d q2 = new Quat4d();
613                 q2.set(new AxisAngle4d(front, angle));
614                 q1.mul(q2);
615                 return q1;
616         }
617
618         public void insert(PipeControlPoint previous, PipeControlPoint next) {
619                 // inserting an offsetpoint is error, 
620                 if (isDualSub())
621                         throw new RuntimeException("Dual sub points cannot be inserted.");
622                 // size change control point cannot be inserted this way, because it ends PipeRun
623                 if (isSizeChange())
624                         throw new RuntimeException("Size change points cannot be inserted.");
625                 PipeRun piperun = previous.getPipeRun();
626                 // and just to make sure that control point structure is not corrupted
627                 if (getPipeRun() != null) {
628                         if (piperun != getPipeRun() || piperun != next.getPipeRun())
629                                 throw new RuntimeException("All controls points must be located on the same pipe run");
630                 } else {
631                         piperun.addChild(this);
632                 }
633
634                 // insert new BranchControlPoint between straight's control points
635                 PipeControlPoint previousNext = previous.getNext();
636                 PipeControlPoint previousPrevious = previous.getPrevious();
637
638                 PipeControlPoint offsetCP = null;
639                 if (isOffset()) {
640                         offsetCP = getDualSub();
641                 }
642                 if (previousNext != null && previousNext == next) {
643                         if (previous.isDualInline()) {
644                                 throw new RuntimeException();
645                         }
646                         if (next.isDualSub()) {
647                                 throw new RuntimeException();
648                         }
649                         previous.setNext(this);
650                         this.setPrevious(previous);
651                         if (previous.isDualSub()) {
652                                 previous.getParentPoint().setNext(this);
653                         }
654                         this.setNext(next);
655
656                         if (offsetCP == null) {
657                                 next.setPrevious(this);
658                         } else {
659                                 next.setPrevious(offsetCP);
660                                 offsetCP.setNext(next);
661                                 offsetCP.setPrevious(previous);
662                         }
663
664                         if (next.isDualInline()) {
665                                 next.getDualSub().setPrevious(this);
666                         }
667                 } else if (previousPrevious != null && previousPrevious == next) {
668                         // control point were given in reverse order 
669                         if (next.isDualInline())
670                                 throw new RuntimeException();
671                         if (previous.isDualSub())
672                                 throw new RuntimeException();
673
674                         this.setNext(previous);
675                         if (offsetCP == null) {
676                                 previous.setNext(this);
677                         } else {
678                                 previous.setPrevious(offsetCP);
679                                 offsetCP.setNext(previous);
680                                 offsetCP.setPrevious(next);
681                         }
682                         if (previous.isDualInline()) {
683                                 previous.getDualSub().setPrevious(this);
684                         }
685                         this.setPrevious(next);
686                         next.setNext(this);
687                         if (next.isDualSub()) {
688                                 next.getParentPoint().setNext(this);
689                         }
690
691                 } else {
692                         throw new RuntimeException();
693                 }       
694
695                 PipingRules.validate(piperun);
696         }
697
698
699
700         public void insert(PipeControlPoint pcp, Direction direction) {
701                 if (isDualSub())
702                         throw new RuntimeException();
703                 if (direction == Direction.NEXT) {
704                         // if direction is next, user must have given OffsetPoint
705                         if (pcp.isDualInline())
706                                 throw new RuntimeException();
707                         // basic next/prev links
708                         pcp.setNext(this);
709                         this.setPrevious(pcp);
710                         // and last take care of sizechange / offset points
711                         if (pcp.isDualSub()) {
712                                 pcp.getParentPoint().setNext(this);
713                         }
714                         if (isDualInline()) {
715                             getDualSub().setPrevious(this);
716                         }
717                 } else {
718                         // if direction is previous, user must have given sizechange
719                         if (pcp.isDualSub())
720                                 throw new RuntimeException();
721                         // previous direction is more complicated, since if newCP is SizeChangeControlPoint,
722                         // we must link pcp to newCP's OffsetPoint
723                         PipeControlPoint nocp = null;
724                         if (isDualInline()) {
725                                 nocp = getDualSub();
726                                 nocp.setNext(pcp);
727                         }
728                         if (nocp == null) {
729                                 pcp.setPrevious(this);
730                         } else {
731                                 pcp.setPrevious(nocp);
732                         }
733                         this.setNext(pcp);
734                         if (pcp.isDualInline()) {
735                                 PipeControlPoint ocp = pcp.getDualSub();
736                                 if (nocp == null)
737                                         ocp.setPrevious(this);
738                                 else
739                                         ocp.setPrevious(nocp);
740                         }
741
742                 }
743                 PipingRules.validate(getPipeRun());
744         }
745
746         public Vector3d getDirectedControlPointDirection() {
747                 assert (isDirected());
748                 Vector3d dir = new Vector3d();
749                 MathTools.rotate(getWorldOrientation(), new Vector3d(1.0, 0.0, 0.0), dir);
750                 dir.normalize();
751                 return dir;
752         }
753         
754         public Vector3d getDirection(Direction direction) {
755         if (isDirected())
756             return getDirectedControlPointDirection();
757         if (isTurn() && asFixedAngle()) {
758             if (direction == Direction.NEXT) {
759                 if (previous != null) {
760                     PipeControlPoint pcp = this;
761                     Vector3d dir = new Vector3d();
762                     dir.sub(pcp.getWorldPosition(),previous.getWorldPosition());
763                     if (dir.lengthSquared() > MathTools.NEAR_ZERO)
764                         dir.normalize();
765                     else
766                         return null;
767                     Quat4d q = getControlPointOrientationQuat(dir, pcp.getRotationAngle() != null ? pcp.getRotationAngle() : 0.0);
768                     AxisAngle4d aa = new AxisAngle4d(MathTools.Y_AXIS,pcp.getTurnAngle() == null ? 0.0 : pcp.getTurnAngle());
769                     Quat4d q2 = MathTools.getQuat(aa);
770                     Vector3d v = new Vector3d(1.,0.,0.);
771                     Vector3d offset = new Vector3d();
772                     MathTools.rotate(q2, v, offset);
773                     MathTools.rotate(q, offset, dir);
774                     return dir;
775                 }
776             } else {
777                 if (next != null) {
778                     PipeControlPoint pcp = this;
779                     Vector3d dir = new Vector3d();
780                     dir.sub(next.getWorldPosition(),pcp.getWorldPosition());
781                     if (dir.lengthSquared() > MathTools.NEAR_ZERO)
782                         dir.normalize();
783                     else
784                         return null;
785                     Quat4d q = getControlPointOrientationQuat(dir, pcp.getRotationAngle() != null ? pcp.getRotationAngle() : 0.0);
786                     AxisAngle4d aa = new AxisAngle4d(MathTools.Y_AXIS,pcp.getTurnAngle() == null ? 0.0 : pcp.getTurnAngle());
787                     Quat4d q2 = MathTools.getQuat(aa);
788                     Vector3d v = new Vector3d(1.,0.,0.);
789                     Vector3d offset = new Vector3d();
790                     MathTools.rotate(q2, v, offset);
791                     MathTools.rotate(q, offset, dir);
792                     return dir;
793                 }
794             }
795         }
796         return null;
797     }
798
799         public Vector3d getPathLegDirection(Direction direction) {
800                 if (direction == Direction.NEXT) {
801                         if (next != null) {
802                                 PipeControlPoint pcp = this;
803                                 if (pcp.isDualInline()) {
804                                         pcp = pcp.getDualSub();
805                                 }
806                                 Vector3d v = new Vector3d();
807                                 v.sub(next.getWorldPosition(),pcp.getWorldPosition());
808                                 return v;
809                         } else {
810                                 if (previous == null) {
811                                         if (!isDirected())
812                                                 throw new RuntimeException("Cannot calculate path leg direction for unconnected control point " + this);
813                                         return getDirectedControlPointDirection();
814
815                                 } else {
816                                         if (isVariableAngle() && !asFixedAngle())
817                                                 throw new RuntimeException("Cannot calculate path leg direction for unconnected variable angle control point " + this);
818                                         if (isInline()) {
819                                                 PipeControlPoint pcp = this;
820                                                 if (pcp.isDualSub()) {
821                                                         pcp = pcp.getParentPoint();
822                                                 }
823                                                 Vector3d v = new Vector3d();
824                                                 v.sub(pcp.getWorldPosition(),previous.getWorldPosition());
825                                                 return v;
826                                         } else if (isDirected()) {
827                                                 return getDirectedControlPointDirection();
828                                         } else if (isEnd()) {
829                                                 Vector3d v = new Vector3d();
830                                                 v.sub(getWorldPosition(),previous.getWorldPosition());
831                                                 return v;
832                                         } else if (isTurn() && asFixedAngle() && !_getReversed()) {
833                                                 return getDirection(Direction.NEXT);
834                                         }
835                                         throw new RuntimeException("Missing implementation " + this);
836                                 }
837                         }
838                 } else {
839                         if (previous != null) {
840                                 PipeControlPoint pcp = this;
841                                 if (isDualSub()) 
842                                         pcp = getParentPoint();
843                                 Vector3d v = new Vector3d();
844                                 v.sub(previous.getWorldPosition(),pcp.getWorldPosition());
845                                 return v;
846                         } else {
847                                 if (next == null)  {
848                                         if (!isDirected())
849                                                 throw new RuntimeException("Cannot calculate path leg direction for unconnected control point " + this);
850                                         Vector3d v = getDirectedControlPointDirection();
851                                         v.negate();
852                                         return v;
853                                 } else {
854                                         if (isVariableAngle() && !asFixedAngle())
855                                                 throw new RuntimeException("Cannot calculate path leg direction for unconnected variable angle control point " + this);
856                                         if (isInline()) {
857                                                 PipeControlPoint pcp = this;
858                                                 if (pcp.isDualInline()) {
859                                                         pcp = pcp.getDualSub();
860                                                 }
861                                                 Vector3d v = new Vector3d();
862                                                 v.sub(pcp.getWorldPosition(),next.getWorldPosition());
863                                                 return v;
864                                         } else if (isDirected()) {
865                                                 Vector3d v = getDirectedControlPointDirection();
866                                                 v.negate();
867                                                 return v;
868                                         } else if (isEnd()) {
869                                                 Vector3d v = new Vector3d();
870                                                 v.sub(getWorldPosition(),next.getWorldPosition());
871                                                 return v;
872                                         } else if (isTurn() && asFixedAngle() && _getReversed()) {
873                                                 return getDirection(Direction.PREVIOUS);
874                                         }
875                                         throw new RuntimeException("Missing implementation " + this);
876                                 }
877                         }
878                 }
879         }
880
881         public void getInlineControlPointEnds(Tuple3d p1, Tuple3d p2) {
882                 assert (isInline());
883
884                 PipeControlPoint sub = isAxial() ? this : getDualSub();
885                 Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
886                 Vector3d dir = sub.getPathLegDirection(Direction.NEXT);
887                 
888                 dir.normalize();
889                 dir.scale(length * 0.5);
890                 p1.set(pos);
891                 p2.set(pos2);
892                 p1.sub(dir);
893                 p2.add(dir);
894         }
895
896         public void getControlPointEnds(Tuple3d p1, Tuple3d p2) {
897                 PipeControlPoint sub = isAxial() || isDirected() || isTurn() ? this : getChildPoints().get(0);
898                 Vector3d pos = getWorldPosition(), pos2 = sub == this ? pos : sub.getWorldPosition();
899                 
900                 Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
901                 dir1.normalize();
902                 Vector3d dir2 = sub.getPathLegDirection(Direction.NEXT);
903                 dir2.normalize();
904                 if (isInline()) {
905                         dir1.scale(length * 0.5);
906                         dir2.scale(length * 0.5);
907                 } else {
908                         dir1.scale(length);
909                         dir2.scale(length);
910                 }
911                 p1.set(pos);
912                 p2.set(pos2);
913                 p1.add(dir1);
914                 p2.add(dir2);
915         }
916
917         public void getEndDirections(Tuple3d v1, Tuple3d v2) {
918                 PipeControlPoint sub = isAxial() ? this : getDualSub();
919                 
920                 Vector3d dir1 = getPathLegDirection(Direction.PREVIOUS);
921                 dir1.normalize();
922                 Vector3d dir2 = sub.getPathLegDirection(Direction.NEXT);
923                 dir2.normalize();
924                 v1.set(dir1);
925                 v2.set(dir2);
926         }
927
928         public void getInlineControlPointEnds(Tuple3d p1, Tuple3d p2, Vector3d dir) {
929                 assert (isInline());
930
931                 Vector3d pos = getWorldPosition();
932                 dir.set(getPathLegDirection(Direction.NEXT));
933                 dir.normalize();
934                 dir.scale(length * 0.5);
935                 p1.set(pos);
936                 p2.set(pos);
937                 p1.sub(dir);
938                 p2.add(dir);
939         }
940
941         public void getInlineControlPointEnds(Tuple3d center, Tuple3d p1, Tuple3d p2, Vector3d dir) {
942                 assert (isInline());
943
944                 Vector3d pos = getWorldPosition();
945                 center.set(pos);
946                 dir.set(getPathLegDirection(Direction.NEXT));
947                 dir.normalize();
948                 dir.scale(length * 0.5);
949                 p1.set(pos);
950                 p2.set(pos);
951                 p1.sub(dir);
952                 p2.add(dir);
953         }
954
955         public double getInlineLength() {
956                 if (type == PointType.TURN)
957                         return length;
958                 else if (type == PointType.INLINE)
959                         return length * 0.5;
960                 return 0;
961         }
962
963         public Vector3d getRealPosition(PositionType type) {
964                 Vector3d pos = getWorldPosition();
965                 switch (type) {
966                 case NEXT: {
967                         Vector3d dir = getPathLegDirection(Direction.NEXT);
968                         double length = getInlineLength();
969                         dir.normalize();
970                         dir.scale(length);
971                         pos.add(dir);
972                         break;
973                 }
974                 case PREVIOUS: {
975                         Vector3d dir = getPathLegDirection(Direction.PREVIOUS);
976                         double length = getInlineLength();
977                         dir.normalize();
978                         dir.scale(length);
979                         pos.add(dir);
980                         break;
981                 }
982                 case PORT:
983                         // IEntity portDir = pcp.getSingleRelatedObject(ProcessResource.plant3Dresource.HasDirection);
984                         // TODO : how we calculated needed space for a port; does it has an offset from control point's position or not?
985                         break;
986                 case SPLIT:
987                         // do nothing
988                         break;
989
990                 }
991                 return pos;
992         }
993
994         public void getInlineMovement(Tuple3d start, Tuple3d end) {
995                 // FIXME : check type of neighbor components and allow movement on top of variable length components,
996                 //         find proper range for movement (pcp's position is not)
997                 PipeControlPoint p = previous.getPrevious();
998                 PipeControlPoint n = next.getNext();
999                 start.set(p.getWorldPosition());
1000                 end.set(n.getWorldPosition());
1001         }
1002
1003         public PipeControlPoint findNextEnd() {
1004                 ArrayList<PipeControlPoint> t = new ArrayList<PipeControlPoint>();
1005                 return findNextEnd( t);
1006         }
1007
1008         public PipeControlPoint findPreviousEnd() {
1009                 ArrayList<PipeControlPoint> t = new ArrayList<PipeControlPoint>();
1010                 return findPreviousEnd(t);
1011         }
1012
1013         public PipeControlPoint findNextEnd(List<PipeControlPoint> nextList) {
1014                 while (true) {
1015                         PipeControlPoint pcp = null;
1016                         PipeControlPoint p = null;
1017                         if (nextList.size() == 0)
1018                                 p = this;
1019
1020                         else
1021                                 p = nextList.get(nextList.size() - 1);
1022
1023                         pcp = p.getNext();
1024                         if (pcp == null) {
1025                                 pcp = p;
1026                                 if (nextList.size() > 0)
1027                                         nextList.remove(nextList.size() - 1);
1028                                 //              if (DEBUG) System.out.println(" " + pcp.getResource() + " not full");
1029                                 return pcp;
1030                                 //break;
1031                         }
1032                         if (pcp.isPathLegEnd()) {
1033                                 //if (DEBUG) System.out.println(" " + pcp.getResource());
1034                                 return pcp;
1035                         } else {
1036                                 nextList.add(pcp);
1037                                 // if (DEBUG) System.out.print(" " + pcp.getResource());
1038                         }
1039                 }
1040         }
1041
1042         public PipeControlPoint findPreviousEnd(List<PipeControlPoint> prevList) {
1043                 while (true) {
1044                         PipeControlPoint pcp = null;
1045                         PipeControlPoint p = null;
1046                         if (prevList.size() == 0)
1047                                 p = this;
1048
1049                         else
1050                                 p = prevList.get(prevList.size() - 1);
1051
1052                         pcp = p.getPrevious();
1053                         if (pcp == null) {
1054                                 pcp = p;
1055                                 if (prevList.size() > 0)
1056                                         prevList.remove(prevList.size() - 1);
1057                                 //                              if (DEBUG) System.out.println(" " + pcp.getResource() + " not full");
1058                                 return pcp;
1059                         }
1060                         if (pcp.isPathLegEnd()) {
1061                                 //                              if (DEBUG)      System.out.println(" " + pcp.getResource());
1062                                 return pcp;
1063                         } else {
1064                                 prevList.add(pcp);
1065                                 //                              if (DEBUG)System.out.print(" " + pcp.getResource());
1066                         }
1067                 }
1068         }
1069         
1070         public void _remove() {
1071             _remove(true);
1072         }
1073         
1074         
1075         public PipeControlPoint getDualSub() {
1076             if (isDualInline())
1077                 return getChildPoints().get(0);
1078             else
1079                 throw new IllegalStateException("Current control point is not dual inline");
1080         }
1081         
1082
1083         public void _remove(boolean renconnect) {
1084             if (disposed)
1085                 return;
1086                 
1087             if (DEBUG) System.out.println(this + " Remove " + renconnect);
1088
1089                 if (getParentPoint() != null) {
1090                     getParentPoint()._remove(renconnect);
1091                     return;
1092                 }
1093                 PipeRun pipeRun = getPipeRun();
1094 //              PipeRUn removal has been changed, so pipeRun may be null.
1095 //              if (pipeRun == null)
1096 //                      return;
1097
1098                 PipeControlPoint additionalRemove = null;
1099                 if (!PipingRules.isEnabled()) {
1100                     component = null;
1101                         setPrevious(null);
1102                         setNext(null);
1103                 } else {
1104
1105                         PipeControlPoint currentPrev = previous;
1106                         PipeControlPoint currentNext = next;
1107                         if (currentNext == null && currentPrev == null) {
1108                                 removeComponent();
1109                                 if (pipeRun != null) {
1110                                     pipeRun.remChild(this);
1111                                     checkRemove(pipeRun);
1112                                 }
1113                                 return;
1114                         }
1115                         if (currentNext != null && currentPrev != null) {
1116                                 boolean link = renconnect;
1117                                 if (currentNext.isBranchEnd()) {
1118                                         link = false;
1119                                         currentNext.remove();
1120                                         currentNext = null;
1121                                         setNext(null);
1122                                 }
1123                                 if (currentPrev.isBranchEnd()) {
1124                                         link = false;
1125                                         currentPrev.remove();
1126                                         currentPrev = null;
1127                                         setPrevious(null);
1128                                 }
1129                                 if (link) {
1130                                     if (currentPrev.isDirected() && currentNext.isDirected())
1131                                         link = false;
1132                                     else if (this.isDualInline()) {
1133                                         link = false;
1134                                     } else if (this.isDualSub()) {
1135                                         throw new RuntimeException("_remove() is called for parent point, somehow got to child point. " + this);
1136                                     }
1137                                 }
1138                                 if (currentNext == null) {
1139                                         // Nothing to do
1140                                 } else if (currentNext.isDualInline()) {
1141                                         PipeControlPoint sccp = currentNext;
1142                                         PipeControlPoint ocp = currentNext.getDualSub();
1143                                         if (ocp == null) {
1144                                                 throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
1145                                         }
1146                                         if (link) {
1147                                                 sccp.setPrevious(currentPrev);
1148                                                 //ocp.setPrevious(currentPrev);
1149                                                 assert(ocp.getPrevious() == currentPrev);
1150                                         } else {
1151                                                 sccp.setPrevious(null);
1152                                                 //ocp.setPrevious(null);
1153                                                 assert(ocp.getPrevious() == null);
1154                                         }
1155                                         setNext(null);
1156                                 } else if (currentNext.isDualSub()) {
1157                                         throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, next control point is offset control point");
1158                                 } else if (currentNext.previous == this) {
1159                                         if (link) {
1160                                                 currentNext.setPrevious(currentPrev);
1161                                         } else {
1162                                                 currentNext.setPrevious(null);
1163                                         }
1164                                         setNext(null);
1165                                 } else if (isDualInline()) {
1166                                     if (currentNext.previous != getDualSub()) {
1167                                         throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
1168                                     }
1169                                     if (link) {
1170                         currentNext.setPrevious(currentPrev);
1171                     } else {
1172                         currentNext.setPrevious(null);
1173                     }
1174                     setNext(null);
1175                                 } else {
1176                                         throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
1177                                 }
1178                                 if (currentPrev == null) {
1179                                         // Nothing to do
1180                                 } else if (currentPrev.isDualInline()) {
1181                                         throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
1182                                 } else if (currentPrev.isDualSub()) {
1183                                         PipeControlPoint ocp = currentPrev;
1184                                         PipeControlPoint sccp = currentPrev.getParentPoint();
1185                                         if (sccp == null)
1186                                                 throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
1187                                         if (link) {
1188                                                 //ocp.setNext(currentNext);
1189                                                 sccp.setNext(currentNext);
1190                                                 assert(ocp.getNext() == currentNext);
1191                                         } else {
1192                                                 //ocp.setNext(null);
1193                                                 sccp.setNext(null);
1194                                                 assert(ocp.getNext() == null);
1195                                         }
1196                                         setPrevious(null);
1197                                 } else if (currentPrev.next == this) {
1198                                         if (link)
1199                                                 currentPrev.setNext(currentNext);
1200                                         else
1201                                                 currentPrev.setNext(null);
1202
1203                                         setPrevious(null);
1204                                 } else {
1205                                         throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged");
1206                                 }
1207                                 if (link) {
1208                                         if (currentNext.isVariableLength() && currentPrev.isVariableLength()) {
1209                                                 // we have to join them into single variable length component.
1210                                                 additionalRemove = currentPrev;
1211                                                 // combine lengths and set the location of remaining control point to the center.
1212                                                 Point3d ps = new Point3d();
1213                                                 Point3d pe = new Point3d();
1214                                                 Point3d ns = new Point3d();
1215                                                 Point3d ne = new Point3d();
1216                                                 currentPrev.getInlineControlPointEnds(ps, pe);
1217                                                 currentNext.getInlineControlPointEnds(ns, ne);
1218                                                 double l = currentPrev.getLength() + currentNext.getLength();
1219                                                 Vector3d cp = new Vector3d();
1220                                                 cp.add(ps, ne);
1221                                                 cp.scale(0.5);
1222                                                 currentNext.setLength(l);
1223                                                 currentNext.setWorldPosition(cp);
1224                                         }
1225                                 } else {
1226                                         // FIXME : pipe run must be split into two parts, since the control point structure is no more continuous. 
1227                                 }
1228                         } else if (currentNext != null) {
1229                                 if (currentNext.isDualInline()) {
1230                                         PipeControlPoint sccp = currentNext;
1231                                         PipeControlPoint ocp = getDualSub();
1232                                         if (ocp == null) {
1233                                                 throw new RuntimeException("Removing PipeControlPoint " + this+ " structure damaged, no offset control point");
1234                                         }
1235                                         sccp.setPrevious(null);
1236                                         assert(ocp.getPrevious() == null);
1237                                         //ocp.setPrevious(null);
1238                                 } else if (currentNext.isDualSub()) {
1239                                         throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, next control point is offset control point");
1240                                 } else if (currentNext.previous == this) {
1241                                     currentNext.setPrevious(null);
1242                                 }  else if (isDualInline()) {
1243                     if (currentNext.previous != getDualSub()) {
1244                         throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
1245                     }
1246                     currentNext.setPrevious(null);
1247                                 } else {
1248                                         throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
1249                                 }
1250                                 setNext(null);
1251                         } else {  //(previous != null)
1252                                 if(currentPrev.isDualInline()) {
1253                                         throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, previous control point is size change control point");
1254                                 } else if (currentPrev.isDualSub()) {
1255                                         PipeControlPoint ocp = currentPrev;
1256                                         PipeControlPoint sccp = currentPrev.getParentPoint();
1257                                         if (sccp == null) {
1258                                                 throw new RuntimeException("Removing PipeControlPoint " + this + " structure damaged, no size change control point");
1259                                         }
1260                                         sccp.setNext(null);
1261                                         assert(ocp.getNext() == null);
1262                                 } else if (currentPrev.next == this) {
1263                                     currentPrev.setNext(null);
1264                                 } else {
1265                                         throw new RuntimeException("Removing PipeControlPoint "+ this+ " structure damaged");
1266                                 }
1267                                 setPrevious(null);
1268                         }
1269                         if (children.size() > 0 ) {
1270                                 removeSubPoints();
1271                         } else if (parent!= null) {
1272                                 removeParentPoint();
1273                         }
1274
1275                 }
1276
1277                 removeComponent();
1278                 if (pipeRun != null) {
1279                 pipeRun.remChild(this);
1280                 checkRemove(pipeRun);
1281                 if (PipingRules.isEnabled() && pipeRun.getParent() != null && pipeRun.getControlPoints().size() > 0)
1282                         PipingRules.validate(pipeRun);
1283                 }
1284                 if (additionalRemove != null)
1285                         additionalRemove.remove();
1286                 disposed = true;
1287         }
1288
1289         /**
1290          * Removes control point and attempts to reconnect next/prev
1291          * 
1292          * If this point is size change (PipeRuns are different on both sides), then reconnection cannot be made.
1293          */
1294         public void remove() {
1295                 PipeControlPoint currentPrev = previous;
1296                 PipeControlPoint currentNext = next;
1297                 _remove();
1298                 try {
1299                         if (currentNext != null)
1300                             if (!currentNext.checkRemove())
1301                                 PipingRules.requestUpdate(currentNext);
1302                         if (currentPrev != null)
1303                             if (!currentPrev.checkRemove())
1304                                 PipingRules.requestUpdate(currentPrev);
1305                 } catch (Exception e) {
1306                         e.printStackTrace();
1307                 }
1308         }
1309         
1310         
1311         /**
1312          * Removes control point without attempting to reconnect next/prev.
1313          * This usually leads to creation of another PipeRun for the control points after this point. 
1314          */
1315         public void removeAndSplit() {
1316         PipeControlPoint currentPrev = previous;
1317         PipeControlPoint currentNext = next;
1318         
1319         if (next != null && previous != null) {
1320             P3DRootNode root = (P3DRootNode)getPipelineComponent().getRootNode();
1321             PipeRun nextPipeRun = new PipeRun();
1322             nextPipeRun.setName(root.getUniqueName("PipeRun"));
1323             root.addChild(nextPipeRun);
1324             
1325             PipeRun previousRun = previous.getPipeRun();
1326             nextPipeRun.setPipeDiameter(previousRun.getPipeDiameter());
1327             nextPipeRun.setTurnRadiusArray(previousRun.getTurnRadiusArray());
1328             
1329             PipelineComponent n = next.getPipelineComponent();
1330             while (n != null) {
1331                 if (n.getPipeRun() != previousRun)
1332                     break;
1333                 if (! (n instanceof Nozzle)) {
1334                     n.deattach();
1335                     nextPipeRun.addChild(n);
1336                 } else
1337                     n.setPipeRun(nextPipeRun);
1338                 n = n.getNext();
1339             }
1340         }
1341         _remove(false);
1342         try {
1343             if (currentNext != null)
1344                 if (!currentNext.checkRemove())
1345                     PipingRules.requestUpdate(currentNext);
1346             if (currentPrev != null)
1347                 if (!currentPrev.checkRemove())
1348                     PipingRules.requestUpdate(currentPrev);
1349         } catch (Exception e) {
1350             e.printStackTrace();
1351         }
1352     }
1353         
1354         /**
1355          * This is called when adjacent control point is removed.
1356          * 
1357          * This call should remove the give point, if the point cannot exist alone. 
1358          * At the moment there is one such case: branch.
1359          * 
1360          * @return
1361          */
1362         protected boolean checkRemove() {
1363             if (getParentPoint() != null) {
1364                 return getParentPoint().checkRemove();
1365             } else {
1366                 if (getPipelineComponent() == null)
1367                     return true; // already removed
1368             if (getPipelineComponent().getType().equals("Plant3D.URIs.Builtin_BranchSplitComponent")) {
1369                 if (getChildPoints().get(0).getNext() == null && getChildPoints().get(0).getPrevious() == null) {
1370                         remove();
1371                         return true;
1372                 }
1373             }
1374             return checkRemove(getPipeRun());
1375             }
1376     }
1377
1378         private boolean checkRemove(PipeRun pipeRun) {
1379             if (pipeRun == null)
1380                 return false;
1381                 Collection<PipeControlPoint> points = pipeRun.getControlPoints();
1382                 if (points.size() == 0) {
1383                         pipeRun.remove();
1384                         return true;
1385                 } else if (points.size() == 1) {
1386                         PipeControlPoint pcp = points.iterator().next();
1387                         if (pcp.isDeletable() && pcp.getNext() == null && pcp.getPrevious() == null) {
1388                                 pcp._remove(); // This call will recursively call also this method...
1389                                 return true;
1390                         }
1391                 } else if (points.size() == 2) {
1392                     
1393                 }
1394                 return false;
1395         }
1396
1397         private void removeSubPoints() {
1398                 for (PipeControlPoint p : children) {
1399                         p.parent = null;
1400                         p.component = null;
1401                         //p._remove();
1402                         PipeControlPoint currentNext = p.getNext();
1403                         PipeControlPoint currentPrev = p.getPrevious();
1404                         p._setNext(null);
1405                         p._setPrevious(null);
1406                         PipeRun run = p.getPipeRun();
1407                         if (run != null) {
1408                             run.remChild(p);
1409                             checkRemove(run);
1410                         }
1411                         if (currentNext != null)
1412                 if (!currentNext.checkRemove())
1413                     PipingRules.requestUpdate(currentNext);
1414             if (currentPrev != null)
1415                 if (!currentPrev.checkRemove())
1416                     PipingRules.requestUpdate(currentPrev);
1417             
1418                 }
1419                 children.clear();
1420         }
1421
1422         private void removeParentPoint() {
1423                 throw new RuntimeException("Child points cannot be removed directly");
1424         }
1425         
1426         public boolean isRemoved() {
1427             return component == null;
1428         }
1429
1430         private void removeComponent() {
1431                 if (component == null)
1432                         return;
1433                 PipelineComponent next = component.getNext();
1434                 PipelineComponent prev = component.getPrevious();
1435                 PipelineComponent br0 = component.getBranch0();
1436                 component.setNext(null);
1437                 component.setPrevious(null);
1438                 component.setBranch0(null);
1439                 if (next != null) {
1440                         if (next.getNext() == component)
1441                                 next.setNext(null);
1442                         else if (next.getPrevious() == component)
1443                                 next.setPrevious(null);
1444                         else if (next.getBranch0() == component)
1445                                 next.setBranch0(null);
1446                 }
1447                 if (prev != null) {
1448                         if (prev.getNext() == component)
1449                                 prev.setNext(null);
1450                         else if (prev.getPrevious() == component)
1451                                 prev.setPrevious(null);
1452                         else if (prev.getBranch0() == component)
1453                                 prev.setBranch0(null);
1454                 }
1455                 if (br0 != null) {
1456                         if (br0.getNext() == component)
1457                                 br0.setNext(null);
1458                         else if (br0.getPrevious() == component)
1459                                 br0.setPrevious(null);
1460                         else if (br0.getBranch0() == component)
1461                                 br0.setBranch0(null);
1462                 }
1463                 PipelineComponent comp = component;
1464                 component = null;
1465
1466                 comp.remove();
1467         }
1468
1469         @Override
1470         public void setOrientation(Quat4d orientation) {
1471                 if (MathTools.equals(orientation, getOrientation()))
1472                         return;
1473                 super.setOrientation(orientation);
1474                 if (getParentPoint() == null && component != null)
1475                         component._setWorldOrientation(getWorldOrientation());
1476                 updateSubPoint();
1477         }
1478
1479         @Override
1480         public void setPosition(Vector3d position) {
1481                 if (MathTools.equals(position, getPosition()))
1482                         return;
1483                 if (Double.isNaN(position.x) || Double.isNaN(position.y) || Double.isNaN(position.z))
1484                         throw new IllegalArgumentException("NaN is not supported");
1485                 super.setPosition(position);
1486                 if (getParentPoint() == null && component != null)
1487                         component._setWorldPosition(getWorldPosition());
1488                 updateSubPoint();
1489         }
1490
1491         private void updateSubPoint() {
1492                 if (isOffset()) {
1493                         if (next == null && previous == null) {
1494                                 for (PipeControlPoint sub : getChildPoints()) {
1495                                         sub.setWorldPosition(getWorldPosition());
1496                                         sub.setWorldOrientation(getWorldOrientation());
1497                                 }
1498                                 return;
1499                         }
1500                         for (PipeControlPoint sub : getChildPoints()) {
1501                                 Vector3d wp = getWorldPosition();
1502                                 wp.add(getSizeChangeOffsetVector());
1503                                 sub.setWorldPosition(wp);
1504                                 sub.setWorldOrientation(getWorldOrientation());
1505                         }
1506                 } else {
1507                         for (PipeControlPoint sub : getChildPoints()) {
1508                                 sub.setWorldPosition(getWorldPosition());
1509                                 sub.setWorldOrientation(getWorldOrientation());
1510                         }
1511                 }
1512         }
1513
1514
1515         public void _setWorldPosition(Vector3d position) {
1516                 Vector3d localPos = getLocalPosition(position);
1517                 super.setPosition(localPos);
1518                 updateSubPoint();
1519         }
1520
1521         public void _setWorldOrientation(Quat4d orientation) {
1522                 Quat4d localOr = getLocalOrientation(orientation);
1523                 super.setOrientation(localOr);
1524                 updateSubPoint();
1525         }
1526
1527         @Override
1528         public String toString() {
1529                 return getClass().getName() + "@" + Integer.toHexString(hashCode());
1530         }
1531
1532 }