package org.simantics.plant3d.scenegraph; import java.util.Collections; import java.util.Map; import javax.vecmath.Quat4d; import javax.vecmath.Tuple3d; import javax.vecmath.Vector3d; import org.simantics.g3d.math.MathTools; import org.simantics.g3d.property.annotations.GetPropertyValue; import org.simantics.g3d.property.annotations.PropertyContributor; import org.simantics.objmap.graph.annotations.RelatedGetObj; import org.simantics.objmap.graph.annotations.RelatedSetObj; import org.simantics.plant3d.ontology.Plant3D; import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint; import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint.Type; import org.simantics.plant3d.scenegraph.controlpoint.PipingRules; /** * * @author Marko Luukkainen * */ @PropertyContributor public abstract class PipelineComponent extends GeometryNode { private PipeRun pipeRun; private PipeRun alternativePipeRun; private PipelineComponent next; private PipelineComponent previous; /** * Sets the pipe run. * * With in-line,turn, and end components, the pipe run is the parent object in the scene-graph. * With nozzles, the pipe run setting is explicit (nozzle has to be linked to the piperun, since the parent object is equipment). * With size change components (in-line), there is also alternative pipe run, which must match the next component's pipe run. * * @param pipeRun */ public void setPipeRun(PipeRun pipeRun) { if (pipeRun == this.pipeRun) return; this.pipeRun = pipeRun; if (getControlPoint() != null) { getControlPoint().deattach(); if (pipeRun != null) { pipeRun.addChild(getControlPoint()); } } updateParameters(); } @RelatedGetObj(Plant3D.URIs.HasAlternativePipeRun) public PipeRun getAlternativePipeRun() { return alternativePipeRun; } @RelatedSetObj(Plant3D.URIs.HasAlternativePipeRun) public void setAlternativePipeRun(PipeRun pipeRun) { if (this.alternativePipeRun == pipeRun) return; this.alternativePipeRun = pipeRun; if (getControlPoint().isDualInline()) { PipeControlPoint sub = getControlPoint().getSubPoint().get(0); if (sub.getParent() != this.alternativePipeRun) this.alternativePipeRun.addChild(sub); } firePropertyChanged(Plant3D.URIs.HasAlternativePipeRun); } @Override public void updateParameters() { setParameterMap(updateParameterMap()); super.updateParameters(); } public abstract void setType(String typeURI) throws Exception; @RelatedGetObj(Plant3D.URIs.HasNext) public PipelineComponent getNext() { return next; } @RelatedSetObj(Plant3D.URIs.HasNext) public void setNext(PipelineComponent comp) { if (next == comp) return; if (this.next != null) this.next._removeRef(this); this.next = comp; this.syncnext = false; syncNext(); firePropertyChanged(Plant3D.URIs.HasNext); if (comp != null) comp.sync(); // System.out.println(this + " next " + comp); } @RelatedGetObj(Plant3D.URIs.HasPrevious) public PipelineComponent getPrevious() { return previous; } @RelatedSetObj(Plant3D.URIs.HasPrevious) public void setPrevious(PipelineComponent comp) { if (previous == comp) return; if (this.previous != null) this.previous._removeRef(this); this.previous = comp; this.syncprev = false; syncPrevious(); firePropertyChanged(Plant3D.URIs.HasPrevious); if (comp != null) comp.sync(); // System.out.println(this + " prev " + comp); } private PipelineComponent branch0; @RelatedGetObj(Plant3D.URIs.HasBranch0) public PipelineComponent getBranch0() { return branch0; } @RelatedSetObj(Plant3D.URIs.HasBranch0) public void setBranch0(PipelineComponent comp) { if (branch0 == comp) return; if (this.branch0 != null) this.branch0._removeRef(this); this.branch0 = comp; this.syncbr0 = false; syncBranch0(); firePropertyChanged(Plant3D.URIs.HasBranch0); if (comp != null) comp.sync(); // System.out.println(this + " next " + comp); } @GetPropertyValue(name="Previous",tabId="Debug",value=Plant3D.URIs.HasPrevious) public String getPreviousDebug() { if (previous == null) return null; return previous.getName(); } @GetPropertyValue(name="Next",tabId="Debug",value=Plant3D.URIs.HasNext) public String getNextDebug() { if (next == null) return null; return next.getName(); } @GetPropertyValue(name="Branch0",tabId="Debug",value=Plant3D.URIs.HasBranch0) public String getBR0Debug() { if (branch0 == null) return null; return branch0.getName(); } private PipeControlPoint getBranchPoint() { PipeControlPoint branchPoint; if (getControlPoint().getSubPoint().size() > 0) { branchPoint = getControlPoint().getSubPoint().get(0); } else { if (branch0.getPipeRun() == null) return null; branchPoint = new PipeControlPoint(this,branch0.getPipeRun()); branchPoint.setFixed(false); branchPoint.setType(Type.END); branchPoint.parent = getControlPoint(); getControlPoint().children.add(branchPoint); branchPoint.setWorldOrientation(getControlPoint().getWorldOrientation()); branchPoint.setWorldPosition(getControlPoint().getWorldPosition()); } return branchPoint; } private boolean _connectNext(PipeControlPoint pcp, PipeControlPoint nextPCP) { if (nextPCP == null) return false; if (pcp.getNext() != nextPCP) { pcp.setNext(nextPCP); } if (pcp.isDualInline()) { PipeControlPoint sub = pcp.getSubPoint().get(0); if (sub.getNext() != nextPCP) sub.setNext(nextPCP); } return true; } private boolean _connectPrev(PipeControlPoint pcp, PipeControlPoint prevPCP) { if (prevPCP == null) return false; if (prevPCP.isDualInline()) prevPCP = prevPCP.getSubPoint().get(0); if (pcp.getPrevious() != prevPCP) { pcp.setPrevious(prevPCP); } if (pcp.isDualInline()) { PipeControlPoint sub = pcp.getSubPoint().get(0); if (sub.getPrevious() != prevPCP) sub.setPrevious(prevPCP); } return true; } // When link to a component is removed, also link to the other direction must be removed at the same time, or // Control point structure is left into illegal state. private void _removeRef(PipelineComponent comp) { if (next == comp) { next = null; syncnext = false; syncNext(); } else if (previous == comp) { previous = null; syncprev = false; syncPrevious(); } else if (branch0 == comp) { branch0 = null; syncbr0 = false; syncBranch0(); } } boolean syncnext = false; private void syncNext() { if (syncnext) return; syncnext = _syncNext(); } private boolean _syncNext() { PipeControlPoint pcp = getControlPoint(); if (pcp != null) { if (next != null ) { if (next.getControlPoint() != null) { // TODO, relying that the other direction is connected. boolean nxt = next.getPrevious() == this; boolean br0 = next.getBranch0() == this; if (nxt){ return _connectNext(pcp, next.getControlPoint()); } else if (br0) { return _connectNext(pcp, next.getBranchPoint()); } else { return false; } } else { return false; } } else if (pcp.getNext() != null) { pcp.setNext(null); return true; } } else { return false; } return true; } boolean syncprev = false; private void syncPrevious() { if (syncprev) return; syncprev = _syncPrevious(); } private boolean _syncPrevious() { PipeControlPoint pcp = getControlPoint(); if (pcp != null) { if (previous != null ) { if (previous.getControlPoint() != null) { // TODO, relying that the other direction is connected. boolean prev = previous.getNext() == this; boolean br0 = previous.getBranch0() == this; if (prev){ return _connectPrev(pcp, previous.getControlPoint()); } else if (br0) { return _connectPrev(pcp, previous.getBranchPoint()); } else { return false; } } else { return false; } } else if (pcp.getPrevious() != null) { pcp.setPrevious(null); return true; } } else { return false; } return true; } boolean syncbr0 = false; private void syncBranch0() { if (syncbr0) return; syncbr0 = _syncBranch0(); } private boolean _syncBranch0() { if (getControlPoint() != null) { if (getControlPoint().isDualInline()) { branch0 = null; return false; } if (branch0 != null) { if (branch0.getControlPoint() != null) { PipeControlPoint branchPoint = getBranchPoint(); PipeControlPoint pcp = branch0.getControlPoint(); // TODO, relying that the other direction is connected. boolean next = branch0.getPrevious() == this; // this --> branch0 boolean prev = branch0.getNext() == this; if (next) { _connectNext(branchPoint, pcp); } else if (prev){ _connectPrev(branchPoint, pcp); } else { return false; } } else { return false; } } else if (getControlPoint().getSubPoint().size() > 0) { // TODO : this may cause problems? (Removes branch point, before branch has been set?) getControlPoint().getSubPoint().get(0).remove(); getControlPoint().children.clear(); return true; } } else { return false; } return true; } public void sync() { syncPrevious(); syncNext(); syncBranch0(); } public void sync2() { // if (getControlPoint().isDualInline()) { // PipeControlPoint sub = getControlPoint().getSubPoint().get(0); // next.getControlPoint().getPipeRun().addChild(sub); // } getControlPoint()._setWorldOrientation(getWorldOrientation()); getControlPoint()._setWorldPosition(getWorldPosition()); } public Map updateParameterMap() { return Collections.EMPTY_MAP; } public PipeRun getPipeRun() { return pipeRun; } public abstract String getType(); public abstract PipeControlPoint getControlPoint(); @Override public void remove() { PipeControlPoint pcp = getControlPoint(); // Second check is needed, when remove process is initiated from control point. if (pcp != null && pcp.getPipelineComponent() != null) { pcp.remove(); } super.remove(); } @Override protected double[] getColor() { if (getControlPoint() == null || !getControlPoint().isFixed()) return new double[]{0.7,0.7,0.7}; else return new double[]{1.0,0.0,0.0}; } @Override protected double[] getSelectedColor() { return new double[]{0.5,0,0.5}; } @Override public void setOrientation(Quat4d orientation) { if (MathTools.equals(orientation, getOrientation())) return; super.setOrientation(orientation); if (getControlPoint() != null) { getControlPoint()._setWorldOrientation(getWorldOrientation()); try { PipingRules.requestUpdate(getControlPoint()); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } } @Override public void setPosition(Vector3d position) { if (MathTools.equals(position, getPosition())) return; super.setPosition(position); if (getControlPoint() != null) { getControlPoint()._setWorldPosition(getWorldPosition()); try { PipingRules.requestUpdate(getControlPoint()); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } } public void _setWorldPosition(Vector3d position) { Vector3d localPos = getLocalPosition(position); super.setPosition(localPos); } public void _setWorldOrientation(Quat4d orientation) { Quat4d localOr = getLocalOrientation(orientation); super.setOrientation(localOr); } @GetPropertyValue(name="Flow Length", value="flowlength", tabId = "Default") public Double getFlowLength() { PipeControlPoint pcp = getControlPoint(); if (pcp == null) return null; switch (pcp.getType()) { case INLINE: return pcp.getLength(); case END: return null; case TURN: { double r = getPipeRun().getTurnRadius(); double a = pcp.getTurnAngle(); return a*r; } default: return null; } } public void getControlPointEnds(Tuple3d p1, Tuple3d p2) { getControlPoint().getControlPointEnds(p1, p2); } public Vector3d getNormal() { Vector3d v = new Vector3d(); MathTools.rotate(getWorldOrientation(), MathTools.Z_AXIS, v); return v; } }