Robust/src/Benchmarks/oooJava/D2/Cavity.java

   1 public class Cavity {
   2
   3   protected Tuple center;
   4   protected Node centerNode;
   5   protected Element centerElement;
   6   protected int dim;
   7   protected LinkedList frontier;
   8   protected Subgraph pre;
   9   protected Subgraph post;
  10   private final UndirectedEdgeGraph graph;
  11   protected HashSet connections;
  12
  13   public Cavity(UndirectedEdgeGraph mesh) {
  14     center = null;
  15     graph = mesh;
  16     connections = new HashSet();
  17     frontier = new LinkedList();
  18     pre = new Subgraph();
  19     post = new Subgraph();
  20   }
  21
  22   public Subgraph getPre() {
  23     return pre;
  24   }
  25
  26   public Subgraph getPost() {
  27     return post;
  28   }
  29
  30   public void triggerAbort() {
  31   }
  32
  33   public void triggerBorderConflict() {
  34   }
  35
  36   public void initialize(Node node) {
  37     pre.reset();
  38     post.reset();
  39     connections.clear();
  40     frontier = new LinkedList();
  41     centerNode = node;
  42     for (centerElement = (Element) getNodeData(centerNode); graph.containsNode(centerNode)
  43         && centerElement.isObtuse();) {
  44       Edge_d oppositeEdge = getOpposite(centerNode);
  45       if (getSource(oppositeEdge) == centerNode)
  46         centerNode = getDest(oppositeEdge);
  47       else
  48         centerNode = getSource(oppositeEdge);
  49       centerElement = (Element) getNodeData(centerNode);
  50       if (centerNode == null)
  51         System.exit(-1);
  52     }
  53
  54     center = centerElement.center();
  55     dim = centerElement.getDim();
  56     pre.addNode(centerNode);
  57     frontier.addLast(centerNode);
  58   }
  59
  60   private Edge_d getOpposite(Node node) {
  61     Element element = (Element) graph.getNodeData(node);
  62
  63     // Don't think we'd run into it but..
  64     // TODO check this.
  65     // if(neighbors.size() != 3)
  66     // throw new Error(String.format("neighbors %d", new Object[] {
  67     // Integer.valueOf(neighbors.size())
  68     // }));
  69
  70     int cntOutNeighbors = 0;
  71
  72     for (Iterator iterator = graph.getOutNeighbors(node); iterator.hasNext();) {
  73       ++cntOutNeighbors;
  74       Node neighbor = (Node) iterator.next();
  75       Edge_d edge = graph.getEdge(node, neighbor);
  76       ElementEdge edge_data = (ElementEdge) graph.getEdgeData(edge);
  77       if (element.getObtuse().notEquals(edge_data.getPoint(0))
  78           && element.getObtuse().notEquals(edge_data.getPoint(1)))
  79         return edge;
  80     }
  81
  82     System.out.println("Error: \"Edge\" in Cavity.java getOpposite(Node)");
  83     System.out.println("  tri="+element+" has "+cntOutNeighbors+" out-neighbors");
  84     System.out.println("  obtuse="+element.getObtuse());
  85     System.exit(-1);
  86     return null; // it's here so the compiler doesn't complain.
  87   }
  88
  89   public boolean isMember(Node node) {
  90     Element element = (Element) getNodeData(node);
  91     return element.inCircle(center);
  92   }
  93
  94   public void build() {
  95     while (frontier.size() != 0) {
  96       Node curr = (Node) frontier.removeFirst();
  97       for (Iterator iterator = getOutNeighbors(curr); iterator.hasNext();) {
  98         Node next = (Node) iterator.next();
  99         Element nextElement = (Element) getNodeData(next);
 100         Edge_d edge = getEdge(curr, next);
 101         if ((dim != 2 || nextElement.getDim() != 2 || next == centerNode) && isMember(next)) {
 102           if (nextElement.getDim() == 2 && dim != 2) {
 103             initialize(next);
 104             build();
 105             return;
 106           }
 107           if (!pre.existsNode(next)) {
 108             pre.addNode(next);
 109             pre.addEdge(edge);
 110             frontier.addLast(next);
 111           }
 112         } else if (!connections.contains(edge)) {
 113           connections.add(edge);
 114           pre.addBorder(next);
 115         }
 116       }
 117
 118     }
 119   }
 120
 121   public void update() {
 122     if (centerElement.getDim() == 2) {
 123       Element ele1 = new Element(center, centerElement.getPoint(0));
 124       Node node1 = graph.createNode(ele1);
 125       post.addNode(node1);
 126       Element ele2 = new Element(center, centerElement.getPoint(1));
 127       Node node2 = graph.createNode(ele2);
 128       post.addNode(node2);
 129     }
 130     Node ne_node;
 131     for (HashMapIterator iterator = connections.iterator(); iterator.hasNext(); post.addNode(ne_node)) {
 132       Edge_d conn = (Edge_d) iterator.next();
 133       ElementEdge edge = (ElementEdge) getEdgeData(conn);
 134       Element new_element = new Element(center, edge.getPoint(0), edge.getPoint(1));
 135       ne_node = graph.createNode(new_element);
 136       Node ne_connection;
 137       if (pre.existsNode(getDest(conn)))
 138         ne_connection = getSource(conn);
 139       else
 140         ne_connection = getDest(conn);
 141       ElementEdge new_edge =
 142           new_element.getRelatedEdge((Element) getNodeData(ne_connection));
 143       post.addEdge(createEdge(ne_node, ne_connection, new_edge));
 144
 145       // Collection postnodes = (Collection)post.getNodes().clone();
 146       LinkedList postnodes = new LinkedList();
 147       for (Iterator it = post.getNodes().iterator(); it.hasNext();) {
 148         postnodes.addLast(it.next());
 149       }
 150
 151       for (Iterator iterator1 = postnodes.iterator(); iterator1.hasNext();) {
 152         Node node = (Node) iterator1.next();
 153         Element element = (Element) getNodeData(node);
 154         if (element.isRelated(new_element)) {
 155           ElementEdge ele_edge = new_element.getRelatedEdge(element);
 156           post.addEdge(createEdge(ne_node, node, ele_edge));
 157         }
 158       }
 159     }
 160   }
 161
 162   private Object getNodeData(Node n) {
 163     return ((EdgeGraphNode) n).data;
 164   }
 165
 166   public Node getSource(Edge_d e) {
 167     return ((GraphEdge) e).getSrc();
 168   }
 169
 170   public Node getDest(Edge_d e) {
 171     return ((GraphEdge) e).getDest();
 172   }
 173
 174   public Edge_d getEdge(Node src, Node dest) {
 175     return ((EdgeGraphNode) src).getOutEdge((EdgeGraphNode) dest);
 176   }
 177
 178
 179   public Edge_d createEdge(Node src, Node dest, Object e) {
 180     return new GraphEdge((EdgeGraphNode) src, (EdgeGraphNode) dest, e);
 181   }
 182
 183   public Iterator getOutNeighbors(Node src) {
 184     return ((EdgeGraphNode) src).getOutNeighbors();
 185   }
 186
 187   public Object getEdgeData(Edge_d e) {
 188     return ((GraphEdge) e).d;
 189   }
 190 }