import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import org.simantics.g3d.math.MathTools;
import org.simantics.g3d.property.annotations.GetPropertyValue;
import org.simantics.g3d.property.annotations.PropertyTabBlacklist;
import org.simantics.g3d.property.annotations.SetPropertyValue;
import org.simantics.g3d.scenegraph.IG3DNode;
+import org.simantics.g3d.vtk.common.VtkView;
import org.simantics.objmap.graph.annotations.GraphType;
import org.simantics.objmap.graph.annotations.RelatedElementsAdd;
import org.simantics.objmap.graph.annotations.RelatedElementsGet;
import org.simantics.plant3d.ontology.Plant3D;
import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
-import vtk.vtkPanel;
import vtk.vtkProp3D;
import vtk.vtkRenderer;
public class PipeRun extends P3DParentNode<IP3DNode> {
private double pipeDiameter = 0.1;
- private double turnRadius = 0.2;
+ private double[] turnRadius = new double[] {0.2};
@Override
public void update(vtkRenderer ren) {
}
@Override
- public void visualize(vtkPanel panel) {
+ public void visualize(VtkView panel) {
}
@Override
public Collection<vtkProp3D> getActors() {
- return Collections.EMPTY_LIST;
+ return Collections.emptyList();
}
@Override
}
+ @SuppressWarnings("deprecation")
@RelatedGetValue(Plant3D.URIs.HasTurnRadius)
@GetPropertyValue(value=Plant3D.URIs.HasTurnRadius, name = "Elbow radius")
public double getTurnRadius() {
- return turnRadius;
+ return turnRadius[0];
}
+ @SuppressWarnings("deprecation")
@RelatedSetValue(Plant3D.URIs.HasTurnRadius)
@SetPropertyValue(Plant3D.URIs.HasTurnRadius)
public void setTurnRadius(double turnRadius) {
- this.turnRadius = turnRadius;
+ this.turnRadius[0] = turnRadius;
firePropertyChanged(Plant3D.URIs.HasTurnRadius);
+ firePropertyChanged(Plant3D.URIs.HasTurnRadiusArray);
}
+ @RelatedGetValue(Plant3D.URIs.HasTurnRadiusArray)
+ @GetPropertyValue(value=Plant3D.URIs.HasTurnRadiusArray, name = "Elbow radius array")
+ public double[] getTurnRadiusArray() {
+ return turnRadius;
+ }
+
+ @RelatedSetValue(Plant3D.URIs.HasTurnRadiusArray)
+ @SetPropertyValue(Plant3D.URIs.HasTurnRadiusArray)
+ public void setTurnRadiusArray(double[] turnRadiusArray) {
+ if (turnRadiusArray == null || turnRadiusArray.length == 0)
+ return;
+ this.turnRadius = turnRadiusArray;
+ firePropertyChanged(Plant3D.URIs.HasTurnRadiusArray);
+ }
+
@RelatedGetValue(Plant3D.URIs.HasPipeDiameter)
@GetPropertyValue(value=Plant3D.URIs.HasPipeDiameter, name = "Diameter")
public double getPipeDiameter() {
firePropertyChanged(Plant3D.URIs.HasPipeDiameter);
}
- @RelatedElementsAdd(Plant3D.URIs.childen)
+ @RelatedElementsAdd(Plant3D.URIs.children)
public void addChild(PipelineComponent node) {
- addNode(Plant3D.URIs.childen,node);
+ addNode(Plant3D.URIs.children,node);
}
- @RelatedElementsGet(Plant3D.URIs.childen)
+ @RelatedElementsGet(Plant3D.URIs.children)
public Collection<PipelineComponent> getChild() {
Collection<PipelineComponent> coll = new ArrayList<PipelineComponent>();
- for (IG3DNode n : getNodes(Plant3D.URIs.childen)) {
+ for (IG3DNode n : getNodes(Plant3D.URIs.children)) {
coll.add((PipelineComponent)n);
}
return coll;
}
- @RelatedElementsRem(Plant3D.URIs.childen)
+ @RelatedElementsRem(Plant3D.URIs.children)
public void remChild(PipelineComponent node) {
- removeNode(Plant3D.URIs.childen, node);
+ removeNode(Plant3D.URIs.children, node);
}
public List<PipelineComponent> getSortedChild() {
List<PipelineComponent> coll = new ArrayList<PipelineComponent>();
- for (IG3DNode n : getNodes(Plant3D.URIs.childen)) {
+ for (IG3DNode n : getNodes(Plant3D.URIs.children)) {
coll.add((PipelineComponent)n);
}
Collections.sort(coll, new ComponentComparator());
return coll;
}
+ private static String PIPECP = "pipecp";
+
public void addChild(PipeControlPoint node) {
- addNode("pipecp",node);
+ addNode(PIPECP,node);
}
public void remChild(PipeControlPoint node) {
- removeNode("pipecp", node);
+ removeNode(PIPECP, node);
}
public void deattachChild(PipeControlPoint node) {
- deattachNode("pipecp", node);
+ deattachNode(PIPECP, node);
}
public Collection<PipeControlPoint> getControlPoints() {
Collection<PipeControlPoint> coll = new ArrayList<PipeControlPoint>();
- for (IG3DNode n : getNodes("pipecp")) {
+ for (IG3DNode n : getNodes(PIPECP)) {
coll.add((PipeControlPoint)n);
}
return coll;
}
+
public boolean equalSpecs(PipeRun other) {
if (!MathTools.equals(pipeDiameter,other.pipeDiameter))
return false;
- if (!MathTools.equals(turnRadius,other.turnRadius))
- return false;
+ if (turnRadius.length != other.turnRadius.length)
+ return false;
+ for (int i = 0; i < turnRadius.length; i++) {
+ if (!MathTools.equals(turnRadius[i],other.turnRadius[i]))
+ return false;
+ }
return true;
}
+ public boolean canMerge(PipeRun other) {
+ return MathTools.equals(pipeDiameter,other.pipeDiameter);
+ }
+
+ /**
+ * Merges contents of PipeRun r2 to this PipeRun. Note: does not connect boundary components!
+ * @param r2
+ */
+ public void merge(PipeRun r2) {
+ Map<Integer, Integer> turnIndexMap = null;
+ if (!this.equalSpecs(r2)) {
+ if (!this.canMerge(r2))
+ throw new IllegalArgumentException("PipeRuns cannot be merged");
+ // Merge turn radii.
+ turnIndexMap = new HashMap<>();
+ List<Double> mergedTurnRadius = new ArrayList<>();
+ for (double t : this.getTurnRadiusArray()) {
+ mergedTurnRadius.add(t);
+ }
+ for (int i2 = 0; i2 < r2.getTurnRadiusArray().length; i2++) {
+ double t2 = r2.getTurnRadiusArray()[i2];
+ boolean found = false;
+ for (int i = 0; i < mergedTurnRadius.size(); i++) {
+ if (MathTools.equals(mergedTurnRadius.get(i), t2)) {
+ turnIndexMap.put(i2, i);
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ turnIndexMap.put(i2, mergedTurnRadius.size());
+ mergedTurnRadius.add(t2);
+ }
+ }
+ for (PipeControlPoint pcp : r2.getControlPoints()) {
+ PipelineComponent comp = pcp.getPipelineComponent();
+ if (comp instanceof TurnComponent) {
+
+ }
+ }
+ if (mergedTurnRadius.size() > this.getTurnRadiusArray().length) {
+ double arr[] = new double[mergedTurnRadius.size()];
+ for (int i = 0; i < mergedTurnRadius.size(); i++) {
+ arr[i] = mergedTurnRadius.get(i);
+ }
+ this.setTurnRadiusArray(arr);
+ }
+ }
+ // Move components and control points
+ Collection<PipeControlPoint> pcps = r2.getControlPoints();
+ for (PipeControlPoint pcp : pcps) {
+ r2.deattachChild(pcp);
+ this.addChild(pcp);
+ PipelineComponent component = pcp.getPipelineComponent();
+ if (component != null) {
+ if (!(component instanceof Nozzle)) {
+ component.deattach();
+ this.addChild(component);
+ } else {
+ Nozzle n = (Nozzle)component;
+ n.setPipeRun(this);
+ }
+ }
+ }
+ // Use new turn radii indexes
+ if (turnIndexMap != null) {
+ for (PipeControlPoint pcp : pcps) {
+ PipelineComponent component = pcp.getPipelineComponent();
+ if (component instanceof TurnComponent) {
+ TurnComponent tc = (TurnComponent)component;
+ if (tc.getTurnRadiusIndex() == null || tc.getTurnRadiusIndex() < 0)
+ continue;
+ tc.setTurnRadiusIndex(turnIndexMap.get(tc.getTurnRadiusIndex()));
+ }
+ }
+ }
+ r2.remove();
+
+ }
+
private class ComponentComparator implements Comparator<PipelineComponent> {
@Override
public int compare(PipelineComponent o1, PipelineComponent o2) {
}
}
+
}
Code Review / simantics / 3d.git / blobdiff