SimulationServer/Models/SimulationCommon/Rectangular_Area_Search_Function.cs

using OpenCvSharp;

namespace SimulationCommon;

public class Rectangular_Area_Search_Function
{
    public static double MokatuoLon(double Lon)
    {
        double R = 6378.137;
        double y = R * Math.Log(Math.Tan((Lon + 90) * Math.PI / 360));
        return y;
    }

    public static double MokatuoLat(double Lat)
    {
        double R = 6378.137;
        double x = (Lat * Math.PI * R) / 180;
        return x;
    }

    //反墨卡托投影
    public static double RMokatuoLon(double y)
    {
        double R = 6378.137;
        double lon = Math.Atan(Math.Exp(y / R)) * 360 / Math.PI - 90;
        return lon;
    }

    public static double RMokatuoLat(double x)
    {
        double R = 6378.137;
        double lat = x * 180 / (R * Math.PI);
        return lat;
    }

    private static double[] GetLinearEquation(Point2f point1, Point2f point2)
    {
        double sign = 1;
        double parameter_a = point2.Y - point1.Y;

        if (parameter_a < 0)
        {
            sign = -1;
            parameter_a = sign * parameter_a;
        }

        double parameter_b = sign * (point1.X - point2.X);
        double parameter_c = sign * (point1.Y * point2.X - point1.X * point2.Y);

        return new double[] { parameter_a, parameter_b, parameter_c };
    }

    private static double[] GetParallelLine(Point2f point, double[] line)
    {
        double parameter_a = line[0];
        double parameter_b = line[1];
        double parameter_c = -point.X * parameter_a - point.Y * parameter_b;

        return new double[] { parameter_a, parameter_b, parameter_c };
    }

    private static double[] GetpPerpendicular(Point2f point, double[] line)
    {
        double parameter_a = line[1];
        double parameter_b = -line[0];
        double parameter_c = -point.Y * parameter_b - point.X * parameter_a;

        return new double[] { parameter_a, parameter_b, parameter_c };
    }

    private static double[] GetCrossPoint(double[] line1, double[] line2)
    {
        double cross_y = (line1[2] * line2[0] - line2[2] * line1[0]) / (line1[0] * line2[1] - line2[0] * line1[1]);
        double cross_x = (line2[2] * line1[1] - line1[2] * line2[1]) / (line1[0] * line2[1] - line2[0] * line1[1]);

        return new double[] { cross_x, cross_y };
    }

    private static double GetDistance(Point2f point, double[] line)
    {
        return Math.Abs(line[0] * point.X + line[1] * point.Y + line[2]) /
               Math.Sqrt(Math.Pow(line[0], 2) + Math.Pow(line[1], 2));
    }

    private static int CheckDirection(Point2f point, double[] line)
    {
        double result = line[0] * point.X + line[1] * point.Y + line[2];
        if (result < 0) return -1;
        if (result > 0) return 1;
        return 0;
    }

    private static double GetRectangularArea(double[] Point0, double[] Point1, double[] Point2, double[] Point3)
    {
        double width = Math.Sqrt(Math.Pow(Point0[0] - Point1[0], 2) + Math.Pow(Point0[1] - Point1[1], 2));
        double height = Math.Sqrt(Math.Pow(Point1[0] - Point2[0], 2) + Math.Pow(Point1[1] - Point2[1], 2));
        return width * height;
    }

    public static Point2f[] GetConvexHull(List<Point2f> pointList)
    {
        Point2f[] hull = Cv2.ConvexHull(pointList);
        return hull;
    }

    public static List<double[]> MinEnclosingRectangle(Point2f[] hull)
    {
         double min_rectangular_area = double.PositiveInfinity;
            List<double[]> Point_muster = new List<double[]>{};

            for (int num = 0; num < hull.Length - 1; num++)
            {
                double[] Base_line = GetLinearEquation(hull[num], hull[num + 1]);
                double max_Ditance = 0;
                Point2f Point = hull[num + 1];

                foreach (Point2f i_point in hull)
                {
                    if ((i_point.X == hull[num].X && i_point.Y == hull[num].Y) ||
                        (i_point.X == hull[num + 1].X && i_point.Y == hull[num + 1].Y))
                    {
                        continue;
                    }

                    double distance = GetDistance(i_point, Base_line);

                    if (distance > max_Ditance)
                    {
                        max_Ditance = distance;
                        Point = i_point;
                    }
                }

                double[] line_Parallel_Base = GetParallelLine(Point, Base_line);

                double[] line_Perpendicular_Base_right = null;
                double[] line_Perpendicular_Base_left = null;

                foreach (Point2f j_point in hull)
                {
                    double[] line_Preparatory = GetpPerpendicular(j_point, Base_line);
                    int point_right = 0;
                    int point_left = 0;

                    foreach (Point2f k_point in hull)
                    {
                        if (k_point.X == j_point.X && k_point.Y == j_point.Y)
                        {
                            continue;
                        }

                        if (CheckDirection(k_point, line_Preparatory) < 0)
                        {
                            point_left++;
                        }
                        else
                        {
                            point_right++;
                        }
                    }

                    if (point_right == hull.Length - 1)
                    {
                        line_Perpendicular_Base_right = line_Preparatory;
                    }

                    if (point_left == hull.Length - 1)
                    {
                        line_Perpendicular_Base_left = line_Preparatory;
                    }
                }

                double[] Point0 = GetCrossPoint(Base_line, line_Perpendicular_Base_left);
                double[] Point1 = GetCrossPoint(Base_line, line_Perpendicular_Base_right);
                double[] Point2 = GetCrossPoint(line_Parallel_Base, line_Perpendicular_Base_right);
                double[] Point3 = GetCrossPoint(line_Parallel_Base, line_Perpendicular_Base_left);
                double rectangular_area = GetRectangularArea(Point0, Point1, Point2, Point3);

                if (rectangular_area < min_rectangular_area)
                {
                    min_rectangular_area = rectangular_area;    
                    Point_muster = new List<double[]> {
                        Point0,
                        Point1,
                        Point2,
                        Point3
                    };
                }
            }

            return Point_muster;
    }
}