import com.vividsolutions.jts.triangulate.quadedge.QuadEdge; //导入依赖的package包/类
/**
 * Inserts a new point into a subdivision representing a Delaunay
 * triangulation, and fixes the affected edges so that the result is still a
 * Delaunay triangulation.
 * <p>
 *
 * @return a quadedge containing the inserted vertex
 */
public QuadEdge insertSite(Vertex v) {

    /**
     * This code is based on Guibas and Stolfi (1985), with minor modifications
     * and a bug fix from Dani Lischinski (Graphic Gems 1993). (The modification
     * I believe is the test for the inserted site falling exactly on an
     * existing edge. Without this test zero-width triangles have been observed
     * to be created)
     */
    QuadEdge e = this.subdiv.locate(v);

    if (this.subdiv.isVertexOfEdge(e, v)) {
        // point is already in subdivision.
        return e;
    } else if (this.subdiv.isOnEdge(e, v.getCoordinate())) {
        // the point lies exactly on an edge, so delete the edge
        // (it will be replaced by a pair of edges which have the point as a vertex)
        e = e.oPrev();
        this.subdiv.delete(e.oNext());
    }

    /**
     * Connect the new point to the vertices of the containing triangle
     * (or quadrilateral, if the new point fell on an existing edge.)
     */
    QuadEdge base = this.subdiv.makeEdge(e.orig(), v);
    QuadEdge.splice(base, e);
    QuadEdge startEdge = base;
    do {
        base = this.subdiv.connect(e, base.sym());
        e = base.oPrev();
    } while (e.lNext() != startEdge);

    // Examine suspect edges to ensure that the Delaunay condition
    // is satisfied.
    do {
        QuadEdge t = e.oPrev();
        if (t.dest().rightOf(e) && v.isInCircle(e.orig(), t.dest(), e.dest())) {
            QuadEdge.swap(e);
            e = e.oPrev();
        } else if (e.oNext() == startEdge) {
            return base; // no more suspect edges.
        } else {
            e = e.oNext().lPrev();
        }
    } while (true);
}
 

import com.vividsolutions.jts.triangulate.quadedge.QuadEdge; //导入依赖的package包/类
/**
 * Inserts a new point into a subdivision representing a Delaunay
 * triangulation, and fixes the affected edges so that the result is still a
 * Delaunay triangulation.
 * <p/>
 *
 * @return a quadedge containing the inserted vertex
 */
public QuadEdge insertSite(Vertex v) {

    /**
     * This code is based on Guibas and Stolfi (1985), with minor modifications
     * and a bug fix from Dani Lischinski (Graphic Gems 1993). (The modification
     * I believe is the test for the inserted site falling exactly on an
     * existing edge. Without this test zero-width triangles have been observed
     * to be created)
     */
    QuadEdge e = subdiv.locate(v);

    if (subdiv.isVertexOfEdge(e, v)) {
        // point is already in subdivision.
        return e;
    } else if (subdiv.isOnEdge(e, v.getCoordinate())) {
        // the point lies exactly on an edge, so delete the edge
        // (it will be replaced by a pair of edges which have the point as a vertex)
        e = e.oPrev();
        subdiv.delete(e.oNext());
    }

    /**
     * Connect the new point to the vertices of the containing triangle
     * (or quadrilateral, if the new point fell on an existing edge.)
     */
    QuadEdge base = subdiv.makeEdge(e.orig(), v);
    QuadEdge.splice(base, e);
    QuadEdge startEdge = base;
    do {
        base = subdiv.connect(e, base.sym());
        e = base.oPrev();
    } while (e.lNext() != startEdge);

    // Examine suspect edges to ensure that the Delaunay condition
    // is satisfied.
    do {
        QuadEdge t = e.oPrev();
        if (t.dest().rightOf(e) && v.isInCircle(e.orig(), t.dest(), e.dest())) {
            QuadEdge.swap(e);
            e = e.oPrev();
        } else if (e.oNext() == startEdge) {
            return base; // no more suspect edges.
        } else {
            e = e.oNext().lPrev();
        }
    } while (true);
}
 

