import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder; //导入依赖的package包/类
public static void iterateOverTriangles(final Polygon polygon, final Consumer<Geometry> action) {
	final double elevation = getContourCoordinates(polygon).averageZ();
	final double sizeTol = FastMath.sqrt(polygon.getArea()) / 100.0;
	final DelaunayTriangulationBuilder dtb = new DelaunayTriangulationBuilder();
	final PreparedGeometry buffered = PREPARED_GEOMETRY_FACTORY.create(polygon.buffer(sizeTol, 5, 0));
	final Envelope3D env = Envelope3D.of(buffered.getGeometry());
	try {
		dtb.setSites(polygon);
		dtb.setTolerance(sizeTol);
		applyToInnerGeometries(dtb.getTriangles(GEOMETRY_FACTORY), (gg) -> {
			final ICoordinates cc = getContourCoordinates(gg);
			if (cc.isCoveredBy(env) && buffered.covers(gg)) {
				cc.setAllZ(elevation);
				gg.geometryChanged();
				action.accept(gg);
			}
		});
	} catch (final LocateFailureException | ConstraintEnforcementException e) {
		final IScope scope = GAMA.getRuntimeScope();
		GamaRuntimeException.warning("Impossible to triangulate: " + new WKTWriter().write(polygon), scope);
		iterateOverTriangles((Polygon) DouglasPeuckerSimplifier.simplify(polygon, 0.1), action);
		return;
	}
}
 

import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder; //导入依赖的package包/类
private static List<Geometry> triangularize(GeometryFactory geometryFactory, Geometry geometry) {
  DelaunayTriangulationBuilder dtb = new DelaunayTriangulationBuilder();
  dtb.setSites(geometry);
  Geometry triangularizedGeom = dtb.getTriangles(geometryFactory);
  List<Geometry> triangles = new ArrayList<Geometry>(triangularizedGeom.getNumGeometries());
  for(int i = 0; i < triangularizedGeom.getNumGeometries(); ++i) {
    triangles.add(triangularizedGeom.getGeometryN(i));
  }
  return triangles;
}
 

import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder; //导入依赖的package包/类
/**
 * Generate a tin from a given coords list. The internal tin geoms array is set from the result.
 * 
 * @param coordinateList the coords to use for the tin generation.
 */
private void generateTin( List<Coordinate> coordinateList ) {
    pm.beginTask("Generate tin...", -1);
    DelaunayTriangulationBuilder b = new DelaunayTriangulationBuilder();
    b.setSites(coordinateList);
    Geometry tinTriangles = b.getTriangles(gf);
    tinGeometries = new Geometry[tinTriangles.getNumGeometries()];
    for( int i = 0; i < tinTriangles.getNumGeometries(); i++ ) {
        tinGeometries[i] = tinTriangles.getGeometryN(i);
    }
    pm.done();
}
 

import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder; //导入依赖的package包/类
@Override
public void actionPerformed(ActionEvent e) {
  this.projectFrame = application.getMainFrame().getSelectedProjectFrame();
  IPopulation<? extends IFeature> pop = getPopulation();

  Vector<Population<DefaultFeature>> vectPop = new Vector<Population<DefaultFeature>>();

  Population<DefaultFeature> popForShape = new Population<DefaultFeature>();

  ArrayList<Coordinate> listCoord = new ArrayList<Coordinate>();

  for (IFeature iFeature : pop.getElements()) {
    Coordinate c = new Coordinate(iFeature.getGeom().centroid().getX(), iFeature.getGeom().centroid().getY());
    listCoord.add(c);
  }
  GeometryFactory g = new GeometryFactory();
  DelaunayTriangulationBuilder dtb = new DelaunayTriangulationBuilder();
  dtb.setSites(listCoord);
  GeometryCollection gc = (GeometryCollection) dtb.getTriangles(g);

  VectTriangle vt = new VectTriangle();

  for (int i = 0; i < gc.getNumGeometries(); i++) {

    Polygon p = (Polygon) gc.getGeometryN(i);
    Coordinate[] tab = p.getCoordinates();

    DirectPositionList idpl = new DirectPositionList();
    for (Coordinate coordinate : tab) {
      idpl.add(new DirectPosition(coordinate.x, coordinate.y));
    }

    GM_Triangle tri = new GM_Triangle(idpl);

    vt.add(tri); 
    popForShape.add(new DefaultFeature(tri));
  }

  int n = 7;

  for(int i=0; i<n; i++)
    vectPop.add(new Population<DefaultFeature>("Triangulation - "+(i*100/n)));


  for (int i = 0; i < vt.size(); i++) {
    vectPop.get((int)(((double)i)/vt.size()*n)).add(new DefaultFeature(vt.get(i)));
  }

  for(int i=0; i<n; i++){
    projectFrame.getDataSet().addPopulation(vectPop.get(i));
    Layer layerC = projectFrame.getSld().createLayer("Triangulation - "+(i*100/n),GM_Polygon.class, Color.BLACK, new Color(232, i*255/(n-1), 12), 1f, 1);
    layerC.getSymbolizer().setUnitOfMeasurePixel();

    projectFrame.getSld().add(layerC);
  }


  ShapefileWriter.chooseAndWriteShapefile(popForShape);

}
 

