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

   1 import java.io.*;
   2 import java.util.*;
   3 import java.util.zip.GZIPInputStream;
   4
   5 public class Mesh {
   6
   7     public Mesh() {
   8     }
   9
  10     public static HashSet getBad(EdgeGraph mesh) {
  11         HashSet ret = new HashSet();
  12         for(Iterator iterator = mesh.iterator(); iterator.hasNext();) {
  13             Node node = (Node)iterator.next();
  14             Element element = (Element)mesh.getNodeData(node);
  15             if(element.isBad())
  16                 ret.add(node);
  17         }
  18
  19         return ret;
  20     }
  21
  22     private static Scanner getScanner(String filename)
  23         throws Exception {
  24         try {
  25             return new Scanner(new GZIPInputStream(new FileInputStream((new StringBuilder(String.valueOf(filename))).append(".gz").toString())));
  26         }
  27         catch(FileNotFoundException _) {
  28             return new Scanner(new FileInputStream(filename));
  29         }
  30     }
  31
  32     private Tuple[] readNodes(String filename)
  33         throws Exception {
  34         Scanner scanner = getScanner((new StringBuilder(String.valueOf(filename))).append(".node").toString());
  35         int ntups = scanner.nextInt();
  36         scanner.nextInt();
  37         scanner.nextInt();
  38         scanner.nextInt();
  39         Tuple tuples[] = new Tuple[ntups];
  40         for(int i = 0; i < ntups; i++) {
  41             int index = scanner.nextInt();
  42             double x = scanner.nextDouble();
  43             double y = scanner.nextDouble();
  44             scanner.nextDouble();
  45             tuples[index] = new Tuple(x, y, 0.0D);
  46         }
  47
  48         return tuples;
  49     }
  50
  51     private void readElements(EdgeGraph mesh, String filename, Tuple tuples[])
  52         throws Exception {
  53         Scanner scanner = getScanner((new StringBuilder(String.valueOf(filename))).append(".ele").toString());
  54         int nels = scanner.nextInt();
  55         scanner.nextInt();
  56         scanner.nextInt();
  57         Element elements[] = new Element[nels];
  58         for(int i = 0; i < nels; i++) {
  59             int index = scanner.nextInt();
  60             int n1 = scanner.nextInt();
  61             int n2 = scanner.nextInt();
  62             int n3 = scanner.nextInt();
  63             elements[index] = new Element(tuples[n1], tuples[n2], tuples[n3]);
  64             addElement(mesh, elements[index]);
  65         }
  66
  67     }
  68
  69     private void readPoly(EdgeGraph mesh, String filename, Tuple tuples[])
  70         throws Exception {
  71         Scanner scanner = getScanner((new StringBuilder(String.valueOf(filename))).append(".poly").toString());
  72         scanner.nextInt();
  73         scanner.nextInt();
  74         scanner.nextInt();
  75         scanner.nextInt();
  76         int nsegs = scanner.nextInt();
  77         scanner.nextInt();
  78         Element segments[] = new Element[nsegs];
  79         for(int i = 0; i < nsegs; i++) {
  80             int index = scanner.nextInt();
  81             int n1 = scanner.nextInt();
  82             int n2 = scanner.nextInt();
  83             scanner.nextInt();
  84             segments[index] = new Element(tuples[n1], tuples[n2]);
  85             addElement(mesh, segments[index]);
  86         }
  87
  88     }
  89
  90     public void read(EdgeGraph mesh, String basename)
  91         throws Exception {
  92         Tuple tuples[] = readNodes(basename);
  93         readElements(mesh, basename, tuples);
  94         readPoly(mesh, basename, tuples);
  95     }
  96
  97     protected Node addElement(EdgeGraph mesh, Element element) {
  98         Node node = mesh.createNode(element);
  99         mesh.addNode(node);
 100         for(int i = 0; i < element.numEdges(); i++) {
 101             Element.Edge edge = element.getEdge(i);
 102             if(!edge_map.containsKey(edge)) {
 103                 edge_map.put(edge, node);
 104             } else {
 105                 Edge new_edge = mesh.createEdge(node, (Node)edge_map.get(edge), edge);
 106                 mesh.addEdge(new_edge);
 107                 edge_map.remove(edge);
 108             }
 109         }
 110
 111         return node;
 112     }
 113
 114     public static boolean verify(EdgeGraph mesh) {
 115         for(Iterator iterator = mesh.iterator(); iterator.hasNext();) {
 116             Node node = (Node)iterator.next();
 117             Element element = (Element)mesh.getNodeData(node);
 118             if(element.getDim() == 2) {
 119                 if(mesh.getOutNeighbors(node).size() != 1) {
 120                     System.out.println((new StringBuilder("-> Segment ")).append(element).append(" has ").append(mesh.getOutNeighbors(node).size()).append(" relation(s)").toString());
 121                     return false;
 122                 }
 123             } else
 124                                 if(element.getDim() == 3) {
 125                                         if(mesh.getOutNeighbors(node).size() != 3) {
 126                                                 System.out.println((new StringBuilder("-> Triangle ")).append(element).append(" has ").append(mesh.getOutNeighbors(node).size()).append(" relation(s)").toString());
 127                                                 return false;
 128                                         }
 129                                 } else {
 130                                         System.out.println((new StringBuilder("-> Figures with ")).append(element.getDim()).append(" edges").toString());
 131                                         return false;
 132                                 }
 133         }
 134
 135         Node start = mesh.getRandom();
 136         Stack remaining = new Stack();
 137         HashSet found = new HashSet();
 138         remaining.push(start);
 139         while(!remaining.isEmpty())  {
 140             Node node = (Node)remaining.pop();
 141             if(!found.contains(node)) {
 142                 found.add(node);
 143                 Node neighbor;
 144                 for(Iterator iterator1 = mesh.getOutNeighbors(node).iterator(); iterator1.hasNext(); remaining.push(neighbor))
 145                     neighbor = (Node)iterator1.next();
 146
 147             }
 148         }
 149         if(found.size() != mesh.getNumNodes()) {
 150             System.out.println("Not all elements are reachable");
 151             return false;
 152         } else {
 153             return true;
 154         }
 155     }
 156
 157     protected static final HashMap edge_map = new HashMap();
 158
 159 }