Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.h2gis.functions.spatial.mesh.DelaunayData Maven / Gradle / Ivy
/**
* H2GIS is a library that brings spatial support to the H2 Database Engine
* . H2GIS is developed by CNRS
* delaunayTriangle = convertedInput.getTriangles();
// Convert into multi polygon
Polygon[] polygons = new Polygon[delaunayTriangle.size()];
for (int idTriangle = 0; idTriangle < polygons.length; idTriangle++) {
TriangulationPoint[] pts = delaunayTriangle.get(idTriangle).points;
polygons[idTriangle] = gf.createPolygon(new Coordinate[]{toJts(isInput2D, pts[0]), toJts(isInput2D, pts[1]), toJts(isInput2D, pts[2]), toJts(isInput2D, pts[0])});
}
return gf.createMultiPolygon(polygons);
} else {
return gf.createMultiPolygon(new Polygon[0]);
}
}
/**
* Return the 3D area of all triangles
* @return
*/
public double get3DArea(){
if(convertedInput != null) {
List delaunayTriangle = convertedInput.getTriangles();
double sum = 0;
for (DelaunayTriangle triangle : delaunayTriangle) {
sum += computeTriangleArea3D(triangle);
}
return sum;
} else {
return 0;
}
}
/**
* Computes the 3D area of a triangle.
*
* @param triangle
* @return
*/
private double computeTriangleArea3D(DelaunayTriangle triangle) {
TriangulationPoint[] points = triangle.points;
TriangulationPoint p1 = points[0];
TriangulationPoint p2 = points[1];
TriangulationPoint p3 = points[2];
/**
* Uses the formula 1/2 * | u x v | where u,v are the side vectors of
* the triangle x is the vector cross-product
*/
// side vectors u and v
double ux = p2.getX() - p1.getX();
double uy = p2.getY() - p1.getY();
double uz = p2.getZ() - p1.getZ();
double vx = p3.getX() - p1.getX();
double vy = p3.getY() - p1.getY();
double vz = p3.getZ() - p1.getZ();
if (Double.isNaN(uz) || Double.isNaN(vz)) {
uz=1;
vz=1;
}
// cross-product = u x v
double crossx = uy * vz - uz * vy;
double crossy = uz * vx - ux * vz;
double crossz = ux * vy - uy * vx;
// tri area = 1/2 * | u x v |
double absSq = crossx * crossx + crossy * crossy + crossz * crossz;
return Math.sqrt(absSq) / 2;
}
private void addSegment(Set segmentHashMap, TriangulationPoint a, TriangulationPoint b) {
LineSegment lineSegment = new LineSegment(toJts(isInput2D, a), toJts(isInput2D, b));
lineSegment.normalize();
segmentHashMap.add(lineSegment);
}
/**
* @return Unique triangles edges
*/
public MultiLineString getTrianglesSides() {
List delaunayTriangle = convertedInput.getTriangles();
// Remove duplicates edges thanks to this hash map of normalized line segments
Set segmentHashMap = new HashSet(delaunayTriangle.size());
for(DelaunayTriangle triangle : delaunayTriangle) {
TriangulationPoint[] pts = triangle.points;
addSegment(segmentHashMap, pts[0], pts[1]);
addSegment(segmentHashMap, pts[1], pts[2]);
addSegment(segmentHashMap, pts[2], pts[0]);
}
LineString[] lineStrings = new LineString[segmentHashMap.size()];
int i = 0;
for(LineSegment lineSegment : segmentHashMap) {
lineStrings[i++] = lineSegment.toGeometry(gf);
}
return gf.createMultiLineString(lineStrings);
}
/**
* Add a geometry to the list of points and edges used by the triangulation.
* @param geom Any geometry
* @throws IllegalArgumentException
*/
private void addGeometry(Geometry geom) throws IllegalArgumentException {
if(!geom.isValid()) {
throw new IllegalArgumentException("Provided geometry is not valid !");
}
if(geom instanceof GeometryCollection) {
Map pts = new HashMap(geom.getNumPoints());
List segments = new ArrayList(pts.size());
AtomicInteger pointsCount = new AtomicInteger(0);
PointHandler pointHandler = new PointHandler(this, pts, pointsCount);
LineStringHandler lineStringHandler = new LineStringHandler(this, pts, pointsCount, segments);
for(int geomId = 0; geomId < geom.getNumGeometries(); geomId++) {
addSimpleGeometry(geom.getGeometryN(geomId), pointHandler, lineStringHandler);
}
int[] index = new int[segments.size()];
for(int i = 0; i < index.length; i++) {
index[i] = segments.get(i);
}
// Construct final points array by reversing key,value of hash map
TriangulationPoint[] ptsArray = new TriangulationPoint[pointsCount.get()];
for(Map.Entry entry : pts.entrySet()) {
ptsArray[entry.getValue()] = entry.getKey();
}
pts.clear();
convertedInput = new ConstrainedPointSet(Arrays.asList(ptsArray), index);
} else {
addGeometry(geom.getFactory().createGeometryCollection(new Geometry[]{geom}));
}
}
private void addSimpleGeometry(Geometry geom, PointHandler pointHandler, LineStringHandler lineStringHandler) throws IllegalArgumentException {
if(geom instanceof Point) {
geom.apply(pointHandler);
} else if(geom instanceof LineString) {
lineStringHandler.reset();
geom.apply(lineStringHandler);
} else if(geom instanceof Polygon) {
Polygon polygon = (Polygon) geom;
lineStringHandler.reset();
polygon.getExteriorRing().apply(lineStringHandler);
for(int idHole = 0; idHole < polygon.getNumInteriorRing(); idHole++) {
lineStringHandler.reset();
polygon.getInteriorRingN(idHole).apply(lineStringHandler);
}
}
}
private static class PointHandler implements CoordinateFilter {
private DelaunayData delaunayData;
private Map pts;
private AtomicInteger maxIndex;
public PointHandler(DelaunayData delaunayData, Map pts, AtomicInteger maxIndex) {
this.delaunayData = delaunayData;
this.pts = pts;
this.maxIndex = maxIndex;
}
protected int addPt(Coordinate coordinate) {
TPoint pt = new TPoint(delaunayData.r(coordinate.x), delaunayData.r(coordinate.y),
Double.isNaN(coordinate.z) ? 0 : delaunayData.r(coordinate.z));
Integer index = pts.get(pt);
if(index == null) {
index = maxIndex.getAndAdd(1);
pts.put(pt, index);
}
return index;
}
@Override
public void filter(Coordinate pt) {
addPt(pt);
}
}
private static class LineStringHandler extends PointHandler {
private List segments;
private int firstPtIndex = -1;
public LineStringHandler(DelaunayData delaunayData, Map pts,
AtomicInteger maxIndex, List segments) {
super(delaunayData, pts, maxIndex);
this.segments = segments;
}
/**
* New line string
*/
public void reset() {
firstPtIndex = -1;
}
@Override
public void filter(Coordinate pt) {
if (firstPtIndex == -1) {
firstPtIndex = addPt(pt);
} else {
int secondPt = addPt(pt);
if (secondPt != firstPtIndex) {
segments.add(firstPtIndex);
segments.add(secondPt);
firstPtIndex = secondPt;
}
}
}
}
}
