Robust/src/Benchmarks/oooJava/DelaunayRefinement/Element.java

   1 public class Element {
   2   private final boolean bObtuse;
   3   private final boolean bBad;
   4   private final Tuple obtuse;
   5   private final Tuple coords[];
   6   private final ElementEdge edges[];
   7   private final int dim;
   8   private final Tuple center;
   9   private final double radius_squared;
  10   private static final double MINANGLE = 30D;
  11
  12   public Element(Tuple a, Tuple b, Tuple c) {
  13     dim = 3;
  14     coords = new Tuple[3];
  15     coords[0] = a;
  16     coords[1] = b;
  17     coords[2] = c;
  18     if (b.lessThan(a) || c.lessThan(a))
  19       if (b.lessThan(c)) {
  20         coords[0] = b;
  21         coords[1] = c;
  22         coords[2] = a;
  23       } else {
  24         coords[0] = c;
  25         coords[1] = a;
  26         coords[2] = b;
  27       }
  28     edges = new ElementEdge[3];
  29     edges[0] = new ElementEdge(coords[0], coords[1]);
  30     edges[1] = new ElementEdge(coords[1], coords[2]);
  31     edges[2] = new ElementEdge(coords[2], coords[0]);
  32     boolean l_bObtuse = false;
  33     boolean l_bBad = false;
  34     Tuple l_obtuse = null;
  35     for (int i = 0; i < 3; i++) {
  36       double angle = getAngle(i);
  37       if (angle > 90.099999999999994D) {
  38         l_bObtuse = true;
  39         l_obtuse = new Tuple(coords[i]);
  40       } else if (angle < 30D)
  41         l_bBad = true;
  42     }
  43
  44     bBad = l_bBad;
  45     bObtuse = l_bObtuse;
  46     obtuse = l_obtuse;
  47     Tuple x = b.subtract(a);
  48     Tuple y = c.subtract(a);
  49     double xlen = a.distance(b);
  50     double ylen = a.distance(c);
  51     double cosine = x.dotp(y) / (xlen * ylen);
  52     double sine_sq = 1.0D - cosine * cosine;
  53     double plen = ylen / xlen;
  54     double s = plen * cosine;
  55     double t = plen * sine_sq;
  56     double wp = (plen - cosine) / (2D * t);
  57     double wb = 0.5D - wp * s;
  58     Tuple tmpval = a.scale(1.0D - wb - wp);
  59     tmpval = tmpval.add(b.scale(wb));
  60     center = tmpval.add(c.scale(wp));
  61     radius_squared = center.distance_squared(a);
  62   }
  63
  64   public Element(Tuple a, Tuple b) {
  65     dim = 2;
  66     coords = new Tuple[2];
  67     coords[0] = a;
  68     coords[1] = b;
  69     if (b.lessThan(a)) {
  70       coords[0] = b;
  71       coords[1] = a;
  72     }
  73     edges = new ElementEdge[2];
  74     edges[0] = new ElementEdge(coords[0], coords[1]);
  75     edges[1] = new ElementEdge(coords[1], coords[0]);
  76     bBad = false;
  77     bObtuse = false;
  78     obtuse = null;
  79     center = a.add(b).scale(0.5D);
  80     radius_squared = center.distance_squared(a);
  81   }
  82
  83
  84
  85   public Tuple center() {
  86     return center;
  87   }
  88
  89   public boolean inCircle(Tuple p) {
  90     double ds = center.distance_squared(p);
  91     return ds <= radius_squared;
  92   }
  93
  94   public double getAngle(int i) {
  95     int j = i + 1;
  96     if (j == dim)
  97       j = 0;
  98     int k = j + 1;
  99     if (k == dim)
 100       k = 0;
 101     Tuple a = coords[i];
 102     Tuple b = coords[j];
 103     Tuple c = coords[k];
 104     return Tuple.angle(b, a, c);
 105   }
 106
 107   public ElementEdge getEdge(int i) {
 108     return edges[i];
 109   }
 110
 111   public Tuple getPoint(int i) {
 112     return coords[i];
 113   }
 114
 115   public Tuple getObtuse() {
 116     return obtuse;
 117   }
 118
 119   public boolean isBad() {
 120     return bBad;
 121   }
 122
 123   public int getDim() {
 124     return dim;
 125   }
 126
 127   public int numEdges() {
 128     return (dim + dim) - 3;
 129   }
 130
 131   public boolean isObtuse() {
 132     return bObtuse;
 133   }
 134
 135   public ElementEdge getRelatedEdge(Element e) {
 136     int edim = e.getDim();
 137     ElementEdge e_edge2 = null;
 138     ElementEdge my_edge = edges[0];
 139     ElementEdge e_edge0 = e.edges[0];
 140     if (my_edge.equals(e_edge0))
 141       return my_edge;
 142     ElementEdge e_edge1 = e.edges[1];
 143     if (my_edge.equals(e_edge1))
 144       return my_edge;
 145     if (edim == 3) {
 146       e_edge2 = e.edges[2];
 147       if (my_edge.equals(e_edge2))
 148         return my_edge;
 149     }
 150     my_edge = edges[1];
 151     if (my_edge.equals(e_edge0))
 152       return my_edge;
 153     if (my_edge.equals(e_edge1))
 154       return my_edge;
 155     if (edim == 3 && my_edge.equals(e_edge2))
 156       return my_edge;
 157     if (dim == 3) {
 158       my_edge = edges[2];
 159       if (my_edge.equals(e_edge0))
 160         return my_edge;
 161       if (my_edge.equals(e_edge1))
 162         return my_edge;
 163       if (edim == 3 && my_edge.equals(e_edge2))
 164         return my_edge;
 165     }
 166     return null;
 167   }
 168
 169   public Element getCopy() {
 170     if (dim == 3)
 171       return new Element(coords[0], coords[1], coords[2]);
 172     else
 173       return new Element(coords[0], coords[1]);
 174   }
 175
 176   public boolean lessThan(Element e) {
 177     if (dim < e.getDim())
 178       return false;
 179     if (dim > e.getDim())
 180       return true;
 181     for (int i = 0; i < dim; i++) {
 182       if (coords[i].lessThan(e.coords[i]))
 183         return true;
 184       if (coords[i].greaterThan(e.coords[i]))
 185         return false;
 186     }
 187
 188     return false;
 189   }
 190
 191   public boolean isRelated(Element e) {
 192     int edim = e.getDim();
 193     ElementEdge e_edge2 = null;
 194     ElementEdge my_edge = edges[0];
 195     ElementEdge e_edge0 = e.edges[0];
 196     if (my_edge.equals(e_edge0))
 197       return true;
 198     ElementEdge e_edge1 = e.edges[1];
 199     if (my_edge.equals(e_edge1))
 200       return true;
 201     if (edim == 3) {
 202       e_edge2 = e.edges[2];
 203       if (my_edge.equals(e_edge2))
 204         return true;
 205     }
 206     my_edge = edges[1];
 207     if (my_edge.equals(e_edge0))
 208       return true;
 209     if (my_edge.equals(e_edge1))
 210       return true;
 211     if (edim == 3 && my_edge.equals(e_edge2))
 212       return true;
 213     if (dim == 3) {
 214       my_edge = edges[2];
 215       if (my_edge.equals(e_edge0))
 216         return true;
 217       if (my_edge.equals(e_edge1))
 218         return true;
 219       if (edim == 3 && my_edge.equals(e_edge2))
 220         return true;
 221     }
 222     return false;
 223   }
 224
 225   public String toString() {
 226     String ret = "[";
 227     for (int i = 0; i < dim; i++) {
 228       ret += coords[i].toString();
 229       if (i != (dim - 1)) {
 230         ret += ", ";
 231       }
 232     }
 233     ret += "]";
 234     return ret;
 235   }
 236 }