This repository has been archived by the owner on Nov 19, 2020. It is now read-only.
/
DoublePoint.cs
395 lines (366 loc) · 14.9 KB
/
DoublePoint.cs
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
// AForge Core Library
// AForge.NET framework
// http://www.aforgenet.com/framework/
//
// Copyright © AForge.NET, 2007-2011
// contacts@aforgenet.com
//
namespace Accord
{
using System;
using Accord.Compat;
/// <summary>
/// Structure for representing a pair of coordinates of double type.
/// </summary>
///
/// <remarks><para>The structure is used to store a pair of floating point
/// coordinates with double precision.</para>
///
/// <para>Sample usage:</para>
/// <code>
/// // assigning coordinates in the constructor
/// DoublePoint p1 = new DoublePoint( 10, 20 );
/// // creating a point and assigning coordinates later
/// DoublePoint p2;
/// p2.X = 30;
/// p2.Y = 40;
/// // calculating distance between two points
/// double distance = p1.DistanceTo( p2 );
/// </code>
/// </remarks>
///
[Serializable]
public struct DoublePoint
{
/// <summary>
/// X coordinate.
/// </summary>
///
public double X;
/// <summary>
/// Y coordinate.
/// </summary>
///
public double Y;
/// <summary>
/// Initializes a new instance of the <see cref="DoublePoint"/> structure.
/// </summary>
///
/// <param name="x">X axis coordinate.</param>
/// <param name="y">Y axis coordinate.</param>
///
public DoublePoint(double x, double y)
{
this.X = x;
this.Y = y;
}
/// <summary>
/// Calculate Euclidean distance between two points.
/// </summary>
///
/// <param name="anotherPoint">Point to calculate distance to.</param>
///
/// <returns>Returns Euclidean distance between this point and
/// <paramref name="anotherPoint"/> points.</returns>
///
public double DistanceTo(DoublePoint anotherPoint)
{
double dx = X - anotherPoint.X;
double dy = Y - anotherPoint.Y;
return System.Math.Sqrt(dx * dx + dy * dy);
}
/// <summary>
/// Calculate squared Euclidean distance between two points.
/// </summary>
///
/// <param name="anotherPoint">Point to calculate distance to.</param>
///
/// <returns>Returns squared Euclidean distance between this point and
/// <paramref name="anotherPoint"/> points.</returns>
///
public double SquaredDistanceTo(DoublePoint anotherPoint)
{
double dx = X - anotherPoint.X;
double dy = Y - anotherPoint.Y;
return dx * dx + dy * dy;
}
/// <summary>
/// Addition operator - adds values of two points.
/// </summary>
///
/// <param name="point1">First point for addition.</param>
/// <param name="point2">Second point for addition.</param>
///
/// <returns>Returns new point which coordinates equal to sum of corresponding
/// coordinates of specified points.</returns>
///
public static DoublePoint operator +(DoublePoint point1, DoublePoint point2)
{
return new DoublePoint(point1.X + point2.X, point1.Y + point2.Y);
}
/// <summary>
/// Addition operator - adds values of two points.
/// </summary>
///
/// <param name="point1">First point for addition.</param>
/// <param name="point2">Second point for addition.</param>
///
/// <returns>Returns new point which coordinates equal to sum of corresponding
/// coordinates of specified points.</returns>
///
public static DoublePoint Add(DoublePoint point1, DoublePoint point2)
{
return new DoublePoint(point1.X + point2.X, point1.Y + point2.Y);
}
/// <summary>
/// Subtraction operator - subtracts values of two points.
/// </summary>
///
/// <param name="point1">Point to subtract from.</param>
/// <param name="point2">Point to subtract.</param>
///
/// <returns>Returns new point which coordinates equal to difference of corresponding
/// coordinates of specified points.</returns>
///
public static DoublePoint operator -(DoublePoint point1, DoublePoint point2)
{
return new DoublePoint(point1.X - point2.X, point1.Y - point2.Y);
}
/// <summary>
/// Subtraction operator - subtracts values of two points.
/// </summary>
///
/// <param name="point1">Point to subtract from.</param>
/// <param name="point2">Point to subtract.</param>
///
/// <returns>Returns new point which coordinates equal to difference of corresponding
/// coordinates of specified points.</returns>
///
public static DoublePoint Subtract(DoublePoint point1, DoublePoint point2)
{
return new DoublePoint(point1.X - point2.X, point1.Y - point2.Y);
}
/// <summary>
/// Addition operator - adds scalar to the specified point.
/// </summary>
///
/// <param name="point">Point to increase coordinates of.</param>
/// <param name="valueToAdd">Value to add to coordinates of the specified point.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point increased by specified value.</returns>
///
public static DoublePoint operator +(DoublePoint point, double valueToAdd)
{
return new DoublePoint(point.X + valueToAdd, point.Y + valueToAdd);
}
/// <summary>
/// Addition operator - adds scalar to the specified point.
/// </summary>
///
/// <param name="point">Point to increase coordinates of.</param>
/// <param name="valueToAdd">Value to add to coordinates of the specified point.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point increased by specified value.</returns>
///
public static DoublePoint Add(DoublePoint point, double valueToAdd)
{
return new DoublePoint(point.X + valueToAdd, point.Y + valueToAdd);
}
/// <summary>
/// Subtraction operator - subtracts scalar from the specified point.
/// </summary>
///
/// <param name="point">Point to decrease coordinates of.</param>
/// <param name="valueToSubtract">Value to subtract from coordinates of the specified point.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point decreased by specified value.</returns>
///
public static DoublePoint operator -(DoublePoint point, double valueToSubtract)
{
return new DoublePoint(point.X - valueToSubtract, point.Y - valueToSubtract);
}
/// <summary>
/// Subtraction operator - subtracts scalar from the specified point.
/// </summary>
///
/// <param name="point">Point to decrease coordinates of.</param>
/// <param name="valueToSubtract">Value to subtract from coordinates of the specified point.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point decreased by specified value.</returns>
///
public static DoublePoint Subtract(DoublePoint point, double valueToSubtract)
{
return new DoublePoint(point.X - valueToSubtract, point.Y - valueToSubtract);
}
/// <summary>
/// Multiplication operator - multiplies coordinates of the specified point by scalar value.
/// </summary>
///
/// <param name="point">Point to multiply coordinates of.</param>
/// <param name="factor">Multiplication factor.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point multiplied by specified value.</returns>
///
public static DoublePoint operator *(DoublePoint point, double factor)
{
return new DoublePoint(point.X * factor, point.Y * factor);
}
/// <summary>
/// Multiplication operator - multiplies coordinates of the specified point by scalar value.
/// </summary>
///
/// <param name="point">Point to multiply coordinates of.</param>
/// <param name="factor">Multiplication factor.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point multiplied by specified value.</returns>
///
public static DoublePoint Multiply(DoublePoint point, double factor)
{
return new DoublePoint(point.X * factor, point.Y * factor);
}
/// <summary>
/// Division operator - divides coordinates of the specified point by scalar value.
/// </summary>
///
/// <param name="point">Point to divide coordinates of.</param>
/// <param name="factor">Division factor.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point divided by specified value.</returns>
///
public static DoublePoint operator /(DoublePoint point, double factor)
{
return new DoublePoint(point.X / factor, point.Y / factor);
}
/// <summary>
/// Division operator - divides coordinates of the specified point by scalar value.
/// </summary>
///
/// <param name="point">Point to divide coordinates of.</param>
/// <param name="factor">Division factor.</param>
///
/// <returns>Returns new point which coordinates equal to coordinates of
/// the specified point divided by specified value.</returns>
///
public static DoublePoint Divide(DoublePoint point, double factor)
{
return new DoublePoint(point.X / factor, point.Y / factor);
}
/// <summary>
/// Equality operator - checks if two points have equal coordinates.
/// </summary>
///
/// <param name="point1">First point to check.</param>
/// <param name="point2">Second point to check.</param>
///
/// <returns>Returns <see langword="true"/> if coordinates of specified
/// points are equal.</returns>
///
public static bool operator ==(DoublePoint point1, DoublePoint point2)
{
return ((point1.X == point2.X) && (point1.Y == point2.Y));
}
/// <summary>
/// Inequality operator - checks if two points have different coordinates.
/// </summary>
///
/// <param name="point1">First point to check.</param>
/// <param name="point2">Second point to check.</param>
///
/// <returns>Returns <see langword="true"/> if coordinates of specified
/// points are not equal.</returns>
///
public static bool operator !=(DoublePoint point1, DoublePoint point2)
{
return ((point1.X != point2.X) || (point1.Y != point2.Y));
}
/// <summary>
/// Check if this instance of <see cref="DoublePoint"/> equal to the specified one.
/// </summary>
///
/// <param name="obj">Another point to check equalty to.</param>
///
/// <returns>Return <see langword="true"/> if objects are equal.</returns>
///
public override bool Equals(object obj)
{
return (obj is DoublePoint) ? (this == (DoublePoint)obj) : false;
}
/// <summary>
/// Get hash code for this instance.
/// </summary>
///
/// <returns>Returns the hash code for this instance.</returns>
///
public override int GetHashCode()
{
return X.GetHashCode() + Y.GetHashCode();
}
/// <summary>
/// Explicit conversion to <see cref="IntPoint"/>.
/// </summary>
///
/// <param name="point">Double precision point to convert to integer point.</param>
///
/// <returns>Returns new integer point which coordinates are explicitly converted
/// to integers from coordinates of the specified double precision point by
/// casting double values to integers value.</returns>
///
public static explicit operator IntPoint(DoublePoint point)
{
return new IntPoint((int)point.X, (int)point.Y);
}
/// <summary>
/// Explicit conversion to <see cref="Point"/>.
/// </summary>
///
/// <param name="point">Double precision point to convert to single precision point.</param>
///
/// <returns>Returns new single precision point which coordinates are explicitly converted
/// to floats from coordinates of the specified double precision point by
/// casting double values to float value.</returns>
///
public static explicit operator Point(DoublePoint point)
{
return new Point((float)point.X, (float)point.Y);
}
/// <summary>
/// Rounds the double precision point.
/// </summary>
///
/// <returns>Returns new integer point, which coordinates equal to whole numbers
/// nearest to the corresponding coordinates of the double precision point.</returns>
///
public IntPoint Round()
{
return new IntPoint((int)System.Math.Round(X), (int)System.Math.Round(Y));
}
/// <summary>
/// Get string representation of the class.
/// </summary>
///
/// <returns>Returns string, which contains values of the point in readable form.</returns>
///
public override string ToString()
{
return string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}, {1}", X, Y);
}
/// <summary>
/// Calculate Euclidean norm of the vector comprised of the point's
/// coordinates - distance from (0, 0) in other words.
/// </summary>
///
/// <returns>Returns point's distance from (0, 0) point.</returns>
///
public double EuclideanNorm()
{
return System.Math.Sqrt(X * X + Y * Y);
}
}
}