org.simantics.plant3d/src/org/simantics/plant3d/scenegraph/TurnComponent.java

   1 package org.simantics.plant3d.scenegraph;
   2
   3 import java.util.HashMap;
   4 import java.util.Map;
   5
   6 import javax.vecmath.Vector3d;
   7
   8 import org.simantics.g3d.math.MathTools;
   9 import org.simantics.g3d.property.annotations.GetPropertyValue;
  10 import org.simantics.g3d.property.annotations.SetPropertyValue;
  11 import org.simantics.g3d.scenegraph.base.ParentNode;
  12 import org.simantics.objmap.graph.annotations.DynamicGraphType;
  13 import org.simantics.objmap.graph.annotations.GetType;
  14 import org.simantics.objmap.graph.annotations.RelatedGetValue;
  15 import org.simantics.objmap.graph.annotations.RelatedSetValue;
  16 import org.simantics.objmap.graph.annotations.SetType;
  17 import org.simantics.plant3d.ontology.Plant3D;
  18 import org.simantics.plant3d.scenegraph.controlpoint.ControlPointFactory;
  19 import org.simantics.plant3d.scenegraph.controlpoint.PipeControlPoint;
  20 import org.simantics.plant3d.scenegraph.controlpoint.PipingRules;
  21
  22 @DynamicGraphType(Plant3D.URIs.TurnComponent)
  23 public class TurnComponent extends PipelineComponent {
  24
  25
  26         private String type;
  27         private PipeControlPoint controlPoint;
  28         private Integer turnRadiusIndex;
  29
  30         @GetType(Plant3D.URIs.TurnComponent)
  31         public String getType() {
  32                 return type;
  33         }
  34
  35         @SetType(Plant3D.URIs.TurnComponent)
  36         public void setType(String type) throws Exception{
  37                 this.type = type;
  38                 controlPoint = ControlPointFactory.create(this);
  39         }
  40
  41         @Override
  42         public PipeControlPoint getControlPoint() {
  43                 return controlPoint;
  44         }
  45
  46         @Override
  47         public void setParent(ParentNode<?> parent, String name) {
  48                 super.setParent(parent, name);
  49                 setPipeRun((PipeRun)parent);
  50         }
  51
  52         @Override
  53         public Map<String, Object> updateParameterMap() {
  54                 Map<String,Object> map = new HashMap<String, Object>();
  55
  56                 if (getPipeRun() != null) {
  57                 map.put("turnRadius", getTurnRadius());
  58                 map.put("radius", getDiameter() * 0.5);
  59                 }
  60                 if (controlPoint != null && controlPoint.getTurnAngle() != null  && !Double.isNaN(controlPoint.getTurnAngle())) {
  61                         map.put("turnAngle", controlPoint.getTurnAngle());
  62                 }
  63                 return map;
  64         }
  65
  66         public boolean isVariableAngle() {
  67                 return !controlPoint.isFixed();
  68         }
  69
  70         @Override
  71         public void updateParameters() {
  72                 super.updateParameters();
  73                 if (controlPoint.asFixedAngle()) {
  74                         Map<String,Object> calculated = getCalculatedParameters();
  75                         if (calculated.containsKey("length")) {
  76                                 controlPoint.setLength((Double)calculated.get("length"));
  77                         }
  78                         PipingRules.requestUpdate(getControlPoint());
  79                 }
  80         }
  81
  82         @RelatedGetValue(Plant3D.URIs.HasTurnAngle)
  83         public Double getTurnAngle() {
  84             if (!getControlPoint().asFixedAngle())
  85                 return null;
  86                 return getControlPoint().getTurnAngle();
  87         }
  88
  89         @RelatedSetValue(Plant3D.URIs.HasTurnAngle)
  90         public void setTurnAngle(Double a) {
  91                 if (!getControlPoint().asFixedAngle())
  92                         return;
  93                 getControlPoint().setTurnAngle(a);
  94         }
  95
  96         @GetPropertyValue(name="Turn Angle", value="turn angle", tabId = "Default")
  97         public Double getTurnAngleDeg() {
  98                 Double d = getControlPoint().getTurnAngle();
  99                 if (d == null)
 100                         return null;
 101                 return MathTools.radToDeg(d);
 102         }
 103
 104         public Vector3d getTurnAxis() {
 105                 return getControlPoint().getTurnAxis();
 106         }
 107
 108         @GetPropertyValue(name="Turn Radius", value="TurnRadius", tabId = "Default")
 109         public Double getTurnRadius() {
 110             if (turnRadiusIndex != null)
 111                 return getPipeRun().getTurnRadiusArray()[turnRadiusIndex];
 112             return getPipeRun().getTurnRadiusArray()[0];
 113         }
 114
 115         @RelatedGetValue(Plant3D.URIs.HasTurnRadiusIndex)
 116         @GetPropertyValue(name="Turn Radius Index", value=Plant3D.URIs.HasTurnRadiusIndex, tabId = "Default")
 117         public Integer getTurnRadiusIndex()
 118         {
 119         // TODO: For backwards compatibility, we do not accept null values.
 120         //       One development path would allow null index, and setting custom turn radius for the component.
 121         if (turnRadiusIndex == null)
 122                 return 0;
 123             return turnRadiusIndex;
 124         }
 125
 126         @RelatedSetValue(Plant3D.URIs.HasTurnRadiusIndex)
 127         @SetPropertyValue(value=Plant3D.URIs.HasTurnRadiusIndex)
 128     public void setTurnRadiusIndex(Integer turnRadiusIndex) {
 129             if (this.turnRadiusIndex == turnRadiusIndex)
 130                 return;
 131             if (turnRadiusIndex == null)
 132                 return;
 133             if (turnRadiusIndex != null && getPipeRun() != null) {
 134                 if (getPipeRun().getTurnRadiusArray().length <= turnRadiusIndex)
 135                     return;
 136             }
 137             this.turnRadiusIndex = turnRadiusIndex;
 138         firePropertyChanged(Plant3D.URIs.HasTurnRadiusIndex);
 139         PipingRules.requestUpdate(getControlPoint());
 140     }
 141
 142         @RelatedGetValue(Plant3D.URIs.HasRotationAngle)
 143         @GetPropertyValue(name="Rotation Angle", value=Plant3D.URIs.HasRotationAngle, tabId = "Default")
 144         public Double getRotationAngle() {
 145                 if (!controlPoint.asFixedAngle())
 146                         return null;
 147                 Double d = controlPoint.getRotationAngle();
 148                 if (d == null)
 149                         return 0.0;
 150                 return MathTools.radToDeg(d);
 151         }
 152         @RelatedSetValue(Plant3D.URIs.HasRotationAngle)
 153         @SetPropertyValue(value=Plant3D.URIs.HasRotationAngle)
 154         public void setRotationAngle(Double angle) {
 155                 if (!controlPoint.asFixedAngle())
 156                         return;
 157
 158                 if (angle == null || Double.isInfinite(angle) || Double.isNaN(angle)) {
 159                         return;
 160                 }
 161                 angle = MathTools.degToRad(angle);
 162                 if (controlPoint.getRotationAngle() != null && Math.abs(controlPoint.getRotationAngle()-angle) < MathTools.NEAR_ZERO)
 163                         return;
 164                 controlPoint.setRotationAngle(angle);
 165                 PipingRules.requestUpdate(getControlPoint());
 166         }
 167
 168         @RelatedGetValue(Plant3D.URIs.IsReversed)
 169         @GetPropertyValue(name="Reverse", value=Plant3D.URIs.IsReversed, tabId = "Default")
 170         public Boolean isReversed() {
 171                 if (!controlPoint.asFixedAngle())
 172                         return null;
 173                 Boolean d = controlPoint._getReversed();
 174                 return d;
 175         }
 176         @RelatedSetValue(Plant3D.URIs.IsReversed)
 177         public void setReversed(Boolean reverse) {
 178                 if (!controlPoint.asFixedAngle())
 179                         return;
 180
 181                 if (reverse == null) {
 182                         return;
 183                 }
 184                 controlPoint.setReversed(reverse);
 185                 PipingRules.requestUpdate(getControlPoint());
 186         }
 187
 188         @Override
 189         protected double[] getColor() {
 190                 if (getControlPoint() == null || !getControlPoint().isFixed())
 191                         return new double[]{0.6,0.6,0.6};
 192                 else
 193                         return new double[]{1.0,0.0,0.0};
 194         }
 195 }