Changeset 171 for trunk/Packages

Timestamp:

Nov 23, 2017, 7:05:37 PM (7 years ago)

Author:

chronos

Message:

• Modified: Use specialized TPointF type from generic class.
• Modified: Part of fixes for Voronoi map generation.

Location:

trunk/Packages/Common

Files:

• UGeometry.pas (modified) (9 diffs)
• UGeometryClasses.pas (modified) (2 diffs)

trunk/Packages/Common/UGeometry.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, Math;
+  Classes, SysUtils, Math, typinfo;
 
 type
@@ -16 +16 @@
     Y: T;
     constructor Create(const X, Y: T);
-    procedure Rotate(Base: TGPoint<T>; Angle: Double);
     class operator Add(const A, B: TGPoint<T>): TGPoint<T>;
     class operator Subtract(const A, B: TGPoint<T>): TGPoint<T>;
     class operator GreaterThan(const A, B: TGPoint<T>): Boolean;
+    class operator GreaterThanOrEqual(const A, B: TGPoint<T>): Boolean;
     class operator LessThan(const A, B: TGPoint<T>): Boolean;
+    class operator LessThanOrEqual(const A, B: TGPoint<T>): Boolean;
     class operator Equal(const A, B: TGPoint<T>): Boolean;
     function Min(const A, B: TGPoint<T>): TGPoint<T>;
     function Max(const A, B: TGPoint<T>): TGPoint<T>;
+    procedure Rotate(Base: TGPoint<T>; Angle: Double);
   end;
 
@@ -94 +96 @@
     procedure AddPoint(const P: T);
     procedure Clear;
-    procedure CutLine(const Vector: TGLine<T>; const PointInside: T);
+    procedure CutLine(Vector: TGLine<T>; const PointInside: T);
     property Items[Index: Integer]: T read GetPoint write SetPoint; default;
   end;
@@ -185 +187 @@
 end;
 
-function PtInPoly(const Points: array of TPoint; Pos: TPoint): Boolean;
-var
-  Count, K, J : Integer;
-begin
-  Result := False;
-  Count := Length(Points) ;
-  J := Count - 1;
-  for K := 0 to Count - 1 do begin
-  if ((Points[K].Y <= Pos.Y) and (Pos.Y < Points[J].Y)) or
-    ((Points[J].Y <= Pos.Y) and (Pos.Y < Points[K].Y)) then
-    begin
-    if (Pos.X < (Points[j].X - Points[K].X) *
-       (Pos.Y - Points[K].Y) /
-       (Points[j].Y - Points[K].Y) + Points[K].X) then
-        Result := not Result;
-    end;
-    J := K;
-  end;
-end;
-
-
 constructor TGPolygon<T>.Create(const Points: TPointArray);
 var
@@ -227 +208 @@
 var
   I: Integer;
-  P1: TGPoint<T>;
 begin
   if Length(Points) = 0 then
@@ -252 +232 @@
 end;
 
-procedure TGPolygon<T>.CutLine(const Vector: TGLine<T>; const PointInside: T);
+procedure TGPolygon<T>.CutLine(Vector: TGLine<T>; const PointInside: T);
 var
   I: Integer;
@@ -359 +339 @@
 end;
 
-{ TGPoint3D }
-
-constructor TGPoint3D<T>.Create(const X, Y, Z: T);
-begin
-  Self.X := X;
-  Self.Y := Y;
-  Self.Z := Z;
-end;
-
-{ TGPoint }
-
-constructor TGPoint<T>.Create(const X, Y: T);
-begin
-  Self.X := X;
-  Self.Y := Y;
-end;
-
-class operator TGPoint<T>.Equal(const A, B: TGPoint<T>): Boolean;
-begin
-  Result := (A.X = B.X) and (A.Y = B.Y);
-end;
-
-class operator TGPoint<T>.Add(const A, B: TGPoint<T>): TGPoint<T>;
-begin
-  Result.X := A.X + B.X;
-  Result.Y := A.Y + B.Y;
-end;
-
-class operator TGPoint<T>.Subtract(const A, B: TGPoint<T>): TGPoint<T>;
-begin
-  Result.X := A.X - B.X;
-  Result.Y := A.Y - B.Y;
-end;
-
-class operator TGPoint<T>.GreaterThan(const A, B: TGPoint<T>): Boolean;
-begin
-  Result := (B.X > A.X) and (B.Y > A.Y);
-end;
-
-class operator TGPoint<T>.LessThan(const A, B: TGPoint<T>): Boolean;
-begin
-  Result := (B.X < A.X) and (B.Y < A.Y);
-end;
-
-{ TGLine }
-
 class function TGLine<T>.LineIntersect(const LineA, LineB: TGLine<T>; out
   Intersection: T): Boolean;
