From 2d58a145fc269a4b9f3ae0cda1e27ec47df5e320 Mon Sep 17 00:00:00 2001 From: Raymond Date: Wed, 7 Apr 2010 23:32:17 +0200 Subject: [PATCH] So.. Did the TPA stuff.. PS should now work correctly (?) --- Units/MMLAddon/PSInc/Wrappers/colour.inc | 2 +- Units/MMLAddon/PSInc/Wrappers/other.inc | 5 - Units/MMLAddon/PSInc/Wrappers/tpa.inc | 327 ++++++++++++++++++++- Units/MMLAddon/PSInc/psexportedmethods.inc | 150 +++++----- 4 files changed, 387 insertions(+), 97 deletions(-) diff --git a/Units/MMLAddon/PSInc/Wrappers/colour.inc b/Units/MMLAddon/PSInc/Wrappers/colour.inc index 8e004b6..689d646 100644 --- a/Units/MMLAddon/PSInc/Wrappers/colour.inc +++ b/Units/MMLAddon/PSInc/Wrappers/colour.inc @@ -31,7 +31,7 @@ begin Colors := CurrThread.Client.MFinder.GetColors(coords); end; -function ps_GetColors(Coords : TPointArray) : TIntegerArray; extdecl; +function ps_GetColors(const Coords : TPointArray) : TIntegerArray; extdecl; begin result := CurrThread.Client.MFinder.GetColors(coords); end; diff --git a/Units/MMLAddon/PSInc/Wrappers/other.inc b/Units/MMLAddon/PSInc/Wrappers/other.inc index 782fd8a..884637f 100644 --- a/Units/MMLAddon/PSInc/Wrappers/other.inc +++ b/Units/MMLAddon/PSInc/Wrappers/other.inc @@ -118,11 +118,6 @@ begin; result := GetTickCount - CurrThread.StartTime; end; -procedure ps_Quicksort(var Arr : TIntegerArray); extdecl; -begin - QuickSort(Arr,low(arr),high(arr)); -end; - procedure ps_ConvertTime(Time : integer; var h,m,s : integer); extdecl; var x : integer; diff --git a/Units/MMLAddon/PSInc/Wrappers/tpa.inc b/Units/MMLAddon/PSInc/Wrappers/tpa.inc index 9def848..f1bdb5e 100644 --- a/Units/MMLAddon/PSInc/Wrappers/tpa.inc +++ b/Units/MMLAddon/PSInc/Wrappers/tpa.inc @@ -1,66 +1,361 @@ -procedure SplitTPAExWrap(arr: TPointArray; w, h: Integer; out res : T2DPointArray); +procedure ps_Quicksort(var Arr : TIntegerArray); extdecl; +begin + QuickSort(Arr,low(arr),high(arr)); +end; + +procedure ps_tSwap(var a, b: TPoint); extdecl; +begin + tswap(a,b); +end; + +procedure ps_tpaSwap(var a, b: TPointArray);extdecl; +begin + tpaSwap(a,b); +end; + +procedure ps_SwapE(var a, b: Extended); extdecl; +begin + SwapE(a,b); +end; + +procedure ps_RAaSTPAEx(var a: TPointArray; const w, h: Integer); extdecl; +begin + RAaSTPAEx(a,w,h); +end; + +procedure ps_RAaSTPA(var a: TPointArray; const Dist: Integer); extdecl; +begin + RAaSTPA(a,dist); +end; + +function ps_NearbyPointInArrayEx(const P: TPoint; w, h:Integer; a: TPointArray): Boolean;extdecl; +begin + result := NearbyPointInArrayEx(p,w,h,a); +end; + +function ps_NearbyPointInArray(const P: TPoint; Dist:Integer; a: TPointArray): Boolean; extdecl; +begin + result := NearbyPointInArray(p,dist,a); +end; + +procedure ps_QuickTPASort(var A: TIntegerArray; var B: TPointArray; iLo, iHi: Integer; SortUp: Boolean);extdecl; +begin + QuickTPASort(a,b,ilo,ihi,SortUp); +end; + +procedure ps_QuickATPASort(var A: TIntegerArray; var B: T2DPointArray; iLo, iHi: Integer; SortUp: Boolean);extdecl; +begin + QuickATPASort(a,b,ilo,ihi,sortup); +end; + +procedure ps_SortTPAFrom(var a: TPointArray; const From: TPoint); extdecl; +begin + SortTPAFrom(a,from); +end; + +procedure ps_SortATPAFrom(var a: T2DPointArray; const From: TPoint); extdecl; +begin + SortATPAFrom(a,from); +end; + +procedure ps_SortATPAFromFirstPoint(var a: T2DPointArray; const From: TPoint); extdecl; +begin + SortATPAFromFirstPoint(a,from); +end; + +procedure ps_InvertTPA(var a: TPointArray); extdecl; +begin + InvertTPA(a); +end; + +procedure ps_InvertATPA(var a: T2DPointArray); extdecl; +begin + InvertATPA(a); +end; + +function ps_MiddleTPAEx(TPA: TPointArray; var x, y: Integer): Boolean; extdecl; +begin + Result := MiddleTPAEx(tpa,x,y); +end; + +function ps_MiddleTPA(tpa: TPointArray): TPoint; extdecl; +begin + result := MiddleTPA(tpa); +end; + +procedure ps_SortATPASize(var a: T2DPointArray; const BigFirst: Boolean); extdecl; +begin + SortATPASize(a,bigfirst); +end; + +procedure ps_SortATPAFromSize(var a: T2DPointArray; const Size: Integer; CloseFirst: Boolean);extdecl; +begin + SortATPAFromSize(a,size,closefirst); +end; + +function ps_InIntArrayEx(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; +begin + result := InIntArray(a,number); +end; + +procedure ps_ClearSameIntegers(var a: TIntegerArray);extdecl; +begin + ClearSameIntegers(a); +end; + +procedure ps_ClearSameIntegersAndTPA(var a: TIntegerArray; var p: TPointArray);extdecl; +begin + ClearSameIntegersAndTPA(a,p); +end; + +function ps_SplitTPAEx(arr: TPointArray; w, h: Integer): T2DPointArray; extdecl; +begin + result := SplitTPAEx(arr,w,h); +end; + +function ps_SplitTPA(arr: TPointArray; Dist: Integer): T2DPointArray; extdecl; +begin + result := SplitTPA(arr,dist); +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; +begin + result := GetATPABounds(ATPA); +end; + +function ps_GetTPABounds(TPA: TPointArray): TBox; extdecl; +begin + result := GetTPABounds(TPA); +end; + +function ps_FindTPAinTPA(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; +begin + result := GetSamePointsATPA(ATPA,Matches); +end; + +function ps_FindTextTPAinTPA(Height : integer; SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;extdecl; +begin + result := FindTextTPAinTPA(height,searchtpa,totaltpa,matches); +end; + +procedure ps_SortCircleWise(var tpa: TPointArray; const cx, cy, StartDegree: Integer; SortUp, ClockWise: Boolean);extdecl; +begin + SortCircleWise(tpa,cx,cy,startdegree,sortup,clockwise); +end; + +procedure ps_LinearSort(var tpa: TPointArray; cx, cy, sd: Integer; SortUp: Boolean); extdecl; +begin + LinearSort(tpa,cx,cy,sd,sortup); +end; + +function ps_RotatePoint(Const p: TPoint; angle, mx, my: Extended): TPoint; extdecl; +begin + result := RotatePoint(p,angle,mx,my); +end; + +function ps_FindGapsTPA(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; +begin + Result := RemoveDistTPointArray(x,y,dist,thepoints,removehigher); +end; + +function ps_CombineTPA(Ar1, Ar2: TPointArray): TPointArray; extdecl; +begin + result := CombineTPA(ar1,ar2); +end; + +function ps_ReArrangeandShortenArrayEx(a: TPointArray; w, h: Integer): TPointArray;extdecl; +begin + result := ReArrangeandShortenArrayEx(a,w,h); +end; + +function ps_ReArrangeandShortenArray(a: TPointArray; Dist: Integer): TPointArray; extdecl; +begin + result := ReArrangeandShortenArray(a,dist); +end; + +function ps_TPAtoATPAEx(TPA: TPointArray; w, h: Integer): T2DPointArray; extdecl; +begin + result := TPAtoATPAEx(tpa,w,h); +end; + +function ps_TPAtoATPA(TPA: TPointArray; Dist: Integer): T2DPointArray;extdecl; +begin + Result := TPAtoATPA(tpa,dist); +end; + +function ps_CombineIntArray(Ar1, Ar2: TIntegerArray): TIntegerArray; extdecl; +begin + result := CombineIntArray(ar1,ar2); +end; + +function ps_MergeATPA(ATPA : T2DPointArray) : TPointArray; extdecl; +begin + result := MergeATPA(ATPA); +end; + +function ps_TPAFromBox(const Box : TBox) : TPointArray; extdecl; +begin + result := TPAFromBox(box); +end; + +function ps_RotatePoints(Const P: TPointArray; A, cx, cy: Extended): TPointArray; extdecl; +begin + Result := RotatePoints(p,a,cx,cy); +end; + +function ps_FindTPAEdges(p: TPointArray): TPointArray;extdecl; +begin + result := FindTPAEdges(p); +end; + +function ps_ClearTPAFromTPA(arP, ClearPoints: TPointArray): TPointArray; extdecl; +begin + result := ClearTPAFromTPA(arP,ClearPoints); +end; + +function ps_ReturnPointsNotInTPA(Const TotalTPA: TPointArray; const Box: TBox): TPointArray; extdecl; +begin + result := ReturnPointsNotInTPA(totaltpa,box); +end; + +function ps_PointInTPA(p: TPoint; arP: TPointArray): Boolean; extdecl; +begin + result := PointInTPA(p,arp); +end; + +procedure ps_ClearDoubleTPA(var TPA: TPointArray); extdecl; +begin + ClearDoubleTPA(tpa); +end; + +procedure ps_TPACountSort(Var TPA: TPointArray;const max: TPoint;Const SortOnX : Boolean); extdecl; +begin; + TPACountSort(TPA,max,sortonx); +end; + +procedure ps_TPACountSortBase(Var TPA: TPointArray;const maxx, base: TPoint; const SortOnX : Boolean);extdecl; +begin + TPACountSortBase(TPA,maxx,base,sortonx); +end; + +procedure ps_InvertTIA(var tI: TIntegerArray); extdecl; +begin + InvertTIA(ti); +end; + +function ps_SumIntegerArray(Ints : TIntegerArray): Integer; extdecl; +begin + result := SumIntegerArray(ints); +end; + +function ps_AverageTIA(tI: TIntegerArray): Integer; extdecl; +begin + result := AverageTIA(ti); +end; + +function ps_AverageExtended(tE: TExtendedArray): Extended; extdecl; +begin + result := AverageExtended(te); +end; + +procedure ps_SplitTPAExWrap(arr: TPointArray; w, h: Integer; out res : T2DPointArray);extdecl; begin res := SplitTPAEx(arr,w,h); end; -procedure SplitTPAWrap(arr: TPointArray; Dist: Integer; out res: T2DPointArray); +procedure ps_SplitTPAWrap(arr: TPointArray; Dist: Integer; out res: T2DPointArray);extdecl; begin res := SplitTPA(arr,dist); end; -procedure FindGapsTPAWrap(TPA: TPointArray; MinPixels: Integer; out Res : T2DPointArray); extdecl; +procedure ps_FindGapsTPAWrap(TPA: TPointArray; MinPixels: Integer; out Res : T2DPointArray); extdecl; begin Res := FindGapsTPA(TPA,MinPixels); end; -procedure RemoveDistTPointArrayWrap(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean; out Res : TPointArray);extdecl; +procedure ps_RemoveDistTPointArrayWrap(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean; out Res : TPointArray);extdecl; begin Res := RemoveDistTPointArray(x,y,dist,thepoints,removehigher); end; -procedure CombineTPAWrap(Ar1, Ar2: TPointArray; out Res : TPointArray);extdecl; +procedure ps_CombineTPAWrap(Ar1, Ar2: TPointArray; out Res : TPointArray);extdecl; begin Res := CombineTPA(Ar1,Ar2); end; -procedure ReArrangeandShortenArrayExWrap(a: TPointArray; w, h: Integer; out Res : TPointArray);extdecl; +procedure ps_ReArrangeandShortenArrayExWrap(a: TPointArray; w, h: Integer; out Res : TPointArray);extdecl; begin Res := ReArrangeandShortenArrayEx(a,w,h); end; -procedure ReArrangeandShortenArrayWrap(a: TPointArray; Dist: Integer; out Res : TPointArray);extdecl; +procedure ps_ReArrangeandShortenArrayWrap(a: TPointArray; Dist: Integer; out Res : TPointArray);extdecl; begin Res := ReArrangeandShortenArray(a,dist); end; -procedure TPAtoATPAExWrap(TPA: TPointArray; w, h: Integer; out Res : T2DPointArray);extdecl; +procedure ps_TPAtoATPAExWrap(TPA: TPointArray; w, h: Integer; out Res : T2DPointArray);extdecl; begin Res := TPAtoATPAEx(TPA,w,h); end; -procedure TPAtoATPAWrap(TPA: TPointArray; Dist: Integer; out Res : T2DPointArray);extdecl; +procedure ps_TPAtoATPAWrap(TPA: TPointArray; Dist: Integer; out Res : T2DPointArray);extdecl; begin Res := TPAtoATPA(TPA,Dist); end; -procedure CombineIntArrayWrap(Ar1, Ar2: TIntegerArray; out Res : TIntegerArray);extdecl; +procedure ps_CombineIntArrayWrap(Ar1, Ar2: TIntegerArray; out Res : TIntegerArray);extdecl; begin Res := CombineIntArray(Ar1,Ar2); end; -procedure MergeATPAWrap(ATPA : T2DPointArray; out Res: TPointArray); extdecl; +procedure ps_MergeATPAWrap(ATPA : T2DPointArray; out Res: TPointArray); extdecl; begin Res := MergeATPA(ATPA); end; -procedure TPAFromBoxWrap(const Box : TBox; out Res : TPointArray);extdecl; +procedure ps_TPAFromBoxWrap(const Box : TBox; out Res : TPointArray);extdecl; begin Res := TPAFromBox(Box); end; -procedure RotatePointsWrap(Const P: TPointArray; A, cx, cy: Extended; out Res : TPointArray);extdecl; +procedure ps_RotatePointsWrap(Const P: TPointArray; A, cx, cy: Extended; out Res : TPointArray);extdecl; begin Res := RotatePoints(P,a,cx,cy); end; -procedure FindTPAEdgesWrap(p: TPointArray; out Res : TPointArray);extdecl; +procedure ps_FindTPAEdgesWrap(p: TPointArray; out Res : TPointArray);extdecl; begin Res := FindTPAEdges(p); end; -procedure ClearTPAFromTPAWrap(arP, ClearPoints: TPointArray; out Res : TPointArray);extdecl; +procedure ps_ClearTPAFromTPAWrap(arP, ClearPoints: TPointArray; out Res : TPointArray);extdecl; begin Res := ClearTPAFromTPA(arP, clearpoints); end; -procedure ReturnPointsNotInTPAWrap(Const TotalTPA: TPointArray; const Box: TBox; out Res : TPointArray);extdecl; +procedure ps_ReturnPointsNotInTPAWrap(Const TotalTPA: TPointArray; const Box: TBox; out Res : TPointArray);extdecl; begin Res := ReturnPointsNotInTPA(TotalTPA,box); end; + +procedure ps_FilterPointsLine(var Points: TPointArray; Radial: Extended; Radius, MX, MY: Integer);extdecl; +begin + FilterPointsLine(points,radial,radius,mx,my); +end; + +function ps_SameTPA(aTPA, bTPA: TPointArray): Boolean;extdecl; +begin + result := SameTPA(atpa,btpa); +end; + +function ps_TPAInATPA(TPA: TPointArray; InATPA: T2DPointArray; var Index: LongInt): Boolean;extdecl; +begin + result := TPAInATPA(tpa,inatpa,index); +end; diff --git a/Units/MMLAddon/PSInc/psexportedmethods.inc b/Units/MMLAddon/PSInc/psexportedmethods.inc index ab86d7f..b8cb4db 100644 --- a/Units/MMLAddon/PSInc/psexportedmethods.inc +++ b/Units/MMLAddon/PSInc/psexportedmethods.inc @@ -196,7 +196,7 @@ AddFunction(@ps_GetToleranceSpeed, 'function GetToleranceSpeed: Integer;'); AddFunction(@ps_SetToleranceSpeed2Modifiers, 'procedure SetToleranceSpeed2Modifiers(nHue, nSat: Extended);'); AddFunction(@ps_GetToleranceSpeed2Modifiers, 'procedure GetToleranceSpeed2Modifiers(var hMod, sMod: Extended);'); AddFunction(@ps_GetColor,'function GetColor(x, y: Integer): Integer;'); -AddFunction(@ps_GetColors,'function GetColors(Coords : TPointArray) : TIntegerArray;'); +AddFunction(@ps_GetColors,'function GetColors(const Coords : TPointArray) : TIntegerArray;'); AddFunction(@ps_GetColorsWrap,'procedure GetColorsWrap(Coords : TPointArray; var Colors :TIntegerArray);'); AddFunction(@ps_FindColor, 'function FindColor(var x, y: integer; color, xs, ys, xe, ye: integer): boolean;'); AddFunction(@ps_findcolortoleranceOptimised, 'function FindColorToleranceOptimised(var x, y: integer; color, xs, ys, xe, ye, tol: integer): boolean;'); @@ -294,80 +294,80 @@ AddFunction(@ps_DrawBitmap,'procedure DrawBitmap(Bmp: Integer; Dest: TCanvas; x, {tpa} SetCurrSection('TPA'); AddFunction(@ps_Quicksort,'procedure Quicksort(var Arr : TIntegerArray);'); -AddFunction(@tSwap,'procedure tSwap(var a, b: TPoint);'); -AddFunction(@tpaSwap,'procedure tpaSwap(var a, b: TPointArray);'); -AddFunction(@SwapE,'procedure SwapE(var a, b: Extended);'); -AddFunction(@RAaSTPAEx,'procedure RAaSTPAEx(var a: TPointArray; const w, h: Integer);'); -AddFunction(@RAaSTPA,'procedure RAaSTPA(var a: TPointArray; const Dist: Integer);'); -AddFunction(@NearbyPointInArrayEx,'function NearbyPointInArrayEx(const P: TPoint; w, h:Integer; a: TPointArray): Boolean;'); -AddFunction(@NearbyPointInArray,'function NearbyPointInArray(const P: TPoint; Dist:Integer; a: TPointArray): Boolean;'); -AddFunction(@QuickTPASort,'procedure QuickTPASort(var A: TIntegerArray; var B: TPointArray; iLo, iHi: Integer; SortUp: Boolean);'); -AddFunction(@QuickATPASort,'procedure QuickATPASort(var A: TIntegerArray; var B: T2DPointArray; iLo, iHi: Integer; SortUp: Boolean);'); -AddFunction(@SortTPAFrom,'procedure SortTPAFrom(var a: TPointArray; const From: TPoint);'); -AddFunction(@SortATPAFrom,'procedure SortATPAFrom(var a: T2DPointArray; const From: TPoint);'); -AddFunction(@SortATPAFromFirstPoint,'procedure SortATPAFromFirstPoint(var a: T2DPointArray; const From: TPoint);'); -AddFunction(@InvertTPA,'procedure InvertTPA(var a: TPointArray);'); -AddFunction(@InvertATPA,'procedure InvertATPA(var a: T2DPointArray);'); -AddFunction(@MiddleTPAEx,'function MiddleTPAEx(TPA: TPointArray; var x, y: Integer): Boolean;'); -AddFunction(@MiddleTPA,'function MiddleTPA(tpa: TPointArray): TPoint;'); -AddFunction(@SortATPASize,'procedure SortATPASize(var a: T2DPointArray; const BigFirst: Boolean);'); -AddFunction(@SortATPAFromSize,'procedure SortATPAFromSize(var a: T2DPointArray; const Size: Integer; CloseFirst: Boolean);'); -AddFunction(@InIntArrayEx,'function InIntArrayEx(a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean;'); -AddFunction(@InIntArray,'function InIntArray(a: TIntegerArray; Number: Integer): Boolean;'); -AddFunction(@ClearSameIntegers,'procedure ClearSameIntegers(var a: TIntegerArray);'); -AddFunction(@ClearSameIntegersAndTPA,'procedure ClearSameIntegersAndTPA(var a: TIntegerArray; var p: TPointArray);'); -AddFunction(@SplitTPAEx,'function SplitTPAEx(arr: TPointArray; w, h: Integer): T2DPointArray;'); -AddFunction(@SplitTPA,'function SplitTPA(arr: TPointArray; Dist: Integer): T2DPointArray;'); -AddFunction(@FilterPointsPie,'procedure FilterPointsPie(var Points: TPointArray; const SD, ED, MinR, MaxR: Extended; Mx, My: Integer);'); -AddFunction(@GetATPABounds,'function GetATPABounds(ATPA: T2DPointArray): TBox;'); -AddFunction(@GetTPABounds,'function GetTPABounds(TPA: TPointArray): TBox;'); -AddFunction(@FindTPAinTPA,'function FindTPAinTPA(SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;'); -AddFunction(@GetSamePointsATPA,'function GetSamePointsATPA( ATPA : T2DPointArray; var Matches : TPointArray) : boolean;'); -AddFunction(@FindTextTPAinTPA,'function FindTextTPAinTPA(Height : integer; SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean;'); -AddFunction(@SortCircleWise,'procedure SortCircleWise(var tpa: TPointArray; const cx, cy, StartDegree: Integer; SortUp, ClockWise: Boolean);'); -AddFunction(@LinearSort,'procedure LinearSort(var tpa: TPointArray; cx, cy, sd: Integer; SortUp: Boolean);'); -AddFunction(@RotatePoint,'function RotatePoint(Const p: TPoint; angle, mx, my: Extended): TPoint;'); -AddFunction(@FindGapsTPA,'function FindGapsTPA(TPA: TPointArray; MinPixels: Integer): T2DPointArray;'); -AddFunction(@RemoveDistTPointArray,'function RemoveDistTPointArray(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray;'); -AddFunction(@CombineTPA,'function CombineTPA(Ar1, Ar2: TPointArray): TPointArray;'); -AddFunction(@ReArrangeandShortenArrayEx,'function ReArrangeandShortenArrayEx(a: TPointArray; w, h: Integer): TPointArray;'); -AddFunction(@ReArrangeandShortenArray,'function ReArrangeandShortenArray(a: TPointArray; Dist: Integer): TPointArray;'); -AddFunction(@TPAtoATPAEx,'function TPAtoATPAEx(TPA: TPointArray; w, h: Integer): T2DPointArray;'); -AddFunction(@TPAtoATPA,'function TPAtoATPA(TPA: TPointArray; Dist: Integer): T2DPointArray;'); -AddFunction(@CombineIntArray,'function CombineIntArray(Ar1, Ar2: TIntegerArray): TIntegerArray;'); -AddFunction(@MergeATPA,'function MergeATPA(ATPA : T2DPointArray) : TPointArray;'); -AddFunction(@TPAFromBox,'function TPAFromBox(const Box : TBox) : TPointArray;'); -AddFunction(@RotatePoints,'function RotatePoints(Const P: TPointArray; A, cx, cy: Extended): TPointArray ;'); -AddFunction(@FindTPAEdges,'function FindTPAEdges(p: TPointArray): TPointArray;'); -AddFunction(@ClearTPAFromTPA,'function ClearTPAFromTPA(arP, ClearPoints: TPointArray): TPointArray;'); -AddFunction(@ReturnPointsNotInTPA,'function ReturnPointsNotInTPA(Const TotalTPA: TPointArray; const Box: TBox): TPointArray;'); -AddFunction(@PointInTPA,'function PointInTPA(p: TPoint; arP: TPointArray): Boolean;'); -AddFunction(@ClearDoubleTPA,'procedure ClearDoubleTPA(var TPA: TPointArray);'); -AddFunction(@TPACountSort,'procedure TPACountSort(Var TPA: TPointArray;const max: TPoint;Const SortOnX : Boolean);'); -AddFunction(@TPACountSortBase,'procedure TPACountSortBase(Var TPA: TPointArray;const maxx, base: TPoint; const SortOnX : Boolean);'); -AddFunction(@InvertTIA,'procedure InvertTIA(var tI: TIntegerArray);'); -AddFunction(@SumIntegerArray,'function SumIntegerArray(Ints : TIntegerArray): Integer;'); -AddFunction(@AverageTIA,'function AverageTIA(tI: TIntegerArray): Integer;'); -AddFunction(@AverageExtended,'function AverageExtended(tE: TExtendedArray): Extended;'); -AddFunction(@SplitTPAExWrap,'procedure SplitTPAExWrap(arr: TPointArray; w, h: Integer; var res : T2DPointArray);'); -AddFunction(@SplitTPAWrap,'procedure SplitTPAWrap(arr: TPointArray; Dist: Integer; var res: T2DPointArray);'); -AddFunction(@FindGapsTPAWrap,'procedure FindGapsTPAWrap(TPA: TPointArray; MinPixels: Integer; var Res : T2DPointArray);'); -AddFunction(@RemoveDistTPointArrayWrap,'procedure RemoveDistTPointArrayWrap(x, y, dist: Integer; ThePoints: TPointArray; RemoveHigher: Boolean; var Res : TPointArray);'); -AddFunction(@CombineTPAWrap,'procedure CombineTPAWrap(Ar1, Ar2: TPointArray; var Res : TPointArray);'); -AddFunction(@ReArrangeandShortenArrayExWrap,'procedure ReArrangeandShortenArrayExWrap(a: TPointArray; w, h: Integer; var Res : TPointArray);'); -AddFunction(@ReArrangeandShortenArrayWrap,'procedure ReArrangeandShortenArrayWrap(a: TPointArray; Dist: Integer; var Res : TPointArray);'); -AddFunction(@TPAtoATPAExWrap,'procedure TPAtoATPAExWrap(TPA: TPointArray; w, h: Integer; var Res : T2DPointArray);'); -AddFunction(@TPAtoATPAWrap,'procedure TPAtoATPAWrap(TPA: TPointArray; Dist: Integer; var Res : T2DPointArray);'); -AddFunction(@CombineIntArrayWrap, 'procedure CombineIntArrayWrap(Ar1, Ar2: TIntegerArray; var Res : TIntegerArray);'); -AddFunction(@ReturnPointsNotInTPAWrap,'procedure ReturnPointsNotInTPAWrap(Const TotalTPA: TPointArray; const Box: TBox; var Res : TPointArray);'); -AddFunction(@MergeATPAWrap,'procedure MergeATPAWrap(ATPA : T2DPointArray; var Res: TPointArray);'); -AddFunction(@TPAFromBoxWrap,'procedure TPAFromBoxWrap(const Box : TBox; var Res : TPointArray);'); -AddFunction(@RotatePointsWrap,'procedure RotatePointsWrap(Const P: TPointArray; A, cx, cy: Extended; var Res : TPointArray);'); -AddFunction(@FindTPAEdgesWrap,'procedure FindTPAEdgesWrap(p: TPointArray; var Res : TPointArray);'); -AddFunction(@ClearTPAFromTPAWrap,'procedure ClearTPAFromTPAWrap(arP, ClearPoints: TPointArray; var Res : TPointArray);'); -AddFunction(@FilterPointsLine,'procedure FilterPointsLine(var Points: TPointArray; Radial: Extended; Radius, MX, MY: Integer);'); -AddFunction(@SameTPA,'function SameTPA(aTPA, bTPA: TPointArray): Boolean;'); -AddFunction(@TPAInATPA,'function TPAInATPA(TPA: TPointArray; InATPA: T2DPointArray; var Index: LongInt): Boolean;'); +AddFunction(@ps_tSwap,'procedure tSwap(var a, b: TPoint);'); +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_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);'); +AddFunction(@ps_SortATPAFrom,'procedure SortATPAFrom(var a: T2DPointArray; const From: TPoint);'); +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_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_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_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_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_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_ReturnPointsNotInTPA,'function ReturnPointsNotInTPA(Const TotalTPA: TPointArray; const Box: TBox): TPointArray;'); +AddFunction(@ps_PointInTPA,'function PointInTPA(p: TPoint; 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_ReturnPointsNotInTPAWrap,'procedure ReturnPointsNotInTPAWrap(Const TotalTPA: TPointArray; const Box: TBox; var Res : TPointArray);'); +AddFunction(@ps_MergeATPAWrap,'procedure MergeATPAWrap(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_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;'); SetCurrSection('Settings'); AddFunction(@ps_KeyIsSetting, 'function KeyIsSetting(const KeyName: String): Boolean;');