import com.vividsolutions.jts.triangulate.quadedge.QuadEdge; //导入依赖的package包/类
/**
 * Inserts a new point into a subdivision representing a Delaunay
 * triangulation, and fixes the affected edges so that the result is still a
 * Delaunay triangulation.
 * <p>
 * 
 * @return a quadedge containing the inserted vertex
 */
public QuadEdge insertSite(Vertex v) {

	/**
	 * This code is based on Guibas and Stolfi (1985), with minor modifications
	 * and a bug fix from Dani Lischinski (Graphic Gems 1993). (The modification
	 * I believe is the test for the inserted site falling exactly on an
	 * existing edge. Without this test zero-width triangles have been observed
	 * to be created)
	 */
	QuadEdge e = subdiv.locate(v);

	if (subdiv.isVertexOfEdge(e, v)) {
		// point is already in subdivision.
		return e; 
	} 
	else if (subdiv.isOnEdge(e, v.getCoordinate())) {
		// the point lies exactly on an edge, so delete the edge 
		// (it will be replaced by a pair of edges which have the point as a vertex)
		e = e.oPrev();
		subdiv.delete(e.oNext());
	}

	/**
	 * Connect the new point to the vertices of the containing triangle 
	 * (or quadrilateral, if the new point fell on an existing edge.)
	 */
	QuadEdge base = subdiv.makeEdge(e.orig(), v);
	QuadEdge.splice(base, e);
	QuadEdge startEdge = base;
	do {
		base = subdiv.connect(e, base.sym());
		e = base.oPrev();
	} while (e.lNext() != startEdge);

	// Examine suspect edges to ensure that the Delaunay condition
	// is satisfied.
	do {
		QuadEdge t = e.oPrev();
		if (t.dest().rightOf(e) && v.isInCircle(e.orig(), t.dest(), e.dest())) {
			QuadEdge.swap(e);
			e = e.oPrev();
		} else if (e.oNext() == startEdge) {
			return base; // no more suspect edges.
		} else {
			e = e.oNext().lPrev();
		}
	} while (true);
}
 

import com.vividsolutions.jts.triangulate.quadedge.QuadEdge; //导入依赖的package包/类
/**
 * Method of comparison.
 * 
 * @param qeA
 * 		quad edge to compare
 * @param qeB
 * 		quad edge to compare
 * @return
 * 		1 if double value associated to qeA  < double
 * 		value associated to qeB,
 * 		0 if values are equals,
 * 		-1 otherwise
 */
@Override
public int compare(QuadEdge qeA, QuadEdge qeB) {
	if (this.map.get(qeA) < this.map.get(qeB)) {
		return 1;
	} else if (this.map.get(qeA) == this.map.get(qeB)) {
		return 0;
	} else {
		return -1;
	}
}
 

import com.vividsolutions.jts.triangulate.quadedge.QuadEdge; //导入依赖的package包/类
/**
 * Method of comparison.
 *
 * @param qeA
 * 		quad edge to compare
 * @param qeB
 * 		quad edge to compare
 * @return
 * 		1 if double value associated to qeA  < double
 * 		value associated to qeB,
 * 		0 if values are equals,
 * 		-1 otherwise
 */
@Override
public int compare(QuadEdge qeA, QuadEdge qeB) {
  if (this.map.get(qeA) < this.map.get(qeB)) {
    return 1;
  } else if (this.map.get(qeA) == this.map.get(qeB)) {
    return 0;
  } else {
    return -1;
  }
}
 

import com.vividsolutions.jts.triangulate.quadedge.QuadEdge; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @param map
 * 		map containing QuadEdge and Double
 */
public DoubleComparator(Map<QuadEdge,Double> map) {
	this.map = map;
}
 

import com.vividsolutions.jts.triangulate.quadedge.QuadEdge; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param map
 * 		map containing QuadEdge and Double
 */
public DoubleComparator(Map<QuadEdge,Double> map) {
  this.map = map;
}