import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder; //导入依赖的package包/类
@Execute
public void process() throws Exception {
    checkNull(inMap);

    if (!EGeometryType.isPoint(inMap.getSchema().getGeometryDescriptor())) {
        throw new ModelsIllegalargumentException("The input geometry needs to be points.", this, pm);
    }

    if (fElev != null) {
        fElev = FeatureUtilities.findAttributeName(inMap.getSchema(), fElev);
        if (fElev == null) {
            throw new ModelsIllegalargumentException("Couldn't find field: " + fElev, this);
        }
    }

    CoordinateReferenceSystem crs = inMap.getBounds().getCoordinateReferenceSystem();
    List<SimpleFeature> fList = FeatureUtilities.featureCollectionToList(inMap);

    pm.beginTask("Processing...", fList.size());
    DelaunayTriangulationBuilder b = new DelaunayTriangulationBuilder();
    List<Coordinate> cList = new ArrayList<Coordinate>();
    for( SimpleFeature f : fList ) {
        Geometry geometry = (Geometry) f.getDefaultGeometry();
        double elev = 0.0;
        if (fElev != null)
            elev = (Double) f.getAttribute(fElev);

        Coordinate c = geometry.getCoordinate();
        c.z = elev;
        cList.add(c);
        pm.worked(1);
    }
    pm.done();

    b.setSites(cList);

    List<Geometry> geosList = new ArrayList<Geometry>();
    Geometry triangles = b.getTriangles(gf);
    for( int i = 0; i < triangles.getNumGeometries(); i++ ) {
        Geometry geometryN = triangles.getGeometryN(i);
        Coordinate[] coordinates = geometryN.getCoordinates();
        double min = Double.POSITIVE_INFINITY;
        double max = Double.NEGATIVE_INFINITY;
        for( Coordinate coordinate : coordinates ) {
            min = Math.min(min, coordinate.z);
            max = Math.max(max, coordinate.z);
        }
        geometryN.setUserData(new String[]{"" + min, "" + max});
        geosList.add(geometryN);
    }
    outMap = FeatureUtilities.featureCollectionFromGeometry(crs, geosList.toArray(new Geometry[0]));
}
 

import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder; //导入依赖的package包/类
/**
 * Triangulates (delaunay standard) a geometry.
 * 
 * @param g
 *            a JTS geometry, on which contains() operations are valid (ie:
 *            one composed of non-intersecting polygons)
 * @return a triangulation, consisting of triples of indices (in the order
 *         defined by g.getCoordinates())
 */
public static short[] triangulate(Geometry g) {
	DelaunayTriangulationBuilder triangulator = new DelaunayTriangulationBuilder();
	Coordinate cs[] = g.getCoordinates();
	if (cs.length > Short.MAX_VALUE) {
		throw new IllegalArgumentException(
				" cannot triangulate polygons exceeding " + Short.MAX_VALUE
						+ " vertices; this one has " + cs.length
						+ " vertices");
	}

	HashMap<Coordinate, Short> cMap = new HashMap<Coordinate, Short>();
	// do not close (because the last == the first)
	for (short i = 0; i < cs.length - 1; i++) {
		cMap.put(cs[i], i);
	}

	Gdx.app.debug("GeometryUtils", "triangulating " + (cs.length - 1));

	triangulator.setSites(g);
	Geometry all = triangulator.getTriangles(gf);
	int allTriangles = all.getNumGeometries();
	Array<Coordinate[]> ts = new Array<Coordinate[]>(allTriangles);
	for (int i = 0; i < allTriangles; i++) {
		Geometry tg = all.getGeometryN(i);
		if (g.contains(tg.getInteriorPoint())) {
			ts.add(tg.getGeometryN(i).getCoordinates());
		}
	}

	Gdx.app.debug("GeometryUtils", "... got " + ts.size + " triangles");

	short indices[] = new short[ts.size * 3];
	int j = 0;
	for (Coordinate[] triangle : ts) {
		indices[j++] = cMap.get(triangle[0]);
		indices[j++] = cMap.get(triangle[1]);
		indices[j++] = cMap.get(triangle[2]);
		Gdx.app.debug("GeometryUtils", "Added triangle: " + indices[j - 1]
				+ " " + indices[j - 2] + " " + indices[j - 3]);
	}
	return indices;
}
 

import com.vividsolutions.jts.triangulate.DelaunayTriangulationBuilder; //导入依赖的package包/类
/**
 * Performs a JTS Delaunay triangulation on the current state of the point
 * cloud and returns a list of faces comprising the resulting mesh.
 * 
 * @return a list of Vertex arrays corresponding to the faces of the mesh
 */
public List<Vertex[]> getFaces() {
    DelaunayTriangulationBuilder builder = new DelaunayTriangulationBuilder();
    builder.setSites(pointCloud);
    return builder.getSubdivision().getTriangleVertices(false);
}