PolylineSmoothCSharp/PointD.cs at master · xstos/PolylineSmoothCSharp · GitHub

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
namespace PolylineSmooth
{
    public class PointD
    {
        public PointD()
        {
        }

        public PointD(double nx, double ny)
        {
            X = nx;
            Y = ny;
        }

        public PointD(PointD p)
        {
            X = p.X;
            Y = p.Y;
        }

        public double X = 0;
        public double Y = 0;

        public static PointD operator +(PointD p1, PointD p2)
        {
            return new PointD(p1.X + p2.X, p1.Y + p2.Y);
        }

        public static PointD operator +(PointD p, double d)
        {
            return new PointD(p.X + d, p.Y + d);
        }

        public static PointD operator +(double d, PointD p)
        {
            return p + d;
        }

        public static PointD operator -(PointD p1, PointD p2)
        {
            return new PointD(p1.X - p2.X, p1.Y - p2.Y);
        }

        public static PointD operator -(PointD p, double d)
        {
            return new PointD(p.X - d, p.Y - d);
        }

        public static PointD operator -(double d, PointD p)
        {
            return p - d;
        }

        public static PointD operator *(PointD p1, PointD p2)
        {
            return new PointD(p1.X * p2.X, p1.Y * p2.Y);
        }

        public static PointD operator *(PointD p, double d)
        {
            return new PointD(p.X * d, p.Y * d);
        }

        public static PointD operator *(double d, PointD p)
        {
            return p * d;
        }

        public static PointD operator /(PointD p1, PointD p2)
        {
            return new PointD(p1.X / p2.X, p1.Y / p2.Y);
        }

        public static PointD operator /(PointD p, double d)
        {
            return new PointD(p.X / d, p.Y / d);
        }

        public static PointD operator /(double d, PointD p)
        {
            return new PointD(d / p.X, d / p.Y);
        }
    }
}