X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.plant3d%2Fsrc%2Forg%2Fsimantics%2Fplant3d%2Fscenegraph%2Fcontrolpoint%2FPipingRules.java;h=de96517552f7d6774f7c0ef0cf20c04820e17f93;hb=1ca09aa9bae3ea1e3382ceff0a2a09427f173286;hp=854b265d3a09e7c00ae370a5c93460a4b99ef020;hpb=53d55c24c779745f188bdb18d32f71d20acb61b2;p=simantics%2F3d.git diff --git a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java index 854b265d..de965175 100644 --- a/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java +++ b/org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/controlpoint/PipingRules.java @@ -51,6 +51,8 @@ public class PipingRules { private static Object ruleMutex = new Object(); public static void requestUpdate(PipeControlPoint pcp) { + if (!PipingRules.enabled) + return; if (DEBUG) System.out.println("PipingRules request " + pcp); synchronized (updateMutex) { if (!requestUpdates.contains(pcp)) @@ -59,6 +61,9 @@ public class PipingRules { } public static boolean update() throws Exception { + if (!PipingRules.enabled) + return false; + if (requestUpdates.size() == 0) return false; @@ -213,15 +218,15 @@ public class PipingRules { 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 (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; - pcp1 = pcp2.getSubPoint().get(0); + pcp1 = pcp2.getDualSub(); pcp2 = t; } else { throw new RuntimeException(); @@ -229,7 +234,7 @@ public class PipingRules { 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); @@ -246,15 +251,15 @@ public class PipingRules { 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 (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; - pcp1 = pcp2.getSubPoint().get(0); + pcp1 = pcp2.getDualSub(); pcp2 = t; } else { throw new RuntimeException(); @@ -262,7 +267,7 @@ public class PipingRules { 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); @@ -282,7 +287,7 @@ public class PipingRules { 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); @@ -304,6 +309,10 @@ public class PipingRules { else if (us.end.equals(updated)) lengthChange = PathLegUpdateType.PREV; } + if (us == null) { + System.out.println("Null update struct " + start); + return; + } updatePathLeg(us, lengthChange); } @@ -316,6 +325,10 @@ public class PipingRules { // else if (us.end.equals(updated)) // lengthChange = PathLegUpdateType.PREV; // } + if (us == null) { + System.out.println("Null update struct " + start); + return; + } updatePathLeg(us, lengthChange); } @@ -362,6 +375,7 @@ public class PipingRules { } + @SuppressWarnings("unused") private static boolean calculateOffset(Vector3d startPoint, Vector3d endPoint, ArrayList list, Vector3d dir, Vector3d offset) { boolean hasOffsets = false; List offsets = new ArrayList(list.size()); @@ -448,7 +462,7 @@ public class PipingRules { private static boolean asDirected(PipeControlPoint pcp, Direction direction) { if (pcp.isDirected()) return true; - if (pcp.isTurn() && pcp.isFixed()) { + if (pcp.asFixedAngle()) { if (!pcp._getReversed()) return direction == Direction.NEXT; else @@ -485,7 +499,7 @@ public class PipingRules { if (DEBUG) System.out.println("PipingRules.updateFreePipeRun " + u + " " + lengthChange); checkExpandPathLeg(u, lengthChange); - if (u.start.isInline() || u.end.isInline() || u.start.isFixed() || u.end.isFixed()) + if (u.start.isInline() || u.end.isInline() || u.start.asFixedAngle()|| u.end.asFixedAngle()) processPathLeg(u, true, false); } @@ -596,7 +610,7 @@ public class PipingRules { 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()) { @@ -671,6 +685,11 @@ public class PipingRules { // must be removed if (icp.isDeletable()) { + if (!allowInsertRemove) { + icp.setLength(0.0001); + triedIR = true; + return false; + } if (DEBUG) System.out.println("PipingRules.updateVariableLength removing " + icp); icp._remove(); @@ -700,7 +719,7 @@ public class PipingRules { // position of the // component dir.add(prevPos); - PipeControlPoint scp = insertStraight(prev, icp, dir, length); + insertStraight(prev, icp, dir, length); return true; } else { triedIR = true; @@ -860,7 +879,7 @@ public class PipingRules { double distance = t.length(); boolean aligned = (distance < ALLOWED_OFFSET); if (aligned) { - if (u.start.isInline() || u.end.isInline() || u.start.isFixed() || u.end.isFixed()) + if (u.start.isInline() || u.end.isInline() || u.start.asFixedAngle() || u.end.asFixedAngle()) processPathLeg(u, true, false); checkExpandPathLeg(u, lengthChange, inlineEnd); @@ -882,14 +901,15 @@ public class PipingRules { if (other.isVariableAngle()) { // TODO calculate needed space from next run end. - if (mu[0] < 1.0) { + double space = spaceForTurn(other); + if (mu[0] < space) { if (dcpStart) { closest.set(u.startPoint); } else { closest.set(u.endPoint); } Vector3d v = new Vector3d(directedDirection); - v.scale(spaceForTurn(other)); + v.scale(space); closest.add(v); } @@ -1069,7 +1089,7 @@ public class PipingRules { // TODO : this returns now space for 90 deg turn. // The challenge: position of tcp affects the turn angle, which then affects the required space. Perhaps we need to iterate... // Additionally, if the path legs contain offset, using just positions of opposite path leg ends is not enough, - return tcp.getPipeRun().getTurnRadius(); + return ((TurnComponent)tcp.getPipelineComponent()).getTurnRadius(); } private static void insertElbowUpdate(UpdateStruct2 u, PipeControlPoint dcp, PipeControlPoint next, boolean dcpStart, Vector3d position, Vector3d directedDirection) throws Exception{ @@ -1353,6 +1373,7 @@ public class PipingRules { // end,Point3d endPoint, Vector3d dir, boolean hasOffsets,int iter, boolean // reversed, ArrayList toRemove) throws TransactionException // { + @SuppressWarnings("unused") private static void processPathLegNoOffset(UpdateStruct2 u) throws Exception { if (DEBUG) System.out.println("PipingRules.processPathLeg " + u.start + " " + u.end); @@ -1373,7 +1394,7 @@ public class PipingRules { 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); } @@ -1409,7 +1430,7 @@ public class PipingRules { 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; @@ -1472,26 +1493,11 @@ public class PipingRules { private static void updateEndComponentControlPoint(PipeControlPoint ecp, Vector3d start, Vector3d end) throws Exception { if (DEBUG) System.out.println("PipingRules.updateEndComponentControlPoint() " + ecp); - // PipeControlPoint next = ecp.getNext(); - // PipeControlPoint prev = ecp.getPrevious(); - // if (next != null) { - // end = G3DTools.getPoint(next.getLocalPosition()); - // start = G3DTools.getPoint(ecp.getLocalPosition()); - // } else if (prev != null) { - // end = G3DTools.getPoint(ecp.getLocalPosition()); - // start = G3DTools.getPoint(prev.getLocalPosition()); - // } else { - // // TODO : warning? - // return; - // } - // Vector3d dir = new Vector3d (end); - // dir.sub(start); - // dir.normalize(); - // G3DTools.setTuple(ecp.getDirection(), dir); - if (!ecp.isFixed()) - updateControlPointOrientation(ecp); - - for (PipeControlPoint pcp : ecp.getSubPoint()) { + //FIXME : end control point cannot be fixed! + //if (!ecp.isFixed()) + updateControlPointOrientation(ecp); + + for (PipeControlPoint pcp : ecp.getChildPoints()) { // TODO update position updatePathLegEndControlPoint(pcp); } @@ -1525,7 +1531,7 @@ public class PipingRules { System.out.println("PipingRules.updateBranchControlPointBranches() " + bcp); if (bcp.isDualInline()) return; - Collection branches = bcp.getSubPoint(); + Collection branches = bcp.getChildPoints(); if (branches.size() == 0) { if (DEBUG) System.out.println("No Branches found"); @@ -1550,7 +1556,7 @@ public class PipingRules { } } - if (!tcp.isFixed()) { + if (!tcp.asFixedAngle()) { if (next == null || prev == null) { @@ -1565,7 +1571,7 @@ public class PipingRules { Vector3d turnAxis = new Vector3d(); turnAxis.cross(prev, next); if (turnAxis.lengthSquared() > MathTools.NEAR_ZERO) { - double elbowRadius = tcp.getPipelineComponent().getPipeRun().getTurnRadius(); + double elbowRadius = ((TurnComponent)tcp.getPipelineComponent()).getTurnRadius(); double R = elbowRadius / Math.tan(angle * 0.5); turnAxis.normalize(); @@ -1628,8 +1634,9 @@ public class PipingRules { PipeControlPoint pcp = pipeRun.getControlPoints().iterator().next(); while (pcp.getPrevious() != null) { PipeControlPoint prev = pcp.getPrevious(); - if (prev.getPipeRun() != pipeRun) - break; + if (prev.getPipeRun() != pipeRun && prev.getPipeRun() != null) { // bypass possible corruption + break; + } pcp = prev; } if (pcp.isDualSub()) { @@ -1650,7 +1657,7 @@ public class PipingRules { while (true) { List 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; @@ -1663,8 +1670,8 @@ public class PipingRules { List 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(); } else { break; } @@ -1712,11 +1719,11 @@ public class PipingRules { 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()) - next = next.getSubPoint().get(0); + next = next.getDualSub(); if (current.getNext() == next) current.setNext(null); current.setPrevious(next); @@ -1741,7 +1748,7 @@ public class PipingRules { 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); @@ -1753,7 +1760,8 @@ public class PipingRules { } } - if (current.isTurn() && current.isFixed()) { + //if (current.isTurn() && current.isFixed()) { + if (current.asFixedAngle()) { current.setReversed(!current._getReversed()); } if (current.isInline() && current.isReverse()) { @@ -1799,17 +1807,25 @@ public class PipingRules { } List runPcps = getControlPoints(pipeRun); if (runPcps.size() != count) { - System.out.println("Run " + pipeRun.getName() + " contains unconnected control points"); + System.out.println("Run " + pipeRun.getName() + " contains unconnected control points, found " + runPcps.size() + " connected, " + pcps.size() + " total."); + for (PipeControlPoint pcp : pcps) { + if (!runPcps.contains(pcp)) { + System.out.println("Unconnected " + pcp + " " + pcp.getPipelineComponent()); + } + } } for (PipeControlPoint pcp : pcps) { + if (pcp.getPipeRun() == null) { + System.out.println("PipeRun ref missing " + pcp + " " + pcp.getPipelineComponent()); + } if (!pcp.isDirected() && pcp.getNext() == null && pcp.getPrevious() == null) - System.out.println("Orphan undirected " + pcp); + System.out.println("Orphan undirected " + pcp + " " + pcp.getPipelineComponent()); } for (PipeControlPoint pcp : pcps) { 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) { @@ -1833,8 +1849,8 @@ public class PipingRules { } public static void splitVariableLengthComponent(PipelineComponent newComponent, InlineComponent splittingComponent, boolean assignPos) throws Exception{ - assert(!splittingComponent.getControlPoint().isFixed()); - assert(!(newComponent instanceof InlineComponent && !newComponent.getControlPoint().isFixed())); + assert(!splittingComponent.getControlPoint().isFixedLength()); + assert(!(newComponent instanceof InlineComponent && !newComponent.getControlPoint().isFixedLength())); PipeControlPoint newCP = newComponent.getControlPoint(); PipeControlPoint splittingCP = splittingComponent.getControlPoint(); PipeControlPoint nextCP = splittingCP.getNext(); @@ -1862,7 +1878,6 @@ public class PipingRules { // this should not be possible throw new RuntimeException("VariableLengthComponent " + splittingComponent + " is not connected to anything."); } - double reservedLength = splittingComponent.getControlPoint().getLength(); double newLength = newComponent.getControlPoint().getLength(); @@ -1898,21 +1913,20 @@ public class PipingRules { vn.interpolate(next, 0.5); - PipeControlPoint newVariableLengthCP = null;//insertStraight(pcp1, pcp2, pos, length); if (nextCP == null) { newCP.insert(splittingCP, Direction.NEXT); - newVariableLengthCP = insertStraight(newCP, Direction.NEXT, new Vector3d(vn), ln); + insertStraight(newCP, Direction.NEXT, new Vector3d(vn), ln); splittingCP.setWorldPosition(new Vector3d(vp)); // ControlPointTools.setWorldPosition(splittingCP, vp); // splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp); } else if (prevCP == null) { newCP.insert(splittingCP, Direction.PREVIOUS); - newVariableLengthCP = insertStraight(newCP, Direction.PREVIOUS, new Vector3d(vp), lp); + insertStraight(newCP, Direction.PREVIOUS, new Vector3d(vp), lp); splittingCP.setWorldPosition(new Vector3d(vn)); // splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, ln); } else { newCP.insert(splittingCP, nextCP); - newVariableLengthCP = insertStraight(newCP, nextCP, new Vector3d(vn), ln); + insertStraight(newCP, nextCP, new Vector3d(vn), ln); splittingCP.setWorldPosition(new Vector3d(vp)); // splittingCP.setRelatedScalarDouble(ProcessResource.plant3Dresource.HasLength, lp); } @@ -1922,7 +1936,7 @@ public class PipingRules { 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);