import org.simantics.plant3d.utils.ComponentUtils;
import org.simantics.utils.datastructures.Pair;
import org.simantics.utils.ui.ErrorLogger;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
public class PipingRules {
- private static final boolean DEBUG = false;
+ private static final Logger LOGGER = LoggerFactory.getLogger(PipingRules.class);
+
private static final boolean DUMMY = false;
private static double MIN_TURN_ANGLE = 0.001; // Threshold for removing turn components.
public static void requestUpdate(PipeControlPoint pcp) {
if (!PipingRules.enabled)
return;
- if (DEBUG) System.out.println("PipingRules request " + pcp);
+ if (LOGGER.isTraceEnabled()) LOGGER.trace("PipingRules request " + pcp);
synchronized (updateMutex) {
if (!requestUpdates.contains(pcp))
requestUpdates.add(pcp);
if (pcp.getPipeRun() == null)
return false;
try {
- if (DEBUG) System.out.println("PipingRules " + pcp);
+ if (LOGGER.isTraceEnabled()) LOGGER.trace("PipingRules " + pcp);
updating = true;
allowInsertRemove = allowIR;
triedIR = false;
return true;
} finally {
updating = false;
-// System.out.println("PipingRules done " + pcp);
+// LOGGER.trace("PipingRules done " + pcp);
}
}
}
private static void updatePathLegEndControlPoint(PipeControlPoint pcp) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.updatePathLegEndControlPoint() " + pcp);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updatePathLegEndControlPoint() " + pcp);
if (pcp.getNext() != null) {
updatePathLegNext(pcp, pcp, PathLegUpdateType.NEXT_S);
}
}
private static void updateInlineControlPoint(PipeControlPoint pcp) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.updateInlineControlPoint() " + pcp);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateInlineControlPoint() " + pcp);
PipeControlPoint start = pcp.findPreviousEnd();
updatePathLegNext(start, pcp, PathLegUpdateType.NONE);
}
private static PipeControlPoint insertElbow(PipeControlPoint pcp1, PipeControlPoint pcp2, Vector3d pos) throws Exception{
- if (DEBUG)
- System.out.println("PipingRules.insertElbow() " + pcp1 + " " + pcp2 + " " + pos);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.insertElbow() " + pcp1 + " " + pcp2 + " " + pos);
if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
} else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) {
}
private static PipeControlPoint insertStraight(PipeControlPoint pcp1, PipeControlPoint pcp2, Vector3d pos, double length) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.insertStraight() " + pcp1 + " " + pcp2 + " " + pos);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.insertStraight() " + pcp1 + " " + pcp2 + " " + pos);
if (pcp1.getNext() == pcp2 && pcp2.getPrevious() == pcp1) {
} else if (pcp1.getNext() == pcp2 && pcp1.isDualInline() && pcp2.getPrevious() == pcp1.getDualSub()) {
}
private static PipeControlPoint insertStraight(PipeControlPoint pcp, Direction direction , Vector3d pos, double length) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.insertStraight() " + pcp + " " + direction + " " + pos);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.insertStraight() " + pcp + " " + direction + " " + pos);
InlineComponent component = ComponentUtils.createStraight((P3DRootNode)pcp.getRootNode());
PipeControlPoint scp = component.getControlPoint();
private static void updatePathLegNext(PipeControlPoint start, PipeControlPoint updated, PathLegUpdateType lengthChange) throws Exception {
UpdateStruct2 us = createUS(start, Direction.NEXT, 0, new ArrayList<ExpandIterInfo>(), updated);
if (us == null) {
- System.out.println("Null update struct " + start);
+ LOGGER.trace("Null update struct " + start);
return;
}
updatePathLeg(us, lengthChange);
private static void updatePathLegPrev(PipeControlPoint start, PipeControlPoint updated, PathLegUpdateType lengthChange) throws Exception {
UpdateStruct2 us = createUS(start, Direction.PREVIOUS, 0, new ArrayList<ExpandIterInfo>(), updated);
if (us == null) {
- System.out.println("Null update struct " + start);
+ LOGGER.trace("Null update struct " + start);
return;
}
updatePathLeg(us, lengthChange);
dir.scale(1.0/Math.sqrt(l));
}
- if (DEBUG)
- System.out.println("calcOffset s:"+ startPoint + " e:" + endPoint + " d:" + dir + " o:"+offset) ;
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("calcOffset s:"+ startPoint + " e:" + endPoint + " d:" + dir + " o:"+offset) ;
return true;
}
}
private static void updateFreePathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.updateFreePipeRun " + u + " " + lengthChange);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateFreePipeRun " + u + " " + lengthChange);
checkExpandPathLeg(u, lengthChange);
if (u.start.isInline() || u.end.isInline() || u.start.asFixedAngle()|| u.end.asFixedAngle())
processPathLeg(u, true, false);
}
private static void updateInlineControlPoints(UpdateStruct2 u, boolean checkSizes) throws Exception{
- if (DEBUG)
- System.out.println("PipingRules.updateInlineControlPoints() " + u);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateInlineControlPoints() " + u);
Vector3d start = new Vector3d(u.startPoint);
Vector3d end = new Vector3d(u.endPoint);
for (PipeControlPoint pcp : u.list)
setError(pcp, "Not enough available space");
}
-// System.out.println(u.start.getPipelineComponent().toString() + " " + pathLegLength + " " + availableLength + " " + u.end.getPipelineComponent().toString() + " " + u.start.getInlineLength() + " " + u.end.getInlineLength());
+// LOGGER.trace(u.start.getPipelineComponent().toString() + " " + pathLegLength + " " + availableLength + " " + u.end.getPipelineComponent().toString() + " " + u.start.getInlineLength() + " " + u.end.getInlineLength());
}
}
triedIR = true;
return false;
}
- if (DEBUG)
- System.out.println("PipingRules.updateVariableLength removing " + icp);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateVariableLength removing " + icp);
icp._remove();
return true;
} else {
double l = beginPos.distance(endPos);
if (Double.isNaN(l))
- System.out.println("Length for " + icp + " is NaN");
+ LOGGER.debug("Length for " + icp + " is NaN");
dir.scale(l * 0.5);
beginPos.add(dir); // center position
- if (DEBUG)
- System.out.println("PipingRules.updateInlineControlPoints() setting variable length to " + l);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateInlineControlPoints() setting variable length to " + l);
icp.setLength(l);
icp.setWorldPosition(new Vector3d(beginPos));
* @throws Exception
*/
private static void ppNoOffset(UpdateStruct2 u, boolean updateEnds) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.ppNoOffset() " + u);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.ppNoOffset() " + u);
Vector3d offset = new Vector3d();
if (u.hasOffsets) {
for (PipeControlPoint icp : u.list) {
}
private static void ppNoDir(PipeControlPoint start, Vector3d startPoint, ArrayList<PipeControlPoint> list, PipeControlPoint end, Vector3d endPoint, boolean hasOffsets, int iter, boolean reversed, ArrayList<ExpandIterInfo> toRemove, PipeControlPoint updated) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.ppNoDir() " + start + " " + end + " " + iter + " " + toRemove.size());
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.ppNoDir() " + start + " " + end + " " + iter + " " + toRemove.size());
// FIXME : extra loop (dir should be calculated here)
Vector3d dir = new Vector3d();
Vector3d offset = new Vector3d();
}
private static void checkExpandPathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange, boolean updateEnds) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.checkExpandPathLeg() " + u + " " + lengthChange);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.checkExpandPathLeg() " + u + " " + lengthChange);
if (lengthChange != PathLegUpdateType.NONE) {
// FIXME : turns cannot be checked before inline cps are updated,
// since their position affects calculation of turns
}
private static void updateDirectedPathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.updateDirectedPipeRun() " + u + " " + lengthChange);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateDirectedPipeRun() " + u + " " + lengthChange);
PipeControlPoint dcp;
PipeControlPoint other;
boolean canMoveOther = false;
}
if (canMoveOther) {
- if (DEBUG)
- System.out.println("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + closest);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + closest);
// Not aligned - we need to recalculate the offset to reflect new end points.
Vector3d offset;
throw new UnsupportedOperationException("not implemented");
}
if (canMoveOther) {
- if (DEBUG)
- System.out.println("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + bintersect);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateDirectedPipeRun() moved end " + other + " to " + bintersect);
// is required branch position is in possible range
bcp.setWorldPosition(bintersect);
if (dcpStart) {
}
private static void updateDualDirectedPathLeg(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.updateDualDirectedPipeRun() " + u + " " + lengthChange);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateDualDirectedPipeRun() " + u + " " + lengthChange);
PipeControlPoint dcp1 = u.start;
PipeControlPoint dcp2 = u.end;
PipeControlPoint tcp1 = insertElbow(dcp, next, p1);
PipeControlPoint tcp2 = insertElbow(tcp1, next, p2);
- if (DEBUG)
- System.out.println("PipingRules.updateDualDirectedPipeRun() created two turns " + tcp1 + " " + tcp2);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateDualDirectedPipeRun() created two turns " + tcp1 + " " + tcp2);
if (!u.reversed) {
Vector3d dd = new Vector3d(p2);
tcp.setPosition(p);
closest = p;
- if (DEBUG)
- System.out.println("PipingRules.updateDirectedPipeRun() inserted " + tcp);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateDirectedPipeRun() inserted " + tcp);
if (dcpStart) {
// update pipe run from new turn to other end
* Checks if turns can be removed (turn angle near zero)
*/
private static int checkTurns(UpdateStruct2 u, PathLegUpdateType lengthChange) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.checkTurns() " + u.start + " " + u.end);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.checkTurns() " + u.start + " " + u.end);
boolean startRemoved = false;
boolean endRemoved = false;
if (u.start.isVariableAngle()) {
}
}
}
- if (DEBUG)
- System.out.println("PipingRules.checkTurns() res " + startRemoved + " " + endRemoved);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.checkTurns() res " + startRemoved + " " + endRemoved);
if (!startRemoved && !endRemoved)
return REMOVE_NONE;
if (startRemoved && endRemoved)
*
*/
private static void expandPathLeg(UpdateStruct2 u, int type) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.expandPipeline " + u.start + " " + u.end);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.expandPipeline " + u.start + " " + u.end);
ArrayList<PipeControlPoint> newList = new ArrayList<PipeControlPoint>();
switch (type) {
case REMOVE_NONE:
ErrorLogger.defaultLogError("Updating pipe run, found offset controlpoint " + icp, new Exception("ASSERT!"));
}
}
- if (DEBUG)
- System.out.println("PipingRules.expandPipeline expanded " + u.start + " " + u.end);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.expandPipeline expanded " + u.start + " " + u.end);
u.iter++;
updatePathLeg(u, PathLegUpdateType.NONE);
}
*/
private static void backIter(UpdateStruct2 u) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.backIter" + u.start + " " + u.end);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.backIter" + u.start + " " + u.end);
if (u.iter == 0)
throw new RuntimeException("Error in piping rules");
ExpandIterInfo info = u.toRemove.get(u.toRemove.size() - 1);
// toRemove) throws TransactionException {
private static void processPathLeg(UpdateStruct2 u) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.processPathLeg " + u.start + " " + u.end);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.processPathLeg " + u.start + " " + u.end);
processPathLeg(u, true, true);
}
private static void processPathLeg(UpdateStruct2 u, boolean updateEnds, boolean updateInline) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.processPathLeg " + (updateEnds ? "ends " : "") + (updateInline ? "inline " : "") + u.start + " " + u.end);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.processPathLeg " + (updateEnds ? "ends " : "") + (updateInline ? "inline " : "") + u.start + " " + u.end);
if (u.toRemove.size() > 0) {
for (ExpandIterInfo info : u.toRemove) {
if (info.getStart() != null) {
- if (DEBUG)
- System.out.println("PipingRules.processPathLeg removing start " + info.getStart());
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.processPathLeg removing start " + info.getStart());
info.getStart()._remove();
}
if (info.getEnd() != null) {
- if (DEBUG)
- System.out.println("PipingRules.processPathLeg removing end " + info.getEnd());
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.processPathLeg removing end " + info.getEnd());
info.getEnd()._remove();
}
}
// {
@SuppressWarnings("unused")
private static void processPathLegNoOffset(UpdateStruct2 u) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.processPathLeg " + u.start + " " + u.end);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.processPathLeg " + u.start + " " + u.end);
Vector3d offset = new Vector3d();
if (u.hasOffsets) {
u.dir.normalize();
* @param prevPoint
*/
private static void updateInlineControlPoint(PipeControlPoint icp, Vector3d prev, Vector3d next, Vector3d dir) {
- if (DEBUG)
- System.out.println("PipingRules.updateInlineControlPoint() " + icp);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateInlineControlPoint() " + icp);
Vector3d inlinePoint = icp.getWorldPosition();
Vector3d prevPoint = new Vector3d(prev);
}
}
boolean canCalc = MathTools.distance(prevPoint, nextPoint) > ALLOWED_OFFSET;
- if (DEBUG)
+ if (LOGGER.isTraceEnabled())
System.out.print("InlineControlPoint update " + icp + " " + inlinePoint + " " + prevPoint + " " + nextPoint);
Vector3d newInlinePoint = null;
if (canCalc) {
newInlinePoint = new Vector3d();
double mu[] = new double[2];
MathTools.intersectStraightStraight(new Vector3d(prevPoint), dir1, new Vector3d(branchLegEnd), dir2, newInlinePoint, new Vector3d(), mu);
- if (DEBUG)
- System.out.println(mu[0]);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace(Double.toString(mu[0]));
// FIXME : reserve space
if (mu[0] < 0.0) {
newInlinePoint = new Vector3d(prevPoint);
// prevPoint == nextPoint
newInlinePoint = new Vector3d(prevPoint);
}
- if (DEBUG)
- System.out.println(" " + newInlinePoint);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace(" " + newInlinePoint);
icp.setWorldPosition(newInlinePoint);
icp.orientToDirection(dir);
* @param prevPoint
*/
private static void updateEndComponentControlPoint(PipeControlPoint ecp, Vector3d dir) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.updateEndComponentControlPoint() " + ecp);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateEndComponentControlPoint() " + ecp);
if (!ecp.isFixed()) // prevent overriding nozzle orientations..
ecp.orientToDirection(dir);
* @param bcp
*/
private static void updateBranchControlPointBranches(PipeControlPoint bcp) throws Exception {
- if (DEBUG)
- System.out.println("PipingRules.updateBranchControlPointBranches() " + bcp);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingRules.updateBranchControlPointBranches() " + bcp);
if (bcp.isDualInline())
return;
Collection<PipeControlPoint> branches = bcp.getChildPoints();
if (branches.size() == 0) {
- if (DEBUG)
- System.out.println("No Branches found");
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("No Branches found");
return;
}
tcp.orientToDirection(prev);
- if (DEBUG)
- System.out.println("PipingTools.updateTurnControlPointTurn " + prev + " " + next + " " + turnAngle + " " + turnAxis);
+ if (LOGGER.isTraceEnabled())
+ LOGGER.trace("PipingTools.updateTurnControlPointTurn " + prev + " " + next + " " + turnAngle + " " + turnAxis);
return turnAngle;
} else {
synchronized (ruleMutex) {
Collection<PipeControlPoint> pcps = pipeRun.getControlPoints();
int count = 0;
- //System.out.println("Validate " + pipeRun.getName());
+ //LOGGER.trace("Validate " + pipeRun.getName());
for (PipeControlPoint pcp : pcps) {
if (pcp.getParentPoint() == null || pcp.getParentPoint().getPipeRun() != pipeRun)
count++;
}
List<PipeControlPoint> runPcps = getControlPoints(pipeRun);
if (runPcps.size() != count) {
- System.out.println("Run " + pipeRun.getName() + " contains unconnected control points, found " + runPcps.size() + " connected, " + pcps.size() + " total.");
+ LOGGER.debug("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());
+ LOGGER.debug("Unconnected " + pcp + " " + pcp.getPipelineComponent());
}
}
}
for (PipeControlPoint pcp : pcps) {
if (pcp.getPipeRun() == null) {
- System.out.println("PipeRun ref missing " + pcp + " " + pcp.getPipelineComponent());
+ LOGGER.debug("PipeRun ref missing " + pcp + " " + pcp.getPipelineComponent());
}
if (!pcp.isDirected() && pcp.getNext() == null && pcp.getPrevious() == null)
- System.out.println("Orphan undirected " + pcp + " " + pcp.getPipelineComponent());
+ LOGGER.debug("Orphan undirected " + pcp + " " + pcp.getPipelineComponent());
}
for (PipeControlPoint pcp : pcps) {
if (pcp.getParentPoint() == null) {
PipeControlPoint prev = pcp.getPrevious();
if (next != null) {
if (!(next.getPrevious() == pcp || next.getPrevious() == sub)) {
- System.out.println("Inconsistency between " + pcp + " -> " +next );
+ LOGGER.debug("Inconsistency between " + pcp + " -> " +next );
}
}
if (prev != null) {
if (prev.isDualSub()) {
prevParent = prev.getParentPoint();
} else if (prev.isDualInline()) {
- System.out.println("Inconsistency between " + pcp + " <-- " +prev );
+ LOGGER.debug("Inconsistency between " + pcp + " <-- " +prev );
}
if (!(prev.getNext() == pcp && (prevParent == null || prevParent.getNext() == pcp))) {
- System.out.println("Inconsistency between " + pcp + " <-- " +prev );
+ LOGGER.debug("Inconsistency between " + pcp + " <-- " +prev );
}
}
}
Code Review / simantics / 3d.git / blobdiff