mirror of
https://github.com/moparisthebest/Simba
synced 2024-11-22 01:02:17 -05:00
Added few TPA functions (OffsetTPA,OffsetATPA,FloodFillTPA,CopyTPA,CopyATPA).. Changed most of the Array parameters to be Consts (this saves the need of copying the whole array just to pass it to the method). Changed the debug image borders back to toolwin.. Added constants MaxInt/MaxLongInt
This commit is contained in:
Raymond
parent
4dc83e9397
commit
1575c1ec11
@ -4,7 +4,7 @@ object DebugImgForm: TDebugImgForm
|
||||
Top = 278
|
||||
Width = 400
|
||||
BorderIcons = [biSystemMenu, biMinimize]
|
||||
BorderStyle = bsSingle
|
||||
BorderStyle = bsToolWindow
|
||||
Caption = 'DebugImgForm'
|
||||
ClientHeight = 300
|
||||
ClientWidth = 400
|
||||
|
||||
@ -28,12 +28,12 @@ begin
|
||||
RAaSTPA(a,dist);
|
||||
end;
|
||||
|
||||
function ps_NearbyPointInArrayEx(const P: TPoint; w, h:Integer; a: TPointArray): Boolean;extdecl;
|
||||
function ps_NearbyPointInArrayEx(const P: TPoint; w, h:Integer;const a: TPointArray): Boolean;extdecl;
|
||||
begin
|
||||
result := NearbyPointInArrayEx(p,w,h,a);
|
||||
end;
|
||||
|
||||
function ps_NearbyPointInArray(const P: TPoint; Dist:Integer; a: TPointArray): Boolean; extdecl;
|
||||
function ps_NearbyPointInArray(const P: TPoint; Dist:Integer;const a: TPointArray): Boolean; extdecl;
|
||||
begin
|
||||
result := NearbyPointInArray(p,dist,a);
|
||||
end;
|
||||
@ -73,12 +73,12 @@ begin
|
||||
InvertATPA(a);
|
||||
end;
|
||||
|
||||
function ps_MiddleTPAEx(TPA: TPointArray; var x, y: Integer): Boolean; extdecl;
|
||||
function ps_MiddleTPAEx(const TPA: TPointArray; var x, y: Integer): Boolean; extdecl;
|
||||
begin
|
||||
Result := MiddleTPAEx(tpa,x,y);
|
||||
end;
|
||||
|
||||
function ps_MiddleTPA(tpa: TPointArray): TPoint; extdecl;
|
||||
function ps_MiddleTPA(const tpa: TPointArray): TPoint; extdecl;
|
||||
begin
|
||||
result := MiddleTPA(tpa);
|
||||
end;
|
||||
@ -93,12 +93,12 @@ begin
|
||||
SortATPAFromSize(a,size,closefirst);
|
||||
end;
|
||||
|
||||
function ps_InIntArrayEx(a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;extdecl;
|
||||
function ps_InIntArrayEx(const a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;extdecl;
|
||||
begin
|
||||
result := InIntArrayEx(a,where,number);
|
||||
end;
|
||||
|
||||
function ps_InIntArray(a: TIntegerArray; Number: Integer): Boolean; extdecl;
|
||||
function ps_InIntArray(const a: TIntegerArray; Number: Integer): Boolean; extdecl;
|
||||
begin
|
||||
result := InIntArray(a,number);
|
||||
end;
|
||||
@ -113,42 +113,47 @@ begin
|
||||
ClearSameIntegersAndTPA(a,p);
|
||||
end;
|
||||
|
||||
function ps_SplitTPAEx(arr: TPointArray; w, h: Integer): T2DPointArray; extdecl;
|
||||
function ps_SplitTPAEx(const arr: TPointArray; w, h: Integer): T2DPointArray; extdecl;
|
||||
begin
|
||||
result := SplitTPAEx(arr,w,h);
|
||||
end;
|
||||
|
||||
function ps_SplitTPA(arr: TPointArray; Dist: Integer): T2DPointArray; extdecl;
|
||||
function ps_SplitTPA(const arr: TPointArray; Dist: Integer): T2DPointArray; extdecl;
|
||||
begin
|
||||
result := SplitTPA(arr,dist);
|
||||
end;
|
||||
|
||||
function ps_FloodFillTPA(const TPA : TPointArray) : T2DPointArray; extdecl;
|
||||
begin
|
||||
result := FloodFillTPA(TPA);
|
||||
end;
|
||||
|
||||
procedure ps_FilterPointsPie(var Points: TPointArray; const SD, ED, MinR, MaxR: Extended; Mx, My: Integer);extdecl;
|
||||
begin
|
||||
FilterPointsPie(points,sd,ed,minr,maxr,mx,my);
|
||||
end;
|
||||
|
||||
function ps_GetATPABounds(ATPA: T2DPointArray): TBox;extdecl;
|
||||
function ps_GetATPABounds(const ATPA: T2DPointArray): TBox;extdecl;
|
||||
begin
|
||||
result := GetATPABounds(ATPA);
|
||||
end;
|
||||
|
||||
function ps_GetTPABounds(TPA: TPointArray): TBox; extdecl;
|
||||
function ps_GetTPABounds(const TPA: TPointArray): TBox; extdecl;
|
||||
begin
|
||||
result := GetTPABounds(TPA);
|
||||
end;
|
||||
|
||||
function ps_FindTPAinTPA(SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean; extdecl;
|
||||
function ps_FindTPAinTPA(const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean; extdecl;
|
||||
begin
|
||||
Result := FindTPAinTPA(searchTPA,totaltpa,matches);
|
||||
end;
|
||||
|
||||
function ps_GetSamePointsATPA( ATPA : T2DPointArray; var Matches : TPointArray) : boolean;extdecl;
|
||||
function ps_GetSamePointsATPA(const ATPA : T2DPointArray; var Matches : TPointArray) : boolean;extdecl;
|
||||
begin
|
||||
result := GetSamePointsATPA(ATPA,Matches);
|
||||
end;
|
||||
|
||||
function ps_FindTextTPAinTPA(Height : integer; SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;extdecl;
|
||||
function ps_FindTextTPAinTPA(Height : integer;const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;extdecl;
|
||||
begin
|
||||
result := FindTextTPAinTPA(height,searchtpa,totaltpa,matches);
|
||||
end;
|
||||
@ -168,47 +173,47 @@ begin
|
||||
result := RotatePoint(p,angle,mx,my);
|
||||
end;
|
||||
|
||||
function ps_FindGapsTPA(TPA: TPointArray; MinPixels: Integer): T2DPointArray; extdecl;
|
||||
function ps_FindGapsTPA(const TPA: TPointArray; MinPixels: Integer): T2DPointArray; extdecl;
|
||||
begin
|
||||
result := FindGapsTPA(TPA,minpixels);
|
||||
end;
|
||||
|
||||
function ps_RemoveDistTPointArray(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray; extdecl;
|
||||
function ps_RemoveDistTPointArray(x, y, dist: Integer;const ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray; extdecl;
|
||||
begin
|
||||
Result := RemoveDistTPointArray(x,y,dist,thepoints,removehigher);
|
||||
end;
|
||||
|
||||
function ps_CombineTPA(Ar1, Ar2: TPointArray): TPointArray; extdecl;
|
||||
function ps_CombineTPA(const Ar1, Ar2: TPointArray): TPointArray; extdecl;
|
||||
begin
|
||||
result := CombineTPA(ar1,ar2);
|
||||
end;
|
||||
|
||||
function ps_ReArrangeandShortenArrayEx(a: TPointArray; w, h: Integer): TPointArray;extdecl;
|
||||
function ps_ReArrangeandShortenArrayEx(const a: TPointArray; w, h: Integer): TPointArray;extdecl;
|
||||
begin
|
||||
result := ReArrangeandShortenArrayEx(a,w,h);
|
||||
end;
|
||||
|
||||
function ps_ReArrangeandShortenArray(a: TPointArray; Dist: Integer): TPointArray; extdecl;
|
||||
function ps_ReArrangeandShortenArray(const a: TPointArray; Dist: Integer): TPointArray; extdecl;
|
||||
begin
|
||||
result := ReArrangeandShortenArray(a,dist);
|
||||
end;
|
||||
|
||||
function ps_TPAtoATPAEx(TPA: TPointArray; w, h: Integer): T2DPointArray; extdecl;
|
||||
function ps_TPAtoATPAEx(const TPA: TPointArray; w, h: Integer): T2DPointArray; extdecl;
|
||||
begin
|
||||
result := TPAtoATPAEx(tpa,w,h);
|
||||
end;
|
||||
|
||||
function ps_TPAtoATPA(TPA: TPointArray; Dist: Integer): T2DPointArray;extdecl;
|
||||
function ps_TPAtoATPA(const TPA: TPointArray; Dist: Integer): T2DPointArray;extdecl;
|
||||
begin
|
||||
Result := TPAtoATPA(tpa,dist);
|
||||
end;
|
||||
|
||||
function ps_CombineIntArray(Ar1, Ar2: TIntegerArray): TIntegerArray; extdecl;
|
||||
function ps_CombineIntArray(const Ar1, Ar2: TIntegerArray): TIntegerArray; extdecl;
|
||||
begin
|
||||
result := CombineIntArray(ar1,ar2);
|
||||
end;
|
||||
|
||||
function ps_MergeATPA(ATPA : T2DPointArray) : TPointArray; extdecl;
|
||||
function ps_MergeATPA(const ATPA : T2DPointArray) : TPointArray; extdecl;
|
||||
begin
|
||||
result := MergeATPA(ATPA);
|
||||
end;
|
||||
@ -223,12 +228,12 @@ begin
|
||||
Result := RotatePoints(p,a,cx,cy);
|
||||
end;
|
||||
|
||||
function ps_FindTPAEdges(p: TPointArray): TPointArray;extdecl;
|
||||
function ps_FindTPAEdges(const p: TPointArray): TPointArray;extdecl;
|
||||
begin
|
||||
result := FindTPAEdges(p);
|
||||
end;
|
||||
|
||||
function ps_ClearTPAFromTPA(arP, ClearPoints: TPointArray): TPointArray; extdecl;
|
||||
function ps_ClearTPAFromTPA(const arP, ClearPoints: TPointArray): TPointArray; extdecl;
|
||||
begin
|
||||
result := ClearTPAFromTPA(arP,ClearPoints);
|
||||
end;
|
||||
@ -238,7 +243,7 @@ begin
|
||||
result := ReturnPointsNotInTPA(totaltpa,box);
|
||||
end;
|
||||
|
||||
function ps_PointInTPA(p: TPoint; arP: TPointArray): Boolean; extdecl;
|
||||
function ps_PointInTPA(p: TPoint;const arP: TPointArray): Boolean; extdecl;
|
||||
begin
|
||||
result := PointInTPA(p,arp);
|
||||
end;
|
||||
@ -263,64 +268,64 @@ begin
|
||||
InvertTIA(ti);
|
||||
end;
|
||||
|
||||
function ps_SumIntegerArray(Ints : TIntegerArray): Integer; extdecl;
|
||||
function ps_SumIntegerArray(const Ints : TIntegerArray): Integer; extdecl;
|
||||
begin
|
||||
result := SumIntegerArray(ints);
|
||||
end;
|
||||
|
||||
function ps_AverageTIA(tI: TIntegerArray): Integer; extdecl;
|
||||
function ps_AverageTIA(const tI: TIntegerArray): Integer; extdecl;
|
||||
begin
|
||||
result := AverageTIA(ti);
|
||||
end;
|
||||
|
||||
function ps_AverageExtended(tE: TExtendedArray): Extended; extdecl;
|
||||
function ps_AverageExtended(const tE: TExtendedArray): Extended; extdecl;
|
||||
begin
|
||||
result := AverageExtended(te);
|
||||
end;
|
||||
|
||||
procedure ps_SplitTPAExWrap(arr: TPointArray; w, h: Integer; var res : T2DPointArray);extdecl;
|
||||
procedure ps_SplitTPAExWrap(const arr: TPointArray; w, h: Integer; var res : T2DPointArray);extdecl;
|
||||
begin
|
||||
res := SplitTPAEx(arr,w,h);
|
||||
end;
|
||||
|
||||
procedure ps_SplitTPAWrap(arr: TPointArray; Dist: Integer; var res: T2DPointArray);extdecl;
|
||||
procedure ps_SplitTPAWrap(const arr: TPointArray; Dist: Integer; var res: T2DPointArray);extdecl;
|
||||
begin
|
||||
res := SplitTPA(arr,dist);
|
||||
end;
|
||||
|
||||
procedure ps_FindGapsTPAWrap(TPA: TPointArray; MinPixels: Integer; var Res : T2DPointArray); extdecl;
|
||||
procedure ps_FindGapsTPAWrap(const TPA: TPointArray; MinPixels: Integer; var Res : T2DPointArray); extdecl;
|
||||
begin
|
||||
Res := FindGapsTPA(TPA,MinPixels);
|
||||
end;
|
||||
procedure ps_RemoveDistTPointArrayWrap(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean; var Res : TPointArray);extdecl;
|
||||
procedure ps_RemoveDistTPointArrayWrap(x, y, dist: Integer;const ThePoints: TPointArray; RemoveHigher: Boolean; var Res : TPointArray);extdecl;
|
||||
begin
|
||||
Res := RemoveDistTPointArray(x,y,dist,thepoints,removehigher);
|
||||
end;
|
||||
procedure ps_CombineTPAWrap(Ar1, Ar2: TPointArray; var Res : TPointArray);extdecl;
|
||||
procedure ps_CombineTPAWrap(const Ar1, Ar2: TPointArray; var Res : TPointArray);extdecl;
|
||||
begin
|
||||
Res := CombineTPA(Ar1,Ar2);
|
||||
end;
|
||||
procedure ps_ReArrangeandShortenArrayExWrap(a: TPointArray; w, h: Integer; var Res : TPointArray);extdecl;
|
||||
procedure ps_ReArrangeandShortenArrayExWrap(const a: TPointArray; w, h: Integer; var Res : TPointArray);extdecl;
|
||||
begin
|
||||
Res := ReArrangeandShortenArrayEx(a,w,h);
|
||||
end;
|
||||
procedure ps_ReArrangeandShortenArrayWrap(a: TPointArray; Dist: Integer; var Res : TPointArray);extdecl;
|
||||
procedure ps_ReArrangeandShortenArrayWrap(const a: TPointArray; Dist: Integer; var Res : TPointArray);extdecl;
|
||||
begin
|
||||
Res := ReArrangeandShortenArray(a,dist);
|
||||
end;
|
||||
procedure ps_TPAtoATPAExWrap(TPA: TPointArray; w, h: Integer; var Res : T2DPointArray);extdecl;
|
||||
procedure ps_TPAtoATPAExWrap(const TPA: TPointArray; w, h: Integer; var Res : T2DPointArray);extdecl;
|
||||
begin
|
||||
Res := TPAtoATPAEx(TPA,w,h);
|
||||
end;
|
||||
procedure ps_TPAtoATPAWrap(TPA: TPointArray; Dist: Integer; var Res : T2DPointArray);extdecl;
|
||||
procedure ps_TPAtoATPAWrap(const TPA: TPointArray; Dist: Integer; var Res : T2DPointArray);extdecl;
|
||||
begin
|
||||
Res := TPAtoATPA(TPA,Dist);
|
||||
end;
|
||||
procedure ps_CombineIntArrayWrap(Ar1, Ar2: TIntegerArray; var Res : TIntegerArray);extdecl;
|
||||
procedure ps_CombineIntArrayWrap(const Ar1, Ar2: TIntegerArray; var Res : TIntegerArray);extdecl;
|
||||
begin
|
||||
Res := CombineIntArray(Ar1,Ar2);
|
||||
end;
|
||||
procedure ps_MergeATPAWrap(ATPA : T2DPointArray; var Res: TPointArray); extdecl;
|
||||
procedure ps_MergeATPAWrap(const ATPA : T2DPointArray; var Res: TPointArray); extdecl;
|
||||
begin
|
||||
Res := MergeATPA(ATPA);
|
||||
end;
|
||||
@ -332,11 +337,11 @@ procedure ps_RotatePointsWrap(Const P: TPointArray; A, cx, cy: Extended; var Res
|
||||
begin
|
||||
Res := RotatePoints(P,a,cx,cy);
|
||||
end;
|
||||
procedure ps_FindTPAEdgesWrap(p: TPointArray; var Res : TPointArray);extdecl;
|
||||
procedure ps_FindTPAEdgesWrap(const p: TPointArray; var Res : TPointArray);extdecl;
|
||||
begin
|
||||
Res := FindTPAEdges(p);
|
||||
end;
|
||||
procedure ps_ClearTPAFromTPAWrap(arP, ClearPoints: TPointArray; var Res : TPointArray);extdecl;
|
||||
procedure ps_ClearTPAFromTPAWrap(const arP, ClearPoints: TPointArray; var Res : TPointArray);extdecl;
|
||||
begin
|
||||
Res := ClearTPAFromTPA(arP, clearpoints);
|
||||
end;
|
||||
@ -350,12 +355,35 @@ begin
|
||||
FilterPointsLine(points,radial,radius,mx,my);
|
||||
end;
|
||||
|
||||
function ps_SameTPA(aTPA, bTPA: TPointArray): Boolean;extdecl;
|
||||
function ps_SameTPA(const aTPA, bTPA: TPointArray): Boolean;extdecl;
|
||||
begin
|
||||
result := SameTPA(atpa,btpa);
|
||||
end;
|
||||
|
||||
function ps_TPAInATPA(TPA: TPointArray; InATPA: T2DPointArray; var Index: LongInt): Boolean;extdecl;
|
||||
function ps_TPAInATPA(const TPA: TPointArray;const InATPA: T2DPointArray; var Index: LongInt): Boolean;extdecl;
|
||||
begin
|
||||
result := TPAInATPA(tpa,inatpa,index);
|
||||
end;
|
||||
procedure ps_OffsetTPA(var TPA : TPointArray; const Offset : TPoint); extdecl;
|
||||
begin
|
||||
OffsetTPA(TPA,offset);
|
||||
end;
|
||||
|
||||
procedure ps_OffsetATPA(var ATPA : T2DPointArray; const Offset : TPoint);extdecl;
|
||||
begin
|
||||
OffsetATPA(atpa,offset);
|
||||
end;
|
||||
function ps_CopyTPA(const TPA : TPointArray) : TPointArray;extdecl;
|
||||
begin
|
||||
result := Copy(TPA,0,Length(TPA));
|
||||
end;
|
||||
|
||||
function ps_CopyATPA(const ATPA : T2DPointArray) : T2DPointArray; extdecl;
|
||||
var
|
||||
i,l : integer;
|
||||
begin
|
||||
l := high(ATPA);
|
||||
SetLength(result,l+1);
|
||||
for i := 0 to l do
|
||||
result[i] := copy(ATPA[i],0,Length(ATPA[i]));
|
||||
end;
|
||||
|
||||
@ -26,6 +26,8 @@ x.AddConstantN('ScriptPath','string').SetString(Self.ScriptPath);
|
||||
x.AddConstantN('IncludePath','string').SetString(Self.IncludePath);
|
||||
x.AddConstantN('PluginPath','string').SetString(Self.PluginPath);
|
||||
x.AddConstantN('FontPath','string').SetString(Self.FontPath);
|
||||
x.AddConstantN('MaxLongInt','integer').SetInt(maxLongint);
|
||||
x.AddConstantN('MaxInt','integer').SetInt(maxLongint);
|
||||
x.AddTypeS('TReplaceFlag', '(rfReplaceAll, rfIgnoreCase)');
|
||||
x.AddTypeS('TReplaceFlags','set of TReplaceFlag');
|
||||
x.AddTypeS('StrExtr','(Numbers, Letters, Others);');
|
||||
|
||||
@ -318,8 +318,8 @@ AddFunction(@ps_tpaSwap,'procedure tpaSwap(var a, b: TPointArray);');
|
||||
AddFunction(@ps_SwapE,'procedure SwapE(var a, b: Extended);');
|
||||
AddFunction(@ps_RAaSTPAEx,'procedure RAaSTPAEx(var a: TPointArray; const w, h: Integer);');
|
||||
AddFunction(@ps_RAaSTPA,'procedure RAaSTPA(var a: TPointArray; const Dist: Integer);');
|
||||
AddFunction(@ps_NearbyPointInArrayEx,'function NearbyPointInArrayEx(const P: TPoint; w, h:Integer; a: TPointArray): Boolean;');
|
||||
AddFunction(@ps_NearbyPointInArray,'function NearbyPointInArray(const P: TPoint; Dist:Integer; a: TPointArray): Boolean;');
|
||||
AddFunction(@ps_NearbyPointInArrayEx,'function NearbyPointInArrayEx(const P: TPoint; w, h:Integer;const a: TPointArray): Boolean;');
|
||||
AddFunction(@ps_NearbyPointInArray,'function NearbyPointInArray(const P: TPoint; Dist:Integer;const a: TPointArray): Boolean;');
|
||||
AddFunction(@ps_QuickTPASort,'procedure QuickTPASort(var A: TIntegerArray; var B: TPointArray; iLo, iHi: Integer; SortUp: Boolean);');
|
||||
AddFunction(@ps_QuickATPASort,'procedure QuickATPASort(var A: TIntegerArray; var B: T2DPointArray; iLo, iHi: Integer; SortUp: Boolean);');
|
||||
AddFunction(@ps_SortTPAFrom,'procedure SortTPAFrom(var a: TPointArray; const From: TPoint);');
|
||||
@ -327,66 +327,71 @@ AddFunction(@ps_SortATPAFrom,'procedure SortATPAFrom(var a: T2DPointArray; const
|
||||
AddFunction(@ps_SortATPAFromFirstPoint,'procedure SortATPAFromFirstPoint(var a: T2DPointArray; const From: TPoint);');
|
||||
AddFunction(@ps_InvertTPA,'procedure InvertTPA(var a: TPointArray);');
|
||||
AddFunction(@ps_InvertATPA,'procedure InvertATPA(var a: T2DPointArray);');
|
||||
AddFunction(@ps_MiddleTPAEx,'function MiddleTPAEx(TPA: TPointArray; var x, y: Integer): Boolean;');
|
||||
AddFunction(@ps_MiddleTPA,'function MiddleTPA(tpa: TPointArray): TPoint;');
|
||||
AddFunction(@ps_MiddleTPAEx,'function MiddleTPAEx(const TPA: TPointArray; var x, y: Integer): Boolean;');
|
||||
AddFunction(@ps_MiddleTPA,'function MiddleTPA(const tpa: TPointArray): TPoint;');
|
||||
AddFunction(@ps_SortATPASize,'procedure SortATPASize(var a: T2DPointArray; const BigFirst: Boolean);');
|
||||
AddFunction(@ps_SortATPAFromSize,'procedure SortATPAFromSize(var a: T2DPointArray; const Size: Integer; CloseFirst: Boolean);');
|
||||
AddFunction(@ps_InIntArrayEx,'function InIntArrayEx(a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;');
|
||||
AddFunction(@ps_InIntArray,'function InIntArray(a: TIntegerArray; Number: Integer): Boolean;');
|
||||
AddFunction(@ps_InIntArrayEx,'function InIntArrayEx(const a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;');
|
||||
AddFunction(@ps_InIntArray,'function InIntArray(const a: TIntegerArray; Number: Integer): Boolean;');
|
||||
AddFunction(@ps_ClearSameIntegers,'procedure ClearSameIntegers(var a: TIntegerArray);');
|
||||
AddFunction(@ps_ClearSameIntegersAndTPA,'procedure ClearSameIntegersAndTPA(var a: TIntegerArray; var p: TPointArray);');
|
||||
AddFunction(@ps_SplitTPAEx,'function SplitTPAEx(arr: TPointArray; w, h: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_SplitTPA,'function SplitTPA(arr: TPointArray; Dist: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_SplitTPAEx,'function SplitTPAEx(const arr: TPointArray; w, h: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_SplitTPA,'function SplitTPA(const arr: TPointArray; Dist: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_FloodFillTPA,'function FloodFillTPA(const TPA : TPointArray) : T2DPointArray;');
|
||||
AddFunction(@ps_FilterPointsPie,'procedure FilterPointsPie(var Points: TPointArray; const SD, ED, MinR, MaxR: Extended; Mx, My: Integer);');
|
||||
AddFunction(@ps_GetATPABounds,'function GetATPABounds(ATPA: T2DPointArray): TBox;');
|
||||
AddFunction(@ps_GetTPABounds,'function GetTPABounds(TPA: TPointArray): TBox;');
|
||||
AddFunction(@ps_FindTPAinTPA,'function FindTPAinTPA(SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;');
|
||||
AddFunction(@ps_GetSamePointsATPA,'function GetSamePointsATPA( ATPA : T2DPointArray; var Matches : TPointArray) : boolean;');
|
||||
AddFunction(@ps_FindTextTPAinTPA,'function FindTextTPAinTPA(Height : integer; SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;');
|
||||
AddFunction(@ps_GetATPABounds,'function GetATPABounds(const ATPA: T2DPointArray): TBox;');
|
||||
AddFunction(@ps_GetTPABounds,'function GetTPABounds(const TPA: TPointArray): TBox;');
|
||||
AddFunction(@ps_FindTPAinTPA,'function FindTPAinTPA(const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;');
|
||||
AddFunction(@ps_GetSamePointsATPA,'function GetSamePointsATPA(const ATPA : T2DPointArray; var Matches : TPointArray) : boolean;');
|
||||
AddFunction(@ps_FindTextTPAinTPA,'function FindTextTPAinTPA(Height : integer;const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;');
|
||||
AddFunction(@ps_SortCircleWise,'procedure SortCircleWise(var tpa: TPointArray; const cx, cy, StartDegree: Integer; SortUp, ClockWise: Boolean);');
|
||||
AddFunction(@ps_LinearSort,'procedure LinearSort(var tpa: TPointArray; cx, cy, sd: Integer; SortUp: Boolean);');
|
||||
AddFunction(@ps_RotatePoint,'function RotatePoint(Const p: TPoint; angle, mx, my: Extended): TPoint;');
|
||||
AddFunction(@ps_FindGapsTPA,'function FindGapsTPA(TPA: TPointArray; MinPixels: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_RemoveDistTPointArray,'function RemoveDistTPointArray(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray;');
|
||||
AddFunction(@ps_CombineTPA,'function CombineTPA(Ar1, Ar2: TPointArray): TPointArray;');
|
||||
AddFunction(@ps_ReArrangeandShortenArrayEx,'function ReArrangeandShortenArrayEx(a: TPointArray; w, h: Integer): TPointArray;');
|
||||
AddFunction(@ps_ReArrangeandShortenArray,'function ReArrangeandShortenArray(a: TPointArray; Dist: Integer): TPointArray;');
|
||||
AddFunction(@ps_TPAtoATPAEx,'function TPAtoATPAEx(TPA: TPointArray; w, h: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_TPAtoATPA,'function TPAtoATPA(TPA: TPointArray; Dist: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_CombineIntArray,'function CombineIntArray(Ar1, Ar2: TIntegerArray): TIntegerArray;');
|
||||
AddFunction(@ps_MergeATPA,'function MergeATPA(ATPA : T2DPointArray) : TPointArray;');
|
||||
AddFunction(@ps_FindGapsTPA,'function FindGapsTPA(const TPA: TPointArray; MinPixels: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_RemoveDistTPointArray,'function RemoveDistTPointArray(x, y, dist: Integer;const ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray;');
|
||||
AddFunction(@ps_CombineTPA,'function CombineTPA(const Ar1, Ar2: TPointArray): TPointArray;');
|
||||
AddFunction(@ps_ReArrangeandShortenArrayEx,'function ReArrangeandShortenArrayEx(const a: TPointArray; w, h: Integer): TPointArray;');
|
||||
AddFunction(@ps_ReArrangeandShortenArray,'function ReArrangeandShortenArray(const a: TPointArray; Dist: Integer): TPointArray;');
|
||||
AddFunction(@ps_TPAtoATPAEx,'function TPAtoATPAEx(const TPA: TPointArray; w, h: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_TPAtoATPA,'function TPAtoATPA(const TPA: TPointArray; Dist: Integer): T2DPointArray;');
|
||||
AddFunction(@ps_CombineIntArray,'function CombineIntArray(const Ar1, Ar2: TIntegerArray): TIntegerArray;');
|
||||
AddFunction(@ps_MergeATPA,'function MergeATPA(const ATPA : T2DPointArray) : TPointArray;');
|
||||
AddFunction(@ps_TPAFromBox,'function TPAFromBox(const Box : TBox) : TPointArray;');
|
||||
AddFunction(@ps_RotatePoints,'function RotatePoints(Const P: TPointArray; A, cx, cy: Extended): TPointArray ;');
|
||||
AddFunction(@ps_FindTPAEdges,'function FindTPAEdges(p: TPointArray): TPointArray;');
|
||||
AddFunction(@ps_ClearTPAFromTPA,'function ClearTPAFromTPA(arP, ClearPoints: TPointArray): TPointArray;');
|
||||
AddFunction(@ps_FindTPAEdges,'function FindTPAEdges(const p: TPointArray): TPointArray;');
|
||||
AddFunction(@ps_ClearTPAFromTPA,'function ClearTPAFromTPA(const arP, ClearPoints: TPointArray): TPointArray;');
|
||||
AddFunction(@ps_ReturnPointsNotInTPA,'function ReturnPointsNotInTPA(Const TotalTPA: TPointArray; const Box: TBox): TPointArray;');
|
||||
AddFunction(@ps_PointInTPA,'function PointInTPA(p: TPoint; arP: TPointArray): Boolean;');
|
||||
AddFunction(@ps_PointInTPA,'function PointInTPA(p: TPoint;const arP: TPointArray): Boolean;');
|
||||
AddFunction(@ps_ClearDoubleTPA,'procedure ClearDoubleTPA(var TPA: TPointArray);');
|
||||
AddFunction(@ps_TPACountSort,'procedure TPACountSort(Var TPA: TPointArray;const max: TPoint;Const SortOnX : Boolean);');
|
||||
AddFunction(@ps_TPACountSortBase,'procedure TPACountSortBase(Var TPA: TPointArray;const maxx, base: TPoint; const SortOnX : Boolean);');
|
||||
AddFunction(@ps_InvertTIA,'procedure InvertTIA(var tI: TIntegerArray);');
|
||||
AddFunction(@ps_SumIntegerArray,'function SumIntegerArray(Ints : TIntegerArray): Integer;');
|
||||
AddFunction(@ps_AverageTIA,'function AverageTIA(tI: TIntegerArray): Integer;');
|
||||
AddFunction(@ps_AverageExtended,'function AverageExtended(tE: TExtendedArray): Extended;');
|
||||
AddFunction(@ps_SplitTPAExWrap,'procedure SplitTPAExWrap(arr: TPointArray; w, h: Integer; var res : T2DPointArray);');
|
||||
AddFunction(@ps_SplitTPAWrap,'procedure SplitTPAWrap(arr: TPointArray; Dist: Integer; var res: T2DPointArray);');
|
||||
AddFunction(@ps_FindGapsTPAWrap,'procedure FindGapsTPAWrap(TPA: TPointArray; MinPixels: Integer; var Res : T2DPointArray);');
|
||||
AddFunction(@ps_RemoveDistTPointArrayWrap,'procedure RemoveDistTPointArrayWrap(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean; var Res : TPointArray);');
|
||||
AddFunction(@ps_CombineTPAWrap,'procedure CombineTPAWrap(Ar1, Ar2: TPointArray; var Res : TPointArray);');
|
||||
AddFunction(@ps_ReArrangeandShortenArrayExWrap,'procedure ReArrangeandShortenArrayExWrap(a: TPointArray; w, h: Integer; var Res : TPointArray);');
|
||||
AddFunction(@ps_ReArrangeandShortenArrayWrap,'procedure ReArrangeandShortenArrayWrap(a: TPointArray; Dist: Integer; var Res : TPointArray);');
|
||||
AddFunction(@ps_TPAtoATPAExWrap,'procedure TPAtoATPAExWrap(TPA: TPointArray; w, h: Integer; var Res : T2DPointArray);');
|
||||
AddFunction(@ps_TPAtoATPAWrap,'procedure TPAtoATPAWrap(TPA: TPointArray; Dist: Integer; var Res : T2DPointArray);');
|
||||
AddFunction(@ps_CombineIntArrayWrap, 'procedure CombineIntArrayWrap(Ar1, Ar2: TIntegerArray; var Res : TIntegerArray);');
|
||||
AddFunction(@ps_SumIntegerArray,'function SumIntegerArray(const Ints : TIntegerArray): Integer;');
|
||||
AddFunction(@ps_AverageTIA,'function AverageTIA(const tI: TIntegerArray): Integer;');
|
||||
AddFunction(@ps_AverageExtended,'function AverageExtended(const tE: TExtendedArray): Extended;');
|
||||
AddFunction(@ps_SplitTPAExWrap,'procedure SplitTPAExWrap(const arr: TPointArray; w, h: Integer; var res : T2DPointArray);');
|
||||
AddFunction(@ps_SplitTPAWrap,'procedure SplitTPAWrap(const arr: TPointArray; Dist: Integer; var res: T2DPointArray);');
|
||||
AddFunction(@ps_FindGapsTPAWrap,'procedure FindGapsTPAWrap(const TPA: TPointArray; MinPixels: Integer; var Res : T2DPointArray);');
|
||||
AddFunction(@ps_RemoveDistTPointArrayWrap,'procedure RemoveDistTPointArrayWrap(x, y, dist: Integer;const ThePoints: TPointArray; RemoveHigher: Boolean; var Res : TPointArray);');
|
||||
AddFunction(@ps_CombineTPAWrap,'procedure CombineTPAWrap(const Ar1, Ar2: TPointArray; var Res : TPointArray);');
|
||||
AddFunction(@ps_ReArrangeandShortenArrayExWrap,'procedure ReArrangeandShortenArrayExWrap(const a: TPointArray; w, h: Integer; var Res : TPointArray);');
|
||||
AddFunction(@ps_ReArrangeandShortenArrayWrap,'procedure ReArrangeandShortenArrayWrap(const a: TPointArray; Dist: Integer; var Res : TPointArray);');
|
||||
AddFunction(@ps_TPAtoATPAExWrap,'procedure TPAtoATPAExWrap(const TPA: TPointArray; w, h: Integer; var Res : T2DPointArray);');
|
||||
AddFunction(@ps_TPAtoATPAWrap,'procedure TPAtoATPAWrap(const TPA: TPointArray; Dist: Integer; var Res : T2DPointArray);');
|
||||
AddFunction(@ps_CombineIntArrayWrap, 'procedure CombineIntArrayWrap(const Ar1, Ar2: TIntegerArray; var Res : TIntegerArray);');
|
||||
AddFunction(@ps_ReturnPointsNotInTPAWrap,'procedure ReturnPointsNotInTPAWrap(Const TotalTPA: TPointArray; const Box: TBox; var Res : TPointArray);');
|
||||
AddFunction(@ps_MergeATPAWrap,'procedure MergeATPAWrap(ATPA : T2DPointArray; var Res: TPointArray);');
|
||||
AddFunction(@ps_MergeATPAWrap,'procedure MergeATPAWrap(const ATPA : T2DPointArray; var Res: TPointArray);');
|
||||
AddFunction(@ps_TPAFromBoxWrap,'procedure TPAFromBoxWrap(const Box : TBox; var Res : TPointArray);');
|
||||
AddFunction(@ps_RotatePointsWrap,'procedure RotatePointsWrap(Const P: TPointArray; A, cx, cy: Extended; var Res : TPointArray);');
|
||||
AddFunction(@ps_FindTPAEdgesWrap,'procedure FindTPAEdgesWrap(p: TPointArray; var Res : TPointArray);');
|
||||
AddFunction(@ps_ClearTPAFromTPAWrap,'procedure ClearTPAFromTPAWrap(arP, ClearPoints: TPointArray; var Res : TPointArray);');
|
||||
AddFunction(@ps_FindTPAEdgesWrap,'procedure FindTPAEdgesWrap(const p: TPointArray; var Res : TPointArray);');
|
||||
AddFunction(@ps_ClearTPAFromTPAWrap,'procedure ClearTPAFromTPAWrap(const arP, ClearPoints: TPointArray; var Res : TPointArray);');
|
||||
AddFunction(@ps_FilterPointsLine,'procedure FilterPointsLine(var Points: TPointArray; Radial: Extended; Radius, MX, MY: Integer);');
|
||||
AddFunction(@ps_SameTPA,'function SameTPA(aTPA, bTPA: TPointArray): Boolean;');
|
||||
AddFunction(@ps_TPAInATPA,'function TPAInATPA(TPA: TPointArray; InATPA: T2DPointArray; var Index: LongInt): Boolean;');
|
||||
AddFunction(@ps_SameTPA,'function SameTPA(const aTPA, bTPA: TPointArray): Boolean;');
|
||||
AddFunction(@ps_TPAInATPA,'function TPAInATPA(const TPA: TPointArray;const InATPA: T2DPointArray; var Index: LongInt): Boolean;');
|
||||
AddFunction(@ps_offsetTPA,'procedure OffsetTPA(var TPA : TPointArray; const Offset : TPoint);');
|
||||
AddFunction(@ps_offsetATPA,'procedure OffsetATPA(var ATPA : T2DPointArray; const Offset : TPoint);');
|
||||
AddFunction(@ps_copyTPA,'function CopyTPA(const TPA : TPointArray) : TPointArray;');
|
||||
AddFunction(@ps_CopyATPA,'function CopyATPA(const ATPA : T2DPointArray) : T2DPointArray;');
|
||||
|
||||
SetCurrSection('Settings');
|
||||
AddFunction(@ps_KeyIsSetting, 'function KeyIsSetting(const KeyName: String): Boolean;');
|
||||
|
||||
@ -24,7 +24,7 @@
|
||||
unit bitmaps;
|
||||
|
||||
{$mode objfpc}{$H+}
|
||||
|
||||
{$Inline on}
|
||||
interface
|
||||
uses
|
||||
Classes, SysUtils, FPImage,IntfGraphics,graphtype,MufasaTypes,MufasaBase,graphics;
|
||||
@ -542,7 +542,7 @@ var
|
||||
SIndex : Integer;
|
||||
CurrX,CurrY : integer;
|
||||
Search,Replace : LongWord;
|
||||
procedure AddToStack(x,y : integer);
|
||||
procedure AddToStack(x,y : integer);inline;
|
||||
begin
|
||||
if LongWord(FData[y * w + x]) = Search then
|
||||
begin
|
||||
|
||||
@ -24,6 +24,7 @@
|
||||
unit colour_conv;
|
||||
|
||||
{$mode objfpc}{$H+}
|
||||
{$Inline on}
|
||||
|
||||
interface
|
||||
|
||||
|
||||
@ -29,7 +29,7 @@ interface
|
||||
uses
|
||||
Classes, SysUtils, mufasatypes;
|
||||
|
||||
function FastTPASort(TPA: TPointArray; Dists: TIntegerArray; maxDist: Integer; CloseFirst: Boolean): TPointArray;
|
||||
function FastTPASort(const TPA: TPointArray;const Dists: TIntegerArray; maxDist: Integer; CloseFirst: Boolean): TPointArray;
|
||||
procedure QuickSort(var A: TIntegerArray; iLo, iHi: Integer);
|
||||
|
||||
//Start Wizzyplugin
|
||||
@ -40,10 +40,10 @@ procedure RAaSTPAEx(var a: TPointArray; const w, h: Integer);
|
||||
procedure RAaSTPA(var a: TPointArray; const Dist: Integer);
|
||||
function NearbyPointInArrayEx(const P: TPoint; w, h:Integer; a: TPointArray): Boolean;
|
||||
function NearbyPointInArray(const P: TPoint; Dist:Integer; a: TPointArray): Boolean;
|
||||
function ReArrangeandShortenArrayEx(a: TPointArray; w, h: Integer): TPointArray;
|
||||
function ReArrangeandShortenArray(a: TPointArray; Dist: Integer): TPointArray;
|
||||
function TPAtoATPAEx(TPA: TPointArray; w, h: Integer): T2DPointArray;
|
||||
function TPAtoATPA(TPA: TPointArray; Dist: Integer): T2DPointArray;
|
||||
function ReArrangeandShortenArrayEx(const a: TPointArray; w, h: Integer): TPointArray;
|
||||
function ReArrangeandShortenArray(const a: TPointArray; Dist: Integer): TPointArray;
|
||||
function TPAtoATPAEx(const TPA: TPointArray; w, h: Integer): T2DPointArray;
|
||||
function TPAtoATPA(const TPA: TPointArray; Dist: Integer): T2DPointArray;
|
||||
procedure QuickTPASort(var A: TIntegerArray; var B: TPointArray; iLo, iHi: Integer; SortUp: Boolean);
|
||||
procedure QuickATPASort(var A: TIntegerArray; var B: T2DPointArray; iLo, iHi: Integer; SortUp: Boolean);
|
||||
procedure SortTPAFrom(var a: TPointArray; const From: TPoint);
|
||||
@ -51,46 +51,49 @@ procedure SortATPAFrom(var a: T2DPointArray; const From: TPoint);
|
||||
procedure SortATPAFromFirstPoint(var a: T2DPointArray; const From: TPoint);
|
||||
procedure InvertTPA(var a: TPointArray);
|
||||
procedure InvertATPA(var a: T2DPointArray);
|
||||
function MiddleTPAEx(TPA: TPointArray; var x, y: Integer): Boolean;
|
||||
function MiddleTPA(tpa: TPointArray): TPoint;
|
||||
function MiddleTPAEx(const TPA: TPointArray; var x, y: Integer): Boolean;
|
||||
function MiddleTPA(const tpa: TPointArray): TPoint;
|
||||
procedure SortATPASize(var a: T2DPointArray; const BigFirst: Boolean);
|
||||
procedure SortATPAFromSize(var a: T2DPointArray; const Size: Integer; CloseFirst: Boolean);
|
||||
function CombineTPA(Ar1, Ar2: TPointArray): TPointArray;
|
||||
function CombineIntArray(Ar1, Ar2: TIntegerArray): TIntegerArray;
|
||||
function InIntArrayEx(a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;
|
||||
function InIntArray(a: TIntegerArray; Number: Integer): Boolean;
|
||||
function CombineTPA(const Ar1, Ar2: TPointArray): TPointArray;
|
||||
function CombineIntArray(const Ar1, Ar2: TIntegerArray): TIntegerArray;
|
||||
function InIntArrayEx(const a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;
|
||||
function InIntArray(const a: TIntegerArray; Number: Integer): Boolean;
|
||||
procedure ClearSameIntegers(var a: TIntegerArray);
|
||||
procedure ClearSameIntegersAndTPA(var a: TIntegerArray; var p: TPointArray);
|
||||
function SplitTPAEx(arr: TPointArray; w, h: Integer): T2DPointArray;
|
||||
function SplitTPA(arr: TPointArray; Dist: Integer): T2DPointArray;
|
||||
function SplitTPAEx(const arr: TPointArray; w, h: Integer): T2DPointArray;
|
||||
function SplitTPA(const arr: TPointArray; Dist: Integer): T2DPointArray;
|
||||
function FloodFillTPA(const TPA : TPointArray) : T2DPointArray;
|
||||
procedure FilterPointsPie(var Points: TPointArray; const SD, ED, MinR, MaxR: Extended; Mx, My: Integer);
|
||||
procedure FilterPointsLine(var Points: TPointArray; Radial: Extended; Radius, MX, MY: Integer);
|
||||
function RemoveDistTPointArray(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray;
|
||||
function GetATPABounds(ATPA: T2DPointArray): TBox;
|
||||
function GetTPABounds(TPA: TPointArray): TBox;
|
||||
function FindTPAinTPA(SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
function FindTextTPAinTPA(Height : integer; SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
function GetSamePointsATPA( ATPA : T2DPointArray; var Matches : TPointArray) : boolean;
|
||||
function FindGapsTPA(TPA: TPointArray; MinPixels: Integer): T2DPointArray;
|
||||
function RemoveDistTPointArray(x, y, dist: Integer;const ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray;
|
||||
function GetATPABounds(const ATPA: T2DPointArray): TBox;
|
||||
function GetTPABounds(const TPA: TPointArray): TBox;
|
||||
function FindTPAinTPA(SearchTPA: TPointArray; const TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
function FindTextTPAinTPA(Height : integer;const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
function GetSamePointsATPA(const ATPA : T2DPointArray; var Matches : TPointArray) : boolean;
|
||||
function FindGapsTPA(const TPA: TPointArray; MinPixels: Integer): T2DPointArray;
|
||||
procedure SortCircleWise(var tpa: TPointArray; const cx, cy, StartDegree: Integer; SortUp, ClockWise: Boolean);
|
||||
procedure LinearSort(var tpa: TPointArray; cx, cy, sd: Integer; SortUp: Boolean);
|
||||
Function MergeATPA(ATPA : T2DPointArray) : TPointArray;
|
||||
Function MergeATPA(const ATPA : T2DPointArray) : TPointArray;
|
||||
function TPAFromBox(const Box : TBox) : TPointArray;
|
||||
Function RotatePoints(Const P: TPointArray; A, cx, cy: Extended): TPointArray ;
|
||||
Function RotatePoint(Const p: TPoint; angle, mx, my: Extended): TPoint; inline;
|
||||
function FindTPAEdges(p: TPointArray): TPointArray;
|
||||
function PointInTPA(p: TPoint; arP: TPointArray): Boolean;
|
||||
function ClearTPAFromTPA(arP, ClearPoints: TPointArray): TPointArray;
|
||||
function FindTPAEdges(const p: TPointArray): TPointArray;
|
||||
function PointInTPA(const p: TPoint;const arP: TPointArray): Boolean;
|
||||
function ClearTPAFromTPA(const arP, ClearPoints: TPointArray): TPointArray;
|
||||
procedure ClearDoubleTPA(var TPA: TPointArray);
|
||||
Function ReturnPointsNotInTPA(Const TotalTPA: TPointArray; const Box: TBox): TPointArray;
|
||||
Procedure TPACountSort(Var TPA: TPointArray;const max: TPoint;Const SortOnX : Boolean);
|
||||
Procedure TPACountSortBase(Var TPA: TPointArray;const maxx, base: TPoint; const SortOnX : Boolean);
|
||||
procedure InvertTIA(var tI: TIntegerArray);
|
||||
function SumIntegerArray(Ints : TIntegerArray): Integer;
|
||||
function AverageTIA(tI: TIntegerArray): Integer;
|
||||
function AverageExtended(tE: TExtendedArray): Extended;
|
||||
function SameTPA(aTPA, bTPA: TPointArray): Boolean;
|
||||
function TPAInATPA(TPA: TPointArray; InATPA: T2DPointArray; var Index: LongInt): Boolean;
|
||||
function SumIntegerArray(const Ints : TIntegerArray): Integer;
|
||||
function AverageTIA(const tI: TIntegerArray): Integer;
|
||||
function AverageExtended(const tE: TExtendedArray): Extended;
|
||||
function SameTPA(const aTPA, bTPA: TPointArray): Boolean;
|
||||
function TPAInATPA(const TPA: TPointArray;const InATPA: T2DPointArray; var Index: LongInt): Boolean;
|
||||
procedure OffsetTPA(var TPA : TPointArray; const Offset : TPoint);
|
||||
procedure OffsetATPA(var ATPA : T2DPointArray; const Offset : TPoint);
|
||||
|
||||
implementation
|
||||
|
||||
@ -104,7 +107,7 @@ uses
|
||||
Very Fast TPA Sort, uses an adepted CountSort algorithm.
|
||||
/\}
|
||||
|
||||
Function FastTPASort(TPA: TPointArray; Dists: TIntegerArray; maxDist: Integer; CloseFirst: Boolean): TPointArray;
|
||||
Function FastTPASort(const TPA: TPointArray;const Dists: TIntegerArray; maxDist: Integer; CloseFirst: Boolean): TPointArray;
|
||||
|
||||
{
|
||||
If you want to understand this algorithm, it might be helpful to read about
|
||||
@ -353,7 +356,7 @@ end;
|
||||
Results the TPointArray a with one point per box with side lengths W and H left.
|
||||
/\}
|
||||
|
||||
function ReArrangeandShortenArrayEx(a: TPointArray; w, h: Integer): TPointArray;
|
||||
function ReArrangeandShortenArrayEx(const a: TPointArray; w, h: Integer): TPointArray;
|
||||
var
|
||||
i, t, c, l: Integer;
|
||||
Found: Boolean;
|
||||
@ -384,7 +387,7 @@ end;
|
||||
Results the TPointArray a with one point per box with side length Dist left.
|
||||
/\}
|
||||
|
||||
function ReArrangeandShortenArray(a: TPointArray; Dist: Integer): TPointArray;
|
||||
function ReArrangeandShortenArray(const a: TPointArray; Dist: Integer): TPointArray;
|
||||
var
|
||||
i, t, c, l: Integer;
|
||||
Found: Boolean;
|
||||
@ -415,7 +418,7 @@ end;
|
||||
Splits the TPA to boxes with sidelengths W and H and results them as a T2DPointArray.
|
||||
/\}
|
||||
|
||||
function TPAtoATPAEx(TPA: TPointArray; w, h: Integer): T2DPointArray;
|
||||
function TPAtoATPAEx(const TPA: TPointArray; w, h: Integer): T2DPointArray;
|
||||
var
|
||||
a, b, c, l: LongInt;
|
||||
Found: Boolean;
|
||||
@ -451,7 +454,7 @@ end;
|
||||
Splits the TPA to boxes with sidelength Dist and results them as a T2DPointArray.
|
||||
/\}
|
||||
|
||||
function TPAtoATPA(TPA: TPointArray; Dist: Integer): T2DPointArray;
|
||||
function TPAtoATPA(const TPA: TPointArray; Dist: Integer): T2DPointArray;
|
||||
var
|
||||
a, b, c, l: LongInt;
|
||||
Found: Boolean;
|
||||
@ -646,7 +649,7 @@ end;
|
||||
Stores the coordinates of the middle of the TPointArray a to X and Y.
|
||||
/\}
|
||||
|
||||
function MiddleTPAEx(TPA: TPointArray; var x, y: Integer): Boolean;
|
||||
function MiddleTPAEx(const TPA: TPointArray; var x, y: Integer): Boolean;
|
||||
var
|
||||
i, l: Integer;
|
||||
begin
|
||||
@ -669,7 +672,7 @@ end;
|
||||
Returns the middle of the TPointArray tpa.
|
||||
/\}
|
||||
|
||||
function MiddleTPA(tpa: TPointArray): TPoint;
|
||||
function MiddleTPA(const tpa: TPointArray): TPoint;
|
||||
var
|
||||
i, l: Integer;
|
||||
begin
|
||||
@ -725,7 +728,7 @@ end;
|
||||
Combines the TPointArrays Ar1 and Ar2, and results the combination.
|
||||
/\}
|
||||
|
||||
function CombineTPA(Ar1, Ar2: TPointArray): TPointArray;
|
||||
function CombineTPA(const Ar1, Ar2: TPointArray): TPointArray;
|
||||
var
|
||||
i, l1, l2: Integer;
|
||||
begin
|
||||
@ -741,7 +744,7 @@ end;
|
||||
Combines the TIntegerArrays Ar1 and Ar2, and results the combination.
|
||||
/\}
|
||||
|
||||
function CombineIntArray(Ar1, Ar2: TIntegerArray): TIntegerArray;
|
||||
function CombineIntArray(const Ar1, Ar2: TIntegerArray): TIntegerArray;
|
||||
var
|
||||
i, l1, l2: Integer;
|
||||
begin
|
||||
@ -757,7 +760,7 @@ end;
|
||||
Returns true if the integer Number was found in the integer array a, and stores the index to Where.
|
||||
/\}
|
||||
|
||||
function InIntArrayEx(a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;
|
||||
function InIntArrayEx(const a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;
|
||||
var
|
||||
i, l: Integer;
|
||||
begin
|
||||
@ -776,7 +779,7 @@ end;
|
||||
Returns true if the integer Number was found in the integer array a.
|
||||
/\}
|
||||
|
||||
function InIntArray(a: TIntegerArray; Number: Integer): Boolean;
|
||||
function InIntArray(const a: TIntegerArray; Number: Integer): Boolean;
|
||||
var
|
||||
i, l: Integer;
|
||||
begin
|
||||
@ -861,7 +864,7 @@ end;
|
||||
Splits the points with max X and Y distances W and H to their own TPointArrays.
|
||||
/\}
|
||||
|
||||
function SplitTPAEx(arr: TPointArray; w, h: Integer): T2DPointArray;
|
||||
function SplitTPAEx(const arr: TPointArray; w, h: Integer): T2DPointArray;
|
||||
var
|
||||
t1, t2, c, ec, tc, l: Integer;
|
||||
tpa: TPointArray;
|
||||
@ -908,7 +911,7 @@ end;
|
||||
Dist 1 puts the points that are next to eachother to their own arrays.
|
||||
/\}
|
||||
|
||||
function SplitTPA(arr: TPointArray; Dist: Integer): T2DPointArray;
|
||||
function SplitTPA(const arr: TPointArray; Dist: Integer): T2DPointArray;
|
||||
var
|
||||
t1, t2, c, ec, tc, l: Integer;
|
||||
tpa: TPointArray;
|
||||
@ -950,6 +953,104 @@ begin
|
||||
SetLength(Result, c);
|
||||
end;
|
||||
|
||||
function FloodFillTPA(const TPA : TPointArray) : T2DPointArray;
|
||||
var
|
||||
x,y,i,CurrentArray, LengthTPA,CurrentStack : integer;
|
||||
TempBox : TBox;
|
||||
PointsToFill : T2DBoolArray;
|
||||
Lengths : TIntegerArray;
|
||||
TempTPA : TPointArray;
|
||||
Stack : TPointArray;
|
||||
fx,fy : integer;
|
||||
begin;
|
||||
LengthTPA := High(TPA);
|
||||
if LengthTPA < 1 then
|
||||
begin;
|
||||
if LengthTPA = 0 then
|
||||
begin;
|
||||
SetLength(Result,1,1);
|
||||
Result[0][0] := TPA[0];
|
||||
end else
|
||||
SetLength(Result,0);
|
||||
exit;
|
||||
end;
|
||||
TempBox := GetTPABounds(TPA);
|
||||
SetLength(PointsToFill,TempBox.x2 - TempBox.x1+3,TempBox.y2 - TempBox.y1+3); //W + 2, H + 2 so that we can check the borders
|
||||
fy := TempBox.y2 - TempBox.y1+3;
|
||||
fx := TempBox.x2 - TempBox.x1+2;
|
||||
for i := 0 to fx do
|
||||
FillChar(PointsToFill[i][0],fy*sizeof(boolean),0);
|
||||
x := TempBox.x1 - 1;
|
||||
y := TempBox.y1 - 1;
|
||||
CurrentArray := -1;
|
||||
SetLength(Stack , LengthTPA + 1);
|
||||
SetLength(Lengths , LengthTPA + 1);
|
||||
SetLength(TempTPA , LengthTPA + 1);
|
||||
For I := 0 to LengthTPA do
|
||||
begin;
|
||||
TempTPA[I].x := TPA[I].x - x;
|
||||
TempTPA[I].y := TPA[I].y - y;
|
||||
end;
|
||||
For I := 0 to LengthTPA do
|
||||
PointsToFill[TempTPA[I].x][TempTPA[I].y] := True;
|
||||
For I := 0 to LengthTPA do
|
||||
if PointsToFill[TempTPA[I].x][TempTPA[I].y] then
|
||||
begin;
|
||||
inc(CurrentArray);
|
||||
SetLength(Result,CurrentArray + 1);
|
||||
SetLength(Result[CurrentArray],LengthTPA - I + 1);
|
||||
Lengths[CurrentArray] := 0;
|
||||
CurrentStack := 0;
|
||||
Stack[0].x := TempTPA[I].x;
|
||||
Stack[0].y := TempTPA[I].y;
|
||||
While CurrentStack > -1 do
|
||||
begin;
|
||||
fx := stack[CurrentStack].x;
|
||||
fy := stack[CurrentStack].y;
|
||||
dec(CurrentStack);
|
||||
Result[CurrentArray][Lengths[CurrentArray]].x := fx + x;
|
||||
Result[CurrentArray][Lengths[CurrentArray]].y := fy + y;
|
||||
inc(Lengths[CurrentArray]);
|
||||
if PointsToFill[fx+1][fy] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy;PointsToFill[fx+1][fy] := false;
|
||||
end;
|
||||
if PointsToFill[fx][fy+1] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx;Stack[Currentstack].y := fy+1;PointsToFill[fx][fy+1] := false;
|
||||
end;
|
||||
if PointsToFill[fx-1][fy] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy;PointsToFill[fx-1][fy] := false;
|
||||
end;
|
||||
if PointsToFill[fx][fy-1] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx;Stack[Currentstack].y := fy-1;PointsToFill[fx][fy-1] := false;
|
||||
end;
|
||||
if PointsToFill[fx+1][fy+1] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy+1;PointsToFill[fx+1][fy+1] := false;
|
||||
end;
|
||||
if PointsToFill[fx-1][fy-1] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy-1;PointsToFill[fx-1][fy-1] := false;
|
||||
end;
|
||||
if PointsToFill[fx-1][fy+1] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy+1;PointsToFill[fx-1][fy+1] := false;
|
||||
end;
|
||||
if PointsToFill[fx+1][fy-1] then
|
||||
begin
|
||||
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy-1;PointsToFill[fx+1][fy-1] := false;
|
||||
end;
|
||||
end;
|
||||
SetLength(Result[CurrentArray],Lengths[CurrentArray]);
|
||||
end;
|
||||
SetLength(Stack,0);
|
||||
SetLength(TempTPA,0);
|
||||
SetLength(Lengths,0);
|
||||
end;
|
||||
|
||||
{/\
|
||||
Removes the points in the TPointArray Points that are not within the degrees
|
||||
\\ SD (StartDegree) and ED (EndDegree) and the distances MinR (MinRadius) and
|
||||
@ -1007,7 +1108,7 @@ var
|
||||
I, Hi, Ind, y: Integer;
|
||||
P: TPointArray;
|
||||
Box: TBox;
|
||||
B: Array of Array of Boolean;
|
||||
B: T2DBoolArray;
|
||||
SinAngle,CosAngle : Extended;
|
||||
begin
|
||||
Ind := 0;
|
||||
@ -1017,7 +1118,10 @@ begin
|
||||
SetLength(B, max(Box.x2, Round(SinAngle * Radius + MX)) + 1);
|
||||
y:= max(Box.x2, -Round(CosAngle * Radius) + MY);
|
||||
for I:= 0 to High(B) do
|
||||
begin;
|
||||
SetLength(B[I], y + 1);
|
||||
FillChar(B[i][0],y+1,0);
|
||||
end;
|
||||
Hi:= High(Points);
|
||||
for I:= 0 to Hi do
|
||||
B[Points[I].x][Points[I].y]:= True;
|
||||
@ -1039,7 +1143,7 @@ end;
|
||||
Removes the points that are inside or outside the distance Dist from the point (x, y) from the TPointArray ThePoints.
|
||||
/\}
|
||||
|
||||
function RemoveDistTPointArray(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray;
|
||||
function RemoveDistTPointArray(x, y, dist: Integer;const ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray;
|
||||
var
|
||||
I, L, LL: integer;
|
||||
begin;
|
||||
@ -1070,7 +1174,7 @@ end;
|
||||
Returns the boundaries of the ATPA as a TBox.
|
||||
/\}
|
||||
|
||||
function GetATPABounds(ATPA: T2DPointArray): TBox;
|
||||
function GetATPABounds(const ATPA: T2DPointArray): TBox;
|
||||
var
|
||||
I,II,L2,L : Integer;
|
||||
begin;
|
||||
@ -1106,7 +1210,7 @@ end;
|
||||
Returns the boundaries of the TPA as a TBox.
|
||||
/\}
|
||||
|
||||
function GetTPABounds(TPA: TPointArray): TBox;
|
||||
function GetTPABounds(const TPA: TPointArray): TBox;
|
||||
var
|
||||
I,L : Integer;
|
||||
begin;
|
||||
@ -1135,11 +1239,11 @@ end;
|
||||
\\ to the TPA Matches. Returns true if there were atleast one match(es).
|
||||
/\}
|
||||
|
||||
function FindTPAinTPA(SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
function FindTPAinTPA(SearchTPA : TPointArray; const TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
var
|
||||
Len, I,II,LenSearch,xOff,yOff : integer;
|
||||
tx,ty,MatchCount : integer;
|
||||
Screen : Array of Array of Boolean;
|
||||
Screen : T2DBoolArray;
|
||||
ScreenBox,SearchBox : TBox;
|
||||
Found: Boolean;
|
||||
begin;
|
||||
@ -1153,6 +1257,8 @@ begin;
|
||||
SearchBox := GetTPABounds(SearchTPA);
|
||||
try
|
||||
SetLength(Screen,ScreenBox.x2 + 1,ScreenBox.y2 + 1);
|
||||
for i := ScreenBox.x2 downto 0 do
|
||||
FillChar(Screen[i][0],screenbox.y2+1,0);
|
||||
except
|
||||
Exit;
|
||||
end;
|
||||
@ -1212,12 +1318,12 @@ end;
|
||||
Read the description of FindTPAinTPA. Additional Height parameter.
|
||||
/\}
|
||||
|
||||
function FindTextTPAinTPA(Height : integer; SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
function FindTextTPAinTPA(Height : integer;const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;
|
||||
var
|
||||
Len, I,II,LenSearch,LenTPA,xOff,yOff,x,y: integer;
|
||||
tx,ty,MatchCount : integer;
|
||||
Found : boolean;
|
||||
Screen : Array of Array of Boolean;
|
||||
Screen : T2DBoolArray;
|
||||
ScreenBox,SearchBox : TBox;
|
||||
InversedTPA : TPointArray;
|
||||
begin;
|
||||
@ -1235,6 +1341,8 @@ begin;
|
||||
Screenbox.y2 := Screenbox.y2 + (height - SearchBox.y2);
|
||||
SearchBox.y2 := Height;
|
||||
SetLength(Screen, SearchBox.x2 + 1,Searchbox.y2 + 1);
|
||||
for i := ScreenBox.x2 downto 0 do
|
||||
FillChar(screen[i][0],screenbox.y2+1,0);
|
||||
SetLength(InversedTPA,(SearchBox.x2 + 1) * (Searchbox.y2 + 1));
|
||||
for I := 0 to LenSearch do
|
||||
Screen[ SearchTPA[I].x,SearchTPA[I].y] := True;
|
||||
@ -1262,6 +1370,8 @@ begin;
|
||||
try
|
||||
SetLength(Screen,0);
|
||||
SetLength(Screen,ScreenBox.x2 + 1,ScreenBox.y2 + 1);
|
||||
for i := ScreenBox.x2 downto 0 do
|
||||
FillChar(screen[i][0],screenbox.y2+1,0);
|
||||
except
|
||||
Exit;
|
||||
end;
|
||||
@ -1309,7 +1419,7 @@ end;
|
||||
Finds the points that exist in all TPA's in the ATPA.
|
||||
/\}
|
||||
|
||||
function GetSamePointsATPA( ATPA : T2DPointArray; var Matches : TPointArray) : boolean;
|
||||
function GetSamePointsATPA(const ATPA : T2DPointArray; var Matches : TPointArray) : boolean;
|
||||
var
|
||||
I,ii,Len,MatchesC : integer;
|
||||
MinBox,TempBox : TBox;
|
||||
@ -1381,10 +1491,10 @@ end;
|
||||
\\ Only horizontal, sorry folks.
|
||||
/\}
|
||||
|
||||
function FindGapsTPA(TPA: TPointArray; MinPixels: Integer): T2DPointArray;
|
||||
function FindGapsTPA(const TPA: TPointArray; MinPixels: Integer): T2DPointArray;
|
||||
var
|
||||
Len,TotalLen,LenRes,I,II,III : integer;
|
||||
Screen : Array of Array of Boolean;
|
||||
Screen : T2DBoolArray;
|
||||
Height,Width : Integer;
|
||||
Box : TBox;
|
||||
begin;
|
||||
@ -1397,6 +1507,8 @@ begin;
|
||||
III := 0;
|
||||
try
|
||||
SetLength(Screen,Width + 1,Height + 1);
|
||||
for i := 0 to Width do
|
||||
FillChar(Screen[i][0],(Height+1),0);
|
||||
except
|
||||
Exit;
|
||||
end;
|
||||
@ -1530,7 +1642,7 @@ end;
|
||||
Merges the TPointArrays of the T2DPointArray ATPA in to one TPA.
|
||||
/\}
|
||||
|
||||
Function MergeATPA(ATPA: T2DPointArray): TPointArray;
|
||||
Function MergeATPA(const ATPA: T2DPointArray): TPointArray;
|
||||
var
|
||||
I, II, Len, TempL, CurrentL: integer;
|
||||
begin;
|
||||
@ -1614,9 +1726,9 @@ End;
|
||||
Returns the edges of the given TPA.
|
||||
/\}
|
||||
|
||||
function FindTPAEdges(p: TPointArray): TPointArray;
|
||||
function FindTPAEdges(const p: TPointArray): TPointArray;
|
||||
var
|
||||
b: array of array of Boolean;
|
||||
b: T2DBoolArray;
|
||||
i, x, y, l, c: Integer;
|
||||
Box: TBox;
|
||||
begin
|
||||
@ -1628,7 +1740,10 @@ begin
|
||||
y := (Box.y2 - Box.y1) + 3;
|
||||
SetLength(b, x);
|
||||
for i := 0 to x -1 do
|
||||
begin
|
||||
SetLength(b[i], y);
|
||||
FillChar(b[i][0],y,0);
|
||||
end;
|
||||
for i := 0 to l -1 do
|
||||
b[p[i].x +1 - Box.x1][p[i].y +1 - Box.y1] := True;
|
||||
SetLength(Result, l);
|
||||
@ -1659,7 +1774,7 @@ end;
|
||||
Notes: In actuallys means IN the array, not in the box shaped by the array.
|
||||
/\}
|
||||
|
||||
function PointInTPA(p: TPoint; arP: TPointArray): Boolean;
|
||||
function PointInTPA(const p: TPoint;const arP: TPointArray): Boolean;
|
||||
var
|
||||
i, l: Integer;
|
||||
begin
|
||||
@ -1677,11 +1792,12 @@ end;
|
||||
Removes the given ClearPoints from arP.
|
||||
/\}
|
||||
|
||||
function ClearTPAFromTPA(arP, ClearPoints: TPointArray): TPointArray;
|
||||
function ClearTPAFromTPA(const arP, ClearPoints: TPointArray): TPointArray;
|
||||
var
|
||||
i, j, l, l2: Integer;
|
||||
Found: Boolean;
|
||||
begin
|
||||
Setlength(result,0);
|
||||
l := High(arP);
|
||||
l2 := High(ClearPoints);
|
||||
for i := 0 to l do
|
||||
@ -1734,13 +1850,15 @@ end;
|
||||
Function ReturnPointsNotInTPA(Const TotalTPA: TPointArray; const Box: TBox): TPointArray;
|
||||
var
|
||||
x, y, w, h, i, l: integer;
|
||||
B: Array of Array of Boolean;
|
||||
B: T2DBoolArray;
|
||||
begin;
|
||||
w := Box.x2 - Box.x1;
|
||||
h := Box.y2 - Box.y1;
|
||||
if (w = 0) and (h = 0) then
|
||||
Exit;
|
||||
SetLength(b, w + 1, h + 1);
|
||||
for i := w downto 0 do
|
||||
FillChar(b[i][0],h+1,0);
|
||||
l := High(TotalTPA);
|
||||
x := 0;
|
||||
for i := 0 to l do
|
||||
@ -1772,13 +1890,15 @@ end;
|
||||
|
||||
Procedure TPACountSort(Var TPA: TPointArray;const max: TPoint;Const SortOnX : Boolean);
|
||||
Var
|
||||
c: Array Of Array Of Integer;
|
||||
c: T2DIntegerArray;
|
||||
I, II, III, hTPA, cc: Integer;
|
||||
Begin
|
||||
hTPA := High(TPA);
|
||||
if hTPA < 1 then
|
||||
Exit;
|
||||
SetLength(c, max.X + 1,max.Y + 1);
|
||||
for i := max.x downto 0 do
|
||||
FillChar(c[i][0],(max.y+1)*sizeof(Integer),0);
|
||||
For I := 0 To hTPA Do
|
||||
c[TPA[I].x][TPA[I].y] := c[TPA[i].x][TPA[i].y] + 1;
|
||||
|
||||
@ -1817,7 +1937,7 @@ End;
|
||||
|
||||
Procedure TPACountSortBase(Var TPA: TPointArray;const maxx, base: TPoint; const SortOnX : Boolean);
|
||||
Var
|
||||
c: Array Of Array Of Integer;
|
||||
c: T2DIntegerArray;
|
||||
I, II, III, hTPA, cc: Integer;
|
||||
Max : TPoint;
|
||||
Begin
|
||||
@ -1827,6 +1947,8 @@ Begin
|
||||
max.X := maxx.X - base.X;
|
||||
max.Y := maxx.Y - base.Y;
|
||||
SetLength(c, max.X + 1,max.Y + 1);
|
||||
for i := max.x downto 0 do
|
||||
FillChar(c[i][0],(max.y+1)*sizeof(integer),0);
|
||||
hTPA := High(TPA);
|
||||
For I := 0 To hTPA Do
|
||||
c[TPA[I].x - base.X][TPA[I].y - base.Y] := c[TPA[i].x- base.X][TPA[i].y- base.Y] + 1;
|
||||
@ -1862,7 +1984,7 @@ End;
|
||||
{/\
|
||||
Returns the sum of all integers in the array
|
||||
/\}
|
||||
function SumIntegerArray(Ints : TIntegerArray): Integer;
|
||||
function SumIntegerArray(const Ints : TIntegerArray): Integer;
|
||||
var
|
||||
I, H: Integer;
|
||||
begin
|
||||
@ -1890,7 +2012,7 @@ end;
|
||||
Results the Average of an IntegerArray
|
||||
/\}
|
||||
|
||||
function AverageTIA(tI: TIntegerArray): Integer;
|
||||
function AverageTIA(const tI: TIntegerArray): Integer;
|
||||
begin
|
||||
try Result := (SumIntegerArray(tI) div Length(tI)); except Result := 0; end;
|
||||
end;
|
||||
@ -1898,7 +2020,7 @@ end;
|
||||
{/\
|
||||
Results the Average of an ExtendedArray
|
||||
/\}
|
||||
function AverageExtended(tE: TExtendedArray): Extended;
|
||||
function AverageExtended(const tE: TExtendedArray): Extended;
|
||||
var
|
||||
i, h: Integer;
|
||||
begin
|
||||
@ -1916,7 +2038,7 @@ end;
|
||||
{/\
|
||||
Returns true if the two inputed TPA's are exactly the same (so the order matters)
|
||||
/\}
|
||||
function SameTPA(aTPA, bTPA: TPointArray): Boolean;
|
||||
function SameTPA(const aTPA, bTPA: TPointArray): Boolean;
|
||||
var
|
||||
I: LongInt;
|
||||
h : integer;
|
||||
@ -1933,7 +2055,7 @@ end;
|
||||
{/\
|
||||
Returns true if the TPA is found as one of ATPA's sub-TPA's.. And again, order matters
|
||||
/\}
|
||||
function TPAInATPA(TPA: TPointArray; InATPA: T2DPointArray; var Index: LongInt): Boolean;
|
||||
function TPAInATPA(const TPA: TPointArray;const InATPA: T2DPointArray; var Index: LongInt): Boolean;
|
||||
var
|
||||
I: LongInt;
|
||||
h : integer;
|
||||
@ -1949,6 +2071,25 @@ begin
|
||||
Result := False;
|
||||
end;
|
||||
|
||||
procedure OffsetTPA(var TPA: TPointArray; const Offset: TPoint);
|
||||
var
|
||||
i : integer;
|
||||
begin
|
||||
for i := high(TPA) downto 0 do
|
||||
begin;
|
||||
inc(TPA[i].x,offset.x);
|
||||
inc(TPA[i].y,offset.y);
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure OffsetATPA(var ATPA: T2DPointArray; const Offset: TPoint);
|
||||
var
|
||||
i : integer;
|
||||
begin
|
||||
for i := high(ATPA) downto 0 do
|
||||
OffsetTPA(ATPA[i],Offset);
|
||||
end;
|
||||
|
||||
|
||||
end.
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user