@@ -435 +369 @@
 end;
 
-procedure TGPoint<T>.Rotate(Base: TGPoint<T>; Angle: Double);
-var
-  D: TGPoint<T>;
-begin
-  D := TGPoint<T>.Create(X - Base.X, Y - Base.Y);
-  //X := Base.X + TypedRound(D.X * Cos(Angle) - D.Y * Sin(Angle));
-  //Y := Base.Y + TypedRound(D.X * Sin(Angle) + D.Y * Cos(Angle));
+{ TGPoint3D }
+
+constructor TGPoint3D<T>.Create(const X, Y, Z: T);
+begin
+  Self.X := X;
+  Self.Y := Y;
+  Self.Z := Z;
+end;
+
+{ TGPoint }
+
+constructor TGPoint<T>.Create(const X, Y: T);
+begin
+  Self.X := X;
+  Self.Y := Y;
+end;
+
+class operator TGPoint<T>.Equal(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X = B.X) and (A.Y = B.Y);
+end;
+
+class operator TGPoint<T>.Add(const A, B: TGPoint<T>): TGPoint<T>;
+begin
+  Result.X := A.X + B.X;
+  Result.Y := A.Y + B.Y;
+end;
+
+class operator TGPoint<T>.Subtract(const A, B: TGPoint<T>): TGPoint<T>;
+begin
+  Result.X := A.X - B.X;
+  Result.Y := A.Y - B.Y;
+end;
+
+class operator TGPoint<T>.GreaterThan(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X > B.X) and (A.Y > B.Y);
+end;
+
+class operator TGPoint<T>.GreaterThanOrEqual(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X >= B.X) and (A.Y >= B.Y);
+end;
+
+class operator TGPoint<T>.LessThan(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X < B.X) and (A.Y < B.Y);
+end;
+
+class operator TGPoint<T>.LessThanOrEqual(const A, B: TGPoint<T>): Boolean;
+begin
+  Result := (A.X <= B.X) and (A.Y <= B.Y);
 end;
 
@@ -456 +435 @@
 end;
 
+procedure TGPoint<T>.Rotate(Base: TGPoint<T>; Angle: Double);
+var
+  D: TGPoint<T>;
+begin
+  D := TGPoint<T>.Create(X - Base.X, Y - Base.Y);
+  X := Base.X + TypedRound(D.X * Cos(Angle) - D.Y * Sin(Angle));
+  Y := Base.Y + TypedRound(D.X * Sin(Angle) + D.Y * Cos(Angle));
+end;
+
 { TGRect }
 
 function TGRect<T>.IsPointInside(const P: T): Boolean;
 begin
-  Result := (P > P1) and (P < P2);
+  Result := (P >= P1) and (P <= P2);
 end;
 

trunk/Packages/Common/UGeometryClasses.pas

@@ -26 +26 @@
 function PointsToRect(const P1, P2: TPoint): TRect;
 function PointInRect(const P: TPoint; aRect: TRect): Boolean;
+function PtInPoly(const Points: array of TPoint; Pos: TPoint): Boolean;
 function HalfDistancePoint(const P1, P2: TPoint): TPoint;
 function NormalizeAngle(const Angle: Double): Double;
@@ -172 +173 @@
 end;
 
+function PtInPoly(const Points: array of TPoint; Pos: TPoint): Boolean;
+var
+  Count, K, J : Integer;
+begin
+  Result := False;
+  Count := Length(Points) ;
+  J := Count - 1;
+  for K := 0 to Count - 1 do begin
+  if ((Points[K].Y <= Pos.Y) and (Pos.Y < Points[J].Y)) or
+    ((Points[J].Y <= Pos.Y) and (Pos.Y < Points[K].Y)) then
+    begin
+    if (Pos.X < (Points[j].X - Points[K].X) *
+       (Pos.Y - Points[K].Y) /
+       (Points[j].Y - Points[K].Y) + Points[K].X) then
+        Result := not Result;
+    end;
+    J := K;
+  end;
+end;
 
 end.