多边形重心计算
三角形重心
多边形重心
import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.io.ParseException;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>Title : PolygonNodeTriangle </p>
* <p>Description : 多边形自身节点组成三角形</p>
* @author huifer
* @date 2018/10/15
*/
public class PolygonNodeTriangle {
private int NUM = 3;
private Set result_p = new HashSet();
public static void main(String[] args) {
//0
double[] point1 = new double[]{0, 0};
//1
double[] point2 = new double[]{10, 0};
//2
double[] point3 = new double[]{20, 0};
//3
double[] point4 = new double[]{10, 10};
List<double[]> allPoint = new ArrayList();
allPoint.add(point1);
allPoint.add(point3);
allPoint.add(point4);
PolygonNodeTriangle polygonCenterPoint = new PolygonNodeTriangle();
// 外围
Polygon waiwei = polygonCenterPoint.waiwei(point1, point3, point4);
// 节点三角形
List<Polygon> sanjiaoxing = polygonCenterPoint.triangleMothed(allPoint);
// 外围内所有三角形
List<Polygon> rangeTriangle = polygonCenterPoint.getRangeTriangle(waiwei, sanjiaoxing);
// 重心xy
double[] gravityCenterXY = polygonCenterPoint.getGravityCenterXY(rangeTriangle);
System.out.println(rangeTriangle.size());
System.out.println("================================================");
double[] doubles = polygonCenterPoint. polygonGravityPoint("POLYGON((0 0, 20 0, 10 10, 0 0))");
}
/***
* polygon wkt 计算重心
* @param wkt
* @return
*/
private double[] polygonGravityPoint(String wkt) {
if (!wkt.startsWith("POLYGON")) {
return null;
}
Operation operation = new Operation();
// 外围数据转 list<double[]>
Polygon waiwei = null;
try {
waiwei = operation.createPolygonByWKT(wkt);
} catch (ParseException e) {
e.printStackTrace();
}
Coordinate[] coordinates = waiwei.getCoordinates();
List<double[]> allP = new ArrayList<>();
Arrays.stream(coordinates).forEach(
s -> {
double nowX = s.x;
double nowY = s.y;
allP.add(new double[]{nowX, nowY});
}
);
List<Polygon> polygons = triangleMothed(allP);
List<Polygon> rangeTriangle1 = getRangeTriangle(waiwei, polygons);
double area = waiwei.getArea();
double[] gravityCenterXY1 = getGravityCenterXY(rangeTriangle1);
return gravityCenterXY1;
}
/***
* 重心值
* @param rangeTriangle
* @return [x, y]
*/
private double[] getGravityCenterXY(List<Polygon> rangeTriangle) {
double xArea = 0.0;
double yArea = 0.0;
double aArea = 0.0;
for (Polygon triangle : rangeTriangle) {
Coordinate[] coordinates = triangle.getCoordinates();
double area = triangle.getArea();
double[] oneGR = triangleCenterOfGravity(coordinates[0], coordinates[1], coordinates[2]);
xArea += oneGR[0] * area;
yArea += oneGR[1] * area;
aArea += area;
}
System.out.println("重心X " + xArea / aArea);
System.out.println("重心Y " + yArea / aArea);
return new double[]{xArea / aArea, yArea / aArea};
}
/***
* 范围内三角形
* @param waiwei
* @param sanjiaoxing
* @return
*/
private List<Polygon> getRangeTriangle(Polygon waiwei, List<Polygon> sanjiaoxing) {
List<Polygon> triangle = new ArrayList<>();
// 判断三角形是否在面内
for (int i = 0; i < sanjiaoxing.size(); i++) {
Polygon polygon = sanjiaoxing.get(i);
boolean within = polygon.within(waiwei);
if (within) {
triangle.add(polygon);
}
}
return triangle;
}
/***
* 三角形重心计算
* @param a
* @param b
* @param c
* @return
*/
private double[] triangleCenterOfGravity(Coordinate a, Coordinate b, Coordinate c) {
double gravityX = (a.x + b.x + c.x) / 3;
double gravityY = (a.y + b.y + c.y) / 3;
double[] result = new double[]{gravityX, gravityY};
return result;
}
/***
* 测试用外包图形
* @return
*/
private Polygon waiwei(double[] point1, double[] point3, double[] point4) {
List<double[]> ceshimian = new ArrayList();
ceshimian.add(point1);
// ceshimian.add(point2);
// ceshimian.add(point7);
ceshimian.add(point4);
// ceshimian.add(point6);
// ceshimian.add(point5);
ceshimian.add(point3);
String polygonForList = createPolygonForList(ceshimian);
Operation op = new Operation();
Polygon polygonByWKT = null;
try {
polygonByWKT = op.createPolygonByWKT(polygonForList);
return polygonByWKT;
} catch (ParseException e) {
e.printStackTrace();
}
return null;
}
/***
* 生成所有三角形
* @param allPoint
* @return
*/
private List<Polygon> triangleMothed(List<double[]> allPoint) {
// 索引 -> 点坐标
Map<String, double[]> indexOfPoint = new HashMap();
for (int i = 0; i < allPoint.size(); i++) {
indexOfPoint.put(String.valueOf(i), allPoint.get(i));
}
// 排序结果
sort((List) indexOfPoint.keySet().stream().collect(Collectors.toList()), new HashSet());
// 删除元素相同后的集合
// 所有三角形
List<Polygon> allTriangle = new ArrayList();
for (Object oneDataObj : result_p) {
//这一行数据
Set oneDataList = (Set) oneDataObj;
// 这一行数据的三角形数据
List<double[]> trianglePoint = new ArrayList();
oneDataList.forEach(
s -> trianglePoint.add(indexOfPoint.get(s)
));
Polygon triangle = createTriangle(trianglePoint);
if (triangle != null) {
allTriangle.add(triangle);
}
}
// 所有三角形结束
return allTriangle;
}
/***
* 从点坐标集合中创建一个面
* @param points
* @return
*/
private static String createPolygonForList(List<double[]> points) {
String end = "))";
String res = "POLYGON((";
Operation op = new Operation();
for (double[] point : points) {
String x = Double.toString(point[0]);
String y = Double.toString(point[1]);
res += x + " " + y + ", ";
}
res += Double.toString(points.get(0)[0]) + " " + Double.toString(points.get(0)[1]);
res += end;
try {
op.createPolygonByWKT(res);
} catch (ParseException e) {
e.printStackTrace();
}
return res;
}
/***
* 创建三角形
* @param trianglePoint
* @return polygon
*/
private static Polygon createTriangle(List<double[]> trianglePoint) {
Operation op = new Operation();
String triangleWkt;
boolean isTri = isTriangle(trianglePoint);
if (isTri) {
triangleWkt = "POLYGON((" + trianglePoint.get(0)[0] + " " + trianglePoint.get(0)[1] + ", " + trianglePoint.get(1)[0] + " " + trianglePoint.get(1)[1] + ", " + trianglePoint.get(2)[0] + " " + trianglePoint.get(2)[1] + ", " + trianglePoint.get(0)[0] + " " + trianglePoint.get(0)[1] + "))";
try {
Polygon polygonByWKT = op.createPolygonByWKT(triangleWkt);
return polygonByWKT;
// return triangleWkt;
} catch (ParseException e) {
e.printStackTrace();
}
}
return null;
}
/***
* 判断三角形
* @param trianglePoint
* @return
*/
private static boolean isTriangle(List<double[]> trianglePoint) {
double[] doubles = trianglePoint.get(0);
double[] doubles1 = trianglePoint.get(1);
double[] doubles2 = trianglePoint.get(2);
double len = Math.sqrt(Math.pow(doubles[0] - doubles1[0], 2) + Math.pow(doubles[1] - doubles1[1], 2));
double len1 = Math.sqrt(Math.pow(doubles[0] - doubles2[0], 2) + Math.pow(doubles[1] - doubles2[1], 2));
double len2 = Math.sqrt(Math.pow(doubles1[0] - doubles2[0], 2) + Math.pow(doubles1[1] - doubles2[1], 2));
if ((len + len1 > len2) && (len + len2 > len1) && (len1 + len2 > len)) {
return true;
}
return false;
}
/***
* 不重复排列 (元素不相同)
* @param datas
* @param target
*/
private void sort(List datas, Set target) {
if (target.size() == this.NUM) {
this.result_p.add(target);
return;
}
for (int i = 0; i < datas.size(); i++) {
List newDatas = new ArrayList(datas);
Set newTarget = new HashSet(target);
newTarget.add(newDatas.get(i));
newDatas.remove(i);
sort(newDatas, newTarget);
}
}
}
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，谢谢大家对呐喊教程的支持。如果你想了解更多相关内容请查看下面相关链接
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：notice#nhooo.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。