all files / diagram/primitives/ point.js

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
1×
1×
1×
1×
1×
1×
 
1×
1×
1×
1×
 
 
 
1×
1×
1×
1×
1×
 
1×
 
1×
1×
1×
1×
125962×
 
1×
122835×
1053×
 
121782×
48×
 
121734×
 
1×
140132×
3183×
 
136949×
 
1×
425406×
425406×
425406×
425406×
 
1×
1306917×
1306917×
 
1×
226128×
226128×
226128×
226128×
126961×
 
226128×
 
1×
858168×
 
1×
3256×
3256×
62297×
 
3256×
 
1×
204021×
204021×
204021×
67677×
21534×
 
 
46143×
 
 
136344×
49441×
19546×
 
 
29895×
 
 
 
86903×
86903×
86903×
 
 
 
 
 
 
204021×
 
1×
16973×
7421×
 
 
9552×
 
 
1×
270×
 
1×
 
 
1×
 
 
1×
 
1×
 
 
/* istanbul ignore next */ 
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
/* istanbul ignore next */ 
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
define(["require", "exports", "@syncfusion/ej2-base"], function (require, exports, ej2_base_1) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    var Point = (function (_super) {
        __extends(Point, _super);
        function Point() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Point.equals = function (point1, point2) {
            if (point1 === point2) {
                return true;
            }
            if (!point1 || !point2) {
                return false;
            }
            return !point1 || !point2 || point1.x === point2.x && point1.y === point2.y;
        };
        Point.isEmptyPoint = function (point) {
            if (point.x && point.y) {
                return false;
            }
            return true;
        };
        Point.transform = function (point, angle, length) {
            var pt = { x: 0, y: 0 };
            pt.x = Math.round((point.x + length * Math.cos(angle * Math.PI / 180)) * 100) / 100;
            pt.y = Math.round((point.y + length * Math.sin(angle * Math.PI / 180)) * 100) / 100;
            return pt;
        };
        Point.findLength = function (s, e) {
            var length = Math.sqrt(Math.pow((s.x - e.x), 2) + Math.pow((s.y - e.y), 2));
            return length;
        };
        Point.findAngle = function (point1, point2) {
            var angle = Math.atan2(point2.y - point1.y, point2.x - point1.x);
            angle = (180 * angle / Math.PI);
            angle %= 360;
            if (angle < 0) {
                angle += 360;
            }
            return angle;
        };
        Point.distancePoints = function (pt1, pt2) {
            return Math.sqrt(Math.pow(pt2.x - pt1.x, 2) + Math.pow(pt2.y - pt1.y, 2));
        };
        Point.getLengthFromListOfPoints = function (points) {
            var length = 0;
            for (var j = 0; j < points.length - 1; j++) {
                length += this.distancePoints(points[parseInt(j.toString(), 10)], points[j + 1]);
            }
            return length;
        };
        Point.adjustPoint = function (source, target, isStart, length) {
            var pt = isStart ? { x: source.x, y: source.y } : { x: target.x, y: target.y };
            var angle;
            if (source.x === target.x) {
                if (source.y < target.y && isStart || source.y > target.y && !isStart) {
                    pt.y += length;
                }
                else {
                    pt.y -= length;
                }
            }
            else if (source.y === target.y) {
                if (source.x < target.x && isStart || source.x > target.x && !isStart) {
                    pt.x += length;
                }
                else {
                    pt.x -= length;
                }
            }
            else {
                Eif (isStart) {
                    angle = this.findAngle(source, target);
                    pt = this.transform(source, angle, length);
                }
                else {
                    angle = this.findAngle(target, source);
                    pt = this.transform(target, angle, length);
                }
            }
            return pt;
        };
        Point.direction = function (pt1, pt2) {
            if (Math.abs(pt2.x - pt1.x) > Math.abs(pt2.y - pt1.y)) {
                return pt1.x < pt2.x ? 'Right' : 'Left';
            }
            else {
                return pt1.y < pt2.y ? 'Bottom' : 'Top';
            }
        };
        Point.prototype.getClassName = function () {
            return 'Point';
        };
        __decorate([
            ej2_base_1.Property(0)
        ], Point.prototype, "x", void 0);
        __decorate([
            ej2_base_1.Property(0)
        ], Point.prototype, "y", void 0);
        return Point;
    }(ej2_base_1.ChildProperty));
    exports.Point = Point;
});