Как найти принадлежит ли точка треугольнику

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

    class Program
    {
        static void Main(string[] args)
        {
 
            int[] x = new int[4];
            int[] y = new int[4];
            for (int i = 0; i < 4; ++i)
            {
               Console.Write("Введите (x" + i.ToString() + ",y" + i.ToString() + "): ");
                x[i] = Console.Read();
                y[i] = Console.Read();
                Console.ReadLine();
            }
            int a = (x[1] - x[0]) * (y[2] - y[1]) - (x[2] - x[1]) * (y[1] - y[0]);
            int b = (x[2] - x[0]) * (y[3] - y[2]) - (x[3] - x[2]) * (y[2] - y[0]);
            int c = (x[3] - x[0]) * (y[1] - y[3]) - (x[1] - x[3]) * (y[3] - y[0]);
 
            if ((a >= 0 && b >= 0 && c >= 0) || (a <= 0 && b <= 0 && c <= 0))
            {
                Console.WriteLine("Принадлежит треугольнику");
            }
            else
            {
                Console.WriteLine("Не принадлежит треугольнике");
            }
            Console.ReadKey();
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

 class Program
    {
        static void Main(string[] args)
        {
            int x, y, x1, y1, x2, y2, x3, y3;
            int s, s1, s2, s3;
            Console.WriteLine("nVvedite koordinaty treugolnika:");
            Console.WriteLine("x1=");
            x1 = Int32.Parse(Console.ReadLine());
            Console.WriteLine("y1="); 
            y1 = Int32.Parse(Console.ReadLine());
            Console.WriteLine("x2=");
            x2 = Int32.Parse(Console.ReadLine());
            Console.WriteLine("y2="); 
            y2 = Int32.Parse(Console.ReadLine());
            Console.WriteLine("x3=");
            x3 = Int32.Parse(Console.ReadLine());
            Console.WriteLine("y3");
            y3 = Int32.Parse(Console.ReadLine());
            Console.WriteLine("nVVedite koordinaty tochki: ");
            Console.WriteLine("y=");
            x = Int32.Parse(Console.ReadLine());
            Console.WriteLine("x=");
            y = Int32.Parse(Console.ReadLine());
 
            if ((x1==x2==x3) || (y1==y2==y3))
            {
                Console.WriteLine("nNevernye koordinaty treugolnika!");
            }
            {
                s = 1 / 2 *Math.Abs((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1));
                s1 = 1 / 2 *Math.Abs((x2 - x1) * (y - y1) - (x - x1) * (y2 - y1));
                s2 = 1 / 2 *Math.Abs((x - x1) * (y3 - y1) - (x3 - x1) * (y - y1));
                s3 = 1 / 2 *Math.Abs((x2 - x) * (y3 - y) - (x3 - x) * (y2 - y));
 
                if (s == s1 + s2 + s3)
                
                    Console.WriteLine("n Tochka v treugolnike! ");
                else 
                    Console.WriteLine("n Vne treugolnika!");
                
                }
            Console.ReadKey();
 
 
            }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// p1 - p3: вершины треугольника, ptest: проверяемая точка.
// VEC - структура, содержащая поля X, Y, написанная нами.
// Можно вполне использовать POINT из <windows.h>
// Возвращается TRUE, если принадлежит, иначе - FALSE.
BOOL IsInTriangle( VEC P1, VEC P2, VEC P3, VEC PTest )
{
  int a = (P1.X - PTest.X) * (P2.Y - P1.Y) - (P2.X - P1.X) * (P1.Y - PTest.Y);
  int b = (P2.X - PTest.X) * (P3.Y - P2.Y) - (P3.X - P2.X) * (P2.Y - PTest.Y);
  int c = (P3.X - PTest.X) * (P1.Y - P3.Y) - (P1.X - P3.X) * (P3.Y - PTest.Y);
 
  if ((a >= 0 && b >= 0 && c >= 0) || (a <= 0 && b <= 0 && c <= 0))
    return TRUE;
  else
    return FALSE;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

        public static bool Is_point_in_triangle(Point[] triangle, Point point, bool include_borders)
        {
            float a = (triangle[0].X - point.X) * (triangle[1].Y - triangle[0].Y) - (triangle[1].X - triangle[0].X) * (triangle[0].Y - point.Y);
            float b = (triangle[1].X - point.X) * (triangle[2].Y - triangle[1].Y) - (triangle[2].X - triangle[1].X) * (triangle[1].Y - point.Y);
            float c = (triangle[2].X - point.X) * (triangle[0].Y - triangle[2].Y) - (triangle[0].X - triangle[2].X) * (triangle[2].Y - point.Y);
 
            int summ = 0;
 
            if (a > 0)
                summ++;
            else if (a < 0)
                summ--;
 
            if (b > 0)
                summ++;
            else if (b < 0)
                summ--;
 
            if (c > 0)
                summ++;
            else if (c < 0)
                summ--;
 
            summ = Math.Abs(summ);
 
            if (summ == 3)
                return true;
            else if (include_borders && summ == 2)
                return true;
            else
                return false;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

        public static bool Is_point_in_triangle_geron(Point[] triangle, Point point)
        {
            float S = Find_triangle_S(triangle); //S значит площадь
 
            float SA = Find_triangle_S(new Point[] { point, triangle[1], triangle[2] });
            float SB = Find_triangle_S(new Point[] { triangle[0], point, triangle[2] });
            float SC = Find_triangle_S(new Point[] { triangle[0], triangle[1], point });
 
            return SA + SB + SC == S;
        }
 
        public static float Find_triangle_S(Point[] triangle)
        {
            float min_x = Math.Min(Math.Min(triangle[0].X, triangle[1].X), triangle[2].X);
            float max_x = Math.Max(Math.Max(triangle[0].X, triangle[1].X), triangle[2].X);
            float min_y = Math.Min(Math.Min(triangle[0].Y, triangle[1].Y), triangle[2].Y);
            float max_y = Math.Max(Math.Max(triangle[0].Y, triangle[1].Y), triangle[2].Y);
 
            return (max_x - min_x) * (max_y - min_y) / 2;
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

        public static bool Is_point_in_triangle_geron(Point[] triangle, Point point)
        {
            float double_S = Find_triangle_S(triangle); //S значит площадь
 
            float double_S_from_ABC_summ = Find_triangle_double_S(new Point[] { point, triangle[1], triangle[2] });
            double_S_from_ABC_summ += Find_triangle_double_S(new Point[] { triangle[0], point, triangle[2] });
            double_S_from_ABC_summ += Find_triangle_double_S(new Point[] { triangle[0], triangle[1], point });
 
            return double_S_from_ABC_summ == double_S;
 
            float Find_triangle_double_S(Point[] t)
            {
                float min_x = Math.Min(Math.Min(t[0].X, t[1].X), t[2].X);
                float max_x = Math.Max(Math.Max(t[0].X, t[1].X), t[2].X);
                float min_y = Math.Min(Math.Min(t[0].Y, t[1].Y), t[2].Y);
                float max_y = Math.Max(Math.Max(t[0].Y, t[1].Y), t[2].Y);
 
                return (max_x - min_x) * (max_y - min_y);
            }
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

        public static bool Is_point_in_triangle_easier(PointF[] triangle, PointF point)
        {
            int summ = 0;
 
            float a = (triangle[0].X - point.X) * (triangle[1].Y - triangle[1].Y) - (triangle[1].X - triangle[0].X) * (triangle[0].Y - point.Y);
            float b = (triangle[1].X - point.X) * (triangle[2].Y - triangle[1].Y) - (triangle[2].X - triangle[1].X) * (triangle[1].Y - point.Y);
            float c = (triangle[2].X - point.X) * (triangle[0].Y - triangle[2].Y) - (triangle[0].X - triangle[2].X) * (triangle[2].Y - point.Y);
 
            if (a > 0)
                summ++;
            else if (a < 0)
                summ--;
 
            if (b > 0)
                summ++;
            else if (b < 0)
                summ--;
 
            if (c > 0)
                summ++;
            else if (c < 0)
                summ--;
 
            return Math.Abs(summ) >= 2;
        }