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