//// This is all pretty useless so far - doesn't work yet!

import java.util.Vector;
import java.util.Hashtable;
import java.util.HashSet;
import java.util.Iterator;

public class EdgeMerge {

  public static void print(String s) {
    System.out.print(s);
  }
  public static void println(String s) {
    System.out.println(s); 
  }

  public static Vector merge(Vector edges) {

    print("consolidating coincident edge points...");
    for (int j = 0; j < edges.size()-1; j++) {
      Edge e1 = (Edge)edges.get(j);
      for (int k = j+1; k < edges.size(); k++) {
        Edge e2 = (Edge)edges.get(k);
        if (Point3d.coincident(e1.p1,e2.p1)) {
          e2.p1 = e1.p1; 
        }
        if (Point3d.coincident(e1.p1,e2.p2)) {
          e2.p2 = e1.p1; 
        }
        if (Point3d.coincident(e1.p2,e2.p1)) {
          e2.p1 = e1.p2;           
        }
        if (Point3d.coincident(e1.p2,e2.p2)) {
          e2.p2 = e1.p2; 
        }
      }
    } 
    println("done");

    Hashtable pointEdges = new Hashtable();
    print("creating an edge list for each contour point...");
    for (int j = 0; j < edges.size()-1; j++) {
      Edge e = (Edge)edges.get(j);
      if (!pointEdges.containsKey(e.p1)) {
        pointEdges.put(e.p1, new Vector());
      }
      if (!pointEdges.containsKey(e.p2)) {
        pointEdges.put(e.p2, new Vector());
      }
    }
    println("done");

    print("associating edges with points...");
    for (int j = 0; j < edges.size()-1; j++) {
      Edge e = (Edge)edges.get(j);
      ((Vector)pointEdges.get(e.p1)).add(e);
      ((Vector)pointEdges.get(e.p2)).add(e);
    }
    println("done");

    print("throwing away non polygon edges");
    Iterator pointIter = pointEdges.keySet().iterator();
    while(pointIter.hasNext()) {
      Point3d p = (Point3d)pointIter.next();
      Vector pEdges = (Vector)pointEdges.get(p);
      if (pEdges.size() <= 1) {
        edges.removeAll(pEdges); 
        pointIter.remove();
        print(".");
      }
    }
    println("done");

    /*
    print("checking contour edge consistency, calculating angles...");
    Hashtable pointAngles = new Hashtable();
    Iterator pointIter = pointEdges.keySet().iterator();
    while(pointIter.hasNext()) {
      Point3d p = (Point3d)pointIter.next();
      Vector pEdges = (Vector)pointEdges.get(p);
      if (pEdges.size() != 2) {
        Vector angles = new Vector();
        pointAngles.put(p,angles);
        for (int i = 0; i < pEdges.size(); i++) {
          Edge e = (Edge)pEdges.get(i);
          double angle = 0.0;
          if (e.p1 == p) {
            angle = Math.atan2(e.p2.y-p.y,e.p2.x-p.x);
          }
          else {  // e.p2 == p
            angle = Math.atan2(e.p1.y-p.y,e.p1.x-p.x);
          }
          if (angle < 0.0) {
            angle += 2.0 * Math.PI;
          }
          angles.add(new Double(angle));
        } 
      }
    }
    println("done");
    */

    Vector polygons = new Vector();
    /*
    System.out.println("building polygons for contour points...");
    for (int i = 0; i < edges.size(); i++) {
      Edge e1 = (Edge)edges.get(i);
      Point3d start = e1.p1;
      P
      while (start != e1.p2) {
        Edge neighbours = (Vector)pointEdges.get(e.p1);
        for (int j = 0; j < neighbours.size(); j++) {
          Edge e2 = (Edge)neighbours.get(j);
          if (e2 == e1) {
            continue;
          }
          
        }
      }
    }
    println("done");
*/
    println("-------------------------------------------------"); 

    return polygons;
  }

}