text stringlengths 14 6.51M |
|---|
{----------------------------------------------------------------------------}
{ Written by Nguyen Le Quang Duy }
{ Nguyen Quang Dieu High School, An Giang }
{----------------------------------------------------------------------------}
Program NOTE;
Var
f :ShortInt;
p :LongInt;
function Find(i :ShortInt; j :LongInt) :Boolean;
var
k :LongInt;
begin
k:=Round(Exp(Ln(2)*(i-1)));
if (j=k) then Exit(false);
if (j>k) then
Exit(Find(i-1,j-k))
else
Exit(not Find(i-1,k-j));
end;
Begin
Assign(Input,''); Reset(Input);
Assign(Output,''); Rewrite(Output);
repeat
Read(f,p);
if (f=0) and (p=0) then Break;
if (Find(f,p)) then WriteLn('U') else WriteLn('D');
until (f=0) and (p=0);
Close(Input); Close(Output);
End. |
program Fibonacci;
// Compiler mode objfpc
// This is the same mode as FPC mode, but it also includes classes, interfaces and exceptions.
// In this case used for optional parameters, the rest of de code is FPC compliant.
{$mode objfpc}
uses math, sysutils;
type
Int64Array = array of Int64;
function fib(n: Int64): Int64;
begin
if n < 2
then fib := n
else fib := fib(n - 1) + fib(n - 2);
end;
function fibLinear(n: Int64; prevFib: Int64 = 0; fib: Int64 = 1): Int64;
var
temp: Int64;
begin
while n > 1 do
begin
temp := prevFib + fib;
prevFib := fib;
fib := temp;
dec(n);
end;
fibLinear := fib;
end;
function fibFormula(n: Int64): Int64;
begin
fibFormula := round(power((power(5, 0.5) + 1) / 2, n) / power(5, 0.5));
end;
function fibTailRecursive(n: Int64; prevFib: Int64 = 0; fib: Int64 = 1): Int64;
begin
if n = 0
then fibTailRecursive := prevFib
else fibTailRecursive := fibTailRecursive(n - 1, fib, prevFib + fib);
end;
function fibFastDoubling(n: Int64): Int64;
function fibFastAuxiliary(n: Int64): Int64Array;
var
fibs: Int64Array;
prevFib, fib, a, b: Int64;
begin
if n = 0
then begin
fibFastAuxiliary := [0, 1];
exit;
end;
fibs := fibFastAuxiliary(floor(n / 2));
prevFib := fibs[0];
fib := fibs[1];
a := prevFib * (fib * 2 - prevFib);
b := prevFib * prevFib + fib * fib;
if n mod 2 = 0
then fibFastAuxiliary := [a, b]
else fibFastAuxiliary := [b, a + b];
end;
begin
fibFastDoubling := fibFastAuxiliary(n)[0];
end;
var input: Int64;
begin
if ParamCount > 0
then input := StrToInt(ParamStr(1))
else input := 29;
WriteLn(IntToStr(fibFastDoubling(input)));
end.
|
unit window;
{$mode objfpc}{$H+}
interface
uses base;
function Hamming(Width: longint): TVector;
function Hann(Width: longint): TVector;
function Cosine(Width: longint): TVector;
function Lanczos(Width: longint): TVector;
function Tukey(Width: longint; alpha: double): TVector;
function Blackman(Width: longint; alpha: double = 0.16): TVector;
implementation
function Hamming(Width: longint): TVector;
var i: longint;
begin
setlength(result, width);
for i := 0 to width-1 do
result[i] := 0.54-0.46*cos((2*pi*i)/(width-1));
end;
function Hann(Width: longint): TVector;
var i: longint;
begin
setlength(result, width);
if width <= 0 then
exit;
result[0] := 0.5*(1+cos((2*pi*width)/(width-1)));
for i := 1 to width-1 do
result[i] := 0.5*(1-cos((2*pi*width)/(width-1)));
end;
function Cosine(Width: longint): TVector;
var i: longint;
begin
setlength(result, width);
for i := 0 to width-1 do
result[i] := sin((pi*i)/(width-1));
end;
function sinc(x: double): double;
begin
result := sin(pi*x)/(pi*x);
end;
function Lanczos(Width: longint): TVector;
var i: longint;
begin
setlength(result, width);
for i := 0 to width-1 do
result[i] := sinc((2*i)/(width-1)-1);
end;
function Tukey(Width: longint; alpha: double): TVector;
var i, an2: longint;
begin
setlength(result, width);
an2 := system.round(width*alpha/2);
for i := 0 to width-1 do
begin
if i <= an2 then
result[i] := 0.5*(1+cos(pi*(i/an2-1)))
else if i >= (width-an2) then
result[i] := 0.5*(1+cos(pi*(i/an2-2/alpha+1)))
else
result[i] := 1;
end;
end;
function Blackman(Width: longint; alpha: double): TVector;
var i: longint;
a0,a1,a2: double;
begin
a0 := (1-alpha)/2;
a1 := 1/2;
a2 := alpha/2;
setlength(result, width);
for i := 0 to width-1 do
result[i] := a0-a1*cos(2*pi*i/(width-1))+a2*cos(4*pi*i/(width-1));
end;
end.
|
unit ULuaEngine;
interface
uses
Windows,Classes,LuaLib,GD_Utils;
type
TLuaState = Lua_State;
TProc = function(L: TLuaState): Integer of object;
TCallback = class
FuncName:string;
Routine: TMethod; // Code and Data for the method
Exec: TProc; // Resulting execution function
end;
TLuaEngine = class(TObject)
private
CallbackList: TList;
procedure CallBackClear(Obj: TObject);
public
Active:Bool;
LuaInstance: TLuaState;
constructor Create(); overload; virtual;
destructor Destroy; override;
//执行文件
Function DoFile(Fs:String):Integer;
//执行字符串
Function DoString(Str:String):Integer;
//注册脚本命令
Function RegisterMethod(FuncName,MethodName:String;Obj: TObject = NIL):Integer;
//获取脚本执行错误信息
Function GetScriptError():String;
//获取已经注册的脚本命令数量
Function GetMethodCount():Integer;
{**脚本内参数获取**}
//获取数值型参数
Function GetValueToInteger(n:Integer):Integer;
//获取字符型参数
function GetValueToString(n:Integer):String;
end;
var
LuaEngine:TLuaEngine;
implementation
{ TLuaEngine }
constructor TLuaEngine.Create;
begin
Active:=False;
inherited Create;
if LoadLuaLib_Mem <> 0 then
begin
LuaInstance := Lua_Open();
luaopen_base(LuaInstance);
CallBackList := TList.Create;
Active:=True;
LogPrintf('脚本引擎加载完毕!',[]);
end else
LogPrintf('脚本引擎加载失败!',[]);
end;
destructor TLuaEngine.Destroy;
begin
CallBackClear(Self);
Lua_Close(LuaInstance);
inherited;
end;
function TLuaEngine.DoFile(Fs: String): Integer;
begin
try
Result := lual_dofile(LuaInstance, Pchar(Fs));
except
Result:=-1;
end;
end;
function TLuaEngine.DoString(Str: String): Integer;
begin
try
Result := luaL_dostring(LuaInstance, PChar(Str));
except
Result:=-1;
end;
end;
function TLuaEngine.GetMethodCount: Integer;
begin
Result:=CallbackList.Count;
end;
function TLuaEngine.GetScriptError: String;
begin
Result := lua_tostring(LuaInstance, -1);
end;
function TLuaEngine.GetValueToInteger(n: Integer): Integer;
begin
Result:=lua_tointeger(LuaInstance,n);
end;
function TLuaEngine.GetValueToString(n: Integer): String;
begin
Result:=lua_tostring(LuaInstance,n);
end;
function LuaCallBack(L: Lua_State): Integer; cdecl;
var
CallBack: TCallBack; // The Object stored in the Object Table
begin
// Retrieve first Closure Value (=Object Pointer)
CallBack := lua_topointer(L, lua_upvalueindex(1));
// Execute only if Object is valid
if (assigned(CallBack) and assigned(CallBack.Exec)) then
Result := CallBack.Exec(L)
else
Result := 0;
end;
function TLuaEngine.RegisterMethod(FuncName, MethodName: String;
Obj: TObject): Integer;
var
CallBack: TCallBack; // Callback Object
begin
// if method name not specified use Lua function name
if (MethodName = '') then
MethodName := FuncName;
// if not object specified use this object
if (Obj = NIL) then
Obj := Self;
// Add Callback Object to the Object Index
CallBack := TCallBack.Create;
CallBack.FuncName:=FuncName;
CallBack.Routine.Data := Obj;
CallBack.Routine.Code := Obj.MethodAddress(String(MethodName));
CallBack.Exec := TProc(CallBack.Routine);
CallbackList.Add(CallBack);
// prepare Closure value (Method Name)
lua_pushstring(LuaInstance, PAnsiChar(FuncName));
// prepare Closure value (CallBack Object Pointer)
lua_pushlightuserdata(LuaInstance, CallBack);
// set new Lua function with Closure value
lua_pushcclosure(LuaInstance, LuaCallBack, 1);
lua_settable(LuaInstance, LUA_GLOBALSINDEX);
Result:=CallbackList.Count;
end;
procedure TLuaEngine.CallBackClear(Obj: TObject);
var
I: Integer;
CallBack: TCallBack;
begin
if CallBackList.Count > 0 then
begin
for I := CallBackList.Count - 1 downto 0 do
begin
CallBack := CallBackList[I-1];
if (assigned(CallBack)) and (CallBack.Routine.Data = Obj) then
begin
CallBack.Free;
CallBackList.Items[I-1] := NIL;
CallBackList.Delete(I-1);
end;
end;
end;
CallBackList.Free;
end;
initialization
LuaEngine:=TLuaEngine.Create;
end.
|
unit IdCoder3To4;
interface
uses
Classes,
IdCoder,
IdException;
const
// Coding Table Length (CTL) values
CTL3To4 = 64;
HalfCodeTable = CTL3To4 div 2;
Base64CodeTable: string =
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
UUCodeTable: string =
'`!"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_';
XXCodeTable: string =
'+-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
UUTable = 'TABLE'; {do not localize}
UUBegin = 'BEGIN '; {do not localize}
UUEnd = 'END'; {do not localize}
minPriv = 600;
maxPriv = 799;
// fState values for TIdUUDecoder
UUStarted = 0;
UUTableBegun = 1;
UUTableOneLine = 2;
UUTableBeenRead = 3;
UUDataStarted = 4;
UUBEGINFound = 5;
UUPrivilegeFound = 6;
UUInitialLength = 8;
UULastCharFound = 9;
UUENDFound = 10;
// These are to be removed once debugging is done...
UUErrTableNotAtEnd = UUTable = ' not at end of line'; {do not localize}
UUErrIncompletePrivilege = 'Not enough chars for three-digit Privilege';
{do not localize}
UUErrIncompletePrivilege2 = 'Too many chars for three-digit Privilege';
{do not localize}
UUErrorPivilageNotNumeric = 'Privilege chars not numeric'; {do not localize}
UUErrorNoBEGINAfterTABLE = 'No BEGIN statement followed a TABLE';
{do not localize}
UUErrorDataEndWithoutEND = ' Data ended without an END statment';
{do not localize}
type
TIdCardinalBytes = record
case integer of
0: (
Byte1: Byte;
Byte2: Byte;
Byte3: Byte;
Byte4: Byte; );
1: (Whole: Cardinal);
end;
TIdASCIICoder = class(TIdCoder)
protected
FCodingTable: string;
FCodeTableLength: Integer;
//
function GetTableIndex(const AChar: Char): Integer;
procedure SetCodingTable(NewTable: string); virtual;
public
property CodingTable: string read FCodingTable write SetCodingTable;
constructor Create(AOwner: TComponent); override;
end;
TId3To4Coder = class(TIdASCIICoder)
protected
procedure Code3To4(In1, In2, In3: Byte; var Out1, Out2, Out3, Out4: Byte);
procedure Code4To3(const AIn1, AIn2, AIn3, AIn4: Byte; var AOut1, AOut2,
AOut3: Byte);
function CodeLine3To4: string;
function CompleteLine3To4: string;
function CodeLine4To3: string;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end;
PIdBase64Encoder = ^TIdBase64Encoder;
TIdBase64Encoder = class(TId3To4Coder)
protected
procedure Coder; override;
procedure CompleteCoding; override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end;
PIdBase64Decoder = ^TIdBase64Decoder;
TIdBase64Decoder = class(TId3To4Coder)
protected
procedure Coder; override;
procedure CompleteCoding; override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end;
PIdUUEncoder = ^TIdUUEncoder;
TIdUUEncoder = class(TId3To4Coder)
protected
FTableNeeded: Boolean;
FIsFirstRound: Boolean;
FPrivilege: Integer;
procedure Coder; override;
procedure CompleteCoding; override;
procedure OutputHeader; virtual;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure SetCodingTable(NewTable: string); override;
procedure SetPrivilege(Priv: Integer);
property Privilege: Integer read FPrivilege write SetPrivilege;
property TableNeeded: Boolean read FTableNeeded write FTableNeeded;
end;
PIdUUDecoder = ^TIdUUDecoder;
TIdUUDecoder = class(TId3To4Coder)
protected
FError, FCompleted: Boolean;
FErrList: TStringList;
FState: Integer;
FRealBufferSize: Integer;
FIsFirstRound: Boolean;
FPrivilege: Integer;
procedure Coder; override;
procedure CompleteCoding; override;
procedure CheckForHeader(DataSize: Integer); virtual;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure SetCodingTable(NewTable: string); override;
procedure SetPrivilege(Priv: Integer);
property Privilege: Integer read FPrivilege write SetPrivilege;
end;
PIdXXEncoder = ^TIdXXEncoder;
TIdXXEncoder = class(TIdUUEncoder)
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end;
PIdXXDecoder = ^TIdXXDecoder;
TIdXXDecoder = class(TIdUUDecoder)
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
end;
EIdTableNotFound = class(EIdException);
function Base64Encode(const s: string): string;
implementation
uses
IdGlobal, IdMIMETypes, IdResourceStrings,
SysUtils;
function FetchEOL(var s: string): string;
var
iCR, iLF: Integer;
begin
iCR := IndyPos(CR, s);
iLF := IndyPos(LF, s);
if (iCR = 0) then
begin
if iLF = 0 then
begin
result := s;
s := '';
end
else
begin
result := Fetch(s, LF);
end;
end
else
if (iCR = iLF - 1) then
begin
result := Fetch(s, CR + LF);
end
else
if (iCR < iLF) or (iLF = 0) then
begin
// CR on it's own
result := Fetch(s, CR);
end
else
begin
// iLF < iCR
result := Fetch(s, LF);
end;
end;
constructor TIdASCIICoder.Create;
begin
inherited Create(AOwner);
if FCodeTableLength > 0 then
begin
SetLength(FCodingTable, FCodeTableLength);
UniqueString(FCodingTable);
end;
fTakesFileName := True;
end;
function TIdASCIICoder.GetTableIndex(const AChar: Char): Integer;
begin
Result := IndyPos(AChar, FCodingTable) - 1;
if Result = -1 then
begin
raise EIdTableNotFound.Create(RSCoderNoTableEntryNotFound);
end;
end;
procedure TIdASCIICoder.SetCodingTable;
begin
FCodingTable := NewTable;
end;
constructor TId3To4Coder.Create;
begin
FCodeTableLength := CTL3To4;
inherited Create(AOwner);
end;
destructor TId3To4Coder.Destroy;
begin
inherited;
end;
procedure TId3To4Coder.Code3To4;
begin
Out1 := Ord(FCodingTable[((In1 shr 2) and 63) + 1]);
Out2 := Ord(FCodingTable[(((In1 shl 4) or
(In2 shr 4)) and 63) + 1]);
Out3 := Ord(FCodingTable[(((In2 shl 2) or
(In3 shr 6)) and 63) + 1]);
Out4 := Ord(FCodingTable[(Ord(In3) and 63) + 1]);
end;
procedure TId3To4Coder.Code4To3(const AIn1, AIn2, AIn3, AIn4: Byte; var AOut1,
AOut2, AOut3: Byte);
var
LCardinal: TIdCardinalBytes;
begin
LCardinal.Whole := (GetTableIndex(Chr(AIn1)) shl 18) or
(GetTableIndex(Chr(AIn2)) shl 12)
or (GetTableIndex(Chr(AIn3)) shl 6) or GetTableIndex(Chr(AIn4));
AOut1 := LCardinal.Byte3;
AOut2 := LCardinal.Byte2;
AOut3 := LCardinal.Byte1;
end;
function TId3To4Coder.CodeLine3To4;
var
i, j: LongWord;
begin
i := FCBufferSize * 4;
j := i div 3 * 3;
if i <> j then
begin
Inc(j, 4);
end;
j := j div 3;
SetLength(result, j);
UniqueString(result);
i := 1;
j := 1;
while i <= FCBufferedData do
begin
Code3To4(Ord(FCBuffer[i]), Ord(FCBuffer[i + 1]), Ord(FCBuffer[i + 2]),
Byte(result[j]), Byte(result[j + 1]), Byte(result[j + 2]),
Byte(result[j + 3]));
Inc(i, 3);
Inc(j, 4);
end;
FCBufferedData := 0;
end;
function TId3To4Coder.CompleteLine3To4;
var
i, j, k: LongWord;
begin
k := FCBufferedData div 3;
j := k * 4;
k := k * 3;
if FCBufferedData <> k then
begin
Inc(j, 4);
end;
SetLength(result, j);
UniqueString(result);
i := 1;
j := 1;
while i <= k do
begin
Code3To4(Ord(FCBuffer[i]), Ord(FCBuffer[i + 1]), Ord(FCBuffer[i + 2]),
Byte(result[j]), Byte(result[j + 1]), Byte(result[j + 2]),
Byte(result[j + 3]));
Inc(i, 3);
Inc(j, 4);
end;
k := FCBufferedData - k;
if k > 0 then
begin
case k of
1:
begin
Code3To4(Ord(FCBuffer[i]), 0, 0,
Byte(result[j]), Byte(result[j + 1]), Byte(result[j + 2]),
Byte(result[j + 3]));
end;
2:
begin
Code3To4(Ord(FCBuffer[i]), Ord(FCBuffer[i + 1]), 0,
Byte(result[j]), Byte(result[j + 1]), Byte(result[j + 2]),
Byte(result[j + 3]));
end;
3:
begin
Code3To4(Ord(FCBuffer[i]), Ord(FCBuffer[i + 1]), Ord(FCBuffer[i + 2]),
Byte(result[j]), Byte(result[j + 1]), Byte(result[j + 2]),
Byte(result[j + 3]));
end;
end;
end;
FCBufferedData := 0;
end;
function TId3To4Coder.CodeLine4To3;
var
i: LongWord;
s: string;
y1, y2, y3: Byte;
begin
i := 1;
s := '';
while i < FCBufferedData do
begin
Code4To3(Ord(FCBuffer[i]), Ord(FCBuffer[i + 1]), Ord(FCBuffer[i + 2]),
Ord(FCBuffer[i + 3]), y1
, y2, y3);
s := s + Chr(y1) + Chr(y2) + Chr(y3);
Inc(i, 4);
end;
result := s;
end;
constructor TIdBase64Encoder.Create;
begin
inherited Create(AOwner);
FCodingTable := Base64CodeTable;
end;
destructor TIdBase64Encoder.Destroy;
begin
inherited;
end;
procedure TIdBase64Encoder.Coder;
var
s: string;
begin
IncByteCount(FCBufferedData);
s := CodeLine3To4;
OutputString(s);
end;
procedure TIdBase64Encoder.CompleteCoding;
var
s: string;
i: LongWord;
begin
fInCompletion := True;
if FCBufferedData = 0 then Exit;
IncByteCount(FCBufferedData);
i := FCBufferedData div 3 * 3;
i := FCBufferedData - i;
s := CompleteLine3To4;
case i of
1:
begin
s[Length(s) - 1] := '=';
s[Length(s)] := '=';
end;
2:
begin
s[Length(s)] := '=';
end;
end;
OutputString(s);
end;
function Base64Encode(const s: string): string;
var
Coder: TIdBase64Encoder;
{I do this as a workaround for a bug}
Res: string;
begin
Result := '';
Coder := TIdBase64Encoder.Create(nil);
try
Coder.AddCRLF := False;
Coder.UseEvent := False;
Coder.Reset;
Coder.CodeString(s);
Res := Coder.CompletedInput;
Result := Copy(Res, 3, Length(Res));
finally
FreeAndNil(Coder);
end;
end;
constructor TIdBase64Decoder.Create;
begin
inherited Create(AOwner);
FCodingTable := Base64CodeTable;
end;
destructor TIdBase64Decoder.Destroy;
begin
inherited;
end;
procedure TIdBase64Decoder.Coder;
var
s, s1, sOut: string;
bCount: LongWord;
exWhile: Boolean;
begin
if FCBufferedData = 0 then Exit;
exWhile := False;
bCount := FCBufferedData;
s1 := Copy(FCBuffer, 1, FCBufferedData);
sOut := '';
while not exWhile do
begin
s := FetchEOL(s1);
if Length(s) = 0 then
begin
s := FetchEOL(s1);
end;
FCBufferedData := length(s);
System.Move(s[1], FCBuffer[1], FCBufferedData);
sOut := sOut + CodeLine4To3;
if IndyPos(CR, s1) = 0 then
begin
exWhile := True;
end;
end;
FCBufferedData := length(s1);
IncByteCount(bCount - FCBufferedData);
if FCBufferedData > 0 then
begin
System.Move(s1[1], FCBuffer[1], FCBufferedData);
end;
OutputString(sOut);
end;
procedure TIdBase64Decoder.CompleteCoding;
var
s, s1, sOut: string;
k: Integer;
in1, in2, in3, in4: Byte;
y1, y2, y3: Byte;
begin
fInCompletion := True;
if FCBufferedData = 0 then Exit;
IncByteCount(FCBufferedData);
s1 := Copy(FCBuffer, 1, FCBufferedData);
while IndyPos(CR, s1) > 0 do
begin
sOut := FetchEOL(s1);
s1 := sOut + s1;
end;
while IndyPos(LF, s1) > 0 do
begin
sOut := FetchEOL(s1);
s1 := sOut + s1;
end;
FCBufferedData := Length(s1);
sOut := '';
while length(s1) > 4 do
begin
s := Copy(s1, 1, 4);
s1 := Copy(s1, 5, length(s1));
Code4To3(Byte(s[1]), Byte(s[2]), Byte(s[3]), Byte(s[4]), y1, y2, y3);
sOut := sOut + Chr(y1) + Chr(y2) + Chr(y3);
end;
while (Length(s1) > 0) and (s1[length(s1)] = '=') do
begin
s1 := Copy(s1, 1, length(s1) - 1);
end;
k := Length(s1);
if k > 0 then
begin
in3 := Byte(FCodingTable[1]);
in4 := Byte(FCodingTable[1]);
in1 := Byte(s1[1]);
in2 := Byte(s1[2]);
case k of
1:
begin
Code4To3(in1, in2, in3, in4, y1, y2, y3);
sOut := sOut + Chr(y1);
end;
2:
begin
in2 := Byte(s1[2]);
Code4To3(in1, in2, in3, in4, y1, y2, y3);
In2 := GetTableIndex(Chr(In2));
if In2 and 15 = 0 then
begin
sOut := sOut + Chr(y1);
end
else
begin
sOut := sOut + Chr(y1) + Chr(y2);
end;
end;
3:
begin
in2 := Byte(s1[2]);
In3 := Byte(s1[3]);
Code4To3(in1, in2, in3, in4, y1, y2, y3);
In3 := GetTableIndex(Chr(In3));
if In3 <= FCodeTableLength shr 2 then
begin
sOut := sOut + Chr(y1) + Chr(y2);
end
else
begin
sOut := sOut + Chr(y1) + Chr(y2) + Chr(In3 shl 6);
end;
end;
4:
begin
in2 := Byte(s1[2]);
In3 := Byte(s1[3]);
In4 := Byte(s1[4]);
Code4To3(In1, In2, In3, In4, y1, y2, y3);
sOut := sOut + Chr(y1) + Chr(y2) + Chr(y3);
end;
end;
end;
OutputString(sOut);
FCBufferedData := 0;
end;
constructor TIdUUEncoder.Create;
begin
inherited Create(AOwner);
FCodingTable := UUCodeTable;
FPrivilege := 644;
FIsFirstRound := True;
FTableNeeded := False;
FAddCRLF := True;
InternSetBufferSize(61);
end;
destructor TIdUUEncoder.Destroy;
begin
inherited;
end;
procedure TIdUUEncoder.OutputHeader;
var
s: string;
begin
if TableNeeded then
begin
OutputString(UUTable);
s := Copy(FCodingTable, 1, FCodeTableLength div 2);
OutputString(s);
s := Copy(FCodingTable, FCodeTableLength div 2 + 1,
FCodeTableLength shl 2);
OutputString(s);
end;
s := UUBegin + IntToStr(FPrivilege) + ' ' + FFileName;
OutputString(s);
FIsFirstRound := False;
end;
procedure TIdUUEncoder.SetCodingTable;
begin
if Length(NewTable) >= FCodeTableLength then
begin
FCodingTable := Copy(NewTable, 1, FCodeTableLength);
end
else
begin
FCodingTable := NewTable + Copy(FCodingTable,
FCodeTableLength + 1, FCodeTableLength - Length(NewTable));
end;
end;
procedure TIdUUEncoder.SetPrivilege(Priv: Integer);
begin
if (Priv >= minPriv) and (Priv <= maxPriv) then
begin
FPrivilege := Priv;
end;
end;
procedure TIdUUEncoder.Coder;
var
s: string;
begin
if FIsFirstRound then
begin
OutputHeader;
end;
IncByteCount(FCBufferedData);
s := FCodingTable[FCBufferSize + 1] + CodeLine3To4;
OutputString(s);
end;
procedure TIdUUEncoder.CompleteCoding;
var
s, s1: string;
begin
fInCompletion := True;
if FIsFirstRound then
begin
OutputHeader;
end;
if FCBufferedData = 0 then
begin
OutputString(FCodingTable[1]);
OutputString(UUEnd);
Exit;
end;
IncByteCount(FCBufferedData);
s := FCodingTable[FCBufferedData + 1] + CompleteLine3To4;
s1 := string(s + CR + LF);
OutputString(s1);
s1 := string(FCodingTable[1] + CR + LF);
OutputString(s1);
s1 := string(UUEnd + CR + LF);
OutputString(s1);
end;
constructor TIdUUDecoder.Create;
begin
inherited Create(AOwner);
FCodingTable := UUCodeTable;
FPrivilege := 644;
FIsFirstRound := True;
FErrList := TStringList.Create;
FError := False;
fInCompletion := False;
FCompleted := false;
FState := UUStarted;
FRealBufferSize := FCBufferSize;
InternSetBufferSize(UUInitialLength);
end;
destructor TIdUUDecoder.Destroy;
begin
inherited;
end;
procedure TIdUUDecoder.SetCodingTable;
begin
if Length(NewTable) >= FCodeTableLength then
begin
FCodingTable := Copy(NewTable, 1, FCodeTableLength);
end
else
begin
FCodingTable := NewTable + Copy(FCodingTable,
FCodeTableLength + 1, FCodeTableLength - Length(NewTable));
end;
end;
procedure TIdUUDecoder.SetPrivilege(Priv: Integer);
begin
if (Priv >= minPriv) and (Priv <= maxPriv) then
begin
FPrivilege := Priv;
end;
end;
procedure TIdUUDecoder.CheckForHeader;
var
i: LongWord;
t, b: Integer;
s, s1: string;
err: Boolean;
begin
if DataSize = 0 then Exit;
s := Copy(FCBuffer, 1, DataSize);
case FState of
UUStarted:
begin
i := IndyPos(UUTable, UpperCase(s));
if i > 0 then
begin
s := Copy(s, i + SizeOf(UUTable), length(s));
s1 := FetchEOL(s);
IncByteCount(i + SizeOf(UUTable) + LongWord(Length(s1)));
FState := UUTableBegun;
OutputNotification(CN_UU_TABLE_FOUND, '');
InternSetBufferSize((FCodeTableLength div 2 + 2));
if Length(s) > 0 then
begin
CodeString(s);
end;
end
else
begin
i := IndyPos(UUBegin, UpperCase(s));
if i > 0 then
begin
s := Copy(s, i + SizeOf(UUBegin) + 1, Length(s));
IncByteCount(i + SizeOf(UUTable) + 1);
i := Length(s);
s := TrimLeft(s);
IncByteCount(i - LongWord(length(s)));
FState := UUBEGINFound;
OutputNotification(CN_UU_BEGIN_FOUND, '');
InternSetBufferSize(3);
FCBufferedData := Length(s);
if FCBufferedData > 0 then
begin
System.Move(s[1], FCBuffer[1], FCBufferedData);
end;
end
else
begin
if fInCompletion then
begin
IncByteCount(FCBufferedData);
FCBufferedData := 0;
end
else
begin
i := Length(s);
s := Copy(s, 3, length(s));
t := IndyPos('T', UpperCase(s));
b := IndyPos('B', UpperCase(s));
if t < b then
begin
if t = 0 then
begin
if b = 0 then
begin
s := '';
end
else
begin
s := Copy(s, b, length(s));
end;
end
else
begin
s := Copy(s, t, length(s));
end;
end
else
begin
if b = 0 then
begin
if t = 0 then
begin
FCBufferedData := 0;
end
else
begin
s := Copy(s, t, length(s));
end;
end
else
begin
s := Copy(s, b, length(s));
end;
end;
if s <> '' then
begin
FCBufferedData := Length(s);
IncByteCount(i - FCBufferedData);
System.Move(s[1], FCBuffer[1], FCBufferedData);
end
else
begin
IncByteCount(FCBufferedData);
FCBufferedData := 0;
end;
end;
end;
end;
end;
UUTableBegun:
begin
SetCodingTable(Copy(s, 1, FCodeTableLength div 2));
s := Copy(s, FCodeTableLength div 2 + 1, length(s));
s1 := FetchEOL(s);
IncByteCount(length(s1));
FState := UUTableOneLine;
FCBufferedData := 0;
if Length(s) > 0 then
begin
CodeString(s);
end;
end;
UUTableOneLine:
begin
SetCodingTable(Copy(FCodingTable, 1, FCodeTableLength div 2) +
Copy(s, 1, FCodeTableLength div 2));
FState := UUTableBeenRead;
s := Copy(s, FCodeTableLength div 2 + 1, Length(s));
s1 := FetchEOL(s);
IncByteCount(length(s1));
InternSetBufferSize(UUInitialLength);
if Length(s) > 0 then
begin
CodeString(s);
end;
end;
UUTableBeenRead:
begin
i := IndyPos(UUBEGIN, UpperCase(s));
if i > 0 then
begin
i := i + 1 + SizeOf(UUBEGIN);
s := Copy(s, i, length(s));
IncByteCount(i);
FState := UUBEGINFound;
OutputNotification(CN_UU_BEGIN_FOUND, '');
InternSetBufferSize(3);
i := Length(s);
s := TrimLeft(s);
IncByteCount(i - LongWord(Length(s)));
if Length(s) > 0 then
begin
CodeString(s);
end;
end
else
begin
FState := UUStarted;
OutputNotification(CN_UU_TABLE_BEGIN_ABORT, '');
FError := True;
FErrList.Add(UUErrorNoBEGINAfterTable);
end;
end;
UUBEGINFound:
begin
if length(s) = 3 then
begin
err := False;
for i := 1 to 3 do
begin
if not IsNumeric(s[1]) then
begin
err := True;
end;
end;
if err then
begin
FError := True;
FErrList.Add(UUErrorPivilageNotNumeric);
OutputNotification(CN_UU_PRIVILEGE_ERROR, '');
end
else
begin
FPrivilege := StrToInt(s);
OutputNotification(CN_UU_PRIVILEGE_FOUND, IntToStr(FPrivilege));
end;
end
else
if length(s) < 3 then
begin
FError := True;
FErrList.Add(UUErrIncompletePrivilege);
OutputNotification(CN_UU_PRIVILEGE_ERROR, '');
end
else
begin
FError := True;
FErrList.Add(UUErrIncompletePrivilege2);
OutputNotification(CN_UU_PRIVILEGE_ERROR, '');
end;
FState := UUPrivilegeFound;
IncByteCount(3);
InternSetBufferSize($FF);
end;
UUPrivilegeFound:
begin
i := Length(s);
s := TrimLeft(s);
IncByteCount(i - LongWord(length(s)));
s1 := FetchEOL(s);
FFileName := s1;
OutputNotification(CN_UU_NEW_FILENAME, FFileName);
FIsFirstRound := False;
InternSetBufferSize(FRealBufferSize);
FCBufferedData := 0;
if Length(s) > 0 then
begin
CodeString(s);
end;
end;
end;
end;
procedure TIdUUDecoder.Coder;
var
s, s1: string;
outlen, inlen: Integer;
begin
if FCompleted then Exit;
if FIsFirstRound then
begin
CheckForHeader(FCBufferSize);
end
else
begin
s1 := Copy(FCBuffer, 1, FCBufferSize);
s := FetchEOL(s1);
if Length(s) = 0 then
begin
s := FetchEOL(s1);
end;
IncByteCount(length(s));
if FState = UULastCharFound then
begin
if Copy(s, 1, Length(UUEnd)) = UUEnd then
begin
OutputNotification(CN_UU_END_FOUND, '');
end
else
begin
end;
Reset;
end
else
if s[1] = FCodingTable[1] then
begin
FState := UULastCharFound;
OutputNotification(CN_UU_LAST_CHAR_FOUND, '');
end
else
begin
outlen := GetTableIndex(s[1]);
if Outlen = 0 then
begin
FCompleted := True;
end;
inLen := outLen div 3 * 4;
System.Move(s[2], FCBuffer[1], inLen);
IncByteCount(FCBufferedData - LongWord(inLen));
FCBufferedData := inLen;
s := CodeLine4To3;
OutputString(Copy(s, 1, outLen));
FCBufferedData := Length(s1);
if FCBufferedData > 0 then
begin
System.Move(s1[1], FCBuffer[1], FCBufferedData);
end;
end;
end;
end;
procedure TIdUUDecoder.CompleteCoding;
var
s, s1, s2: string;
i, j, step, outlen: Integer;
begin
if FCompleted then Exit;
IncByteCount(FCBufferedData);
fInCompletion := True;
if FIsFirstRound then
begin
CheckForHeader(FCBufferedData);
if (FCBufferedData > 0) and FIsFirstRound then
begin
CompleteCoding;
end;
end;
if not FIsFirstRound then
begin
if FCBufferedData = 0 then Exit;
s1 := Copy(FCBuffer, 1, FCBufferedData);
while s1[1] <> FCodingTable[1] do
begin
OutLen := GetTableIndex(s1[1]);
SetLength(s2, OutLen + 4);
s := FetchEOL(s1);
s := Copy(s, 2, length(s));
j := 1;
i := 1;
while i <= length(s) do
begin
Code4To3(Ord(s[i]), Ord(s[i + 1]), Ord(s[i + 2]),
Ord(s[i + 3]), Byte(s2[j]), Byte(s2[j + 1]),
Byte(s2[j + 2]));
Inc(j, 3);
Inc(i, 4);
end;
step := Length(s) - i;
if step >= 1 then
begin
case step of
1:
begin
Code4To3(Ord(s[i]), 0, 0, 0,
Byte(s2[j]), Byte(s2[j + 1]), Byte(s2[j + 2]));
end;
2:
begin
Code4To3(Ord(s[i]), Ord(s[i + 1]), 0, 0,
Byte(s2[j]), Byte(s2[j + 1]), Byte(s2[j + 2]));
end;
3:
begin
Code4To3(Ord(s[i]), Ord(s[i + 1]), Ord(s[i + 2]), 0,
Byte(s2[j]), Byte(s2[j + 1]), Byte(s2[j + 2]));
end;
4:
begin
Code4To3(Ord(s[i]), Ord(s[i + 1]), Ord(s[i + 2]), Ord(s[i + 3]),
Byte(s2[j]), Byte(s2[j + 1]), Byte(s2[j + 2]));
end;
end;
end;
if length(s1) = 0 then
begin
FErrList.Add(UUErrorDataEndWithoutEND);
break;
end;
OutputString(Copy(s2, 1, outLen));
end;
FCBufferedData := 0;
end;
end;
constructor TIdXXEncoder.Create;
begin
inherited Create(AOwner);
FCodingTable := XXCodeTable;
end;
destructor TIdXXEncoder.Destroy;
begin
inherited;
end;
constructor TIdXXDecoder.Create;
begin
inherited Create(AOwner);
FCodingTable := XXCodeTable;
end;
destructor TIdXXDecoder.Destroy;
begin
inherited;
end;
initialization
RegisterCoderClass(TIdBase64Encoder, CT_CREATION, CP_STANDARD,
'', MIMEEncBase64);
RegisterCoderClass(TIdBase64Decoder, CT_REALISATION, CP_STANDARD,
'', MIMEEncBase64);
RegisterCoderClass(TIdUUEncoder, CT_CREATION, CP_STANDARD,
'', MIMEEncUUEncode);
RegisterCoderClass(TIdUUDecoder, CT_REALISATION, CP_STANDARD,
'', MIMEEncUUEncode);
RegisterCoderClass(TIdXXEncoder, CT_CREATION, CP_STANDARD,
'', MIMEEncXXEncode);
RegisterCoderClass(TIdXXDecoder, CT_REALISATION, CP_STANDARD,
'', MIMEEncXXEncode);
end.
|
unit ClassDBF;
interface
uses Classes, SysUtils, Dialogs;
type PFldDesc = ^TFldDesc;
TFldDesc = record
FldName : array[1..11] of char;
FldType : char;
FldAddr : word;
FldLength : byte;
end;
THeader = record
Compatibility : byte;
Rok, Mesiac, Den : byte;
Records : Longword;
HeaderSize : word;
RecordSize : word;
Transaction : byte;
Encryption : byte;
LanguageDriver : byte;
FldDescs : TList;
end;
Tdbf = class
private
Subor : string;
FileStr : TFileStream;
Rows : TList;
protected
function NacitajHeader : THeader;
function NacitajFieldDescriptor : TFldDesc;
procedure NacitajRecords;
procedure Nacitaj;
public
Header : THeader;
function Cells( Row, Col : integer ) : string;
constructor Create( iSubor : string );
destructor Destroy; override;
end;
implementation
//==============================================================================
//==============================================================================
//
// Constructor
//
//==============================================================================
//==============================================================================
constructor Tdbf.Create( iSubor : string );
begin
inherited Create;
Subor := iSubor;
Rows := TList.Create;
Nacitaj;
end;
//==============================================================================
//==============================================================================
//
// Destructor
//
//==============================================================================
//==============================================================================
destructor Tdbf.Destroy;
var I : integer;
begin
for I := 0 to Header.FldDescs.Count-1 do
Dispose( PFldDesc( Header.FldDescs[I] ) );
Header.FldDescs.Free;
for I := 0 to Rows.Count-1 do
FreeMem( Rows.Items[I] , Header.RecordSize );
Rows.Free;
inherited;
end;
//==============================================================================
//==============================================================================
//
// Načítavanie dát zo súboru :
//
//==============================================================================
//==============================================================================
function Tdbf.NacitajHeader : THeader;
begin
with FileStr do
begin
Read( Result.Compatibility , 1 );
Read( Result.Rok , 1 );
Read( Result.Mesiac , 1 );
Read( Result.Den , 1 );
Read( Result.Records , 4 );
Read( Result.HeaderSize , 2 );
Read( Result.RecordSize , 2 );
Seek( 2 , soFromCurrent );
Read( Result.Transaction , 1 );
Read( Result.Encryption , 1 );
Seek( 13 , soFromCurrent );
Read( Result.LanguageDriver , 1 );
Seek( 2 , soFromCurrent );
end;
end;
function Tdbf.NacitajFieldDescriptor : TFldDesc;
begin
with FileStr do
begin
Read( Result.FldName , 11 );
Read( Result.FldType , 1 );
Read( Result.FldAddr , 2 );
Seek( 2 , soFromCurrent );
Read( Result.FldLength , 1 );
Seek( 15 , soFromCurrent );
end;
end;
procedure Tdbf.NacitajRecords;
var I : integer;
P : pointer;
begin
for I := 0 to Header.Records-1 do
begin
GetMem( P , Header.RecordSize );
Rows.Add( P );
FileStr.Read( P^ , Header.RecordSize );
end;
end;
procedure Tdbf.Nacitaj;
var PNewFldDesc : PFldDesc;
Koniec : byte;
begin
FileStr := TFileStream.Create( Subor , fmOpenRead );
//Načítanie hlavičky a popisu jednotlivých polí (Field descriptors)
Header := NacitajHeader;
Header.FldDescs := TList.Create;
repeat
New( PNewFldDesc );
PNewFldDesc^ := NacitajFieldDescriptor;
Header.FldDescs.Add( PNewFldDesc );
until FileStr.Position >= Header.HeaderSize-1;
FileStr.Read( Koniec , 1 );
if Koniec <> $0D then
begin
MessageDlg( 'Nebol nájdený koniec hlavičky!' , mtError , [mbOK] , 0 );
FileStr.Free;
Exit;
end;
//Načítanie tabuľky
NacitajRecords;
FileStr.Free;
end;
//==============================================================================
//==============================================================================
//
// Prístup k jednotlivým bunkám
//
//==============================================================================
//==============================================================================
function Tdbf.Cells( Row, Col : integer ) : string;
var I : integer;
P : pointer;
S : string;
begin
P := Rows.Items[Row-1];
P := Ptr( LongWord( P ) + TFldDesc( Header.FldDescs.Items[Col-1]^ ).FldAddr );
Result := '';
for I := 1 to TFldDesc( Header.FldDescs.Items[Col-1]^ ).FldLength do
Result := Result + Char( Ptr( LongWord( P ) + LongWord( I - 1 ) )^ );
//Formátovanie stringu :
if TFldDesc( Header.FldDescs.Items[Col-1]^ ).FldType = 'C' then
begin
S := Result;
Result := '';
I := 1;
while (S[I] = ' ') and
(I < Length(S)) do Inc( I );
while (S[I] <> ' ') and
(I <= Length(S)) do
begin
Result := Result + S[I];
Inc( I );
end;
end;
//Formátovanie floatu :
if TFldDesc( Header.FldDescs.Items[Col-1]^ ).FldType = 'N' then
begin
S := Result;
Result := '';
I := 1;
while (S[I] = ' ') and
(I < Length(S)) do Inc( I );
while (S[I] <> '.') and
(I <= Length(S)) do
begin
Result := Result + S[I];
Inc( I );
end;
if I > Length(S) then exit;
Result := Result + ',';
Inc( I );
while I <= Length( S ) do
begin
Result := Result + S[I];
Inc( I );
end;
end;
//Formátovanie dátumu :
if TFldDesc( Header.FldDescs.Items[Col-1]^ ).FldType = 'D' then
begin
S := Result;
Result := Copy( S , 7 , 2 ) + '.' + Copy( S , 5 , 2 ) + '.' + Copy( S , 1 , 4 );
end;
end;
end.
|
unit UpdateBDEParametersUnit;
interface
uses BDE, DBTables, Classes, SysUtils, Forms, Dialogs, DB;
Procedure UpdateBDEParameters(Application : TApplication);
const
DBASEVERSION = '\DRIVERS\DBASE\INIT\;VERSION';
DBASETYPE = '\DRIVERS\DBASE\INIT\;TYPE';
DBASELANGDRIVER = '\DRIVERS\DBASE\INIT\;LANGDRIVER';
DBASELEVEL = '\DRIVERS\DBASE\TABLE CREATE\;LEVEL';
DBASEMDXBLOCKSIZE = '\DRIVERS\DBASE\TABLE CREATE\;MDX BLOCK SIZE';
DBASEMEMOFILEBLOCKSIZE = '\DRIVERS\DBASE\TABLE CREATE\;MEMO FILE BLOCK SIZE';
AUTOODBC = '\SYSTEM\INIT\;AUTO ODBC';
DATAREPOSITORY = '\SYSTEM\INIT\;DATA REPOSITORY';
DEFAULTDRIVER = '\SYSTEM\INIT\;DEFAULT DRIVER';
LANGDRIVER = '\SYSTEM\INIT\;LANGDRIVER';
LOCALSHARE = '\SYSTEM\INIT\;LOCAL SHARE';
LOWMEMORYUSAGELIMIT = '\SYSTEM\INIT\;LOW MEMORY USAGE LIMIT';
MAXBUFSIZE = '\SYSTEM\INIT\;MAXBUFSIZE';
MAXFILEHANDLES = '\SYSTEM\INIT\;MAXFILEHANDLES';
MEMSIZE = '\SYSTEM\INIT\;MEMSIZE';
MINBUFSIZE = '\SYSTEM\INIT\;MINBUFSIZE';
MTSPOOLING = '\SYSTEM\INIT\;MTS POOLING';
SHAREDMEMLOCATION = '\SYSTEM\INIT\;SHAREDMEMLOCATION';
SHAREDMEMSIZE = '\SYSTEM\INIT\;SHAREDMEMSIZE';
SQLQRYMODE = '\SYSTEM\INIT\;SQLQRYMODE';
SYSFLAGS = '\SYSTEM\INIT\;SYSFLAGS';
VERSION = '\SYSTEM\INIT\;VERSION';
implementation
{===================================================}
Function SetConfigParameter( Param : string;
Value : string;
var ResultMsg : String) : Boolean;
var
hCur: hDBICur;
rslt: DBIResult;
Config: CFGDesc;
Path, Option: String;
Temp: array[0..255] of char;
TempStr : String;
I : Integer;
Successful : Boolean;
begin
hCur := nil;
Successful := True;
try
If (Pos(';', Param) = 0)
then
raise EDatabaseError.Create('Invalid parameter passed to' +
'function. There must be a semicolon delimited sting passed');
Path := Copy(Param, 0, Pos(';', Param) - 1);
Option := Copy(Param, Pos(';', Param) + 1, Length(Param) - Pos(';', Param));
Check(DbiOpenCfgInfoList(nil, dbiREADWRITE, cfgPERSISTENT,
StrPCopy(Temp, Path), hCur));
Check(DbiSetToBegin(hCur));
repeat
rslt := DbiGetNextRecord(hCur, dbiNOLOCK, @Config, nil);
If (rslt = DBIERR_NONE)
then
begin
TempStr := StrPas(Config.szNodeName);
If (StrPas(Config.szNodeName) = Option)
then
begin
{To set the value, copy in byte by byte and make the following
byte null.}
For I := 0 to (Length(Value) - 1) do
Config.szValue[I] := Value[I + 1];
Config.szValue[Length(Value)] := #0;
rslt := dbiModifyRecord(hCur, @Config, True);
Successful := (Rslt = DBIERR_NONE);
end; {If (StrPas(Config.szNodeName) = Option)}
end
else
If (rslt <> DBIERR_EOF)
then Check(rslt);
until (rslt <> DBIERR_NONE);
finally
If (hCur <> nil)
then Check(DbiCloseCursor(hCur));
end;
If Successful
then TempStr := 'was'
else TempStr := 'was not';
ResultMsg := 'The BDE parameter ' + Option + ' ' +
TempStr + ' successfully set to ' +
Value;
Result := Successful;
end; {SetConfigParameter}
{===================================================}
Function SetBDEConfigParameter( ParameterName : String;
ParameterValue : String;
var ResultMsg : String) : Boolean;
var
ParameterPath : String;
begin
ParameterName := ANSIUpperCase(ParameterName);
If (ParameterName = 'DBASEVERSION')
then ParameterPath := DBASEVERSION;
If (ParameterName = 'DBASETYPE')
then ParameterPath := DBASETYPE;
If (ParameterName = 'DBASELANGDRIVER')
then ParameterPath := DBASELANGDRIVER;
If (ParameterName = 'DBASELEVEL')
then ParameterPath := DBASELEVEL;
If (ParameterName = 'DBASEMDXBLOCKSIZE')
then ParameterPath := DBASEMDXBLOCKSIZE;
If (ParameterName = 'DBASEMEMOFILEBLOCKSIZE')
then ParameterPath := DBASEMEMOFILEBLOCKSIZE;
If (ParameterName = 'AUTOODBC')
then ParameterPath := AUTOODBC;
If (ParameterName = 'DATAREPOSITORY')
then ParameterPath := DATAREPOSITORY;
If (ParameterName = 'DEFAULTDRIVER')
then ParameterPath := DEFAULTDRIVER;
If (ParameterName = 'LANGDRIVER')
then ParameterPath := LANGDRIVER;
If (ParameterName = 'LOCALSHARE')
then ParameterPath := LOCALSHARE;
If (ParameterName = 'LOWMEMORYUSAGELIMIT')
then ParameterPath := LOWMEMORYUSAGELIMIT;
If (ParameterName = 'MAXBUFSIZE')
then ParameterPath := MAXBUFSIZE;
If (ParameterName = 'MAXFILEHANDLES')
then ParameterPath := MAXFILEHANDLES;
If (ParameterName = 'MEMSIZE')
then ParameterPath := MEMSIZE;
If (ParameterName = 'MINBUFSIZE')
then ParameterPath := MINBUFSIZE;
If (ParameterName = 'MTSPOOLING')
then ParameterPath := MTSPOOLING;
If (ParameterName = 'SHAREDMEMLOCATION')
then ParameterPath := SHAREDMEMLOCATION;
If (ParameterName = 'SHAREDMEMSIZE')
then ParameterPath := SHAREDMEMSIZE;
If (ParameterName = 'SQLQRYMODE')
then ParameterPath := SQLQRYMODE;
If (ParameterName = 'SYSFLAGS')
then ParameterPath := SYSFLAGS;
If (ParameterName = 'VERSION')
then ParameterPath := VERSION;
If (Trim(ParameterPath) <> '')
then Result := SetConfigParameter(ParameterPath, ParameterValue, ResultMsg)
else Result := False;
end; {SetBDEConfigParameter}
{$H+}
{===========================================================================}
Function StripLeadingAndEndingDuplicateChar(TempStr : String;
CharToStrip : Char) : String;
begin
Result := TempStr;
If ((Length(Result) > 1) and
(Result[1] = CharToStrip) and
(Result[Length(Result)] = CharToStrip))
then
begin
Delete(Result, Length(Result), 1);
Delete(Result, 1, 1);
end;
end; {StripLeadingAndEndingDuplicateChar}
{$H-}
{$H+}
{===========================================================================}
Procedure ParseCommaDelimitedStringIntoFields(TempStr : String;
FieldList : TStringList;
CapitalizeStrings : Boolean);
var
InEmbeddedQuote : Boolean;
CurrentField : String;
I : Integer;
begin
FieldList.Clear;
InEmbeddedQuote := False;
CurrentField := '';
For I := 1 to Length(TempStr) do
begin
If (TempStr[I] = '"')
then InEmbeddedQuote := not InEmbeddedQuote;
{New field if we have found comma and we are not in an embedded quote.}
If ((TempStr[I] = ',') and
(not InEmbeddedQuote))
then
begin
{If the field starts and ends with a double quote, strip it.}
CurrentField := StripLeadingAndEndingDuplicateChar(CurrentField, '"');
If CapitalizeStrings
then CurrentField := ANSIUpperCase(CurrentField);
FieldList.Add(CurrentField);
CurrentField := '';
end
else CurrentField := CurrentField + TempStr[I];
end; {For I := 1 to Length(TempStr) do}
CurrentField := StripLeadingAndEndingDuplicateChar(CurrentField, '"');
If CapitalizeStrings
then CurrentField := ANSIUpperCase(CurrentField);
FieldList.Add(CurrentField);
end; {ParseCommaDelimitedStringIntoFields}
{$H-}
{================================================================================}
Procedure UpdateBDEParameters(Application : TApplication);
var
ParameterFile : TextFile;
FieldList : TStringList;
TempStr, ResultMsg, AppPath : String;
Done : Boolean;
begin
Done := False;
FieldList := TStringList.Create;
AppPath := ExtractFilePath(ExpandFileName(Application.ExeName));
try
AssignFile(ParameterFile, AppPath + 'WorkstationParameters.txt');
Reset(ParameterFile);
repeat
Readln(ParameterFile, TempStr);
If EOF(ParameterFile)
then Done := True;
ParseCommaDelimitedStringIntoFields(TempStr, FieldList, False);
If (FieldList.Count > 0)
then SetBDEConfigParameter(FieldList[0], FieldList[1], ResultMsg);
until Done;
CloseFile(ParameterFile);
except
end;
FieldList.Free;
end; {UpdateBDEParameters}
end.
|
unit u_xpl_event;
{==============================================================================
UnitName = uxPLEvent
UnitDesc = xPL timer management object and function
UnitCopyright = GPL by Clinique / xPL Project
==============================================================================
0.90 : Initial version
0.91 : Modification to stick to timer.basic schema as described in xpl website
0.92 : Removed XMLCfg usage, use u_xml instead
0.93 : Still a lot of things to clean up this code...
}
{$mode objfpc}{$M+}{$H+}
interface
uses Controls, ExtCtrls, Classes, u_xpl_custom_message, FPTimer,
u_xPL_Address
, ComCtrls
, u_xpl_timer
, JvScheduledEvents
, u_xpl_actionlist
;
{ TxPLEventCollectionItem }
{ TxPLEvent }
(* TxPLEvent = class(TCollectionItem)
protected
fName : string;
fEventType : string;
fEnabled : boolean;
fNextExecution : TDateTime;
(* fActionList : TXMLActionsType;
fCfgEntry : TDOMElement;*)
public
constructor Create(aOwner: TCollection); override;
procedure InitComponent(const aMsg : TxPLMessage);
// constructor Create(const aCfgEntry : TDOMElement);
// constructor Create(const aName : string; const aEnabled : boolean; const aNext : TDateTime);
// function WriteToXML : boolean; virtual;
// procedure ReadFromXML; virtual; abstract;
function Edit : boolean; virtual; abstract;
procedure Check(bAndFire : boolean =true); virtual;
procedure Fire; virtual; abstract;
function Over : boolean;
function EnabledAsString : string;
published
property Name : string read fName write fName;
property Next : TDateTime read fNextExecution write fNextExecution;
property Enabled : boolean read fEnabled write fEnabled;
property TypeAsString : string read fEventType;
(* property ActionList : TXMLActionsType read fActionList;*)
end;
{ TxPLEventList }
TxPLEventList = class(TStringList)
private
aMessage : TxPLMessage;
fGrid : TListView;
fSysTimer : TfpTimer;
// fCfgEntry : TXMLLocalsType;
function GetEvent(Index : integer): TxPLEvent;
public
constructor Create(const aClient : TxPLListener; const aGrid : TListView);
destructor Destroy; override;
// procedure ReadFromXML(const aCfgfile : TXMLLocalsType);
procedure Check(Sender: TObject);
procedure ToGrid(const anItem : integer);
function Add(const S: string; const anEvent : TxPLEvent): Integer; overload;
procedure Edit(const S: string);
procedure Delete(aEvent : TxPLEvent); overload;
procedure Delete(Index: Integer); override;
// property CfgEntry : TXMLLocalsType read fCfgEntry;
property Events[Index : integer] : TxPLEvent read GetEvent;
end;
{ TxPLSingleEvent }
TxPLSingleEvent = class(TxPLEvent)
protected
fSingleEvent : boolean;
fDescription : widestring;
public
constructor Create(aOwner: TCollection); override;
procedure InitComponent(const aMsg : TxPLMessage);
// constructor Create(const aCfgEntry : TDOMElement);
constructor Create(const aName: string; const bEnabled : boolean; const dtNext : TDateTime);
// function WriteToXML : boolean; override;
// procedure ReadFromXML; override;
function Edit : boolean; override;
procedure Fire; override;
published
property IsSingleEvent : boolean read fSingleEvent;
property Description : widestring read fDescription write fDescription;
end;
TxPLEventRecurrenceType = ( er_Daily, er_Weekly, er_Monthly);
{ TxPLEventList }
{ TxPLRecurEvent }
TxPLRecurEvent = class(TxPLSingleEvent)
protected
fRecurrenceType : TxPLEventRecurrenceType;
fStartInDay : TTime;
fStopInDay : TTime;
fRandom : integer; // In seconds
fInterval : integer; // In seconds
fDayRecurrence : integer;
fWeekMap : string; // Something like : 111111
function GetRecurrence : string;
procedure SetRecurrence (const aRecurr: string);
public
// constructor Create(const aCfgEntry : TDOMElement); //(const aMsg : TxPLMessage);
constructor Create(aOwner: TCollection); override;
procedure InitComponent(const aMsg : TxPLMessage);
property RecurrenceAsString : string read Getrecurrence write SetRecurrence;
property StartInDay : TTime read fStartInDay write fStartInDay;
property StopInDay : TTime read fStopInDay write fStopInDay;
property DayRecurrence : integer read fDayRecurrence write fDayRecurrence;
property Random : integer read fRandom write fRandom;
property Interval : integer read fInterval write fInterval;
property RecurrenceType : TxPLEventRecurrenceType read fRecurrenceType write fRecurrenceType;
property WeekMap : string read fWeekMap write fWeekMap;
// function WriteToXML : boolean; override;
// procedure ReadFromXML; override;
function Edit : boolean; override;
procedure Check(bAndFire : boolean =true); override;
end; *)
implementation //========================================================================
uses SysUtils,
strUtils,
DateUtils
, LResources
, cRandom
;
{ TxPLEventCollectionItem }
(*procedure TxPLEventCollectionItem.ReadActions(Reader: Treader);
var s : string;
begin
Reader.ReadListBegin;
Reader.ReadComponent(fActions);
Reader.ReadListEnd;
end;
procedure TxPLEventCollectionItem.WriteActions(Writer: Twriter);
var i : integer;
begin
Writer.WriteListBegin;
Writer.WriteComponent(fActions);
Writer.WriteListEnd;
end;
procedure TxPLEventCollectionItem.DefineProperties(Filer: TFiler);
begin
inherited DefineProperties(Filer);
Filer.DefineProperty('Actions', @ReadActions, @WriteActions, True);
end;*)
{ TxPLEvent =============================================================================}
(*constructor TxPLEvent.Create(aOwner : TCollection);
begin
inherited;
end;
constructor TxPLEvent.Create(const aName: string; const aEnabled: boolean; const aNext: TDateTime);
begin
inherited Create(nil);
fName := aName;
fEnabled := aEnabled;
fNextExecution := aNext;
end;
constructor TxPLEvent.Create(const aCfgEntry: TDOMElement);
begin
Create('', true, now);
fCfgEntry := aCfgEntry;
fActionList := TXMLActionsType.Create(fCfgEntry,'action',K_XML_STR_Display_name);
end;
procedure TxPLEvent.Check(bAndFire: boolean);
begin
if not (Over and Enabled) then exit;
Enabled := false;
if bAndFire then Fire;
end;
function TxPLEvent.Over: boolean;
begin result := (next <= now()); end;
function TxPLEvent.EnabledAsString: string;
begin Result := Ifthen(Enabled,'Yes','No'); end;
function TxPLEventList.GetEvent(Index : integer): TxPLEvent;
begin result := TxPLEvent(Objects[Index]); end;
{ TxPLEventList ========================================================================}
constructor TxPLEventList.Create(const aClient : TxPLListener; const aGrid : TListView);
begin
inherited Create;
fSysTimer := TfpTimer.Create(nil);
fSysTimer.Interval := 1000;
fSysTimer.Enabled := False;
fSysTimer.OnTimer := @Check;
aMessage := TxPLMessage.Create;
aMessage.MessageType:= K_MSG_TYPE_CMND;
aMessage.Schema.RawxPL := K_SCHEMA_TIMER_BASIC;
aMessage.Target.IsGeneric:=true;
fGrid := aGrid;
end;
procedure TxPLEventList.ReadFromXML(const aCfgfile : TXMLLocalsType);
var i : integer;
anEvent : TxPLSingleEvent;
aRecur : TxPLRecurEvent;
begin
fCfgEntry := aCfgFile;
self.Clear;
for i:=0 to fCfgEntry.Count-1 do begin
anEvent := TxPLSingleEvent.Create(fCfgEntry[i]); //(aMessage);
anEvent.ReadFromXML; //(aCfgFile[i]);
if anEvent.IsSingleEvent then
if anEvent.Over then
anEvent.Destroy
else
Objects[Add(anEvent.Name)] := anEvent
else begin
anEvent.Destroy;
aRecur := TXPLRecurEvent.Create(fCfgEntry[i]); //(aMessage);
aRecur.ReadFromXML; //(aCfgfile[i]);
Objects[Add(aRecur.Name)] := aRecur;
end;
end;
fSysTimer.Enabled := (Count>0);
end;
procedure TxPLEventList.ToGrid(const anItem : integer);
var item : tListItem;
anEvent : TxPLEvent;
begin
if fGrid.items.Count<=anItem then begin
item := fGrid.Items.Add ;
item.SubItems.Add(''); // Name
item.SubItems.Add(''); // Type
item.SubItems.Add(''); // Next Runing time
end
else item := fGrid.Items[anItem];
anEvent := TxPLEvent(Objects[anItem]);
item.Caption := anEvent.Name;
item.SubItems[0] := anEvent.TypeAsString;
item.SubItems[1] := DateTimeToStr(anEvent.Next);
item.SubItems[2] := anEvent.EnabledAsString;
item.Data := anEvent;
end;
function TxPLEventList.Add(const S: string; const anEvent : TxPLEvent): Integer;
begin
if IndexOf(s)=-1 then begin
Result:=inherited Add(S);
Objects[Result] := anEvent;
end else Result := -1;
fSysTimer.Enabled := (Count>0);
end;
procedure TxPLEventList.Edit(const S: string);
var i: integer;
sEvent : TxPLEvent;
begin
i := IndexOf(s);
if i=-1 then exit;
sEvent := TxPLEvent(Objects[i]);
sEvent.Edit;
end;
procedure TxPLEventList.Delete(aEvent: TxPLEvent);
var itemnum : integer;
begin
itemnum := IndexOf(aEvent.name);
if itemnum=-1 then exit;
Delete(itemnum);
end;
procedure TxPLEventList.Delete(Index: Integer);
var node : TDomNode;
begin
node := Events[Index].fCfgEntry;
if node<>nil then Self.fCfgEntry.RootNode.DetachChild(node);
inherited Delete(Index);
fSysTimer.Enabled := (Count>0);
fGrid.Items[index].Delete ;
end;
procedure TxPLEventList.Check(Sender: TObject);
var i : integer;
aGenericEvent : TxPLEvent;
begin
i := Count-1;
repeat
aGenericEvent := Events[i];
aGenericEvent.Check;
if aGenericEvent.Over then Delete(i) else ToGrid(i);
dec(i);
until ((i<0) or (count=0));
end;
{ TxPLSingleEvent ========================================================================}
constructor TxPLSingleEvent.Create(const aName: string; const bEnabled : boolean; const dtNext : TDateTime);
begin
inherited Create(aName, bEnabled, dtNext);
fSingleEvent := True;
fEventType := 'Single';
fDescription := '';
end;
constructor TxPLSingleEvent.Create(const aCfgEntry: TDOMElement); //(const aMsg : TxPLMessage);
begin
Create('', true, now);
fCfgEntry := aCfgEntry;
fActionList := TXMLActionsType.Create(fCfgEntry,'action',K_XML_STR_Display_name);
end;
function TxPLSingleEvent.Edit: boolean;
var aForm : TfrmxPLSingleEvent;
begin
aForm := TfrmxPLSingleEvent.Create(self);
result := (aForm.ShowModal = mrOk);
if result then WriteToXML;
aForm.Destroy;
end;
procedure TxPLSingleEvent.Fire;
var i : integer;
aMessage : TxPLMessage;
begin
if ActionList.Count=0 then
xPLClient.SendMessage(K_MSG_TYPE_TRIG,'*',K_SCHEMA_TIMER_BASIC,['device','current'],[fName,'fired'])
else
for i := 0 to ActionList.Count-1 do begin
aMessage := TxPLMessage.Create;
aMessage.ReadFromXML(ActionList[i]);
xPLClient.Send(aMessage);
aMessage.Destroy;
end;
end;
(*function TxPLSingleEvent.WriteToXML : boolean;
begin
fCfgEntry.SetAttribute('name' , Name);
fCfgEntry.SetAttribute('next' , DateTimeToStr(Next));
fCfgEntry.SetAttribute('enabled' , EnabledAsString);
fCfgEntry.SetAttribute('issingle' , Ifthen(IsSingleEvent,'Yes','No'));
fCfgEntry.SetAttribute('description' , fDescription);
result := true;
end;
procedure TxPLSingleEvent.ReadFromXML;
begin
Name := fCfgEntry.GetAttribute('name');
Next := StrToDateTime(fCfgEntry.GetAttribute('next'));
Enabled := (fCfgEntry.GetAttribute('enabled')='Yes');
fSingleEvent := (fCfgEntry.GetAttribute('issingle')='Yes');
fDescription := fCfgEntry.GetAttribute('description');
Check(false); // This is done to recalc the event when loaded without firing it
end;*)
constructor TxPLRecurEvent.Create(const aCfgEntry : TDOMElement); //(const aMsg : TxPLMessage);
begin
inherited; // Create;
fRecurrenceType := er_Daily;
fStartInDay := now;
fStopInDay := IncMinute(fStartInDay,60);
fRandom := 0;
fInterval := 60;
fDayRecurrence := 1;
fSingleEvent:= false; // this is a recurrent event
fEventType := 'Recurrent';
fWeekMap := '1111111';
Next := 0;
fCfgEntry := aCfgEntry;
fActionList := TXMLActionsType.Create(fCfgEntry,'action',K_XML_STR_Display_name);
end;
function TxPLRecurEvent.Edit: boolean;
var aForm : TfrmxPLRecurEvent;
begin
aForm := TfrmxPLRecurEvent.Create(self);
result := (aForm.ShowModal = mrOk);
if result then begin
WriteToXML;
Next := 0; // FS#27 Reset next run time to force recompute
Check(false); // FS#29 False added to avoid launch of the event when creating it
end;
aForm.Destroy;
end;
procedure TxPLRecurEvent.Check(bAndFire : boolean =true);
function GetRandomDelta : integer;
begin
if RandomBoolean then result := -1 * RandomInt64(fRandom)
else result := 1 * RandomInt64(fRandom);
end;
var aTime : TDateTime;
dow, delta : integer;
begin
if (not Enabled) or (Next > Now) then exit;
case fRecurrenceType of
er_Daily : begin
aTime := fStartInDay; // Compute target event time
if aTime < Now then aTime := Now;
aTime := IncSecond(aTime,fInterval + GetRandomDelta);
if aTime > fStopInDay then begin // If the target is not in the window then report it on next
ReplaceDate(aTime,IncDay(aTime,fDayRecurrence)); // possible day
ReplaceTime(aTime,fStartInDay);
aTime := IncSecond(aTime,fInterval + GetRandomDelta); // Correction of bug FS#20
end;
end;
er_Weekly : begin
aTime := Now;
ReplaceTime(aTime,fStartInDay);
aTime := IncSecond(aTime,GetRandomDelta); // Enhancement FS#23
Delta := 0;
if aTime < Now then begin // if passed then shift it
repeat // seek next appliable day;
inc(delta);
Dow := DayOfTheWeek(IncDay(aTime,delta));
if Dow = 1 then delta := delta + (fDayRecurrence-1)*7;
until fWeekMap[Dow] = '1';
aTime := IncDay(aTime,delta);
end else begin
Dow := DayOfTheWeek(aTime);
if fWeekMap[Dow] ='0' then begin // if today is not appliable then shift it
repeat // seek next appliable day;
inc(delta);
Dow := DayOfTheWeek(IncDay(aTime,delta));
if Dow = 1 then delta := delta + (fDayRecurrence-1)*7;
until fWeekMap[Dow] = '1';
aTime := IncDay(aTime,delta);
end;
end;
end;
er_Monthly : begin
end;
end;
Next := aTime;
if bAndFire then Fire;
end;
function TxPLRecurEvent.GetRecurrence : string;
begin
case fRecurrenceType of
er_Daily : result := 'Daily';
er_Weekly : result := 'Weekly';
er_Monthly : result := 'Monthly';
end;
end;
procedure TxPLRecurEvent.SetRecurrence(const aRecurr: string);
begin
fRecurrenceType := er_Daily;
if aRecurr = 'Monthly' then fRecurrenceType := er_Monthly;
if aRecurr = 'Weekly' then fRecurrenceType := er_Weekly;
end;
(*function TxPLRecurEvent.WriteToXML : boolean;
begin
inherited; // WriteToXML; //(aCfgfile);
fCfgEntry.SetAttribute('recurrence' , RecurrenceAsString);
fCfgEntry.SetAttribute('startinday' , DateTimeToStr(fStartInDay));
fCfgEntry.SetAttribute('stopinday' , DateTimeToStr(fStopInDay));
fCfgEntry.SetAttribute('random' , IntToStr(fRandom));
fCfgEntry.SetAttribute('interval' , IntToStr(fInterval));
fCfgEntry.SetAttribute('dayrecurrence' , IntToStr(fDayRecurrence));
fCfgEntry.SetAttribute('weekmap' , fWeekMap);
Result := true;
end;
procedure TxPLRecurEvent.ReadFromXML;
begin
RecurrenceAsString := fCfgEntry.GetAttribute('recurrence');
fStartInDay := StrToDateTime(fCfgEntry.GetAttribute('startinday'));
fStopInDay := StrToDateTime(fCfgEntry.GetAttribute('stopinday'));
fRandom := StrToInt(fCfgEntry.GetAttribute('random'));
fInterval := StrToInt(fCfgEntry.GetAttribute('interval'));
fDayRecurrence := StrToInt(fCfgEntry.GetAttribute('dayrecurrence'));
fWeekMap := fCfgEntry.GetAttribute('weekmap');
fCfgEntry := fCfgEntry;
inherited;
end;*) *)
end.
|
{**
* @Author: Du xinming
* @Contact: QQ<36511179>; Email<lndxm1979@163.com>
* @Version: 0.0
* @Date: 2018.10
* @Brief:
*}
unit org.algorithms.queue;
interface
uses
WinApi.Windows,
org.algorithms;
type
TQueueType = (qtLinked, qtFixed, qtFlexible);
TLinkedItem<T> = class
private
FNext: TLinkedItem<T>;
FValue: T;
FValueNotify: TValueNotify<T>;
public
constructor Create;
destructor Destroy; override;
property Value: T read FValue write FValue;
{$IfDef TEST_ALGORITHMS}
property Next: TLinkedItem<T> read FNext;
{$Endif}
end;
TLinkedQueue<T> = class
private
FCS: TRtlCriticalSection;
FHead: TLinkedItem<T>;
FTail: TLinkedItem<T>;
FCount: Integer;
FValueNotify: TValueNotify<T>;
public
constructor Create;
destructor Destroy; override;
function Dequeue: TLinkedItem<T>;
function Empty: Boolean;
procedure Enqueue(AItem: TLinkedItem<T>; FromHead: Boolean = False);
procedure Clear;
property Count: Integer read FCount;
property OnValueNotify: TValueNotify<T> read FValueNotify write FValueNotify;
{$IfDef TEST_ALGORITHMS}
property Head: TLinkedItem<T> read FHead;
{$Endif}
end;
TFixedQueue<T> = class
public type
TArryOfT = array of T;
private
FCS: TRtlCriticalSection;
FCapacity: Integer;
FCount: Integer;
FItemArray: TArryOfT;
FPushIndex: Integer;
FPopIndex: Integer;
FItemNotify: TValueNotify<T>;
function GetCount: Integer;
public
constructor Create(Capacity: Integer);
destructor Destroy; override;
procedure Clear;
procedure Lock;
procedure Unlock;
function Dequeue: T;
function DequeueEx: T;
procedure Enqueue(Item: T); virtual;
procedure EnqueueEx(Item: T); virtual;
function Empty: Boolean;
function GetValue(Index: Integer): T;
property Count: Integer read GetCount;
property Capacity: Integer read FCapacity;
property OnItemNotify: TValueNotify<T> read FItemNotify write FItemNotify;
{$IfDef TEST_ALGORITHMS}
property PopIndex: Integer read FPopIndex;
property PushIndex: Integer read FPushIndex;
property ItemArray: TArryOfT read FItemArray;
{$Endif}
end;
TFlexibleQueue<T> = class(TFixedQueue<T>)
public
procedure Enqueue(Item: T); override;
procedure EnqueueEx(Item: T); override;
end;
const
QUEUE_TYPE_DESC: array [TQueueType] of string = (
'链式',
'定长',
'变长'
);
implementation
{ TLinkedItem<T> }
constructor TLinkedItem<T>.Create;
begin
end;
destructor TLinkedItem<T>.Destroy;
begin
if Assigned(FValueNotify) then
FValueNotify(FValue, atDelete);
inherited;
end;
{ TLinkedQueue<T> }
procedure TLinkedQueue<T>.Clear;
var
AItem: TLinkedItem<T>;
begin
while FCount > 0 do begin
AItem := Dequeue();
AItem.Free();
end;
FHead := nil;
FTail := nil;
end;
constructor TLinkedQueue<T>.Create;
begin
InitializeCriticalSection(FCS);
FHead := nil;
FTail := nil;
end;
function TLinkedQueue<T>.Dequeue: TLinkedItem<T>;
begin
EnterCriticalSection(FCS);
try
if FCount = 0 then
Result := nil
else begin
Result := FHead;
FHead := FHead.FNext;
Result.FNext := nil;
if FHead = nil then
FTail := nil;
Dec(FCount);
end;
finally
LeaveCriticalSection(FCS);
end;
end;
destructor TLinkedQueue<T>.Destroy;
begin
Clear();
DeleteCriticalSection(FCS);
inherited;
end;
function TLinkedQueue<T>.Empty: Boolean;
begin
Result := FCount = 0;
end;
procedure TLinkedQueue<T>.Enqueue(AItem: TLinkedItem<T>; FromHead: Boolean);
begin
AItem.FValueNotify := FValueNotify;
EnterCriticalSection(FCS);
try
if FCount = 0 then begin
FHead := AItem;
FTail := AItem;
end else begin
if not FromHead then begin
FTail.FNext := AItem;
FTail := AItem;
end else begin
AItem.FNext := FHead;
FHead := AItem;
end;
end;
Inc(FCount);
finally
LeaveCriticalSection(FCS);
end;
end;
{ TFixedQueue<T> }
procedure TFixedQueue<T>.Clear;
var
Item: T;
begin
while FCount > 0 do begin
Item := Dequeue();
if Assigned(FItemNotify) then
FItemNotify(Item, atDelete);
end;
end;
constructor TFixedQueue<T>.Create(Capacity: Integer);
begin
InitializeCriticalSection(FCS);
FCapacity := Capacity;
SetLength(FItemArray, FCapacity);
FCount := 0;
FPushIndex := 0;
FPopIndex := 0;
end;
function TFixedQueue<T>.Dequeue: T;
begin
Result := Default(T);
EnterCriticalSection(FCS);
try
if FCount > 0 then begin
Result := FItemArray[FPopIndex];
Inc(FPopIndex);
if FPopIndex = FCapacity then
FPopIndex := 0;
Dec(FCount);
end;
finally
LeaveCriticalSection(FCS);
end;
end;
function TFixedQueue<T>.DequeueEx: T;
begin
Result := Default(T);
if FCount > 0 then begin
Result := FItemArray[FPopIndex];
Inc(FPopIndex);
if FPopIndex = FCapacity then
FPopIndex := 0;
Dec(FCount);
end;
end;
destructor TFixedQueue<T>.Destroy;
begin
Clear();
DeleteCriticalSection(FCS);
inherited;
end;
function TFixedQueue<T>.Empty: Boolean;
begin
Result := FCount = 0;
end;
procedure TFixedQueue<T>.Enqueue(Item: T);
begin
EnterCriticalSection(FCS);
try
FItemArray[FPushIndex] := Item;
Inc(FCount);
Inc(FPushIndex);
// 添加后未达当前容量
if FCount < FCapacity then begin
if FPushIndex = FCapacity then
FPushIndex := 0;
end
// 添加前容量未满，添加后容量满。下次添加时将覆盖最先入队的元素
else if FCount = FCapacity then begin
FPushIndex := FPopIndex;
end
// 添加前容量已满。更新PopIndex和PushIndex
else begin
FCount := FCapacity;
if FPushIndex = FCapacity then
FPushIndex := 0;
FPopIndex := FPushIndex;
end;
finally
LeaveCriticalSection(FCS);
end;
end;
procedure TFixedQueue<T>.EnqueueEx(Item: T);
begin
FItemArray[FPushIndex] := Item;
Inc(FCount);
Inc(FPushIndex);
// 添加后未达当前容量
if FCount < FCapacity then begin
if FPushIndex = FCapacity then
FPushIndex := 0;
end
// 添加前容量未满，添加后容量满。下次添加时将覆盖最先入队的元素
else if FCount = FCapacity then begin
FPushIndex := FPopIndex;
end
// 添加前容量已满。更新PopIndex和PushIndex
else begin
FCount := FCapacity;
if FPushIndex = FCapacity then
FPushIndex := 0;
FPopIndex := FPushIndex;
end;
end;
function TFixedQueue<T>.GetCount: Integer;
begin
EnterCriticalSection(FCS);
try
Result := FCount;
finally
LeaveCriticalSection(FCS);
end;
end;
function TFixedQueue<T>.GetValue(Index: Integer): T;
var
I: Integer;
begin
Result := Default(T);
EnterCriticalSection(FCS);
try
if (Index >= 0) and (Index < FCount) then begin
I := FPopIndex + Index;
if I < FCapacity then
Result := FItemArray[I]
else
Result := FItemArray[I - FCapacity];
end;
finally
LeaveCriticalSection(FCS);
end;
end;
procedure TFixedQueue<T>.Lock;
begin
EnterCriticalSection(FCS);
end;
procedure TFixedQueue<T>.Unlock;
begin
LeaveCriticalSection(FCS);
end;
{ TFlexibleQueue<T> }
procedure TFlexibleQueue<T>.Enqueue(Item: T);
var
PrevCapacity: Integer;
begin
EnterCriticalSection(FCS);
try
FItemArray[FPushIndex] := Item;
Inc(FCount);
Inc(FPushIndex);
if FCount < FCapacity then begin
if FPushIndex = FCapacity then
FPushIndex := 0;
end
// 添加前容量未满，添加后容量满。需扩容
else if FCount = FCapacity then begin
PrevCapacity := FCapacity;
FCapacity := FCapacity * 2;
SetLength(FItemArray, FCapacity);
if FPushIndex < PrevCapacity then begin
Move(FItemArray[FPopIndex], FItemArray[FPopIndex + PrevCapacity], (PrevCapacity - FPopIndex) * SizeOf(T));
FPopIndex := FPopIndex + PrevCapacity;
end;
end;
finally
LeaveCriticalSection(FCS);
end;
end;
procedure TFlexibleQueue<T>.EnqueueEx(Item: T);
var
PrevCapacity: Integer;
begin
FItemArray[FPushIndex] := Item;
Inc(FCount);
Inc(FPushIndex);
if FCount < FCapacity then begin
if FPushIndex = FCapacity then
FPushIndex := 0;
end
// 添加前容量未满，添加后容量满。需扩容
else if FCount = FCapacity then begin
PrevCapacity := FCapacity;
FCapacity := FCapacity * 2;
SetLength(FItemArray, FCapacity);
if FPushIndex < PrevCapacity then begin
Move(FItemArray[FPopIndex], FItemArray[FPopIndex + PrevCapacity], (PrevCapacity - FPopIndex) * SizeOf(T));
FPopIndex := FPopIndex + PrevCapacity;
end;
end;
end;
end.
|
//
// Copyright (c) 2009-2010 Mikko Mononen memon@inside.org
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
// 3. This notice may not be removed or altered from any source distribution.
//
{$POINTERMATH ON}
unit RN_Sample;
interface
uses Math, SysUtils,
RN_DetourCrowd, RN_DetourNavMesh, RN_DetourNavMeshQuery, RN_Helper, RN_Recast, RN_InputGeom, RN_SampleInterfaces;
/// Tool types.
type
TSampleToolType =
(
TOOL_NONE,
TOOL_TILE_EDIT,
TOOL_TILE_HIGHLIGHT,
TOOL_TEMP_OBSTACLE,
TOOL_NAVMESH_TESTER,
TOOL_NAVMESH_PRUNE,
TOOL_OFFMESH_CONNECTION,
TOOL_CONVEX_VOLUME,
TOOL_CROWD,
MAX_TOOLS
);
/// These are just sample areas to use consistent values across the samples.
/// The use should specify these base on his needs.
TSamplePolyAreas =
(
SAMPLE_POLYAREA_GROUND,
SAMPLE_POLYAREA_WATER,
SAMPLE_POLYAREA_ROAD,
SAMPLE_POLYAREA_DOOR,
SAMPLE_POLYAREA_GRASS,
SAMPLE_POLYAREA_JUMP
);
const
SAMPLE_POLYFLAGS_WALK = $01; // Ability to walk (ground, grass, road)
SAMPLE_POLYFLAGS_SWIM = $02; // Ability to swim (water).
SAMPLE_POLYFLAGS_DOOR = $04; // Ability to move through doors.
SAMPLE_POLYFLAGS_JUMP = $08; // Ability to jump.
SAMPLE_POLYFLAGS_DISABLED = $10; // Disabled polygon
SAMPLE_POLYFLAGS_ALL = $ffff; // All abilities.
type
TSamplePartitionType =
(
SAMPLE_PARTITION_WATERSHED,
SAMPLE_PARTITION_MONOTONE,
SAMPLE_PARTITION_LAYERS
);
TSample = class;
TSampleTool = class // Delphi: Could be a record, but they are not allowed to have abstract methods
&type: TSampleToolType;
procedure init(sample: TSample); virtual; abstract;
procedure reset(); virtual; abstract;
procedure handleMenu(Sender: TObject); virtual; abstract;
procedure handleClick(s,p: PSingle; shift: Boolean); virtual; abstract;
procedure handleRender(); virtual; abstract;
procedure handleRenderOverlay(proj, model: PDouble; view: PInteger); virtual; abstract;
procedure handleToggle(); virtual; abstract;
procedure handleStep(); virtual; abstract;
procedure handleUpdate(dt: Single); virtual; abstract;
end;
TSampleToolState = class // Delphi: Could be a record, but they are not allowed to have abstract methods
procedure init(sample: TSample); virtual; abstract;
procedure reset; virtual; abstract;
procedure handleRender; virtual; abstract;
procedure handleRenderOverlay(proj, model: PDouble; view: PInteger); virtual; abstract;
procedure handleUpdate(dt: Single); virtual; abstract;
end;
TSample = class
protected
m_geom: TInputGeom;
m_navMesh: TdtNavMesh;
m_navQuery: TdtNavMeshQuery;
m_crowd: TdtCrowd;
m_navMeshDrawFlags: Byte;
m_tool: TSampleTool;
m_toolStates: array [TSampleToolType] of TSampleToolState;
m_ctx: TBuildContext;
public
// Delphi. Making it public does no harm, but makes GUI easier to rig
m_cellSize: Single;
m_cellHeight: Single;
m_agentHeight: Single;
m_agentRadius: Single;
m_agentMaxClimb: Single;
m_agentMaxSlope: Single;
m_regionMinSize: Single;
m_regionMergeSize: Single;
m_edgeMaxLen: Single;
m_edgeMaxError: Single;
m_vertsPerPoly: Single;
m_detailSampleDist: Single;
m_detailSampleMaxError: Single;
m_partitionType: TSamplePartitionType; // Delphi. Use specific type instead of Int
constructor Create;
destructor Destroy; override;
property setContext: TBuildContext write m_ctx;
procedure setTool(tool: TSampleTool);
function getToolState(&type: TSampleToolType): TSampleToolState; { return m_toolStates[type]; }
procedure setToolState(&type: TSampleToolType; s: TSampleToolState); { m_toolStates[type] = s; }
procedure handleSettings(); virtual;
procedure handleTools(Sender: TObject); virtual;
procedure handleDebugMode(); virtual;
procedure handleClick(const s, p: PSingle; shift: Boolean); virtual;
procedure handleMenu(Sender: TObject); virtual;
procedure handleToggle(); virtual;
procedure handleStep(); virtual;
procedure handleRender(); virtual;
procedure handleRenderOverlay(proj, model: PDouble; view: PInteger); virtual;
procedure handleMeshChanged(geom: TInputGeom); virtual;
function handleBuild(): Boolean; virtual;
procedure handleUpdate(const dt: Single); virtual;
property getInputGeom: TInputGeom read m_geom;
property getNavMesh: TdtNavMesh read m_navMesh;
property getNavMeshQuery: TdtNavMeshQuery read m_navQuery;
property getCrowd: TdtCrowd read m_crowd;
property getAgentRadius: Single read m_agentRadius;
property getAgentHeight: Single read m_agentHeight;
property getAgentClimb: Single read m_agentMaxClimb;
function getBoundsMin: PSingle;
function getBoundsMax: PSingle;
property getNavMeshDrawFlags: Byte read m_navMeshDrawFlags write m_navMeshDrawFlags;
procedure updateToolStates(const dt: Single);
procedure initToolStates(sample: TSample);
procedure resetToolStates();
procedure renderToolStates();
procedure renderOverlayToolStates(proj, model: PDouble; view: PInteger);
procedure resetCommonSettings();
procedure handleCommonSettings();
end;
implementation
uses RN_DebugDraw, RN_DetourDebugDraw, RN_RecastDebugDraw;
constructor TSample.Create;
begin
inherited;
m_navMeshDrawFlags := DU_DRAWNAVMESH_OFFMESHCONS or DU_DRAWNAVMESH_CLOSEDLIST;
resetCommonSettings();
m_navQuery := dtAllocNavMeshQuery();
m_crowd := dtAllocCrowd;
end;
destructor TSample.Destroy;
begin
dtFreeNavMeshQuery(m_navQuery);
FreeAndNil(m_navMesh);
dtFreeCrowd(m_crowd);
FreeAndNil(m_tool);
inherited;
end;
procedure TSample.setTool(tool: TSampleTool);
begin
FreeAndNil(m_tool);
m_tool := tool;
if (tool <> nil) then
m_tool.init(Self);
end;
function TSample.getToolState(&type: TSampleToolType): TSampleToolState;
begin
Result := m_toolStates[&type];
end;
procedure TSample.setToolState(&type: TSampleToolType; s: TSampleToolState);
begin
m_toolStates[&type] := s;
end;
procedure TSample.handleSettings();
begin
end;
procedure TSample.handleTools(Sender: TObject);
begin
end;
procedure TSample.handleDebugMode();
begin
end;
procedure TSample.handleRender();
var dd: TDebugDrawGL; bmin,bmax: PSingle;
begin
if (m_geom = nil) then
Exit;
dd := TDebugDrawGL.Create;
// Draw mesh
duDebugDrawTriMesh(dd, m_geom.getMesh.getVerts, m_geom.getMesh.getVertCount,
m_geom.getMesh.getTris, m_geom.getMesh.getNormals, m_geom.getMesh.getTriCount, nil, 1.0);
// Draw bounds
bmin := m_geom.getMeshBoundsMin();
bmax := m_geom.getMeshBoundsMax();
duDebugDrawBoxWire(dd, bmin[0],bmin[1],bmin[2], bmax[0],bmax[1],bmax[2], duRGBA(255,255,255,128), 1.0);
dd.Free;
end;
procedure TSample.handleRenderOverlay(proj, model: PDouble; view: PInteger);
begin
end;
procedure TSample.handleMenu(Sender: TObject);
begin
if m_tool <> nil then
m_tool.handleMenu(Sender);
end;
procedure TSample.handleMeshChanged(geom: TInputGeom);
begin
m_geom := geom;
end;
function TSample.getBoundsMin(): PSingle;
begin
if (m_geom = nil) then Exit(nil);
Result := m_geom.getMeshBoundsMin;
end;
function TSample.getBoundsMax(): PSingle;
begin
if (m_geom = nil) then Exit(nil);
Result := m_geom.getMeshBoundsMax;
end;
procedure TSample.resetCommonSettings();
begin
m_cellSize := 0.3;
m_cellHeight := 0.2;
m_agentHeight := 2.0;
m_agentRadius := 0.6;
m_agentMaxClimb := 0.9;
m_agentMaxSlope := 45.0;
m_regionMinSize := 8;
m_regionMergeSize := 20;
m_edgeMaxLen := 12.0;
m_edgeMaxError := 1.3;
m_vertsPerPoly := 6.0;
m_detailSampleDist := 6.0;
m_detailSampleMaxError := 1.0;
m_partitionType := SAMPLE_PARTITION_WATERSHED;
end;
procedure TSample.handleCommonSettings();
begin
// Delphi. Refactored into DFM
end;
procedure TSample.handleClick(const s, p: PSingle; shift: Boolean);
begin
if (m_tool <> nil) then
m_tool.handleClick(s, p, shift);
end;
procedure TSample.handleToggle();
begin
if (m_tool <> nil) then
m_tool.handleToggle();
end;
procedure TSample.handleStep();
begin
if (m_tool <> nil) then
m_tool.handleStep();
end;
function TSample.handleBuild(): Boolean;
begin
Result := True;
end;
procedure TSample.handleUpdate(const dt: Single);
begin
if (m_tool <> nil) then
m_tool.handleUpdate(dt);
updateToolStates(dt);
end;
procedure TSample.updateToolStates(const dt: Single);
var i: TSampleToolType;
begin
for i := Low(TSampleToolType) to High(TSampleToolType) do
begin
if (m_toolStates[i] <> nil) then
m_toolStates[i].handleUpdate(dt);
end;
end;
procedure TSample.initToolStates(sample: TSample);
var i: TSampleToolType;
begin
for i := Low(TSampleToolType) to High(TSampleToolType) do
begin
if (m_toolStates[i] <> nil) then
m_toolStates[i].init(sample);
end;
end;
procedure TSample.resetToolStates();
var i: TSampleToolType;
begin
for i := Low(TSampleToolType) to High(TSampleToolType) do
begin
if (m_toolStates[i] <> nil) then
m_toolStates[i].reset();
end;
end;
procedure TSample.renderToolStates();
var i: TSampleToolType;
begin
for i := Low(TSampleToolType) to High(TSampleToolType) do
begin
if (m_toolStates[i] <> nil) then
m_toolStates[i].handleRender();
end;
end;
procedure TSample.renderOverlayToolStates(proj, model: PDouble; view: PInteger);
var i: TSampleToolType;
begin
for i := Low(TSampleToolType) to High(TSampleToolType) do
begin
if (m_toolStates[i] <> nil) then
m_toolStates[i].handleRenderOverlay(proj, model, view);
end;
end;
end.
|
{*******************************************************}
{ }
{ CodeGear Delphi Runtime Library }
{ }
{ Copyright(c) 1995-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit System.Generics.Defaults;
{$R-,T-,X+,H+,B-}
(*$HPPEMIT '#pragma option -w-8022'*)
interface
uses System.SysUtils, System.TypInfo;
type
IComparer<T> = interface
function Compare(const Left, Right: T): Integer;
end;
IEqualityComparer<T> = interface
function Equals(const Left, Right: T): Boolean;
function GetHashCode(const Value: T): Integer;
end;
TComparison<T> = reference to function(const Left, Right: T): Integer;
// Abstract base class for IComparer<T> implementations, and a provider
// of default IComparer<T> implementations.
TComparer<T> = class(TInterfacedObject, IComparer<T>)
public
class function Default: IComparer<T>;
class function Construct(const Comparison: TComparison<T>): IComparer<T>;
function Compare(const Left, Right: T): Integer; virtual; abstract;
end;
TEqualityComparison<T> = reference to function(const Left, Right: T): Boolean;
THasher<T> = reference to function(const Value: T): Integer;
// Abstract base class for IEqualityComparer<T> implementations, and a provider
// of default IEqualityComparer<T> implementations.
TEqualityComparer<T> = class(TInterfacedObject, IEqualityComparer<T>)
public
class function Default: IEqualityComparer<T>; static;
class function Construct(const EqualityComparison: TEqualityComparison<T>;
const Hasher: THasher<T>): IEqualityComparer<T>;
function Equals(const Left, Right: T): Boolean;
reintroduce; overload; virtual; abstract;
function GetHashCode(const Value: T): Integer;
reintroduce; overload; virtual; abstract;
end;
// A non-reference-counted IInterface implementation.
TSingletonImplementation = class(TObject, IInterface)
protected
function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
function _AddRef: Integer; stdcall;
function _Release: Integer; stdcall;
end;
TDelegatedEqualityComparer<T> = class(TEqualityComparer<T>)
private
FEquals: TEqualityComparison<T>;
FGetHashCode: THasher<T>;
public
constructor Create(const AEquals: TEqualityComparison<T>;
const AGetHashCode: THasher<T>);
function Equals(const Left, Right: T): Boolean; overload; override;
function GetHashCode(const Value: T): Integer; overload; override;
end;
TDelegatedComparer<T> = class(TComparer<T>)
private
FCompare: TComparison<T>;
public
constructor Create(const ACompare: TComparison<T>);
function Compare(const Left, Right: T): Integer; override;
end;
TCustomComparer<T> = class(TSingletonImplementation, IComparer<T>, IEqualityComparer<T>)
protected
function Compare(const Left, Right: T): Integer; virtual; abstract;
function Equals(const Left, Right: T): Boolean;
reintroduce; overload; virtual; abstract;
function GetHashCode(const Value: T): Integer;
reintroduce; overload; virtual; abstract;
end;
TStringComparer = class(TCustomComparer<string>)
private
class var
FOrdinal: TCustomComparer<string>;
public
class destructor Destroy;
class function Ordinal: TStringComparer;
end;
TIStringComparer = class(TCustomComparer<string>)
private
class var
FOrdinal: TCustomComparer<string>;
public
class destructor Destroy;
class function Ordinal: TStringComparer;
end;
TOrdinalIStringComparer = class(TStringComparer)
public
function Compare(const Left, Right: string): Integer; override;
function Equals(const Left, Right: string): Boolean;
reintroduce; overload; override;
function GetHashCode(const Value: string): Integer;
reintroduce; overload; override;
end;
function BobJenkinsHash(const Data; Len, InitData: Integer): Integer; deprecated 'Use System.Hash.THashBobJenkins.GetHashValue';
function BinaryCompare(const Left, Right: Pointer; Size: Integer): Integer;
// Must be in interface section to be used by generic method. For internal use only.
type
TDefaultGenericInterface = (giComparer, giEqualityComparer);
function _LookupVtableInfo(intf: TDefaultGenericInterface; info: PTypeInfo; size: Integer): Pointer;
implementation
uses
System.Hash,
System.Math, System.Generics.Collections, System.Variants;
type
PSimpleInstance = ^TSimpleInstance;
TSimpleInstance = record
Vtable: Pointer;
Info: PTypeInfo;
RefCount: Integer;
Size: Integer;
end;
TInfoFlags = set of (ifVariableSize, ifSelector);
PVtableInfo = ^TVtableInfo;
TVtableInfo = record
Flags: TInfoFlags;
Data: Pointer;
end;
TTypeInfoSelector = function(info: PTypeInfo; size: Integer): Pointer;
TThreeByteData = array [0..2] of Byte;
function MakeInstance(vtable: Pointer; info: PTypeInfo; sizeField: Integer): Pointer;
var
inst: PSimpleInstance;
begin
GetMem(inst, SizeOf(inst^));
inst^.Vtable := vtable;
inst^.RefCount := 0;
inst^.Size := sizeField;
inst^.Info := info;
Result := inst;
end;
function NopAddref(inst: Pointer): Integer; stdcall;
begin
Result := -1;
end;
function NopRelease(inst: Pointer): Integer; stdcall;
begin
Result := -1;
end;
function NopQueryInterface(inst: Pointer; const IID: TGUID; out Obj): HResult; stdcall;
begin
Result := E_NOINTERFACE;
end;
function MemAddref(inst: PSimpleInstance): Integer; stdcall;
begin
Result := AtomicIncrement(inst^.RefCount);
end;
function MemRelease(inst: PSimpleInstance): Integer; stdcall;
begin
Result := AtomicDecrement(inst^.RefCount);
if Result = 0 then
FreeMem(inst);
end;
// I/U 1-4
function Compare_I1(Inst: Pointer; const Left, Right: Shortint): Integer;
begin
{ Use subtraction }
Result := Left - Right;
end;
function Equals_I1(Inst: Pointer; const Left, Right: Shortint): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_I1(Inst: Pointer; const Value: Shortint): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Value), 0);
end;
function Compare_I2(Inst: Pointer; const Left, Right: Smallint): Integer;
begin
{ Use subtraction }
Result := Left - Right;
end;
function Equals_I2(Inst: Pointer; const Left, Right: Smallint): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_I2(Inst: Pointer; const Value: Smallint): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Value), 0);
end;
function Compare_I4(Inst: Pointer; const Left, Right: Integer): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_I4(Inst: Pointer; const Left, Right: Integer): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_I4(Inst: Pointer; const Value: Integer): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Value), 0);
end;
{$IFDEF EABI_RECORD_ARRAY_BYREF}
// I/U 1-4
function Equals_Ref_I1(Inst: Pointer; const [Ref] Left, Right: Shortint): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_Ref_I1(Inst: Pointer; const [Ref] Value: Shortint): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Shortint), 0);
end;
function Equals_Ref_I2(Inst: Pointer; const [Ref] Left, Right: Smallint): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_Ref_I2(Inst: Pointer; const [Ref] Value: Smallint): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Smallint), 0);
end;
function Equals_Ref_I4(Inst: Pointer; const [Ref] Left, Right: Integer): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_Ref_I4(Inst: Pointer; const [Ref] Value: Integer): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Integer), 0);
end;
{$ENDIF EABI_RECORD_ARRAY_BYREF}
function Compare_U1(Inst: Pointer; const Left, Right: Byte): Integer;
begin
{ Use subtraction }
Result := Integer(Left) - Integer(Right);
end;
function Compare_U2(Inst: Pointer; const Left, Right: Word): Integer;
begin
{ Use subtraction }
Result := Integer(Left) - Integer(Right);
end;
function Compare_U4(Inst: Pointer; const Left, Right: Cardinal): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
{$IFDEF EABI_RECORD_ARRAY_BYREF}
function Compare_Ref_U1(Inst: Pointer; const [Ref] Left, Right: Byte): Integer;
begin
{ Use subtraction }
Result := Integer(Left) - Integer(Right);
end;
function Compare_Ref_U2(Inst: Pointer; const [Ref] Left, Right: Word): Integer;
begin
{ Use subtraction }
Result := Integer(Left) - Integer(Right);
end;
function Compare_Ref_U4(Inst: Pointer; const [Ref] Left, Right: Cardinal): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
{$ENDIF EABI_RECORD_ARRAY_BYREF}
const
Comparer_Vtable_I1: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_I1
);
Comparer_Vtable_U1: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_U1
);
Comparer_Vtable_I2: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_I2
);
Comparer_Vtable_U2: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_U2
);
Comparer_Vtable_I4: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_I4
);
Comparer_Vtable_U4: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_U4
);
Comparer_Instance_I1: Pointer = @Comparer_Vtable_I1;
Comparer_Instance_U1: Pointer = @Comparer_Vtable_U1;
Comparer_Instance_I2: Pointer = @Comparer_Vtable_I2;
Comparer_Instance_U2: Pointer = @Comparer_Vtable_U2;
Comparer_Instance_I4: Pointer = @Comparer_Vtable_I4;
Comparer_Instance_U4: Pointer = @Comparer_Vtable_U4;
{$IFDEF EABI_RECORD_ARRAY_BYREF}
Comparer_Vtable_Ref_U1: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Ref_U1
);
Comparer_Vtable_Ref_U2: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Ref_U2
);
Comparer_Vtable_Ref_U4: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Ref_U4
);
Comparer_Instance_Ref_U1: Pointer = @Comparer_Vtable_Ref_U1;
Comparer_Instance_Ref_U2: Pointer = @Comparer_Vtable_Ref_U2;
Comparer_Instance_Ref_U4: Pointer = @Comparer_Vtable_Ref_U4;
{$ENDIF}
EqualityComparer_Vtable_I1: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_I1,
@GetHashCode_I1
);
EqualityComparer_Vtable_I2: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_I2,
@GetHashCode_I2
);
EqualityComparer_Vtable_I4: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_I4,
@GetHashCode_I4
);
EqualityComparer_Instance_I1: Pointer = @EqualityComparer_VTable_I1;
EqualityComparer_Instance_I2: Pointer = @EqualityComparer_VTable_I2;
EqualityComparer_Instance_I4: Pointer = @EqualityComparer_VTable_I4;
{$IFDEF EABI_RECORD_ARRAY_BYREF}
EqualityComparer_Vtable_Ref_I1: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Ref_I1,
@GetHashCode_Ref_I1
);
EqualityComparer_Vtable_Ref_I2: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Ref_I2,
@GetHashCode_Ref_I2
);
EqualityComparer_Vtable_Ref_I4: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Ref_I4,
@GetHashCode_Ref_I4
);
EqualityComparer_Instance_Ref_I1: Pointer = @EqualityComparer_VTable_Ref_I1;
EqualityComparer_Instance_Ref_I2: Pointer = @EqualityComparer_VTable_Ref_I2;
EqualityComparer_Instance_Ref_I4: Pointer = @EqualityComparer_VTable_Ref_I4;
{$ENDIF EABI_RECORD_ARRAY_BYREF}
function Comparer_Selector_Integer(info: PTypeInfo; size: Integer): Pointer;
begin
case GetTypeData(info)^.OrdType of
otSByte: Result := @Comparer_Instance_I1;
otUByte: Result := @Comparer_Instance_U1;
otSWord: Result := @Comparer_Instance_I2;
otUWord: Result := @Comparer_Instance_U2;
otSLong: Result := @Comparer_Instance_I4;
otULong: Result := @Comparer_Instance_U4;
else
System.Error(reRangeError);
Exit(nil);
end;
end;
function EqualityComparer_Selector_Integer(info: PTypeInfo; size: Integer): Pointer;
begin
case GetTypeData(info)^.OrdType of
otSByte, otUByte: Result := @EqualityComparer_Instance_I1;
otSWord, otUWord: Result := @EqualityComparer_Instance_I2;
otSLong, otULong: Result := @EqualityComparer_Instance_I4;
else
System.Error(reRangeError);
Exit(nil);
end;
end;
// I8 & U8
function Equals_I8(Inst: Pointer; const Left, Right: Int64): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_I8(Inst: Pointer; const Value: Int64): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Value), 0);
end;
function Compare_I8(Inst: Pointer; const Left, Right: Int64): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Compare_U8(Inst: Pointer; const Left, Right: UInt64): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
{$IF Defined(CPUX64) and defined(MSWINDOWS)}
function Equals_Ref_I8(Inst: Pointer; const Left, Right: PInt64): Boolean;
begin
Result := Left^ = Right^;
end;
function Compare_Ref_U8_Swap(Inst: Pointer; const Left, Right: PUInt64): Integer;
asm
.NOFRAME
//Self: RCX Left: RDX, Right: R8
mov RAX, [RDX] // Left
mov RCX, [R8] // Right
bswap RAX
bswap RCX
sub RAX,RCX
setz CL
sbb EAX, EAX
sbb EAX, -1
shr EAX, CL
end;
function GetHashCode_Ref_I8(Inst: Pointer; const Value: PInt64): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value^, SizeOf(Value^), 0);
end;
{$ENDIF}
const
Comparer_Vtable_I8: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_I8
);
Comparer_Instance_I8: Pointer = @Comparer_Vtable_I8;
Comparer_Vtable_U8: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_U8
);
Comparer_Instance_U8: Pointer = @Comparer_Vtable_U8;
{$IF defined(CPUX64) and defined(MSWINDOWS)}
Comparer_Vtable_Ref_U8_Swap: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Ref_U8_Swap
);
Comparer_Instance_Ref_U8_Swap: Pointer = @Comparer_Vtable_Ref_U8_Swap;
EqualityComparer_Vtable_Ref_I8: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Ref_I8,
@GetHashCode_Ref_I8
);
EqualityComparer_Instance_Ref_I8: Pointer = @EqualityComparer_Vtable_Ref_I8;
{$ENDIF}
EqualityComparer_Vtable_I8: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_I8,
@GetHashCode_I8
);
EqualityComparer_Instance_I8: Pointer = @EqualityComparer_Vtable_I8;
function Comparer_Selector_Int64(info: PTypeInfo; size: Integer): Pointer;
begin
if GetTypeData(info)^.MaxInt64Value > GetTypeData(info)^.MinInt64Value then
Result := @Comparer_Instance_I8
else
Result := @Comparer_Instance_U8;
end;
// Float
function Compare_R4(Inst: Pointer; const Left, Right: Single): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_R4(Inst: Pointer; const Left, Right: Single): Boolean;
begin
Result := Left = Right;
end;
const
{$IF (SizeOf(Extended) > 10) and (Defined(CPUX86) or Defined(CPUX64))}
// Intel FPU case. GetHashValue needs actual Extended value bytes.
BYTESIZEOFEXTENDED = 10;
{$ELSE}
BYTESIZEOFEXTENDED = SizeOf(Extended);
{$ENDIF}
function GetHashCode_R4(Inst: Pointer; const Value: Single): Integer;
var
m: Extended;
e: Integer;
begin
// Denormalized floats and positive/negative 0.0 complicate things.
Frexp(Value, m, e);
if m = 0 then
m := Abs(m);
Result := THashBobJenkins.GetHashValue(m, BYTESIZEOFEXTENDED, 0);
Result := THashBobJenkins.GetHashValue(e, SizeOf(e), Result);
end;
const
Comparer_Vtable_R4: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_R4
);
Comparer_Instance_R4: Pointer = @Comparer_Vtable_R4;
EqualityComparer_Vtable_R4: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_R4,
@GetHashCode_R4
);
EqualityComparer_Instance_R4: Pointer = @EqualityComparer_Vtable_R4;
function Compare_R8(Inst: Pointer; const Left, Right: Double): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_R8(Inst: Pointer; const Left, Right: Double): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_R8(Inst: Pointer; const Value: Double): Integer;
var
m: Extended;
e: Integer;
begin
// Denormalized floats and positive/negative 0.0 complicate things.
Frexp(Value, m, e);
if m = 0 then
m := Abs(m);
Result := THashBobJenkins.GetHashValue(m, BYTESIZEOFEXTENDED, 0);
Result := THashBobJenkins.GetHashValue(e, SizeOf(e), Result);
end;
const
Comparer_Vtable_R8: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_R8
);
Comparer_Instance_R8: Pointer = @Comparer_Vtable_R8;
EqualityComparer_Vtable_R8: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_R8,
@GetHashCode_R8
);
EqualityComparer_Instance_R8: Pointer = @EqualityComparer_Vtable_R8;
function Compare_R10(Inst: Pointer; const Left, Right: Extended): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_R10(Inst: Pointer; const Left, Right: Extended): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_R10(Inst: Pointer; const Value: Extended): Integer;
var
m: Extended;
e: Integer;
begin
// Denormalized floats and positive/negative 0.0 complicate things.
Frexp(Value, m, e);
if m = 0 then
m := Abs(m);
Result := THashBobJenkins.GetHashValue(m, BYTESIZEOFEXTENDED, 0);
Result := THashBobJenkins.GetHashValue(e, SizeOf(e), Result);
end;
const
Comparer_Vtable_R10: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_R10
);
Comparer_Instance_R10: Pointer = @Comparer_Vtable_R10;
EqualityComparer_Vtable_R10: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_R10,
@GetHashCode_R10
);
EqualityComparer_Instance_R10: Pointer = @EqualityComparer_Vtable_R10;
function Compare_RI8(Inst: Pointer; const Left, Right: Comp): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_RI8(Inst: Pointer; const Left, Right: Comp): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_RI8(Inst: Pointer; const Value: Comp): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Value), 0);
end;
const
Comparer_Vtable_RI8: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_RI8
);
Comparer_Instance_RI8: Pointer = @Comparer_Vtable_RI8;
EqualityComparer_Vtable_RI8: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_RI8,
@GetHashCode_RI8
);
EqualityComparer_Instance_RI8: Pointer = @EqualityComparer_Vtable_RI8;
function Compare_RC8(Inst: Pointer; const Left, Right: Currency): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_RC8(Inst: Pointer; const Left, Right: Currency): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_RC8(Inst: Pointer; const Value: Currency): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Value), 0);
end;
const
Comparer_Vtable_RC8: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_RC8
);
Comparer_Instance_RC8: Pointer = @Comparer_Vtable_RC8;
EqualityComparer_Vtable_RC8: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_RC8,
@GetHashCode_RC8
);
EqualityComparer_Instance_RC8: Pointer = @EqualityComparer_Vtable_RC8;
function Comparer_Selector_Float(info: PTypeInfo; size: Integer): Pointer;
begin
case GetTypeData(info)^.FloatType of
ftSingle: Result := @Comparer_Instance_R4;
ftDouble: Result := @Comparer_Instance_R8;
ftExtended: Result := @Comparer_Instance_R10;
ftComp: Result := @Comparer_Instance_RI8;
ftCurr: Result := @Comparer_Instance_RC8;
else
System.Error(reRangeError);
Exit(nil);
end;
end;
function EqualityComparer_Selector_Float(info: PTypeInfo; size: Integer): Pointer;
begin
case GetTypeData(info)^.FloatType of
ftSingle: Result := @EqualityComparer_Instance_R4;
ftDouble: Result := @EqualityComparer_Instance_R8;
ftExtended: Result := @EqualityComparer_Instance_R10;
ftComp: Result := @EqualityComparer_Instance_RI8;
ftCurr: Result := @EqualityComparer_Instance_RC8;
else
System.Error(reRangeError);
Exit(nil);
end;
end;
// Binary
function BinaryCompare(const Left, Right: Pointer; Size: Integer): Integer;
var
pl, pr: PByte;
len: Integer;
begin
pl := Left;
pr := Right;
len := Size;
while len > 0 do
begin
Result := pl^ - pr^;
if Result <> 0 then
Exit;
Dec(len);
Inc(pl);
Inc(pr);
end;
Result := 0;
end;
function Compare_Binary(Inst: PSimpleInstance; const Left, Right): Integer;
begin
Result := BinaryCompare(@Left, @Right, Inst^.Size);
end;
function Compare_Binary_ThreeByteData(Inst: PSimpleInstance; const Left, Right: TThreeByteData): Integer;
begin
Result := Left[0] - Right[0];
if Result <> 0 then exit;
Result := Left[1] - Right[1];
if Result <> 0 then exit;
Result := Left[2] - Right[2];
end;
function Equals_Binary(Inst: PSimpleInstance; const Left, Right): Boolean;
begin
Result := CompareMem(@Left, @Right, Inst^.Size);
end;
function GetHashCode_Binary(Inst: PSimpleInstance; const Value): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, Inst^.Size, 0);
end;
function Equals_Binary_ThreeByteData(Inst: PSimpleInstance; const Left, Right: TThreeByteData): Boolean;
begin
Result := CompareMem(@Left, @Right, 3);
end;
function GetHashCode_Binary_ThreeByteData(Inst: PSimpleInstance; const Value: TThreeByteData): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, 3, 0);
end;
const
Comparer_Vtable_Binary: array[0..3] of Pointer =
(
@NopQueryInterface,
@MemAddref,
@MemRelease,
@Compare_Binary
);
Comparer_Vtable_Binary_ThreeByteData: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Binary_ThreeByteData
);
Comparer_Instance_ThreeByteData: Pointer = @Comparer_Vtable_Binary_ThreeByteData;
EqualityComparer_Vtable_Binary: array[0..4] of Pointer =
(
@NopQueryInterface,
@MemAddref,
@MemRelease,
@Equals_Binary,
@GetHashCode_Binary
);
EqualityComparer_Vtable_Binary_ThreeByteData: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Binary_ThreeByteData,
@GetHashCode_Binary_ThreeByteData
);
EqualityComparer_Instance_ThreeByteData: Pointer = @EqualityComparer_Vtable_Binary_ThreeByteData;
function Comparer_Selector_Binary(info: PTypeInfo; size: Integer): Pointer;
begin
case size of
// NOTE: Little-endianness may cause counterintuitive results,
// but the results will at least be consistent.
{$IFDEF EABI_RECORD_ARRAY_BYREF}
1:
if (info <> nil) and ((info^.Kind = tkArray) or (info^.Kind = tkRecord)) then
Result := @Comparer_Instance_Ref_U1
else
Result := @Comparer_Instance_U1;
2:
if (info <> nil) and ((info^.Kind = tkArray) or (info^.Kind = tkRecord)) then
Result := @Comparer_Instance_Ref_U2
else
Result := @Comparer_Instance_U2;
4:
if (info <> nil) and ((info^.Kind = tkArray) or (info^.Kind = tkRecord)) then
Result := @Comparer_Instance_Ref_U4
else
Result := @Comparer_Instance_U4;
{$ELSE}
1: Result := @Comparer_Instance_U1;
2: Result := @Comparer_Instance_U2;
4: Result := @Comparer_Instance_U4;
{$ENDIF}
3: // Array [0..2] of byte, or Record with SizeOf() = 3 special case
Result := @Comparer_Instance_ThreeByteData;
{$IF defined(CPUX64) and defined(MSWINDOWS)}
// 64-bit will pass const args in registers
8: Result := @Comparer_Instance_Ref_U8_Swap;
{$ENDIF}
else
Result := MakeInstance(@Comparer_Vtable_Binary, info, size);
end;
end;
function EqualityComparer_Selector_Binary(info: PTypeInfo; size: Integer): Pointer;
begin
case size of
{$IFDEF EABI_RECORD_ARRAY_BYREF}
1:
if (info <> nil) and ((info^.Kind = tkArray) or (info^.Kind = tkRecord)) then
Result := @EqualityComparer_Instance_Ref_I1
else
Result := @EqualityComparer_Instance_I1;
2:
if (info <> nil) and ((info^.Kind = tkArray) or (info^.Kind = tkRecord)) then
Result := @EqualityComparer_Instance_Ref_I2
else
Result := @EqualityComparer_Instance_I2;
4:
if (info <> nil) and ((info^.Kind = tkArray) or (info^.Kind = tkRecord)) then
Result := @EqualityComparer_Instance_Ref_I4
else
Result := @EqualityComparer_Instance_I4;
{$ELSE}
1: Result := @EqualityComparer_Instance_I1;
2: Result := @EqualityComparer_Instance_I2;
4: Result := @EqualityComparer_Instance_I4;
{$ENDIF}
3: // Array [0..2] of byte, or Record with SizeOf() = 3 special case
Result := @EqualityComparer_Instance_ThreeByteData;
{$IF defined(CPUX64) and defined(MSWINDOWS)}
// 64-bit will pass const args in registers
8: Result := @EqualityComparer_Instance_Ref_I8;
{$ENDIF}
else
Result := MakeInstance(@EqualityComparer_Vtable_Binary, info, size);
end;
end;
// Record
type
TRecStack = record
f: array[0 .. 3] of Byte;
constructor Create(a: Byte);
end;
constructor TRecStack.Create(a: Byte);
begin
end;
function Compare_Record_Stack(Inst: PSimpleInstance; const Left, Right: TRecStack): Integer;
begin
Result := BinaryCompare(@Left, @Right, Inst^.Size);
System.FinalizeRecord(@Left, Inst^.Info);
System.FinalizeRecord(@Right, Inst^.Info);
end;
function Equals_Record_Stack(Inst: PSimpleInstance; const Left, Right: TRecStack): Boolean;
begin
Result := CompareMem(@Left, @Right, Inst^.Size);
System.FinalizeRecord(@Left, Inst^.Info);
System.FinalizeRecord(@Right, Inst^.Info);
end;
function GetHashCode_Record_Stack(Inst: PSimpleInstance; const Value: TRecStack): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, Inst^.Size, 0);
System.FinalizeRecord(@Value, Inst^.Info);
end;
const
Comparer_Vtable_Record_Stack: array[0..3] of Pointer =
(
@NopQueryInterface,
@MemAddref,
@MemRelease,
@Compare_Record_Stack
);
EqualityComparer_Vtable_Record_Stack: array[0..4] of Pointer =
(
@NopQueryInterface,
@MemAddref,
@MemRelease,
@Equals_Record_Stack,
@GetHashCode_Record_Stack
);
function Comparer_Selector_Record(info: PTypeInfo; size: Integer): Pointer;
begin
case GetConstRecordArgMode(info) of
rmByValueStack:
Result := MakeInstance(@Comparer_Vtable_Record_Stack, info, size);
rmByValueReg:
Result := Comparer_Selector_Binary(info, size);
rmByRef:
Result := MakeInstance(@Comparer_Vtable_Binary, info, size);
else
Result := nil;
Assert(False);
end;
end;
function EqualityComparer_Selector_Record(info: PTypeInfo; size: Integer): Pointer;
begin
case GetConstRecordArgMode(info) of
rmByValueStack:
Result := MakeInstance(@EqualityComparer_Vtable_Record_Stack, info, size);
rmByValueReg:
Result := EqualityComparer_Selector_Binary(info, size);
rmByRef:
Result := MakeInstance(@EqualityComparer_Vtable_Binary, info, size);
else
Result := nil;
Assert(False);
end;
end;
// Class (i.e. instances)
function Equals_Class(Inst: PSimpleInstance; const Left, Right: TObject): Boolean;
begin
if Left <> nil then
Result := Left.Equals(Right)
else if Right <> nil then
Result := Right.Equals(Left)
else
Result := True;
end;
function Compare_Class(Inst: PSimpleInstance; Left, Right: TObject): Integer;
begin
if Equals_Class(Inst, Left, Right) then
Result := 0
else if NativeInt(Left) < NativeInt(Right) then
Result := -1
else if NativeInt(Left) > NativeInt(Right) then
Result := 1
else
Result := 0;
end;
function GetHashCode_Class(Inst: PSimpleInstance; const Value: TObject): Integer;
begin
if Value = nil then
Result := 42
else
Result := Value.GetHashCode;
end;
// DynArray
function DynLen(Arr: Pointer): NativeInt; inline;
begin
if Arr = nil then
Exit(0);
Result := PNativeInt(PByte(Arr) - SizeOf(NativeInt))^;
end;
function Compare_DynArray(Inst: PSimpleInstance; Left, Right: Pointer): NativeInt;
var
len, lenDiff: NativeInt;
begin
len := DynLen(Left);
lenDiff := len - DynLen(Right);
if lenDiff > 0 then
Dec(len, lenDiff);
Result := BinaryCompare(Left, Right, Inst^.Size * len);
if Result = 0 then
Result := lenDiff;
end;
function Equals_DynArray(Inst: PSimpleInstance; Left, Right: Pointer): Boolean;
var
lenL, lenR: NativeInt;
begin
lenL := DynLen(Left);
lenR := DynLen(Right);
if lenL <> lenR then
Exit(False);
Result := CompareMem(Left, Right, Inst^.Size * lenL);
end;
function GetHashCode_DynArray(Inst: PSimpleInstance; Value: Pointer): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value^, Inst^.Size * DynLen(Value), 0);
end;
const
Comparer_Vtable_DynArray: array[0..3] of Pointer =
(
@NopQueryInterface,
@MemAddref,
@MemRelease,
@Compare_DynArray
);
EqualityComparer_Vtable_DynArray: array[0..4] of Pointer =
(
@NopQueryInterface,
@MemAddref,
@MemRelease,
@Equals_DynArray,
@GetHashCode_DynArray
);
function Comparer_Selector_DynArray(info: PTypeInfo; size: Integer): Pointer;
begin
Result := MakeInstance(@Comparer_Vtable_DynArray, info, GetTypeData(info)^.elSize);
end;
function EqualityComparer_Selector_DynArray(info: PTypeInfo; size: Integer): Pointer;
begin
Result := MakeInstance(@EqualityComparer_Vtable_DynArray, info, GetTypeData(info)^.elSize);
end;
// PStrings
type
{$IFNDEF NEXTGEN}
TPS1 = string[1];
TPS2 = string[2];
TPS3 = string[3];
{$ELSE NEXTGEN}
OpenString = type string;
TPS1 = string;
TPS2 = string;
TPS3 = string;
{$ENDIF !NEXTGEN}
function Compare_PS1(Inst: PSimpleInstance; const Left, Right: TPS1): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Compare_PS2(Inst: PSimpleInstance; const Left, Right: TPS2): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Compare_PS3(Inst: PSimpleInstance; const Left, Right: TPS3): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Compare_PSn(Inst: PSimpleInstance; const Left, Right: OpenString): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_PS1(Inst: PSimpleInstance; const Left, Right: TPS1): Boolean;
begin
Result := Left = Right;
end;
function Equals_PS2(Inst: PSimpleInstance; const Left, Right: TPS2): Boolean;
begin
Result := Left = Right;
end;
function Equals_PS3(Inst: PSimpleInstance; const Left, Right: TPS3): Boolean;
begin
Result := Left = Right;
end;
function Equals_PSn(Inst: PSimpleInstance; const Left, Right: OpenString): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_PS1(Inst: PSimpleInstance; const Value: TPS1): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value[Low(string)], Length(Value), 0);
end;
function GetHashCode_PS2(Inst: PSimpleInstance; const Value: TPS2): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value[Low(string)], Length(Value), 0);
end;
function GetHashCode_PS3(Inst: PSimpleInstance; const Value: TPS3): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value[Low(string)], Length(Value), 0);
end;
function GetHashCode_PSn(Inst: PSimpleInstance; const Value: OpenString): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value[Low(string)], Length(Value), 0);
end;
const
Comparer_Vtable_PS1: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_PS1
);
Comparer_Instance_PS1: Pointer = @Comparer_Vtable_PS1;
Comparer_Vtable_PS2: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_PS2
);
Comparer_Instance_PS2: Pointer = @Comparer_Vtable_PS2;
Comparer_Vtable_PS3: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_PS3
);
Comparer_Instance_PS3: Pointer = @Comparer_Vtable_PS3;
Comparer_Vtable_PSn: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_PSn
);
Comparer_Instance_PSn: Pointer = @Comparer_Vtable_PSn;
EqualityComparer_Vtable_PS1: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_PS1,
@GetHashCode_PS1
);
EqualityComparer_Instance_PS1: Pointer = @EqualityComparer_Vtable_PS1;
EqualityComparer_Vtable_PS2: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_PS2,
@GetHashCode_PS2
);
EqualityComparer_Instance_PS2: Pointer = @EqualityComparer_Vtable_PS2;
EqualityComparer_Vtable_PS3: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_PS3,
@GetHashCode_PS3
);
EqualityComparer_Instance_PS3: Pointer = @EqualityComparer_Vtable_PS3;
EqualityComparer_Vtable_PSn: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_PSn,
@GetHashCode_PSn
);
EqualityComparer_Instance_PSn: Pointer = @EqualityComparer_Vtable_PSn;
function Comparer_Selector_String(info: PTypeInfo; size: Integer): Pointer;
begin
case size of
2: Result := @Comparer_Instance_PS1;
3: Result := @Comparer_Instance_PS2;
4: Result := @Comparer_Instance_PS3;
else
Result := @Comparer_Instance_PSn;
end;
end;
function EqualityComparer_Selector_String(info: PTypeInfo; size: Integer): Pointer;
begin
case size of
2: Result := @EqualityComparer_Instance_PS1;
3: Result := @EqualityComparer_Instance_PS2;
4: Result := @EqualityComparer_Instance_PS3;
else
Result := @EqualityComparer_Instance_PSn;
end;
end;
function CompareRawByteString(const Left, Right: RawByteString): Integer; inline;
var
Len, LLen, RLen: Integer;
LPtr, RPtr: PByte;
begin
if Pointer(Left) = Pointer(Right) then
Result := 0
else if Pointer(Left) = nil then
Result := 0 - PInteger(PByte(Right) - 4)^ // Length(Right)
else if Pointer(Right) = nil then
Result := PInteger(PByte(Left) - 4)^ // Length(Left)
else
begin
Result := Integer(PByte(Left)^) - Integer(PByte(Right)^);
if Result <> 0 then
Exit;
LLen := PInteger(PByte(Left) - 4)^ - 1; // Length(Left);
RLen := PInteger(PByte(Right) - 4)^ - 1; // Length(Right);
Len := LLen;
if Len > RLen then Len := RLen;
LPtr := PByte(Left) + 1;
RPtr := PByte(Right) + 1;
while Len > 0 do
begin
Result := Integer(LPtr^) - Integer(RPtr^);
if Result <> 0 then
Exit;
if Len = 1 then break;
Result := Integer(LPtr[1]) - Integer(RPtr[1]);
if Result <> 0 then
Exit;
Inc(LPtr, 2);
Inc(RPtr, 2);
Dec(Len, 2);
end;
Result := LLen - RLen;
end;
end;
function Compare_LString(Inst: PSimpleInstance; const Left, Right: RawByteString): Integer;
begin
Result := CompareRawByteString(Left, Right);
end;
function Equals_LString(Inst: PSimpleInstance; const Left, Right: RawByteString): Boolean;
begin
Result := CompareRawByteString(Left, Right) = 0;
end;
function GetHashCode_LString(Inst: PSimpleInstance; const Value: RawByteString): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value[1], Length(Value) * SizeOf(Value[1]), 0);
end;
// UStrings
function Compare_UString(Inst: PSimpleInstance; const Left, Right: UnicodeString): Integer;
begin
Result := CompareStr(Left, Right);
end;
function Equals_UString(Inst: PSimpleInstance; const Left, Right: UnicodeString): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_UString(Inst: PSimpleInstance; const Value: UnicodeString): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value[Low(string)], Length(Value) * SizeOf(Char), 0);
end;
// Methods
type
TMethodPointer = procedure of object;
function Compare_Method(Inst: PSimpleInstance; const Left, Right: TMethodPointer): Integer;
var
LMethod, RMethod: TMethod;
begin
LMethod := TMethod(Left);
RMethod := TMethod(Right);
if LMethod < RMethod then
Result := -1
else if LMethod > RMethod then
Result := 1
else
Result := 0;
end;
function Equals_Method(Inst: PSimpleInstance; const Left, Right: TMethodPointer): Boolean;
begin
Result := TMethod(Left) = TMethod(Right);
end;
function GetHashCode_Method(Inst: PSimpleInstance; const Value: TMethodPointer): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(TMethodPointer), 0);
end;
// WStrings
{$IFNDEF NEXTGEN}
function Compare_WString(Inst: PSimpleInstance; const Left, Right: WideString): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_WString(Inst: PSimpleInstance; const Left, Right: WideString): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_WString(Inst: PSimpleInstance; const Value: WideString): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value[1], Length(Value) * SizeOf(Value[1]), 0);
end;
{$ENDIF !NEXTGEN}
// Variants
function Compare_Variant(Inst: PSimpleInstance; Left, Right: Pointer): Integer;
var
l, r: Variant;
lAsString, rAsString: string;
begin
Result := 0; // Avoid warning.
l := PVariant(Left)^;
r := PVariant(Right)^;
try
case VarCompareValue(l, r) of
vrEqual: Exit(0);
vrLessThan: Exit(-1);
vrGreaterThan: Exit(1);
vrNotEqual:
begin
if VarIsEmpty(L) or VarIsNull(L) then
Exit(1)
else
Exit(-1);
end;
end;
except // if comparison failed with exception, compare as string.
try
lAsString := PVariant(Left)^;
rAsString := PVariant(Right)^;
Result := Compare_UString(nil, lAsString, rAsString);
except // if comparison fails again, compare bytes.
Result := BinaryCompare(Left, Right, SizeOf(Variant));
end;
end;
end;
function Equals_Variant(Inst: PSimpleInstance; Left, Right: Pointer): Boolean;
var
l, r: Variant;
begin
l := PVariant(Left)^;
r := PVariant(Right)^;
Result := VarCompareValue(l, r) = vrEqual;
end;
function GetHashCode_Variant(Inst: PSimpleInstance; Value: Pointer): Integer;
var
v: string;
begin
try
v := PVariant(Value)^;
Result := GetHashCode_UString(nil, v);
except
Result := THashBobJenkins.GetHashValue(Value^, SizeOf(Variant), 0);
end;
end;
// Pointers
function Compare_Pointer(Inst: PSimpleInstance; Left, Right: NativeUInt): Integer;
begin
if Left < Right then
Result := -1
else if Left > Right then
Result := 1
else
Result := 0;
end;
function Equals_Pointer(Inst: Pointer; const Left, Right: NativeUInt): Boolean;
begin
Result := Left = Right;
end;
function GetHashCode_Pointer(Inst: Pointer; const Value: NativeUInt): Integer;
begin
Result := THashBobJenkins.GetHashValue(Value, SizeOf(Value), 0);
end;
{$IFDEF NEXTGEN}
const
Compare_WString: Pointer = nil;
Equals_WString: Pointer = nil;
GetHashCode_WString: Pointer = nil;
{$ENDIF !NEXTGEN}
const
Comparer_Vtable_Pointer: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Pointer
);
Comparer_Vtable_Class: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Class
);
Comparer_Vtable_LString: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_LString
);
Comparer_Vtable_WString: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_WString
);
Comparer_Vtable_Variant: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Variant
);
Comparer_Vtable_UString: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_UString
);
Comparer_Vtable_Method: array[0..3] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Compare_Method
);
Comparer_Instance_Pointer: Pointer = @Comparer_Vtable_Pointer;
Comparer_Instance_Class: Pointer = @Comparer_Vtable_Class;
Comparer_Instance_LString: Pointer = @Comparer_Vtable_LString;
Comparer_Instance_WString: Pointer = @Comparer_Vtable_WString;
Comparer_Instance_Variant: Pointer = @Comparer_Vtable_Variant;
Comparer_Instance_UString: Pointer = @Comparer_Vtable_UString;
Comparer_Instance_Method: Pointer = @Comparer_Vtable_Method;
EqualityComparer_Vtable_Pointer: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Pointer,
@GetHashCode_Pointer
);
EqualityComparer_Vtable_Class: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Class,
@GetHashCode_Class
);
EqualityComparer_Vtable_LString: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_LString,
@GetHashCode_LString
);
EqualityComparer_Vtable_WString: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_WString,
@GetHashCode_WString
);
EqualityComparer_Vtable_Variant: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Variant,
@GetHashCode_Variant
);
EqualityComparer_Vtable_UString: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_UString,
@GetHashCode_UString
);
EqualityComparer_Vtable_Method: array[0..4] of Pointer =
(
@NopQueryInterface,
@NopAddref,
@NopRelease,
@Equals_Method,
@GetHashCode_Method
);
EqualityComparer_Instance_Pointer: Pointer = @EqualityComparer_Vtable_Pointer;
EqualityComparer_Instance_Class: Pointer = @EqualityComparer_Vtable_Class;
EqualityComparer_Instance_LString: Pointer = @EqualityComparer_Vtable_LString;
EqualityComparer_Instance_WString: Pointer = @EqualityComparer_Vtable_WString;
EqualityComparer_Instance_Variant: Pointer = @EqualityComparer_Vtable_Variant;
EqualityComparer_Instance_UString: Pointer = @EqualityComparer_Vtable_UString;
EqualityComparer_Instance_Method: Pointer = @EqualityComparer_Vtable_Method;
VtableInfo: array[TDefaultGenericInterface, TTypeKind] of TVtableInfo =
(
// IComparer
(
// tkUnknown
(Flags: [ifSelector]; Data: @Comparer_Selector_Binary),
// tkInteger
(Flags: [ifSelector]; Data: @Comparer_Selector_Integer),
// tkChar
(Flags: [ifSelector]; Data: @Comparer_Selector_Binary),
// tkEnumeration
(Flags: [ifSelector]; Data: @Comparer_Selector_Integer),
// tkFloat
(Flags: [ifSelector]; Data: @Comparer_Selector_Float),
// tkString
(Flags: [ifSelector]; Data: @Comparer_Selector_String),
// tkSet
(Flags: [ifSelector]; Data: @Comparer_Selector_Binary),
// tkClass
(Flags: []; Data: @Comparer_Instance_Class),
// tkMethod
(Flags: []; Data: @Comparer_Instance_Method),
// tkWChar
(Flags: [ifSelector]; Data: @Comparer_Selector_Binary),
// tkLString
(Flags: []; Data: @Comparer_Instance_LString),
// tkWString
(Flags: []; Data: @Comparer_Instance_WString),
// tkVariant
(Flags: []; Data: @Comparer_Instance_Variant),
// tkArray
(Flags: [ifSelector]; Data: @Comparer_Selector_Binary),
// tkRecord
(Flags: [ifSelector]; Data: @Comparer_Selector_Record),
// tkInterface
(Flags: []; Data: @Comparer_Instance_Pointer),
// tkInt64
(Flags: [ifSelector]; Data: @Comparer_Selector_Int64),
// tkDynArray
(Flags: [ifSelector]; Data: @Comparer_Selector_DynArray),
// tkUString
(Flags: []; Data: @Comparer_Instance_UString),
// tkClassRef
(Flags: []; Data: @Comparer_Instance_Pointer),
// tkPointer
(Flags: []; Data: @Comparer_Instance_Pointer),
// tkProcedure
(Flags: []; Data: @Comparer_Instance_Pointer),
// tkMRecord
(Flags: [ifSelector]; Data: @Comparer_Selector_Record)
),
// IEqualityComparer
(
// tkUnknown
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Binary),
// tkInteger
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Integer),
// tkChar
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Binary),
// tkEnumeration
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Integer),
// tkFloat
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Float),
// tkString
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_String),
// tkSet
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Binary),
// tkClass
(Flags: []; Data: @EqualityComparer_Instance_Class),
// tkMethod
(Flags: []; Data: @EqualityComparer_Instance_Method),
// tkWChar
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Binary),
// tkLString
(Flags: []; Data: @EqualityComparer_Instance_LString),
// tkWString
(Flags: []; Data: @EqualityComparer_Instance_WString),
// tkVariant
(Flags: []; Data: @EqualityComparer_Instance_Variant),
// tkArray
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Binary),
// tkRecord
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Record),
// tkInterface
(Flags: []; Data: @EqualityComparer_Instance_Pointer),
// tkInt64
(Flags: []; Data: @EqualityComparer_Instance_I8),
// tkDynArray
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_DynArray),
// tkUString
(Flags: []; Data: @EqualityComparer_Instance_UString),
// tkClassRef
(Flags: []; Data: @EqualityComparer_Instance_Pointer),
// tkPointer
(Flags: []; Data: @EqualityComparer_Instance_Pointer),
// tkProcedure
(Flags: []; Data: @EqualityComparer_Instance_Pointer),
// tkMRecord
(Flags: [ifSelector]; Data: @EqualityComparer_Selector_Record)
)
);
function _LookupVtableInfo(intf: TDefaultGenericInterface; info: PTypeInfo; size: Integer): Pointer;
var
pinfo: PVtableInfo;
begin
if info <> nil then
begin
pinfo := @VtableInfo[intf, info^.Kind];
Result := pinfo^.Data;
if ifSelector in pinfo^.Flags then
Result := TTypeInfoSelector(Result)(info, size);
if ifVariableSize in pinfo^.Flags then
Result := MakeInstance(Result, info, size);
end
else
begin
case intf of
giComparer: Result := Comparer_Selector_Binary(info, size);
giEqualityComparer: Result := EqualityComparer_Selector_Binary(info, size);
else
System.Error(reRangeError);
Result := nil;
end;
end;
end;
{ TSingletonImplementation }
function TSingletonImplementation.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
if GetInterface(IID, Obj) then
Result := S_OK
else
Result := E_NOINTERFACE;
end;
function TSingletonImplementation._AddRef: Integer;
begin
Result := -1;
end;
function TSingletonImplementation._Release: Integer;
begin
Result := -1;
end;
{ Delegated Comparers }
constructor TDelegatedEqualityComparer<T>.Create(const AEquals: TEqualityComparison<T>; const AGetHashCode: THasher<T>);
begin
FEquals := AEquals;
FGetHashCode := AGetHashCode;
end;
function TDelegatedEqualityComparer<T>.Equals(const Left, Right: T): Boolean;
begin
Result := FEquals(Left, Right);
end;
function TDelegatedEqualityComparer<T>.GetHashCode(const Value: T): Integer;
begin
Result := FGetHashCode(Value);
end;
constructor TDelegatedComparer<T>.Create(const ACompare: TComparison<T>);
begin
FCompare := ACompare;
end;
function TDelegatedComparer<T>.Compare(const Left, Right: T): Integer;
begin
Result := FCompare(Left, Right);
end;
{ TOrdinalStringComparer }
type
TOrdinalStringComparer = class(TStringComparer)
public
function Compare(const Left, Right: string): Integer; override;
function Equals(const Left, Right: string): Boolean;
reintroduce; overload; override;
function GetHashCode(const Value: string): Integer;
reintroduce; overload; override;
end;
function TOrdinalStringComparer.Compare(const Left, Right: string): Integer;
var
len, lenDiff: Integer;
begin
len := Length(Left);
lenDiff := len - Length(Right);
if Length(Right) < len then
len := Length(Right);
Result := BinaryCompare(PChar(Left), PChar(Right), len * SizeOf(Char));
if Result = 0 then
Exit(lenDiff);
end;
function TOrdinalStringComparer.Equals(const Left, Right: string): Boolean;
var
len: Integer;
begin
len := Length(Left);
Result := (len - Length(Right) = 0) and CompareMem(PChar(Left), PChar(Right), len * SizeOf(Char));
end;
function TOrdinalStringComparer.GetHashCode(const Value: string): Integer;
begin
Result := THashBobJenkins.GetHashValue(PChar(Value)^, SizeOf(Char) * Length(Value), 0);
end;
{ TStringComparer }
class destructor TStringComparer.Destroy;
begin
FreeAndNil(FOrdinal);
end;
class function TStringComparer.Ordinal: TStringComparer;
begin
if FOrdinal = nil then
FOrdinal := TOrdinalStringComparer.Create;
Result := TStringComparer(FOrdinal);
end;
{ TOrdinalIStringComparer }
function TOrdinalIStringComparer.Compare(const Left, Right: string): Integer;
var
L, R: string;
len, lenDiff: Integer;
begin
L := AnsiLowerCase(Left);
R := AnsiLowerCase(Right);
len := Length(L);
lenDiff := len - Length(R);
if Length(R) < len then
len := Length(R);
Result := BinaryCompare(PChar(L), PChar(R), len * SizeOf(Char));
if Result = 0 then
Exit(lenDiff);
end;
function TOrdinalIStringComparer.Equals(const Left, Right: string): Boolean;
var
len: Integer;
L, R: string;
begin
L := AnsiLowerCase(Left);
R := AnsiLowerCase(Right);
len := Length(L);
Result := (len - Length(R) = 0) and CompareMem(PChar(L), PChar(R), len * SizeOf(Char));
end;
function TOrdinalIStringComparer.GetHashCode(const Value: string): Integer;
var
S: string;
begin
S := AnsiLowerCase(Value);
Result := THashBobJenkins.GetHashValue(PChar(S)^, SizeOf(Char) * Length(S), 0);
end;
{ TIStringComparer }
class destructor TIStringComparer.Destroy;
begin
FreeAndNil(FOrdinal);
end;
class function TIStringComparer.Ordinal: TStringComparer;
begin
if FOrdinal = nil then
FOrdinal := TOrdinalIStringComparer.Create;
Result := TStringComparer(FOrdinal);
end;
{ TComparer<T> }
class function TComparer<T>.Default: IComparer<T>;
begin
Result := IComparer<T>(_LookupVtableInfo(giComparer, TypeInfo(T), SizeOf(T)));
end;
class function TComparer<T>.Construct(const Comparison: TComparison<T>): IComparer<T>;
begin
Result := TDelegatedComparer<T>.Create(Comparison);
end;
{ TEqualityComparer<T> }
class function TEqualityComparer<T>.Default: IEqualityComparer<T>;
begin
Result := IEqualityComparer<T>(_LookupVtableInfo(giEqualityComparer, TypeInfo(T), SizeOf(T)));
end;
class function TEqualityComparer<T>.Construct(
const EqualityComparison: TEqualityComparison<T>;
const Hasher: THasher<T>): IEqualityComparer<T>;
begin
Result := TDelegatedEqualityComparer<T>.Create(EqualityComparison, Hasher);
end;
{ BobJenkinsHash }
function BobJenkinsHash(const Data; Len, InitData: Integer): Integer;
begin
Result := THashBobJenkins.GetHashValue(Data, Len, InitData);
end;
end.
|
object Form1: TForm1
Left = 0
Top = 0
BorderIcons = [biSystemMenu, biMinimize]
BorderStyle = bsSingle
Caption = 'Registro Diamond'
ClientHeight = 578
ClientWidth = 660
Color = clWindow
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -12
Font.Name = 'Tahoma'
Font.Style = []
Icon.Data = {
0000010001002020100000000000E80200001600000028000000200000004000
0000010004000000000080020000000000000000000000000000000000000000
0000000080000080000000808000800000008000800080800000C0C0C0008080
80000000FF0000FF000000FFFF00FF000000FF00FF00FFFF0000FFFFFF000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000F0F0000000000000000000
0000000000E0F000000000000000000000000000E0F0F0E00000000000000000
00000000E0E0F0E000000000000000000000000E0EF0FF0E0000000000000000
000000EE0FE0FF0EE000000000000000000000E0FEF0FFF0E000000000000000
00000EE0EFE0FFF0EE000000000000000000EEE0FEF0FFF0EEE0000000000000
0000EE0FEFE0FFFF0EE0000000000000000EEE0EFEF0FFFF0EEE000000000000
00EEEE0FEFE0FFFF0EEEE000000000000EEEE0FEFEF0FFFFF0EEEE0000000000
0EEEE0EFEFE0FFFFF0EEEE0000000000EEEE0EFE0000000FFF0EEEE00000000E
EEE00000FF0E0FE00000EEEE00000000000F00FFFF0E0EFEF00F00000000000E
FEFE00FFF0EEE0EFE00EFEFE0000000FEFEF0F0FF0EEE0FE0F0FEFEF00000000
FEF0FF0F0EEEEE0F0EF0FEF00000000000E0FFF00EEEEE00EFE0E00000000000
0000FF00000000000EF00000000000000000000F00FFF00E0000000000000000
0000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000FFFF
FFFFFFFFFFFFFFFEFFFFFFFC7FFFFFFC7FFFFFF83FFFFFF01FFFFFE00FFFFFE0
0FFFFFC007FFFF8003FFFF8003FFFF0001FFFE0000FFFE0000FFFC00007FF800
003FF000001FF000001FE000000FC0000007C000000780000003C0000007E000
000FF000001FFC00007FFE0000FFFF8003FFFFFFFFFFFFFFFFFFFFFFFFFF}
OldCreateOrder = False
Position = poScreenCenter
OnCloseQuery = FormCloseQuery
PixelsPerInch = 96
TextHeight = 14
object GroupBox1: TGroupBox
Left = 27
Top = 8
Width = 625
Height = 81
Color = clWhite
ParentBackground = False
ParentColor = False
TabOrder = 0
object Label9: TLabel
Left = 206
Top = 19
Width = 220
Height = 59
Caption = 'Diamond'
Font.Charset = DEFAULT_CHARSET
Font.Color = clAqua
Font.Height = -49
Font.Name = 'Tahoma'
Font.Style = [fsBold]
ParentFont = False
end
object Image1: TImage
Left = 295
Top = 3
Width = 33
Height = 30
Picture.Data = {
055449636F6E0000010001002020100000000000E80200001600000028000000
2000000040000000010004000000000080020000000000000000000000000000
0000000000000000000080000080000000808000800000008000800080800000
C0C0C000808080000000FF0000FF000000FFFF00FF000000FF00FF00FFFF0000
FFFFFF0000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000F0F0000000
0000000000000000000000E0F000000000000000000000000000E0F0F0E00000
00000000000000000000E0E0F0E000000000000000000000000E0EF0FF0E0000
000000000000000000EE0FE0FF0EE000000000000000000000E0FEF0FFF0E000
00000000000000000EE0EFE0FFF0EE000000000000000000EEE0FEF0FFF0EEE0
0000000000000000EE0FEFE0FFFF0EE0000000000000000EEE0EFEF0FFFF0EEE
00000000000000EEEE0FEFE0FFFF0EEEE000000000000EEEE0FEFEF0FFFFF0EE
EE00000000000EEEE0EFEFE0FFFFF0EEEE0000000000EEEE0EFE0000000FFF0E
EEE00000000EEEE00000FF0E0FE00000EEEE00000000000F00FFFF0E0EFEF00F
00000000000EFEFE00FFF0EEE0EFE00EFEFE0000000FEFEF0F0FF0EEE0FE0F0F
EFEF00000000FEF0FF0F0EEEEE0F0EF0FEF00000000000E0FFF00EEEEE00EFE0
E000000000000000FF00000000000EF00000000000000000000F00FFF00E0000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
00000000FFFFFFFFFFFFFFFFFFFEFFFFFFFC7FFFFFFC7FFFFFF83FFFFFF01FFF
FFE00FFFFFE00FFFFFC007FFFF8003FFFF8003FFFF0001FFFE0000FFFE0000FF
FC00007FF800003FF000001FF000001FE000000FC0000007C000000780000003
C0000007E000000FF000001FFC00007FFE0000FFFF8003FFFFFFFFFFFFFFFFFF
FFFFFFFF}
end
end
object StatusBar1: TStatusBar
Left = 0
Top = 558
Width = 660
Height = 20
Color = clWhite
Panels = <>
end
object GroupBox3: TGroupBox
Left = 344
Top = 454
Width = 297
Height = 89
TabOrder = 2
object DBText1: TDBText
Left = 233
Top = 14
Width = 50
Height = 17
DataField = 'sum(valor_venda)'
DataSource = DataSource2
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -12
Font.Name = 'Tahoma'
Font.Style = []
ParentFont = False
end
object SpeedButton1: TSpeedButton
Left = 19
Top = 37
Width = 251
Height = 32
Caption = 'Gerar Valor de Vendas'
Flat = True
Glyph.Data = {
76010000424D7601000000000000760000002800000020000000100000000100
04000000000000010000120B0000120B00001000000000000000000000000000
800000800000008080008000000080008000808000007F7F7F00BFBFBF000000
FF0000FF000000FFFF00FF000000FF00FF00FFFF0000FFFFFF00337000000000
73333337777777773F333308888888880333337F3F3F3FFF7F33330808089998
0333337F737377737F333308888888880333337F3F3F3F3F7F33330808080808
0333337F737373737F333308888888880333337F3F3F3F3F7F33330808080808
0333337F737373737F333308888888880333337F3F3F3F3F7F33330808080808
0333337F737373737F333308888888880333337F3FFFFFFF7F33330800000008
0333337F7777777F7F333308000E0E080333337F7FFFFF7F7F33330800000008
0333337F777777737F333308888888880333337F333333337F33330888888888
03333373FFFFFFFF733333700000000073333337777777773333}
NumGlyphs = 2
OnClick = SpeedButton1Click
end
object Label10: TLabel
Left = 21
Top = 14
Width = 206
Height = 14
Caption = 'O valor em vendas cadastras e de: R$'
end
end
object GroupBox2: TGroupBox
Left = 20
Top = 454
Width = 297
Height = 89
TabOrder = 3
object DBText2: TDBText
Left = 234
Top = 16
Width = 65
Height = 17
DataField = 'sum(valor_compra)'
DataSource = DataSource4
end
object SpeedButton2: TSpeedButton
Left = 40
Top = 47
Width = 209
Height = 22
Caption = 'Gerar Valor de Compras'
Flat = True
Glyph.Data = {
76010000424D7601000000000000760000002800000020000000100000000100
04000000000000010000120B0000120B00001000000000000000000000000000
800000800000008080008000000080008000808000007F7F7F00BFBFBF000000
FF0000FF000000FFFF00FF000000FF00FF00FFFF0000FFFFFF00337000000000
73333337777777773F333308888888880333337F3F3F3FFF7F33330808089998
0333337F737377737F333308888888880333337F3F3F3F3F7F33330808080808
0333337F737373737F333308888888880333337F3F3F3F3F7F33330808080808
0333337F737373737F333308888888880333337F3F3F3F3F7F33330808080808
0333337F737373737F333308888888880333337F3FFFFFFF7F33330800000008
0333337F7777777F7F333308000E0E080333337F7FFFFF7F7F33330800000008
0333337F777777737F333308888888880333337F333333337F33330888888888
03333373FFFFFFFF733333700000000073333337777777773333}
NumGlyphs = 2
OnClick = SpeedButton2Click
end
object Label19: TLabel
Left = 15
Top = 16
Width = 213
Height = 14
Caption = 'O valor em compras cadastras e de: R$'
end
end
object DBComboBox4: TDBComboBox
Left = 35
Top = 244
Width = 145
Height = 22
DataField = 'nm_forn'
TabOrder = 4
end
object PageControl1: TPageControl
Left = 16
Top = 95
Width = 625
Height = 337
ActivePage = Vendas
MultiLine = True
TabOrder = 5
object Vendas: TTabSheet
Caption = 'Vendas'
object Label1: TLabel
Left = 14
Top = 3
Width = 37
Height = 14
Caption = 'Codigo'
FocusControl = DBEdit1
end
object Label2: TLabel
Left = 14
Top = 51
Width = 32
Height = 14
Caption = 'Nome'
FocusControl = DBEdit2
end
object Label3: TLabel
Left = 234
Top = 48
Width = 63
Height = 14
Caption = 'Sobrenome'
FocusControl = DBEdit3
end
object Label4: TLabel
Left = 14
Top = 98
Width = 20
Height = 14
Caption = 'CPF'
FocusControl = DBEdit4
end
object Label5: TLabel
Left = 14
Top = 150
Width = 14
Height = 14
Caption = 'NF'
FocusControl = DBEdit5
end
object Label6: TLabel
Left = 14
Top = 210
Width = 79
Height = 14
Caption = 'Data da venda'
FocusControl = DBEdit6
end
object Label8: TLabel
Left = 376
Top = 211
Width = 117
Height = 14
Caption = 'Forma de pagamento'
end
object Label7: TLabel
Left = 192
Top = 212
Width = 82
Height = 14
Caption = 'Valor de venda'
FocusControl = DBEdit7
end
object DBComboBox1: TDBComboBox
Left = 376
Top = 231
Width = 169
Height = 22
DataField = 'forma_pagar'
DataSource = DataSource1
Items.Strings = (
'Dinheiro'
'Cart'#227'o de d'#233'bito'
'Cart'#227'o de cr'#233'dito x1'
'Cart'#227'o de cr'#233'dito x2'
'Cart'#227'o de cr'#233'dito x3'
'Boleto banc'#225'rio')
TabOrder = 7
end
object DBEdit1: TDBEdit
Left = 14
Top = 23
Width = 51
Height = 22
DataField = 'codigo_venda'
DataSource = DataSource1
Enabled = False
TabOrder = 0
end
object DBEdit2: TDBEdit
Left = 14
Top = 67
Width = 177
Height = 22
DataField = 'nome_cli'
DataSource = DataSource1
TabOrder = 1
end
object DBEdit3: TDBEdit
Left = 234
Top = 67
Width = 331
Height = 22
DataField = 'sobrenome_cli'
DataSource = DataSource1
TabOrder = 2
end
object DBEdit4: TDBEdit
Left = 14
Top = 117
Width = 174
Height = 22
DataField = 'cpf'
DataSource = DataSource1
MaxLength = 14
TabOrder = 3
end
object DBEdit5: TDBEdit
Left = 14
Top = 166
Width = 134
Height = 22
DataField = 'nf'
DataSource = DataSource1
TabOrder = 4
end
object DBEdit6: TDBEdit
Left = 14
Top = 231
Width = 134
Height = 22
DataField = 'data_venda'
DataSource = DataSource1
MaxLength = 10
TabOrder = 5
end
object DBNavigator1: TDBNavigator
Left = 151
Top = 272
Width = 321
Height = 25
DataSource = DataSource1
VisibleButtons = [nbInsert, nbPost, nbCancel]
Flat = True
Ctl3D = True
ParentCtl3D = False
TabOrder = 8
end
object DBEdit7: TDBEdit
Left = 192
Top = 232
Width = 144
Height = 22
DataField = 'valor_venda'
DataSource = DataSource1
TabOrder = 6
end
end
object TabSheet1: TTabSheet
Caption = 'Compras'
ImageIndex = 1
object Label13: TLabel
Left = 12
Top = 147
Width = 14
Height = 14
Caption = 'NF'
FocusControl = DBEdit10
end
object Label14: TLabel
Left = 12
Top = 203
Width = 87
Height = 14
Caption = 'Data da Compra'
FocusControl = DBEdit11
end
object Label11: TLabel
Left = 12
Top = 8
Width = 37
Height = 14
Caption = 'Codigo'
FocusControl = DBEdit8
end
object Label18: TLabel
Left = 264
Top = 97
Width = 27
Height = 14
Caption = 'CNPJ'
FocusControl = DBEdit15
end
object Label12: TLabel
Left = 12
Top = 53
Width = 93
Height = 14
Caption = 'Nome do Usuario'
end
object Label17: TLabel
Left = 400
Top = 204
Width = 117
Height = 14
Caption = 'Forma de Pagamento'
end
object Label15: TLabel
Left = 208
Top = 204
Width = 90
Height = 14
Caption = 'Valor de Compra'
FocusControl = DBEdit9
end
object Label16: TLabel
Left = 12
Top = 97
Width = 116
Height = 14
Caption = 'Nome do Fornecedor'
FocusControl = DBEdit12
end
object DBEdit10: TDBEdit
Left = 12
Top = 167
Width = 144
Height = 22
DataField = 'nf_compra'
DataSource = DataSource3
TabOrder = 3
end
object DBEdit11: TDBEdit
Left = 12
Top = 223
Width = 144
Height = 22
DataField = 'data_compra'
DataSource = DataSource3
MaxLength = 10
TabOrder = 4
end
object DBNavigator2: TDBNavigator
Left = 151
Top = 280
Width = 321
Height = 25
DataSource = DataSource3
VisibleButtons = [nbInsert, nbPost, nbCancel]
Flat = True
Ctl3D = True
ParentCtl3D = False
TabOrder = 8
end
object DBEdit8: TDBEdit
Left = 12
Top = 25
Width = 54
Height = 22
DataField = 'codigo_compras'
DataSource = DataSource3
Enabled = False
TabOrder = 6
end
object DBEdit15: TDBEdit
Left = 264
Top = 113
Width = 284
Height = 22
DataField = 'cnpj'
DataSource = DataSource3
MaxLength = 18
TabOrder = 2
end
object DBComboBox3: TDBComboBox
Left = 12
Top = 69
Width = 145
Height = 22
DataField = 'nm_usuario'
DataSource = DataSource3
Items.Strings = (
'Jo'#227'o'
'Maria'
'Jorge'
'Eliseu'
'Fernanda')
TabOrder = 0
end
object DBComboBox2: TDBComboBox
Left = 400
Top = 224
Width = 145
Height = 22
DataField = 'forma_pagar'
DataSource = DataSource3
Items.Strings = (
'Transfer'#234'ncia banc'#225'ria'
'Boleto Banc'#225'rio'
'D'#233'bito Autom'#225'tico')
TabOrder = 7
end
object DBEdit9: TDBEdit
Left = 208
Top = 224
Width = 144
Height = 22
DataField = 'valor_compra'
DataSource = DataSource3
TabOrder = 5
end
object DBEdit12: TDBEdit
Left = 12
Top = 112
Width = 197
Height = 22
DataField = 'nm_fornecedor'
DataSource = DataSource3
TabOrder = 1
end
end
end
object FDConnection1: TFDConnection
Params.Strings = (
'LockingMode=Normal'
'Database=C:\Users\albuq\Desktop\Projetos Delphi 7\Diamond\BD\Ven' +
'dasBD.db'
'DriverID=SQLite')
Connected = True
LoginPrompt = False
Left = 168
Top = 24
end
object FDTable1: TFDTable
Active = True
IndexFieldNames = 'codigo_venda'
Connection = FDConnection1
UpdateOptions.UpdateTableName = 'Vendas'
TableName = 'Vendas'
Left = 56
Top = 24
object FDTable1codigo_venda: TFDAutoIncField
FieldName = 'codigo_venda'
Origin = 'codigo_venda'
ProviderFlags = [pfInWhere, pfInKey]
ReadOnly = True
end
object FDTable1nome_cli: TStringField
FieldName = 'nome_cli'
Origin = 'nome_cli'
Required = True
end
object FDTable1sobrenome_cli: TStringField
FieldName = 'sobrenome_cli'
Origin = 'sobrenome_cli'
Required = True
Size = 35
end
object FDTable1cpf: TStringField
FieldName = 'cpf'
Origin = 'cpf'
Required = True
EditMask = '000\.000\.000\-00;1;_'
Size = 16
end
object FDTable1nf: TIntegerField
FieldName = 'nf'
Origin = 'nf'
Required = True
end
object FDTable1data_venda: TDateField
FieldName = 'data_venda'
Origin = 'data_venda'
Required = True
EditMask = '!00/00/0000;1;_'
end
object FDTable1forma_pagar: TStringField
FieldName = 'forma_pagar'
Origin = 'forma_pagar'
Required = True
Size = 25
end
object FDTable1valor_venda: TFloatField
FieldName = 'valor_venda'
Origin = 'valor_venda'
Required = True
EditFormat = 'R$'
end
end
object DataSource1: TDataSource
DataSet = FDTable1
Left = 112
Top = 24
end
object FDQuery1: TFDQuery
Connection = FDConnection1
SQL.Strings = (
'select sum(valor_venda) from Vendas')
Left = 584
Top = 504
end
object DataSource2: TDataSource
DataSet = FDQuery1
Left = 368
Top = 503
end
object FDTable2: TFDTable
Active = True
IndexFieldNames = 'codigo_compras'
Connection = FDConnection1
UpdateOptions.UpdateTableName = 'Compras'
TableName = 'Compras'
Left = 520
Top = 24
object FDTable2codigo_compras: TFDAutoIncField
FieldName = 'codigo_compras'
Origin = 'codigo_compras'
ProviderFlags = [pfInWhere, pfInKey]
ReadOnly = True
end
object FDTable2nf_compra: TIntegerField
FieldName = 'nf_compra'
Origin = 'nf_compra'
Required = True
end
object FDTable2data_compra: TDateField
FieldName = 'data_compra'
Origin = 'data_compra'
Required = True
EditMask = '!00/00/0000;1;_'
end
object FDTable2cnpj: TStringField
FieldName = 'cnpj'
Origin = 'cnpj'
Required = True
EditMask = '00\.000\.000\/0000\-00;1;_'
end
object FDTable2nm_usuario: TStringField
FieldName = 'nm_usuario'
Origin = 'nm_usuario'
Required = True
Size = 25
end
object FDTable2forma_pagar: TStringField
FieldName = 'forma_pagar'
Origin = 'forma_pagar'
Required = True
Size = 25
end
object FDTable2valor_compra: TFloatField
FieldName = 'valor_compra'
Origin = 'valor_compra'
Required = True
EditFormat = 'R$'
end
object FDTable2nm_fornecedor: TStringField
FieldName = 'nm_fornecedor'
Origin = 'nm_fornecedor'
Required = True
Size = 40
end
end
object DataSource3: TDataSource
DataSet = FDTable2
Left = 576
Top = 24
end
object FDQuery2: TFDQuery
Connection = FDConnection1
SQL.Strings = (
'Select sum(valor_compra) from Compras')
Left = 256
Top = 496
end
object DataSource4: TDataSource
DataSet = FDQuery2
Left = 32
Top = 496
end
end
|
{*******************************************************}
{ }
{ Borland Delphi Visual Component Library }
{ Web server application components }
{ }
{ Copyright (c) 2001 Borland Software Corp. }
{ }
{*******************************************************}
unit DesignerDbgSite;
interface
uses SysUtils, Classes, HTTPApp, HTTPProd, DbgSiteAS, AscrLib, ActiveX, ActivDbgLib;
type
TDesignerDebugScriptSite = class(TBaseDebugScriptSite)
protected
procedure HandleScriptError(const AErrorDebug: IActiveScriptErrorDebug;
var AEnterDebugger: Boolean); override;
function BreakOnFirstStatement: Boolean; override;
end;
implementation
uses
WebScript, Forms, Windows, SiteComp, WebScriptAS, Dialogs, Controls;
var
SetBreak: Boolean = False;
{ TDesignerDebugScriptSite }
resourcestring
sScriptErrorPrompt = 'A script error occured. Do you want to debug?';
sScriptError = 'Script Error';
function TDesignerDebugScriptSite.BreakOnFirstStatement: Boolean;
begin
Result := SetBreak;
end;
procedure TDesignerDebugScriptSite.HandleScriptError(
const AErrorDebug: IActiveScriptErrorDebug; var AEnterDebugger: Boolean);
begin
inherited HandleScriptError(AErrorDebug, AEnterDebugger);
AEnterDebugger := True;
if SiteComp.InternetEnvOptions <> nil then
if SiteComp.InternetEnvOptions.DisableDebugger then
AEnterDebugger := False;
if AEnterDebugger then
AEnterDebugger := MessageDlg(sScriptErrorPrompt, mtError, [mbYes, mbNo], 0) = mrYes;
end;
type
TScriptDebugger = class(TInterfacedObject, IInternetScriptDebugger)
protected
procedure DebugScript(AContext: IUnknown);
function CanDebugScript(AContext: IUnknown): Boolean;
end;
procedure TScriptDebugger.DebugScript(AContext: IUnknown);
begin
SetBreak := True;
try
if SiteComp.ExecuteScript <> nil then
SiteComp.ExecuteScript.ExecuteScript(AContext);
finally
SetBreak := False;
end;
end;
function TScriptDebugger.CanDebugScript(AContext: IUnknown): Boolean;
begin
Result := (SiteComp.ExecuteScript <> nil) and SiteComp.ExecuteScript.CanExecuteScript(AContext);
end;
initialization
ActiveScriptEngine.ScriptSiteClass := TDesignerDebugScriptSite;
SiteComp.ScriptDebugger := TScriptDebugger.Create;
finalization
if (ActiveScriptEngine <> nil) and (ActiveScriptEngine.ScriptSiteClass = TDesignerDebugScriptSite) then
ActiveScriptEngine.ScriptSiteClass := nil;
Sitecomp.ScriptDebugger := nil;
end.
|
unit ColorComboEdit;
interface
uses
Windows, Types, UITypes, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, RxCombos, CommDlg;
type
TColorComboEdit = class(TColorComboBox)
private
{ Private declarations }
FColorDlg: TColorDialog;
FCanTransparent: boolean;
procedure SetCanTransparent(const Value: boolean);
protected
{ Protected declarations }
procedure DrawItem(Index: Integer; Rect: TRect; State: TOwnerDrawState); override;
procedure PopulateList; override;
procedure Click; override;
procedure DoChange; override;
procedure ChooseColor;
procedure SetNewColor(Value: TColor);
public
{ Public declarations }
published
{ Published declarations }
property CanTransparent: boolean read FCanTransparent
write SetCanTransparent;
end;
var
CustomColors: TStringList;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Samples', [TColorComboEdit]);
end;
// TColorComboEdit ////////////////////////////////////////////////////////////
const
ColorValues: array [0..17] of TColor = (
clNone,
clBlack, clMaroon, clGreen, clOlive, clNavy, clPurple, clTeal, clGray,
clSilver, clRed, clLime, clYellow, clBlue, clFuchsia, clAqua, clWhite,
clDefault );
procedure TColorComboEdit.SetNewColor(Value: TColor);
begin
end;
procedure TColorComboEdit.Click;
var OldColor: TCOlor;
begin
OldColor := ColorValue;
inherited;
if ItemIndex = Items.Count - 1 then begin
ColorValue := OldColor;
ChooseColor;
end;
end;
procedure TColorComboEdit.DoChange;
begin
inherited;
if ItemIndex = -1 then ItemIndex := Items.Count-1;
end;
procedure TColorComboEdit.DrawItem(Index: Integer; Rect: TRect;
State: TOwnerDrawState);
const
ColorWidth = 22;
var
ARect: TRect;
Text: array[0..255] of Char;
Safer: TColor;
begin
ARect := Rect;
Inc(ARect.Top, 2);
Inc(ARect.Left, 2);
Dec(ARect.Bottom, 2);
if DisplayNames then ARect.Right := ARect.Left + ColorWidth
else Dec(ARect.Right, 3);
with Canvas do begin
FillRect(Rect);
Safer := Brush.Color;
try
Pen.Color := clWindowText;
Rectangle(ARect.Left, ARect.Top, ARect.Right, ARect.Bottom);
InflateRect(ARect, -1, -1);
if TColor(Items.Objects[Index]) = clNone then begin
Brush.Color := clWhite;
FillRect(ARect);
MoveTo(ARect.Left, ARect.Top);
LineTo(ARect.Right, ARect.Bottom-1);
MoveTo(ARect.Right, ARect.Top);
LineTo(ARect.Left, ARect.Bottom-1);
end else
if Index = Items.Count-1 then begin
Brush.Color := ColorValue;
FillRect(ARect);
end else begin
Brush.Color := TColor(Items.Objects[Index]);
FillRect(ARect);
end;
finally
Brush.Color := Safer;
end;
if DisplayNames then begin
StrPCopy(Text, Items[Index]);
Rect.Left := Rect.Left + ColorWidth + 6;
DrawText(Canvas.Handle, Text, StrLen(Text), Rect,
DrawTextBiDiModeFlags(DT_SINGLELINE or DT_VCENTER or DT_NOPREFIX));
end;
end;
end;
procedure TColorComboEdit.PopulateList;
var
i: Integer;
ColorName: string;
begin
Items.BeginUpdate;
try
Clear;
for i := 0 to High(ColorValues) do
begin
if (i = 0) and not FCanTransparent then continue;
if i = High(ColorValues) then
ColorName := 'Other ...'
else
{ delete two first characters which prefix "cl" educated }
ColorName := Copy(ColorToString(ColorValues[i]), 3, MaxInt);
Items.AddObject(ColorName, TObject(ColorValues[i]));
end;
finally
Items.EndUpdate;
end;
end;
procedure TColorComboEdit.ChooseColor;
begin
FColorDlg := TColorDialog.Create(Self);
with FColorDlg do
try
CustomColors.Assign(ColorComboEdit.CustomColors);
Color := ColorValue;
Options := [cdFullOpen, cdAnyColor];
if Execute then begin
ColorValue := Color;
ColorComboEdit.CustomColors.Assign(CustomColors);
end;
finally
FColorDlg.Free;
FColorDlg := Nil;
end;
end;
procedure TColorComboEdit.SetCanTransparent(const Value: boolean);
begin
if Value = FCanTransparent then exit;
FCanTransparent := Value;
if not FCanTransparent and (ColorValue = clNone) then ColorValue := clBlack;
PopulateList;
end;
initialization
CustomColors := TStringList.Create;
finalization
CustomColors.Free;
CustomColors := Nil;
end.
|
unit DUnitTestRunner;
interface
uses
System.SysUtils,
TextTestRunner,
{$IFDEF CLR}
{$IF RTLVersion <= 20.00} // RS 2009 or earlier
NGuiTestRunner,
{$ENDIF}
{$ENDIF}
{$IFDEF MSWINDOWS}
{$IFNDEF NEXTGEN}
Vcl.Forms,
GuiTestRunner,
{$ENDIF NEXTGEN}
{$ENDIF}
TestFramework;
procedure RunRegisteredTests;
implementation
procedure RunRegisteredTests;
begin
{$IFDEF MSWINDOWS}
{$IFNDEF NEXTGEN}
Application.Initialize;
{$ENDIF NEXTGEN}
{$ENDIF}
if IsConsole then
begin
{$IFNDEF NEXTGEN}
with TextTestRunner.RunRegisteredTests do
Free;
{$ELSE NEXTGEN}
TextTestRunner.RunRegisteredTests
{$ENDIF NEXTGEN}
end
else
begin
{$IFDEF CLR}
{$IF RTLVersion <= 20.00} // RS 2009 or earlier
NGuiTestRunner.RunRegisteredTests;
{$ELSE}
Assert(False, 'DotNet unit test not supported');
{$ENDIF}
{$ENDIF}
{$IFDEF MSWINDOWS}
{$IFNDEF NEXTGEN}
GuiTestRunner.RunRegisteredTests;
{$ENDIF NEXTGEN}
{$ENDIF}
end;
end;
end.
|
unit U_Param_Mod;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, U_ParamReadWrite, StdCtrls, Buttons;
type
TF_Param_Mod = class(TF_ParamReadWrite)
btn_read: TBitBtn;
btn_write: TBitBtn;
chk_plc_frequency: TCheckBox;
cbb_plc_frequency: TComboBox;
chk_version: TCheckBox;
edt_version: TEdit;
chk_version_plc: TCheckBox;
edt_version_plc: TEdit;
btn_stop_plc: TBitBtn;
btn_resume_plc: TBitBtn;
chk_plcnode_count: TCheckBox;
edt_plcnode_count: TEdit;
chk_all: TCheckBox;
chk_rt_mode: TCheckBox;
cbb_rt_mode: TComboBox;
grp1: TGroupBox;
lbl1: TLabel;
lbl2: TLabel;
lbl3: TLabel;
cbb_meter_protocol: TComboBox;
edt_meter_no: TEdit;
edt_read_energy: TEdit;
btn_read_meter_energy: TBitBtn;
grp2: TGroupBox;
lbl4: TLabel;
lbl5: TLabel;
cbb_meter_protocol_sn: TComboBox;
edt_meter_sn_start: TEdit;
btn_read_meter_energy_by_sn: TBitBtn;
lbl6: TLabel;
edt_meter_sn_end: TEdit;
lbl7: TLabel;
edt_success: TEdit;
lbl8: TLabel;
edt_failed: TEdit;
lbl9: TLabel;
edt_DI: TEdit;
procedure btn_readClick(Sender: TObject);
procedure btn_writeClick(Sender: TObject);
procedure btn_stop_plcClick(Sender: TObject);
procedure btn_resume_plcClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure chk_allClick(Sender: TObject);
procedure btn_read_meter_energyClick(Sender: TObject);
procedure btn_read_meter_energy_by_snClick(Sender: TObject);
procedure cbb_meter_protocol_snChange(Sender: TObject);
private
{ Private declarations }
function SendFrame_645(Sender: TObject; ctrl:Byte; DI:LongWord; pData:PByte=nil; datalen:Integer=0):Boolean;override;
function SendFrame_645_2(Sender: TObject; ctrl:Byte; DI:LongWord; pData:PByte=nil; datalen:Integer=0):Boolean;virtual;
public
{ Public declarations }
end;
var
F_Param_Mod: TF_Param_Mod;
implementation
uses U_Main, U_Operation, U_Protocol, U_Protocol_645, U_MyFunction;
{$R *.dfm}
type TFreType = (ftOld, ftNew);
const g_fre_type: TFreType = ftOld;
//const g_fre_type: TFreType = ftNew;
function TF_Param_Mod.SendFrame_645(Sender: TObject; ctrl:Byte; DI:LongWord; pData:PByte=nil; datalen:Integer=0):Boolean;
var i,sendcounter:Integer;
p:PByte;
dataUnit:array[0..255]of Byte;
begin
Result := False;
O_ProTx_645.MakeFrame_645(ctrl, DI, pData, datalen);
case ctrl of
ctrl_read_97,
ctrl_write_97:
dataUnit[0] := 1; //规约类型
ctrl_read_07,
ctrl_write_07:
dataUnit[0] := 2; //规约类型
else
dataUnit[0] := 3; //规约类型
end;
dataUnit[1] := 0; //从节点附属节点数量n
dataUnit[2] := O_ProTx_645.GetFrameLen(); //报文长度L
MoveMemory(@dataUnit[3], O_ProTx_645.GetFrameBuf(), O_ProTx_645.GetFrameLen());
MakeFrame(AFN_ROUTER_TRANS, F1, @dataUnit[0],O_ProTx_645.GetFrameLen()+3);
if Sender is TCheckBox then TCheckBox(Sender).Font.Color := clBlack;
if Sender is TButton then TButton(Sender).Font.Color :=clBlack;
if F_Main.SendDataAuto()
and WaitForResp(Sender,AFN_ROUTER_TRANS,F1)
and O_ProRx_645.CheckFrame(GetDataUnit(), GetDataUnitLen())
and O_ProRx_645.IsRespOK()
then
begin
m_pData := O_ProRx_645.GetDataUnit();
m_nLen := O_ProRx_645.GetDataUnitLen();
m_data := 0;
p := m_pData;
for i:=0 to m_nLen-1 do
begin
m_data := m_data or (Int64(p^ and $ff) shl (i*8)); //左移优先级比乘法还高
Inc(p);
end;
if Sender is TCheckBox then TCheckBox(Sender).Font.Color := clSucced;
if Sender is TButton then TButton(Sender).Font.Color :=clSucced;
Result := True;
end
else
begin
if Sender is TCheckBox then TCheckBox(Sender).Font.Color := clFailed;
if Sender is TButton then TButton(Sender).Font.Color :=clFailed;
end;
end;
function TF_Param_Mod.SendFrame_645_2(Sender: TObject; ctrl:Byte; DI:LongWord; pData:PByte=nil; datalen:Integer=0):Boolean;
var i,sendcounter:Integer;
p:PByte;
dataUnit:array[0..255]of Byte;
begin
Result := False;
O_ProTx_645.MakeFrame_645(ctrl, DI, pData, datalen);
case ctrl of
ctrl_read_97,
ctrl_write_97:
dataUnit[0] := 1; //规约类型
ctrl_read_07,
ctrl_write_07:
dataUnit[0] := 2; //规约类型
else
dataUnit[0] := 3; //规约类型
end;
dataUnit[1] := 0; //从节点附属节点数量n
dataUnit[2] := O_ProTx_645.GetFrameLen(); //报文长度L
MoveMemory(@dataUnit[3], O_ProTx_645.GetFrameBuf(), O_ProTx_645.GetFrameLen());
MakeFrame(AFN_ROUTER_TRANS, F213, @dataUnit[0],O_ProTx_645.GetFrameLen()+3);
if Sender is TCheckBox then TCheckBox(Sender).Font.Color := clBlack;
if Sender is TButton then TButton(Sender).Font.Color :=clBlack;
if F_Main.SendDataAuto()
and WaitForResp(Sender,AFN_ROUTER_TRANS,F1)
and O_ProRx_645.CheckFrame(GetDataUnit(), GetDataUnitLen())
and O_ProRx_645.IsRespOK()
then
begin
m_pData := O_ProRx_645.GetDataUnit();
m_nLen := O_ProRx_645.GetDataUnitLen();
m_data := 0;
p := m_pData;
for i:=0 to m_nLen-1 do
begin
m_data := m_data or (Int64(p^ and $ff) shl (i*8)); //左移优先级比乘法还高
Inc(p);
end;
if Sender is TCheckBox then TCheckBox(Sender).Font.Color := clSucced;
if Sender is TButton then TButton(Sender).Font.Color :=clSucced;
Result := True;
end
else
begin
if Sender is TCheckBox then TCheckBox(Sender).Font.Color := clFailed;
if Sender is TButton then TButton(Sender).Font.Color :=clFailed;
end;
end;
procedure TF_Param_Mod.btn_readClick(Sender: TObject);
var chk:TCheckBox;
pData2:PWORD;
pData1:PByte;
begin
TButton(Sender).Enabled := False;
g_bStop := False;
chk := chk_plc_frequency;
if chk.Checked and not g_bStop then
begin
chk.Font.Color := clBlack;
cbb_plc_frequency.ItemIndex := -1;
MakeFrame(AFN_READ_SELF,F1);
F_Main.SendDataAuto();
F_Operation.DisplayOperation(Format('抄读载波频率',[]));
if WaitForResp(chk,AFN_READ_SELF,F1) then
begin
{
FB, BB BB BB 为频率 80/120K，双扩频模式
FC, BB BB BB 为频率 80/120K，XC兼容模式
FD, CC CC CC 为频率 96/160K，双扩频模式
FA, CC CC CC 为频率 96/160K，高速模式
}
pData2 := @(GetDataUnit()^);
{
if pData2^=$BBFB then cbb_plc_frequency.ItemIndex := 0;
if pData2^=$BBFC then cbb_plc_frequency.ItemIndex := 1;
if pData2^=$CCFD then cbb_plc_frequency.ItemIndex := 2;
if pData2^=$CCFA then cbb_plc_frequency.ItemIndex := 3;
}
cbb_plc_frequency.ItemIndex := cbb_plc_frequency.Items.IndexOfObject(TObject(pData2^));
end;
end;
chk := chk_rt_mode;
if chk.Checked and not g_bStop then
begin
chk.Font.Color := clBlack;
cbb_rt_mode.ItemIndex := -1;
MakeFrame($02, F5);
F_Main.SendDataAuto();
F_Operation.DisplayOperation(Format('抄读路由运行模式',[]));
if WaitForResp(chk, $02, F5) then
begin
pData1 := @(GetDataUnit()^);
cbb_rt_mode.ItemIndex := cbb_rt_mode.Items.IndexOfObject(TObject(pData1^ and $ff));
end;
end;
chk := chk_version;
if chk.Checked and not g_bStop then
begin
chk.Font.Color := clBlack;
edt_version.Text := '';
MakeFrame($03,F1);
F_Main.SendDataAuto();
F_Operation.DisplayOperation(Format('抄读集中器模块版本号',[]));
if WaitForResp(chk,$03,F1) then
begin
pData1 := GetDataUnit();
edt_plcnode_count.Text := Format('', []);
edt_version.Text := Format('版本:%.2x%.2x,日期:%.2x-%.2x-%.2x,芯片:%s%s,厂商:%s%s',[
PByte(Integer(pData1)+8)^,
PByte(Integer(pData1)+7)^,
PByte(Integer(pData1)+6)^,
PByte(Integer(pData1)+5)^,
PByte(Integer(pData1)+4)^,
PChar(Integer(pData1)+3)^,
PChar(Integer(pData1)+2)^,
PChar(Integer(pData1)+1)^,
PChar(Integer(pData1)+0)^
]);
end;
end;
chk := chk_version_plc;
if chk.Checked and not g_bStop then
begin
chk.Font.Color := clBlack;
edt_version_plc.Text := '';
MakeFrame($03,F1,nil,0,0,True);
F_Main.SendDataAuto();
F_Operation.DisplayOperation(Format('抄读载波版本号',[]));
if WaitForResp(chk,$03,F1) then
begin
pData1 := GetDataUnit();
edt_version_plc.Text := Format('版本:%.2x%.2x,日期:%.2x-%.2x-%.2x,芯片:%s%s,厂商:%s%s',[
PByte(Integer(pData1)+8)^,
PByte(Integer(pData1)+7)^,
PByte(Integer(pData1)+6)^,
PByte(Integer(pData1)+5)^,
PByte(Integer(pData1)+4)^,
PChar(Integer(pData1)+3)^,
PChar(Integer(pData1)+2)^,
PChar(Integer(pData1)+1)^,
PChar(Integer(pData1)+0)^
]);
end;
end;
chk := chk_plcnode_count;
if chk.Checked and not g_bStop then
begin
chk.Font.Color := clBlack;
edt_plcnode_count.Text := '';
MakeFrame($10,F1);
F_Main.SendDataAuto();
F_Operation.DisplayOperation(Format('抄读载波节点数量',[]));
if WaitForResp(chk,$10,F1) then
begin
pData2 := @(GetDataUnit()^);
edt_plcnode_count.Text := Format('%d',[pData2^]);
end;
end;
TButton(Sender).Enabled := True;
end;
procedure TF_Param_Mod.btn_writeClick(Sender: TObject);
var chk:TCheckBox;
buf:array[0..63]of Byte;
p:Integer;
begin
TButton(Sender).Enabled := False;
g_bStop := False;
chk := chk_plc_frequency;
if chk.Checked and not g_bStop then
begin
chk.Font.Color := clBlack;
p := 0;
{
if cbb_plc_frequency.ItemIndex=0 then
begin
buf[p] := $FB; Inc(p);
buf[p] := $BB; Inc(p);
end
else if cbb_plc_frequency.ItemIndex=1 then
begin
buf[p] := $FC; Inc(p);
buf[p] := $BB; Inc(p);
end
else if cbb_plc_frequency.ItemIndex=2 then
begin
buf[p] := $FD; Inc(p);
buf[p] := $CC; Inc(p);
end
else if cbb_plc_frequency.ItemIndex=3 then
begin
buf[p] := $FA; Inc(p);
buf[p] := $CC; Inc(p);
end;
}
if cbb_plc_frequency.ItemIndex>=0 then
begin
(PWORD(@buf[p]))^ := Integer(cbb_plc_frequency.Items.Objects[cbb_plc_frequency.ItemIndex]); Inc(p, 2);
end;
if p>0 then
begin
MakeFrame(AFN_WRITE_SELF,F1,@buf[0],p);
F_Main.SendDataAuto();
F_Operation.DisplayOperation(Format('设置载波频率',[]));
//WaitForResp(chk,AFN_WRITE_SELF,F1);
WaitForResp(chk,AFN_CONFIRM,F1);
end
else
begin
MyMessageBox(Handle,'请选择载波频率！','提示',MB_OK or MB_ICONINFORMATION);
end;
end;
chk := chk_rt_mode;
if chk.Checked and not g_bStop then
begin
chk.Font.Color := clBlack;
p := 0;
if cbb_rt_mode.ItemIndex>=0 then
begin
(PByte(@buf[p]))^ := Integer(cbb_rt_mode.Items.Objects[cbb_rt_mode.ItemIndex]); Inc(p, 1);
end;
if p>0 then
begin
MakeFrame($01, F7, @buf[0], p);
F_Main.SendDataAuto();
F_Operation.DisplayOperation(Format('设置路由运行模式',[]));
WaitForResp(chk, $01, F7);
end
else
begin
MyMessageBox(Handle,'请选择路由运行模式！','提示',MB_OK or MB_ICONINFORMATION);
end;
end;
TButton(Sender).Enabled := True;
end;
procedure TF_Param_Mod.btn_stop_plcClick(Sender: TObject);
begin
TButton(Sender).Enabled := False;
g_bStop := False;
MakeFrame(AFN_CTRL_ROUTER,F2);
if F_Main.SendDataAuto()
and WaitForResp(Sender,AFN_CONFIRM,F1)
then;
TButton(Sender).Enabled := True;
end;
procedure TF_Param_Mod.btn_resume_plcClick(Sender: TObject);
begin
TButton(Sender).Enabled := False;
g_bStop := False;
MakeFrame(AFN_CTRL_ROUTER,F3);
if F_Main.SendDataAuto()
and WaitForResp(Sender,AFN_CONFIRM,F1)
then;
TButton(Sender).Enabled := True;
end;
procedure TF_Param_Mod.FormCreate(Sender: TObject);
var i:Integer;
begin
inherited;
cbb_plc_frequency.Clear;
if g_fre_type=ftOld then
begin
cbb_plc_frequency.Items.AddObject('80/120K，双扩频模式', TObject($BBFB));
cbb_plc_frequency.Items.AddObject('80/120K，XC兼容模式', TObject($BBFC));
cbb_plc_frequency.Items.AddObject('96/160K，双扩频模式', TObject($CCFD));
cbb_plc_frequency.Items.AddObject('96/160K，高速模式', TObject($CCFA));
cbb_plc_frequency.Items.AddObject('F7 高频模式', TObject($BBF7));
cbb_plc_frequency.Items.AddObject('F9 晓程模式', TObject($BBF9));
end
else
begin
cbb_plc_frequency.Items.AddObject('东软3代', TObject($BBF3));
for i:=1 to 15 do
begin
//F3, BB BB BB 东软三代
//BX, BB BB BB 东软3.5代 X:0-F
cbb_plc_frequency.Items.AddObject(Format('东软3.5代，%.2d',[i]), TObject(StrToInt( Format('xBBB%x', [i]) )));
end;
cbb_plc_frequency.ItemIndex := cbb_plc_frequency.Items.IndexOfObject(TObject($BBBA));
end;
cbb_rt_mode.Clear;
cbb_rt_mode.Items.AddObject('01H标准协议', TObject($01));
cbb_rt_mode.Items.AddObject('02H扩展路由协议', TObject($02));
cbb_rt_mode.Items.AddObject('03H东软RT-III协议', TObject($03));
cbb_meter_protocol_snChange(cbb_meter_protocol_sn);
end;
procedure TF_Param_Mod.chk_allClick(Sender: TObject);
begin
inherited;
MakeCheck(scrlbx1, TCheckBox(Sender).Checked);
end;
procedure TF_Param_Mod.btn_read_meter_energyClick(Sender: TObject);
var ret:Boolean;
meterNo:Int64;
begin
if TryStrToInt64('x'+edt_meter_no.Text, meterNo) then
begin
O_ProTx_645.SetDeviceAddr(meterNo);
end;
TButton(Sender).Enabled := False;
g_bStop := False;
edt_read_energy.Text := '';
if cbb_meter_protocol.ItemIndex=0 then
ret := SendFrame_645(Sender, ctrl_read_97, $9010)
else
ret := SendFrame_645(Sender, ctrl_read_07, $00010000);
if ret then
begin
edt_read_energy.Text := Format('%.6x.%.2x',[m_data shr 8 and $ffffff, m_data and $ff]);
end;
TButton(Sender).Enabled := True;
end;
procedure TF_Param_Mod.btn_read_meter_energy_by_snClick(Sender: TObject);
var ret:Boolean;
meterSn:Int64;
meter_sn_start:Int64;
meter_sn_end:Int64;
pData:PByte;
DI:Int64;
begin
TButton(Sender).Enabled := False;
TryStrToInt64(edt_meter_sn_start.Text, meter_sn_start);
TryStrToInt64(edt_meter_sn_end.Text, meter_sn_end);
g_bStop := False;
meterSn := meter_sn_start;
edt_success.Text := '0';
edt_failed.Text := '0';
while not g_bStop do
begin
O_ProTx_645.SetDeviceAddr(meterSn);
TryStrToInt64('x'+edt_DI.Text, DI);
if cbb_meter_protocol_sn.ItemIndex=0 then
ret := SendFrame_645_2(Sender, ctrl_read_97, DI)
else
ret := SendFrame_645_2(Sender, ctrl_read_07, DI);
if ret then
begin
if (GetAFN()=$13)and(GetFn()=F1) then
begin
pData := GetDataUnit();
Inc(pData);
if (pData^<>0) then //不超时
begin
edt_success.Text := IntToStr(StrToInt(edt_success.Text)+1);
end
else //超时
begin
edt_failed.Text := IntToStr(StrToInt(edt_failed.Text)+1);
end;
end;
end
else
begin
edt_failed.Text := IntToStr(StrToInt(edt_failed.Text)+1);
end;
Inc(meterSn);
if meterSn>meter_sn_end then Break;
end;
TButton(Sender).Enabled := True;
end;
procedure TF_Param_Mod.cbb_meter_protocol_snChange(Sender: TObject);
begin
inherited;
if cbb_meter_protocol_sn.ItemIndex=0 then
edt_DI.Text := '9010'
else
edt_DI.Text := '00010000';
end;
end.
|
{
@html(<b>)
Timer
@html(</b>)
- Copyright (c) Danijel Tkalcec
@html(<br><br>)
Thread-safe timer class,
tightly coupled with the RTC Window Handle and Thread Pool mechanisms.
@html(<br>)
This class is used internally by TRtcConnection and all its descendant classes
to implement the timeout, reconnect and restart functionality.
}
unit rtcTimer;
{$INCLUDE rtcDefs.inc}
interface
uses
rtcTrashcan,
Windows,
Messages,
SysUtils,
Classes,
rtcSyncObjs,
rtcThrPool,
rtcHWndPool,
rtcLog;
type
// @Abstract(Events used by RTC Timer)
TRtcTimerEvent = procedure of object;
{ @Abstract(RTC Timer class)
This class ensures a Thread-Safe Timer by
using the RTC Window Handle Pool and RTC Thread Pool
instead of the TTimer class implementation. }
TRtcTimer = class
private
FRunning:boolean;
FAutoDisable:boolean;
FAutoDestroy:boolean;
FHandle:HWND;
FEvent:TRtcTimerEvent;
FThr:TRtcThread;
FJob:TObject;
FInterval:Cardinal;
FNextTrigger:Cardinal;
public
// Create a Timer. To start the timer, use the @Link(Enable) method.
constructor Create(Multi_Threaded:boolean); virtual;
{ @exclude }
destructor Destroy; override;
{ Allways use Stop instead of Free or Destroy! }
class procedure Stop(me:TObject);
{ Disable the Timer }
class procedure Disable(me:TObject);
{ Enable the Timer to trigger 'Event' every 'Wait' miliseconds.
If AutoDisable is True, Timer will be automatically disabled after the event has been triggered.
If AutoDestroy is True, Timer object will be automaticaly destroyed after the event has been triggered. }
class procedure Enable(me:TObject; Wait:Cardinal; Event:TRtcTimerEvent; AutoDisable:boolean=False; AutoDestroy:boolean=False); overload;
{ Enable the Timer to post the 'Job' to Thread 'Thr' every 'Wait' miliseconds.
If AutoDisable is True, Timer will be automatically disabled after the event has been triggered.
If AutoDestroy is True, Timer object will be automaticaly destroyed after the event has been triggered. }
class procedure Enable(me:TObject; Wait:Cardinal; Thr:TRtcThread; Job:TObject; AutoDisable:boolean=False; AutoDestroy:boolean=False); overload;
{ Reset elapsed time counter.
This will make the Timer skip one upcoming event. }
class procedure Reset(me:TObject);
{ For internal use only!!!
Called by the framework to call the Event for this timer.
@exclude }
class procedure Timer(me:TObject);
end;
{ For internal use only!!!
Called by the framework to find the Timer matching the
Timer ID included in the Windows message.
@exclude }
function rtcGetTimer(ID:LongWord):TRtcTimer;
implementation
uses
memBinList;
var
TimerList:tBinList;
CS:TRtcCritSec;
procedure CloseTimerPool;
begin
CS.Enter;
try
if assigned(TimerList) then
begin
TimerList.Free;
TimerList:=nil;
end;
finally
CS.Leave;
end;
end;
function rtcStoreTimer(obj:TObject):boolean;
begin
Result:=False;
if not assigned(CS) then Exit;
CS.Enter;
try
if not assigned(TimerList) then
TimerList:=tBinList.Create(128);
if assigned(TimerList) then
if TimerList.search(longint(Obj))=0 then
begin
Result:=True;
TimerList.insert(longint(Obj), 1);
end;
finally
CS.Leave;
end;
end;
function rtcRemoveTimer(obj:TObject):boolean;
begin
Result:=False;
if not assigned(CS) then Exit;
CS.Enter;
try
if assigned(TimerList) then
if TimerList.search(longint(Obj))>0 then
begin
TimerList.remove(longint(Obj));
Result:=True;
end;
finally
CS.Leave;
end;
end;
function rtcGetTimer(ID:LongWord):TRtcTimer;
begin
Result:=nil;
if not assigned(CS) then Exit;
CS.Enter;
try
if assigned(TimerList) then
if TimerList.search(ID)>0 then
Result:=TRtcTimer(ID);
finally
if Result=nil then
CS.Leave;
end;
end;
function rtcEnterTimer(ID:LongWord):boolean;
begin
Result:=False;
if not assigned(CS) then Exit;
CS.Enter;
try
if assigned(TimerList) then
if TimerList.search(ID)>0 then
Result:=True;
finally
if not Result then CS.Leave;
end;
end;
procedure rtcLeaveTimer;
begin
if not assigned(CS) then Exit;
CS.Leave;
end;
constructor TRtcTimer.Create(Multi_Threaded:boolean);
begin
inherited Create;
FRunning:=False;
FHandle := rtcGetHWND(Multi_Threaded);
FInterval := 0;
FNextTrigger := 0;
rtcStoreTimer(self);
end;
destructor TRtcTimer.Destroy;
begin
rtcRemoveTimer(self);
if FRunning then
begin
FRunning:=False;
KillTimer(FHandle,LongWord(self));
end;
rtcReturnHWND(FHandle);
inherited Destroy;
end;
class procedure TRtcTimer.Stop(me:TObject);
begin
if rtcRemoveTimer(me) then
me.Free;
end;
class procedure TRtcTimer.Timer(me:TObject);
var
FE:TRtcTimerEvent;
TH:TRtcThread;
JO:TObject;
intimer:boolean;
begin
intimer:=True;
with TRtcTimer(me) do
try
if FRunning and (GetTickCount>=FNextTrigger) then
begin
if assigned(FEvent) then
begin
FNextTrigger:=GetTickCount + FInterval;
if FAutoDisable then
begin
FRunning:=False;
KillTimer(FHandle, LongWord(me));
end;
FE:=FEvent;
if FAutoDestroy then Free;
rtcLeaveTimer;
intimer:=False;
FE;
end
else if assigned(FThr) then
begin
FNextTrigger:=GetTickCount+FInterval;
if FAutoDisable then
begin
FRunning:=False;
KillTimer(FHandle, LongWord(me));
end;
TH:=FThr;
JO:=FJob;
if FAutoDestroy then Free;
rtcLeaveTimer;
intimer:=False;
TRtcThread.PostJob(TH, JO);
end
else // Disable ...
begin
FRunning:=False;
KillTimer(FHandle, LongWord(me));
if FAutoDestroy then Free;
end;
end;
finally
if intimer then rtcLeaveTimer;
end;
end;
class procedure TRtcTimer.Disable(me:TObject);
begin
if rtcEnterTimer(longword(me)) then
with TRtcTimer(me) do try
if FRunning then
begin
FRunning:=False;
KillTimer(FHandle, LongWord(me));
end;
finally
rtcLeaveTimer;
end;
end;
class procedure TRtcTimer.Reset(me:TObject);
begin
if rtcEnterTimer(longword(me)) then
with TRtcTimer(me) do try
if FRunning then
FNextTrigger:=GetTickCount + FInterval;
finally
rtcLeaveTimer;
end;
end;
class procedure TRtcTimer.Enable(me:TObject; Wait: Cardinal; Event: TRtcTimerEvent; AutoDisable:boolean=False; AutoDestroy:boolean=False);
begin
if rtcEnterTimer(LongWord(me)) then
with TRtcTimer(me) do try
FAutoDisable:=AutoDisable or AutoDestroy;
FAutoDestroy:=AutoDestroy;
FThr:=nil;
FEvent:=Event;
FInterval:=Wait;
FNextTrigger:=GetTickCount+Wait;
if SetTimer(FHandle, LongWord(me), Wait, nil) = 0 then
raise EOutOfResources.Create('No more timers available.')
else
FRunning:=True;
finally
rtcLeaveTimer;
end;
end;
class procedure TRtcTimer.Enable(me:TObject; Wait:Cardinal; Thr:TRtcThread; Job:TObject; AutoDisable:boolean=False; AutoDestroy:boolean=False);
begin
if rtcEnterTimer(LongWord(me)) then
with TRtcTimer(me) do try
FAutoDisable:=AutoDisable or AutoDestroy;
FAutoDestroy:=AutoDestroy;
FThr:=Thr;
FJob:=Job;
FEvent:=nil;
FInterval:=Wait;
FNextTrigger:=GetTickCount+Wait;
if SetTimer(FHandle, LongWord(me), Wait, nil) = 0 then
raise EOutOfResources.Create('No more timers available.')
else
FRunning:=True;
finally
rtcLeaveTimer;
end;
end;
function RtcTimerWindowProc(ahWnd : HWND;
auMsg : LongWord;
awParam : WPARAM;
alParam : LPARAM): Integer; stdcall;
var
Obj : TObject;
begin
if auMsg=WM_TIMER then
begin
if (awParam<>0) then
Obj:=rtcGetTimer(awParam)
else
Obj:=nil;
if (Obj<>nil) and (Obj is TRtcTimer) then
begin
try
TRtcTimer.Timer(Obj);
except
on E:Exception do
Log('WM_TIMER',E);
end;
Result := 0;
end
else
Result := DefWindowProc(ahWnd, auMsg, awParam, alParam);
end
else
Result := DefWindowProc(ahWnd, auMsg, awParam, alParam);
end;
var
RtcTimerRegistered:boolean=False;
RtcTimerWindowClass: TWndClass = (
style : 0;
lpfnWndProc : @RtcTimerWindowProc;
cbClsExtra : 0;
cbWndExtra : SizeOf(Pointer);
hInstance : 0;
hIcon : 0;
hCursor : 0;
hbrBackground : 0;
lpszMenuName : nil;
lpszClassName : 'RtcTimerWindowClass');
procedure RtcTimerUnregisterClass;
begin
if RtcTimerRegistered then
begin
Windows.UnregisterClass(RtcTimerWindowClass.lpszClassName, HInstance);
RtcTimerRegistered:=False;
end;
end;
procedure RtcTimerRegisterClass;
var
TempClass : TWndClass;
ClassRegistered : Boolean;
begin
if not RTcTimerRegistered then
begin
RtcTimerWindowClass.hInstance := HInstance;
ClassRegistered := GetClassInfo(HInstance,
RtcTimerWindowClass.lpszClassName,
TempClass);
if not ClassRegistered then
begin
if Windows.RegisterClass(RtcTimerWindowClass)=0 then
Exit;
end;
RtcTimerRegistered:=True;
end;
end;
initialization
CS:=TRtcCritSec.Create;
RTC_HWND_CLASS_NAME:=RtcTimerWindowClass.lpszClassName;
RtcTimerRegisterClass;
rtcInitMainHWND;
finalization
CloseTimerPool;
RtcTimerUnregisterClass;
rtcReleaseMainHWND;
Garbage(CS);
end.
|
(**********************************************************************************)
(* Code generated with NexusDB Enterprise Manager Data Dictionary Code Generator *)
(* *)
(* Version: 3,0101 *)
(* *)
(**********************************************************************************)
unit ncTableDefs;
interface
uses
Classes,
nxdb,
nxsdTypes,
nxsdKeyFieldEngineBase,
nxsdDataDictionary;
type
TnxcgProgressCallback =
procedure(const aTableName : String;
var aStatus : TnxTaskStatus;
var aCancel : Boolean) of object;
procedure BuildAndEvolveDatabase(aDatabase : TnxDatabase;
aProgressCallback : TnxcgProgressCallback = nil;
const aPassword : String = '');
procedure RestructureDatabase(aDatabase : TnxDatabase;
aProgressCallback : TnxcgProgressCallback = nil;
const aPassword : String = '');
procedure PackDatabase(aDatabase : TnxDatabase;
aProgressCallback : TnxcgProgressCallback = nil;
const aPassword : String = '');
function DatabaseVersion: Cardinal;
function DatabaseVersionStr: String;
function GetTableDictionary(aDatabase : TnxDatabase; const aTableName : String): TnxDataDictionary;
// procedure GetTableNames(aSL: TStrings);
// function GetTablePrimaryKey(aTable: String): String;
type
TnxcgCreateDictCallback = function(aDatabase : TnxDatabase): TnxDataDictionary;
TncTableInfo = class
public
TableName : String;
Backup : Byte;
ID_Name : String;
ID_IxName : String;
UID_Name : String;
UID_IxName : String;
Callback : TnxcgCreateDictCallback;
TableID : Byte;
function Bkp: Boolean;
constructor Create(
aTableName : String;
aCallback : TnxcgCreateDictCallback;
aTableID : Byte;
aBackup : Byte;
aID_Name : String;
aID_IxName : String;
aUID_Name : String;
aUID_IxName : String);
end;
TncTableManager = class
private
FItems: TList;
function GetByName(aName: String): TncTableInfo;
function GetByID(aID: Byte): TncTableInfo;
function GetItem(aIndex: Integer): TncTableInfo;
public
constructor Create;
destructor Destroy; override;
procedure Add(
aTableName : String;
aCallback : TnxcgCreateDictCallback;
aTableID : Byte;
aBackup : Byte = 1;
aID_Name : String = '';
aID_IxName : String = '';
aUID_Name : String = '';
aUID_IxName : String = '');
function Count: Integer;
procedure GetTableNames(sl: TStrings);
property Items[aIndex: Integer]: TncTableInfo read GetItem;
property Tables[aName: String]: TncTableInfo read GetByName; default;
property Tables[aID: Byte]: TncTableInfo read GetByID; default;
end;
const
sEncPass = 'CEWk4jhsad3f';
var
gTables : TncTableManager;
gEvolvingTables : Boolean = False;
gEvolvingTableName : String = '';
implementation
uses
{$IFDEF NXWINAPI}nxWinAPI{$ELSE}Windows{$ENDIF},
Math,
SysUtils,
StrUtils,
Variants,
DBCommon,
nxllTypes,
nxllBde,
nxllException,
nxllWideString,
nxsdConst,
nxsdDataDictionaryStrings,
nxsdDataDictionaryRefInt,
nxsdDataDictionaryFulltext,
nxsdFilterEngineSimpleExpression,
nxsdFilterEngineSql,
nxsdServerEngine,
nxsdTableMapperDescriptor, ncClassesBase, kwicDescriptor,
kwicEngine,
ncVersionInfo,
ncsFrmBackup, ncDebug;
threadvar
aCopiouArqs : Boolean;
// ConvUnid
function __ConvUnid(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('A', '', nxtNullString, 10, 0, False);
AddField('B', '', nxtNullString, 10, 0, False);
AddField('Fator', '', nxtDouble, 0, 0, False);
AddField('Mult', '', nxtBoolean, 0, 0, False);
AddField('Universal', '', nxtBoolean, 0, 0, False);
AddField('Produto', '', nxtWord32, 10, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IABUniv', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('A'));
Add(GetFieldFromName('B'));
Add(GetFieldFromName('Universal'));
Add(GetFieldFromName('Produto'));
end;
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// ProdFor
function __xmls_compra(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('ChaveNFE', '', nxtNullString, 44, 0, False);
AddField('xml', '', nxtBlobMemo, 10, 0, False);
AddField('Tran', '', nxtWord32, 10, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IChaveNFE', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ChaveNFE'));
with AddIndex('ITran', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Tran'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __SolicitacoesSped(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('dataIni', '', nxtDate, 0, 0, False);
AddField('dataFim', '', nxtDate, 0, 0, False);
AddField('dataInclusao', '', nxtDateTime, 0, 0, False);
AddField('dataConclusao', '', nxtDateTime, 0, 0, False);
AddField('usuario', '', nxtNullString, 50, 0, False);
AddField('cnpj_emissor', '', nxtNullString, 25, 0, False);
AddField('status', '', nxtWord32, 0, 0, False);
AddField('resultado', '', nxtBlobMemo, 10, 0, False);
AddField('spedGerado', '', nxtBlobMemo, 10, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IStatus', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('status'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// ProdFor
function __DadosFiscais(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('ChaveNFE', '', nxtNullString, 44, 0, False);
AddField('NomeFor', '', nxtNullString, 50, 0, False);
AddField('nItem', '', nxtWord16, 0, 0, False);
AddField('Produto', '', nxtWord32, 0, 0, False);
AddField('DataNF', '', nxtDateTime, 0, 0, False);
AddField('CNPJFor', '', nxtNullString, 19, 0, False);
AddField('Quant', '', nxtDouble, 0, 0, False);
AddField('CustoU', '', nxtCurrency, 0, 0, False);
AddField('QuantOrig', '', nxtDouble, 0, 0, False);
AddField('DadosFiscais', '', nxtBlobMemo, 10, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IChaveNFEnItem', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('ChaveNFE'));
Add(GetFieldFromName('nItem'));
end;
with AddIndex('ICNPJForProdutoDataNF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('CNPJFor'));
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('DataNF'));
end;
with AddIndex('IProdutoDataNF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('DataNF'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __cfop_dev(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('cfop_compra', '', nxtWord16, 5, 0, False);
AddField('cfop', '', nxtWord16, 5, 0, False);
AddField('natop', '', nxtWideString, 60, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('Icfop_compra', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('cfop_compra'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __Sped_C190(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Tran', '', nxtWord32, 10, 0, False);
AddField('CST_ICMS', '', nxtNullString, 5, 0, False);
AddField('CFOP', '', nxtNullString, 8, 0, False);
AddField('ALIQ_ICMS', '', nxtCurrency, 8, 2, False);
AddField('VL_OPER', '', nxtCurrency, 8, 2, False);
AddField('VL_BC_ICMS', '', nxtCurrency, 8, 2, False);
AddField('VL_ICMS', '', nxtCurrency, 8, 2, False);
AddField('VL_BC_ICMS_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_ICMS_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_RED_BC', '', nxtCurrency, 8, 2, False);
AddField('VL_IPI', '', nxtCurrency, 8, 2, False);
AddField('COD_OBS', '', nxtNullString, 6, 0, False);
end;
//
with EnsureIndicesDescriptor do begin
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('ITranCfopCstAliq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tran'));
Add(GetFieldFromName('CFOP'));
Add(GetFieldFromName('CST_ICMS'));
Add(GetFieldFromName('ALIQ_ICMS'));
end;
with AddIndex('ITran', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Tran'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __Sped_E210(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Tran', '', nxtWord32, 6, 0, False);
AddField('ID_UF', '', nxtWord32, 5, 0, False);
AddField('DT_APURACAO', '', nxtDate, 0, 0, False);
AddField('IND_MOV_ST', '', nxtCurrency, 8, 0, False);
AddField('VL_SLD_CRED_ANT_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_DEVOL_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_RESSARC_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_OUT_CRED_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_AJ_CREDITOS_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_RETENCAO_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_OUT_DEB_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_AJ_DEBITOS_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_SLD_DEV_ANT_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_DEDUCOES_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_ICMS_RECOL_ST', '', nxtCurrency, 8, 2, False);
AddField('VL_SLD_CRED_ST_TRAN', '', nxtCurrency, 8, 2, False);
AddField('DEB_ESP_ST', '', nxtCurrency, 8, 2, False);
end;
//
with EnsureIndicesDescriptor do begin
with AddIndex('IdUFDataApuracao', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('ID_UF'));
Add(GetFieldFromName('DT_APURACAO'));
end;
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __movEst_Sped(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Tran', '', nxtWord32, 10, 0, False);
AddField('MovEst', '', nxtWord32, 10, 0, False);
AddField('Produto', '', nxtWord32, 10, 0, False);
AddField('Data', '', nxtDate, 0, 0, False);
AddField('Num_Item', '', nxtWord32, 10, 0, False);
AddField('Num_Item_XML', '', nxtWord32, 10, 0, False);
AddField('Cod_Item', '', nxtNullString, 15, 0, False);
AddField('Descr_compl', '', nxtNullString, 100, 0, False);
AddField('QTD', '', nxtCurrency, 8, 2, False);
AddField('Unid', '', nxtNullString, 6, 0, False);
AddField('vl_item', '', nxtCurrency, 8, 2, False);
AddField('vl_desc', '', nxtCurrency, 8, 2, False);
AddField('ind_mov', '', nxtNullString, 5, 0, False);
AddField('cst_icms', '', nxtNullString, 5, 0, False);
AddField('cfop', '', nxtNullString, 5, 0, False);
AddField('cod_nat', '', nxtNullString, 5, 0, False);
AddField('vl_bc_icms', '', nxtCurrency, 8, 2, False);
AddField('aliq_icms', '', nxtCurrency, 8, 2, False);
AddField('vl_icms', '', nxtCurrency, 8, 2, False);
AddField('vl_bc_icms_st', '', nxtCurrency, 8, 2, False);
AddField('aliq_st', '', nxtCurrency, 8, 2, False);
AddField('vl_icms_st', '', nxtCurrency, 8, 2, False);
AddField('ind_apur', '', nxtChar, 1, 0, False);
AddField('cst_ipi', '', nxtNullString, 2, 0, False);
AddField('cod_enq', '', nxtNullString, 3, 0, False);
AddField('vl_bc_ipi', '', nxtCurrency, 8, 2, False);
AddField('aliq_ipi', '', nxtCurrency, 8, 2, False);
AddField('vl_ipi', '', nxtCurrency, 8, 2, False);
AddField('cst_pis', '', nxtCurrency, 8, 2, False);
AddField('vl_bc_pis', '', nxtCurrency, 8, 2, False);
AddField('aliq_pis_perc', '', nxtCurrency, 8, 2, False);
AddField('quant_bc_pis', '', nxtCurrency, 8, 2, False);
AddField('aliq_pis', '', nxtCurrency, 8, 2, False);
AddField('vl_pis', '', nxtCurrency, 8, 2, False);
AddField('cst_cofins', '', nxtCurrency, 8, 2, False);
AddField('vl_bc_cofins', '', nxtCurrency, 8, 2, False);
AddField('aliq_cofins_perc', '', nxtCurrency, 8, 2, False);
AddField('quant_bc_cofins', '', nxtCurrency, 8, 2, False);
AddField('aliq_cofins', '', nxtCurrency, 8, 2, False);
AddField('vl_cofins', '', nxtCurrency, 8, 2, False);
AddField('cod_cta', '', nxtNullString, 20, 0, False);
end;
//
with EnsureIndicesDescriptor do begin
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('MovEstProd', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('MovEst'));
Add(GetFieldFromName('Produto'));
end;
with AddIndex('TranProd', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tran'));
Add(GetFieldFromName('Produto'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// ProdFor
function __ProdFor(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Produto', '', nxtWord32, 10, 0, False);
AddField('Fornecedor', '', nxtWord32, 10, 0, False);
AddField('Pos', '', nxtWord16, 5, 0, False);
AddField('Ref', '', nxtNullString, 20, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IProdFor', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('Fornecedor'));
end;
with AddIndex('IForRef', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
Add(GetFieldFromName('Ref'));
end;
with AddIndex('IProdPos', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('Pos'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// LinkXML
function __LinkXML(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Produto', '', nxtWord32, 10, 0, False);
AddField('Fornecedor', '', nxtWord32, 10, 0, False);
AddField('Link', '', nxtNullString, 20, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IForLink', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
Add(GetFieldFromName('Link'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// brtrib
function __brtrib(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtWord16, 5, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Nome', '', nxtNullString, 50, 0, False);
AddField('Origem', '', nxtByte, 2, 0, False);
AddField('CST', '', nxtWord16, 3, 0, False);
AddField('CSOSN', '', nxtWord16, 5, 0, False);
AddField('ICMS', '', nxtDouble, 5, 5, False);
AddField('ICMSSt', '', nxtBlobMemo, 0, 0, False);
AddField('Padrao', '', nxtBoolean, 0, 0, False);
AddField('NFE_CredIcms', '', nxtBoolean, 0, 0, False);
AddField('CFOP_nfce', '', nxtWord16, 5, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('INome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Nome'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// CFOP
function __CFOP(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('Codigo', '', nxtWord16, 5, 0, False);
AddField('Descricao', '', nxtBLOBMemo, 0, 0, False);
AddField('Entrada', '', nxtBoolean, 0, 0, False);
AddField('Tipo', '', nxtByte, 3, 0, False);
AddField('NFCe', '', nxtBoolean, 0, 0, False);
with AddField('Ordem', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 255;
AddField('CSOSN', '', nxtWord16, 5, 0, False);
AddField('Origem', '', nxtWord16, 5, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('ICodigo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Codigo'));
with AddIndex('ITipoCodigo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('Codigo'));
end;
with AddIndex('IOrdemCodigo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Ordem'));
Add(GetFieldFromName('Codigo'));
end;
with AddIndex('ITipoCodigoOrigem', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('Origem'));
Add(GetFieldFromName('Codigo'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// MunBr
function __MunBr(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('UF', '', nxtNullString, 2, 0, False);
AddField('Nome', '', nxtNullString, 40, 0, False);
AddField('Codigo', '', nxtNullString, 7, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IUFNome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('UF'));
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416;
Flags := $00001000;
UseStringSort := True;
end;
end;
end;
with AddIndex('IUFCodigo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('UF'));
Add(GetFieldFromName('Codigo'));
end;
with AddIndex('ICodigo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Codigo'));
with AddIndex('INome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416;
Flags := $00001000;
UseStringSort := True;
end;
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// NFCONFIG
function __NFCONFIG(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
with AddField('EmitirNFCe', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('nfe_pedido_na_obs', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('Tipo', '', nxtByte, 5, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := nfcfg_nfce;
with AddField('RemoverNFCe', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('UsarPautaMaiorMVA', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('EmitirNFE', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('CertificadoDig', '', nxtNullString, 300, 0, False);
AddField('sat_modelo', '', nxtByte, 5, 0, False);
AddField('sat_config', '', nxtNullString, 50, 0, False);
AddField('sat_esq', '', nxtByte, 5, 0, False);
AddField('nfe_permite_cred_icms', '', nxtBoolean, 0, 0, False);
AddField('nfe_perc_cred_icms', '', nxtDouble, 0, 0, False);
AddField('Contabilidade', '', nxtNullString, 19, 0, False);
AddField('exigir_peso_vol', '', nxtBoolean, 0, 0, False);
AddField('enviar_peso_vol_def', '', nxtBoolean, 0, 0, False);
with AddField('auto_calc_peso_def', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('nfe_venda', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('tipodoc_padrao', '0-selecionar, 1-cupom, 2-nf-e', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
AddField('PinCert', '', nxtNullString, 50, 0, False);
with AddField('DependNFCEOk', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('DependSATOk', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('DependNFEOk', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('TipoCert', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
AddField('AutoPrintNFCe', '', nxtBoolean, 0, 0, False);
with AddField('CRT', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 1;
AddField('NCM_Padrao', '', nxtNullString, 8, 0, False);
AddField('Trib_Padrao', '', nxtWord16, 0, 0, False);
AddField('MostrarDadosNFE', '', nxtBoolean, 0, 0, False);
AddField('ModeloNFE', '', nxtNullString, 5, 0, False);
AddField('ModeloNFCe', '', nxtNullString, 5, 0, False);
with AddField('SerieNFCe', '', nxtNullString, 5, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := '1';
with AddField('SerieNFe', '', nxtNullString, 5, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := '1';
AddField('NomeDllSat', '', nxtNullString, 200, 0, False);
AddField('SignACSat', '', nxtNullString, 344, 0, False);
AddField('CodigoAtivacao', '', nxtNullString, 50, 0, False);
with AddField('AssociarSignAC', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('InicioNFe', '', nxtWord32, 10, 0, False);
AddField('InicioNFCe', '', nxtWord32, 10, 0, False);
AddField('RazaoSocial', '', nxtNullString, 100, 0, False);
AddField('NomeFantasia', '', nxtNullString, 50, 0, False);
AddField('CNPJ', '', nxtNullString, 20, 0, False);
AddField('IE', '', nxtNullString, 20, 0, False);
AddField('End_Logradouro', '', nxtNullString, 100, 0, False);
AddField('End_Numero', '', nxtNullString, 10, 0, False);
AddField('End_Complemento', '', nxtNullString, 20, 0, False);
AddField('End_Bairro', '', nxtNullString, 40, 0, False);
AddField('End_UF', '', nxtNullString, 2, 0, False);
AddField('End_CEP', '', nxtNullString, 9, 0, False);
AddField('End_Municipio', '', nxtNullString, 50, 0, False);
AddField('End_CodMun', '', nxtNullString, 7, 0, False);
AddField('End_CodUF', '', nxtByte, 3, 0, False);
AddField('Telefone', '', nxtNullString, 20, 0, False);
with AddField('tpAmb', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 2;
with AddField('tpAmbNFE', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 2;
AddField('CSC', '', nxtNullString, 100, 0, False);
AddField('IdCSC', '', nxtNullString, 10, 0, False);
with AddField('PedirEmail', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 1;
with AddField('PedirCPF', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 1;
AddField('FromEmail', '', nxtNullString, 100, 0, False);
AddField('AssuntoEmail', '', nxtNullString, 100, 0, False);
AddField('FromName', '', nxtNullString, 50, 0, False);
AddField('CorpoEmail', '', nxtBlobMemo, 0, 0, False);
AddField('ModeloNFCe_Email', '', nxtGuid, 0, 0, False);
AddField('ModeloSAT_Email', '', nxtGuid, 0, 0, False);
AddField('ModeloNFE_Email', '', nxtGuid, 0, 0, False);
AddField('urls_qrcode_hom', '', nxtBLOBMemo, 0, 0, False);
AddField('urls_qrcode_prod', '', nxtBLOBMemo, 0, 0, False);
AddField('urls_consulta', '', nxtBLOBMemo, 0, 0, False);
AddField('config_nfe', '', nxtBlobMemo, 0, 0, False);
AddField('ObsFisco', '', nxtBLOBMemo, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// NFE
function __NFE(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
with AddField('UID', '', nxtGUID, 0, 0, False) do
with AddDefaultValue(TnxAutoGuidDefaultValueDescriptor) as TnxAutoGuidDefaultValueDescriptor do
ApplyAt := [aaClient, aaServer];
AddField('NumSeq', '', nxtAutoInc, 10, 0, False);
AddField('Modelo', '', nxtNullString, 5, 0, False);
AddField('Serie', '', nxtNullString, 5, 0, False);
AddField('Numero', '', nxtWord32, 4, 0, False);
AddField('TicksConsulta', '', nxtWord32, 0, 0, False);
AddField('Chave', '', nxtNullString, 44, 0, False);
AddField('ChaveCont', '', nxtNullString, 44, 0, False);
with AddField('ConsultouChave', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('Entrada', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('TipoDoc', 'NFCe=1, SAT=2, NFe=3', nxtByte, 2, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
with AddField('DataHora', '', nxtDateTime, 0, 0, False) do
AddDefaultValue(TnxCurrentDateTimeDefaultValueDescriptor);
AddField('CFOP', '', nxtWord16, 4, 0, False);
AddField('Tran', '', nxtGUID, 0, 0, False);
AddField('Recibo', '', nxtNullString, 20, 0, False);
AddField('Protocolo', '', nxtNullString, 20, 0, False);
AddField('Contingencia', '', nxtBoolean, 0, 0, False);
AddField('Status', '', nxtByte, 3, 0, False);
AddField('tpAmb', '', nxtByte, 3, 0, False);
AddField('StatusNF', '', nxtInt32, 5, 0, False);
AddField('XMLdest', '', nxtBLOBMemo, 0, 0, False);
AddField('XMLret', '', nxtBLOBMemo, 0, 0, False);
AddField('XMLtrans', '', nxtBlobMemo, 0, 0, False);
AddField('XMLtransCont', '', nxtBlobMemo, 0, 0, False);
AddField('xMotivo', '', nxtBlobMemo, 0, 0, False);
AddField('LogEnvio', '', nxtBlobMemo, 0, 0, False);
AddField('LogRec', '', nxtBlobMemo, 0, 0, False);
AddField('ProtocoloCanc', '', nxtNullString, 20, 0, False);
AddField('StatusCanc', '', nxtByte, 0, 0, False);
AddField('StatusCancNF', '', nxtInt32, 0, 0, False);
AddField('JustCanc', '', nxtBlobMemo, 0, 0, False);
AddField('xMotivoCanc', '', nxtBlobMemo, 0, 0, False);
AddField('xmlRetCanc', '', nxtBlobMemo, 0, 0, False);
AddField('CanceladoPor', '', nxtNullString, 30, 0, False);
AddField('CanceladoEm', '', nxtDateTime, 0, 0, False);
AddField('StatusInut', '', nxtByte, 0, 0, False);
AddField('StatusInutNF', '', nxtInt32, 0, 0, False);
AddField('ProtocoloInut', '', nxtNullString, 20, 0, False);
AddField('xMotivoInut', '', nxtBlobMemo, 0, 0, False);
AddField('xmlRetInut', '', nxtBlobMemo, 0, 0, False);
AddField('CPF', '', nxtNullString, 14, 0, False);
AddField('Email', '', nxtNullString, 100, 0, False);
AddField('IncluidoEm', '', nxtDateTime, 0, 0, False);
AddField('EmitidoEm', '', nxtDateTime, 0, 0, False);
AddField('ContingenciaEM', '', nxtDateTime, 0, 0, False);
AddField('Valor', '', nxtCurrency, 20, 4, False);
AddField('TotalNF', '', nxtCurrency, 20, 4, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('INumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('NumSeq'));
with AddIndex('IChave', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Chave'));
with AddIndex('ITran', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tran'));
Add(GetFieldFromName('TipoDoc'))
end;
with AddIndex('ITipoDocIncluidoEm', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('IncluidoEm'));
end;
with AddIndex('ITipoDoctpAmbStatusInut', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('tpAmb'));
Add(GetFieldFromName('StatusInut'));
end;
with AddIndex('ITipoDocConsulta', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('tpAmb'));
Add(GetFieldFromName('ConsultouChave'));
Add(GetFieldFromName('StatusNF'));
end;
with AddIndex('ITipoDocStatusCancNumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('StatusCanc'));
Add(GetFieldFromName('NumSeq'));
end;
with AddIndex('IStatusCancNumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('StatusCanc'));
Add(GetFieldFromName('NumSeq'));
end;
with AddIndex('ITipoDocNumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('NumSeq'));
end;
with AddIndex('ITipoDoctpAmbModeloSerieNumero', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('tpAmb'));
Add(GetFieldFromName('Modelo'));
Add(GetFieldFromName('Serie'));
Add(GetFieldFromName('Numero'));
end;
with AddIndex('ITipoDoctpAmbStatus', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('tpAmb'));
Add(GetFieldFromName('Status'));
Add(GetFieldFromName('TicksConsulta'));
end;
with AddIndex('ITipoDocStatusNumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('Status'));
Add(GetFieldFromName('NumSeq'));
end;
with AddIndex('ITipoDoctpAmbDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('tpAmb'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ITipoDocDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
begin
Add(GetFieldFromName('TipoDoc'));
Add(GetFieldFromName('DataHora'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __Terminal(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('TermID', '', nxtGUID, 0, 0, False);
AddField('Nome', '', nxtNullString, 50, 0, False);
AddField('Opcoes', '', nxtBLOBMemo, 0, 0, False);
AddField('RECVER', '', nxtWord32, 9, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('ITermID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('TermID'));
with AddIndex('INome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Nome'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// CCe
function __CCe(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('NumSeq', '', nxtAutoInc, 10, 0, False);
AddField('Chave', '', nxtNullString, 44, 0, False);
with AddField('DataHora', '', nxtDateTime, 0, 0, False) do
AddDefaultValue(TnxCurrentDateTimeDefaultValueDescriptor);
AddField('tran_uid', '', nxtGUID, 0, 0, False);
AddField('tran_id', '', nxtWord32, 0, 0, False);
AddField('nfe_serie', '', nxtNullString, 5, 0, False);
AddField('nfe_numero', '', nxtWord32, 0, 0, False);
AddField('tpAmbNFE', '', nxtByte, 3, 0, False);
AddField('Protocolo', '', nxtNullString, 20, 0, False);
AddField('Texto', '', nxtBLOBMemo, 0, 0, False);
AddField('Status', '', nxtByte, 3, 0, False);
AddField('StatusCCE', '', nxtInt32, 5, 0, False);
AddField('XMLdest', '', nxtBLOBMemo, 0, 0, False);
AddField('XMLret', '', nxtBLOBMemo, 0, 0, False);
AddField('xMotivo', '', nxtBLOBMemo, 0, 0, False);
AddField('LogEnvio', '', nxtBLOBMemo, 0, 0, False);
AddField('LogRec', '', nxtBLOBMemo, 0, 0, False);
AddField('Usuario', '', nxtNullString, 20, 20, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IChaveNumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Chave'));
Add(GetFieldFromName('NumSeq'));
end;
with AddIndex('IChaveStatus', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Chave'));
Add(GetFieldFromName('Status'));
end;
with AddIndex('IStatusNumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Status'));
Add(GetFieldFromName('NumSeq'));
end;
with AddIndex('IDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('DataHora'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('INumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('NumSeq'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// NCM
function __NCM(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('NCM', '', nxtNullString, 8, 0, False);
AddField('Ex', '', nxtNullString, 2, 0, False);
AddField('Descricao', '', nxtNullString, 100, 0, False);
AddField('ImpostoFed_Imp', '', nxtDouble, 0, 0, False);
AddField('ImpostoFed_Nac', '', nxtDouble, 0, 0, False);
AddField('ImpostoEst', '', nxtDouble, 0, 0, False);
AddField('ImpostoMun', '', nxtDouble, 0, 0, False);
AddField('RECVER', '', nxtWord32, 9, 0, False);
end;
with EnsureIndicesDescriptor do
with AddIndex('IID', 0, idNull), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with IndicesDescriptor.AddIndex('ISuperBusca', 0, True, '', TnxMainIndexTokenKeyDescriptor) do
with (KeyDescriptor as TnxMainIndexTokenKeyDescriptor) do
MaxTokenSize := 50; // set max key length here
with EnsureFulltextDescriptor(Result) do
with AddFullTextIndex('full_superbusca') do begin
// N.B. you can add extractors for as many fields as you like here:
AddFieldTokenExtractor(FieldsDescriptor.GetFieldFromName('Descricao'), '', TnxKwicTokenExtractorDescriptor);
with TnxMainIndexTokenIndexDescriptor(AddTokenIndex('ISuperBusca', TnxMainIndexTokenIndexDescriptor)) do begin
MainIndexNumber := 2;
IgnoreCase := True;
{ with AddLocaleDescriptor do begin
Locale := $00000416;
Flags := $00001000;
UseStringSort := True;
end; }
end;
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IDescricao', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Descricao'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416;
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('INCM', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('NCM'));
Add(GetFieldFromName('Ex'));
end;
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __Card(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('card_id', '', nxtAutoInc, 10, 0, False);
AddField('card_id_ref', '', nxtWord32, 0, 0, False);
AddField('method', '', nxtByte, 0, 0, False);
with AddField('card_array', '', nxtByte, 0, 0, False) do // 0 - criar json, 1- enviar, 2-enviado
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := card_array_cards;
with AddField('status', '', nxtByte, 0, 0, False) do // 0 - criar json, 1- enviar, 2-enviado
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := card_status_criar_json;
AddField('created_on', '', nxtDateTime, 0, 0, False);
AddField('type', '', nxtByte, 0, 0, False);
AddField('id_ref', '', nxtWord32, 0, 0, False);
AddField('json', '', nxtBlobWideMemo, 0, 0, False);
AddField('json_dif', '', nxtBlobWideMemo, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_card_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('card_id'));
with AddIndex('I_status_method_card_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('status'));
Add(GetFieldFromName('method'));
Add(GetFieldFromName('card_id'));
end;
with AddIndex('I_card_array_status_method_card_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('card_array'));
Add(GetFieldFromName('status'));
Add(GetFieldFromName('method'));
Add(GetFieldFromName('card_id'));
end;
with AddIndex('I_type_id_ref_status', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('type'));
Add(GetFieldFromName('id_ref'));
Add(GetFieldFromName('status'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __bk_process(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('id', '', nxtAutoInc, 10, 0, False);
AddField('method', '', nxtByte, 0, 0, False);
AddField('table', '', nxtByte, 0, 0, False);
AddField('status', '', nxtByte, 0, 0, False); // 0 - criar json, 1 - enviar, 2 - enviado
AddField('updated_on', '', nxtDateTime, 0, 0, False);
AddField('nex_id', '', nxtWord32, 0, 0, False);
AddField('json', '', nxtBlobWideMemo, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('id'));
with AddIndex('I_table_nex_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('table'));
Add(GetFieldFromName('nex_id'));
end;
with AddIndex('I_status_table_method_updated_on', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('status'));
Add(GetFieldFromName('table'));
Add(GetFieldFromName('method'));
Add(GetFieldFromName('updated_on'));
end;
with AddIndex('I_status_method_updated_on', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('status'));
Add(GetFieldFromName('method'));
Add(GetFieldFromName('updated_on'));
end;
with AddIndex('I_status_update_on', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('status'));
Add(GetFieldFromName('updated_on'));
end;
with AddIndex('I_status_table_update_on', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('status'));
Add(GetFieldFromName('table'));
Add(GetFieldFromName('updated_on'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __bk_upload(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('ContentType', '', nxtWideString, 100, 0, False);
AddField('Dados', '', nxtBLOB, 0, 0, False);
AddField('Table', '', nxtByte, 0, 0, False);
AddField('Qtd', '', nxtWord16, 0, 0, False);
AddField('Method', '', nxtByte, 0, 0, False);
AddField('Resp', '', nxtBlobWideMemo, 0, 0, False);
AddField('DH', '', nxtDateTime, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IMethodID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Method'));
Add(GetFieldFromName('ID'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __bk_control(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('shopcode', '', nxtWord32, 0, 0, False);
AddField('remote_dbinfo', '', nxtBlobMemo, 0, 0, False);
AddField('DH', '', nxtDateTime, 0, 0, False);
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __Doc(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
AddLocaleDescriptor;
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
with AddDefaultValue(TnxAutoGuidDefaultValueDescriptor) as TnxAutoGuidDefaultValueDescriptor do
ApplyAt := [aaClient];
AddField('Tipo', '0-Recibo venda, 1-orçamento, 2-etiqueta, 3-pg.débito', nxtByte, 1, 0, False);
AddField('Bobina', '', nxtBoolean, 0, 0, False);
AddField('Pais', '', nxtNullString, 2, 0, False);
AddField('Lingua', '', nxtNulLString, 5, 0, False);
AddField('Free', '', nxtBoolean, 0, 0, False);
AddField('TextOnly', '', nxtBoolean, 0, 0, False);
AddField('Tamanho', '', nxtNullString, 20, 0, False);
AddField('Nome', '', nxtWideString, 100, 0, False);
AddField('Obs', '', nxtBLOBWideMemo, 0, 0, False);
AddField('Params', '', nxtBLOBMemo, 0, 0, False);
AddField('Doc', '', nxtBLOB, 0, 0, False);
AddField('Img', '', nxtBLOBGraphic, 0, 0, False);
AddField('Custom', '', nxtBoolean, 0, 0, False);
with AddField('MinVer', '', nxtWord16, 9, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
with AddField('MaxVer', '', nxtWord16, 9, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 9999;
AddField('SRECVER', '', nxtWord32, 9, 0, False);
AddField('RECVER', '', nxtWord32, 9, 0, False);
end;
with EnsureIndicesDescriptor do
with AddIndex('IID', 0, idNull), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with IndicesDescriptor.AddIndex('ISuperBuscaDoc', 0, True, '', TnxMainIndexTokenKeyDescriptor) do
with (KeyDescriptor as TnxMainIndexTokenKeyDescriptor) do
MaxTokenSize := 50; // set max key length here
with EnsureFulltextDescriptor(Result) do
with AddFullTextIndex('full_superbuscadoc') do begin
// N.B. you can add extractors for as many fields as you like here:
AddFieldTokenExtractor(FieldsDescriptor.GetFieldFromName('Nome'), '', TnxKwicTokenExtractorDescriptor);
{ if slIni.Values['docmgr']<>'1' then
AddFieldTokenExtractor(FieldsDescriptor.GetFieldFromName('Obs'), '', TnxKwicTokenExtractorDescriptor);}
with TnxMainIndexTokenIndexDescriptor(AddTokenIndex('ISuperBuscaDoc', TnxMainIndexTokenIndexDescriptor)) do begin
MainIndexNumber := 2;
IgnoreCase := True;
end;
end;
with EnsureIndicesDescriptor do
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with EnsureIndicesDescriptor do begin
with AddIndex('ITipoBobinaNome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('Bobina'));
Add(GetFieldFromName('Nome'));
end;
with AddIndex('ILinguaTipoBobinaNome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Lingua'));
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('Bobina'));
Add(GetFieldFromName('Nome'));
end;
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
with AddIndex('ISRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('SRecVer'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __br_cest(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
AddLocaleDescriptor;
with FieldsDescriptor do begin
AddField('cest', '', nxtWord32, 10, 0, False);
AddField('ncm', '', nxtWord32, 10, 0, False);
AddField('descr', '', nxtBLOBMemo, 0, 0, False);
AddField('apagar', '', nxtBoolean, 0, 0, False);
AddField('srecver', '', nxtWord32, 9, 0, False);
AddField('recver', '', nxtWord32, 9, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_ncm_cest', 0, idNone), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('ncm'));
Add(GetFieldFromName('cest'));
end;
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
with AddIndex('ISRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('SRecVer'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __syslog(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
with AddField('DataHora', '', nxtDateTime, 0, 0, False) do
with AddDefaultValue(TnxCurrentDateTimeDefaultValueDescriptor) as TnxCurrentDateTimeDefaultValueDescriptor do
ApplyAt := [aaServer];
AddField('Info', '', nxtNullString, 30, 0, False);
AddField('ver', '', nxtWord16, 0, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idNull), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IInfo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Info'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// IOrcamento
function __IOrcamento(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('Orcamento_UID', '', nxtGUID, 0, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Item', '', nxtWord16, 5, 0, False);
AddField('Produto', '', nxtWord32, 5, 0, False);
AddField('Descr', '', nxtBLOBMemo, 0, 0, False);
AddField('Unitario', '', nxtCurrency, 16, 0, False);
AddField('Quant', '', nxtDouble, 0, 0, False);
AddField('Total', '', nxtCurrency, 16, 0, False);
AddField('Desconto', '', nxtCurrency, 16, 0, False);
AddField('TotalFinal', '', nxtCurrency, 16, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IOrcamento_UID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Orcamento_UID'));
Add(GetFieldFromName('Item'));
end;
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Orcamento
function __Orcamento(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
with AddField('UID', '', nxtGUID, 0, 0, False) do
with AddDefaultValue(TnxAutoGuidDefaultValueDescriptor) as TnxAutoGuidDefaultValueDescriptor do
ApplyOnInsert := False;
AddField('IDSeq', '', nxtAutoInc, 10, 0, False);
AddField('RecVer', '', nxtWord32, 10, 0, False);
with AddField('CriadoEm', '', nxtDateTime, 0, 0, False) do
with AddDefaultValue(TnxCurrentDateTimeDefaultValueDescriptor) as TnxCurrentDateTimeDefaultValueDescriptor do begin
ApplyOnModify := True;
ApplyAt := [aaServer];
end;
with AddField('Status', '0-Pendente, 1-Aprovado, 2-Recusado, 3-Vendido, 4-Expirado', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
AddField('AtualizadoEm', '', nxtDateTime, 0, 0, False);
AddField('AprovadoEm', '', nxtDateTime, 0, 0, False);
AddField('RecusadoEm', '', nxtDateTime, 0, 0, False);
AddField('VendidoEm', '', nxtDateTime, 0, 0, False);
AddField('ExpiradoEm', '', nxtDateTime, 0, 0, False);
AddField('StatusAlteradoEm', '', nxtDateTime, 0, 0, False);
AddField('Func', '', nxtNullString, 20, 0, False);
AddField('IDVenda', '', nxtWord32, 10, 0, False);
AddField('Cliente', '', nxtWord32, 10, 0, False);
AddField('Total', '', nxtCurrency, 10, 0, False);
AddField('Desconto', '', nxtCurrency, 10, 0, False);
AddField('TotalFinal', '', nxtCurrency, 16, 0, False);
AddField('Vendido', '', nxtBoolean, 0, 0, False);
AddField('ValData', '', nxtDateTime, 0, 0, False);
AddField('ValModo', '', nxtByte, 0, 0, False);
AddField('ValTempo', '', nxtWord16, 0, 0, False);
AddField('ValUTempo', '', nxtByte, 0, 0, False);
AddField('Obs', '', nxtBLOBMemo, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IUID', 0, idNone), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IIDSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('IDSeq'));
with AddIndex('ICriadoEm', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('CriadoEm'));
with AddIndex('IAtualizadoEm', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('AtualizadoEm'));
with AddIndex('IClienteCriadoEm', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('CriadoEm'));
end;
with AddIndex('IStatusEm', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Status'));
Add(GetFieldFromName('StatusAlteradoEm'));
end;
with AddIndex('IStatusValData', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Status'));
Add(GetFieldFromName('ValData'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Caixa
function __Caixa(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('IDLivre', '', nxtNulLString, 10, 0, False);
AddField('Aberto', '', nxtBoolean, 0, 0, False);
AddField('Usuario', '', nxtNullString, 20, 0, False);
AddField('Abertura', '', nxtDateTime, 0, 0, False);
AddField('Fechamento', '', nxtDateTime, 0, 0, False);
AddField('Reproc', '', nxtDateTime, 0, 0, False);
AddField('TotalFinal', '', nxtCurrency, 16, 0, False);
AddField('Descontos', '', nxtCurrency, 16, 0, False);
AddField('Cancelamentos', '', nxtCurrency, 16, 0, False);
AddField('Sangria', '', nxtCurrency, 16, 0, False);
AddField('Supr', '', nxtCurrency, 16, 0, False);
AddField('SaldoAnt', '', nxtCurrency, 16, 0, False);
AddField('Obs', '', nxtBLOBMemo, 0, 0, False);
AddField('EstSessoesQtd', '', nxtInt32, 10, 0, False);
AddField('EstSessoesTempo', '', nxtDouble, 0, 0, False);
AddField('EstUrls', '', nxtInt32, 10, 0, False);
AddField('EstSyncOk', '', nxtBoolean, 0, 0, False);
AddField('EstBuscasEng', '', nxtBLOBMemo, 0, 0, False);
AddField('EstRes', '', nxtBLOBMemo, 0, 0, False);
AddField('SaldoF', '', nxtCurrency, 16, 0, False);
AddField('Quebra', '', nxtCurrency, 16, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IUsuario', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
with Add(GetFieldFromName('Usuario'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00030002;
IgnoreKanaType := True;
IgnoreNonSpace := True;
Ignorewidth := True;
end;
end;
Add(GetFieldFromName('Abertura'));
end;
with AddIndex('IAbertura', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Abertura'));
with AddIndex('IAberto', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Aberto'));
Add(GetFieldFromName('Abertura'));
end;
with AddIndex('IAbertoEstSyncOk', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Aberto'));
Add(GetFieldFromName('EstSyncOk'));
end;
with AddIndex('IIDLivre', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('IDLivre'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Categoria
function __Categoria(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('Descricao', '', nxtWideString, 35, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('uq_Categoria', 0, idNone), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Descricao'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
DefaultIndex := GetIndexFromName('uq_Categoria');
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Unidade
function __Unidade(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Descricao', '', nxtWideString, 5, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('uq_Unidade', 0, idNone), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Descricao'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
DefaultIndex := GetIndexFromName('uq_Unidade');
end;
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __Marca(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Nome', '', nxtWideString, 40, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('INome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Nome'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Cliente
function __Cliente(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
AddLocaleDescriptor;
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('Codigo', '', nxtNullString, 15, 0, False);
AddField('CodigoKey', '', nxtNullString, 15, 0, False);
AddField('Nome', '', nxtWideString, 50, 0, False);
AddField('Endereco', '', nxtWideString, 60, 0, False);
AddField('Endereco2', '', nxtWideString, 60, 0, False);
AddField('End_Numero', '', nxtWideString, 20, 0, False);
AddField('End_CodMun', '', nxtWideString, 7, 0, False);
AddField('End_Dest', '', nxtWideString, 40, 0, False);
AddField('End_Obs', '', nxtWideString, 40, 0, False);
AddField('endereco_id', '', nxtGuid, 0, 0, False);
AddField('Pais', '', nxtWideString, 2, 0, False);
AddField('Bairro', '', nxtWideString, 30, 0, False);
AddField('Cidade', '', nxtWideString, 40, 0, False);
AddField('UF', '', nxtWideString, 30, 0, False);
AddField('CEP', '', nxtWideString, 10, 0, False);
AddField('NaoContribICMS', '', nxtBoolean, 0, 0, False);
AddField('IsentoIE', '', nxtBoolean, 0, 0, False);
AddField('NFE_CredIcms', '', nxtBoolean, 0, 0, False);
AddField('Sexo', 'M=Masculo, F=Feminino', nxtChar, 1, 0, False);
AddField('Obs', '', nxtBLOBWideMemo, 0, 0, False);
AddField('Cpf', '', nxtWideString, 20, 0, False);
AddField('CPF_sodig', '', nxtWideString, 20, 0, False);
AddField('Rg', '', nxtWideString, 20, 0, False);
AddField('Telefone', '', nxtWideString, 15, 0, False);
AddField('Email', '', nxtBLOBWideMemo, 0, 0, False);
AddField('Passaportes', '', nxtDouble, 10, 0, False);
AddField('Pai', '', nxtWideString, 40, 0, False);
AddField('Mae', '', nxtWideString, 40, 0, False);
AddField('UltVisita', '', nxtDateTime, 0, 0, False);
AddField('Debito', '', nxtCurrency, 16, 0, False);
AddField('DataNasc', '', nxtDateTime, 0, 0, False);
AddField('Celular', '', nxtWideString, 15, 0, False);
AddField('TemDebito', '', nxtBoolean, 0, 0, False);
AddField('LimiteDebito', '', nxtCurrency, 16, 0, False);
AddField('Foto', '', nxtBLOBGraphic, 0, 0, False);
AddField('IncluidoEm', '', nxtDateTime, 0, 0, False);
AddField('AlteradoEm', '', nxtDateTime, 0, 0, False);
AddField('IncluidoPor', '', nxtNullString, 20, 0, False);
AddField('AlteradoPor', '', nxtNullString, 20, 0, False);
AddField('FidPontos', '', nxtDouble, 10, 0, False);
AddField('FidTotal', '', nxtDouble, 10, 0, False);
AddField('FidResg', '', nxtDouble, 10, 0, False);
AddField('Aniversario', '', nxtNullString, 4, 0, False);
AddField('SemFidelidade', '', nxtBoolean, 0, 0, False);
AddField('TemCredito', '', nxtBoolean, 0, 0, False);
AddField('InfoExtra', '', nxtWideString, 50, 0, False);
AddField('TranspEntPadrao', '', nxtWord32, 0, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
with AddField('TranspEnt', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('TipoFor', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
with AddField('PJuridica', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('Consumidor', '', nxtBoolean, 0, 0, False);
with AddField('Inativo', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('Fornecedor', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('ValorCred', '', nxtCurrency, 16, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
end;
with EnsureIndicesDescriptor do
with AddIndex('IID', 0, idNone), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with IndicesDescriptor.AddIndex('ISuperBusca', 0, True, '', TnxMainIndexTokenKeyDescriptor) do
with (KeyDescriptor as TnxMainIndexTokenKeyDescriptor) do
MaxTokenSize := 50; // set max key length here
with EnsureFulltextDescriptor(Result) do
with AddFullTextIndex('full_superbusca') do begin
// N.B. you can add extractors for as many fields as you like here:
AddFieldTokenExtractor(FieldsDescriptor.GetFieldFromName('Nome'), '', TnxKwicTokenExtractorDescriptor);
with TnxMainIndexTokenIndexDescriptor(AddTokenIndex('ISuperBusca', TnxMainIndexTokenIndexDescriptor)) do begin
MainIndexNumber := 2;
IgnoreCase := True;
end;
end;
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
with EnsureIndicesDescriptor do begin
with AddIndex('ICodigoKey', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('CodigoKey'));
with AddIndex('IFornecedorUltVisita', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
Add(GetFieldFromName('UltVisita'));
end;
with AddIndex('IFornecedorAniversario', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
Add(GetFieldFromName('Aniversario'));
end;
with AddIndex('INome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('IFornecedorNome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
end;
with AddIndex('ITranspEntNome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TranspEnt'));
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
end;
with AddIndex('IFornecedorID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IFornecedorCodigoKey', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
Add(GetFieldFromName('CodigoKey'));
end;
with AddIndex('IRg', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Rg'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('ICPF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('CPF'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('ICPF_sodig', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('CPF_sodig'));
with AddIndex('IFornecedorCPF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
with Add(GetFieldFromName('CPF'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
end;
with AddIndex('IFornecedorRg', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Fornecedor'));
with Add(GetFieldFromName('Rg'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
end;
with AddIndex('IDebito', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TemDebito'));
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00030002;
IgnoreKanaType := True;
IgnoreNonSpace := True;
Ignorewidth := True;
end;
end;
end;
with AddIndex('ICredito', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TemCredito'));
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00030002;
IgnoreKanaType := True;
IgnoreNonSpace := True;
Ignorewidth := True;
end;
end;
end;
with AddIndex('IFidPontos', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('FidPontos'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Config
function __Config(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('NumSeq', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
with AddField('MeioPagto', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
with AddField('AutoCad', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('QuickCad', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('CodProdutoDuplicados', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('CampoLocalizaCli', '0=nome, 1=username, 2=código', nxtByte, 3, 0, False);
AddField('ManterSaldoCaixa', '', nxtBoolean, 0, 0, False);
AddField('RecPorta', '', nxtNullString, 100, 0, False);
AddField('RecSalto', '', nxtWord16, 5, 0, False);
AddField('RecLargura', '', nxtWord16, 5, 0, False);
AddField('RecRodape', '', nxtBLOBMemo, 0, 0, False);
AddField('RecImprimir', '', nxtByte, 3, 0, False);
AddField('RecMatricial', '', nxtBoolean, 0, 0, False);
AddField('RecTipoImpressora', '', nxtNullString, 32, 0, False);
AddField('RecNomeLoja', '', nxtNullString, 40, 0, False);
AddField('RecCortaFolha', '', nxtBoolean, 0, 0, False);
with AddField('TamCodigoAuto', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 6;
with AddField('fmt_moeda', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('fmt_decimais', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 2;
AddField('fmt_simbmoeda', '', nxtNullString, 5, 0, False);
AddField('fmt_sep_decimal', '', nxtNullString, 1, 0, False);
AddField('fmt_sep_milhar', '', nxtNullString, 1, 0, False);
AddField('Pais', '', nxtNullString, 2, 0, False);
AddField('tax_id_def', '', nxtWord32, 0, 0, False);
with AddField('RecImprimeMeioPagto', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
AddField('RecPrefixoMeioPagto', '', nxtNullString, 30, 0, False);
AddField('EscondeTextoBotoes', '', nxtBoolean, 0, 0, False);
AddField('PastaDownload', '', nxtNullString, 1024, 0, False);
AddField('Endereco_Loja', '', nxtGUID, 0, 0, False);
AddField('EmailDestino', '', nxtBLOBMemo, 0, 0, False);
AddField('EmailIdent', '', nxtNullString, 20, 0, False);
with AddField('EmailConteudo', '', nxtNullString, 20, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := '11111111111111111111';
AddField('Flags', '', nxtBLOBMemo, 0, 0, False);
with AddField('EmailEnviarCaixa', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('AlertaAssinatura', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('RelCaixaAuto', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('NaoVenderAlemEstoque', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('AutoSortGridCaixa', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('AutoObsAoCancelar', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('LimitePadraoDebito', '', nxtCurrency, 16, 0, False);
with AddField('FidAtivo', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('FidVendaValor', '', nxtCurrency, 16, 0, False);
AddField('FidVendaPontos', '', nxtInt32, 10, 0, False);
with AddField('FidParcial', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('FidAutoPremiar', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('FidAutoPremiarValor', '', nxtCurrency, 16, 0, False);
AddField('FidAutoPremiarPontos', '', nxtInt32, 10, 0, False);
with AddField('FidMostrarSaldoAdmin', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('FidMsg', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('FidMsgTitulo', '', nxtNullString, 50, 0, False);
AddField('FidMsgTexto', '', nxtBlobMemo, 0, 0, False);
with AddField('ExigeDadosMinimos', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('DadosMinimos', '', nxtNullString, 300, 0, False);
AddField('CidadePadrao', '', nxtNullString, 50, 0, False);
AddField('UFPadrao', '', nxtNullString, 2, 0, False);
with AddField('PedirSaldoI', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('PedirSaldoF', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('DTol', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 5;
AddField('DVA', '', nxtDateTime, 0, 0, False);
AddField('ProxAvisoAss', '', nxtDateTime, 0, 0, False);
with AddField('PreLib', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('CamposCliCC', '', nxtBLOBMemo, 0, 0, False);
with AddField('CliCongelado', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('Banners', '', nxtBlobMemo, 0, 0, False);
AddField('Botoes', '', nxtBlobMemo, 0, 0, False);
AddField('Recursos', '', nxtNullString, 30, 0, False);
AddField('PrecoAuto', '', nxtBoolean, 0, 0, False);
AddField('Margem', '', nxtDouble, 0, 0, False);
AddField('ComissaoPerc', '', nxtDouble, 0, 0, False);
AddField('ValOrc_Tempo', '', nxtWord16, 0, 0, False);
AddField('ValOrc_UTempo', '', nxtByte, 0, 0, False);
with AddField('EmailOrc_Enviar', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
AddField('EmailOrc_FromName', '', nxtNullString, 100, 0, False);
AddField('EmailOrc_FromEmail', '', nxtNullString, 100, 0, False);
with AddField('EmailOrc_Subject', '', nxtNullString, 100, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 'Orçamento #[numero]';
AddField('EmailOrc_Body', '', nxtBlobMemo, 0, 0, False);
with AddField('DocOrc_Imprimir', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
AddField('DocOrc_NomeLoja', '', nxtNullString, 50, 0, False);
AddField('ObsPadraoOrcamento', '', nxtBLOBMemo, 0, 0, False);
with AddField('ComissaoLucro', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('CodBarBal', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('CodBarBalTam', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 13;
with AddField('CodBarBalIdent', '', nxtNullString, 5, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := '2';
with AddField('CodBarBalInicioCod', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 2;
with AddField('CodBarBalTamCod', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 5;
with AddField('CodBarBalValor', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('CodBarBalPPInicio', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 7;
with AddField('CodBarBalPPTam', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 6;
with AddField('CodBarBalPPDig', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 2;
with AddField('CodBarMaxQtdDig', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 3;
with AddField('CodBarArredondar', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 4;
with AddField('ComandaOff', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('MesasOff', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('ConsumoAvulsoOff', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('ConfirmarDebito', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('TelaPosVenda_Mostrar', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('ExigirVendedor', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('TelaPosVenda_BtnDef', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 1;
AddField('RecVer', '', nxtWord32, 0, 0, False);
with AddField('TrocoMax', '', nxtCurrency, 16, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 1000;
AddField('DocParam_Email', '', nxtNullString, 100, 0, False);
AddField('DocParam_Tel', '', nxtNullString, 15, 0, False);
AddField('DocParam_Tel2', '', nxtNullString, 15, 0, False);
AddField('DocParam_Cidade', '', nxtNullString, 50, 0, False);
AddField('DocParam_End', '', nxtNullString, 100, 0, False);
AddField('DocParam_CEP', '', nxtNullString, 9, 0, False);
AddField('DocParam_CNPJ', '', nxtNullString, 19, 0, False);
AddField('DocParam_IE', '', nxtNullString, 19, 0, False);
AddField('DocParam_Site', '', nxtNullString, 50, 0, False);
AddField('DocParam_Facebook', '', nxtNullString, 100, 0, False);
AddField('DocParam_Instagram', '', nxtNullString, 50, 0, False);
AddField('DocParam_Whats', '', nxtNullString, 15, 0, False);
AddField('DocParam_Whats2', '', nxtNullString, 15, 0, False);
AddField('DocParam_InfoExtra', '', nxtNullString, 100, 0, False);
AddField('DocParam_Logo', '', nxtBLOBGraphic, 0, 0, False);
AddField('DocParam_Logo2', '', nxtBLOBGraphic, 0, 0, False);
with AddField('RecAddObsItem', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
AddField('Urls', '', nxtBLOBMemo, 0, 0, False);
AddField('TranspEntPadrao', '', nxtWord32, 0, 0, False);
AddField('FretePadrao', '', nxtCurrency, 0, 0, False);
AddField('DesativarFrete', '', nxtBoolean, 0, 0, False);
with AddField('modFretePadrao', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 9;
AddField('DesativarTranspEnt', '', nxtBoolean, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do
with AddIndex('INumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('NumSeq'));
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Debito
function __Debito(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('NumSeq', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Data', '', nxtDateTime, 0, 0, False);
AddField('Cliente', '', nxtWord32, 10, 0, False);
AddField('Valor', '', nxtCurrency, 16, 0, False);
with AddField('Tipo', '0=Sessao, 1=Credito Tempo, 2=Produto', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
AddField('ID', '', nxtWord32, 10, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('ICliData', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('Data'));
end;
with AddIndex('ITipoID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('ID'));
Add(GetFieldFromName('Cliente'));
end;
with AddIndex('INumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('NumSeq'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __PostMS(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('MS', '', nxtBLOB, 0, 0, False);
AddField('URL', '', nxtNullString, 255, 0, False);
AddField('Inclusao', '', nxtDateTime, 0, 0, False);
AddField('Envio', '', nxtDateTime, 0, 0, False);
AddField('Tries', '', nxtWord16, 5, 0, False);
AddField('Max', '', nxtWord16, 0, 0, False);
AddField('NextTry', '', nxtWord32, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('INextTryID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('NextTry'));
Add(GetFieldFromName('ID'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __post_nexapp(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('ContentType', '', nxtWideString, 100, 0, False);
with AddField('card_array', '', nxtByte, 0, 0, False) do // 0 - criar json, 1- enviar, 2-enviado
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := card_array_cards;
AddField('Dados', '', nxtBLOB, 0, 0, False);
AddField('Qtd', '', nxtWord16, 0, 0, False);
AddField('Method', '', nxtByte, 0, 0, False);
AddField('Resp', '', nxtBlobWideMemo, 0, 0, False);
AddField('DH', '', nxtDateTime, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IMethodID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Method'));
Add(GetFieldFromName('ID'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// ITran
function __ITran(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Tran', '', nxtWord32, 10, 0, False);
AddField('Caixa', '', nxtWord32, 10, 0, False);
AddField('CaixaPag', '', nxtWord32, 10, 0, False);
AddField('Cliente', '', nxtWord32, 10, 0, False);
AddField('Sessao', '', nxtWord32, 10, 0, False);
AddField('DataHora', '', nxtDateTime, 0, 0, False);
AddField('IncluidoEm', '', nxtDateTime, 0, 0, False);
AddField('TipoTran', '', nxtByte, 3, 0, False);
AddField('TipoItem', 'Sessao, Credito, MovEst, Transação', nxtByte, 3, 0, False);
AddField('SubTipo', '', nxtByte, 3, 0, False);
AddField('ItemID', '', nxtWord32, 10, 0, False);
AddField('SubItemID', '', nxtWord32, 10, 0, False);
AddField('ItemPos', '', nxtByte, 0, 0, False);
AddField('Total', '', nxtCurrency, 16, 0, False);
AddField('Desconto', '', nxtCurrency, 16, 0, False);
AddField('TotLiq', '', nxtCurrency, 16, 0, False);
AddField('Debito', '', nxtCurrency, 16, 0, False);
AddField('Pago', '', nxtCurrency, 16, 0, False);
AddField('Cancelado', '', nxtBoolean, 0, 0, False);
AddField('PagPend', '', nxtBoolean, 0, 0, False);
AddField('FidFator', '', nxtInt8, 3, 0, False);
AddField('FidPontos', '', nxtDouble, 0, 0, False);
AddField('FidMov', '', nxtBoolean, 0, 0, False);
with AddField('FidOpe', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('ITipoItemDH', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoItem'));
Add(GetFieldFromName('ItemID'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ITranID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tran'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IClienteID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICaixaCancelado', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('TipoItem'));
end;
with AddIndex('ICaixaPagCancelado', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('CaixaPag'));
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('TipoItem'));
end;
with AddIndex('ITipoItemTran', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoItem'));
Add(GetFieldFromName('ItemID'));
Add(GetFieldFromName('Tran'));
end;
with AddIndex('ICanceladoTipoTranItemID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('ItemID'));
end;
with AddIndex('IFidMovClienteDH', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('FidMov'));
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('DataHora'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Layout
function __Layout(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('Usuario', '', nxtNullString, 20, 0, False);
AddField('Grid', '', nxtNullString, 40, 0, False);
AddField('Nome', '', nxtNullString, 100, 0, False);
AddField('Publico', '', nxtBoolean, 0, 0, False);
AddField('Layout', '', nxtBLOB, 0, 0, False);
AddField('Filtro', '', nxtBLOB, 0, 0, False);
AddField('Usuarios', '', nxtBLOBMemo, 0, 0, False);
end;
with EnsureIndicesDescriptor do
with AddIndex('IPubGridUsuario', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Publico'));
with Add(GetFieldFromName('Grid'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with Add(GetFieldFromName('Usuario'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// MovEst
function __MovEst(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('ID_ref', '', nxtWord32, 0, 0, False);
AddField('Tran', '', nxtWord32, 10, 0, False);
AddField('Item', '', nxtByte, 0, 0, False);
AddField('tax_id', '', nxtWord32, 10, 0, False);
AddField('tax_incluido', '', nxtCurrency, 0, 0, False);
AddField('tax_incluir', '', nxtCurrency, 0, 0, False);
AddField('Produto', '', nxtWord32, 10, 0, False);
AddField('Quant', '', nxtDouble, 0, 0, False);
AddField('Unitario', '', nxtCurrency, 16, 0, False);
AddField('Total', '', nxtCurrency, 16, 0, False);
AddField('TotLiq', '', nxtCurrency, 16, 0, False);
AddField('CustoU', '', nxtCurrency, 16, 0, False);
AddField('CustoT', '', nxtCurrency, 16, 0, False);
AddField('Lucro', '', nxtCurrency, 16, 0, False);
AddField('Desconto', '', nxtCurrency, 16, 0, False);
AddField('Descr', '', nxtWideString, 100, 0, False);
AddField('Obs', '', nxtBlobWideMemo, 0, 0, False);
AddField('TotalFinal', '', nxtCurrency, 16, 0, False);
AddField('Pago', '', nxtCurrency, 16, 0, False);
AddField('PagoPost', '', nxtCurrency, 16, 0, False);
AddField('DescPost', '', nxtCurrency, 16, 0, False);
AddField('DataHora', '', nxtDateTime, 0, 0, False);
AddField('Pend', '', nxtBoolean, 0, 0, False);
AddField('IncluidoEm', '', nxtDateTime, 0, 0, False);
AddField('Entrada', '', nxtBoolean, 0, 0, False);
AddField('Cancelado', '', nxtBoolean, 0, 0, False);
AddField('AjustaCusto', '', nxtBoolean, 0, 0, False);
AddField('EstoqueAnt', '', nxtDouble, 0, 0, False);
AddField('Cliente', '', nxtWord32, 10, 0, False);
AddField('Caixa', '', nxtInt32, 10, 0, False);
AddField('Categoria', '', nxtNullString, 20, 0, False);
AddField('NaoControlaEstoque', '', nxtBoolean, 0, 0, False);
AddField('ITran', '', nxtInt32, 10, 0, False);
AddField('TipoTran', '', nxtByte, 3, 0, False);
AddField('Sessao', '', nxtInt32, 10, 0, False);
AddField('DebDev', '', nxtCurrency, 0, 0, False);
AddField('Comissao', '', nxtCurrency, 0, 0, False);
AddField('ComissaoPerc', '', nxtDouble, 0, 0, False);
AddField('ComissaoLucro', '', nxtBoolean, 0, 0, False);
AddField('VenDev', '', nxtBoolean, 0, 0, False);
AddField('DadosFiscais', '', nxtBlobMemo, 0, 0, False);
AddField('DataSped', '', nxtDate, 0, 0, False);
AddField('vDF', '', nxtWord16, 9, 0, False);
with AddField('PermSemEstoque', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('FidResgate', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('FidPontos', '', nxtDouble, 0, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IID_ref', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('ID_ref'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('Cancelado'));
end;
with AddIndex('IProduto', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICanceladoDataSped', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('DataSped'));
end;
with AddIndex('IContato', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ICanceladoContatoTipoDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ICanceladoContatoProdutoTipoDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('DataHora'));
end;
{---- MOSTRAR CANCELADOS -----}
{---- Mesmo Caixa ----}
with AddIndex('ICaixaVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
with AddIndex('ICaixaTipoTranDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
{---- Todos Caixas ----}
with AddIndex('IVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
with AddIndex('ITipoTranDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
{---- NAO MOSTRAR CANCELADOS -----}
{---- Mesmo Caixa ----}
with AddIndex('ICanceladoCaixaVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
with AddIndex('ICanceladoCaixaTipoTranDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
{---- Todos Caixas ----}
with AddIndex('ICanceladoVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
with AddIndex('ICanceladoTipoTranDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
{---------------------------------------------------}
with AddIndex('ITipoTranCaixa', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('Tran'));
end;
with AddIndex('ITipoTranCliente', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ICaixaMov', 0, idAll, 'M'), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ITranItem', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tran'));
Add(GetFieldFromName('Item'));
end;
with AddIndex('IProdCxMov', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
with Add(GetFieldFromName('Produto'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00030002;
IgnoreKanaType := True;
IgnoreNonSpace := True;
Ignorewidth := True;
end;
end;
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ISessaoID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Sessao'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IProdAjustaCustoTran', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('AjustaCusto'));
Add(GetFieldFromName('Tran'));
end;
with AddIndex('IProdAjustaCustoData', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('AjustaCusto'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('IProdPendCancelado', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Produto'));
Add(GetFieldFromName('Pend'));
Add(GetFieldFromName('Cancelado'));
end;
with AddIndex('IDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICanceladoDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Produto
function __Produto(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
AddLocaleDescriptor;
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Marca', '', nxtGUID, 0, 0, False);
AddField('Codigo', '', nxtWideString, 30, 0, False);
AddField('CodigoNum', '', nxtWord32, 0, 0, False);
AddField('Codigo2', '', nxtWideString, 30, 0, False);
AddField('Codigo2Num', '', nxtWord32, 0, 0, False);
AddField('Descricao', '', nxtWideString, 100, 0, False);
AddField('Unid', '', nxtWideString, 5, 0, False);
AddField('Preco', '', nxtCurrency, 5, 0, False);
AddField('PrecoAuto', '', nxtBoolean, 0, 0, False);
AddField('Margem', '', nxtDouble, 0, 0, False);
AddField('Obs', '', nxtBLOBWideMemo, 0, 0, False);
AddField('Imagem', '', nxtBLOBGraphic, 0, 0, False);
AddField('Categoria', '', nxtWideString, 35, 0, False);
AddField('Fornecedor', '', nxtWord32, 10, 0, False);
AddField('EstoqueAtual', '', nxtDouble, 0, 0, False);
AddField('EstoquePend', '', nxtDouble, 0, 0, False);
AddField('EstoqueTot', '', nxtDouble, 0, 0, False);
AddField('brtrib', '', nxtWord16, 0, 0, False);
AddField('CustoUnitario', '', nxtCurrency, 16, 0, False);
AddField('PodeAlterarPreco', '', nxtBoolean, 0, 0, False);
AddField('PermiteVendaFracionada', '', nxtBoolean, 0, 0, False);
AddField('NaoControlaEstoque', '', nxtBoolean, 0, 0, False);
AddField('EstoqueMin', '', nxtDouble, 0, 0, False);
AddField('EstoqueMax', '', nxtDouble, 0, 0, False);
AddField('AbaixoMin', '', nxtBoolean, 0, 0, False);
AddField('AbaixoMinDesde', '', nxtDateTime, 0, 0, False);
AddField('EstoqueRepor', '', nxtDouble, 0, 0, False);
AddField('ComissaoPerc', '', nxtDouble, 0, 0, False);
AddField('ComissaoLucro', '', nxtBoolean, 0, 0, False);
AddField('PesoBruto', '', nxtDouble, 0, 0, False);
AddField('PesoLiq', '', nxtDouble, 0, 0, False);
AddField('tax_id', '', nxtWord32, 0, 0, False);
with AddField('Ativo', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := True;
with AddField('Fidelidade', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('FidPontos', '', nxtInt32, 10, 0, False);
AddField('NCM', '', nxtNullString, 8, 0, False);
AddField('NCM_Ex', '', nxtNullString, 2, 0, False);
AddField('cest', '', nxtWord32, 0, 0, False);
AddField('modST', '', nxtByte, 0, 0, False);
AddField('MVA', '', nxtBlobMemo, 0, 0, False);
AddField('Pauta', '', nxtBlobMemo, 0, 0, False);
with AddField('CadastroRapido', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
with AddField('IncluidoEm', '', nxtDateTime, 0, 0, False) do
AddDefaultValue(TnxCurrentDateTimeDefaultValueDescriptor);
AddField('AlteradoEm', '', nxtDateTime, 0, 0, False);
AddField('AlteradoPor', '', nxtNullString, 30, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
end;
with EnsureIndicesDescriptor do
with AddIndex('IID', 0, idNull), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with IndicesDescriptor.AddIndex('ISuperBusca', 0, True, '', TnxMainIndexTokenKeyDescriptor) do
with (KeyDescriptor as TnxMainIndexTokenKeyDescriptor) do
MaxTokenSize := 50; // set max key length here
with EnsureFulltextDescriptor(Result) do
with AddFullTextIndex('full_superbusca') do begin
// N.B. you can add extractors for as many fields as you like here:
AddFieldTokenExtractor(FieldsDescriptor.GetFieldFromName('Descricao'), '', TnxKwicTokenExtractorDescriptor);
with TnxMainIndexTokenIndexDescriptor(AddTokenIndex('ISuperBusca', TnxMainIndexTokenIndexDescriptor)) do begin
MainIndexNumber := 2;
IgnoreCase := True;
{ with AddLocaleDescriptor do begin
Locale := $00000416;
Flags := $00001000;
UseStringSort := True;
end; }
end;
end;
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
with EnsureIndicesDescriptor do begin
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('ICodigo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Codigo'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('ICodigoNum', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('CodigoNum'));
with AddIndex('ICodigo2', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Codigo2'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('ICodigo2Num', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Codigo2Num'));
with AddIndex('IDescricao', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Descricao'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416;
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('IAbaixoMin', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('AbaixoMin'));
Add(GetFieldFromName('AbaixoMinDesde'));
end;
with AddIndex('IMarcaDescr', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Marca'));
Add(GetFieldFromName('Descricao'));
end;
with AddIndex('IPrecoAutoMargem', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('PrecoAuto'));
Add(GetFieldFromName('Margem'));
end;
with AddIndex('ICadastroRapido', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
with Add(GetFieldFromName('CadastroRapido')) do
Ascend := False;
with Add(GetFieldFromName('IncluidoEm')) do
Ascend := False;
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Tran
function __Tran(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
AddField('UID', '', nxtGUID, 0, 0, False);
AddField('UID_ref', '', nxtGUID, 0, 0, False);
with AddField('StatusNFE', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := nfetran_naoemitir;
AddField('ChaveNFE', '', nxtNullString, 44, 0, False);
with AddField('TipoNFE', '', nxtByte, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := tiponfe_nenhum;
AddField('DataHora', '', nxtDateTime, 0, 0, False);
AddField('Entregar', '', nxtBoolean, 0, 0, False);
AddField('VenDev', '', nxtBoolean, 0, 0, False);
AddField('endereco_entrega', '', nxtGUID, 0, 0, False);
AddField('IncluidoEm', '', nxtDateTime, 0, 0, False);
AddField('Cliente', '', nxtWord32, 10, 0, False);
AddField('Tipo', '', nxtByte, 3, 0, False);
AddField('OpDevValor', '', nxtByte, 3, 0, False);
AddField('Func', '', nxtNullString, 20, 0, False);
AddField('Total', '', nxtCurrency, 16, 0, False);
AddField('Desconto', '', nxtCurrency, 16, 0, False);
AddField('DescPerc', '', nxtDouble, 16, 0, False);
AddField('ids_pagto', '', nxtNullString, 20, 0, False);
AddField('Hora', '', nxtByte, 0, 0, False);
with AddField('DescPorPerc', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('TotLiq', '', nxtCurrency, 16, 0, False);
with AddField('PagEsp', '', nxtWord16, 5, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := 0;
AddField('Pago', '', nxtCurrency, 16, 0, False);
AddField('DebitoAnt', '', nxtCurrency, 16, 0, False);
AddField('Debito', '', nxtCurrency, 16, 0, False);
AddField('DebitoPago', '', nxtCurrency, 16, 0, False);
AddField('CreditoAnt', '', nxtCurrency, 16, 0, False);
AddField('Credito', '', nxtCurrency, 16, 0, False);
AddField('CreditoUsado', '', nxtCurrency, 16, 0, False);
AddField('Troco', '', nxtCurrency, 16, 0, False);
AddField('Obs', '', nxtBLOBMemo, 0, 0, False);
AddField('Cancelado', '', nxtBoolean, 0, 0, False);
AddField('CanceladoPor', '', nxtNullString, 30, 0, False);
AddField('CanceladoEm', '', nxtDateTime, 0, 0, False);
AddField('Caixa', '', nxtWord32, 10, 0, False);
AddField('CaixaPag', '', nxtWord32, 10, 0, False);
AddField('Maq', '', nxtWord16, 5, 0, False);
AddField('NomeCliente', '', nxtWideString, 50, 0, False);
AddField('Sessao', '', nxtWord32, 10, 0, False);
AddField('Descricao', '', nxtBlobWideMemo, 0, 0, False);
AddField('QtdTempo', '', nxtDouble, 0, 0, False);
AddField('CredValor', '', nxtBoolean, 0, 0, False);
AddField('FidResgate', '', nxtBoolean, 0, 0, False);
AddField('AmbNFe', '', nxtByte, 0, 0, False);
AddField('StatusCanc', '', nxtByte, 0, 0, False);
AddField('Extra', '', nxtBlobMemo, 0, 0, False);
AddField('PagFunc', '', nxtNullString, 20, 0, False);
AddField('Vendedor', '', nxtNullString, 20, 0, False);
AddField('Comissao', '', nxtCurrency, 16, 0, False);
AddField('Frete', '', nxtCurrency, 0, 0, False);
AddField('tax_incluido', '', nxtCurrency, 0, 0, False);
AddField('tax_incluir', '', nxtCurrency, 0, 0, False);
AddField('TotalFinal', '', nxtCurrency, 0, 0, False);
AddField('tranest', '', nxtBoolean, 0, 0, False);
AddField('trancx', '', nxtBoolean, 0, 0, False);
AddField('TranspEnt', '', nxtWord32, 0, 0, False);
AddField('TranspVol', '', nxtWord16, 0, 0, False);
AddField('TranspPesoB', '', nxtDouble, 0, 0, False);
AddField('TranspPesoL', '', nxtDouble, 0, 0, False);
AddField('TranspPesoVol', '', nxtByte, 0, 0, False);
AddField('UpdID', '', nxtGUID, 0, 0, False);
AddField('DataNF', '', nxtDate, 0, 0, False);
AddField('vSped', '', nxtWord16, 9, 0, False);
with AddField('PagPend', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('RecVer', '', nxtWord32, 0, 0, False);
AddField('processaSped', '', nxtByte, 0, 0, False);
AddField('ErroProcSped', '', nxtBlobMemo, 10, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('ICliDH', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ITranspEntDH', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TranspEnt'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ICliID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICaixaID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ITipoDataNF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataNF'));
end;
with AddIndex('ITipoNFeDataNF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoNFe'));
Add(GetFieldFromName('DataNF'));
end;
with AddIndex('IprocessaSpedvSped', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('processaSped'));
Add(GetFieldFromName('vSped'));
end;
with AddIndex('ICanceladoTipoDataNF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataNF'));
end;
with AddIndex('ICanceladoTipoNFETipoDataNF', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('TipoNFE'));
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataNF'));
end;
with AddIndex('ICaixaPagID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('CaixaPag'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IPagPendID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('PagPend'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IprocessaSpedID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('processaSped'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IPagPendEntID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('PagPend'));
Add(GetFieldFromName('Entregar'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IDH', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('DataHora'));
with AddIndex('ITipoDH', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('ITipoCaixaID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ITipoID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ISessao', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Sessao'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('IUID_ref', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('UID_ref'));
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('Cancelado'));
end;
with AddIndex('ITipoNFEStatusNFE', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoNFE'));
Add(GetFieldFromName('StatusNFE'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ITipoNFECanceladoStatusNFE', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoNFE'));
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('StatusNFE'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICanceladoStatusNFE', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('StatusNFE'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ITipoNFECanceladoAmbStatusNFE', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoNFE'));
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('AmbNFe'));
Add(GetFieldFromName('StatusNFE'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICanceladoAmbStatusNFE', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('AmbNFe'));
Add(GetFieldFromName('StatusNFE'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('Iendereco_entrega_ID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('endereco_entrega'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('Itranest_tipo_datahora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('tranest'));
Add(GetFieldFromName('tipo'));
Add(GetFieldFromName('datahora'));
end;
with AddIndex('Itranest_datahora_tipo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('tranest'));
Add(GetFieldFromName('datahora'));
Add(GetFieldFromName('tipo'));
end;
with AddIndex('Itrancx_tipo_datahora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('trancx'));
Add(GetFieldFromName('tipo'));
Add(GetFieldFromName('datahora'));
end;
with AddIndex('Itrancx_datahora_tipo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('trancx'));
Add(GetFieldFromName('datahora'));
Add(GetFieldFromName('tipo'));
end;
with AddIndex('IChaveNFE', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ChaveNFE'));
with AddIndex('IStatusCanc', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('StatusCanc'));
{---- MOSTRAR CANCELADOS -----}
{---- Mesmo Caixa ----}
with AddIndex('ICaixaVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICaixaTipoDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
{---- Todos Caixas ----}
with AddIndex('IVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ITipoDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
{---- NAO MOSTRAR CANCELADOS -----}
{---- Mesmo Caixa ----}
with AddIndex('ICanceladoCaixaVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICanceladoCaixaTipoDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
{---- Todos Caixas ----}
with AddIndex('ICanceladoVenDevDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('VenDev'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICanceladoTipoDataHora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cancelado'));
Add(GetFieldFromName('Tipo'));
Add(GetFieldFromName('DataHora'));
Add(GetFieldFromName('ID'));
end;
{---------------------------------------------------}
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Usuario
function __Usuario(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
Result.EncryptionEngine := 'nx1xDefault';
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Username', '', nxtNullString, 20, 0, False);
AddField('Nome', '', nxtNullString, 40, 0, False);
with AddField('Inativo', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('Admin', '', nxtBoolean, 0, 0, False);
AddField('Senha', '', nxtNullString, 30, 0, False);
AddField('Grupos', '', nxtBLOBMemo, 0, 0, False);
AddField('Direitos', '', nxtBLOBMemo, 0, 0, False);
AddField('MaxTempoManut', '', nxtInt32, 10, 0, False);
AddField('MaxMaqManut', '', nxtInt32, 10, 0, False);
AddField('LimiteDesc', '', nxtDouble, 16, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
AddField('Email', '', nxtWideString, 100, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IUsername', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Username'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('INome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
with Add(GetFieldFromName('Nome'), TnxExtTextKeyFieldDescriptor) as TnxExtTextKeyFieldDescriptor do begin
IgnoreCase := True;
with AddLocaleDescriptor do begin
Locale := $00000416; { Portuguese }
Flags := $00001000;
UseStringSort := True;
end;
end;
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __infocampanha(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('IP', '', nxtNullString, 15, 0, False);
AddField('campanha', '', nxtNullString, 50, 0, False);
AddField('utmccn', '', nxtNullString, 250, 0, False);
AddField('utmctr', '', nxtNullString, 250, 0, False);
AddField('utmcct', '', nxtNullString, 250, 0, False);
AddField('utmcmd', '', nxtNullString, 250, 0, False);
AddField('utmcsr', '', nxtNullString, 250, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IIP', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('IP'));
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// temp
function __temp(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do
AddField('last_upd_cmds', '', nxtInt32, 10, 0, False);
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __Credito(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('DataHora', '', nxtDateTime, 0, 0, False);
AddField('Func', '', nxtNullString, 20, 0, False);
AddField('Adicionar', '', nxtBoolean, 0, 0, False);
AddField('Tran', '', nxtWord32, 10, 0, False);
AddField('Caixa', '', nxtWord32, 10, 0, False);
AddField('Cliente', '', nxtWord32, 10, 0, False);
AddField('Cancelado', '', nxtBoolean, 0, 0, False);
AddField('Valor', '', nxtCurrency, 16, 0, False);
with AddField('FidResgate', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('FidPontos', '', nxtDouble, 0, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('ICliente', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Cliente'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ITran', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Tran'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// Usuario
function __Especies(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtWord16, 5, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Tipo', '', nxtByte, 3, 0, False);
AddField('Nome', '', nxtNullString, 40, 0, False);
AddField('PermiteTroco', '', nxtBoolean, 0, 0, False);
AddField('PermiteVarios', '', nxtBoolean, 0, 0, False);
AddField('PermiteCred', '', nxtBoolean, 0, 0, False);
AddField('Img', '', nxtWord16, 5, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
AddField('TipoPagNFE', '', nxtByte, 3, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __PagEspecies(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Caixa', '', nxtWord32, 10, 0, False);
AddField('DataHora', '', nxtDateTime, 0, 0, False);
AddField('Tran', '', nxtWord32, 10, 0, False);
with AddField('TipoTran', '', nxtByte, 3, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := trEstVenda;
AddField('Especie', '', nxtWord16, 5, 0, False);
AddField('Tipo', '', nxtByte, 3, 0, False);
AddField('Valor', '', nxtCurrency, 16, 0, False);
AddField('Troco', '', nxtCurrency, 16, 0, False);
AddField('Doc', '', nxtNullString, 50, 0, False);
AddField('Cancelado', '', nxtBoolean, 0, 0, False);
with AddField('Devolucao', '', nxtBoolean, 0, 0, False) do
with AddDefaultValue(TnxConstDefaultValueDescriptor) as TnxConstDefaultValueDescriptor do
AsVariant := False;
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
with AddIndex('IDoc', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('Doc'));
with AddIndex('ITranID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Tran'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('ICaixaID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('ID'));
end;
with AddIndex('I_caixa_datahora', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('Caixa'));
Add(GetFieldFromName('DataHora'));
end;
with AddIndex('I_tipotran_tran', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('TipoTran'));
Add(GetFieldFromName('Tran'));
end;
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __RecDel(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('Tab', '', nxtWord16, 5, 0, False);
AddField('Key', '', nxtNullString, 40, 0, False);
AddField('RecVer', '', nxtWord32, 0, 0, False);
with EnsureIndicesDescriptor do
with AddIndex('IRecVer', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('RecVer'));
end;
with EnsureIndicesDescriptor do begin
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// movest_tax
function __movest_tax(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('movest', '', nxtWord32, 10, 0, False);
AddField('tax_id', '', nxtWord32, 10, 0, False);
AddField('nome', '', nxtWideString, 40, 0, False);
AddField('incluido', '', nxtBoolean, 0, 0, False);
AddField('perc', '', nxtDouble, 0, 0, False);
AddField('valor', '', nxtCurrency, 20, 4, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_movest_tax_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('movest'));
Add(GetFieldFromName('tax_id'));
end;
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// tax
function __tax(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('tax_id', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('nome', '', nxtWideString, 40, 0, False);
AddField('incluido', '', nxtBoolean, 0, 0, False);
AddField('perc', '', nxtDouble, 40, 0, False);
AddField('grupo', '', nxtBoolean, 0, 0, False);
AddField('itens', '', nxtBLOBWideMemo, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_tax_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('tax_id'));
with AddIndex('I_nome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('nome'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function __tax_itens(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('grupo', '', nxtWord32, 10, 0, False);
AddField('item', '', nxtWord32, 10, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_grupo_item', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('grupo'));
Add(GetFieldFromName('item'));
end;
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// endereco
function __endereco(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('endereco_id', '', nxtGUID, 0, 0, False);
AddField('cliente_id', '', nxtWord32, 10, 0, False);
AddField('pos', '', nxtByte, 3, 0, False);
AddField('numseq', '', nxtAutoInc, 10, 0, False);
AddField('end_dest', '', nxtWideString, 50, 0, False);
AddField('endereco', '', nxtWideString, 60, 0, False);
AddField('endereco2', '', nxtWideString, 60, 0, False);
AddField('end_numero', '', nxtWideString, 20, 0, False);
AddField('cidade', '', nxtWideString, 40, 0, False);
AddField('cep', '', nxtWideString, 10, 0, False);
AddField('bairro', '', nxtWideString, 30, 0, False);
AddField('end_codmun', '', nxtWideString, 7, 0, False);
AddField('uf', '', nxtWideString, 30, 0, False);
AddField('end_obs', '', nxtWideString, 40, 0, False);
AddField('def_cad', '', nxtBoolean, 0, 0, False);
AddField('def_ent', '', nxtBoolean, 0, 0, False);
AddField('def_cob', '', nxtBoolean, 0, 0, False);
AddField('pais', '', nxtWideString, 2, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_cliente_pos', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('cliente_id'));
Add(GetFieldFromName('pos'));
end;
with AddIndex('I_endereco_id', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('endereco_id'));
with AddIndex('INumSeq', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('NumSeq'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// opest
function __tipotran(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('tipo', '', nxtByte, 0, 0, False);
AddField('user', '', nxtBoolean, 0, 0, False);
AddField('estoque', '', nxtBoolean, 0, 0, False);
AddField('caixa', '', nxtBoolean, 0, 0, False);
AddField('nome', '', nxtWideString, 50, 0, False);
AddField('entrada', '', nxtBoolean, 0, 0, False);
AddField('emite_nfe', '', nxtBoolean, 0, 0, False);
AddField('movest', '', nxtBoolean, 0, 0, False);
AddField('atualiza_custo', '', nxtBoolean, 0, 0, False);
AddField('visivel', '', nxtBoolean, 0, 0, False);
AddField('precocusto_nfe', '', nxtBoolean, 0, 0, False);
AddField('pagto', '', nxtBoolean, 0, 0, False);
AddField('sel_endereco', '', nxtBoolean, 0, 0, False);
AddField('tipocad', '0=não identificar, 1=cliente, 2=fornecedor, 3=filiais', nxtByte, 0, 0, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_tipo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('tipo'));
with AddIndex('I_nome', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('tipo'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
// opest_brtrib
function __brtrib_tipo(aDatabase : TnxDatabase): TnxDataDictionary;
begin
Result := TnxDataDictionary.Create;
try
with Result do begin
AddRecordDescriptor(TnxBaseRecordDescriptor);
with FieldsDescriptor do begin
AddField('ID', '', nxtAutoInc, 10, 0, False);
with AddField('UID', '', nxtGUID, 0, 0, False) do
AddDefaultValue(TnxAutoGuidDefaultValueDescriptor);
AddField('tipo', '', nxtByte, 5, 0, False);
AddField('id_brtrib', '', nxtWord16, 5, 0, False);
AddField('local', '', nxtByte, 0, 0, False);
AddField('csosn', '', nxtWord32, 10, 0, False);
AddField('cfop', '', nxtWord32, 10, 0, False);
AddField('natop', '', nxtWideString, 60, 0, False);
AddField('obsfiscal', '', nxtBlobWideMemo, 0, 0, False);
AddField('icms', '', nxtDouble, 0, 2, False);
end;
with EnsureIndicesDescriptor do begin
with AddIndex('I_brtrib_tipo', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('id_brtrib'));
Add(GetFieldFromName('tipo'));
Add(GetFieldFromName('local'));
end;
with AddIndex('I_tipo_brtrib', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do begin
Add(GetFieldFromName('tipo'));
Add(GetFieldFromName('id_brtrib'));
Add(GetFieldFromName('local'));
end;
with AddIndex('IID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('ID'));
with AddIndex('IUID', 0, idAll), KeyDescriptor as TnxCompKeyDescriptor do
Add(GetFieldFromName('UID'));
end;
CheckValid(False);
end;
except
FreeAndNil(Result);
raise;
end;
end;
function TncTableInfo.Bkp: Boolean;
begin
Result := (Backup=1);
end;
constructor TncTableInfo.Create(
aTableName : String;
aCallback : TnxcgCreateDictCallback;
aTableID : Byte;
aBackup : Byte;
aID_Name : String;
aID_IxName : String;
aUID_Name : String;
aUID_IxName : String);
begin
TableName := aTableName;
Backup := aBackup;
if aID_Name='' then
ID_Name := 'ID' else
ID_Name := aID_Name;
if aID_IxName='' then
ID_IxName := 'IID' else
ID_IxName := aID_IxName;
if aUID_Name='' then
UID_Name := 'UID' else
UID_Name := aUID_Name;
if aUID_IxName='' then
UID_IxName := 'IUID' else
UID_IxName := aUID_IxName;
Callback := aCallback;
TableID := aTableID;
end;
function DatabaseVersion: Cardinal;
begin
Result := Cardinal($04000000);
end;
function DatabaseVersionStr: String;
begin
Result :=
Format('%d.%d.%d.%d',
[(DatabaseVersion and $ff000000) shr 24,
(DatabaseVersion and $00ff0000) shr 16,
(DatabaseVersion and $0000ff00) shr 8,
(DatabaseVersion and $000000ff)]);
end;
function __GetTablePrimaryKey(aTable: String): String;
begin
if SameText(aTable, 'usuario') then
Result := 'Username'
else
if SameText(aTable, 'categoria') then
Result := 'Descricao'
else
if SameText(aTable, 'unidade') then
Result := 'Descricao'
else
if SameText(aTable, 'Aviso') then
Result := 'Minutos'
else
if SameText(aTable, 'Config') then
Result := 'NumSeq'
else
if SameText(aTable, 'Maq') or SameText(aTable, 'Maquina') then
Result := 'Numero'
else
if SameText(aTable, 'Orcamento') or SameText(aTable, 'IOrcamento') or SameText(aTable, 'Doc') then
Result := 'UID';
end;
function GetTableDictionary(aDatabase : TnxDatabase; const aTableName : String): TnxDataDictionary;
begin
Result := gTables[aTableName].Callback(aDatabase);
end;
procedure RestructureTable(aDatabase : TnxDatabase;
const aTableName, aPassword : String;
aNewDict : TnxDataDictionary;
aProgressCallback : TnxcgProgressCallback;
var aCancelTask : Boolean;
aFreeDict : Boolean = False);
var
OldDict : TnxDataDictionary;
Mapper : TnxTableMapperDescriptor;
TaskInfo : TnxAbstractTaskInfo;
Completed : Boolean;
TaskStatus : TnxTaskStatus;
begin
try
OldDict := TnxDataDictionary.Create;
try
nxCheck(aDatabase.GetDataDictionaryEx(aTableName, aPassword, OldDict));
if (aPassword <> '') and (aNewDict.EncryptionEngine = '') then
aNewDict.EncryptionEngine := OldDict.EncryptionEngine;
if OldDict.IsEqual(aNewDict) then
Exit;
if (not aCopiouArqs) and (not SameText(aTableName, 'config')) then
begin
aCopiouArqs := True;
FrmCopia.CopiaDados('_ver'+SelfShortVer, 'config.nx1');
end;
Mapper := TnxTableMapperDescriptor.Create;
try
Mapper.MapAllTablesAndFieldsByName(OldDict, aNewDict);
nxCheck(aDatabase.RestructureTableEx(aTableName, aPassword, aNewDict, Mapper, TaskInfo));
if Assigned(TaskInfo) then
try
repeat
if not aCancelTask then
TaskInfo.GetStatus(Completed, TaskStatus);
if not Completed then begin
if Assigned(aProgressCallback) then
aProgressCallback(aTableName, TaskStatus, aCancelTask);
if not aCancelTask then
Sleep(100)
else
nxCheck(TaskInfo.Cancel);
end;
until Completed or aCancelTask;
nxCheck(TaskStatus.tsErrorCode);
finally
TaskInfo.Free;
end;
finally
Mapper.Free;
end;
finally
OldDict.Free;
end;
finally
if aFreeDict then
aNewDict.Free;
end;
end;
procedure PackTable(aDatabase : TnxDatabase;
const aTableName, aPassword : String;
aProgressCallback : TnxcgProgressCallback;
var aCancelTask : Boolean);
var
TaskInfo : TnxAbstractTaskInfo;
Completed : Boolean;
TaskStatus : TnxTaskStatus;
begin
nxCheck(aDatabase.PackTableEx(aTableName, aPassword, TaskInfo));
if Assigned(TaskInfo) then
try
while True do begin
TaskInfo.GetStatus(Completed, TaskStatus);
if Assigned(aProgressCallback) then
aProgressCallback(aTableName, TaskStatus, aCancelTask);
if Completed then
break;
if aCancelTask then
nxCheck(TaskInfo.Cancel);
end;
finally
TaskInfo.Free;
end;
end;
procedure BuildAndEvolveTable(aDatabase : TnxDatabase;
const aTableName, aPassword : String;
aCreateDictCallback : TnxcgCreateDictCallback;
aProgressCallback : TnxcgProgressCallback;
var aCancelTask : Boolean);
var
Dict : TnxDataDictionary;
aPass: String;
begin
Dict := aCreateDictCallback(aDatabase);
if Assigned(Dict) then
try
aPass := '';
if not aDatabase.TableExists(aTableName, aPassword) then
aDatabase.CreateTable(False, aTableName, aPass, Dict)
else
RestructureTable(aDatabase, aTableName,
aPass, Dict, aProgressCallback, aCancelTask);
finally
Dict.Free;
end;
end;
procedure BuildAndEvolveDatabase(aDatabase : TnxDatabase;
aProgressCallback : TnxcgProgressCallback;
const aPassword : String);
var
I : Integer;
CancelTask : Boolean;
begin
gEvolvingTables := True;
aCopiouArqs := False;
try
CancelTask := False;
for I := 0 to gTables.Count-1 do with gTables.Items[I] do begin
gEvolvingTableName := TableName;
DebugMsg('BuildAndEvolveDatabase - '+gEvolvingTableName);
try
BuildAndEvolveTable(aDatabase, TableName, aPassword, Callback, aProgressCallback, CancelTask);
except
on E: Exception do begin
DebugEx(nil, 'BuildAndEvolveDatabase - '+gEvolvingTableName, E, True);
raise Exception.Create('Erro evolving table: '+gEvolvingTableName+': '+E.Message);
end;
end;
if CancelTask then
Exit;
end;
finally
gEvolvingTables := False;
end;
end;
procedure RestructureDatabase(aDatabase : TnxDatabase;
aProgressCallback : TnxcgProgressCallback;
const aPassword : String);
var
I : Integer;
CancelTask : Boolean;
begin
CancelTask := False;
for I := 0 to gTables.Count-1 do with gTables.Items[I] do begin
RestructureTable(aDatabase, TableName, aPassword, Callback(aDatabase), aProgressCallback, CancelTask, True);
if CancelTask then Exit;
end;
end;
procedure PackDatabase(aDatabase : TnxDatabase;
aProgressCallback : TnxcgProgressCallback;
const aPassword : String);
var
I : Integer;
CancelTask : Boolean;
begin
CancelTask := False;
for I := 0 to gTables.Count-1 do with gTables.Items[I] do begin
PackTable(aDatabase, TableName, aPassword, aProgressCallback, CancelTask);
if CancelTask then Exit;
end;
end;
function TncTableManager.GetByName(aName: String): TncTableInfo;
var I: Integer;
begin
for i := 0 to FItems.Count-1 do
if SameText(GetItem(I).TableName, aName) then begin
Result := GetItem(I);
Exit;
end;
Result := nil;
end;
function TncTableManager.GetByID(aID: Byte): TncTableInfo;
var I: Integer;
begin
for i := 0 to FItems.Count-1 do
if GetItem(I).TableID=aID then begin
Result := GetItem(I);
Exit;
end;
Result := nil;
end;
function TncTableManager.GetItem(aIndex: Integer): TncTableInfo;
begin
Result := TncTableInfo(FItems[aIndex]);
end;
procedure TncTableManager.GetTableNames(sl: TStrings);
var i: integer;
begin
sl.Clear;
for I := 0 to Count-1 do sl.Add(GetItem(i).TableName);
end;
constructor TncTableManager.Create;
begin
FItems := TList.Create;
end;
destructor TncTableManager.Destroy;
begin
while FItems.Count>0 do begin
TObject(FItems[0]).Free;
FItems.Delete(0)
end;
FItems.Free;
inherited;
end;
procedure TncTableManager.Add(
aTableName : String;
aCallback : TnxcgCreateDictCallback;
aTableID : Byte;
aBackup : Byte = 1;
aID_Name : String = '';
aID_IxName : String = '';
aUID_Name : String = '';
aUID_IxName : String = '');
begin
FItems.Add(TncTableInfo.Create(aTableName, aCallback, aTableID, aBackup, aID_Name, aID_IxName, aUID_Name, aUID_IxName));
end;
function TncTableManager.Count: Integer;
begin
Result := FItems.Count;
end;
initialization
gTables := TncTableManager.Create;
with gTables do begin
//Tabelas que não fazem backup no cloud
Add('bk_control', __bk_control, idtb_bk_control, 0);
Add('bk_process', __bk_process, idtb_bk_process, 0);
Add('bk_upload', __bk_upload, idtb_bk_upload, 0);
Add('RecDel', __RecDel, idtb_RecDel, 0);
Add('Card', __Card, idtb_Card, 0);
Add('post_nexapp', __post_nexapp, idtb_post_nexapp, 0);
Add('Layout', __Layout, idtb_Layout, 0);
Add('Categoria', __Categoria, idtb_Categoria, 0);
Add('NCM', __NCM, idtb_NCM, 0);
Add('temp', __temp, idtb_temp, 0);
Add('PostMS', __PostMS, idtb_PostMS, 0);
Add('Doc', __Doc, idtb_Doc, 0);
Add('br_cest', __br_cest, idtb_br_cest, 0);
Add('CFOP', __CFOP, idtb_CFOP, 0);
Add('MunBr', __MunBr, idtb_MunBR, 0);
Add('tipotran', __tipotran, idtb_tipotran, 0);
// Tabelas que fazem backup no cloud
Add('Caixa', __Caixa, idtb_Caixa);
Add('Credito', __Credito, idtb_Credito);
Add('Cliente', __Cliente, idtb_Cliente);
Add('ITran', __ITran, idtb_ITran);
Add('MovEst', __MovEst, idtb_MovEst);
Add('Produto', __Produto, idtb_Produto);
Add('Marca', __Marca, idtb_Marca);
Add('Tran', __Tran, idtb_Tran);
Add('Usuario', __Usuario, idtb_Usuario);
Add('infoCampanha', __infocampanha, idtb_infoCampanha);
Add('Unidade', __Unidade, idtb_Unidade);
Add('Especie', __Especies, idtb_Especie);
Add('PagEspecies', __PagEspecies, idtb_PagEspecies);
Add('IOrcamento', __IOrcamento, idtb_IOrcamento);
Add('syslog', __syslog, idtb_syslog);
Add('NFCONFIG', __NFCONFIG, idtb_NFConfig);
Add('BRTrib', __BRTrib, idtb_BRTrib);
Add('ConvUnid', __ConvUnid, idtb_ConvUnid);
Add('ProdFor', __ProdFor, idtb_ProdFor);
Add('tax_itens', __tax_itens, idtb_tax_itens);
Add('movest_tax', __movest_tax, idtb_movest_tax);
Add('BRTrib_Tipo', __brtrib_tipo, idtb_BRTrib_Tipo);
Add('LinkXML', __LinkXML, idtb_LinkXML);
Add('xmls_compra', __xmls_compra, idtb_xmls_compra);
Add('DadosFiscais', __DadosFiscais, idtb_DadosFiscais);
Add('cfop_dev', __cfop_dev, idtb_cfop_dev);
Add('SolicitacoesSped', __SolicitacoesSped, idtb_SolicitacoesSped);
Add('Sped_C190', __Sped_C190, idtb_Sped_C190);
Add('Sped_E210', __Sped_E210, idtb_Sped_E210);
Add('movEst_Sped', __movEst_Sped, idtb_movEstSped);
//Tabelas que fazem backup no cloud mas possuem campos/indices de ID ou UID diferente do padrão
Add('tax', __tax, idtb_tax, 1, 'tax_id', 'I_tax_id');
Add('Orcamento', __Orcamento, idtb_Orcamento, 1, 'IDSeq', 'IIDSeq');
Add('Config', __Config, idtb_Config, 1, 'NumSeq', 'INumSeq');
Add('Debito', __Debito, idtb_Debito, 1, 'NumSeq', 'INumSeq');
Add('NFE', __NFE, idtb_NFE, 1, 'NumSeq', 'INumSeq');
Add('CCE', __CCE, idtb_CCE, 1, 'NumSeq', 'INumSeq');
Add('Terminal', __Terminal, idtb_Terminal, 1, '', '', 'TermID', 'ITermID');
Add('endereco', __endereco, idtb_endereco, 1, 'NumSeq', 'INumSeq', 'endereco_id', 'I_endereco_id');
end;
finalization
gTables.Free;
end. |
unit u_Comm;
interface
uses Windows, Forms, Messages, ComCtrls, SysUtils, Variants, Classes, SyncObjs, IniFiles
, UniDBC, u_OneIC, u_Mes, u_CommBag;
type
TPDAConnInfo = record
TID: THandle;
IP: string;
Port: Word;
CreateTime: TDateTime;
LastActiveTime: TDateTime;
end;
procedure _AddPDAList();
procedure _RemovePDAList();
procedure _UpdatePDAList(const SubIndex: Integer; const Value: string);
procedure _AddDataList(const TID: THandle; const ClientIP, Info: string);
//检测数据库连接
procedure _CheckDBConn();
//获取帐户信息
procedure _GetUserInfo(var UI: TUserInfo; var rt: Integer; var rtStr: string);
//获取车辆信息
procedure _GetCarInfo(var CI: TCarInfo; var rt: Integer; var rtStr: string);
//保存登记记录
function _SaveInOutRec(const IOR: TInOutRec; var DataFlag, rt: Integer; var rtStr: string): Boolean;
//载入配置文件
function _LoadCfgFile(): boolean;
var
_PI: TPDAConnInfo;
_SBar: TStatusBar;
_PDAList: TListView;
_DataList: TListView;
_CS: TCriticalSection;
//配置文件
_SvrName:string;
_SvrPort: Word;
_ActiveTimeOut: Word;
_CheckDBTimeOut: Word;
//OneIC Conn
OneIC_ConnCfg: TConnCfg;
OneIC_DBC: TOneICDBCtl;
OneIC_CS: TCriticalSection;
//MES Conn
MES_ConnCfg: TConnCfg;
MES_DBC: TMESDBCtl;
MES_CS: TCriticalSection;
implementation
function _LoadCfgFile(): boolean;
var
inif: TIniFile;
inifile: string;
begin
Result := False;
inifile := ExtractFilePath(Application.ExeName) + 'PDAServer.ini';
if not FileExists(inifile) then exit;
inif := TIniFile.Create(inifile);
try
_SvrName:= inif.ReadString('PDAServer', 'SvrName', '');
_SvrPort := inif.ReadInteger('PDAServer', 'SvrPort', 10008);
_ActiveTimeOut := inif.ReadInteger('PDAServer', 'ActiveTimeOut', 200);
if _ActiveTimeOut < 200 then _ActiveTimeOut := 200;
if _ActiveTimeOut > 600 then _ActiveTimeOut := 600;
_CheckDBTimeOut := inif.ReadInteger('PDAServer', 'CheckDBTimeOut', 60);
if _CheckDBTimeOut < 60 then _CheckDBTimeOut := 60;
if _CheckDBTimeOut > 600 then _CheckDBTimeOut := 600;
//OneIC Conn
OneIC_ConnCfg.ProviderName := inif.ReadString('OneIC', 'ProviderName', 'SQL Server');
OneIC_ConnCfg.IsDirect := inif.ReadBool('OneIC', 'IsDirect', false);
OneIC_ConnCfg.Server := inif.ReadString('OneIC', 'Server', '');
OneIC_ConnCfg.Port := inif.ReadInteger('OneIC', 'Port', 0);
OneIC_ConnCfg.Database := inif.ReadString('OneIC', 'Database', '');
OneIC_ConnCfg.Username := inif.ReadString('OneIC', 'UID', '');
OneIC_ConnCfg.Password := inif.ReadString('OneIC', 'PWD', '');
//MES Conn
MES_ConnCfg.ProviderName := inif.ReadString('MES', 'ProviderName', 'Oracle');
MES_ConnCfg.IsDirect := inif.ReadBool('MES', 'IsDirect', false);
MES_ConnCfg.Server := inif.ReadString('MES', 'Server', '');
MES_ConnCfg.Port := inif.ReadInteger('MES', 'Port', 0);
MES_ConnCfg.Database := inif.ReadString('MES', 'Database', '');
MES_ConnCfg.Username := inif.ReadString('MES', 'UID', '');
MES_ConnCfg.Password := inif.ReadString('MES', 'PWD', '');
Result := True;
finally
inif.Free;
end;
end;
procedure _UpdatePDAList(const SubIndex: Integer; const Value: string);
var
Item: TListItem;
i: Integer;
begin
try
for I := _PDAList.Items.Count - 1 downto 0 do
begin
Item := _PDAList.Items[i];
if (IntToStr(_PI.TID) = Trim(Item.Caption)) and (_PI.IP = Item.SubItems[0]) then
Item.SubItems[SubIndex] := Value;
end;
except
;
end;
end;
procedure _AddPDAList();
var
Item: TListItem;
begin
Item := _PDAList.Items.Add;
Item.Caption := IntToStr(_PI.TID);
Item.SubItems.Add(_PI.IP);
Item.SubItems.Add(IntToStr(_PI.Port));
Item.SubItems.Add(FormatDateTime('YYYY-MM-DD hh:nn:ss', _PI.CreateTime));
Item.SubItems.Add(FormatDateTime('YYYY-MM-DD hh:nn:ss', _PI.LastActiveTime));
end;
procedure _AddDataList(const TID: THandle; const ClientIP, Info: string);
var
Item: TListItem;
begin
Item := _DataList.Items.Insert(0);
Item.Caption :=FormatDateTime('YYYY-MM-DD hh:nn:ss', Now) ;
Item.SubItems.Add(IntToStr(TID));
Item.SubItems.Add(ClientIP);
Item.SubItems.Add(Info);
if _DataList.Items.Count > 50 then
_DataList.Items.Delete(50);
end;
procedure _RemovePDAList();
var
Item: TListItem;
i: Integer;
begin
for I := _PDAList.Items.Count - 1 downto 0 do
begin
Item := _PDAList.Items[i];
if (IntToStr(_PI.TID) = Trim(Item.Caption)) and (_PI.IP = Item.SubItems[0]) then
Item.Delete;
end;
end;
procedure _CheckDBConn();
var
dt: TDateTime;
begin
OneIC_CS.Enter;
try
if not OneIC_DBC.GetSvrDateTime(dt) then
begin
_SBar.Panels[5].Text := '重连中...';
Application.ProcessMessages;
OneIC_DBC.ReConnDB;
end;
if OneIC_DBC.IsConn then
_SBar.Panels[5].Text := '正常'
else
_SBar.Panels[5].Text := '断开';
finally
OneIC_CS.Leave;
end;
MES_CS.Enter;
try
if not MES_DBC.GetSvrDateTime(dt) then
begin
_SBar.Panels[7].Text := '重连中...';
Application.ProcessMessages;
MES_DBC.ReConnDB;
end;
if MES_DBC.IsConn then
_SBar.Panels[7].Text := '正常'
else
_SBar.Panels[7].Text := '断开';
finally
MES_CS.Leave;
end;
end;
procedure _GetUserInfo(var UI: TUserInfo; var rt: Integer; var rtStr: string);
begin
OneIC_CS.Enter;
try
rt := OneIC_DBC.GetUserInfo(UI);
rtStr := OneIC_DBC.GetRtInfo(rt);
finally
OneIC_CS.Leave;
end;
end;
procedure _GetCarInfo(var CI: TCarInfo; var rt: Integer; var rtStr: string);
begin
MES_CS.Enter;
try
rt := MES_DBC.GetCarInfo(CI);
rtStr := MES_DBC.GetRtInfo(rt);
finally
MES_CS.Leave;
end;
end;
function _SaveInOutRec(const IOR: TInOutRec; var DataFlag, rt: Integer; var rtStr: string): Boolean;
var
PI: TPDAInfo;
begin
Result := False;
DataFlag := 0;
OneIC_CS.Enter;
try
//如果找不到此PDA，那么提示未授权PDA设备
FillChar(PI, SizeOf(TPDAInfo), 0);
PI.PDANum := IOR.PDANum;
PI.PDAName := '---';
rt := OneIC_DBC.GetPDAInfo(PI);
rtStr := OneIC_DBC.GetRtInfo(rt);
if rt > 0 then
begin
//检测PDA与驾驶员关联
rt := OneIC_DBC.UserAndMachIsLink(IOR.Driver.UserID, PI.MachID);
rtStr := OneIC_DBC.GetRtInfo(rt);
if rt > 0 then
DataFlag := 1
else
DataFlag := -2; //未关联PDA
end
else
DataFlag := -1; //未授权PDA
finally
OneIC_CS.Leave;
end;
//////////////////////////////////////////////////////////////
MES_CS.Enter;
try
if DataFlag > 0 then
begin
rt := MES_DBC.SaveInOutRec(IOR, PI.PDAName, DataFlag);
rtStr := MES_DBC.GetRtInfo(rt);
Result := True;
end
else
begin
//异常记录，不提示是否成功!
MES_DBC.SaveInOutRec(IOR, PI.PDAName, DataFlag);
end;
finally
MES_CS.Leave;
end;
end;
end.
|
{*******************************************************}
{ }
{ Delphi DataSnap Framework }
{ }
{ Copyright(c) 1995-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit Datasnap.DSPlatform;
interface
uses
Datasnap.DSCommonTable,
Data.DBXCommon,
Data.DBXJSON,
System.Classes,
System.JSON;
type
{$MethodInfo ON}
TDBXServerComponent = class(TComponent)
private
HasTunnelSessionEvent: Boolean;
function ConsumeAllClientChannel(const ChannelName: string; const ChannelId: string;
const CallbackId: string; const SecurityToken: string; ChannelNames: TStringList;
ChannelCallback: TDBXCallback; Timeout: Cardinal): Boolean;
function ConsumeOneClientChannel(const ChannelName, ClientManagerId, CallbackId: string;
const SecurityToken: string; ChannelNames: TStringList;
ResponseData: TJSONValue; Timeout: Cardinal): TJSONValue;
protected
/// <summary>Returns the name of the Server for the current instance of this component</summary>
function GetDSServerName: string; virtual; abstract;
public
constructor Create(AOwner: TComponent); overload; override;
constructor Create; reintroduce; overload; virtual;
/// <summary> Consume callback channel events one at a time </summary>
/// <remarks> Used mainly with JS API </remarks>
function ConsumeClientChannel(const ChannelName, ClientManagerId, CallbackId, ChannelNames: string;
const SecurityToken: string;
ResponseData: TJSONValue): TJSONValue;
function ConsumeClientChannelTimeout(const ChannelName, ClientManagerId, CallbackId: string;
const ChannelNames, SecurityToken: string;
Timeout: Integer; ResponseData: TJSONValue): TJSONValue;
/// <summary> Connects to the channel when the first callback registers with client manager
/// </summary>
function ConnectClientChannel(const ChannelName: string; const ChannelId: string;
const CallbackId, ChannelNames, SecurityToken: string;
ChannelCallback: TDBXCallback): Boolean;
function ConnectClientChannelTimeout(const ChannelName: string; const ChannelId: string;
const CallbackId, ChannelNames, SecurityToken: string;
ChannelCallback: TDBXCallback; Timeout: Integer): Boolean;
/// <summary> Closes the client channel </summary>
function CloseClientChannel(const ChannelId, SecurityToken: string): Boolean;
/// <summary> Registers a new callback callback </summary>
function RegisterClientCallback(const ChannelId: string;
const CallbackId, ChannelNames, SecurityToken: string; ChannelCallback: TDBXCallback): Boolean;
function RegisterClientCallbackServer(const ChannelId: string;
const CallbackId, ChannelNames, SecurityToken: string): Boolean;
/// <summary> Unregisters the client callback </summary>
function UnregisterClientCallback(const ChannelId: string;
const CallbackId: string; const SecurityToken: string): Boolean;
/// <summary> Broadcast a message to all of the registered callbacks of the given channel </summary>
/// <remarks> Annotated with 'ChannelBroadcast' as the authorized role. </remarks>
/// <param name="ChannelName">Name of the channel to notify all registered callbacks for</param>
/// <param name="Msg">The message to broadcast</param>
/// <returns>true if the broadcast was successful, false otherwise</returns>
function BroadcastToChannel(const ChannelName: string; const Msg: TJSONValue): Boolean;
function BroadcastObjectToChannel(const ChannelName: string; const Msg: TObject): Boolean;
/// <summary> Notifies a client callback with the specified message </summary>
/// <remarks> Annotated with 'ChannelNotify' as the authorized role. </remarks>
/// <param name="ClientId"> The ChannelId of the client </param>
/// <param name="CallbackId"> The Id of the callback on the client to notify </param>
/// <param name="Msg">The message to notify with</param>
/// <param name="Response">Output parameter containing the client's response value</param>
/// <returns>true if the notification was successful, false otherwise</returns>
function NotifyCallback(const ClientId: string;
const CallbackId: string;
const Msg: TJSONValue; out Response: TJSONValue): Boolean;
function NotifyObject(const ClientId, CallbackId: string;
const Msg: TObject; out Response: TObject): Boolean;
end;
{$MethodInfo OFF}
TDSPlatform = class
public
class function DefaultPackageName: string; static;
class function DataSnapAdminClassName: string; static;
class function DataSnapAdminUnitName: string; static;
class function MetadataClassName: string; static;
class function MetadataUnitName: string; static;
class function PlatformName: string; static;
class function GetDatabaseConnection(DBXContext: TDBXContext;
ServerConnectionName: string;
ConProperties: TDBXProperties
): TDBXConnection; static;
class procedure GetConnectionProperties(Connections: TDSConnectionEntity); static;
end;
implementation
uses
Data.DBXCommonTable,
Datasnap.DSCommonServer,
Data.DBXMessageHandlerJSonServer,
Datasnap.DSServer,
Datasnap.DSSession,
System.SysUtils;
{ TDSPlatform }
class function TDSPlatform.DataSnapAdminUnitName: string;
begin
Result := 'DSCommonServer';
end;
class function TDSPlatform.DefaultPackageName: string;
begin
Result := '';
end;
class procedure TDSPlatform.GetConnectionProperties(
Connections: TDSConnectionEntity);
var
Factory: TDBXConnectionFactory;
Items: TStrings;
Row: Integer;
DriverName, Name: string;
ConProperties: TDBXProperties;
LProperties: TDBXProperties;
begin
Factory := TDBXConnectionFactory.GetConnectionFactory;
Items := TStringList.Create;
try
TDBXConnectionFactory.Lock;
try
Factory.GetConnectionItems(Items);
for Row := 0 to Items.Count - 1 do
begin
Connections.Table.Insert;
Name := Items[Row];
Connections.ConnectionName := Name;
ConProperties := Factory.GetConnectionProperties(Name);
Connections.ConnectionProperties := ConProperties.Properties.DelimitedText;
DriverName := ConProperties[TDBXPropertyNames.DriverName];
Connections.DriverName := DriverName;
if DriverName.Length > 0 then
begin
try
LProperties := Factory.GetDriverProperties(DriverName);
if LProperties <> nil then
Connections.DriverProperties := LProperties.Properties.DelimitedText
except on ex: Exception do
Connections.DriverProperties := ex.Message;
end;
end;
Connections.Table.Post;
end;
finally
TDBXConnectionFactory.Unlock;
end;
finally
Items.Free;
end;
end;
class function TDSPlatform.GetDatabaseConnection(
DBXContext: TDBXContext;
ServerConnectionName: string;
ConProperties: TDBXProperties
): TDBXConnection;
begin
Result :=
TDBXDriverHelp.GetConnection(
TDBXConnectionFactory.GetConnectionFactory,
DBXContext,
ServerConnectionName
);
end;
class function TDSPlatform.DataSnapAdminClassName: string;
begin
Result := 'DSAdmin';
end;
class function TDSPlatform.PlatformName: string;
begin
Result := 'win32';
end;
class function TDSPlatform.MetadataClassName: string;
begin
Result := 'DSMetadata';
end;
class function TDSPlatform.MetadataUnitName: string;
begin
Result := 'DSCommonServer';
end;
{ TDBXServerComponent }
constructor TDBXServerComponent.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
HasTunnelSessionEvent := False;
end;
function TDBXServerComponent.ConsumeAllClientChannel(const ChannelName,
ChannelId, CallbackId, SecurityToken: string; ChannelNames: TStringList;
ChannelCallback: TDBXCallback; Timeout: Cardinal): Boolean;
var
ServerCallback: TDBXServerCallback;
DSServer: TDSServer;
CallbackTunnel: TDSCallbackTunnel;
Msg: TJSONObject;
Data: TJSONValue;
ArgType: Integer;
IsBroadcast: Boolean;
IsAquired: Boolean;
QueueMessage: TDSCallbackTunnelBufferItem;
WasConnectionLost: Boolean;
LSessionEvent: TDSSessionEvent;
LSession: TDSSession;
LSessionId: string;
begin
WasConnectionLost := False;
if ChannelCallback is TDBXCallbackDelegate then
begin
ServerCallback := (ChannelCallback as TDBXCallbackDelegate).Delegate as TDBXServerCallback;
// get the server instance
DSServer := ServerCallback.DsServer as TDSServer;
// get the callback tunnel
CallbackTunnel := DSServer.CreateChannelTunnel(ChannelName, ChannelId, CallbackId, ChannelNames, SecurityToken);
if CallbackTunnel <> nil then
begin
//add a session event used to close this tunnel if the session closes
LSession := TDSSessionManager.GetThreadSession;
if LSession <> nil then
begin
LSessionId := LSession.SessionName;
LSessionEvent :=
procedure(Sender: TObject; const EventType: TDSSessionEventType;
const Session: TDSSession)
begin
case EventType of
SessionClose:
begin
if LSessionId = Session.SessionName then
TMonitor.Pulse(CallbackTunnel.Queue);
end;
end;
end;
TDSSessionManager.Instance.AddSessionEvent(LSessionEvent);
end;
try
// wait for exit message
repeat
Data := nil;
IsBroadcast := false;
ArgType := TDBXCallback.ArgJson;
QueueMessage := nil;
TMonitor.Enter(CallbackTunnel.Queue);
try
{Wait for a queue item to be added if the queue is empty, otherwise
don't wait and just pop the next queue item}
if CallbackTunnel.Queue.QueueSize = 0 then
IsAquired := TMonitor.Wait(CallbackTunnel.Queue, Timeout)
else
IsAquired := true;
if IsAquired and (CallbackTunnel.Queue.QueueSize > 0) then
begin
{Get the next queued item from the tunnel}
QueueMessage := CallbackTunnel.Queue.PopItem;
Data := QueueMessage.Msg;
IsBroadcast := QueueMessage.IsBroadcast;
ArgType := QueueMessage.ArgType;
end;
finally
TMonitor.Exit(CallbackTunnel.Queue);
end;
if IsAquired and (Data <> nil) then
begin
if IsBroadcast then
begin
try
//if this is a broadcast, but has a callbackId specified, it is a selective broadcast,
//to only one of the callbacks of the client.
if QueueMessage.CallbackId <> EmptyStr then
Msg := TJSONObject.Create( TJSONPair.Create('invoke',
TJSONArray.Create( TJSONString.Create(QueueMessage.CallbackId),
Data).Add(ArgType)))
else
begin
Msg := TJSONObject.Create(TJSONPair.Create('broadcast',
TJSONArray.Create(Data).Add(ArgType)));
end;
if (QueueMessage.ChannelName <> EmptyStr) and
(QueueMessage.ChannelName <> CallbackTunnel.ServerChannelName) then
Msg.AddPair(TJSONPair.Create('channel', QueueMessage.ChannelName));
try
ChannelCallback.Execute(Msg).Free;
except
try
// Remove the callback tunnel from the list, it will be freed at the end of this method
InternalRemoveCallbackTunnel(DSServer, CallbackTunnel);
except
end;
raise;
end;
finally
QueueMessage.InstanceOwner := false;
FreeAndNil(QueueMessage);
end;
end
else if Assigned(QueueMessage) then
begin
TMonitor.Enter(QueueMessage);
try
Msg := TJSONObject.Create( TJSONPair.Create('invoke',
TJSONArray.Create( TJSONString.Create(QueueMessage.CallbackId),
Data).Add(ArgType)));
try
QueueMessage.Response := ChannelCallback.Execute(Msg);
except
on E : Exception do
begin
QueueMessage.IsError := True;
QueueMessage.Response := TJSONObject.Create(TJSONPair.Create('error', E.Message));
if ChannelCallback.ConnectionLost then
begin
WasConnectionLost := True;
TMonitor.Pulse(QueueMessage);
try
// Remove the callback tunnel from the list, it will be freed at the end of this method
InternalRemoveCallbackTunnel(DSServer, CallbackTunnel);
except
end;
Break;
end;
end;
end;
TMonitor.Pulse(QueueMessage);
finally
TMonitor.Exit(QueueMessage);
end;
end;
end
else
begin
try
// Remove the callback tunnel from the list, it will be freed at the end of this method
InternalRemoveCallbackTunnel(DSServer, CallbackTunnel);
except
end;
end;
until (not IsAquired) or (Data = nil);
finally
//remove the session event used to close the tunnel if the session closes
if LSession <> nil then
TDSSessionManager.Instance.RemoveSessionEvent(LSessionEvent);
//if the connection wasn't lost then this must be the termination (nil) message, so free it
//otherwise, the caller sending the message (who pushed it into the tunnel's queue) should free it
if not WasConnectionLost then
FreeAndNil(QueueMessage)
else
begin
//loop over all remaining messages and pulse them. Free one if Data = nil (the termination message)
//this is done so no messages are left in the queue waiting and so the termination message gets freed
while CallbackTunnel.Queue.QueueSize > 0 do
begin
QueueMessage := CallbackTunnel.Queue.PopItem;
if QueueMessage <> nil then
begin
TMonitor.Pulse(QueueMessage);
if QueueMessage.Msg = nil then
FreeAndNil(QueueMessage);
end;
end;
end;
// free the callback tunnel
TDSCallbackTunnelManagerInternal(TDSCallbackTunnelManager.Instance).CloseChannelTunnel(CallbackTunnel);
end;
exit(true);
end
else
exit(false);
end
else
exit(false);
end;
function TDBXServerComponent.ConsumeClientChannel(const ChannelName, ClientManagerId,
CallbackId, ChannelNames, SecurityToken: string; ResponseData: TJSONValue): TJSONValue;
begin
Result := ConsumeClientChannelTimeout(ChannelName, ClientManagerId, CallbackId, ChannelNames,
SecurityToken, -1, ResponseData);
end;
function TDBXServerComponent.ConsumeClientChannelTimeout(const ChannelName,
ClientManagerId, CallbackId, ChannelNames, SecurityToken: string; Timeout: Integer;
ResponseData: TJSONValue): TJSONValue;
var
ms: Cardinal;
LChannelNames: TStringList;
begin
if Timeout < 0 then
ms := INFINITE
else
ms := Timeout * 1000;
LChannelNames := nil;
//only build a list of channel names if a callback is beign registered and specifies some in CSV form
if (CallbackId <> EmptyStr) and (ChannelNames <> EmptyStr) then
begin
LChannelNames := TStringList.Create;
LChannelNames.CommaText := ChannelNames;
end;
try
Result := ConsumeOneClientChannel(ChannelName, ClientManagerId, CallbackId,
SecurityToken, LChannelNames, ResponseData, ms);
finally
FreeAndNil(LChannelNames);
end;
end;
function TDBXServerComponent.ConsumeOneClientChannel(const ChannelName,
ClientManagerId, CallbackId, SecurityToken: string; ChannelNames: TStringList; ResponseData: TJSONValue;
Timeout: Cardinal): TJSONValue;
var
DSServer: TDSServer;
CallbackTunnel: TDSCallbackTunnel;
Data: TJSONValue;
IsBroadcast: Boolean;
IsTimeout: Boolean;
QueueMessage: TDSCallbackTunnelBufferItem;
ArgType: Integer;
StartupMessage: TDSCallbackTunnelBufferItem;
Msg: TJSONObject;
EmptyQueuePulsed: Boolean;
begin
StartupMessage := nil;
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
begin
if CallbackId <> EmptyStr then
begin
// ignore data
CallbackTunnel := DSServer.CreateChannelTunnel(ChannelName, ClientManagerId, CallbackId,
ChannelNames, SecurityToken);
if CallbackTunnel = nil then
exit(TJSONObject.Create( TJSONPair.Create('error',
TJSONString.Create(ChannelName+':'+ClientManagerId+':'+CallbackId))));
Msg := TJSONObject.Create;
Msg.AddPair(TJSONPair.Create('created', TJSONTrue.Create));
StartupMessage := TDSCallbackTunnelBufferItem.Create(ChannelName, CallbackId, False, Msg, TDBXCallback.ArgJson);
end
else
begin
CallbackTunnel := DSServer.CallbackTunnelOf(ClientManagerId);
//set the state of the tunnel as waiting on the server side. (no message sent to client yet)
if (CallbackTunnel <> nil) then
begin
//pulse the queue, to free a previously waiting tunnel, if one exists
if CallbackTunnel.State = ctsWaitingOnServer then
TMonitor.Pulse(CallbackTunnel.Queue);
CallbackTunnel.State := ctsWaitingOnServer;
end;
if (CallbackTunnel <> nil) and (CallbackTunnel.ThinPop <> nil) then
begin
if not CallbackTunnel.ThinPop.IsBroadcast then
begin
if not Assigned(ResponseData) then
CallbackTunnel.ThinPop.Response := TJSONNull.Create
else
CallbackTunnel.ThinPop.Response := ResponseData.Clone as TJSONValue;
TMonitor.Pulse(CallbackTunnel.ThinPop)
end
else
begin
CallbackTunnel.ThinPop.Free;
CallbackTunnel.ThinPop := nil;
end;
end
else if (CallbackTunnel = nil) then
exit(TJSONObject.Create( TJSONPair.Create('error',
TJSONString.Create(ChannelName+':'+ClientManagerId))));
end;
Data := nil;
IsBroadcast := false;
QueueMessage := nil;
ArgType := TDBXCallback.ArgJson;
TMonitor.Enter(CallbackTunnel.Queue);
try
{Wait for a queue item to be added if the queue is empty}
if (StartupMessage = nil) and (CallbackTunnel.Queue.QueueSize = 0) then
IsTimeout := not TMonitor.Wait(CallbackTunnel.Queue, Timeout)
else
IsTimeout := False;
//the queue is empty, there is no first message, and waiting on a message didn't time out,
//so the tunnel must have been re-issued by the client.
EmptyQueuePulsed := (not CallbackTunnel.Queue.ShutDown) and (not IsTimeout) and (StartupMessage = nil) and (CallbackTunnel.Queue.QueueSize = 0);
if (not IsTimeout) and ((StartupMessage <> nil) or (CallbackTunnel.Queue.QueueSize > 0)) then
begin
if StartupMessage <> nil then
QueueMessage := StartupMessage
else
QueueMessage := CallbackTunnel.Queue.PopItem;
if Assigned(QueueMessage) then
begin
if StartupMessage = nil then
CallbackTunnel.ThinPop := QueueMessage;
Data := QueueMessage.Msg;
//nil the message, as it will be memory managed by the response being sent
QueueMessage.Msg := nil;
IsBroadcast := QueueMessage.IsBroadcast;
ArgType := QueueMessage.ArgType;
end;
end
finally
TMonitor.Exit(CallbackTunnel.Queue);
end;
//When an empty queue is pulsed, this means that a second thread is trying to reestablish this tunne.
//usually that means the client has disconnected and is reconnecting and reestablishing the tunnel.
//when this happens, the first tunnel HTTP response should be abandoned.
if EmptyQueuePulsed then
exit(TJSONObject.Create(TJSONPair.Create('error', TJSONString.Create('tunnel_replaced'))));
try
if IsBroadcast and (Data <> nil) then
begin
//call invoke if a CallbackId is specified, to invoke just that callback, but to ignore
//the client's response
if QueueMessage.CallbackId <> EmptyStr then
Msg := TJSONObject.Create( TJSONPair.Create('invoke',
TJSONArray.Create( TJSONString.Create(QueueMessage.CallbackId),
Data).Add(ArgType)))
else
Msg := TJSONObject.Create(TJSONPair.Create('broadcast',
TJSONArray.Create(Data).Add(ArgType)) );
if (QueueMessage.ChannelName <> EmptyStr) and
(QueueMessage.ChannelName <> CallbackTunnel.ServerChannelName) then
Msg.AddPair(TJSONPair.Create('channel', QueueMessage.ChannelName));
//signify we are now waiting for the client to respond
CallbackTunnel.State := ctsWaitingForClient;
exit(Msg);
end
else if (QueueMessage <> nil) and (Data <> nil) then
begin
//signify we are now waiting for the client to respond
CallbackTunnel.State := ctsWaitingForClient;
exit( TJSONObject.Create( TJSONPair.Create('invoke',
TJSONArray.Create( TJSONString.Create(QueueMessage.CallbackId),
Data).Add(ArgType))));
end
else
begin
//note that in this case, the tunnel is closing, so we aren't waiting for the client.
//setting this state here just to make it clear. It should already be in this state.
CallbackTunnel.State := ctsWaitingOnServer;
if (QueueMessage <> nil) then
begin
if QueueMessage = CallbackTunnel.ThinPop then
CallbackTunnel.ThinPop := nil;
QueueMessage.InstanceOwner := true;
FreeAndNil(QueueMessage);
end;
TDSCallbackTunnelManagerInternal(TDSCallbackTunnelManager.Instance).CloseChannelTunnel(CallbackTunnel);
if IsTimeout then
exit(TJSONObject.Create( TJSONPair.Create('timeout', TJSONTrue.Create)))
else
exit( TJSONObject.Create( TJSONPair.Create('close', TJSONTrue.Create)))
end;
finally
FreeAndNil(StartupMessage);
end;
end
else
exit( TJSONObject.Create( TJSONPair.Create('error', TJSONString.Create(GetDSServerName()))));
end;
function TDBXServerComponent.BroadcastToChannel(const ChannelName: string; const Msg: TJSONValue): Boolean;
var
DSServer: TDSServer;
begin
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
exit(DSServer.BroadcastMessage(ChannelName, TJSONValue(Msg.Clone)))
else
exit(false);
end;
function TDBXServerComponent.BroadcastObjectToChannel(const ChannelName: string; const Msg: TObject): Boolean;
var
DSServer: TDSServer;
begin
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
exit(DSServer.BroadcastObject(ChannelName, Msg))
else
exit(false);
end;
function TDBXServerComponent.NotifyCallback(const ClientId, CallbackId: string;
const Msg: TJSONValue; out Response: TJSONValue): Boolean;
var
DSServer: TDSServer;
begin
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
exit(DSServer.NotifyCallback(ClientId, CallbackId, TJSONValue(Msg.Clone), Response))
else
exit(false);
end;
function TDBXServerComponent.NotifyObject(const ClientId, CallbackId: string;
const Msg: TObject; out Response: TObject): Boolean;
var
DSServer: TDSServer;
begin
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
exit(DSServer.NotifyObject(ClientId, CallbackId, Msg, Response))
else
exit(false);
end;
function TDBXServerComponent.CloseClientChannel(const ChannelId, SecurityToken: string): Boolean;
var
DSServer: TDSServer;
begin
// get the server instance
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
begin
try
DSServer.UnregisterChannelCallback(ChannelId, SecurityToken, false);
except
exit(false);
end;
exit(true)
end
else
exit(false);
end;
function TDBXServerComponent.ConnectClientChannel(const ChannelName, ChannelId,
CallbackId, ChannelNames, SecurityToken: string; ChannelCallback: TDBXCallback): Boolean;
var
LChannelNames: TStringList;
begin
LChannelNames := TStringList.Create;
LChannelNames.CommaText := ChannelNames;
try
Result := ConsumeAllClientChannel(ChannelName, ChannelId, CallbackId, SecurityToken, LChannelNames,
ChannelCallback, INFINITE);
finally
FreeAndNil(LChannelNames);
end;
end;
function TDBXServerComponent.ConnectClientChannelTimeout(const ChannelName,
ChannelId, CallbackId, ChannelNames, SecurityToken: string; ChannelCallback: TDBXCallback;
Timeout: Integer): Boolean;
var
ms: Cardinal;
LChannelNames: TStringList;
begin
if Timeout < 0 then
ms := INFINITE
else
ms := Timeout * 1000;
LChannelNames := TStringList.Create;
LChannelNames.CommaText := ChannelNames;
try
Result := ConsumeAllClientChannel(ChannelName, ChannelId, CallbackId, SecurityToken, LChannelNames,
ChannelCallback, ms);
finally
FreeAndNil(LChannelNames);
end;
end;
constructor TDBXServerComponent.Create;
begin
inherited Create(nil);
HasTunnelSessionEvent := False;
end;
function TDBXServerComponent.RegisterClientCallback(const ChannelId, CallbackId, ChannelNames, SecurityToken: string;
ChannelCallback: TDBXCallback): Boolean;
var
ServerCallback: TDBXServerCallback;
DSServer: TDSServer;
LChannelNames: TStringList;
begin
if ChannelCallback is TDBXCallbackDelegate then
begin
ServerCallback := (ChannelCallback as TDBXCallbackDelegate).Delegate as TDBXServerCallback;
// get the server instance
DSServer := ServerCallback.DsServer as TDSServer;
LChannelNames := TStringList.Create;
LChannelNames.CommaText := ChannelNames;
try
exit(DSServer.RegisterChannelCallback(ChannelId, CallbackId, LChannelNames, SecurityToken));
finally
FreeAndNil(LChannelNames);
end;
end
else
exit(false)
end;
function TDBXServerComponent.RegisterClientCallbackServer(const ChannelId, CallbackId, ChannelNames,
SecurityToken: string): Boolean;
var
DSServer: TDSServer;
LChannelNames: TStringList;
begin
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
try
LChannelNames := TStringList.Create;
LChannelNames.CommaText := ChannelNames;
try
exit(DSServer.RegisterChannelCallback(ChannelId, CallbackId, LChannelNames, SecurityToken));
finally
FreeAndNil(LChannelNames);
end;
except
end;
exit(false);
end;
function TDBXServerComponent.UnregisterClientCallback(const ChannelId, CallbackId, SecurityToken: string): Boolean;
var
DSServer: TDSServer;
begin
DSServer := TDSServer.FindServer(GetDSServerName()) as TDSServer;
if DSServer <> nil then
begin
try
DSServer.UnregisterChannelCallback(ChannelId, CallbackId, SecurityToken);
except
exit(false);
end;
exit(true);
end;
exit(false)
end;
initialization
RegisterClass(DSAdmin);
RegisterClass(DSMetadata);
end.
|
unit fileutil;
interface
function GetFileSize(const f: string): Int64;
implementation
uses Windows, sysUtils;
function GetFileSize(const f: string): Int64;
var
Handle: THandle;
FindData: TWin32FindData;
begin
Handle := FindFirstFile(PChar(f), FindData);
if Handle <> INVALID_HANDLE_VALUE then begin
Windows.FindClose(Handle);
if (FindData.dwFileAttributes and FILE_ATTRIBUTE_DIRECTORY) = 0 then
begin
Int64Rec(Result).Lo := FindData.nFileSizeLow;
Int64Rec(Result).Hi := FindData.nFileSizeHigh;
Exit;
end;
end;
Result := -1;
end;
end. |
unit ClientsList;
interface
uses
Classes, StdCtrls, SysUtils, Contnrs, ScktComp,
Client, CommonUtils;
type
TClientsList = class(TObjectList)
constructor Create;
public
// Синхронизация с отображением
procedure Sync;
function IsNickInUse(NickName: string) : boolean;
function AddClient(SocketHandle: integer; var Socket: TCustomWinSocket;
NickName: string) : TClient;
procedure RemoveClient(SocketHandle: integer);
function GetClientByHandle(SocketHandle: integer) : TClient;
function GetClientByNick(NickName: string) : TClient;
function GetNickByHandle(SocketHandle: integer) : string;
function View : TListBox;
// Задать отображение
procedure SetView(var ListBox: TListBox);
private
dView: TListBox;
end;
implementation
{ TClientsList }
constructor TClientsList.Create;
begin
Inherited;
end;
procedure TClientsList.Sync;
var
i: integer;
Client: TClient;
buff: TStrings;
begin
buff := TStringList.Create;
for i := 0 to Self.Count - 1 do
begin
Client := Self.Items[i] as TClient;
buff.Add(Client.NickName);
end;
AlphabeticSort(buff);
dView.Items := buff;
end;
function TClientsList.IsNickInUse(NickName: string) : boolean;
var
i: integer;
Client: TClient;
begin
for i := 0 to Self.Count - 1 do
begin
Client := Self.Items[i] as TClient;
if Client.NickName = NickName then
begin
Result := True;
Exit;
end;
end;
Result := False;
end;
function TClientsList.AddClient(SocketHandle: Integer;
var Socket: TCustomWinSocket; NickName: string) : TClient;
var
Client: TClient;
begin
if ValidateNickName(NickName) then
if not IsNickInUse(NickName) then
begin
Client := TClient.Create(SocketHandle, Socket, NickName);
Add(Client);
Result := Client;
Sync;
end
else
raise ENickInUse.Create('Nickname is already in use: ' + NickName)
else
raise EIncorrectNick.Create('Incorrect nick: ' + NickName);
end;
procedure TClientsList.RemoveClient(SocketHandle: Integer);
var
i: integer;
Client: TClient;
begin
for i := 0 to Count - 1 do
begin
Client := Items[i] as TClient;
if Client.SocketHandle = SocketHandle then
begin
Delete(i);
Break;
end;
end;
Sync;
end;
function TClientsList.GetClientByHandle(SocketHandle: Integer) : TClient;
var
i: integer;
Client: TClient;
begin
Result := nil;
for i := 0 to Self.Count - 1 do
begin
Client := Self.Items[i] as TClient;
if Client.dSocketHandle = SocketHandle then
begin
Result := Client;
Exit;
end;
end;
end;
function TClientsList.GetClientByNick(NickName: string) : TClient;
var
i: integer;
Client: TClient;
begin
for i := 0 to Self.Count - 1 do
begin
Client := Self.Items[i] as TClient;
if Client.dNickName = NickName then
begin
Result := Client;
Exit;
end;
end;
end;
function TClientsList.GetNickByHandle(SocketHandle: Integer) : string;
var
Client: TClient;
begin
Client := GetClientByHandle(SocketHandle);
if Assigned(Client) then
Result := Client.NickName
else
end;
function TClientsList.View;
begin
Result := dView;
end;
procedure TClientsList.SetView(var ListBox: TListBox);
begin
dView := ListBox;
end;
end.
|
unit Form.EditCategory;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Form.BaseEditForm, cxGraphics,
cxLookAndFeels, cxLookAndFeelPainters, Vcl.Menus, dxSkinsCore,
dxSkinMetropolis, cxClasses, dxSkinsForm, Vcl.StdCtrls, cxButtons,
Vcl.ExtCtrls,
Model.Entities, cxControls, cxContainer, cxEdit,
cxMaskEdit, cxDropDownEdit, cxTextEdit, cxLabel,
System.Generics.Collections,
Aurelius.Bind.Dataset,
Aurelius.Engine.ObjectManager,
System.ImageList, Vcl.ImgList, Data.DB, cxLookupEdit, cxDBLookupEdit,
cxDBLookupComboBox, cxDBEdit;
type
TfrmEditCategory = class(TfrmBaseEditor)
lblCategoryName: TcxLabel;
lblParentCategory: TcxLabel;
edtCategoryName: TcxDBTextEdit;
cbbParentCategory: TcxDBLookupComboBox;
adsCategories: TAureliusDataset;
adsCategoriesSelf: TAureliusEntityField;
adsCategoriesID: TIntegerField;
adsCategoriesCategoryName: TStringField;
adsCategoriesParent: TAureliusEntityField;
adsCategoriesBooks: TDataSetField;
dsCategories: TDataSource;
adsParents: TAureliusDataset;
adsParentsSelf: TAureliusEntityField;
adsParentsID: TIntegerField;
adsParentsCategoryName: TStringField;
adsParentsParent: TAureliusEntityField;
adsParentsBooks: TDataSetField;
dsParents: TDataSource;
procedure btnOKClick(Sender: TObject);
procedure btnCancelClick(Sender: TObject);
private
procedure SetCategory(ACategory: TCategory; AManager: TObjectManager);
public
class function Edit(ACategory: TCategory; AManager: TObjectManager): Boolean;
end;
var
frmEditCategory: TfrmEditCategory;
implementation
uses
Common.Utils;
{$R *.dfm}
{ TfrmEditCategory }
procedure TfrmEditCategory.btnCancelClick(Sender: TObject);
begin
adsCategories.Cancel;
inherited;
end;
procedure TfrmEditCategory.btnOKClick(Sender: TObject);
begin
with adsCategories do begin
try
Post;
except on E: Exception do begin
ShowErrorFmt('Не удалось сохранить категорию "%s"'#10#13+'%s', [edtCategoryName.Text]);
ModalResult := mrCancel;
end;
end;
end;
inherited;
end;
class function TfrmEditCategory.Edit(ACategory: TCategory;
AManager: TObjectManager): Boolean;
var
Form: TfrmEditCategory;
CategoryName: string;
begin
Form := TfrmEditCategory.Create(Application);
try
CategoryName := ACategory.CategoryName;
if CategoryName.IsEmpty then
Form.Header := 'Новая категория книг'
else
Form.Header := Format('Редактирование категории книг: %s', [CategoryName]);
Form.SetCategory(ACategory, AManager);
Result := Form.ShowModal = mrOk;
finally
Form.Free;
end;
end;
procedure TfrmEditCategory.SetCategory(ACategory: TCategory;
AManager: TObjectManager);
begin
// открытие DS
adsParents.Close;
adsParents.SetSourceCriteria(AManager.Find<TCategory>.OrderBy('CategoryName'));
adsParents.Open;
with adsCategories do begin
Close;
SetSourceObject(ACategory);
Open;
Edit;
end;
end;
end.
|
{**************************************************************************************************}
{ }
{ Project JEDI Code Library (JCL) }
{ }
{ The contents of this file are subject to the Mozilla Public License Version 1.1 (the "License"); }
{ you may not use this file except in compliance with the License. You may obtain a copy of the }
{ License at http://www.mozilla.org/MPL/ }
{ }
{ Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF }
{ ANY KIND, either express or implied. See the License for the specific language governing rights }
{ and limitations under the License. }
{ }
{ The Original Code is Stack.pas. }
{ }
{ The Initial Developer of the Original Code is Jean-Philippe BEMPEL aka RDM. Portions created by }
{ Jean-Philippe BEMPEL are Copyright (C) Jean-Philippe BEMPEL (rdm_30 att yahoo dott com) }
{ All rights reserved. }
{ }
{ Contributors: }
{ Florent Ouchet (outchy) }
{ }
{**************************************************************************************************}
{ }
{ The Delphi Container Library }
{ }
{**************************************************************************************************}
{ }
{ Last modified: $Date:: 2008-06-05 15:35:37 +0200 (jeu., 05 juin 2008) $ }
{ Revision: $Rev:: 2376 $ }
{ Author: $Author:: obones $ }
{ }
{**************************************************************************************************}
unit JclStacks;
{$I jcl.inc}
interface
uses
{$IFDEF UNITVERSIONING}
JclUnitVersioning,
{$ENDIF UNITVERSIONING}
{$IFDEF SUPPORTS_GENERICS}
{$IFDEF CLR}
System.Collections.Generic,
{$ENDIF CLR}
JclAlgorithms,
{$ENDIF SUPPORTS_GENERICS}
JclBase, JclAbstractContainers, JclContainerIntf, JclSynch;
{$I containers\JclContainerCommon.imp}
{$I containers\JclStacks.imp}
{$I containers\JclStacks.int}
type
(*$JPPEXPANDMACRO JCLSTACKINT(TJclIntfStack,IJclIntfStack,TJclIntfAbstractContainer,JclBase.TDynIInterfaceArray, IJclIntfEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,const ,AInterface,IInterface)*)
(*$JPPEXPANDMACRO JCLSTACKINT(TJclAnsiStrStack,IJclAnsiStrStack,TJclAnsiStrAbstractContainer,JclBase.TDynAnsiStringArray, IJclStrContainer\, IJclAnsiStrContainer\, IJclAnsiStrEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,const ,AString,AnsiString)*)
(*$JPPEXPANDMACRO JCLSTACKINT(TJclWideStrStack,IJclWideStrStack,TJclWideStrAbstractContainer,JclBase.TDynWideStringArray, IJclStrContainer\, IJclWideStrContainer\, IJclWideStrEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,const ,AString,WideString)*)
{$IFDEF CONTAINER_ANSISTR}
TJclStrStack = TJclAnsiStrStack;
{$ENDIF CONTAINER_ANSISTR}
{$IFDEF CONTAINER_WIDESTR}
TJclStrStack = TJclWideStrStack;
{$ENDIF CONTAINER_WIDESTR}
(*$JPPEXPANDMACRO JCLSTACKINT(TJclSingleStack,IJclSingleStack,TJclSingleAbstractContainer,JclBase.TDynSingleArray, IJclSingleContainer\, IJclSingleEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,const ,AValue,Single)*)
(*$JPPEXPANDMACRO JCLSTACKINT(TJclDoubleStack,IJclDoubleStack,TJclDoubleAbstractContainer,JclBase.TDynDoubleArray, IJclDoubleContainer\, IJclDoubleEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,const ,AValue,Double)*)
(*$JPPEXPANDMACRO JCLSTACKINT(TJclExtendedStack,IJclExtendedStack,TJclExtendedAbstractContainer,JclBase.TDynExtendedArray, IJclExtendedContainer\, IJclExtendedEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,const ,AValue,Extended)*)
{$IFDEF MATH_EXTENDED_PRECISION}
TJclFloatStack = TJclExtendedStack;
{$ENDIF MATH_EXTENDED_PRECISION}
{$IFDEF MATH_DOUBLE_PRECISION}
TJclFloatStack = TJclDoubleStack;
{$ENDIF MATH_DOUBLE_PRECISION}
{$IFDEF MATH_SINGLE_PRECISION}
TJclFloatStack = TJclSingleStack;
{$ENDIF MATH_SINGLE_PRECISION}
(*$JPPEXPANDMACRO JCLSTACKINT(TJclIntegerStack,IJclIntegerStack,TJclIntegerAbstractContainer,JclBase.TDynIntegerArray, IJclIntegerEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,,AValue,Integer)*)
(*$JPPEXPANDMACRO JCLSTACKINT(TJclCardinalStack,IJclCardinalStack,TJclCardinalAbstractContainer,JclBase.TDynCardinalArray, IJclCardinalEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,,AValue,Cardinal)*)
(*$JPPEXPANDMACRO JCLSTACKINT(TJclInt64Stack,IJclInt64Stack,TJclInt64AbstractContainer,JclBase.TDynInt64Array, IJclInt64EqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,const ,AValue,Int64)*)
{$IFNDEF CLR}
(*$JPPEXPANDMACRO JCLSTACKINT(TJclPtrStack,IJclPtrStack,TJclPtrAbstractContainer,JclBase.TDynPointerArray, IJclPtrEqualityComparer\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,,,APtr,Pointer)*)
{$ENDIF ~CLR}
(*$JPPEXPANDMACRO JCLSTACKINT(TJclStack,IJclStack,TJclAbstractContainer,JclBase.TDynObjectArray, IJclEqualityComparer\, IJclObjectOwner\,,,
function CreateEmptyContainer: TJclAbstractContainerBase; override;,,; AOwnsObjects: Boolean,,AObject,TObject)*)
{$IFDEF SUPPORTS_GENERICS}
(*$JPPEXPANDMACRO JCLSTACKINT(TJclStack<T>,IJclStack<T>,TJclAbstractContainer<T>,TJclBase<T>.TDynArray, IJclEqualityComparer<T>\, IJclItemOwner<T>\,,,,,; AOwnsItems: Boolean,const ,AItem,T)*)
// E = external helper to compare items for equality
TJclStackE<T> = class(TJclStack<T>, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE}
IJclIntfCloneable, IJclCloneable, IJclPackable, IJclGrowable, IJclContainer,
IJclStack<T>, IJclItemOwner<T>)
private
FEqualityComparer: IEqualityComparer<T>;
protected
procedure AssignPropertiesTo(Dest: TJclAbstractContainerBase); override;
function CreateEmptyContainer: TJclAbstractContainerBase; override;
function ItemsEqual(const A, B: T): Boolean; override;
{ IJclCloneable }
function IJclCloneable.Clone = ObjectClone;
{ IJclIntfCloneable }
function IJclIntfCloneable.Clone = IntfClone;
public
constructor Create(const AEqualityComparer: IEqualityComparer<T>; ACapacity: Integer; AOwnsItems: Boolean);
property EqualityComparer: IEqualityComparer<T> read FEqualityComparer write FEqualityComparer;
end;
// F = Function to compare items for equality
TJclStackF<T> = class(TJclStack<T>, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE}
IJclIntfCloneable, IJclCloneable, IJclPackable, IJclGrowable, IJclContainer,
IJclStack<T>, IJclItemOwner<T>)
protected
function CreateEmptyContainer: TJclAbstractContainerBase; override;
{ IJclCloneable }
function IJclCloneable.Clone = ObjectClone;
{ IJclIntfCloneable }
function IJclIntfCloneable.Clone = IntfClone;
public
constructor Create(AEqualityCompare: TEqualityCompare<T>; ACapacity: Integer; AOwnsItems: Boolean);
end;
// I = items can compare themselves to an other for equality
TJclStackI<T: IEquatable<T>> = class(TJclStack<T>, {$IFDEF THREADSAFE} IJclLockable, {$ENDIF THREADSAFE}
IJclIntfCloneable, IJclCloneable, IJclPackable, IJclGrowable, IJclContainer,
IJclStack<T>, IJclItemOwner<T>)
protected
function CreateEmptyContainer: TJclAbstractContainerBase; override;
function ItemsEqual(const A, B: T): Boolean; override;
{ IJclCloneable }
function IJclCloneable.Clone = ObjectClone;
{ IJclIntfCloneable }
function IJclIntfCloneable.Clone = IntfClone;
end;
{$ENDIF SUPPORTS_GENERICS}
{$IFDEF UNITVERSIONING}
const
UnitVersioning: TUnitVersionInfo = (
RCSfile: '$URL: https://jcl.svn.sourceforge.net:443/svnroot/jcl/tags/JCL-1.102-Build3072/jcl/source/prototypes/JclStacks.pas $';
Revision: '$Revision: 2376 $';
Date: '$Date: 2008-06-05 15:35:37 +0200 (jeu., 05 juin 2008) $';
LogPath: 'JCL\source\common'
);
{$ENDIF UNITVERSIONING}
implementation
uses
SysUtils;
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclIntfStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclIntfStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclIntfStack,,,const ,AInterface,IInterface,nil,FreeObject)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclAnsiStrStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclAnsiStrStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclAnsiStrStack,,,const ,AString,AnsiString,'',FreeString)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclWideStrStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclWideStrStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclWideStrStack,,,const ,AString,WideString,'',FreeString)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclSingleStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclSingleStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclSingleStack,,,const ,AValue,Single,0.0,FreeSingle)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclDoubleStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclDoubleStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclDoubleStack,,,const ,AValue,Double,0.0,FreeDouble)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclExtendedStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclExtendedStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclExtendedStack,,,const ,AValue,Extended,0.0,FreeExtended)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclIntegerStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclIntegerStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclIntegerStack,,,,AValue,Integer,0,FreeInteger)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclCardinalStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclCardinalStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclCardinalStack,,,,AValue,Cardinal,0,FreeCardinal)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclInt64Stack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclInt64Stack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclInt64Stack,,,const ,AValue,Int64,0,FreeInt64)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$IFNDEF CLR}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclPtrStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclPtrStack.Create(FSize);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclPtrStack,,,,APtr,Pointer,nil,FreePointer)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$ENDIF ~CLR}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER
function TJclStack.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclStack.Create(FSize, False);
AssignPropertiesTo(Result);
end;
}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclStack,; AOwnsObjects: Boolean,AOwnsObjects,,AObject,TObject,nil,FreeObject)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
{$IFDEF SUPPORTS_GENERICS}
{$JPPDEFINEMACRO CREATEEMPTYCONTAINER}
(*$JPPEXPANDMACRO JCLSTACKIMP(TJclStack<T>,; AOwnsItems: Boolean,AOwnsItems,const ,AItem,T,Default(T),FreeItem)*)
{$JPPUNDEFMACRO CREATEEMPTYCONTAINER}
//=== { TJclStackE<T> } ======================================================
constructor TJclStackE<T>.Create(const AEqualityComparer: IEqualityComparer<T>; ACapacity: Integer;
AOwnsItems: Boolean);
begin
inherited Create(ACapacity, AOwnsItems);
FEqualityComparer := AEqualityComparer;
end;
procedure TJclStackE<T>.AssignPropertiesTo(Dest: TJclAbstractContainerBase);
begin
inherited AssignPropertiesTo(Dest);
if Dest is TJclStackE<T> then
TJclStackE<T>(Dest).FEqualityComparer := FEqualityComparer;
end;
function TJclStackE<T>.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclStackE<T>.Create(FEqualityComparer, FSize, False);
AssignPropertiesTo(Result);
end;
function TJclStackE<T>.ItemsEqual(const A, B: T): Boolean;
begin
if EqualityComparer <> nil then
Result := EqualityComparer.Equals(A, B)
else
Result := inherited ItemsEqual(A, B);
end;
//=== { TJclStackF<T> } ======================================================
constructor TJclStackF<T>.Create(AEqualityCompare: TEqualityCompare<T>; ACapacity: Integer; AOwnsItems: Boolean);
begin
inherited Create(ACapacity, AOwnsItems);
SetEqualityCompare(AEqualityCompare);
end;
function TJclStackF<T>.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclStackF<T>.Create(FEqualityCompare, FSize + 1, False);
AssignPropertiesTo(Result);
end;
//=== { TJclStackI<T> } ======================================================
function TJclStackI<T>.CreateEmptyContainer: TJclAbstractContainerBase;
begin
Result := TJclStackI<T>.Create(FSize + 1, False);
AssignPropertiesTo(Result);
end;
function TJclStackI<T>.ItemsEqual(const A, B: T): Boolean;
begin
if Assigned(FEqualityCompare) then
Result := FEqualityCompare(A, B)
else
if Assigned(FCompare) then
Result := FCompare(A, B) = 0
else
Result := A.Equals(B);
end;
{$ENDIF SUPPORTS_GENERICS}
{$IFDEF UNITVERSIONING}
initialization
RegisterUnitVersion(HInstance, UnitVersioning);
finalization
UnregisterUnitVersion(HInstance);
{$ENDIF UNITVERSIONING}
end.
|
unit WasmSample_Threads;
interface
uses
System.Classes, System.SysUtils
, Wasm
{$ifndef USE_WASMER}
, Wasmtime
{$else}
, Wasmer
{$ifend}
;
function ThreadsSample() : Boolean;
implementation
const N_THREADS = 10;
const N_REPS = 3;
// A function to be called from Wasm code.
function callback(const args : PWasmValVec; results : PWasmValVec) : PWasmTrap; cdecl;
begin
assert(args.Items[0].kind = WASM_I32);
writeln('> Thread '+IntToStr(args.Items[0].i32)+' running');
result := nil;
end;
type TThreadArgs = record
engine : TOwnEngine;
module : TOwnSharedModule;
id : Integer;
end;
PThreadArgs = ^TThreadArgs;
function run(const args : TThreadArgs) : Boolean;
begin
// Rereate store and module.
var store := TWasmStore.New(+args.engine);
var module := (+args.module).Obtain(+store);
// Run the example N times.
for var i := 0 to N_REPS-1 do
begin
Sleep(100);
// Create imports.
var func := TWasmFunc.New(+store, +TWasmFunctype.New([WASM_I32],[]), callback);
var val := WASM_I32_VAL(args.id);
var global_type := TWasmGlobaltype.New(WASM_I32, WASM_CONST);
var global := TWasmGlobal.New(+store, +global_type, @val);
// Instantiate.
var externs := [ (+func).AsExtern, (+global).AsExtern ];
var instance := TWasmInstance.New(+store, +module, externs);
if instance.IsNone then
begin
writeln('> Error instantiating module!');
exit(false);
end;
// Extract export.
var export_s := (+instance).GetExports;
if export_s.Unwrap.size = 0 then
begin
writeln('> Error accessing exports!');
exit(false);
end;
var run_func := export_s.Unwrap.Items[0].AsFunc;
if run_func = nil then
begin
writeln('> Error accessing export!');
exit(false);
end;
// Call.
var empty := Default(TWasmValVec);
if run_func.Call(@empty, @empty).IsError then
begin
writeln('> Error calling function!!');
exit(false);
end;
end;
result := true;
end;
function ThreadsSample() : Boolean;
function makeProc(arg : TThreadArgs) : TProc;
begin
result := procedure
begin
run(arg);
end;
end;
begin
// Initialize.
writeln('Initializing...');
var engine := TWasmEngine.New();
var store := TWasmStore.New(+engine);
// Load binary.
writeln('Loading binary...');
var binary := TWasmByteVec.NewEmpty;
{$ifdef USE_WASMFILE}
if not (+binary).LoadFromFile('threads.wasm') then
begin
writeln('> Error loading module!');
exit(false);
end;
{$else}
var wat :=
'(module'+
' (func $message (import "" "hello") (param i32))'+
' (global $id (import "" "id") i32)'+
' (func (export "run") (call $message (global.get $id)))'+
')';
(+binary).Wat2Wasm(wat);
{$ifend}
// Compile.
writeln('Compiling module...');
var module := TWasmModule.New(+store, +binary);
if module.IsNone then
begin
writeln('> Error compiling module!');
exit(false);
end;
var shared := module.Unwrap.Share();
// Spawn threads.
var threads : TArray<TThread>;
SetLength(threads, N_THREADS);
for var i := 0 to N_THREADS-1 do
begin
writeln('Initializing thread '+IntToStr(i)+'...');
var arg := Default(TThreadArgs);
arg.id := i;
arg.engine := engine;
arg.module := shared;
threads[i] := TThread.CreateAnonymousThread(makeProc(arg));
threads[i].FreeOnTerminate := false;
threads[i].Start;
end;
for var i := 0 to N_THREADS-1 do
begin
writeln('Waiting for thread: '+IntToStr(i));
threads[i].WaitFor;
threads[i].Free;
end;
writeln('finished');
result := true;
end;
end.
|
unit GrupoEditFormUn;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
osCUSTOMEDITFRM, Wwintl, Db, DBClient, osClientDataset, ActnList,
StdCtrls, Mask, DBCtrls, Grids, DBGrids, ComCtrls,
wwdbedit, Wwdotdot, Wwdbcomb, Menus, ImgList,
osActionList, ToolWin, Buttons, ExtCtrls, osComboSearch, Wwdbigrd,
Wwdbgrid, osUtils, Variants, CheckLst, osDBDualTree, acCustomSQLMainDataUn;
type
TRefInt = class(TObject)
private
FValue: integer;
public
constructor Create(const AValue: integer);
property Value: integer read FValue write FValue;
end;
TGrupoEditForm = class(TosCustomEditForm)
TestarAction: TAction;
Label1: TLabel;
DescricaoEdit: TDBEdit;
Label2: TLabel;
NomeEdit: TDBEdit;
PageControl: TPageControl;
ParticipantesTabSheet: TTabSheet;
TabSheet1: TTabSheet;
clbAcao: TCheckListBox;
Splitter1: TSplitter;
ParticipantesDualTree: TosDBDualTree;
GrupoDataSet: TosClientDataset;
GrupoDataSetIDGRUPO: TIntegerField;
GrupoDataSetNOME: TStringField;
GrupoDataSetDESCRICAO: TStringField;
GrupoDataSetGrupoUsuarioDataSet: TDataSetField;
GrupoUsuarioClientDataSet: TosClientDataset;
GrupoUsuarioClientDataSetIDGRUPOUSUARIO: TIntegerField;
GrupoUsuarioClientDataSetIDGRUPO: TIntegerField;
GrupoUsuarioClientDataSetIDUSUARIO: TIntegerField;
UsuarioClientDataSet: TosClientDataset;
UsuarioClientDataSetIDUSUARIO: TIntegerField;
UsuarioClientDataSetNOME: TStringField;
GrupoDataSetDireitoUsoDataSet: TDataSetField;
DireitoUsoClientDataSet: TosClientDataset;
DireitoUsoClientDataSetIDGRUPO: TIntegerField;
DireitoUsoClientDataSetIDRECURSO: TIntegerField;
DireitoUsoClientDataSetDireitoUsoAcaoDataSet: TDataSetField;
DireitoUsoAcaoClientDataSet: TosClientDataset;
DireitoUsoAcaoClientDataSetIDDIREITOUSO: TIntegerField;
DireitoUsoAcaoClientDataSetIDGRUPO: TIntegerField;
DireitoUsoAcaoClientDataSetIDRECURSO: TIntegerField;
DireitoUsoAcaoClientDataSetIDACAO: TIntegerField;
RecursoClientDataSet: TosClientDataset;
AcaoClientDataSet: TosClientDataset;
AcaoClientDataSetIDACAO: TIntegerField;
AcaoClientDataSetNOME: TStringField;
DireitoUsoDualTree: TosDBDualTree;
RecursoClientDataSetIDRECURSO: TIntegerField;
RecursoClientDataSetNOMERECURSO: TStringField;
RecursoClientDataSetNOMEDOMINIO: TStringField;
procedure FormShow(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure DireitoUsoDualTreeNodeSelect(LeafSelected: Boolean);
procedure clbAcaoClickCheck(Sender: TObject);
procedure DireitoUsoClientDataSetNewRecord(DataSet: TDataSet);
procedure GrupoDataSetBeforePost(DataSet: TDataSet);
procedure GrupoDataSetAfterApplyUpdates(Sender: TObject;
var OwnerData: OleVariant);
private
function LocateAction(IDAction: integer): boolean;
procedure ClearActions;
procedure LoadActions;
procedure CreateActions;
procedure SaveAction(IDAction: integer; Checked: boolean);
public
{ Public declarations }
end;
var
GrupoEditForm: TGrupoEditForm;
implementation
uses GrupoDataUn, AdministracaoLookupDataUn, SQLMainData;
{$R *.DFM}
procedure TGrupoEditForm.clbAcaoClickCheck(Sender: TObject);
begin
inherited;
SaveAction(
(clbAcao.Items.Objects[clbAcao.ItemIndex] as TRefInt).Value,
clbAcao.Checked[clbAcao.ItemIndex]);
end;
procedure TGrupoEditForm.ClearActions;
var
i: integer;
begin
for i := 0 to clbAcao.Count - 1 do
clbAcao.Items.Objects[i].Free;
clbAcao.Clear;
end;
procedure TGrupoEditForm.CreateActions;
var
i: integer;
begin
AcaoClientDataSet.Params[0].Value := DireitoUsoClientDataSetIDRecurso.Value;
AcaoClientDataSet.Active := True;
AcaoClientDataSet.First;
for i := 0 to AcaoClientDataSet.RecordCount - 1 do
begin
DireitoUsoAcaoClientDataSet.Append;
DireitoUsoAcaoClientDataSetIDAcao.Value := AcaoClientDataSetIDAcao.Value;
DireitoUsoAcaoClientDataSet.Post;
AcaoClientDataSet.Next;
end;
AcaoClientDataSet.Active := False;
end;
procedure TGrupoEditForm.DireitoUsoClientDataSetNewRecord(
DataSet: TDataSet);
begin
inherited;
CreateActions;
end;
procedure TGrupoEditForm.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
RecursoClientDataSet.Active := False;
UsuarioClientDataSet.Active := False;
inherited;
end;
procedure TGrupoEditForm.FormShow(Sender: TObject);
begin
inherited;
PageControl.ActivePage := ParticipantesTabSheet;
ClearActions;
UsuarioClientDataSet.Active := True;
ParticipantesDualTree.Load;
RecursoClientDataSet.Active := True;
DireitoUsoDualTree.Load;
end;
procedure TGrupoEditForm.LoadActions;
var
i,
IDAcao: integer;
begin
ClearActions;
AcaoClientDataSet.Params[0].Value := DireitoUsoClientDataSetIDRecurso.Value;
AcaoClientDataSet.Active := True;
for i := 0 to AcaoClientDataSet.RecordCount - 1 do
begin
IDAcao := AcaoClientDataSetIDAcao.Value;
clbAcao.AddItem(AcaoClientDataSetNome.Value, TRefInt.Create(IDAcao));
clbAcao.Checked[i] := LocateAction(IDAcao);
AcaoClientDataSet.Next;
end;
AcaoClientDataSet.Active := False;
end;
function TGrupoEditForm.LocateAction(IDAction: integer): boolean;
begin
Result := DireitoUsoAcaoClientDataSet.Locate('IDAcao', VarArrayOf([IDAction]), []);
end;
procedure TGrupoEditForm.DireitoUsoDualTreeNodeSelect(LeafSelected: Boolean);
begin
inherited;
if LeafSelected then
LoadActions
else
ClearActions;
end;
procedure TGrupoEditForm.SaveAction(IDAction: integer; Checked: boolean);
begin
if LocateAction(IDAction) then
begin
if not Checked then
DireitoUsoAcaoClientDataSet.Delete;
end
else
if Checked then
begin
DireitoUsoAcaoClientDataSet.Append;
DireitoUsoAcaoClientDataSetIDAcao.Value := IDAction;
DireitoUsoAcaoClientDataSet.Post;
end;
end;
constructor TRefInt.Create(const AValue: integer);
begin
FValue := AValue;
end;
procedure TGrupoEditForm.GrupoDataSetBeforePost(DataSet: TDataSet);
begin
inherited;
GrupoData.Validate(DataSet);
end;
procedure TGrupoEditForm.GrupoDataSetAfterApplyUpdates(Sender: TObject;
var OwnerData: OleVariant);
begin
inherited;
if TClientDataSet(Sender).UpdateStatus in [usModified, usInserted, usDeleted] then
MainData.UpdateVersion(tnGrupo);
end;
initialization
OSRegisterClass(TGrupoEditForm);
end.
|
unit uSurgery;
interface
uses
SysUtils, Windows, Messages, Controls, Classes, StdCtrls, ORfn, dialogs;
type
TSurgeryTitles = class
public
ClassName: string;
DfltTitle: Integer;
DfltTitleName: string;
ShortList: TStringList;
constructor Create;
destructor Destroy; override;
end;
function MakeSurgeryCaseDisplayText(InputString: string): string;
function MakeSurgeryReportDisplayText(RawText: string): string;
//procedure DisplayOpTop(ANoteIEN: integer);
const
(* SG_ALL = 1; // Case context - all cases
SG_BY_SURGEON = 2; // Case context - all cases by surgeon
SG_BY_DATE = 3; // Case context - all cases by date range*)
SG_TV_TEXT = 'Surgery Cases';
OP_TOP_NEVER_SHOW = 0;
OP_TOP_ALWAYS_SHOW = 1;
OP_TOP_ASK_TO_SHOW = 2;
implementation
uses
uConst, rSurgery, fRptBox;
constructor TSurgeryTitles.Create;
{ creates an object to store Surgery titles so only obtained from server once }
begin
inherited Create;
ShortList := TStringList.Create;
end;
destructor TSurgeryTitles.Destroy;
{ frees the lists that were used to store the Surgery titles }
begin
ShortList.Free;
inherited Destroy;
end;
function MakeSurgeryCaseDisplayText(InputString: string): string;
(*
CASE #^Operative Procedure^Date/Time of Operation^Surgeon^^^^^^^^^+^Context
*)
var
x: string;
begin
x := InputString;
x := FormatFMDateTime('mmm dd yyyy', MakeFMDateTime(Piece(x, U, 3))) + ' ' + Piece(x, U, 2) +
', ' + Piece(Piece(x, U, 4), ';', 2) + ', ' + 'Case #: ' + Piece(x, u, 1);
Result := x;
end;
function MakeSurgeryReportDisplayText(RawText: string): string;
var
x: string;
begin
x := RawText;
x := FormatFMDateTime('mmm dd,yy', MakeFMDateTime(Piece(x, U, 3))) + ' ' + Piece(x, U, 2) +
' (#' + Piece(x, U, 1) + '), ' + Piece(x, U, 6) + ', ' + Piece(Piece(x, U, 5), ';', 2);
Result := x;
end;
(*procedure DisplayOpTop(ANoteIEN: integer);
const
{ TODO -oRich V. -cSurgery/TIU : What should be the text of the prompt for display OpTop on signature? }
TX_OP_TOP_PROMPT = 'Would you like to first review the OpTop for this surgery report?';
var
AList: TStringList;
ACaseIEN: integer;
IsNonORProc: boolean;
ShouldShowOpTop: integer;
x: string;
ShowReport: boolean;
begin
AList := TStringList.Create;
try
ShowReport := False;
x := GetSurgCaseRefForNote(ANoteIEN);
ACaseIEN := StrToIntDef(Piece(x, ';', 1), 0);
ShouldShowOpTop := ShowOpTopOnSignature(ACaseIEN);
case ShouldShowOpTop of
OP_TOP_NEVER_SHOW : ; // do nothing
OP_TOP_ALWAYS_SHOW : begin
x := GetSingleCaseListItemWithoutDocs(ANoteIEN);
IsNonORProc := IsNonORProcedure(ACaseIEN);
LoadOpTop(AList, ACaseIEN, IsNonORProc, ShowReport);
ReportBox(AList, MakeSurgeryCaseDisplayText(x), True);
end;
OP_TOP_ASK_TO_SHOW : if InfoBox(TX_OP_TOP_PROMPT, 'Confirmation', MB_YESNO or MB_ICONQUESTION) = IDYES then
begin
x := GetSingleCaseListItemWithoutDocs(ANoteIEN);
IsNonORProc := IsNonORProcedure(ACaseIEN);
LoadOpTop(AList, ACaseIEN, IsNonORProc, ShowReport);
ReportBox(AList, MakeSurgeryCaseDisplayText(x), True);
end;
end;
finally
AList.Free;
end;
end;*)
end.
|
unit vr_fpg;
{$mode delphi}{$H+}
{$I vrode.inc}
interface
uses SysUtils, Classes, vr_types, vr_utils, fgl, vr_intfs, RtlConsts, Math;
type
{ TGThreadObjectList }
TGThreadObjectList<T{$IF FPC_FULLVERSION >= 030200} : TObject{$ENDIF}> = class(TObject)
private
type
TObjectList_T = TFPGObjectList<T>;
private
FList: TObjectList_T;
FDuplicates: TDuplicates;
FLock: TRTLCriticalSection;
public
constructor Create(const AFreeObjects: Boolean = True);
destructor Destroy; override;
procedure Add(Item: T);
procedure Clear;
function IsEmpty: Boolean;
procedure Remove(Item: T);
function LockList: TObjectList_T;
procedure UnlockList;
property Duplicates: TDuplicates read FDuplicates write FDuplicates;
end;
{ TGItemDataList<T, D> }
TGItemDataList<T, D> = class(TObject)
private
type
TGItemDataListRec = record
Item: T;
Data: D;
end;
PDataListRec = ^TGItemDataListRec;
PData = ^D;
private
FList: TFPList;
FDataSize: Integer;
function AllocateNewItem(const AItem: T): PDataListRec;
function GetCapacity: Integer;
function GetCount: Integer;
function GetData(const AIndex: Integer): PData;
function GetItem(const AIndex: Integer): T;
procedure SetCapacity(AValue: Integer);
procedure SetItem(const AIndex: Integer; AValue: T);
protected
procedure DoInitData(var AData: D); virtual;
procedure DoFreeData(var AData: D); virtual;
public
constructor Create; virtual;
destructor Destroy; override;
//Procedure AddList(AList : TList);
function Add(const AItem: T): Integer;
procedure Clear;
procedure Delete(const AIndex: Integer);
//class procedure Error(const Msg: string; Data: PtrInt); virtual;
//procedure Exchange(Index1, Index2: Integer);
//function Expand: TList;
function Extract(AItem: T): T;
function First: T;
//function GetEnumerator: TListEnumerator;
function IndexOf(const AItem: T): Integer;
procedure Insert(const AIndex: Integer; const AItem: T);
function Last: T;
//procedure Move(CurIndex, NewIndex: Integer);
//procedure Assign (ListA: TList; AOperator: TListAssignOp=laCopy; ListB: TList=nil);
function Remove(const AItem: T): Integer;
//procedure Pack;
procedure Sort(ACompare: TListSortCompare);
property Capacity: Integer read GetCapacity write SetCapacity;
property Count: Integer read GetCount;// write SetCount;
property Items[const AIndex: Integer]: T read GetItem write SetItem; default;
property Data[const AIndex: Integer]: PData read GetData;
end;
{ TGThreadItemDataList }
TGThreadItemDataList<T, D> = class(TObject)
private
type
//PData = ^D;
//TGRecordListEnumeratorSpec = TGRecordListEnumerator<T>;
TItemList = TGItemDataList<T, D>;
private
FList: TItemList;
FLock: TRTLCriticalSection;
public
constructor Create; virtual;
destructor Destroy; override;
function Lock: TItemList;
procedure UnLock;
//Procedure AddList(AList : TList);
function Add(const AItem: T): Integer;
procedure Clear;
procedure Delete(const AIndex: Integer);
//class procedure Error(const Msg: string; Data: PtrInt); virtual;
//procedure Exchange(Index1, Index2: Integer);
//function Expand: TList;
function Extract(AItem: T): T;
function First: T;
//function GetEnumerator: TListEnumerator;
function IndexOf(const AItem: T): Integer;
procedure Insert(const AIndex: Integer; const AItem: T);
function Last: T;
//procedure Move(CurIndex, NewIndex: Integer);
//procedure Assign (ListA: TList; AOperator: TListAssignOp=laCopy; ListB: TList=nil);
function Remove(const AItem: T): Integer;
//procedure Pack;
procedure Sort(ACompare: TListSortCompare);
//property Capacity: Integer read GetCapacity write SetCapacity;
//property Count: Integer read GetCount;// write SetCount;
//property Items[const AIndex: Integer]: T read GetItem write SetItem; default;
//property Data[const AIndex: Integer]: PData read GetData;
end;
{$IF FPC_FULLVERSION >= 030000}
//!!! if RecordList to vr_fpg from vrFpgPlus not compiled under 2.6.4
{ TGRecordListEnumerator }
TGRecordListEnumerator<T> = class(TObject)
private
type
PT = ^T;
protected
FList: TFPList;
FPosition: Integer;
function GetCurrent: PT;
public
constructor Create(AList: TFPList);
function MoveNext: Boolean;
property Current: PT read GetCurrent;
end;
{ TGRecordList }
TGRecordList<T> = class(TObject)
private
type
PT = ^T;
TGRecordListEnumeratorSpec = TGRecordListEnumerator<T>;
private
FList: TFPList;
FDataSize: Integer;
function AllocateNewItem: PT;
function GetCapacity: Integer;
function GetCount: Integer;
function GetItem(const AIndex: Integer): PT;
procedure SetCapacity(AValue: Integer);
protected
procedure DoInitItem(var AItems: T); virtual;
procedure DoFreeItem(var AItems: T); virtual;
public
constructor Create; virtual;
destructor Destroy; override;
function Add(constref AItem: T): Integer;
procedure AddList(AList: TGRecordList<T>);
procedure Clear;
procedure Delete(const AIndex: Integer);
//class procedure Error(const Msg: string; Data: PtrInt); virtual;
procedure Exchange(Index1, Index2: Integer);
//function Expand: TList;
//function Extract(AItem: T): T;
function First: PT;
function GetEnumerator: TGRecordListEnumeratorSpec;
function IndexOf(const AItem: PT): Integer;
procedure Insert(const AIndex: Integer; constref AItem: T);
function Last: PT;
//procedure Move(CurIndex, NewIndex: Integer);
//procedure Assign (ListA: TList; AOperator: TListAssignOp=laCopy; ListB: TList=nil);
function Remove(const AItem: PT): Integer;
//procedure Pack;
procedure Sort(ACompare: TListSortCompare);
property Capacity: Integer read GetCapacity write SetCapacity;
property Count: Integer read GetCount;// write SetCount;
property Items[const AIndex: Integer]: PT read GetItem; default;
end;
{ TGThreadRecordList }
TGThreadRecordList<T> = class(TObject)
private
type
PT = ^T;
//TGRecordListEnumeratorSpec = TGRecordListEnumerator<T>;
TRecordList = TGRecordList<T>;
private
FList: TRecordList;
FLock: TRTLCriticalSection;
public
constructor Create; virtual;
destructor Destroy; override;
function Lock: TRecordList;
procedure UnLock;
function Add(constref AItem: T): Integer;
procedure AddList(AList: TRecordList);
procedure Clear;
procedure Delete(const AIndex: Integer);
//class procedure Error(const Msg: string; Data: PtrInt); virtual;
//procedure Exchange(Index1, Index2: Integer);
//function Expand: TList;
//function Extract(AItem: T): T;
function First: T;
//function GetEnumerator: TGRecordListEnumeratorSpec;
function IndexOf(const AItem: PT): Integer;
procedure Insert(const AIndex: Integer; constref AItem: T);
function Last: T;
//procedure Move(CurIndex, NewIndex: Integer);
//procedure Assign (ListA: TList; AOperator: TListAssignOp=laCopy; ListB: TList=nil);
function Remove(const AItem: PT): Integer;
//procedure Pack;
procedure Sort(ACompare: TListSortCompare);
function IsEmpty: Boolean;
//property Capacity: Integer read GetCapacity write SetCapacity;
//property Count: Integer read GetCount;// write SetCount;
//property Items[const AIndex: Integer]: PT read GetItem; default;
end;
{$IFDEF TEST_MODE}
type
TTestInfo = record
Handle: PtrInt;
IsJob: Boolean;
end;
PTestInfo = ^TTestInfo;
TTestRecordList = TGThreadRecordList<TTestInfo>;
{$ENDIF}
{$ENDIF VER3}
implementation
{ TGThreadObjectList }
constructor TGThreadObjectList<T>.Create(const AFreeObjects: Boolean);
begin
FDuplicates:=dupIgnore;
InitCriticalSection(FLock);
FList := TObjectList_T.Create(AFreeObjects);
end;
destructor TGThreadObjectList<T>.Destroy;
begin
LockList;
try
FList.Free;
inherited Destroy;
finally
UnlockList;
DoneCriticalSection(FLock);
end;
end;
procedure TGThreadObjectList<T>.Add(Item: T);
begin
LockList;
try
if (Duplicates=dupAccept) or
// make sure it's not already in the list
(FList.IndexOf(Item) = -1) then
FList.Add(Item)
else if (Duplicates=dupError) then
FList.Error(SDuplicateItem, PtrUInt(Item));
finally
UnlockList;
end;
end;
procedure TGThreadObjectList<T>.Clear;
begin
Locklist;
try
FList.Clear;
finally
UnLockList;
end;
end;
function TGThreadObjectList<T>.IsEmpty: Boolean;
begin
Locklist;
try
Result := FList.Count = 0;
finally
UnLockList;
end;
end;
procedure TGThreadObjectList<T>.Remove(Item: T);
begin
LockList;
try
FList.Remove(Item);
finally
UnlockList;
end;
end;
function TGThreadObjectList<T>.LockList: TObjectList_T;
begin
Result:=FList;
System.EnterCriticalSection(FLock);
end;
procedure TGThreadObjectList<T>.UnlockList;
begin
System.LeaveCriticalSection(FLock);
end;
{ TGItemDataList<D, T> }
function TGItemDataList<T, D>.AllocateNewItem(const AItem: T): PDataListRec;
begin
Getmem(Result, FDataSize);
FillChar(Result^, SizeOf(Result^), 0);
Result.Item := AItem;
end;
function TGItemDataList<T, D>.GetCapacity: Integer;
begin
Result := FList.Capacity;
end;
function TGItemDataList<T, D>.GetCount: Integer;
begin
Result := FList.Count;
end;
function TGItemDataList<T, D>.GetData(const AIndex: Integer): PData;
begin
Result := @PDataListRec(FList[AIndex]).Data;
end;
function TGItemDataList<T, D>.GetItem(const AIndex: Integer): T;
begin
Result := PDataListRec(FList[AIndex]).Item;
end;
procedure TGItemDataList<T, D>.SetCapacity(AValue: Integer);
begin
FList.Capacity := AValue;
end;
procedure TGItemDataList<T, D>.SetItem(const AIndex: Integer; AValue: T);
begin
PDataListRec(FList[AIndex]).Item := AValue;
end;
procedure TGItemDataList<T, D>.DoInitData(var AData: D);
begin
end;
procedure TGItemDataList<T, D>.DoFreeData(var AData: D);
begin
end;
constructor TGItemDataList<T, D>.Create;
begin
FList := TFPList.Create;
FDataSize := SizeOf(TGItemDataListRec);
end;
destructor TGItemDataList<T, D>.Destroy;
begin
Clear;
FreeAndNil(FList);
inherited Destroy;
end;
function TGItemDataList<T, D>.Add(const AItem: T): Integer;
var
p: PDataListRec;
begin
p := AllocateNewItem(AItem);
Result := FList.Add(p);
DoInitData(p.Data);
end;
procedure TGItemDataList<T, D>.Clear;
var
I: Integer;
begin
for I := FList.Count - 1 downto 0 do
Delete(I);
end;
procedure TGItemDataList<T, D>.Delete(const AIndex: Integer);
var
p: PDataListRec;
begin
p := FList[AIndex];
DoFreeData(p.Data);
Finalize(p.Data);
Freemem(p, FDataSize);
FList.Delete(AIndex);
end;
function TGItemDataList<T, D>.Extract(AItem: T): T;
var
i : Integer;
begin
i := IndexOf(AItem);
if i >= 0 then
begin
Result := AItem;
Delete(i);
end
else
Result := T(0);
end;
function TGItemDataList<T, D>.First: T;
begin
if FList.Count = 0 then
Result := T(0)
else
Result := PDataListRec(FList[0]).Item;
end;
function TGItemDataList<T, D>.IndexOf(const AItem: T): Integer;
var
C: Integer;
begin
Result := 0;
C := FList.Count;
while (Result < C) and (Items[Result] <> AItem) do
Inc(Result);
If Result >= C then
Result := -1;
end;
procedure TGItemDataList<T, D>.Insert(const AIndex: Integer; const AItem: T);
var
p: PDataListRec;
begin
p := AllocateNewItem(AItem);
p.Item := AItem;
FList.Insert(AIndex, p);
end;
function TGItemDataList<T, D>.Last: T;
begin
If FList.Count = 0 then
Result := T(0)
else
Result := PDataListRec(FList[FList.Count - 1]).Item;
end;
function TGItemDataList<T, D>.Remove(const AItem: T): Integer;
begin
Result := IndexOf(AItem);
if Result <> -1 then
Delete(Result);
end;
procedure TGItemDataList<T, D>.Sort(ACompare: TListSortCompare);
begin
FList.Sort(ACompare);
end;
{ TGThreadItemDataList }
constructor TGThreadItemDataList<T, D>.Create;
begin
FList := TItemList.Create;
InitCriticalSection(FLock);
end;
destructor TGThreadItemDataList<T, D>.Destroy;
begin
Lock;
try
FreeAndNil(FList);
inherited Destroy;
finally
UnLock;
DoneCriticalsection(FLock);
end;
end;
function TGThreadItemDataList<T, D>.Lock: TItemList;
begin
System.EnterCriticalsection(FLock);
Result := FList;
end;
procedure TGThreadItemDataList<T, D>.UnLock;
begin
System.LeaveCriticalsection(FLock);
end;
function TGThreadItemDataList<T, D>.Add(const AItem: T): Integer;
begin
Lock;
try
Result := FList.Add(AItem);
finally
UnLock;
end;
end;
procedure TGThreadItemDataList<T, D>.Clear;
begin
Lock;
try
FList.Clear;
finally
UnLock;
end;
end;
procedure TGThreadItemDataList<T, D>.Delete(const AIndex: Integer);
begin
Lock;
try
FList.Delete(AIndex);
finally
UnLock;
end;
end;
function TGThreadItemDataList<T, D>.Extract(AItem: T): T;
begin
Lock;
try
Result := FList.Extract(AItem);
finally
UnLock;
end;
end;
function TGThreadItemDataList<T, D>.First: T;
begin
Lock;
try
Result := FList.First;
finally
UnLock;
end;
end;
function TGThreadItemDataList<T, D>.IndexOf(const AItem: T): Integer;
begin
Lock;
try
Result := FList.IndexOf(AItem);
finally
UnLock;
end;
end;
procedure TGThreadItemDataList<T, D>.Insert(const AIndex: Integer; const AItem: T);
begin
Lock;
try
FList.Insert(AIndex, AItem);
finally
UnLock;
end;
end;
function TGThreadItemDataList<T, D>.Last: T;
begin
Lock;
try
Result := FList.Last;
finally
UnLock;
end;
end;
function TGThreadItemDataList<T, D>.Remove(const AItem: T): Integer;
begin
Lock;
try
Result := FList.Remove(AItem);
finally
UnLock;
end;
end;
procedure TGThreadItemDataList<T, D>.Sort(ACompare: TListSortCompare);
begin
Lock;
try
FList.Sort(ACompare);
finally
UnLock;
end;
end;
{$IF FPC_FULLVERSION >= 030000}
{ TGRecordListEnumerator<T> }
function TGRecordListEnumerator<T>.GetCurrent: PT;
begin
Result := PT(FList.Items[FPosition]);
end;
constructor TGRecordListEnumerator < T > .Create(AList: TFPList);
begin
FList := AList;
FPosition := -1;
end;
function TGRecordListEnumerator<T>.MoveNext: Boolean;
begin
inc(FPosition);
Result := FPosition < FList.Count;
end;
{ TGRecordList<T> }
function TGRecordList<T>.AllocateNewItem: PT;
begin
Getmem(Result, FDataSize);
FillChar(Result^, SizeOf(Result^), 0);
DoInitItem(Result^);
end;
function TGRecordList<T>.GetCapacity: Integer;
begin
Result := FList.Capacity;
end;
function TGRecordList<T>.GetCount: Integer;
begin
Result := FList.Count;
end;
function TGRecordList<T>.GetItem(const AIndex: Integer): PT;
begin
Result := PT(FList[AIndex]);
end;
procedure TGRecordList<T>.SetCapacity(AValue: Integer);
begin
FList.Capacity := AValue;
end;
procedure TGRecordList<T>.DoInitItem(var AItems: T);
begin
end;
procedure TGRecordList<T>.DoFreeItem(var AItems: T);
begin
end;
constructor TGRecordList < T > .Create;
begin
FList := TFPList.Create;
FDataSize := SizeOf(T);
end;
destructor TGRecordList < T > .Destroy;
begin
Clear;
FreeAndNil(FList);
inherited Destroy;
end;
function TGRecordList<T>.Add(constref AItem: T): Integer;
var
p: PT;
begin
p := AllocateNewItem;
p^ := AItem;
Result := FList.Add(p);
end;
procedure TGRecordList<T>.AddList(AList: TGRecordList<T>);
var
i: Integer;
begin
for i := 0 to AList.Count - 1 do
{$IF FPC_FULLVERSION >= 030000}Add(AList[i]^){$ELSE}Add(PT(AList[i])^){$ENDIF};
end;
procedure TGRecordList<T>.Clear;
var
i: Integer;
begin
for i := FList.Count - 1 downto 0 do
Delete(i);
end;
procedure TGRecordList<T>.Delete(const AIndex: Integer);
var
p: PT;
begin
p := FList[AIndex];
DoFreeItem(p^);
Finalize(p^);
Freemem(p, FDataSize);
FList.Delete(AIndex);
end;
procedure TGRecordList<T>.Exchange(Index1, Index2: Integer);
begin
FList.Exchange(Index1, Index2);
end;
function TGRecordList<T>.First: PT;
begin
if FList.Count = 0 then
Result := nil
else
Result := PT(FList[0]);
end;
function TGRecordList<T>.GetEnumerator: TGRecordListEnumeratorSpec;
begin
Result := TGRecordListEnumeratorSpec.Create(FList);
end;
procedure TGRecordList<T>.Insert(const AIndex: Integer; constref AItem: T);
var
p: PT;
begin
p := AllocateNewItem;
p^ := AItem;
FList.Insert(AIndex, p);
end;
function TGRecordList<T>.Last: PT;
begin
If FList.Count = 0 then
Result := nil
else
Result := PT(FList[FList.Count - 1]);
end;
function TGRecordList<T>.IndexOf(const AItem: PT): Integer;
var
C: Integer;
begin
Result := 0;
C := FList.Count;
while (Result < C) and (Items[Result] <> AItem) do
Inc(Result);
If Result >= C then
Result := -1;
end;
function TGRecordList<T>.Remove(const AItem: PT): Integer;
begin
Result := IndexOf(AItem);
if Result <> -1 then
Delete(Result);
end;
procedure TGRecordList<T>.Sort(ACompare: TListSortCompare);
begin
FList.Sort(ACompare);
end;
{ TGThreadRecordList }
constructor TGThreadRecordList<T>.Create;
begin
FList := TRecordList.Create;
InitCriticalSection(FLock);
end;
destructor TGThreadRecordList<T>.Destroy;
begin
Lock;
try
FreeAndNil(FList);
inherited Destroy;
finally
UnLock;
DoneCriticalsection(FLock);
end;
end;
function TGThreadRecordList<T>.Lock: TRecordList;
begin
System.EnterCriticalSection(FLock);
Result := FList;
end;
procedure TGThreadRecordList<T>.UnLock;
begin
System.LeaveCriticalsection(FLock);
end;
function TGThreadRecordList<T>.Add(constref AItem: T): Integer;
begin
Lock;
try
Result := FList.Add(AItem);
finally
UnLock;
end;
end;
procedure TGThreadRecordList<T>.AddList(AList: TRecordList);
begin
Lock;
try
FList.AddList(AList);
finally
UnLock;
end;
end;
procedure TGThreadRecordList<T>.Clear;
begin
Lock;
try
FList.Clear;
finally
UnLock;
end;
end;
procedure TGThreadRecordList<T>.Delete(const AIndex: Integer);
begin
Lock;
try
FList.Delete(AIndex);
finally
UnLock;
end;
end;
function TGThreadRecordList<T>.First: T;
begin
Lock;
try
Result := FList.First^;
finally
UnLock;
end;
end;
function TGThreadRecordList<T>.IndexOf(const AItem: PT): Integer;
begin
Lock;
try
Result := FList.IndexOf(AItem);
finally
UnLock;
end;
end;
procedure TGThreadRecordList<T>.Insert(const AIndex: Integer; constref AItem: T);
begin
Lock;
try
FList.Insert(AIndex, AItem);
finally
UnLock;
end;
end;
function TGThreadRecordList<T>.Last: T;
begin
Lock;
try
Result := FList.Last^;
finally
UnLock;
end;
end;
function TGThreadRecordList<T>.Remove(const AItem: PT): Integer;
begin
Lock;
try
Result := FList.Remove(AItem);
finally
UnLock;
end;
end;
procedure TGThreadRecordList<T>.Sort(ACompare: TListSortCompare);
begin
Lock;
try
FList.Sort(ACompare);
finally
UnLock;
end;
end;
function TGThreadRecordList<T>.IsEmpty: Boolean;
begin
Lock;
try
Result := FList.Count = 0;
finally
UnLock;
end;
end;
{$ENDIF VER3}
end.
|
unit RN_Helper;
interface
uses SysUtils;
type
TCompareIndicesFunction = function (const A,B: Pointer): Integer;
procedure qSort(aBuffer: Pointer; aCount: Integer; aSize: Integer; Compare: TCompareIndicesFunction);
function Sscanf(const s: string; const fmt: string; const Pointers: array of Pointer): Integer;
implementation
//todo: Test this sort with array of record containing array of Integers
procedure QSort(aBuffer: Pointer; aCount: Integer; aSize: Integer; Compare: TCompareIndicesFunction);
procedure QuickSort(aBuffer: Pointer; iLo, iHi: Integer);
var Lo, Hi: Integer; Mid, T: Pointer;
begin
Lo := iLo;
Hi := iHi;
Mid := Pointer(Cardinal(aBuffer) + ((Lo + Hi) div 2) * aSize);
repeat
while Compare(Pointer(Cardinal(aBuffer) + Lo*aSize), Mid) < 0 do
Inc(Lo);
while Compare(Pointer(Cardinal(aBuffer) + Hi*aSize), Mid) > 0 do
Dec(Hi);
if Lo <= Hi then begin
getmem(T, aSize);
Move(Pointer(Cardinal(aBuffer) + Lo*aSize)^, T^, aSize);
Move(Pointer(Cardinal(aBuffer) + Hi*aSize)^, Pointer(Cardinal(aBuffer) + Lo*aSize)^, aSize);
Move(T^, Pointer(Cardinal(aBuffer) + Hi*aSize)^, aSize);
freemem(T);
Inc(Lo);
Dec(Hi);
end;
until Lo > Hi;
if Hi > iLo then
QuickSort(aBuffer, iLo, Hi);
if Lo < iHi then
QuickSort(aBuffer, Lo, iHi);
end;
begin
QuickSort(aBuffer, 0, aCount-1);
end;
{ Sscanf выполняет синтаксический разбор входной строки. Параметры...
s - входная строка для разбора
fmt - 'C' scanf-форматоподобная строка для управления разбором
%d - преобразование в Long Integer
%f - преобразование в Extended Float
%s - преобразование в строку (ограничено пробелами)
другой символ - приращение позиции s на "другой символ"
пробел - ничего не делает
Pointers - массив указателей на присваиваемые переменные
результат - количество действительно присвоенных переменных
Например, ...
Sscanf('Name. Bill Time. 7:32.77 Age. 8',
'. %s . %d:%f . %d', [@Name, @hrs, @min, @age]);
возвратит ...
Name = Bill hrs = 7 min = 32.77 age = 8 }
function Sscanf(const s: string; const fmt: string;
const Pointers: array of Pointer): Integer;
var
i, j, n, m: integer;
s1: string;
L: Integer;
X: Single;
function GetInt: Integer;
begin
s1 := '';
while (s[n] = ' ') and (Length(s) > n) do
inc(n);
while (n <= Length(s)) and (s[n] in ['0'..'9', '+', '-']) do
begin
s1 := s1 + s[n];
inc(n);
end;
Result := Length(s1);
end;
function GetFloat: Integer;
begin
s1 := '';
while (s[n] = ' ') and (Length(s) > n) do
inc(n);
while (n <= Length(s)) and (s[n] in ['0'..'9', '+', '-', '.', 'e', 'E']) do
begin
s1 := s1 + s[n];
inc(n);
end;
Result := Length(s1);
end;
function GetString: Integer;
begin
s1 := '';
while (s[n] = ' ') and (Length(s) > n) do
inc(n);
while (n <= Length(s)) and (s[n] <> ' ') do
begin
s1 := s1 + s[n];
inc(n);
end;
Result := Length(s1);
end;
function ScanStr(c: Char): Boolean;
begin
while (s[n] <> c) and (Length(s) > n) do
inc(n);
inc(n);
if (n <= Length(s)) then
Result := True
else
Result := False;
end;
function GetFmt: Integer;
begin
Result := -1;
while (TRUE) do
begin
while (fmt[m] = ' ') and (Length(fmt) > m) do
inc(m);
if (m >= Length(fmt)) then
break;
if (fmt[m] = '%') then
begin
inc(m);
case fmt[m] of
'd': Result := vtInteger;
'f': Result := vtExtended;
's': Result := vtString;
end;
inc(m);
break;
end;
if (ScanStr(fmt[m]) = False) then
break;
inc(m);
end;
end;
begin
n := 1;
m := 1;
Result := 0;
for i := 0 to High(Pointers) do
begin
j := GetFmt;
case j of
vtInteger:
begin
if GetInt > 0 then
begin
L := StrToInt(s1);
Move(L, Pointers[i]^, SizeOf(LongInt));
inc(Result);
end
else
break;
end;
vtExtended:
begin
if GetFloat > 0 then
begin
X := StrToFloat(s1);
Move(X, Pointers[i]^, SizeOf(Single));
inc(Result);
end
else
break;
end;
vtString:
begin
if GetString > 0 then
begin
Move(s1, Pointers[i]^, Length(s1) + 1);
inc(Result);
end
else
break;
end;
else
break;
end;
end;
end;
end.
|
unit FIToolkit.Runner.Exceptions;
interface
uses
FIToolkit.Commons.Exceptions;
type
ECommonTaskException = class abstract (ECustomException);
{ Task manager exceptions }
ETaskManagerException = class abstract (ECustomException);
ESomeTasksFailed = class (ETaskManagerException);
{ Task runner exceptions }
ETaskRunnerException = class abstract (ECommonTaskException);
ECreateProcessError = class (ETaskRunnerException);
ENonZeroExitCode = class (ETaskRunnerException);
implementation
uses
FIToolkit.Runner.Consts;
initialization
RegisterExceptionMessage(ECreateProcessError, RSCreateProcessError);
RegisterExceptionMessage(ENonZeroExitCode, RSNonZeroExitCode);
RegisterExceptionMessage(ESomeTasksFailed, RSSomeTasksFailed);
end.
|
{ **************************************************************
Package: XWB - Kernel RPCBroker
Date Created: Sept 18, 1997 (Version 1.1)
Site Name: Oakland, OI Field Office, Dept of Veteran Affairs
Developers: Danila Manapsal, Joel Ivey
Description: Contains TRPCBroker and related components.
Unit: RpcSLogin Silent Login functionality.
Current Release: Version 1.1 Patch 65
*************************************************************** }
{ **************************************************
Changes in v1.1.65 (HGW 11/17/2016) XWB*1.1*65
1. Added new Silent Login mode for Identity and Access Management (IAM)
Single Sign-On (lmSSOi).
2. In function SilentLogin, ASOSKIP (Param[1]) is set to 1 to disable
Client Agent (ClAgent.exe) callback (deprecated).
3. Commented out (but did not yet remove) login mode lmNTToken, as it
was not fully implemented.
Changes in v1.1.60 (HGW 12/18/2013) XWB*1.1*60
1. None.
Changes in v1.1.50 (JLI 09/01/2011) XWB*1.1*50
1. Updates to support SSH.
************************************************** }
unit RpcSLogin;
interface
{$I IISBase.inc}
uses
{System}
SysUtils, Classes, IniFiles, Registry, AnsiStrings,
{WinApi}
Messages, WinProcs,
{VA}
Trpcb,
{Vcl}
Dialogs;
function SilentLogIn(SLBroker: TRPCBroker): boolean;
procedure GetUserInfo(ConnectedBroker: TRPCBroker);
procedure GetSessionInfo(ConnectedBroker: TRPCBroker);
procedure StartProgSLogin(const ProgLine: String; ConnectedBroker: TRPCBroker; WindowType: Integer = SW_SHOWNORMAL);
function CheckCmdLine(SLBroker: TRPCBroker): Boolean;
implementation
uses
{VA}
Wsockc, Loginfrm, RpcbErr, SelDiv, XWBHash;
{------------------------ ValidAVCodes ---------------------------
Authenticate user with Access/Verify Codes or ASO token using
an RPC call to 'XUS AV CODE'
------------------------------------------------------------------}
function ValidAVCodes(SLBroker: TRPCBroker): boolean;
begin
Result := False;
try
with SLBroker do
begin
Param[0].Value := Encrypt(LogIn.AccessCode + ';' + LogIn.VerifyCode);
Param[0].PType := literal;
RemoteProcedure := 'XUS AV CODE';
Call;
if Results[0] > '0' then
begin
Login.DUZ := Results[0];
Login.PromptDivision := True;
Result := True;
end
else
begin
Result := False;
if Results[2] = '1' then Login.ErrorText := 'Expired Verify Code' //vcode needs changing;
else if Results[0] = '0' then Login.ErrorText :='Invalid Access/Verify Codes' //no valid DUZ returned;
else Login.ErrorText := Results[3];
end;
end;
except
raise
end;
end; //function ValidAVCodes
{------------------------ ValidAppHandle -------------------------
Authenticate user with Application Handle (CCOW Token)
using an RPC call to 'XUS AV CODE'
------------------------------------------------------------------}
function ValidAppHandle(SLBroker: TRPCBroker): boolean;
begin
Result := False;
try
with SLBroker do
begin
Param[0].Value := SLBroker.Login.LogInHandle;
Param[0].PType := literal;
RemoteProcedure := 'XUS AV CODE';
Call;
if Pos(Copy(SLBroker.Results[0],1,1),'123456789') > 0 then
begin
Login.DUZ := Results[0];
Login.PromptDivision := False;
Result := True;
end
else if Results[2] = '1' then Login.ErrorText := 'Expired Verify Code' //vcode needs changing;
else if Results[0] = '0' then Login.ErrorText :='Invalid Access/Verify Codes' //no valid DUZ returned;
else Login.ErrorText := Results[3];
end;
except
raise
end;
end; //function ValidAppHandle
{------------------------ ValidNTToken ---------------------------
Authenticate user with NT Kerberos token (not implemented)
------------------------------------------------------------------}
//function ValidNTToken(SLBroker: TRPCBroker): boolean;
//begin
// Result := False;
//end; //function ValidNTToken
{------------------------ ValidSSOiToken -------------------------
Authenticate user with STS SAML Token from IAM using
an RPC call to 'XUS ESSO VALIDATE'
------------------------------------------------------------------}
function ValidSSOiToken(SLBroker: TRPCBroker): boolean;
var
I,iStart,iEnd: integer;
uToken: String;
iTokenLength: Integer;
begin
Result := False;
try
with SLBroker do
begin
uToken := Login.LogInHandle;
iTokenLength := Length(uToken);
RemoteProcedure := 'XUS ESSO VALIDATE';
Param[0].PType := global;
with Param[0] do
begin
I :=0;
iEnd := 0;
while (iEnd < iTokenLength) do
begin
//Build Param[0] global, 200 chars per node
iStart := (I * 200) + 1;
iEnd := iStart + 199;
Mult[IntToStr(I)] := AnsiStrings.AnsiMidStr(uToken, iStart, 200);
I := I + 1;
end;
end;
Call;
if Results[0] > '0' then
begin
Login.DUZ := Results[0];
Login.PromptDivision := True;
Result := True;
end
else
begin
Result := False;
if Results[2] = '1' then Login.ErrorText := 'Expired Verify Code' //vcode needs changing;
else if Results[0] = '0' then Login.ErrorText :='Invalid 2-Factor Authentication' //no valid DUZ returned;
else Login.ErrorText := Results[3];
end;
end;
except
raise
end;
end; //function ValidSSOiToken
{------------------------ SilentLogIn -------------------------
Authenticate user with credentials passed as parameters.
------------------------------------------------------------------}
function SilentLogIn(SLBroker: TRPCBroker): boolean;
begin
Result := False;
//determine if signon is needed
try
with SLBroker do begin
RemoteProcedure := 'XUS SIGNON SETUP';
Param[0].Value := ''; //No AppHandle for silent login
Param[0].PType := literal;
Param[1].Value := '1'; //Disable Client Agent callback
Param[1].PType := literal;
Call;
SLBroker.Login.IsProductionAccount := False;
SLBroker.Login.DomainName := '';
if SLBroker.Results.Count > 7 then
begin
SLBroker.Login.DomainName := SLBroker.Results[6];
if SLBroker.Results[7] = '1' then
SLBroker.Login.IsProductionAccount := True;
end;
if Results.Count > 5 then //Server sent auto signon info.
if SLBroker.Results[5] = '1' then //User already logged in
begin
Result := True;
GetUserInfo(SLBroker);
exit;
end;
if Login.Mode = lmSSOi then //STS SAML token authentication
if ValidSSOiToken(SLBroker) then Result := True;
if Login.Mode = lmAVCodes then //Access & Verify codes authentication
if ValidAVCodes(SLBroker) then Result := True;
if Login.Mode = lmAppHandle then
if ValidAppHandle(SLBroker)then Result := True;
if Result and (SLBroker.Contextor = nil) and not (Login.Mode = lmSSOi) then
begin
//determine if user is multidivisional - makes calls to Seldiv.
LogIn.MultiDivision := MultDiv(SLBroker);
if not LogIn.MultiDivision then
begin
Result := True;
exit;
end;
if LogIn.PromptDivision then
Result := SelectDivision(LogIn.DivList, SLBroker)
else if Login.Division <> '' then
Result := SetDiv(Login.Division, SLBroker)
else
begin
Result := False;
Login.ErrorText := 'No Division Selected';
end;
if not Result then
exit;
end;
end;
except
exit;
end;
end; //function SilentLogIn
{------------------------ GetUserInfo -------------------------
Get information for TVistaUser class (Tobject) using
RPC 'XUS GET USER INFO'
------------------------------------------------------------------}
procedure GetUserInfo(ConnectedBroker: TRPCBroker);
begin
with ConnectedBroker do
begin
try
RemoteProcedure := 'XUS GET USER INFO';
Call;
if Results.Count > 0 then
with ConnectedBroker.User do
begin
DUZ := Results[0];
Name := Results[1];
StandardName := Results[2];
Division := Results[3];
Title := Results[4];
ServiceSection := Results[5];
Language := Results[6];
DTime := Results[7];
if Results.Count > 8 then
Vpid := Results[8]
else
Vpid := '';
end;
except
end;
end;
end; //procedure GetUserInfo
{------------------------ GetSessionInfo -------------------------
Get information for TVistaSession class (Tobject) using
RPC 'XUS GET SESSION INFO'
------------------------------------------------------------------}
procedure GetSessionInfo(ConnectedBroker: TRPCBroker);
begin
with ConnectedBroker do
begin
try
RemoteProcedure := 'XWB GET SESSION INFO';
Call;
if Results.Count > 0 then
begin
{VistaSession.Create;
with VistaSession do
begin
DUZ := Results[0]
//other properties follow
end;}
end;
except
end;
end;
end; //procedure GetSessionInfo
{------------------------ StartProgSLogin -------------------------
This procedure can be used to start a second application and pass on the
command line the data which would be needed to initiate a silent login
using a LoginHandle value. It is assumed that the command line would be
read using the CheckCmdLine procedure or one similar to it as the form
for the new application was loaded. This procedure can also be used to
start a non-RPCBroker application. If the value for ConnectedBroker is nil,
the application specified in ProgLine will be started and any command line
included in ProgLine will be passed to the application.
------------------------------------------------------------------}
procedure StartProgSLogin(const ProgLine: String; ConnectedBroker: TRPCBroker; WindowType: Integer = SW_SHOWNORMAL);
var
StartupInfo: TStartupInfo;
ProcessInfo: TProcessInformation;
AppHandle: String;
CmndLine: String;
currHandle1: THandle;
begin
currHandle1 := GetCurrentProcess;
FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
with StartupInfo do
begin
cb := SizeOf(TStartupInfo);
dwFlags := STARTF_USESHOWWINDOW;
WShowWindow := WindowType;
end;
CmndLine := ProgLine;
if ConnectedBroker <> nil then
begin
AppHandle := GetAppHandle(ConnectedBroker);
CmndLine := CmndLine + ' s='+ConnectedBroker.Server + ' p='
+ IntToStr(ConnectedBroker.ListenerPort) + ' h='
+ AppHandle + ' d=' + ConnectedBroker.User.Division;
end;
CreateProcess(nil, PChar(CmndLine), nil, nil, False,
NORMAL_PRIORITY_CLASS, nil, nil, StartupInfo, ProcessInfo);
CommandBoxProcessHandle := ProcessInfo.hProcess;
CommandBoxThreadHandle := ProcessInfo.hThread;
SetActiveWindow(currHandle1);
end; //procedure StartProgSLogin
{------------------------ CheckCmdLine --------------------------
This function can be used to check whether the command line contains
information on the broker settings and can setup for a Silent Login using
the LoginHandle value passed from another application. This procedure
would normally be called within the code associated with FormCreate event.
It assumes the Server, ListenerPort, Division, and LoginHandle values
(if present) are indicated by s=, p=, d=, and h=, respectively. The
argument is a reference to the TRPCBroker instance to be used.
------------------------------------------------------------------}
function CheckCmdLine(SLBroker: TRPCBroker): Boolean;
var
j: Integer;
begin
with SLBroker do
begin
for j := 1 to ParamCount do // Iterate through possible command line arguments
begin
if Pos('p=',ParamStr(j)) > 0 then
ListenerPort := StrToInt(Copy(ParamStr(j),
(Pos('=',ParamStr(j))+1),length(ParamStr(j))));
if Pos('s=',ParamStr(j)) > 0 then
Server := Copy(ParamStr(j),
(Pos('=',ParamStr(j))+1),length(ParamStr(j)));
if Pos('h=',ParamStr(j)) > 0 then
begin
Login.LoginHandle := Copy(ParamStr(j),
(Pos('=',ParamStr(j))+1),length(ParamStr(j)));
if Login.LoginHandle <> '' then
begin
KernelLogin := False;
Login.Mode := lmAppHandle;
end;
end;
if Pos('d=',ParamStr(j)) > 0 then
Login.Division := Copy(ParamStr(j),
(Pos('=',ParamStr(j))+1),length(ParamStr(j)));
end; // for
if Login.Mode = lmAppHandle then
Connected := True; // Go ahead and make the connection
Result := False;
if Connected then
Result := True;
end; // with SLBroker
end; //function CheckCmdLine
end.
|
program stack;
const
STACK_ELEMENTS = 18;
type
TStack = record
data: array of integer;
head: integer;
end;
procedure stack_init(var stack: TStack);
begin
SetLength(stack.data, STACK_ELEMENTS);
stack.head := 0;
end;
procedure stack_destroy(var stack: TStack);
begin
stack_init(stack);
end;
function stack_size(var stack: TStack): integer;
begin
stack_size := stack.head;
end;
function stack_is_full(var stack: TStack): boolean;
begin
stack_is_full := stack_size(stack) >= STACK_ELEMENTS;
end;
function stack_is_empty(var stack: TStack): boolean;
begin
stack_is_empty := stack_size(stack) <= 0;
end;
function stack_push(var stack: TStack; number: integer): boolean;
begin
if stack_is_full(stack) then
begin
stack_push := false;
exit;
end;
stack.data[stack.head] := number;
stack.head := stack.head + 1;
stack_push := true;
end;
function stack_pop(var stack: TStack; var number: integer): boolean;
begin
if stack_is_empty(stack) then
begin
stack_pop := false;
exit;
end;
stack.head := stack.head - 1;
number := stack.data[stack.head];
stack_pop := true;
end;
var
s1, s2: TStack;
i: integer;
begin
stack_init(s1);
stack_init(s2);
i := 0;
while stack_push(s1, i) do i := i + 1;
i := 100;
while stack_push(s2, i) do i := i + 1;
writeln('Stack1 size: ', stack_size(s1));
writeln('Stack2 size: ', stack_size(s2));
write('Stack1: ');
while stack_pop(s1, i) do write(i, ' ');
writeln; write('Stack2: ');
while stack_pop(s2, i) do write(i, ' ');
writeln;
stack_destroy(s1);
stack_destroy(s2);
writeln('Stack1 size: ', stack_size(s1));
writeln('Stack2 size: ', stack_size(s2));
end.
|
unit TablasComis;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
TB2Dock, TB2Toolbar, ComCtrls, TB2ExtItems, TBXExtItems, TBX, AxCtrls, OleCtrls,
StdCtrls, Mask, RxToolEdit, Menus, VCIF1Lib_TLB,IniFiles, LibApp, RxPlacemnt,
RXCtrls, ExtCtrls, RXSpin, ProductoSearch, FamiliaSearch, HHelp,
rxCurrEdit, TB2Item, IB_Components, RzEdit, RzSpnEdt, RzLabel, RzPanel, RzTabs;
type
TfrmTablasComis = class(TForm)
dckSincro: TTBXDock;
tlbMain: TTBXToolbar;
tbtSalir: TTBXItem;
tbtImprimir: TTBXItem;
tbtPrever: TTBXItem;
tbtGrabar: TTBXItem;
tbtAbrir: TTBXItem;
tbtCreate: TTBXItem;
ToolbarSep973: TTBXSeparatorItem;
PopupMenu1: TPopupMenu;
Fonts1: TMenuItem;
Numeros1: TMenuItem;
Bordes1: TMenuItem;
Alineacion1: TMenuItem;
Rellenos1: TMenuItem;
N1: TMenuItem;
Preferencias1: TMenuItem;
FormStorage1: TFormStorage;
TBXSeparatorItem1: TTBXSeparatorItem;
isqlIns: TIB_DSQL;
isqlDel: TIB_DSQL;
itmAyuda: TTBXItem;
TBXSeparatorItem2: TTBXSeparatorItem;
pgcSincro: TRzPageControl;
tshCriterios: TRzTabSheet;
tshOpciones: TRzTabSheet;
RzPanel1: TRzPanel;
lbzEsquema: TRzLabel;
sedEsquema: TRzSpinEdit;
fraFamilia1: TfraFamilia;
pgcMain: TRzPageControl;
tshCaptura: TRzTabSheet;
TabSheet2: TRzTabSheet;
F1: TF1Book;
TBXSeparatorItem3: TTBXSeparatorItem;
F2: TF1Book;
lblEsquema: TRzLabel;
icu1: TIB_Cursor;
tbtGenReporte: TTBXItem;
tbtImpReporte: TTBXItem;
tbtGrabarXls: TTBXItem;
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure tbtSalirClick(Sender: TObject);
procedure LoadXLS;
procedure LoadXLS2;
procedure FormCreate(Sender: TObject);
procedure Preferencias1Click(Sender: TObject);
procedure LeerTablas;
procedure GrabarTablas;
procedure tbtLeerClick(Sender: TObject);
procedure F1StartEdit(Sender: TObject; var EditString: WideString;
var Cancel: Smallint);
procedure F1KeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure tbtCreateClick(Sender: TObject);
procedure axnLimpiar;
procedure axnLeer;
procedure axnGrabar;
procedure axnPrever;
procedure axnImprimir;
procedure tbtAbrirClick(Sender: TObject);
procedure tbtGrabarClick(Sender: TObject);
procedure tbtPreverClick(Sender: TObject);
procedure tbtImprimirClick(Sender: TObject);
procedure tbtAfectarClick(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure UpdateControls(Sender: TObject);
procedure itmAyudaClick(Sender: TObject);
procedure sedEsquemaChange(Sender: TObject);
procedure fraFamilia1xceCodFamKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure GenerarReporte;
procedure tbtGenReporteClick(Sender: TObject);
procedure tbtImpReporteClick(Sender: TObject);
procedure tbtGrabarXlsClick(Sender: TObject);
procedure axnGrabarXls;
private
{ Private declarations }
public
{ Public declarations }
end;
const UPD:Integer = 1;
DEL:Integer = 0;
var
frmTablasComis: TfrmTablasComis;
iType:SmallInt;
mfLook,mfShowMsg:Boolean;
ColSet: set of 1..200;
miRowIni:Integer = 8;
miRowEnd:Integer;
oIni:TIniFile;
mrRes:Integer;
aEsq : array[0..3] of String;
aTabla: array[1..3] of String;
implementation
uses Main, OpcionesF1, StrMan, SelTabla, DM_MBA;
var WCols: array[1..100] of integer;
{$R *.DFM}
procedure TfrmTablasComis.FormCreate(Sender: TObject);
var tFile:String;
begin
tFile := LibApp.GetIniFile;
oIni := TIniFile.Create (tFile);
LoadXLS;
// Columnas que no se pueden modificar en el F1...
ColSet := [1];
fraFamilia1.Initiate;
frafamilia1.OnRetrieve :=UpdateControls;
icu1 := TIB_Cursor.Create(nil);
icu1.IB_Connection := DM1.cnMBA;
icu1.IB_Transaction := DM1.trMBA;
isqlIns:= TIB_DSQL.Create(DM1);
isqlIns.IB_Connection := DM1.cnMBA;
isqlIns.IB_Transaction := DM1.trMBA;
isqlDel:= TIB_DSQL.Create(DM1);
isqlDel.IB_Connection := DM1.cnMBA;
isqlDel.IB_Transaction := DM1.trMBA;
with icu1 do begin
SQL.Clear;
Sql.Add ('SELECT ');
Sql.Add (' A.ID, A.HOJA, A.REN, A.CODFAMILIA, B.DESCRIPFAM, A.ESQUEMA, A.LIMITEINF, A.LIMITESUP, A.PORCENTAJE, A.OBSERVACIONES, FHACT, USERACT ');
Sql.Add ('FROM TABLACOMIS A ');
Sql.Add ('JOIN MBA10040 B ON (A.CODFAMILIA = B.CODFAM) ');
Sql.Add ('WHERE (A.ESQUEMA = ?ESQUEMA) ');
Sql.Add ('ORDER BY A.CODFAMILIA,A.HOJA,A.LIMITEINF; ');
Prepare;
end;
with isqlIns do begin
SQL.Clear;
Sql.Add ('INSERT INTO TABLACOMIS ');
Sql.Add (' ( ID, HOJA, REN, CODFAMILIA, ESQUEMA, LIMITEINF, LIMITESUP, PORCENTAJE, OBSERVACIONES, FHACT, USERACT) VALUES ');
Sql.Add (' (?ID, ?HOJA,?REN,?CODFAMILIA,?ESQUEMA,?LIMITEINF,?LIMITESUP,?PORCENTAJE,?OBSERVACIONES,?FHACT,?USERACT);');
Prepare;
end;
with isqlDel do begin
SQL.Clear;
Sql.Add ('DELETE FROM TABLACOMIS ');
Sql.Add (' WHERE (CODFAMILIA = ?CODFAMILIA) AND (ESQUEMA = ?ESQUEMA);');
Prepare;
end;
aEsq[0] := 'Vendedores Comisionistas';
aEsq[1] := 'Vendedores Especializados';
aEsq[2] := 'Vendedores Telemarketing';
aEsq[3] := 'Por Definir';
aTabla[1] := 'Tabla de Comisiones por Descuento';
aTabla[2] := 'Tabla de Comisiones por Margen';
aTabla[3] := 'Tabla de Comision Base por Dias Vencidos';
sedEsquema.Value := 0;
sedEsquemaChange(nil);
UpdateControls(nil);
end;
procedure TfrmTablasComis.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
oIni.Free;
frmTablasComis := nil;
Action := caFree;
end;
procedure TfrmTablasComis.tbtSalirClick(Sender: TObject);
begin
close;
end;
procedure TfrmTablasComis.tbtGrabarXlsClick(Sender: TObject);
begin
axnGrabarXls;
end;
procedure TfrmTablasComis.LoadXLS;
var tFile,tDir:String;
begin
tDir := oINi.ReadString ('Directorios','Formatos',''); // ExtractFileDir(ParamStr(0));
tFile := 'FMT_TABLASCOMIS.xls';
tFile := tDir+'\'+tFile;
F1.Read (tFile,iType);
F1.FixedRows := 7;
miRowIni := F1.FixedRows + 1;
F1.PrintTitles := 'A1:IV7';
F1.Sheet :=1;
F1.TextRC[2,2] := oEmp.RAZSOCIAL;
F1.AllowDelete := False;
F1.ShowEditBar := True;
F1.Modified := False;
end;
procedure TfrmTablasComis.LoadXLS2;
var tFile,tDir:String;
begin
tDir := oINi.ReadString ('Directorios','Formatos',''); // ExtractFileDir(ParamStr(0));
tFile := 'FMT_TablasComisImpre.xls';
tFile := tDir+'\'+tFile;
F2.Read (tFile,iType);
F2.FixedRows := 6;
miRowIni := F2.FixedRows + 1;
F2.PrintTitles := 'A2:IV6';
F2.Sheet :=1;
F2.TextRC[2,2] := oEmp.RAZSOCIAL;
F2.AllowDelete := False;
F2.ShowEditBar := True;
F2.Modified := False;
end;
procedure TfrmTablasComis.UpdateControls(Sender: TObject);
begin
if fraFamilia1.FOUND then begin
LeerTablas;
end else begin
end;
tbtAbrir.Enabled := fraFamilia1.FOUND;
tbtGrabar.Enabled:= tbtAbrir.Enabled;
end;
procedure TfrmTablasComis.Preferencias1Click(Sender: TObject);
var iRes :Integer;
begin
frmOpcF1 := TFrmOpcF1.Create (Application);
frmOpcF1.F1 := F1;
iRes := frmOpcF1.showmodal;
end;
procedure TfrmTablasComis.sedEsquemaChange(Sender: TObject);
begin
lblEsquema.caption := aEsq[sedEsquema.IntValue];
end;
procedure TfrmTablasComis.LeerTablas;
var i:Integer;
iRecCount,iRec,iSheet:Integer;
tFiltro,tKey,tTipoProd,tSel,tP1,tP2,tCodIni,tCodFin:String;
fFound,fBorrado:Boolean;
Row,Col:Integer;
begin
Screen.Cursor := crHourglass;
pgcMain.ActivePageIndex := 0;
LoadXls;
tSel := F1.selection;
F1.TextSRC[1,4,2] := fraFamilia1.xceCodFam.Text + ' ' +
fraFamilia1.xceDescripFam.Text;
F1.TextSRC[2,4,2] := F1.TextSRC[1,4,2];
F1.TextSRC[3,4,2] := F1.TextSRC[1,4,2];
DM1.iqrArt.SQL.Clear;
DM1.iqrArt.SQL.Add ('SELECT id, hoja, ren, codfamilia, limiteinf, limitesup, porcentaje, observaciones, fhact, useract ');
DM1.iqrArt.SQL.Add ('FROM TABLACOMIS ');
DM1.iqrArt.SQL.Add ('WHERE (CODFAMILIA =?CODFAMILIA) AND (ESQUEMA = ?ESQUEMA);');
DM1.iqrArt.Prepare;
tCodIni := fraFamilia1.xceCodFam.Text;
DM1.iqrArt.ParamByName('CODFAMILIA').AsString := tCodIni;
DM1.iqrArt.ParamByName('ESQUEMA').AsInteger := sedEsquema.IntValue;
DM1.iqrArt.Open;
iRecCount := Dm1.iqrArt.RecordCount;
iRec := 1;
while not DM1.iqrArt.Eof do begin
iSheet := DM1.iqrArt.fieldbyName('HOJA').AsInteger;
Row := DM1.iqrArt.fieldbyName('REN').AsInteger;
F1.NumberSRC[iSheet,Row,2] := DM1.iqrArt.fieldbyName('LIMITEINF').AsDouble;
F1.NumberSRC[iSheet,Row,3] := DM1.iqrArt.fieldbyName('LIMITESUP').AsDouble;
F1.NumberSRC[iSheet,Row,4] := DM1.iqrArt.fieldbyName('PORCENTAJE').AsDouble;
F1.TextSRC[iSheet,Row,5] := DM1.iqrArt.fieldbyName('OBSERVACIONES').AsString;
DM1.iqrArt.Next;
end;
F1.Selection := tSel;
Screen.Cursor := crDefault;
DM1.iqrArt.UnPrepare;
DM1.iqrArt.Close;
// Empezar a checar si se ha modificado el F1...
mfLook := True
end;
procedure TfrmTablasComis.GrabarTablas;
var i,iCount:Integer;
iSheet,iRec,Row:Integer;
tVal,tTP,tKey:String;
fFound,fUpdate,fDelete:Boolean;
begin
Screen.Cursor := crHourglass;
iCount := 0;
// Borrar datos por familia
isqldEL.ParamByName('CODFAMILIA').AsString := fraFamilia1.xceCodFam.Text;
isqldEL.ParamByName('ESQUEMA').AsInteger := sedEsquema.IntValue;
isqlDel.ExecSQL;
//----------------------------
for iSheet := 1 to 3 do begin
Row := miRowIni;
tVal := F1.TextSRC[iSheet,Row,2];
while length(tVal) > 0 do begin
iCount := iCount + 1;
isqlIns.ParamByName('ID').AsInteger := DM1.GetDocID;
isqlIns.ParamByName('HOJA').AsInteger := iSheet;
isqlIns.ParamByName('REN').AsInteger := Row;
isqlIns.ParamByName('CODFAMILIA').AsString := fraFamilia1.xceCodFam.Text;
isqlIns.ParamByName('ESQUEMA').AsInteger := sedEsquema.IntValue;
isqlIns.ParamByName('LIMITEINF').AsDouble := F1.NumberSRC[iSheet,Row,2];
isqlIns.ParamByName('LIMITESUP').AsDouble := F1.NumberSRC[iSheet,Row,3];
isqlIns.ParamByName('PORCENTAJE').AsDouble := F1.NumberSRC[iSheet,Row,4];
isqlIns.ParamByName('OBSERVACIONES').AsString := F1.TextSRC[iSheet,Row,5];
isqlIns.ParamByName('FHACT').AsDateTime := Date+Time;
isqlIns.ParamByName('USERACT').AsString := oUSer.LOGIN;
isqlIns.Execute;
Row := Row + 1;
tVal := F1.TextSRC[iSheet,Row,2];
end;
end;
isqlIns.Unprepare;
Screen.Cursor := crDefault;
ShowMessage('Se grabaron ' + IntToStr(iCount) + ' parametros!');
end;
procedure TfrmTablasComis.itmAyudaClick(Sender: TObject);
begin
ShowHelp('frmTablasComis');
end;
procedure TfrmTablasComis.tbtLeerClick(Sender: TObject);
begin
LeerTablas;
end;
procedure TfrmTablasComis.F1StartEdit(Sender: TObject;
var EditString: WideString; var Cancel: Smallint);
var iCol:Integer;
begin
iCol := F1.Col;
if iCol in ColSet then Cancel := 1;
end;
procedure TfrmTablasComis.F1KeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
case Key of
VK_DELETE:
begin
F1.ClearRange(F1.SelStartRow, F1.SelStartCol, F1.SelEndRow, F1.SelEndCol, F1ClearValues); // Delete key
end;
else
end;
end;
procedure TfrmTablasComis.tbtCreateClick(Sender: TObject);
begin
axnLimpiar;
end;
procedure TfrmTablasComis.tbtAbrirClick(Sender: TObject);
begin
LeerTablas;
end;
procedure TfrmTablasComis.tbtGenReporteClick(Sender: TObject);
begin
GenerarReporte;
end;
procedure TfrmTablasComis.tbtGrabarClick(Sender: TObject);
begin
GrabarTablas;
// axnGrabar;
end;
procedure TfrmTablasComis.tbtPreverClick(Sender: TObject);
begin
axnPrever;
end;
procedure TfrmTablasComis.tbtImpReporteClick(Sender: TObject);
begin
try
F2.FilePrint(True);
except
MessageDlg('No es posible imprimir!', mtWarning,[mbOk], 0);
end;
end;
procedure TfrmTablasComis.tbtImprimirClick(Sender: TObject);
begin
axnImprimir;
end;
procedure TfrmTablasComis.axnLimpiar;
begin
// F1.ClearRange (miRowIni,1,F1.LastRow,20,f1ClearValues);
LoadXLS;
{ F1.Row := miROWINI;
F1.Col := 1;
F1.TopRow := miROWINI;
F1.LeftCol := 1;
}
fraFamilia1.Limpiar;
end;
procedure TfrmTablasComis.axnLeer;
var tBuffer:WideString;
begin
try
F1.OpenFileDlg('Abrir archivo Articulos',frmTablasComis.Handle,tBuffer);
except
tBuffer := '';
end;
// tFile := 'Doc.xls';
// tFile := tDir+'\Doc\'+tFile;
if length(tBuffer) > 0 then begin
F1.Read (tBuffer,iType);
// F1.FixedRows := miRowIni;
end;
end;
procedure TfrmTablasComis.axnGrabar;
var tFile:WideString;
begin
try
F1.SaveFileDlg ('Grabar Listado de Articulos',tFile,iType);
except
Exit;
end;
try
F1.Write (tFile,iType);
except;
MessageDlg('Imposible grabar el archivo!', mtWarning,[mbOk], 0);
end;
end;
procedure TfrmTablasComis.axnPrever;
begin
try
F1.FilePrintPreview;
except
MessageDlg('Imposible hacer la presentacion preliminar!', mtWarning,[mbOk], 0);
end;
end;
procedure TfrmTablasComis.axnImprimir;
begin
try
F1.FilePrint(True);
except
MessageDlg('No es posible imprimir!', mtWarning,[mbOk], 0);
end;
end;
procedure TfrmTablasComis.tbtAfectarClick(Sender: TObject);
begin
//Grabar articulos
mfShowMsg := False;
GrabarTablas;
end;
procedure TfrmTablasComis.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
case Key of
VK_DELETE:
begin
F1.ClearRange(F1.SelStartRow, F1.SelStartCol, F1.SelEndRow, F1.SelEndCol, F1ClearValues); // Delete key
end;
else
end;
end;
procedure TfrmTablasComis.fraFamilia1xceCodFamKeyDown(Sender: TObject;
var Key: Word; Shift: TShiftState);
begin
fraFamilia1.xceCodFamKeyDown(Sender, Key, Shift);
LeerTablas;
end;
procedure TfrmTablasComis.GenerarReporte;
var i:Integer;
iRecCount,iRec,iTabla,iTablax:Integer;
tKey,tSel,tFam,tFamx,tNomFam,tNomTabla:String;
fFound,fBorrado:Boolean;
Row,Col:Integer;
begin
Screen.Cursor := crHourglass;
pgcMain.ActivePageIndex := 1;
LoadXls2;
miRowIni := 7;
tSel := F1.selection;
F2.TextRC[2,2] := oEmp.RAZSOCIAL;
F2.TextRC[4,3] := aEsq[sedEsquema.IntValue];
icu1.Prepare;
icu1.ParamByName('ESQUEMA').AsInteger := sedEsquema.IntValue;
icu1.Open;
icu1.First;
tFam :=icu1.FieldByName('CODFAMILIA').AsString;
tNomFam :=icu1.FieldByName('DESCRIPFAM').AsString;
tFamx:=tFam;
iTabla := icu1.FieldByName('HOJA').AsInteger;;
iTablax := iTabla;
iRecCount := icu1.RecordCount;
iRec := 1;
Row := miRowIni;
F2.TextRC[Row,2] := tFam + ' '+tNomFam;
F2.TextRC[Row,5] := aTabla[iTabla];
Row := Row + 1;
while not icu1.Eof do begin
tKey := icu1.fieldbyName('ESQUEMA').AsString;
tKey := Trim(tKey);
if (length(tKey) > 0) then begin
tKey := icu1.fieldbyName('ESQUEMA').AsString;
tKey := Trim(tKey);
if (tFam <> tFamx) or (iTabla <> iTablax) then begin
if (iTabla <> iTablax) then begin
F2.TextRC[Row,5]:= aTabla[iTabla];
iTablax := iTabla;
end;
if (tFam <> tFamx) then begin
F2.TextRC[Row,2] := tFam + ' '+tNomFam;
tFamx := tFam;
end;
Row := Row + 1;
end;
F2.NumberRC[Row,4] := icu1.fieldbyName('LIMITEINF').AsDouble;
F2.NumberRC[Row,5] := icu1.fieldbyName('LIMITESUP').AsDouble;
F2.NumberRC[Row,6] := icu1.fieldbyName('PORCENTAJE').AsDouble;
F2.TextRC[Row,7] := icu1.FieldByName('OBSERVACIONES').AsString;
Row := Row + 1;
end;
icu1.Next;
tFam :=icu1.FieldByName('CODFAMILIA').AsString;
tNomFam :=icu1.FieldByName('DESCRIPFAM').AsString;
iTabla := icu1.FieldByName('HOJA').AsInteger;;
end;
miRowEnd := Row -1;
F2.Selection := tSel;
F2.MaxRow := miRowEnd;
F2.SetSelection(2, 2, miRowEnd, 7);
F2.SetPrintAreaFromSelection;
F2.Selection := tSel;
Screen.Cursor := crDefault;
icu1.Close;
// Empezar a checar si se ha modificado el F1...
mfLook := True
end;
procedure TfrmTablasComis.axnGrabarXls;
var tFile:WideString;
begin
try
F2.SaveFileDlg ('Grabar Tablasde Comisiones',tFile,iType);
except
Exit;
end;
try
F2.Write (tFile,iType);
except;
MessageDlg('Imposible grabar el archivo!', mtWarning,[mbOk], 0);
end;
end;
end.
|
// Example showing TProcess usage and setting environment
program TProcessExample2;
{$mode objfpc} {$h+}
uses sysutils, classes, process;
procedure DoLog(s: string);
begin
writeln(s);
end;
function RunProcess(const Binary: string; args: TStrings): boolean;
const
BufSize = 2048;
var
p: TProcess;
Buf: string;
Count: integer;
i: integer;
LineStart: integer;
OutputLine: string;
begin
p := TProcess.Create(nil);
try
p.Environment.Add('HTTP_REFERER=test');
p.Environment.Add('OTHERVAR=testdata');
p.Executable := Binary;
p.Options := [poUsePipes, poStdErrToOutPut];
// p.CurrentDirectory := ExtractFilePath(p.Executable);
p.ShowWindow := swoShowNormal; // ??? Is this needed?
p.Parameters.Assign(args);
DoLog('Running command '+ p.Executable +' with arguments: '+ p.Parameters.Text);
p.Execute;
{ Now process the output }
OutputLine := '';
SetLength(Buf, BufSize);
repeat
if (p.Output <> nil) then
begin
Count := p.Output.Read(Buf[1],Length(Buf));
end
else
Count := 0;
LineStart := 1;
i := 1;
while i<=Count do
begin
if Buf[i] in [#10,#13] then
begin
OutputLine := OutputLine+Copy(Buf,LineStart,i-LineStart);
writeln(OutputLine);
OutputLine := '';
if (i < Count) and (Buf[i+1] in [#10,#13]) and (Buf[i] <> Buf[i+1]) then
inc(i);
LineStart := i+1;
end;
inc(i);
end;
OutputLine := Copy(Buf,LineStart,Count-LineStart+1);
until Count = 0;
if OutputLine <> '' then
writeln(OutputLine);
p.WaitOnExit;
Result := p.ExitStatus = 0;
if not Result then
Writeln('Command ', p.Executable ,' failed with exit code: ', p.ExitStatus);
finally
FreeAndNil(p);
end;
end;
var args: TStringList;
const
EXTENSION = {$IFDEF WINDOWS}'.exe'{$ELSE}''{$ENDIF};
prog = 'subproc' + EXTENSION;
begin
args := TStringList.Create;
writeln('---Launching sub program in TProcess---');
RunProcess(prog, args);
writeln('---end of launch---');
args.free; args := nil;
writeln('Finished main program, <enter> to exit');
readln;
end.
|
namespace RemObjects.SDK.CodeGen4;
{$HIDE W46}
interface
type
CocoaRodlCodeGen = public class (RodlCodeGen)
private
fCachedNumberFN: Dictionary<String, String> := new Dictionary<String, String>;
property IsSwift: Boolean read Generator is CGSwiftCodeGenerator;
property IsObjC: Boolean read Generator is CGObjectiveCCodeGenerator;
property IsAppleSwift: Boolean read IsSwift and (SwiftDialect = SwiftDialect.Standard);
property IsSilver: Boolean read IsSwift and (SwiftDialect = SwiftDialect.Silver);
property NSUIntegerType: CGTypeReference read (if IsAppleSwift then "UInt" else "NSUInteger").AsTypeReference(false);
property SELType: CGTypeReference read (if IsAppleSwift then "Selector" else "SEL").AsTypeReference(false);
method GetNumberFN(dataType: String):String;
method GetReaderStatement(library: RodlLibrary; aEntity: RodlTypedEntity; aVariableName: String := "aMessage"): CGStatement;
method GetReaderExpression(library: RodlLibrary; aEntity: RodlTypedEntity; aVariableName: String := "aMessage"): CGExpression;
method GetWriterStatement(library: RodlLibrary; aEntity: RodlTypedEntity; aVariableName: String := "aMessage"; isMethod: Boolean; aInOnly: Boolean := false): CGStatement;
method WriteToMessage_Method(library: RodlLibrary; aEntity: RodlStructEntity): CGMethodDefinition;
method ReadFromMessage_Method(library: RodlLibrary; aEntity: RodlStructEntity): CGMethodDefinition;
method GenerateServiceProxyMethod(library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
method GenerateServiceProxyMethodDeclaration(library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
method GenerateServiceAsyncProxyBeginMethod_Body(library: RodlLibrary; aEntity: RodlOperation; Statements: List<CGStatement>);
method GenerateServiceAsyncProxyBeginMethod(library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
method GenerateServiceAsyncProxyBeginMethod_start(library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
method GenerateServiceAsyncProxyBeginMethod_startWithBlock(library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
method GenerateServiceAsyncProxyBeginMethodDeclaration(library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
method GenerateServiceAsyncProxyEndMethod(library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
method GenerateOperationAttribute(library: RodlLibrary; aEntity: RodlOperation;Statements: List<CGStatement>);
method GenerateServiceMethods(library: RodlLibrary; aEntity: RodlService; service:CGClassTypeDefinition);
method HandleAtributes_private(library: RodlLibrary; aEntity: RodlEntity): CGFieldDefinition;
method HandleAtributes_public(library: RodlLibrary; aEntity: RodlEntity): CGMethodDefinition;
method ApplyParamDirection(paramFlag: ParamFlags; aInOnly: Boolean := false): CGParameterModifierKind;
method ApplyParamDirectionExpression(aExpr: CGExpression; paramFlag: ParamFlags; aInOnly: Boolean := false): CGExpression;
protected
method isClassType(library: RodlLibrary; dataType: String): Boolean;
method AddUsedNamespaces(file: CGCodeUnit; library: RodlLibrary); override;
method AddGlobalConstants(file: CGCodeUnit; library: RodlLibrary);override;
method GenerateEnum(file: CGCodeUnit; library: RodlLibrary; aEntity: RodlEnum); override;
method GenerateStruct(file: CGCodeUnit; library: RodlLibrary; aEntity: RodlStruct); override;
method GenerateArray(file: CGCodeUnit; library: RodlLibrary; aEntity: RodlArray); override;
method GenerateOldStyleArray(file: CGCodeUnit; library: RodlLibrary; aEntity: RodlArray);
method GenerateException(file: CGCodeUnit; library: RodlLibrary; aEntity: RodlException); override;
method GenerateService(file: CGCodeUnit; library: RodlLibrary; aEntity: RodlService); override;
method GenerateEventSink(file: CGCodeUnit; library: RodlLibrary; aEntity: RodlEventSink); override;
method GetIncludesNamespace(library: RodlLibrary): String; override;
method GetGlobalName(library: RodlLibrary): String; override;
property EnumBaseType: CGTypeReference read NSUIntegerType; override;
public
property SwiftDialect: CGSwiftCodeGeneratorDialect := CGSwiftCodeGeneratorDialect.Silver;
property DontPrefixEnumValues: Boolean := not IsObjC; override;
constructor;
constructor withSwiftDialect(aSwiftDialect: CGSwiftCodeGeneratorDialect);
method FixUpForAppleSwift;
end;
implementation
method CocoaRodlCodeGen.AddUsedNamespaces(file: CGCodeUnit; &library: RodlLibrary);
begin
file.Imports.Add(new CGImport(new CGNamespaceReference("Foundation")));
file.Imports.Add(new CGImport(new CGNamespaceReference("RemObjectsSDK")));
for rodl: RodlUse in library.Uses.Items do begin
if length(rodl.Includes:CocoaModule) > 0 then
file.Imports.Add(new CGImport(new CGNamespaceReference(rodl.Includes.CocoaModule)))
else if length(rodl.Namespace) > 0 then
file.Imports.Add(new CGImport(new CGNamespaceReference(rodl.Namespace)))
else
file.HeaderComment.Lines.Add(String.Format("Requires RODL file {0} ({1}) in same namespace.", [rodl.Name, rodl.FileName]));
end;
end;
method CocoaRodlCodeGen.GenerateEnum(file: CGCodeUnit; &library: RodlLibrary; aEntity: RodlEnum);
begin
inherited GenerateEnum(file, &library, aEntity);
var lname := SafeIdentifier(aEntity.Name);
var lenum := new CGClassTypeDefinition(lname+"__EnumMetaData", "ROEnumMetaData".AsTypeReference,
Visibility := CGTypeVisibilityKind.Public);
file.Types.Add(lenum);
var linst := lname+"__EnumMetaDataInstance";
lenum.Members.Add(new CGFieldDefinition(linst,
lenum.Name.AsTypeReference,
Visibility := CGMemberVisibilityKind.Private,
&Static := True,
Initializer := new CGNilExpression
)
);
{$REGION class method instance: %ENUM_NAME%__EnumMetaData;}
lenum.Members.Add(new CGMethodDefinition("instance",
[new CGIfThenElseStatement(new CGAssignedExpression(linst.AsNamedIdentifierExpression, Inverted := true),
new CGAssignmentStatement(
linst.AsNamedIdentifierExpression,
new CGNewInstanceExpression(lenum.Name.AsTypeReference)),
nil),
linst.AsNamedIdentifierExpression.AsReturnStatement].ToList,
ReturnType:= lenum.Name.AsTypeReference,
&Static := True,
Visibility := CGMemberVisibilityKind.Public
));
{$ENDREGION}
{$REGION method typeName: NSString; override;}
lenum.Members.Add(
new CGPropertyDefinition("typeName", CGPredefinedTypeReference.String.NotNullable,
GetExpression := lname.AsLiteralExpression,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public,
&ReadOnly := true,
Atomic := true)
);
{$ENDREGION}
if not IsAppleSwift then begin
lenum.Members.Add(new CGFieldDefinition("stringToValueLookup",
"NSDictionary".AsTypeReference,
Visibility := CGMemberVisibilityKind.Private
)
);
{$REGION method stringFromValue(aValue: Integer): NSString;}
var lcases := new List<CGSwitchStatementCase>;
for enummember: RodlEnumValue in aEntity.Items index i do begin
var lmName := GenerateEnumMemberName(library, aEntity, enummember);
lcases.Add(new CGSwitchStatementCase(i.AsLiteralExpression, [CGStatement(lmName.AsLiteralExpression.AsReturnStatement)].ToList));
end;
var sw: CGStatement := new CGSwitchStatement("aValue".AsNamedIdentifierExpression,
lcases,
DefaultCase := [CGStatement("<Invalid Enum Value>".AsLiteralExpression.AsReturnStatement)].ToList);
lenum.Members.Add(new CGMethodDefinition(if IsSwift then "string" else "stringFromValue",
[sw].ToList,
Parameters := [new CGParameterDefinition("aValue", NSUIntegerType, ExternalName := if IsSwift then "fromValue")].ToList,
ReturnType:= CGPredefinedTypeReference.String.NotNullable,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public));
{$ENDREGION}
{$REGION method valueFromString(aValue: NSString): Integer; override;}
var lArgs := new List<CGCallParameter>;
for enummember: RodlEnumValue in aEntity.Items do begin
var lmName := GenerateEnumMemberName(library, aEntity, enummember);
var lParameter := new CGTypeCastExpression(new CGEnumValueAccessExpression(lname.AsTypeReference,lmName), NSUIntegerType, ThrowsException := true);
lArgs.Add(if IsSwift then new CGNewInstanceExpression("NSNumber".AsTypeReferenceExpression, [lParameter.AsCallParameter("unsignedInt")]).AsCallParameter
else new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression, "numberWithInt", [lParameter.AsCallParameter].ToList).AsEllipsisCallParameter);
lArgs.Add(lmName.AsLiteralExpression.AsEllipsisCallParameter);
end;
lArgs.Add(new CGNilExpression().AsEllipsisCallParameter);
var lNewDictionary := /*if IsAppleSwift then
new CGNewInstanceExpression("NSDictionary".AsTypeReference, lArgs, ConstructorName := "dictionaryLiteral")
else*/
new CGNewInstanceExpression("NSDictionary".AsTypeReference, lArgs, ConstructorName := "withObjectsAndKeys");
lenum.Members.Add(new CGMethodDefinition(
if IsSwift then "value" else "valueFromString",
Parameters := [new CGParameterDefinition("aValue", CGPredefinedTypeReference.String.NotNullable, ExternalName := if IsSwift then "from")].ToList,
ReturnType:= NSUIntegerType,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public,
Statements:= [{0}new CGIfThenElseStatement(
new CGAssignedExpression("stringToValueLookup".AsNamedIdentifierExpression, Inverted := true),
new CGAssignmentStatement("stringToValueLookup".AsNamedIdentifierExpression,
lNewDictionary)),
{1}new CGVariableDeclarationStatement("lResult",
"NSNumber".AsTypeReference,
new CGTypeCastExpression(new CGMethodCallExpression("stringToValueLookup".AsNamedIdentifierExpression,
if IsSwift then "value" else "valueForKey",
["aValue".AsNamedIdentifierExpression.AsCallParameter(if IsSwift then "forKey")].ToList),
"NSNumber".AsTypeReference, true)
),
{2}new CGIfThenElseStatement(
new CGAssignedExpression("lResult".AsNamedIdentifierExpression),
new CGPropertyAccessExpression("lResult".AsNamedIdentifierExpression,"unsignedIntValue").AsReturnStatement,
if IsAppleSwift then
new CGThrowExpression(new CGNewInstanceExpression("NSError".AsTypeReference,
["ROException".AsLiteralExpression.AsCallParameter("domain"),
0.AsLiteralExpression.AsCallParameter("code"),
CGNilExpression.Nil.AsCallParameter("userInfo")
].ToList))
else
new CGThrowExpression(new CGNewInstanceExpression("NSException".AsTypeReference,
[if IsAppleSwift then
new CGNewInstanceExpression("NSExceptionName".AsTypeReference, "ROException".AsLiteralExpression.AsCallParameter).AsCallParameter
else
"ROException".AsLiteralExpression.AsCallParameter,
if IsAppleSwift then
new CGNewInstanceExpression("String".AsTypeReference, [("Invalid value %@ for enum "+lname).AsLiteralExpression.AsCallParameter, "aValue".AsNamedIdentifierExpression.AsEllipsisCallParameter].ToList).AsCallParameter("reason")
else
new CGMethodCallExpression("NSString".AsTypeReference.AsExpression, "stringWithFormat", [("Invalid value %@ for enum "+lname).AsLiteralExpression.AsCallParameter, "aValue".AsNamedIdentifierExpression.AsEllipsisCallParameter].ToList).AsCallParameter("reason"),
CGNilExpression.Nil.AsCallParameter("userInfo")
].ToList, ConstructorName := "withName"))
)
].ToList
));
{$ENDREGION}
{$REGION method typeName: NSString; override;}
lenum.Members.Add(
new CGMethodDefinition(
lname+"ToString",
[new CGMethodCallExpression(new CGMethodCallExpression(lenum.Name.AsTypeReferenceExpression,"instance"),
if IsSwift then "string" else "stringFromValue",
[new CGTypeCastExpression("aValue".AsNamedIdentifierExpression, NSUIntegerType, true).AsCallParameter(if IsSwift then "fromValue")].ToList
).AsReturnStatement],
Parameters := [new CGParameterDefinition("aValue",lname.AsTypeReference)].ToList,
ReturnType := CGPredefinedTypeReference.String.NotNullable,
Visibility := CGMemberVisibilityKind.Public
)
);
{$ENDREGION}
end;
end;
method CocoaRodlCodeGen.GenerateStruct(file: CGCodeUnit; &library: RodlLibrary; aEntity: RodlStruct);
begin
var lancestorName := aEntity.AncestorName;
if String.IsNullOrEmpty(lancestorName) then lancestorName := "ROComplexType";
var lStruct := new CGClassTypeDefinition(SafeIdentifier(aEntity.Name), lancestorName.AsTypeReference,
Visibility := CGTypeVisibilityKind.Public,
Comment := GenerateDocumentation(aEntity));
lStruct.Attributes.Add(new CGAttribute("objc".AsTypeReference, SafeIdentifier(aEntity.Name).AsNamedIdentifierExpression.AsCallParameter));
file.Types.Add(lStruct);
{$REGION private class class __attributes: NSDictionary;}
if (aEntity.CustomAttributes.Count > 0) then
lStruct.Members.Add(HandleAtributes_private(&library,aEntity));
{$ENDREGION}
{$REGION public class method getAttributeValue(aName: NSString): NSString;}
if (aEntity.CustomAttributes.Count > 0) then
lStruct.Members.Add(HandleAtributes_public(&library,aEntity));
{$ENDREGION}
{$REGION public property %fldname%: %fldtype%}
for m: RodlTypedEntity in aEntity.Items do begin
var lType := ResolveDataTypeToTypeRef(&library, m.DataType);
var p := new CGPropertyDefinition(m.Name, lType,
Visibility := CGMemberVisibilityKind.Public,
Comment := GenerateDocumentation(m));
var lEnumDefault := FindEnum(library, m.DataType):DefaultValueName;
if assigned(lEnumDefault) then
p.Initializer := new CGEnumValueAccessExpression(lType, lEnumDefault);
lStruct.Members.Add(p);
end;
{$ENDREGION}
{$REGION method assignFrom(aValue: ROComplexType); override;}
lStruct.Members.Add(
new CGMethodDefinition(if IsSwift then "assign" else "assignFrom",
Parameters := [new CGParameterDefinition("aValue", "ROComplexType".AsTypeReference().NotNullable, ExternalName := if IsSwift then "from")].ToList,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public )
);
{$ENDREGION}
if aEntity.Items.Count >0 then begin
{$REGION public method writeToMessage(aMessage: ROMessage) withName(aName: NSString); override;}
lStruct.Members.Add(WriteToMessage_Method(&library,aEntity));
{$ENDREGION}
{$REGION public method readFromMessage(aMessage: ROMessage) withName(aName: NSString); override;}
lStruct.Members.Add(ReadFromMessage_Method(&library,aEntity));
{$ENDREGION}
end;
end;
method CocoaRodlCodeGen.GenerateArray(file: CGCodeUnit; &library: RodlLibrary; aEntity: RodlArray);
begin
var lArray := new CGClassTypeDefinition(SafeIdentifier(aEntity.Name), "ROMutableArray".AsTypeReference,
Visibility := CGTypeVisibilityKind.Public,
Comment := GenerateDocumentation(aEntity));
file.Types.Add(lArray);
{$REGION private class __attributes: NSDictionary;}
if (aEntity.CustomAttributes.Count > 0) then
lArray.Members.Add(HandleAtributes_private(&library,aEntity));
{$ENDREGION}
{$REGION public class method getAttributeValue(aName: NSString): NSString;}
if (aEntity.CustomAttributes.Count > 0) then
lArray.Members.Add(HandleAtributes_public(&library,aEntity));
{$ENDREGION}
var lElementType:= ResolveDataTypeToTypeRef(&library, SafeIdentifier(aEntity.ElementType));
var lIsEnum := isEnum(&library,aEntity.ElementType);
var lIsComplex := isComplex(&library, aEntity.ElementType);
var lIsArray := isArray(&library, aEntity.ElementType);
var lIsSimple := not (lIsEnum or lIsComplex);
{$REGION method itemClass: &Class; override;}
if lIsComplex then begin
var l_elementType2 := ResolveDataTypeToTypeRef(&library,SafeIdentifier(aEntity.ElementType)).NotNullable;
lArray.Members.Add(
new CGPropertyDefinition(
"itemClass", CGPredefinedTypeReference.Class.NotNullable,
GetExpression := new CGTypeOfExpression(l_elementType2.AsExpression),
Visibility := CGMemberVisibilityKind.Public,
Virtuality := CGMemberVirtualityKind.Override,
Atomic := true));
end;
{$ENDREGION}
{$REGION - (void)writeItem:(id)item toMessage:(ROMessage *)aMessage withIndex:(NSUInteger)index; }
var lList := new List<CGStatement>;
//var __item: %ARRAY_TYPE% := self.itemAtIndex(aIndex);
var getItemAtIndex: CGExpression := if IsAppleSwift then
new CGMethodCallExpression(new CGSelfExpression, "object", "aIndex".AsNamedIdentifierExpression.AsCallParameter("at"))
else
new CGArrayElementAccessExpression(new CGSelfExpression, ["aIndex".AsNamedIdentifierExpression]);
if lIsSimple then begin
var getItemAtIndexAsNSNumber := new CGTypeCastExpression(getItemAtIndex, "NSNumber".AsTypeReference, ThrowsException := true);
case aEntity.ElementType.ToLowerInvariant of
"integer": getItemAtIndex := new CGPropertyAccessExpression(getItemAtIndexAsNSNumber, "intValue");
"int64": getItemAtIndex := new CGPropertyAccessExpression(getItemAtIndexAsNSNumber, "longLongValue");
"double": getItemAtIndex := new CGPropertyAccessExpression(getItemAtIndexAsNSNumber, "doubleValue");
"boolean": getItemAtIndex := new CGPropertyAccessExpression(getItemAtIndexAsNSNumber, "boolValue");
else if IsAppleSwift then getItemAtIndex := new CGTypeCastExpression(getItemAtIndex, lElementType, ThrowsException := true);
end;
end
else if lIsEnum then begin
getItemAtIndex := new CGTypeCastExpression(getItemAtIndex, "NSNumber".AsTypeReference, ThrowsException := true);
getItemAtIndex := new CGPropertyAccessExpression(getItemAtIndex, "integerValue");
getItemAtIndex := new CGTypeCastExpression(getItemAtIndex, lElementType, ThrowsException := true);
end
else begin
getItemAtIndex := new CGTypeCastExpression(getItemAtIndex, lElementType, ThrowsException := true);
end;
lList.Add(new CGVariableDeclarationStatement("___item", lElementType, getItemAtIndex, &ReadOnly := true));
var lLower: String := aEntity.ElementType.ToLowerInvariant();
var lMethodName: String;
if ReaderFunctions.ContainsKey(lLower) then begin
lMethodName := ReaderFunctions[lLower];
end
else if isArray(&library, aEntity.ElementType) then begin
lMethodName := "MutableArray";
end
else if isStruct(&library, aEntity.ElementType) then begin
lMethodName := "Complex";
end
else if lIsEnum then begin
lMethodName := "Enum";
end;
var lArguments := new List<CGCallParameter>;
lArguments.Add("___item".AsNamedIdentifierExpression.AsCallParameter);
lArguments.Add(new CGCallParameter(new CGNilExpression(), "withName"));
if lIsEnum then
lArguments.Add(new CGCallParameter(new CGMethodCallExpression((aEntity.ElementType+"__EnumMetaData").AsTypeReferenceExpression,"instance"), if IsAppleSwift then "as" else "asEnum"));
lList.Add(new CGMethodCallExpression("aMessage".AsNamedIdentifierExpression, "write" + lMethodName, lArguments));
lArray.Members.Add(
new CGMethodDefinition( "writeItem",
Parameters := [new CGParameterDefinition("aItem", CGPredefinedTypeReference.Dynamic.NotNullable),
new CGParameterDefinition("aMessage", "ROMessage".AsTypeReference().NotNullable, ExternalName := if IsAppleSwift then "to" else "toMessage"),
new CGParameterDefinition("aIndex", NSUIntegerType, ExternalName := if IsAppleSwift then "with" else "withIndex")].ToList,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public,
Statements := lList as not nullable));
{$ENDREGION}
{$REGION - (id)readItemFromMessage:(ROMessage *)aMessage withIndex:(NSUInteger)index; }
lList := new List<CGStatement>;
lArguments:= new List<CGCallParameter>;
lArguments.Add(new CGNilExpression().AsCallParameter(if IsSwift then "withName"));
if lIsEnum then
lArguments.Add(new CGCallParameter(new CGMethodCallExpression((aEntity.ElementType+"__EnumMetaData").AsTypeReferenceExpression,"instance"), if IsAppleSwift then "as" else "asEnum"));
if lIsComplex or lIsArray then
lArguments.Add(new CGCallParameter(new CGPropertyAccessExpression(nil, "itemClass"), if IsSwift then "as" else "asClass"));
var lExpression: CGExpression := new CGMethodCallExpression("aMessage".AsNamedIdentifierExpression, if IsSwift then "read"+lMethodName else "read"+lMethodName+"WithName", lArguments);
if lIsComplex or lIsEnum or lIsArray then
lExpression := new CGTypeCastExpression(lExpression, lElementType, ThrowsException := true);
lList.Add(new CGVariableDeclarationStatement("___item", lElementType, lExpression, &ReadOnly := true));
var lItem: CGExpression := "___item".AsNamedIdentifierExpression;
if lIsSimple then begin
case aEntity.ElementType.ToLowerInvariant of
"integer": lItem := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression, "numberWithInteger", [lItem.AsCallParameter]);
"int64": lItem := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression, "numberWithLongLong", [lItem.AsCallParameter]);
"double": lItem := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression, "numberWithDouble", [lItem.AsCallParameter]);
"boolean": lItem := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression, "numberWithBool", [lItem.AsCallParameter]);
end;
end else if lIsEnum then begin
lItem := new CGTypeCastExpression(lItem, "NSInteger".AsTypeReference, ThrowsException := true);
lItem := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression, "numberWithInteger", [lItem.AsCallParameter]);
end;
lList.Add(lItem.AsReturnStatement);
lArray.Members.Add(
new CGMethodDefinition(if IsAppleSwift then "readItem" else "readItemFromMessage",
Parameters := [new CGParameterDefinition("aMessage", "ROMessage".AsTypeReference().NotNullable, ExternalName := if IsAppleSwift then "from"),
new CGParameterDefinition("aIndex", NSUIntegerType, ExternalName := if IsAppleSwift then "with" else "withIndex")].ToList,
ReturnType := CGPredefinedTypeReference.Dynamic.NullableNotUnwrapped,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public,
Statements := lList as not nullable));
{$ENDREGION}
end;
method CocoaRodlCodeGen.GenerateOldStyleArray(file: CGCodeUnit; &library: RodlLibrary; aEntity: RodlArray);
begin
var lArray := new CGClassTypeDefinition(SafeIdentifier(aEntity.Name), "ROArray".AsTypeReference,
Visibility := CGTypeVisibilityKind.Public,
Comment := GenerateDocumentation(aEntity));
file.Types.Add(lArray);
{$REGION private class __attributes: NSDictionary;}
if (aEntity.CustomAttributes.Count > 0) then
lArray.Members.Add(HandleAtributes_private(&library,aEntity));
{$ENDREGION}
{$REGION public class method getAttributeValue(aName: NSString): NSString;}
if (aEntity.CustomAttributes.Count > 0) then
lArray.Members.Add(HandleAtributes_public(&library,aEntity));
{$ENDREGION}
var lElementType:= ResolveDataTypeToTypeRef(&library,SafeIdentifier(aEntity.ElementType));
var lIsEnum := isEnum(&library,aEntity.ElementType);
var lIsComplex := iif(not lIsEnum,isComplex(&library,aEntity.ElementType), false) ;
var lIsSimple := not (lIsEnum or lIsComplex);
{$REGION method add: %ARRAY_TYPE%;}
if lIsComplex then
lArray.Members.Add(
new CGMethodDefinition("add",
ReturnType := lElementType,
Visibility := CGMemberVisibilityKind.Public,
Statements:=
[new CGVariableDeclarationStatement('lresult',lElementType, new CGNewInstanceExpression(lElementType)),
new CGMethodCallExpression(CGInheritedExpression.Inherited, "addItem", ["lresult".AsNamedIdentifierExpression.AsCallParameter].ToList),
"lresult".AsNamedIdentifierExpression.AsReturnStatement
].ToList
)
);
{$ENDREGION}
{$REGION method addItem(aObject: %ARRAY_TYPE%);}
var lExpression : CGExpression := "aObject".AsNamedIdentifierExpression;
if lIsEnum then lExpression := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression,"numberWithInt", [lExpression.AsCallParameter].ToList);
if lIsSimple then lExpression := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression,"numberWith"+GetNumberFN(aEntity.ElementType), [lExpression.AsCallParameter].ToList);
lArray.Members.Add(
new CGMethodDefinition("addItem",
[new CGMethodCallExpression(CGInheritedExpression.Inherited, "addItem", [lExpression.AsCallParameter].ToList)],
Parameters := [new CGParameterDefinition("aObject", lElementType)].ToList,
Visibility := CGMemberVisibilityKind.Public
)
);
{$ENDREGION}
{$REGION method insertItem(aObject: %ARRAY_TYPE%) atIndex(aIndex: NSUInteger);}
lArray.Members.Add(
new CGMethodDefinition("insertItem",
[new CGMethodCallExpression(CGInheritedExpression.Inherited, "insertItem", [lExpression.AsCallParameter,new CGCallParameter("aIndex".AsNamedIdentifierExpression, "atIndex")].ToList)],
Parameters := [new CGParameterDefinition("aObject", lElementType),
new CGParameterDefinition("aIndex", NSUIntegerType, ExternalName := "atIndex")].ToList,
Visibility := CGMemberVisibilityKind.Public
)
);
{$ENDREGION}
{$REGION method replaceItemAtIndex(aIndex: NSUInteger) withItem(aItem: %ARRAY_TYPE%);}
lExpression := "aItem".AsNamedIdentifierExpression;
if lIsEnum then lExpression := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression,"numberWithInt",[lExpression.AsCallParameter].ToList);
if lIsSimple then lExpression := new CGMethodCallExpression("NSNumber".AsTypeReferenceExpression,"numberWith"+GetNumberFN(aEntity.ElementType),[lExpression.AsCallParameter].ToList);
lArray.Members.Add(
new CGMethodDefinition("replaceItemAtIndex",
[new CGMethodCallExpression(CGInheritedExpression.Inherited, "replaceItemAtIndex",
["aIndex".AsNamedIdentifierExpression.AsCallParameter,
new CGCallParameter(lExpression, "withItem")].ToList)],
Parameters := [new CGParameterDefinition("aIndex", NSUIntegerType),
new CGParameterDefinition("aItem", lElementType, ExternalName := "withItem")].ToList,
Visibility := CGMemberVisibilityKind.Public)
);
{$ENDREGION}
{$REGION method itemAtIndex(aIndex: NSUInteger): %ARRAY_TYPE%;}
var lList := new List<CGStatement>;
if lIsComplex then begin
// exit inherited itemAtIndex(aIndex) as %ARRAY_TYPE%;
lList.Add(new CGTypeCastExpression(
new CGMethodCallExpression(CGInheritedExpression.Inherited, "itemAtIndex", ["aIndex".AsNamedIdentifierExpression.AsCallParameter].ToList),
lElementType,
ThrowsException := True
).AsReturnStatement);
end;
if lIsSimple then begin
// var __result: Integer;
// __result := (inherited itemAtIndex(aIndex) as NSNumber) as %ARRAY_TYPE%;
// exit __result;
lList.Add(new CGVariableDeclarationStatement("___result",ResolveStdtypes(CGPredefinedTypeReference.Int32)));
lList.Add(new CGAssignmentStatement(
"___result".AsNamedIdentifierExpression,
new CGTypeCastExpression(
new CGTypeCastExpression(
new CGMethodCallExpression(CGInheritedExpression.Inherited, "itemAtIndex", ["aIndex".AsNamedIdentifierExpression.AsCallParameter].ToList),
"NSNumber".AsTypeReference,
ThrowsException := True
),
lElementType,
ThrowsException := True
)
));
lList.Add("___result".AsNamedIdentifierExpression.AsReturnStatement);
end;
if lIsEnum then begin
// exit inherited itemAtIndex(aIndex).intValue;
lList.Add( new CGPropertyAccessExpression(
new CGMethodCallExpression(CGInheritedExpression.Inherited, "itemAtIndex", ["aIndex".AsNamedIdentifierExpression.AsCallParameter].ToList),
"intValue").AsReturnStatement);
end;
lArray.Members.Add(
new CGMethodDefinition("itemAtIndex",
Parameters := [new CGParameterDefinition("aIndex", NSUIntegerType)].ToList,
ReturnType := lElementType,
Visibility := CGMemberVisibilityKind.Public,
Reintroduced := true,
Statements := lList as not nullable));
{$ENDREGION}
{$REGION method itemClass: &Class; override;}
if lIsComplex then begin
var l_elementType2 := ResolveDataTypeToTypeRef(&library,SafeIdentifier(aEntity.ElementType)).NotNullable;
lArray.Members.Add(
new CGPropertyDefinition(
"itemClass", CGPredefinedTypeReference.Class,
GetExpression := new CGTypeOfExpression(l_elementType2.AsExpression),
Visibility := CGMemberVisibilityKind.Public,
Virtuality := CGMemberVirtualityKind.Override,
Atomic := true));
end;
{$ENDREGION}
{$REGION method itemTypeName: NSString; override;}
lArray.Members.Add(
new CGPropertyDefinition("itemTypeName", CGPredefinedTypeReference.String.NotNullable,
GetExpression := aEntity.ElementType.AsLiteralExpression,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public,
Atomic := true));
{$ENDREGION}
{$REGION method writeItemToMessage(aMessage: ROMessage) fromIndex(aIndex: Integer); override;}
lList := new List<CGStatement>;
//var __item: %ARRAY_TYPE% := self.itemAtIndex(aIndex);
lList.Add(new CGVariableDeclarationStatement("___item",lElementType,new CGMethodCallExpression(new CGSelfExpression,"itemAtIndex",["aIndex".AsNamedIdentifierExpression.AsCallParameter].ToList), &ReadOnly := true));
var lLower: String := aEntity.ElementType.ToLowerInvariant();
var lMethodName: String;
if ReaderFunctions.ContainsKey(lLower) then begin
lMethodName := ReaderFunctions[lLower];
end
else if isArray(&library, aEntity.ElementType) then begin
lMethodName := "MutableArray";
end
else if isStruct(&library, aEntity.ElementType) then begin
lMethodName := "Complex";
end
else if lIsEnum then begin
lMethodName := "Enum";
end;
var lArguments := new List<CGCallParameter>;
lArguments.Add("___item".AsNamedIdentifierExpression.AsCallParameter);
lArguments.Add(new CGCallParameter(new CGNilExpression(), "withName"));
if lIsEnum then
lArguments.Add(new CGCallParameter(new CGMethodCallExpression((aEntity.ElementType+"__EnumMetaData").AsTypeReferenceExpression,"instance"), if IsAppleSwift then "as" else "asEnum"));
lList.Add(new CGMethodCallExpression("aMessage".AsNamedIdentifierExpression, "write" + lMethodName, lArguments));
lArray.Members.Add(
new CGMethodDefinition( "writeItemToMessage",
Parameters := [new CGParameterDefinition("aMessage", "ROMessage".AsTypeReference),
new CGParameterDefinition("aIndex", NSUIntegerType, ExternalName :="fromIndex" )].ToList,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public,
Statements := lList as not nullable));
{$ENDREGION}
{$REGION method method readItemFromMessage(aMessage: ROMessage) toIndex(aIndex: Integer); override;}
lList := new List<CGStatement>;
// var __item: %ARRAY_TYPE%;
lList.Add(new CGVariableDeclarationStatement("___item", lElementType.NotNullable, &ReadOnly := true));
lArguments:= new List<CGCallParameter>;
lArguments.Add(new CGNilExpression().AsCallParameter);
if lIsEnum then
lArguments.Add(new CGCallParameter(new CGMethodCallExpression((aEntity.ElementType+"__EnumMetaData").AsTypeReferenceExpression,"instance"), if IsAppleSwift then "as" else "asEnum"));
if lIsComplex then
lArguments.Add(new CGCallParameter(new CGPropertyAccessExpression(new CGSelfExpression, "itemClass"), "asClass"));
lExpression := new CGMethodCallExpression("aMessage".AsNamedIdentifierExpression, "read" + lMethodName+"WithName", lArguments);
if lIsComplex then
lExpression := new CGTypeCastExpression(
lExpression,
lElementType,
ThrowsException := true);
lList.Add(new CGAssignmentStatement("___item".AsNamedIdentifierExpression, lExpression));
lList.Add(new CGCommentStatement("for efficiency, assumes this is called in ascending order"));
lList.Add(new CGMethodCallExpression(new CGSelfExpression, "addItem",["___item".AsNamedIdentifierExpression.AsCallParameter].ToList));
lArray.Members.Add(
new CGMethodDefinition(if IsSwift then "readItem" else "readItemFromMessage",
Parameters := [new CGParameterDefinition("aMessage", "ROMessage".AsTypeReference, ExternalName := if IsSwift then "from"),
new CGParameterDefinition("aIndex", NSUIntegerType, ExternalName := "toIndex")].ToList,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public,
Statements := lList as not nullable));
{$ENDREGION}
end;
method CocoaRodlCodeGen.GenerateException(file: CGCodeUnit; &library: RodlLibrary; aEntity: RodlException);
begin
var lancestorName := aEntity.AncestorName;
if String.IsNullOrEmpty(lancestorName) then lancestorName := "ROException";
var lException := new CGClassTypeDefinition(SafeIdentifier(aEntity.Name), lancestorName.AsTypeReference,
Visibility := CGTypeVisibilityKind.Public,
Comment := GenerateDocumentation(aEntity));
file.Types.Add(lException);
{$REGION private class class __attributes: NSDictionary;}
if (aEntity.CustomAttributes.Count > 0) then
lException.Members.Add(HandleAtributes_private(&library,aEntity));
{$ENDREGION}
{$REGION public class method getAttributeValue(aName: NSString): NSString;}
if (aEntity.CustomAttributes.Count > 0) then
lException.Members.Add(HandleAtributes_public(&library,aEntity));
{$ENDREGION}
{$REGION public property %fldname%: %fldtype%}
for m: RodlTypedEntity in aEntity.Items do
lException.Members.Add(new CGPropertyDefinition(m.Name,
ResolveDataTypeToTypeRef(&library,m.DataType),
Visibility:= CGMemberVisibilityKind.Public,
Comment := GenerateDocumentation(m)));
{$ENDREGION}
{$REGION public method initWithMessage(anExceptionMessage: NSString; a%FIELD_NAME_UNSAFE%: %FIELD_TYPE%);dynamic;}
var linitWithMessage := new CGConstructorDefinition("withMessage", Visibility := CGMemberVisibilityKind.Public);
lException.Members.Add(linitWithMessage);
var lAncestorEntity := aEntity as RodlStructEntity;
var st:= new CGBeginEndBlockStatement;
var llist:= new List<CGCallParameter>;
while assigned(lAncestorEntity) do begin
var memberlist:= new List<CGParameterDefinition>;
var arlist:= new List<CGCallParameter>;
for m: RodlTypedEntity in lAncestorEntity.Items do begin
var lname := "a"+m.Name;
memberlist.Add(new CGParameterDefinition(lname, ResolveDataTypeToTypeRef(m.OwnerLibrary,m.DataType)));
if lAncestorEntity = aEntity then
st.Statements.Add(new CGAssignmentStatement(new CGPropertyAccessExpression(nil, SafeIdentifier(m.Name)),
lname.AsNamedIdentifierExpression))
else
arlist.Add(lname.AsNamedIdentifierExpression.AsCallParameter);
end;
for i: Integer := memberlist.Count-1 downto 0 do
linitWithMessage.Parameters.Insert(0,memberlist[i]);
for i: Integer := arlist.Count-1 downto 0 do
llist.Insert(0,arlist[i]);
lAncestorEntity := lAncestorEntity.AncestorEntity as RodlStructEntity;
end;
linitWithMessage.Parameters.Insert(0,new CGParameterDefinition("anExceptionMessage", CGPredefinedTypeReference.String.NotNullable));
llist.Insert(0,"anExceptionMessage".AsNamedIdentifierExpression.AsCallParameter);
linitWithMessage.Statements.Add(new CGConstructorCallStatement(CGInheritedExpression.Inherited, llist, ConstructorName := "withMessage"));
linitWithMessage.Statements.Add(st.Statements);
{$ENDREGION}
if aEntity.Items.Count >0 then begin
{$REGION public method writeToMessage(aMessage: ROMessage) withName(aName: NSString); override;}
lException.Members.Add(WriteToMessage_Method(&library,aEntity));
{$ENDREGION}
{$REGION public method readFromMessage(aMessage: ROMessage) withName(aName: NSString); override;}
lException.Members.Add(ReadFromMessage_Method(&library,aEntity));
{$ENDREGION}
end;
end;
method CocoaRodlCodeGen.GenerateService(file: CGCodeUnit; &library: RodlLibrary; aEntity: RodlService);
begin
{$REGION I%SERVICE_NAME%}
var lIService := new CGInterfaceTypeDefinition(SafeIdentifier("I"+aEntity.Name),
Visibility := CGTypeVisibilityKind.Public,
Comment := GenerateDocumentation(aEntity));
file.Types.Add(lIService);
for lop : RodlOperation in aEntity.DefaultInterface:Items do begin
var m := GenerateServiceProxyMethodDeclaration(&library, lop);
m.Comment := GenerateDocumentation(lop, true);
lIService.Members.Add(m);
end;
{$ENDREGION}
{$REGION %SERVICE_NAME%_Proxy}
var lancestorName := aEntity.AncestorName;
if String.IsNullOrEmpty(lancestorName) then
lancestorName := "ROProxy"
else
lancestorName := lancestorName+"_Proxy";
var lServiceProxy := new CGClassTypeDefinition(SafeIdentifier(aEntity.Name+"_Proxy"),
[lancestorName.AsTypeReference].ToList,
[lIService.Name.AsTypeReference].ToList,
Visibility := CGTypeVisibilityKind.Public
);
file.Types.Add(lServiceProxy);
GenerateServiceMethods(&library,aEntity, lServiceProxy);
for lop : RodlOperation in aEntity.DefaultInterface:Items do
lServiceProxy.Members.Add(GenerateServiceProxyMethod(&library,lop));
{$ENDREGION}
{$REGION %SERVICE_NAME%_AsyncProxy}
lancestorName := aEntity.AncestorName;
if String.IsNullOrEmpty(lancestorName) then
lancestorName := "ROAsyncProxy"
else
lancestorName := lancestorName+"_AsyncProxy";
var lServiceAsyncProxy := new CGClassTypeDefinition(SafeIdentifier(aEntity.Name+"_AsyncProxy"),lancestorName.AsTypeReference,
Visibility := CGTypeVisibilityKind.Public
);
file.Types.Add(lServiceAsyncProxy);
GenerateServiceMethods(&library,aEntity,lServiceAsyncProxy);
for lop : RodlOperation in aEntity.DefaultInterface:Items do begin
lServiceAsyncProxy.Members.Add(GenerateServiceAsyncProxyBeginMethod(&library, lop));
lServiceAsyncProxy.Members.Add(GenerateServiceAsyncProxyBeginMethod_start(&library, lop));
lServiceAsyncProxy.Members.Add(GenerateServiceAsyncProxyBeginMethod_startWithBlock(&library, lop));
lServiceAsyncProxy.Members.Add(GenerateServiceAsyncProxyEndMethod(&library, lop));
end;
{$ENDREGION}
end;
method CocoaRodlCodeGen.GenerateEventSink(file: CGCodeUnit; &library: RodlLibrary; aEntity: RodlEventSink);
begin
var lIEvent := new CGInterfaceTypeDefinition("I"+aEntity.Name,
Visibility := CGTypeVisibilityKind.Public,
Comment:= GenerateDocumentation(aEntity));
file.Types.Add(lIEvent);
var lEventInvoker := new CGClassTypeDefinition(aEntity.Name+"_EventInvoker", "ROEventInvoker".AsTypeReference,
Visibility := CGTypeVisibilityKind.Public
);
lEventInvoker.Attributes.Add(new CGAttribute("objc".AsTypeReference, SafeIdentifier(aEntity.Name+"_EventInvoker").AsNamedIdentifierExpression.AsCallParameter));
file.Types.Add(lEventInvoker);
for lop : RodlOperation in aEntity.DefaultInterface:Items do begin
var lievent_method := new CGMethodDefinition(lop.Name,
Visibility := CGMemberVisibilityKind.Public,
Comment:= GenerateDocumentation(lop, true));
lIEvent.Members.Add(lievent_method);
var lInParam:=new List<RodlParameter>;
for m: RodlParameter in lop.Items do begin
lievent_method.Parameters.Add(new CGParameterDefinition(SafeIdentifier(m.Name),ResolveDataTypeToTypeRef(library,m.DataType), Modifier := ApplyParamDirection(m.ParamFlag)));
if m.ParamFlag in [ParamFlags.In,ParamFlags.InOut] then lInParam.Add(m);
end;
var linvk_method := new CGMethodDefinition("Invoke_"+lop.Name,
Parameters := [new CGParameterDefinition("aMessage", "ROMessage".AsTypeReference),
new CGParameterDefinition("aHandler", ResolveStdtypes(CGPredefinedTypeReference.Object), ExternalName := "handler")].ToList,
ReturnType:= ResolveStdtypes(CGPredefinedTypeReference.Boolean),
Visibility := CGMemberVisibilityKind.Public);
lEventInvoker.Members.Add(linvk_method);
if IsAppleSwift then begin
linvk_method.Statements.Add(new CGVariableDeclarationStatement("___selPattern",
"NSString".AsTypeReference().NotNullable,
new CGNewInstanceExpression("NSString".AsTypeReference,
[SafeIdentifier(lop.Name).AsLiteralExpression.AsCallParameter("string")].ToList)));
end
else begin
linvk_method.Statements.Add(new CGVariableDeclarationStatement("___selPattern",
"NSString".AsTypeReference,
new CGMethodCallExpression("NSMutableString".AsTypeReferenceExpression,
"stringWithString",
[SafeIdentifier(lop.Name).AsLiteralExpression.AsCallParameter].ToList)));
end;
if lInParam.Count>0 then
linvk_method.Statements.Add(new CGForToLoopStatement(
"i",
ResolveStdtypes(CGPredefinedTypeReference.Int),
new CGIntegerLiteralExpression(1),
new CGIntegerLiteralExpression(lInParam.Count),
new CGAssignmentStatement("___selPattern".AsNamedIdentifierExpression, new CGMethodCallExpression("___selPattern".AsNamedIdentifierExpression, "stringByAppendingString", [":".AsLiteralExpression.AsCallParameter].ToList))
));
linvk_method.Statements.Add(new CGVariableDeclarationStatement("___selector",
SELType,
new CGMethodCallExpression(nil,
"NSSelectorFromString", [
(if IsAppleSwift then
new CGTypeCastExpression("___selPattern".AsNamedIdentifierExpression, "String".AsTypeReference, GuaranteedSafe := true)
else
"___selPattern".AsNamedIdentifierExpression).AsCallParameter].ToList),
&ReadOnly := true));
var if_true:= new CGBeginEndBlockStatement;
{if_true.Statements.Add(new CGVariableDeclarationStatement("__signature",
"NSMethodSignature".AsTypeReference,
new CGMethodCallExpression("aHandler".AsNamedIdentifierExpression,
"methodSignatureForSelector",
["__selector".AsNamedIdentifierExpression.AsCallParameter].ToList)));}
if IsAppleSwift then
if_true.Statements.Add(new CGVariableDeclarationStatement("___invocation",
"ROInvocation".AsTypeReference,
new CGNewInstanceExpression("ROInvocation".AsTypeReference,
["___selector".AsNamedIdentifierExpression.AsCallParameter("selector"),
"aHandler".AsNamedIdentifierExpression.AsCallParameter("object")].ToList),
&ReadOnly := true))
else
if_true.Statements.Add(new CGVariableDeclarationStatement("___invocation",
"ROInvocation".AsTypeReference,
new CGMethodCallExpression("ROInvocation".AsTypeReferenceExpression,
"invocationWithSelector",
["___selector".AsNamedIdentifierExpression.AsCallParameter,
"aHandler".AsNamedIdentifierExpression.AsCallParameter("object")].ToList),
&ReadOnly := true));
//Indices 0 and 1 indicate the hidden arguments self and _cmd, respectively; you should set these values directly with the target and selector properties. Use indices 2 and greater for the arguments normally passed in a message.
var linc := 2;
for m: RodlParameter in lInParam do begin
var lm_name:= "___"+SafeIdentifier(m.Name);
if_true.Statements.Add(new CGVariableDeclarationStatement(lm_name,ResolveDataTypeToTypeRef(library,m.DataType),GetReaderExpression(&library,m)));
if_true.Statements.Add(new CGMethodCallExpression("___invocation".AsNamedIdentifierExpression,
"setArgument",
[new CGCallParameter(new CGUnaryOperatorExpression(lm_name.AsNamedIdentifierExpression, CGUnaryOperatorKind.AddressOf)),
new CGCallParameter(new CGIntegerLiteralExpression(linc), "atIndex")].ToList));
inc(linc);
end;
if_true.Statements.Add(new CGMethodCallExpression("___invocation".AsNamedIdentifierExpression,"invoke"));
if_true.Statements.Add(new CGBooleanLiteralExpression(True).AsReturnStatement);
linvk_method.Statements.Add(new CGIfThenElseStatement(
new CGMethodCallExpression("aHandler".AsNamedIdentifierExpression,"respondsToSelector", ["___selector".AsNamedIdentifierExpression.AsCallParameter].ToList),
if_true,
new CGBooleanLiteralExpression(False).AsReturnStatement
));
end;
end;
constructor CocoaRodlCodeGen;
begin
CodeGenTypes.Add("integer", ResolveStdtypes(CGPredefinedTypeReference.Int32));
CodeGenTypes.Add("datetime", "NSDate".AsTypeReference().NullableUnwrapped);
CodeGenTypes.Add("double", ResolveStdtypes(CGPredefinedTypeReference.Double));
CodeGenTypes.Add("currency", "NSDecimalNumber".AsTypeReference().NullableUnwrapped);
CodeGenTypes.Add("widestring", ResolveStdtypes(CGPredefinedTypeReference.String));
CodeGenTypes.Add("ansistring", ResolveStdtypes(CGPredefinedTypeReference.String));
CodeGenTypes.Add("int64", ResolveStdtypes(CGPredefinedTypeReference.Int64));
CodeGenTypes.Add("boolean", ResolveStdtypes(CGPredefinedTypeReference.Boolean));
CodeGenTypes.Add("variant", "ROVariant".AsTypeReference);
CodeGenTypes.Add("binary", "NSData".AsTypeReference);
CodeGenTypes.Add("xml", "ROXml".AsTypeReference);
CodeGenTypes.Add("guid", "ROGuid".AsTypeReference);
CodeGenTypes.Add("decimal", "NSDecimalNumber".AsTypeReference().NullableUnwrapped);
CodeGenTypes.Add("utf8string", ResolveStdtypes(CGPredefinedTypeReference.String));
CodeGenTypes.Add("xsdatetime", "NSDate".AsTypeReference().NullableUnwrapped);
ReaderFunctions.Add("integer", "Int32");
ReaderFunctions.Add("datetime", "DateTime");
ReaderFunctions.Add("double", "Double");
ReaderFunctions.Add("currency", "Currency");
ReaderFunctions.Add("widestring", "WideString");
ReaderFunctions.Add("ansistring", "AnsiString");
ReaderFunctions.Add("int64", "Int64");
ReaderFunctions.Add("decimal", "Decimal");
ReaderFunctions.Add("guid", "Guid");
ReaderFunctions.Add("utf8string", "Utf8String");
ReaderFunctions.Add("boolean", "Boolean");
ReaderFunctions.Add("variant", "Variant");
ReaderFunctions.Add("binary", "Binary");
ReaderFunctions.Add("xml", "Xml");
ReaderFunctions.Add("xsdatetime", "XsDateTime");
fCachedNumberFN.Add("integer","Int");
fCachedNumberFN.Add("double", "Double");
fCachedNumberFN.Add("int64", "LongLong");
fCachedNumberFN.Add("boolean", "Bool");
{ReservedWords.Add([
"abstract", "and", "add", "async", "as", "begin", "break", "case", "class", "const", "constructor", "continue",
"delegate", "default", "div", "do", "downto", "each", "else", "empty", "end", "enum", "ensure", "event", "except",
"exit", "external", "false", "final", "finalizer", "finally", "flags", "for", "forward", "function", "global", "has",
"if", "implementation", "implements", "implies", "in", "index", "inline", "inherited", "interface", "invariants", "is",
"iterator", "locked", "locking", "loop", "matching", "method", "mod", "namespace", "nested", "new", "nil", "not",
"nullable", "of", "old", "on", "operator", "or", "out", "override", "pinned", "partial", "private", "property",
"protected", "public", "reintroduce", "raise", "read", "readonly", "remove", "repeat", "require", "result", "sealed",
"self", "sequence", "set", "shl", "shr", "static", "step", "then", "to", "true", "try", "type", "typeof", "until",
"unsafe", "uses", "using", "var", "virtual", "where", "while", "with", "write", "xor", "yield"]);}
end;
constructor CocoaRodlCodeGen withSwiftDialect(aSwiftDialect: CGSwiftCodeGeneratorDialect);
begin
constructor;
SwiftDialect := aSwiftDialect;
end;
method CocoaRodlCodeGen.FixUpForAppleSwift;
begin
// nasty hack, but so fuck it!
CodeGenTypes.Remove("binary");
CodeGenTypes.Remove("datetime");
CodeGenTypes.Remove("xsdatetime");
CodeGenTypes.Add("binary", "Data".AsTypeReference);
CodeGenTypes.Add("datetime", "Date".AsTypeReference);
CodeGenTypes.Add("xsdatetime", "Date".AsTypeReference);
end;
method CocoaRodlCodeGen.HandleAtributes_private(&library: RodlLibrary; aEntity: RodlEntity): CGFieldDefinition;
begin
// There is no need to generate CustomAttribute-related methods if there is no custom attributes
if (aEntity.CustomAttributes.Count = 0) then exit;
exit new CGFieldDefinition(
"___attributes",
"NSDictionary".AsTypeReference,
&Static := true,
Visibility := CGMemberVisibilityKind.Private);
end;
method CocoaRodlCodeGen.HandleAtributes_public(&library: RodlLibrary; aEntity: RodlEntity): CGMethodDefinition;
begin
// There is no need to generate CustomAttribute-related methods if there is no custom attributes
if (aEntity.CustomAttributes.Count = 0) then exit;
result := new CGMethodDefinition("getAttributeValue",
ReturnType := CGPredefinedTypeReference.String,
Parameters := [new CGParameterDefinition("aName", CGPredefinedTypeReference.String.NotNullable)].ToList,
Visibility := CGMemberVisibilityKind.Public,
Virtuality := CGMemberVirtualityKind.Override,
&Static := true);
var l_attributes := "___attributes".AsNamedIdentifierExpression;
var list:= new List<CGCallParameter>;
list.Add(new CGBooleanLiteralExpression(False).AsCallParameter);
for l_key: String in aEntity.CustomAttributes.Keys do begin
list.Add(EscapeString(l_key.ToLowerInvariant).AsLiteralExpression.AsCallParameter);
list.Add(EscapeString(aEntity.CustomAttributes[l_key]).AsLiteralExpression.AsCallParameter);
end;
if not IsAppleSwift then
list.Add(new CGNilExpression().AsCallParameter);
result.Statements.Add(new CGIfThenElseStatement(
new CGAssignedExpression(l_attributes, Inverted := true),
new CGAssignmentStatement(l_attributes,
new CGMethodCallExpression(nil,"DictionaryFromNameValueList", list)
)));
result.Statements.Add(new CGMethodCallExpression(l_attributes, "objectForKey",
[new CGMethodCallExpression("aName".AsNamedIdentifierExpression, "lowercaseString").AsCallParameter].ToList).AsReturnStatement);
end;
method CocoaRodlCodeGen.WriteToMessage_Method(&library: RodlLibrary; aEntity: RodlStructEntity): CGMethodDefinition;
begin
//method writeToMessage(aMessage: ROMessage) withName(aName: NSString); override;
result := new CGMethodDefinition(if IsSwift then "write" else "writeToMessage",
Parameters := [new CGParameterDefinition("aMessage","ROMessage".AsTypeReference().NotNullable, ExternalName := if IsSwift then "to"),
new CGParameterDefinition("aName", ResolveStdtypes(CGPredefinedTypeReference.String), ExternalName := "withName")].ToList,
Visibility := CGMemberVisibilityKind.Public);
if not (aEntity is RodlException) then result.Virtuality := CGMemberVirtualityKind.Override;
var lIfRecordStrictOrder_True := new CGBeginEndBlockStatement;
var lIfRecordStrictOrder_False := new CGBeginEndBlockStatement;
var lIfRecordStrictOrder := new CGIfThenElseStatement(
new CGPropertyAccessExpression("aMessage".AsNamedIdentifierExpression, "useStrictFieldOrderForStructs"),
lIfRecordStrictOrder_True,
lIfRecordStrictOrder_False
);
result.Statements.Add(lIfRecordStrictOrder);
if assigned(aEntity.AncestorEntity) then begin
lIfRecordStrictOrder_True.Statements.Add(
new CGMethodCallExpression(CGInheritedExpression.Inherited, if IsSwift then "write" else "writeToMessage",
["aMessage".AsNamedIdentifierExpression.AsCallParameter(if IsSwift then "to"),
new CGCallParameter("aName".AsNamedIdentifierExpression, "withName")].ToList)
);
end;
var lSortedFields := new Dictionary<String,RodlField>;
var lAncestorEntity := aEntity.AncestorEntity as RodlStructEntity;
while assigned(lAncestorEntity) do begin
for field: RodlField in lAncestorEntity.Items do
lSortedFields.Add(field.Name.ToLowerInvariant, field);
lAncestorEntity := lAncestorEntity.AncestorEntity as RodlStructEntity;
end;
for field: RodlField in aEntity.Items do
if not lSortedFields.ContainsKey(field.Name.ToLowerInvariant) then begin
lSortedFields.Add(field.Name.ToLowerInvariant, field);
lIfRecordStrictOrder_True.Statements.Add(GetWriterStatement(library, field, false));
end;
for lvalue: String in lSortedFields.Keys.ToList.Sort_OrdinalIgnoreCase(b->b) do
lIfRecordStrictOrder_False.Statements.Add(GetWriterStatement(library, lSortedFields.Item[lvalue], false));
end;
method CocoaRodlCodeGen.ReadFromMessage_Method(&library: RodlLibrary; aEntity: RodlStructEntity): CGMethodDefinition;
begin
//method readFromMessage(aMessage: ROMessage) withName(aName: NSString); override;
result := new CGMethodDefinition(if IsSwift then "read" else "readFromMessage",
Parameters := [new CGParameterDefinition("aMessage","ROMessage".AsTypeReference().NotNullable, ExternalName := if IsSwift then "from"),
new CGParameterDefinition("aName", ResolveStdtypes(CGPredefinedTypeReference.String), ExternalName :="withName")].ToList,
Visibility := CGMemberVisibilityKind.Public);
if not (aEntity is RodlException) then result.Virtuality := CGMemberVirtualityKind.Override;
var lIfRecordStrictOrder_True := new CGBeginEndBlockStatement;
var lIfRecordStrictOrder_False := new CGBeginEndBlockStatement;
var lIfRecordStrictOrder := new CGIfThenElseStatement(
new CGPropertyAccessExpression("aMessage".AsNamedIdentifierExpression, "useStrictFieldOrderForStructs"),
lIfRecordStrictOrder_True,
lIfRecordStrictOrder_False
);
result.Statements.Add(lIfRecordStrictOrder);
if assigned(aEntity.AncestorEntity) then begin
lIfRecordStrictOrder_True.Statements.Add(
new CGMethodCallExpression(CGInheritedExpression.Inherited, if IsSwift then "read" else "readFromMessage",
["aMessage".AsNamedIdentifierExpression.AsCallParameter(if IsSwift then "from"),
new CGCallParameter("aName".AsNamedIdentifierExpression, "withName")].ToList)
);
end;
var lSortedFields := new Dictionary<String,RodlField>;
var lAncestorEntity := aEntity.AncestorEntity as RodlStructEntity;
while assigned(lAncestorEntity) do begin
for field: RodlField in lAncestorEntity.Items do
lSortedFields.Add(field.Name.ToLowerInvariant, field);
lAncestorEntity := lAncestorEntity.AncestorEntity as RodlStructEntity;
end;
for field: RodlField in aEntity.Items do
if not lSortedFields.ContainsKey(field.Name.ToLowerInvariant) then begin
lSortedFields.Add(field.Name.ToLowerInvariant, field);
lIfRecordStrictOrder_True.Statements.Add(GetReaderStatement(library, field));
end;
for lvalue: String in lSortedFields.Keys.ToList.Sort_OrdinalIgnoreCase(b->b) do
lIfRecordStrictOrder_False.Statements.Add(GetReaderStatement(library, lSortedFields.Item[lvalue]));
end;
method CocoaRodlCodeGen.GetWriterStatement(&library: RodlLibrary; aEntity: RodlTypedEntity; aVariableName: String := "aMessage"; isMethod: Boolean; aInOnly: Boolean := false): CGStatement;
begin
var lLower: String := aEntity.DataType.ToLowerInvariant();
var lMethodName: String;
var lIsEnum := isEnum(&library,aEntity.DataType);
var lIsComplex := iif(not lIsEnum,isComplex(&library,aEntity.DataType), false);
var lIsSimple := not (lIsEnum or lIsComplex);
if lIsEnum then lMethodName := "Enum"
else if isArray(&library, aEntity.DataType) then lMethodName := "MutableArray"
else if isStruct(&library, aEntity.DataType) then lMethodName := "Complex"
else if ReaderFunctions.ContainsKey(lLower) then lMethodName := ReaderFunctions[lLower]
else lMethodName := "UnknownType";
var lIdentifier : CGExpression := if isMethod then
SafeIdentifier(aEntity.Name).AsNamedIdentifierExpression
else
new CGPropertyAccessExpression(nil, SafeIdentifier(aEntity.Name));
if aEntity is RodlParameter then
lIdentifier := ApplyParamDirectionExpression(lIdentifier,RodlParameter(aEntity).ParamFlag, aInOnly);
if lIsComplex or lIsSimple then begin
exit new CGMethodCallExpression(aVariableName.AsNamedIdentifierExpression,
"write" + lMethodName,
[lIdentifier.AsCallParameter,
new CGCallParameter(CleanedWsdlName(aEntity.Name).AsLiteralExpression, "withName")].ToList);
end
else if lIsEnum then begin
//aMessage.write%FIELD_READER_WRITER%(Integer(%FIELD_NAME%)) withName("%FIELD_NAME_UNSAFE%") asEnum(%FIELD_TYPE_RAW%__EnumMetaData.instance);
exit new CGMethodCallExpression(aVariableName.AsNamedIdentifierExpression,
"write" + lMethodName,
[if IsAppleSwift then new CGPropertyAccessExpression(lIdentifier, "rawValue").AsCallParameter
else new CGTypeCastExpression(lIdentifier, NSUIntegerType, ThrowsException := true).AsCallParameter,
new CGCallParameter(CleanedWsdlName(aEntity.Name).AsLiteralExpression, "withName"),
new CGCallParameter(new CGMethodCallExpression((aEntity.DataType+"__EnumMetaData").AsTypeReferenceExpression, "instance"), if IsAppleSwift then "as" else "asEnum")].ToList);
end
else begin
raise new Exception(String.Format("unknown type: {0}",[aEntity.DataType]));
end;
end;
method CocoaRodlCodeGen.GetReaderStatement(&library: RodlLibrary; aEntity: RodlTypedEntity; aVariableName: String := "aMessage"): CGStatement;
begin
exit new CGAssignmentStatement(new CGPropertyAccessExpression(nil, SafeIdentifier(aEntity.Name)), GetReaderExpression(&library,aEntity,aVariableName));
end;
method CocoaRodlCodeGen.GetReaderExpression(&library: RodlLibrary; aEntity: RodlTypedEntity; aVariableName: String := "aMessage"): CGExpression;
begin
var lLower: String := aEntity.DataType.ToLowerInvariant();
var lMethodName: String;
var lIsEnum := isEnum(&library,aEntity.DataType);
var lIsComplex := iif(not lIsEnum,isComplex(&library,aEntity.DataType), false);
var lIsArray := isArray(&library, aEntity.DataType);
var lIsStruct := isStruct(&library, aEntity.DataType);
var lIsSimple := not (lIsEnum or lIsComplex);
if lIsEnum then lMethodName := "Enum"
else if lIsArray then lMethodName := "MutableArray"
else if lIsStruct then lMethodName := "Complex"
else if ReaderFunctions.ContainsKey(lLower) then lMethodName := ReaderFunctions[lLower]
else lMethodName := "UnknownType";
var lNameString := CleanedWsdlName(aEntity.Name).AsLiteralExpression.AsCallParameter(if IsSwift then "withName");
if isClassType(library, aEntity.DataType) then begin
// %FIELD_NAME% := aMessage.read%FIELD_READER_WRITER%WithName("%FIELD_NAME_UNSAFE%") asClass(%FIELD_TYPE_NAME%.class) as %FIELD_TYPE_NAME%;
var lType := ResolveDataTypeToTypeRef(&library, aEntity.DataType);//.NotNullabeCopy;
if lIsComplex or lIsArray then begin
//var l_type1:= ResolveDataTypeToTypeRef(&library, aEntity.DataType).NotNullable;
var lArgument1 := new CGCallParameter(new CGTypeOfExpression(lType.AsExpression), if IsSwift then "as" else "asClass");
var l_methodCall := new CGMethodCallExpression(aVariableName.AsNamedIdentifierExpression,
if IsSwift then "read"+lMethodName else "read"+lMethodName+"WithName",
[lNameString, lArgument1].ToList);
exit new CGTypeCastExpression(l_methodCall, lType, ThrowsException := true)
end
else begin
var l_methodCall := new CGMethodCallExpression(aVariableName.AsNamedIdentifierExpression,
if IsSwift then "read"+lMethodName else "read"+lMethodName+"WithName",
[lNameString].ToList);
exit l_methodCall;
end;
end
else if lIsEnum then begin
// %FIELD_NAME% := %FIELD_TYPE_RAW%(aMessage.read%FIELD_READER_WRITER%WithName("%FIELD_NAME_UNSAFE%") asEnum(%FIELD_TYPE_RAW%__EnumMetaData.instance));
var lType := ResolveDataTypeToTypeRef(&library, aEntity.DataType);
var lArgument1 := new CGCallParameter(new CGMethodCallExpression((SafeIdentifier(aEntity.DataType)+"__EnumMetaData").AsTypeReferenceExpression,"instance"), "asEnum");
var lMethodCall := new CGMethodCallExpression(aVariableName.AsNamedIdentifierExpression,
if IsSwift then "read"+lMethodName else "read"+lMethodName+"WithName",
[lNameString, lArgument1].ToList);
if IsAppleSwift then
exit new CGUnaryOperatorExpression(new CGNewInstanceExpression(lType, lMethodCall.AsCallParameter("rawValue")), CGUnaryOperatorKind.ForceUnwrapNullable)
else
exit new CGTypeCastExpression(lMethodCall, lType, ThrowsException := true);
end
else if lIsSimple then begin
exit new CGMethodCallExpression(aVariableName.AsNamedIdentifierExpression,
if IsSwift then "read"+lMethodName else "read"+lMethodName+"WithName",
[lNameString].ToList);
end
else begin
raise new Exception(String.Format("unknown type: {0}",[aEntity.DataType]));
end;
end;
method CocoaRodlCodeGen.isClassType(&library: RodlLibrary; dataType: String): Boolean;
begin
exit not (fCachedNumberFN.ContainsKey(dataType.ToLowerInvariant) or isEnum(&library,dataType));
end;
method CocoaRodlCodeGen.GetNumberFN(dataType: String): String;
begin
var ln := dataType.ToLowerInvariant;
if fCachedNumberFN.ContainsKey(ln) then
exit fCachedNumberFN[ln]
else
exit "-";
end;
method CocoaRodlCodeGen.ApplyParamDirection(paramFlag: ParamFlags; aInOnly: Boolean := false): CGParameterModifierKind;
begin
case paramFlag of
ParamFlags.In: exit CGParameterModifierKind.In;
ParamFlags.InOut: exit if aInOnly then CGParameterModifierKind.In else CGParameterModifierKind.Var;
ParamFlags.Out: exit CGParameterModifierKind.Out;
ParamFlags.Result: raise new Exception("problem with ParamFlags.Result");
end;
end;
method CocoaRodlCodeGen.GenerateServiceProxyMethod(&library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
begin
result := GenerateServiceProxyMethodDeclaration(&library,aEntity);
var lInParameters := new List<RodlParameter>;
var lOutParameters := new List<RodlParameter>;
for p: RodlParameter in aEntity.Items do begin
if p.ParamFlag in [ParamFlags.In,ParamFlags.InOut] then
lInParameters.Add(p);
if p.ParamFlag in [ParamFlags.Out,ParamFlags.InOut] then
lOutParameters.Add(p);
end;
if assigned(aEntity.Result) then begin
result.Statements.Add(new CGVariableDeclarationStatement("___result",result.ReturnType));
end;
result.Statements.Add(new CGVariableDeclarationStatement("___localMessage",
"ROMessage".AsTypeReference,
new CGTypeCastExpression(new CGMethodCallExpression(new CGPropertyAccessExpression(new CGSelfExpression(), "___message") , "copy"), "ROMessage".AsTypeReference(), ThrowsException := true),
&ReadOnly := true));
GenerateOperationAttribute(&library,aEntity,result.Statements);
result.Statements.Add(new CGMethodCallExpression("___localMessage".AsNamedIdentifierExpression,
if IsAppleSwift then "initialize" else "initializeAsRequestMessage",
[new CGPropertyAccessExpression(new CGSelfExpression, "___clientChannel").AsCallParameter(if IsAppleSwift then "asRequest"),
new CGCallParameter(library.Name.AsLiteralExpression, "libraryName"),
new CGCallParameter(new CGMethodCallExpression(new CGSelfExpression(), "__getActiveInterfaceName"), "interfaceName"),
new CGCallParameter(SafeIdentifier(aEntity.Name).AsLiteralExpression, "messageName")].ToList
));
// Apple Swift can't do and doesn't need the try/finally
var lTryStatements := new List<CGStatement>;
var lFinallyStatements := if SwiftDialect = CGSwiftCodeGeneratorDialect.Silver then new List<CGStatement> else lTryStatements;
for p: RodlParameter in lInParameters do
lTryStatements.Add(GetWriterStatement(&library, p, "___localMessage", true));
lTryStatements.Add(new CGMethodCallExpression("___localMessage".AsNamedIdentifierExpression, "finalizeMessage"));
lTryStatements.Add(new CGMethodCallExpression(new CGPropertyAccessExpression(new CGSelfExpression, "___clientChannel"),
"dispatch",
["___localMessage".AsNamedIdentifierExpression.AsCallParameter].ToList));
if assigned(aEntity.Result) then
lTryStatements.Add(new CGAssignmentStatement("___result".AsNamedIdentifierExpression,
GetReaderExpression(&library,aEntity.Result,"___localMessage")));
for p: RodlParameter in lOutParameters do
lTryStatements.Add(new CGAssignmentStatement(
ApplyParamDirectionExpression(p.Name.AsNamedIdentifierExpression, p.ParamFlag),
GetReaderExpression(&library, p ,"___localMessage")
));
var lSelfMessage := new CGPropertyAccessExpression(new CGSelfExpression, "___message");
lFinallyStatements.Add(new CGMethodCallExpression(nil, "objc_sync_enter", [lSelfMessage.AsCallParameter].ToList));
lFinallyStatements.Add(new CGAssignmentStatement(new CGPropertyAccessExpression(lSelfMessage, "clientID"),
new CGPropertyAccessExpression("___localMessage".AsNamedIdentifierExpression, "clientID")));
lFinallyStatements.Add(new CGMethodCallExpression(nil,"objc_sync_exit", [lSelfMessage.AsCallParameter].ToList));
if SwiftDialect = CGSwiftCodeGeneratorDialect.Silver then begin
result.Statements.Add(new CGTryFinallyCatchStatement(lTryStatements, FinallyStatements:= lFinallyStatements as not nullable));
end
else begin
result.Statements.Add(lTryStatements);
end;
if assigned(aEntity.Result) then
result.Statements.Add("___result".AsNamedIdentifierExpression.AsReturnStatement);
end;
method CocoaRodlCodeGen.GenerateServiceProxyMethodDeclaration(&library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
begin
result:= new CGMethodDefinition(SafeIdentifier(aEntity.Name),
Visibility := CGMemberVisibilityKind.Public);
for p: RodlParameter in aEntity.Items do begin
if p.ParamFlag in [ParamFlags.In, ParamFlags.InOut, ParamFlags.Out] then
result.Parameters.Add(new CGParameterDefinition(p.Name, ResolveDataTypeToTypeRef(&library, p.DataType), Modifier := ApplyParamDirection(p.ParamFlag)));
end;
if assigned(aEntity.Result) then
result.ReturnType := ResolveDataTypeToTypeRef(&library, aEntity.Result.DataType);
end;
method CocoaRodlCodeGen.GenerateServiceAsyncProxyBeginMethod(&library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
begin
result := GenerateServiceAsyncProxyBeginMethodDeclaration(&library ,aEntity);
GenerateServiceAsyncProxyBeginMethod_Body(&library,aEntity,result.Statements);
// exit self.___clientChannel.asyncDispatch(___localMessage) withProxy(self) start(true);
result.Statements.Add(new CGMethodCallExpression( new CGPropertyAccessExpression(new CGSelfExpression,"___clientChannel"),
"asyncDispatch",
["___localMessage".AsNamedIdentifierExpression.AsCallParameter,
new CGCallParameter(new CGSelfExpression(), if IsSwift then "with" else "withProxy"),
new CGCallParameter(new CGBooleanLiteralExpression(True), "start")].ToList
).AsReturnStatement);
end;
method CocoaRodlCodeGen.GenerateServiceAsyncProxyEndMethod(&library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
begin
result := new CGMethodDefinition("end" + PascalCase(aEntity.Name), Visibility := CGMemberVisibilityKind.Public);
result.Parameters.Add(new CGParameterDefinition("___asyncRequest", "ROAsyncRequest".AsTypeReference));
var lOutParameters := new List<RodlParameter>;
for p: RodlParameter in aEntity.Items do begin
if p.ParamFlag in [ParamFlags.Out,ParamFlags.InOut] then begin
lOutParameters.Add(p);
result.Parameters.Add(new CGParameterDefinition(p.Name, ResolveDataTypeToTypeRef(&library, p.DataType), Modifier := CGParameterModifierKind.Out)); // end* metbods are always "out"
end;
end;
if assigned(aEntity.Result) then begin
result.ReturnType := ResolveDataTypeToTypeRef(&library, aEntity.Result.DataType);
end;
if assigned(aEntity.Result) then
result.Statements.Add(new CGVariableDeclarationStatement("___result", result.ReturnType) );
result.Statements.Add(new CGVariableDeclarationStatement("___localMessage", "ROMessage".AsTypeReference, new CGPropertyAccessExpression("___asyncRequest".AsNamedIdentifierExpression, "responseMessage"), &ReadOnly := true));
GenerateOperationAttribute(&library,aEntity,Result.Statements);
if assigned(aEntity.Result) then
result.Statements.Add(new CGAssignmentStatement("___result".AsNamedIdentifierExpression, GetReaderExpression(&library,aEntity.Result,"___localMessage")));
for p: RodlParameter in lOutParameters do
result.Statements.Add(new CGAssignmentStatement(
ApplyParamDirectionExpression(p.Name.AsNamedIdentifierExpression,p.ParamFlag),
GetReaderExpression(&library,p,"___localMessage")
));
var lSelfMessage := new CGPropertyAccessExpression(new CGSelfExpression, "___message");
result.Statements.Add(new CGMethodCallExpression(nil, "objc_sync_enter", [lSelfMessage.AsCallParameter].ToList));
result.Statements.Add(new CGAssignmentStatement(new CGPropertyAccessExpression(lSelfMessage,"clientID"), new CGPropertyAccessExpression("___localMessage".AsNamedIdentifierExpression, "clientID")));
result.Statements.Add(new CGMethodCallExpression(nil,"objc_sync_exit", [lSelfMessage.AsCallParameter].ToList));
if assigned(aEntity.Result) then
result.Statements.Add("___result".AsNamedIdentifierExpression.AsReturnStatement);
end;
method CocoaRodlCodeGen.GenerateServiceAsyncProxyBeginMethodDeclaration(&library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
begin
result := new CGMethodDefinition("begin" + PascalCase(aEntity.Name),
Visibility := CGMemberVisibilityKind.Public,
ReturnType := "ROAsyncRequest".AsTypeReference);
if IsSwift then
result.Attributes.Add(new CGAttribute("discardableResult".AsTypeReference));
for p: RodlParameter in aEntity.Items do begin
if p.ParamFlag in [ParamFlags.In,ParamFlags.InOut] then
result.Parameters.Add(new CGParameterDefinition(p.Name, ResolveDataTypeToTypeRef(&library, p.DataType), Modifier := ApplyParamDirection(p.ParamFlag, true)));
end;
end;
method CocoaRodlCodeGen.GenerateOperationAttribute(&library: RodlLibrary; aEntity: RodlOperation; Statements: List<CGStatement>);
begin
var ld := Operation_GetAttributes(&library, aEntity);
if ld.Count > 0 then begin
var list:= new List<CGCallParameter>;
list.Add(new CGBooleanLiteralExpression(False).AsCallParameter);
for l_key: String in ld.Keys do begin
list.Add(EscapeString(l_key.ToLowerInvariant).AsLiteralExpression.AsCallParameter);
list.Add(EscapeString(ld[l_key]).AsLiteralExpression.AsCallParameter);
end;
if not IsAppleSwift then
list.Add(new CGNilExpression().AsCallParameter);
Statements.Add(new CGMethodCallExpression("___localMessage".AsNamedIdentifierExpression,
"setupAttributes",
[new CGMethodCallExpression(nil,"DictionaryFromNameValueList",list).AsCallParameter].ToList));
end;
end;
method CocoaRodlCodeGen.GenerateServiceMethods(&library: RodlLibrary; aEntity: RodlService; service: CGClassTypeDefinition);
begin
{$REGION method __getInterfaceName: NSString; override;}
service.Members.Add(
new CGMethodDefinition("__getInterfaceName",
[SafeIdentifier(aEntity.Name).AsLiteralExpression.AsReturnStatement],
ReturnType := CGPredefinedTypeReference.String.NotNullable,
Virtuality := CGMemberVirtualityKind.Override,
Visibility := CGMemberVisibilityKind.Public
)
);
{$ENDREGION}
end;
method CocoaRodlCodeGen.GenerateServiceAsyncProxyBeginMethod_start(&library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
begin
result := GenerateServiceAsyncProxyBeginMethodDeclaration(&library, aEntity);
if result.Parameters.Count = 0 then
result.Name := result.Name+ "__start";
result.Parameters.Add(new CGParameterDefinition("___start", ResolveStdtypes(CGPredefinedTypeReference.Boolean), ExternalName := if result.Parameters.Count > 0 then "start"));
GenerateServiceAsyncProxyBeginMethod_Body(&library,aEntity,result.Statements);
result.Statements.Add(new CGMethodCallExpression( new CGPropertyAccessExpression(new CGSelfExpression(),"___clientChannel"),
"asyncDispatch",
["___localMessage".AsNamedIdentifierExpression.AsCallParameter,
new CGCallParameter(new CGSelfExpression(), if IsSwift then "with" else "withProxy"),
new CGCallParameter("___start".AsNamedIdentifierExpression, "start")].ToList
).AsReturnStatement);
end;
method CocoaRodlCodeGen.GenerateServiceAsyncProxyBeginMethod_startWithBlock(&library: RodlLibrary; aEntity: RodlOperation): CGMethodDefinition;
begin
result := GenerateServiceAsyncProxyBeginMethodDeclaration(&library, aEntity);
if result.Parameters.Count = 0 then
result.Name := result.Name+ "__startWithBlock";
var bl := new CGInlineBlockTypeReference (new CGBlockTypeDefinition('',Parameters := [new CGParameterDefinition("request", "ROAsyncRequest".AsTypeReference(CGTypeNullabilityKind.NullableNotUnwrapped))].ToList));
result.Parameters.Add(new CGParameterDefinition("___block", bl, ExternalName := if result.Parameters.Count > 0 then (if IsAppleSwift then "startWith" else "startWithBlock")));
GenerateServiceAsyncProxyBeginMethod_Body(&library,aEntity,result.Statements);
result.Statements.Add(new CGMethodCallExpression( new CGPropertyAccessExpression(new CGSelfExpression(),"___clientChannel"),
"asyncDispatch",
["___localMessage".AsNamedIdentifierExpression.AsCallParameter,
new CGCallParameter(new CGSelfExpression(), if IsSwift then "with" else "withProxy"),
new CGCallParameter("___block".AsNamedIdentifierExpression, (if IsAppleSwift then "startWith" else "startWithBlock"))].ToList
).AsReturnStatement);
end;
method CocoaRodlCodeGen.ApplyParamDirectionExpression(aExpr: CGExpression; paramFlag: ParamFlags; aInOnly: Boolean := false): CGExpression;
begin
if Generator is CGObjectiveCCodeGenerator then begin
case paramFlag of
ParamFlags.In: exit aExpr;
ParamFlags.InOut: exit if aInOnly then aExpr else new CGPointerDereferenceExpression(aExpr);
ParamFlags.Out: exit new CGPointerDereferenceExpression(aExpr);
ParamFlags.Result: raise new Exception("problem with ParamFlags.Result");
end;
end
else
exit aExpr;
end;
method CocoaRodlCodeGen.GenerateServiceAsyncProxyBeginMethod_Body(&library: RodlLibrary; aEntity: RodlOperation; Statements: List<CGStatement>);
begin
Statements.Add(new CGVariableDeclarationStatement("___localMessage",
"ROMessage".AsTypeReference,
new CGTypeCastExpression(new CGMethodCallExpression(new CGPropertyAccessExpression(new CGSelfExpression(), "___message") , "copy"), "ROMessage".AsTypeReference(), ThrowsException := true),
&ReadOnly := true));
GenerateOperationAttribute(&library,aEntity,Statements);
Statements.Add(
new CGMethodCallExpression("___localMessage".AsNamedIdentifierExpression,
if IsAppleSwift then "initialize" else "initializeAsRequestMessage",
[new CGCallParameter(new CGPropertyAccessExpression(new CGSelfExpression,"___clientChannel"), Name := if IsAppleSwift then "asRequest"),
new CGCallParameter(library.Name.AsLiteralExpression, "libraryName"),
new CGCallParameter(new CGMethodCallExpression(new CGSelfExpression(), "__getActiveInterfaceName"), "interfaceName"),
new CGCallParameter(SafeIdentifier(aEntity.Name).AsLiteralExpression, "messageName")].ToList));
for p: RodlParameter in aEntity.Items do
if p.ParamFlag in [ParamFlags.In,ParamFlags.InOut] then
Statements.Add(GetWriterStatement(&library,p,"___localMessage", true, true));
Statements.Add(new CGMethodCallExpression("___localMessage".AsNamedIdentifierExpression, "finalizeMessage"));
end;
method CocoaRodlCodeGen.GetIncludesNamespace(library: RodlLibrary): String;
begin
if assigned(library.Includes) then begin
if IsObjC then
exit library.Includes.ObjCModule
else
exit library.Includes.CocoaModule;
end;
exit inherited GetIncludesNamespace(library);
end;
method CocoaRodlCodeGen.GetGlobalName(library: RodlLibrary): String;
begin
exit library.Name+"_Defines";
end;
method CocoaRodlCodeGen.AddGlobalConstants(file: CGCodeUnit; library: RodlLibrary);
begin
file.Globals.Add(new CGFieldDefinition("TargetNamespace", CGPredefinedTypeReference.String.NotNullable,
Constant := true,
Visibility := CGMemberVisibilityKind.Public,
Initializer := if assigned(targetNamespace) then targetNamespace.AsLiteralExpression).AsGlobal());
for lentity: RodlEntity in &library.EventSinks.Items do begin
if not EntityNeedsCodeGen(lentity) then Continue;
var lName := lentity.Name;
file.Globals.Add(new CGFieldDefinition(String.Format("EID_{0}",[lName]), CGPredefinedTypeReference.String.NotNullable,
Constant := true,
Visibility := CGMemberVisibilityKind.Public,
Initializer := lName.AsLiteralExpression).AsGlobal);
end;
end;
end. |
unit Unit1;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls;
type
TForm1 = class(TForm)
ButtonMyAdd: TButton;
EditValue1: TEdit;
EditValue2: TEdit;
EditResult: TEdit;
LabelAnd: TLabel;
LabelResult: TLabel;
ButtonMySub: TButton;
procedure ButtonMyAddClick(Sender: TObject);
procedure ButtonMySubClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
function MyAdd(txt1, txt2: string): string;
function MySub(txt1, txt2: string): string;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.ButtonMyAddClick(Sender: TObject);
begin
EditResult.Text := MyAdd(EditValue1.Text, EditValue2.Text);
end;
procedure TForm1.ButtonMySubClick(Sender: TObject);
begin
EditResult.Text := MySub(EditValue1.Text, EditValue2.Text);
end;
function TForm1.MyAdd(txt1: string; txt2: string): string;
var
x, y, r: Integer;
begin
x := StrToInt(txt1);
y := StrToInt(txt2);
r := x + y;
result := r.ToString();
end;
function TForm1.MySub(txt1: string; txt2: string): string;
var
x, y, r: Integer;
begin
x := StrToInt(txt1);
y := StrToInt(txt2);
r := x - y;
result := r.ToString();
end;
end.
|
unit uArquivoUDL;
interface
uses System.Classes, System.SysUtils, System.IniFiles;
type TArquivoUdl = class
private
FDataSource: string;
FsecurityInfo: Boolean;
FuserId: string;
Fcatalogo: string;
Fpassword: string;
FintegratedSecurity: string;
public
property dataSource : string read FDataSource;
property catalogo : string read Fcatalogo;
property userId : string read FuserId;
property password : string read Fpassword;
property securityInfo : Boolean read FsecurityInfo;
property integratedSecurity : string read FintegratedSecurity;
constructor create(AUdlFile: String);
end;
implementation
{ TArquivoUdl }
constructor TArquivoUdl.create(AUdlFile: String);
var
iniFile : TIniFile;
parametros: string;
lista : TStringList;
begin
try
lista := TStringList.Create;
iniFile := TIniFile.Create(AUdlFile);
parametros := iniFile.ReadString('oledb','Provider','');
with lista do
begin
StrictDelimiter := True;
Delimiter := ';';
DelimitedText := parametros;
FDataSource := Values['Data Source'];
Fcatalogo := Values['Initial Catalog'];
FuserId := Values['User ID'];
Fpassword := Values['Password'];
FsecurityInfo := StrToBool(Values['Persist Security Info']);
FintegratedSecurity := Values['Integrated Security'];
end;
finally
FreeAndNil(iniFile);
FreeAndNil(lista);
end;
end;
end.
|
unit Ths.Erp.Database.Connection.Settings;
interface
{$I ThsERP.inc}
uses
Vcl.Forms, System.SysUtils, System.IniFiles;
type
TConnSettings = class
private
FLanguage: string;
FDBUserPassword: UnicodeString;
FDBPortNo: Integer;
FDBUserName: UnicodeString;
FSQLServer: UnicodeString;
FDatabaseName: UnicodeString;
FAppName: UnicodeString;
protected
public
property Language: UnicodeString read FLanguage write FLanguage;
property SQLServer: UnicodeString read FSQLServer write FSQLServer;
property DatabaseName: UnicodeString read FDatabaseName write FDatabaseName;
property DBUserName: UnicodeString read FDBUserName write FDBUserName;
property DBUserPassword: UnicodeString read FDBUserPassword write FDBUserPassword;
property DBPortNo: Integer read FDBPortNo write FDBPortNo;
property AppName: UnicodeString read FAppName write FAppName;
procedure ReadFromFile();
procedure SaveToFile();
end;
implementation
uses
Ths.Erp.Constants;
{ TConnSettings }
procedure TConnSettings.ReadFromFile();
var
iniFile: TIniFile;
begin
iniFile := TIniFile.Create(ExtractFilePath(Application.ExeName) + PATH_SETTINGS + '\' + 'GlobalSettings.ini');
try
Self.FLanguage := iniFile.ReadString('ConnectionSettings', 'Language', '');
Self.FSQLServer := iniFile.ReadString('ConnectionSettings', 'SQLServer', '');
Self.FDatabaseName := iniFile.ReadString('ConnectionSettings', 'DatabaseName', '');
Self.FDBUserName := iniFile.ReadString('ConnectionSettings', 'DBUserName', '');
Self.FDBUserPassword := iniFile.ReadString('ConnectionSettings', 'DBUserPassword', '');
Self.DBPortNo := iniFile.ReadInteger('ConnectionSettings', 'DBPortNo', 0);
finally
iniFile.Free;
end;
end;
procedure TConnSettings.SaveToFile();
var
iniFile: TIniFile;
begin
iniFile := TIniFile.Create(ExtractFilePath(Application.ExeName) + 'Settings' + '\' + 'GlobalSettings.ini');
try
iniFile.WriteString('ConnectionSettings', 'Language', Self.FLanguage);
iniFile.WriteString('ConnectionSettings', 'SQLServer', Self.FSQLServer);
iniFile.WriteString('ConnectionSettings', 'DatabaseName', Self.DatabaseName);
iniFile.WriteString('ConnectionSettings', 'DBUserName', Self.DBUserName);
iniFile.WriteString('ConnectionSettings', 'DBUserPassword', Self.DBUserPassword);
iniFile.WriteInteger('ConnectionSettings', 'DBPortNo', Self.DBPortNo);
finally
iniFile.Free;
end;
end;
end.
|
unit New_Crt;
INTERFACE
const
BW40 = 0;
CO40 = 1;
BW80 = 2;
CO80 = 3;
C40 = CO40;
C80 = CO80;
Black = 0;
Blue = 1;
Green = 2;
Cyan = 3;
Red = 4;
Magenta = 5;
Brown = 6;
LightGray = 7;
DarkGray = 8;
LightBlue = 9;
LightGreen = 10;
LightCyan = 11;
LightRed = 12;
LightMagenta = 13;
Yellow = 14;
White = 15;
Blink = 128;
TextAttr : Byte = 7;
LastMode : Word = C80;
procedure Crt_Init;
function KeyPressed: Boolean;
function ReadKey: Char;
procedure TextMode(Mode: Integer);
procedure GotoXY(X,Y: Byte);
function WhereX: Byte;
function WhereY: Byte;
procedure ClrScr;
procedure ClrEol;
procedure InsLine;
procedure DelLine;
procedure TextColor(Color: Byte);
procedure TextBackground(Color: Byte);
procedure LowVideo;
procedure HighVideo;
procedure NormVideo;
procedure Delay(MS: Word);
procedure Sound(Hz: Word);
procedure NoSound;
IMPLEMENTATION
uses Dos;
const
DelayCnt : LongInt = 0;
ScanCode : Byte = 0;
procedure WriteChar(Cr : string); assembler;
asm
push bp
mov ah,3
xor bh,bh
int 10h
mov ax,1301h
xor bh,bh
les bp,Cr
mov bl,TextAttr
mov cx,1
inc bp
int 10h
pop bp
end;
function Zero(var F : TextRec) : Integer; far; assembler;
asm
xor ax,ax
end;
function PageWrite(var F : TextRec) : Integer; far;
var k : Integer;
begin
with F do if (Mode=fmOutput) and (BufPos>0) then
begin
for k:=0 to BufPos-1 do WriteChar(BufPtr^[k]);
BufPos:=0
end;
PageWrite:=0
end;
procedure DelayLoop; near; assembler;
asm
@1: sub ax,1
sbb dx,0
jc @2
cmp bl,es:[di]
je @1
@2:
end;
procedure Delay(MS: Word); assembler;
type
LongRec = record
Lo, Hi : Word
end;
asm
mov es,Seg0040
mov ax,DelayCnt.LongRec.Lo
add ax,DelayCnt.LongRec.Hi
or ax,ax
jne @2
mov di,$6c
mov bl,es:[di]
@1: cmp bl,es:[di]
je @1
mov bl,es:[di]
mov ax,-28
cwd
call DelayLoop
not ax
not dx
mov bx,ax
mov ax,dx
xor dx,dx
mov cx,55
div cx
mov DelayCnt.LongRec.Hi,ax
mov ax,bx
div cx
mov DelayCnt.LongRec.Lo,ax
@2: mov cx,MS
jcxz @3
xor di,di
mov bl,es:[di]
@4: mov ax,DelayCnt.LongRec.Lo
mov dx,DelayCnt.LongRec.Hi
call DelayLoop
loop @4
@3:
end;
procedure Sound(Hz: Word); assembler;
asm
mov bx,Hz
mov ax,34ddh
mov dx,0012h
cmp dx,bx
jnc @@2
div bx
mov bx,ax
in al,61h
test al,3
jnz @@1
or al,3
out 61h,al
mov al,0b6h
out 43h,al
@@1: mov al,bl
out 42h,al
mov al,bh
out 42h,al
@@2:
end;
procedure NoSound; assembler;
asm
in al,61h
and al,0fch
out 61h,al
end;
function KeyPressed: Boolean; assembler;
asm
cmp ScanCode,0
jne @@1
mov ah,1
int 16h
mov al,0
je @@2
@@1: mov al,1
@@2:
end;
function ReadKey: Char; assembler;
asm
mov al,ScanCode
mov ScanCode,0
or al,al
jne @@1
xor ah,ah
int 16h
or al,al
jne @@1
mov ScanCode,ah
or ah,ah
jne @@1
mov al,3
@@1:
end;
procedure TextColor(Color: Byte); assembler;
asm
mov al,Color
test al,0f0h
je @@1
and al,0fh
or al,80h
@@1: and TextAttr,70h
or TextAttr,al
end;
procedure TextMode(Mode: Integer); assembler;
asm
xor ah,ah
mov al,byte ptr Mode
mov LastMode,ax
int 10h
end;
procedure TextBackground(Color: Byte); assembler;
asm
mov al,Color
and al,7
mov cl,4
shl al,cl
and TextAttr,8fh
or TextAttr,al
end;
procedure GotoXY(X,Y: Byte); assembler;
asm
mov ah,2
xor bh,bh
mov dl,x
mov dh,y
dec dl
dec dh
int 10h
end;
procedure ClrEol; assembler;
asm
mov ah,3
xor bh,bh
int 10h
mov ax,600h
mov cx,dx
mov es,Seg0040
mov dl,es:[$4a]
dec dl
mov bh,TextAttr
int 10h
end;
function WhereX: Byte; assembler;
asm
mov ah,3
xor bh,bh
int 10h
mov al,dl
inc al
end;
function WhereY: Byte; assembler;
asm
mov ah,3
xor bh,bh
int 10h
mov al,dh
inc al
end;
procedure ClrScr; assembler;
asm
mov ax,600h
mov bh,TextAttr
xor cx,cx
mov dx,184fh
int 10h
mov ah,2
xor bh,bh
xor dx,dx
int 10h
end;
procedure InsLine; assembler;
asm
mov ah,3
xor bh,bh
int 10h
mov bh,TextAttr
mov ch,dh
xor cl,cl
mov es,Seg0040
mov al,es:[$4a]
xor ah,ah
mov dx,24*256-1
add dx,ax
mov ax,7*256+1
cmp ch,dh
jne @@1
xor al,al
@@1: int 10h
end;
procedure DelLine; assembler;
asm
mov ah,3
xor bh,bh
int 10h
mov bh,TextAttr
mov ch,dh
xor cl,cl
mov es,Seg0040
mov al,es:[$4a]
xor ah,ah
mov dx,24*256-1
add dx,ax
mov ax,6*256+1
cmp ch,dh
jne @@1
xor al,al
@@1: int 10h
end;
procedure LowVideo; assembler;
asm
and TextAttr,0f7h
end;
procedure HighVideo; assembler;
asm
or TextAttr,8
end;
procedure NormVideo; assembler;
asm
mov TextAttr,7
end;
procedure Crt_Init;
begin
with TextRec(Output) do
begin
OpenFunc:=@Zero; CloseFunc:=@Zero;
InOutFunc:=@PageWrite; FlushFunc:=@PageWrite
end
end;
end { New_Crt }. |
unit ADOTools;
{
ADOTools: thin ADODB wrapper.
https://github.com/stijnsanders/DataLank
}
interface
uses SysUtils, ADODB_TLB;
type
TADOLink=class(TObject)
private
FConnection:Connection;
public
constructor Create(const ConnectionString: WideString);
destructor Destroy; override;
function SingleValue(const SQL: WideString;
const Values: array of Variant): Variant;
function Execute(const SQL: WideString;
const Values: array of Variant): integer;
function Insert(const TableName: WideString; const Values: array of OleVariant;
const PKFieldName: WideString=''): int64;
procedure Update(const TableName: WideString; const Values:array of OleVariant);
property Connection:Connection read FConnection;
end;
TADOResult=class(TObject)
private
FRecordSet:Recordset;
FFirstRead:boolean;
function GetValue(Idx:OleVariant):OleVariant;
function IsEof:boolean;
public
constructor Create(Connection: TADOLink; const SQL: WideString;
const Values: array of Variant); overload;
constructor Create(Recordset: Recordset); overload;
destructor Destroy; override;
procedure Reset;
procedure CheckResultSet;//use with multiple resultsets (e.g. when calling stored procedure)
function Read:boolean;
property Fields[Idx:OleVariant]:OleVariant read GetValue; default;
property EOF: boolean read IsEof;
function GetInt(const Idx:OleVariant):integer;
function GetStr(const Idx:OleVariant):WideString;
function GetDate(const Idx:OleVariant):TDateTime;
function IsNull(const Idx:OleVariant):boolean;
function GetDefault(const Idx,Default:OleVariant):OleVariant;
end;
EFieldNotFound=class(Exception);
ESingleValueFailed=class(Exception);
implementation
uses Variants, Classes, ComObj;
procedure CmdParameters(Cmd:Command;const Values:array of Variant);
var
i:integer;
vt:TVarType;
begin
for i:=0 to Length(Values)-1 do
begin
vt:=VarType(Values[i]);
if (vt=varNull) or (vt=varString) or (vt=varOleStr) then
cmd.Parameters.Append(cmd.CreateParameter('',adVariant,adParamInput,0,Values[i]))
else
cmd.Parameters.Append(cmd.CreateParameter('',vt,adParamInput,0,Values[i]));
end;
end;
function ErrInfo(const QueryName: AnsiString; const Values: array of Variant):AnsiString;
var
i,l:integer;
begin
l:=Length(Values);
Result:='';
if l>0 then
begin
Result:=VarToStr(Values[0]);
for i:=1 to l-1 do Result:=Result+','+VarToStr(Values[i]);
end;
Result:=#13#10'"'+QueryName+'"['+Result+']';
end;
{ TADOResult }
constructor TADOResult.Create(Connection: TADOLink; const SQL: WideString;
const Values: array of Variant);
var
cmd:Command;
begin
inherited Create;
//FRecordSet:=Session.DbCon.Execute(,v,adCmdText);
FFirstRead:=true;
cmd:=CoCommand.Create;
try
cmd.CommandType:=adCmdText;
cmd.CommandText:=SQL;
cmd.Set_ActiveConnection(Connection.FConnection);
CmdParameters(cmd,Values);
FRecordset:=CoRecordset.Create;
FRecordset.CursorLocation:=adUseClient;
FRecordset.Open(cmd,EmptyParam,adOpenStatic,adLockReadOnly,0);
except
on e:Exception do
begin
e.Message:=e.Message+ErrInfo(SQL,Values);
raise;
end;
end;
end;
constructor TADOResult.Create(Recordset: Recordset);
begin
inherited Create;
FFirstRead:=true;
FRecordSet:=Recordset;//Clone?
end;
destructor TADOResult.Destroy;
begin
//FRecordSet.Close;
FRecordSet:=nil;
inherited;
end;
procedure TADOResult.Reset;
begin
FFirstRead:=true;
FRecordSet.MoveFirst;
end;
function TADOResult.GetInt(const Idx: OleVariant): integer;
var
v:OleVariant;
begin
try
//v:=FRecordSet.Fields[Idx].Value;
v:=FRecordSet.Collect[idx];
except
on e:EOleException do
if cardinal(e.ErrorCode)=$800A0CC1 then
raise EFieldNotFound.Create('GetInt: Field not found: '+VarToStr(Idx))
else
begin
//if cardinal(e.ErrorCode)=$80004005 then Connection.Close;
raise;
end;
end;
if VarIsNull(v) then Result:=0 else Result:=v;
end;
function TADOResult.GetStr(const Idx: OleVariant): WideString;
begin
try
//Result:=VarToWideStr(FRecordSet.Fields[Idx].Value);
Result:=VarToWideStr(FRecordSet.Collect[Idx]);
except
on e:EOleException do
if cardinal(e.ErrorCode)=$800A0CC1 then
raise EFieldNotFound.Create('GetStr: Field not found: '+VarToStr(Idx))
else
begin
//if cardinal(e.ErrorCode)=$80004005 then Connection.Close;
raise;
end;
end;
end;
function TADOResult.GetDate(const Idx: OleVariant): TDateTime;
var
v:OleVariant;
begin
try
//v:=FRecordSet.Fields[Idx].Value;
v:=FRecordSet.Collect[Idx];
except
on e:EOleException do
if cardinal(e.ErrorCode)=$800A0CC1 then
raise EFieldNotFound.Create('GetDate: Field not found: '+VarToStr(Idx))
else
begin
//if cardinal(e.ErrorCode)=$80004005 then Connection.Close;
raise;
end;
end;
if VarIsNull(v) then
Result:=0 //Now?
else
Result:=VarToDateTime(v);
end;
function TADOResult.GetValue(Idx: OleVariant): OleVariant;
begin
try
//Result:=FRecordSet.Fields[Idx].Value;
Result:=FRecordSet.Collect[Idx];
except
on e:EOleException do
if cardinal(e.ErrorCode)=$800A0CC1 then
raise EFieldNotFound.Create('Field not found: '+VarToStr(Idx))
else
begin
//if cardinal(e.ErrorCode)=$80004005 then Connection.Close;
raise;
end;
end;
end;
function TADOResult.GetDefault(const Idx,Default: OleVariant): OleVariant;
begin
if FRecordSet.EOF then Result:=Default else Result:=GetValue(Idx);
end;
function TADOResult.IsNull(const Idx: OleVariant): boolean;
begin
try
//Result:=VarIsNull(FRecordSet.Fields[Idx].Value);
Result:=VarIsNull(FRecordSet.Collect[Idx]);
except
on e:EOleException do
begin
if cardinal(e.ErrorCode)=$800A0CC1 then
raise EFieldNotFound.Create('IsNull: Field not found: '+VarToStr(Idx))
else
begin
//if cardinal(e.ErrorCode)=$80004005 then Connection.Close;
raise;
end;
Result:=true;//counter warning
end;
end;
end;
function TADOResult.IsEof: boolean;
begin
Result:=FRecordSet.EOF;
end;
function TADOResult.Read: boolean;
begin
if (FRecordSet=nil) or FRecordSet.EOF then Result:=false else
begin
if FFirstRead then FFirstRead:=false else FRecordSet.MoveNext;
Result:=not(FRecordSet.EOF);
end;
end;
procedure TADOResult.CheckResultSet;
var
v:OleVariant;
begin
while (FRecordSet<>nil) and (FRecordSet.State=adStateClosed) do
FRecordSet:=FRecordSet.NextRecordset(v);
FFirstRead:=true;
end;
{ TADOLink }
constructor TADOLink.Create(const ConnectionString: WideString);
begin
inherited Create;
FConnection:=CoConnection.Create;
FConnection.Open(ConnectionString,'','',0);
end;
destructor TADOLink.Destroy;
begin
try
if FConnection<>nil then FConnection.Close;
except
//ignore
end;
FConnection:=nil;
inherited;
end;
function TADOLink.SingleValue(const SQL: WideString;
const Values: array of Variant): Variant;
var
cmd:Command;
rs:Recordset;
v:OleVariant;
begin
try
cmd:=CoCommand.Create;
cmd.CommandType:=adCmdText;
cmd.CommandText:=SQL;
cmd.Set_ActiveConnection(FConnection);
CmdParameters(cmd,Values);
rs:=cmd.Execute(v,EmptyParam,0);
if rs.EOF then
raise ESingleValueFailed.Create('SingleValue did not result a value "'+SQL+'"')
else
begin
Result:=rs.Fields[0].Value;
rs.MoveNext;
if not rs.EOF then
raise ESingleValueFailed.Create('SingleValue resulted in more than one value "'+SQL+'"')
end;
except
on e:Exception do
begin
e.Message:=e.Message+ErrInfo(SQL,Values);
raise;
end;
end;
end;
function TADOLink.Execute(const SQL: WideString;
const Values: array of Variant): integer;
var
cmd:Command;
v:OleVariant;
begin
try
cmd:=CoCommand.Create;
cmd.CommandType:=adCmdText;
cmd.CommandText:=SQL;
cmd.Set_ActiveConnection(FConnection);
CmdParameters(cmd,Values);
cmd.Execute(v,EmptyParam,0);//rs:=
//while (rs<>nil) and (rs.State=adStateClosed) do rs:=rs.NextRecordset(v);
Result:=v;
except
on e:Exception do
begin
e.Message:=e.Message+ErrInfo(SQL,Values);
raise;
end;
end;
end;
function TADOLink.Insert(const TableName: WideString;
const Values: array of OleVariant; const PKFieldName: WideString=''): int64;
var
rs:Recordset;
i,l:integer;
begin
l:=Length(Values);
if (l mod 2)<>0 then
raise Exception.Create('TADOLink.Insert expects pairs of name-value');
rs:=CoRecordset.Create;
//TODO: adCmdTable and find PK? first col?
rs.Open(
'SELECT * FROM ['+TableName+'] WHERE 0=1',
FConnection,
adOpenKeyset,//?
adLockOptimistic,//adLockPessimistic?
adCmdText);
rs.AddNew(EmptyParam,EmptyParam);
for i:=0 to (l div 2)-1 do
rs.Fields[Values[i*2]].Value:=Values[i*2+1];
if PKFieldName='' then
Result:=rs.Fields[0].Value //assert primary key
else
Result:=rs.Fields[PKFieldName].Value;
rs.Update(EmptyParam,EmptyParam);
rs:=nil;
end;
procedure TADOLink.Update(const TableName: WideString;
const Values: array of OleVariant);
var
cmd:Command;
rs:Recordset;
i,l:integer;
vt:TVarType;
begin
l:=Length(Values);
if (l mod 2)<>0 then
raise Exception.Create('TADOLink.Insert expects pairs of name-value');
cmd:=CoCommand.Create;
cmd.CommandType:=adCmdText;
cmd.CommandText:='SELECT * FROM ['+TableName+'] WHERE ['+VarToStr(Values[0])+']=?';
cmd.Set_ActiveConnection(FConnection);
vt:=VarType(Values[1]);
if (vt=varNull) or (vt=varString) or (vt=varOleStr) then
cmd.Parameters.Append(cmd.CreateParameter('',adVariant,adParamInput,0,Values[1]))
else
cmd.Parameters.Append(cmd.CreateParameter('',vt,adParamInput,0,Values[1]));
rs:=CoRecordset.Create;
//TODO: adCmdTable and find PK? first col?
rs.Open(
cmd,
FConnection,
adOpenKeyset,//?
adLockOptimistic,//adLockPessimistic?
integer(adCmdUnspecified));
for i:=2 to (l div 2)-1 do
rs.Fields[Values[i*2]].Value:=Values[i*2+1];
rs.Update(EmptyParam,EmptyParam);
rs:=nil;
cmd:=nil;
end;
end.
|
unit FIToolkit.Config.Data;
interface
uses
System.SysUtils, System.Types,
FIToolkit.Commons.Types, FIToolkit.Config.FixInsight, FIToolkit.Config.Types, FIToolkit.Config.TypedDefaults,
FIToolkit.Config.Consts;
type
DefaultDeduplicate = class (TDefaultBooleanValue); //FI:C104
DefaultExcludeProjectPatterns = class (TDefaultStringArrayValue); //FI:C104
DefaultExcludeUnitPatterns = class (TDefaultStringArrayValue); //FI:C104
DefaultFixInsightExe = class (TDefaultFileNameValue); //FI:C104
DefaultMakeArchive = class (TDefaultBooleanValue); //FI:C104
DefaultNonZeroExitCodeMsgCount = class (TDefaultIntegerValue); //FI:C104
DefaultOutputDirectory = class (TDefaultStringValue); //FI:C104
DefaultOutputFileName = class (TDefaultStringValue); //FI:C104
DefaultSnippetSize = class (TDefaultIntegerValue); //FI:C104
DefaultTempDirectory = class (TDefaultStringValue); //FI:C104
TConfigData = class sealed
strict private
FCustomTemplateFileName : TAssignableFileName;
FDeduplicate : Boolean;
FExcludeProjectPatterns : TStringDynArray;
FExcludeUnitPatterns : TStringDynArray;
FFixInsightExe : TAssignableFileName;
FInputFileName : TAssignableFileName;
FMakeArchive : Boolean;
FNonZeroExitCodeMsgCount : Integer;
FOutputDirectory : TAssignableString;
FOutputFileName : TAssignableString;
FSnippetSize : Integer;
FTempDirectory : TAssignableString;
FValidate : Boolean;
FFixInsightOptions : TFixInsightOptions;
private
procedure ValidateCustomTemplateFileName(const Value : TFileName);
procedure ValidateExcludeProjectPatterns(const Value : TStringDynArray);
procedure ValidateExcludeUnitPatterns(const Value : TStringDynArray);
procedure ValidateFixInsightExe(const Value : TFileName);
procedure ValidateInputFileName(const Value : TFileName);
procedure ValidateNonZeroExitCodeMsgCount(Value : Integer);
procedure ValidateOutputDirectory(const Value : String);
procedure ValidateOutputFileName(const Value : String);
procedure ValidateSnippetSize(Value : Integer);
procedure ValidateTempDirectory(const Value : String);
function GetCustomTemplateFileName : TFileName;
function GetFixInsightExe : TFileName;
function GetInputFileName : TFileName;
function GetOutputDirectory : String;
function GetOutputFileName : String;
function GetTempDirectory : String;
procedure SetCustomTemplateFileName(Value : TFileName);
procedure SetExcludeProjectPatterns(const Value : TStringDynArray);
procedure SetExcludeUnitPatterns(const Value : TStringDynArray);
procedure SetFixInsightExe(Value : TFileName);
procedure SetInputFileName(Value : TFileName);
procedure SetNonZeroExitCodeMsgCount(Value : Integer);
procedure SetOutputDirectory(Value : String);
procedure SetOutputFileName(const Value : String);
procedure SetSnippetSize(Value : Integer);
procedure SetTempDirectory(Value : String);
public
constructor Create;
destructor Destroy; override;
[FIToolkitParam]
property CustomTemplateFileName : TFileName read GetCustomTemplateFileName write SetCustomTemplateFileName;
[FIToolkitParam, DefaultDeduplicate(DEF_CD_BOOL_DEDUPLICATE)]
property Deduplicate : Boolean read FDeduplicate write FDeduplicate;
[FIToolkitParam(STR_CFG_VALUE_ARR_DELIM_REGEX), DefaultExcludeProjectPatterns]
property ExcludeProjectPatterns : TStringDynArray read FExcludeProjectPatterns write SetExcludeProjectPatterns;
[FIToolkitParam(STR_CFG_VALUE_ARR_DELIM_REGEX), DefaultExcludeUnitPatterns]
property ExcludeUnitPatterns : TStringDynArray read FExcludeUnitPatterns write SetExcludeUnitPatterns;
[FIToolkitParam, DefaultFixInsightExe]
property FixInsightExe : TFileName read GetFixInsightExe write SetFixInsightExe;
[FIToolkitParam]
property FixInsightOptions : TFixInsightOptions read FFixInsightOptions;
[FIToolkitParam]
property InputFileName : TFileName read GetInputFileName write SetInputFileName;
[FIToolkitParam, DefaultMakeArchive(DEF_CD_BOOL_MAKE_ARCHIVE)]
property MakeArchive : Boolean read FMakeArchive write FMakeArchive;
[FIToolkitParam, DefaultNonZeroExitCodeMsgCount(DEF_CD_INT_NONZERO_EXIT_CODE_MSG_COUNT)]
property NonZeroExitCodeMsgCount : Integer read FNonZeroExitCodeMsgCount write SetNonZeroExitCodeMsgCount;
[FIToolkitParam, DefaultOutputDirectory]
property OutputDirectory : String read GetOutputDirectory write SetOutputDirectory;
[FIToolkitParam, DefaultOutputFileName(DEF_CD_STR_OUTPUT_FILENAME)]
property OutputFileName : String read GetOutputFileName write SetOutputFileName;
[FIToolkitParam, DefaultSnippetSize(DEF_CD_INT_SNIPPET_SIZE)]
property SnippetSize : Integer read FSnippetSize write SetSnippetSize;
[FIToolkitParam, DefaultTempDirectory]
property TempDirectory : String read GetTempDirectory write SetTempDirectory;
property Validate : Boolean read FValidate write FValidate;
end;
implementation
uses
System.IOUtils, System.Rtti, System.RegularExpressions, System.Math,
FIToolkit.Config.Exceptions, FIToolkit.Config.Defaults, FIToolkit.Commons.Utils;
{ TConfigData }
constructor TConfigData.Create;
begin
inherited Create;
FFixInsightOptions := TFixInsightOptions.Create;
end;
destructor TConfigData.Destroy;
begin
FreeAndNil(FFixInsightOptions);
inherited Destroy;
end;
function TConfigData.GetCustomTemplateFileName : TFileName;
begin
Result := FCustomTemplateFileName;
end;
function TConfigData.GetFixInsightExe : TFileName;
begin
Result := FFixInsightExe;
end;
function TConfigData.GetInputFileName : TFileName;
begin
Result := FInputFileName;
end;
function TConfigData.GetOutputDirectory : String;
begin
Result := TPath.IncludeTrailingPathDelimiter(FOutputDirectory);
end;
function TConfigData.GetOutputFileName : String;
begin
Result := FOutputFileName;
end;
function TConfigData.GetTempDirectory : String;
begin
Result := TPath.IncludeTrailingPathDelimiter(FTempDirectory);
end;
procedure TConfigData.SetCustomTemplateFileName(Value : TFileName);
begin
Value := TPath.ExpandIfNotExists(Value);
if not FCustomTemplateFileName.Assigned or (FCustomTemplateFileName <> Value) then
begin
if FValidate then
ValidateCustomTemplateFileName(Value);
FCustomTemplateFileName := Value;
end;
end;
procedure TConfigData.SetExcludeProjectPatterns(const Value : TStringDynArray);
begin
if FValidate then
ValidateExcludeProjectPatterns(Value);
FExcludeProjectPatterns := Value;
end;
procedure TConfigData.SetExcludeUnitPatterns(const Value : TStringDynArray);
begin
if FValidate then
ValidateExcludeUnitPatterns(Value);
FExcludeUnitPatterns := Value;
end;
procedure TConfigData.SetFixInsightExe(Value : TFileName);
begin
Value := TPath.ExpandIfNotExists(Value);
if not FFixInsightExe.Assigned or (FFixInsightExe <> Value) then
begin
if FValidate then
ValidateFixInsightExe(Value);
FFixInsightExe := Value;
end;
end;
procedure TConfigData.SetInputFileName(Value : TFileName);
begin
Value := TPath.ExpandIfNotExists(Value);
if not FInputFileName.Assigned or (FInputFileName <> Value) then
begin
if FValidate then
ValidateInputFileName(Value);
FInputFileName := Value;
end;
end;
procedure TConfigData.SetNonZeroExitCodeMsgCount(Value : Integer);
begin
if FValidate then
ValidateNonZeroExitCodeMsgCount(Value);
FNonZeroExitCodeMsgCount := Value;
end;
procedure TConfigData.SetOutputDirectory(Value : String);
begin
Value := TPath.ExpandIfNotExists(Value);
if not FOutputDirectory.Assigned or (FOutputDirectory <> Value) then
begin
if FValidate then
ValidateOutputDirectory(Value);
FOutputDirectory := Value;
end;
end;
procedure TConfigData.SetOutputFileName(const Value : String);
begin
if not FOutputFileName.Assigned or (FOutputFileName <> Value) then
begin
if FValidate then
ValidateOutputFileName(Value);
FOutputFileName := Value;
end;
end;
procedure TConfigData.SetSnippetSize(Value : Integer);
begin
if FValidate then
ValidateSnippetSize(Value);
FSnippetSize := Value;
end;
procedure TConfigData.SetTempDirectory(Value : String);
begin
Value := TPath.ExpandIfNotExists(Value);
if not FTempDirectory.Assigned or (TempDirectory <> Value) then
begin
if FValidate then
ValidateTempDirectory(Value);
FTempDirectory := Value;
end;
end;
procedure TConfigData.ValidateCustomTemplateFileName(const Value : TFileName);
begin
if not (Value.IsEmpty or TFile.Exists(Value)) then
raise ECDCustomTemplateFileNotFound.Create;
end;
procedure TConfigData.ValidateExcludeProjectPatterns(const Value : TStringDynArray);
var
S : String;
begin
for S in Value do
try
TRegEx.Create(S, [roNotEmpty, roCompiled]);
except
Exception.RaiseOuterException(ECDInvalidExcludeProjectPattern.CreateFmt([S]));
end;
end;
procedure TConfigData.ValidateExcludeUnitPatterns(const Value : TStringDynArray);
var
S : String;
begin
for S in Value do
try
TRegEx.Create(S, [roNotEmpty, roCompiled]);
except
Exception.RaiseOuterException(ECDInvalidExcludeUnitPattern.CreateFmt([S]));
end;
end;
procedure TConfigData.ValidateFixInsightExe(const Value : TFileName);
begin
if not TFile.Exists(Value) then
raise ECDFixInsightExeNotFound.Create;
end;
procedure TConfigData.ValidateInputFileName(const Value : TFileName);
begin
if not TFile.Exists(Value) then
raise ECDInputFileNotFound.Create;
end;
procedure TConfigData.ValidateNonZeroExitCodeMsgCount(Value : Integer);
begin
if Value < 0 then
raise ECDInvalidNonZeroExitCodeMsgCount.Create;
end;
procedure TConfigData.ValidateOutputDirectory(const Value : String);
begin
if not TDirectory.Exists(Value) then
raise ECDOutputDirectoryNotFound.Create;
end;
procedure TConfigData.ValidateOutputFileName(const Value : String);
begin
if not TPath.IsApplicableFileName(Value) then
raise ECDInvalidOutputFileName.Create;
end;
procedure TConfigData.ValidateSnippetSize(Value : Integer);
begin
if (Value <> 0) and not InRange(Value, CD_INT_SNIPPET_SIZE_MIN, CD_INT_SNIPPET_SIZE_MAX) then
raise ECDSnippetSizeOutOfRange.CreateFmt([CD_INT_SNIPPET_SIZE_MIN, CD_INT_SNIPPET_SIZE_MAX]);
end;
procedure TConfigData.ValidateTempDirectory(const Value : String);
begin
if not TDirectory.Exists(Value) then
raise ECDTempDirectoryNotFound.Create;
end;
initialization
RegisterDefaultValue(DefaultExcludeProjectPatterns, TValue.From<TStringDynArray>(DEF_CD_ARR_EXCLUDE_PROJECT_PATTERNS));
RegisterDefaultValue(DefaultExcludeUnitPatterns, TValue.From<TStringDynArray>(DEF_CD_ARR_EXCLUDE_UNIT_PATTERNS));
RegisterDefaultValue(DefaultFixInsightExe, GetFixInsightExePath);
RegisterDefaultValue(DefaultOutputDirectory, TPath.GetDocumentsPath);
RegisterDefaultValue(DefaultTempDirectory, TPath.GetTempPath);
end.
|
unit uViewInclusao;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls, ComCtrls;
type
TListaEvent = procedure of object; // Aqui é uma grande sacada pois a variável abaixo
// FDOLista recebe um procedimento do Controle sem na verdade
// conhecer o controle
// para ententer melhor veja a inicialização ( TControle.Initialize)
// do controle
TViewInclusao = class(TForm)
Panel1: TPanel;
btFechar: TButton;
btSalvar: TButton;
Panel2: TPanel;
reTitulo: TRichEdit;
Panel3: TPanel;
procedure btFecharClick(Sender: TObject);
procedure btSalvarClick(Sender: TObject);
private
FSalvar: TListaEvent;
procedure SetSalvar(const Value: TListaEvent);
{ Private declarations }
public
procedure Initialize;
property Salvar : TListaEvent read FSalvar write SetSalvar;
{ Public declarations }
end;
var
ViewInclusao: TViewInclusao;
implementation
{$R *.dfm}
procedure TViewInclusao.btFecharClick(Sender: TObject);
begin
close;
end;
procedure TViewInclusao.Initialize;
begin
end;
procedure TViewInclusao.btSalvarClick(Sender: TObject);
begin
Salvar;
Close;
end;
procedure TViewInclusao.SetSalvar(const Value: TListaEvent);
begin
FSalvar := Value;
end;
end.
|
unit taTypes;
interface
uses
System.Generics.Collections, System.SysUtils, Data.DB, System.Classes;
type
TTimePeriod = record
Start: TDateTime;
Duration: Integer;
Tags: string;
strict private
function GetFinish: TDateTime;
procedure StringsTrim(AStrings: TStrings);
procedure TagsFromStrings(AStrings: TStrings);
procedure TagsToStrings(AStrings: TStringList);
private
public
constructor Create(AStart: TDateTime; ADuration: Integer; const ATags: string);
function HasTag(ATag: string): Boolean;
function IncDuration(ASeconds: Integer; AMoveStart: Boolean): TTimePeriod;
function IncludeTags(ASource: TTimePeriod): TTimePeriod;
function RemoveTag(ATag: string): TTimePeriod;
function TimeShift(ASeconds: Integer): TTimePeriod;
property Finish: TDateTime read GetFinish;
end;
TTimePeriodList = class(TList<TTimePeriod>)
strict private
private
function GetNearestIdx(AMoment: TDateTime; out AFoundBefore: Boolean): Integer;
public
procedure MergeSequences;
procedure ApplyCorrections(ACorrections: TTimePeriodList);
procedure Check;
procedure ClearUntil(ALastStart: TDatetime);
procedure FilterByTag(ATag: string; ARemoveTag: Boolean);
/// <summary>TTimePeriodList.JustifyMidnight
/// Prevents the transition period through midnight
/// </summary>
procedure JustifyMidnight;
function ShrinkOverlapped: Boolean;
procedure TimeShift(ASeconds: Integer);
end;
implementation
uses
System.DateUtils, taGlobals, System.Types;
constructor TTimePeriod.Create(AStart: TDateTime; ADuration: Integer; const
ATags: string);
begin
Start := AStart;
Duration := ADuration;
Tags := ATags;
end;
function TTimePeriod.GetFinish: TDateTime;
begin
Result := IncSecond(Self.Start, Self.Duration);
end;
function TTimePeriod.HasTag(ATag: string): Boolean;
var
LStrings: TStringList;
LTag: string;
begin
Result := False;
LStrings := TStringList.Create();
try
TagsToStrings(LStrings);
LStrings.CaseSensitive := False;
Result := LStrings.IndexOf(ATag) >= 0;
{for LTag in LStrings do
if LTag.ToUpper=ATag.ToUpper then
Exit(True);}
finally
FreeAndNil(LStrings);
end;
end;
function TTimePeriod.IncDuration(ASeconds: Integer; AMoveStart: Boolean):
TTimePeriod;
begin
Inc(Self.Duration, ASeconds);
if AMoveStart then
Self.Start := IncSecond(Self.Start, -ASeconds);
Result := Self;
end;
function TTimePeriod.IncludeTags(ASource: TTimePeriod): TTimePeriod;
var
LSource: TStringList;
LDest: TStringList;
LTag: string;
begin
LSource := TStringList.Create();
LDest := TStringList.Create();
try
ASource.TagsToStrings(LSource);
Self.TagsToStrings(LDest);
for LTag in LSource do
if LDest.IndexOf(LTag) < 0 then
LDest.Add(LTag);
Self.TagsFromStrings(LDest);
finally
FreeAndNil(LDest);
FreeAndNil(LSource);
end;
Result := Self;
end;
function TTimePeriod.RemoveTag(ATag: string): TTimePeriod;
var
LStrings: TStringList;
LTag: string;
I: Integer;
begin
LStrings := TStringList.Create();
try
Self.TagsToStrings(LStrings);
while True do
begin
I := LStrings.IndexOf(ATag);
if I < 0 then
Break;
LStrings.Delete(I);
end;
{
for I := LStrings.Count - 1 downto 0 do
if LStrings.Strings[I].ToUpper=ATag.ToUpper then
LStrings.Delete(I);}
Self.TagsFromStrings(LStrings);
finally
FreeAndNil(LStrings);
end;
Result := Self;
end;
procedure TTimePeriod.StringsTrim(AStrings: TStrings);
var
I: Integer;
begin
for I := 0 to AStrings.Count - 1 do
begin
AStrings.Strings[I] := Trim(AStrings.Strings[I]);
AStrings.Strings[I] := StringReplace(AStrings.Strings[I], ''#$00a0, '', []);
end;
end;
procedure TTimePeriod.TagsFromStrings(AStrings: TStrings);
begin
AStrings.Delimiter := ',';
Tags := AStrings.DelimitedText;
end;
procedure TTimePeriod.TagsToStrings(AStrings: TStringList);
begin
AStrings.Delimiter := ',';
AStrings.StrictDelimiter := True;
AStrings.DelimitedText := Tags;
AStrings.CaseSensitive := False;
StringsTrim(AStrings);
end;
function TTimePeriod.TimeShift(ASeconds: Integer): TTimePeriod;
begin
Self.Start := IncSecond(Self.Start, ASeconds);
Result := Self;
end;
procedure TTimePeriodList.ApplyCorrections(ACorrections: TTimePeriodList);
var
LTomatoIsBefore: Boolean;
LNearest: TTimePeriod;
LNearestIdx: Integer;
LPeriod: TTimePeriod;
begin
if ACorrections.Count = 0 then
Exit;
if Count = 0 then
begin
Add(ACorrections[0]);
ACorrections.Delete(0);
end;
for LPeriod in ACorrections do
begin
LNearestIdx := GetNearestIdx(LPeriod.Start, LTomatoIsBefore);
LNearest := Self[LNearestIdx];
LNearest := LNearest.IncDuration(LPeriod.Duration, not LTomatoIsBefore);
LNearest := LNearest.IncludeTags(LPeriod);
Self[LNearestIdx] := LNearest;
end;
end;
procedure TTimePeriodList.Check;
var
APrevFinish: TDateTime;
I: Integer;
LPeriod: TTimePeriod;
begin
I := 0;
APrevFinish := 0;
for LPeriod in Self do
begin
if APrevFinish > LPeriod.Start then
raise Exception.CreateFmt(
'TTimePeriodList.Check APrevFinish > LPeriod.Start Idx:%d %s > %s', [I,
FormatDateTime('yy-mmdd hh:nn', APrevFinish),
FormatDateTime('yy-mmdd hh:nn', LPeriod.Start)
]);
if LPeriod.Duration < 0 then
raise Exception.CreateFmt(
'TTimePeriodList.Check LPeriod.Duration < 0 Idx:%d %s > %s', [I,
FormatDateTime('yy-mmdd hh:nn', LPeriod.Start),
FormatDateTime('yy-mmdd hh:nn', LPeriod.Finish)
]);
APrevFinish := LPeriod.Finish;
Inc(I);
end;
end;
procedure TTimePeriodList.ClearUntil(ALastStart: TDatetime);
var
I: Integer;
begin
for I := Count-1 downto 0 do
begin
//if Self[I].Start <= ALastStart then //acts not correct when seconds are equal
if CompareDateTime(Self[I].Start, ALastStart) <= EqualsValue then
Delete(I);
end;
end;
procedure TTimePeriodList.FilterByTag(ATag: string; ARemoveTag: Boolean);
var
I: Integer;
begin
for I := Count-1 downto 0 do
if not Self[I].HasTag(ATag) then
Delete(I)
else if ARemoveTag then
begin
Self[I] := Self[I].RemoveTag(ATag);
end;
end;
function TTimePeriodList.GetNearestIdx(AMoment: TDateTime; out AFoundBefore:
Boolean): Integer;
var
I: Integer;
LSpan: Double;
begin
LSpan := MaxDateTime;
Result := -1;
for I := 0 to Count - 1 do
if Abs(AMoment - Self[i].Start) < LSpan then
begin
Result := I;
AFoundBefore := AMoment > Self[i].Start;
LSpan := Abs(AMoment - Self[i].Start);
end;
end;
procedure TTimePeriodList.JustifyMidnight;
var
I: Integer;
LNewPeriod: TTimePeriod;
LPeriod: TTimePeriod;
begin
for LPeriod in Self do
if DateOf(LPeriod.Start) <> DateOf(LPeriod.Finish) then
begin
LNewPeriod := TTimePeriod.Create(DateOf(LPeriod.Finish),
SecondsBetween(DateOf(LPeriod.Finish), LPeriod.Finish) + SECONDSINMINUTE,
LPeriod.Tags);
I := IndexOf(LPeriod);
Self[I] := Self[I].IncDuration(-LNewPeriod.Duration, False);
Self.Insert(I + 1, LNewPeriod);
end;
while ShrinkOverlapped do
JustifyMidnight;
end;
procedure TTimePeriodList.MergeSequences;
const
MERGEMAXSPAN = SECONDSINMINUTE * 60 * 2;
var
I: Integer;
begin
for I := Count - 2 downto 0 do
if (Self[I].Tags = Self[I + 1].Tags)
and (SecondsBetween(Self[I].Start, Self[I + 1].Start) < MERGEMAXSPAN) then
begin
Self[I] := Self[I].IncDuration(Self[I + 1].Duration, False);
Delete(I + 1);
end;
end;
function TTimePeriodList.ShrinkOverlapped: Boolean;
var
dbgTmp: TDateTime;
I: Integer;
begin
Result := False;
for I := 1 to Count - 1 do
begin
if Self[I - 1].Finish > Self[I].Start then
begin
Self[I] := Self[I].TimeShift(SecondsBetween(Self[I].Start, Self[I - 1].Finish));
Result := True;
end;
end;
end;
procedure TTimePeriodList.TimeShift(ASeconds: Integer);
var
I: Integer;
LItem: TTimePeriod;
begin
for I := 0 to Count - 1 do
begin
Self[I] := Self[I].TimeShift(ASeconds);
end;
end;
end.
|
{*******************************************************}
{ }
{ Delphi Visual Component Library }
{ Registration of Web server application and }
{ internet components }
{ }
{ Copyright(c) 1995-2011 Embarcadero Technologies, Inc. }
{ }
{*******************************************************}
unit InetWiz;
// Remove this line when WebSnap wizards use the new framework
{$DEFINE SHOWOLDWIZARDS}
interface
//uses ExptIntf, VirtIntf, InetSource, Classes;
uses InetSource, Classes, Forms;
{$IFDEF LINUX}
resourcestring
sNewWebModuleExpertName = 'Web Server Application';
sNewWebModuleExpertComment = 'Creates a new web server application';
sNewPage = 'New';
sEditURLMap = 'Action Editor...';
{$ENDIF}
type
{$IFDEF MSWINDOWS}
TProjectType = (ptISAPI, ptCGI, ptWinCGI, ptCOM, ptApache, ptApacheTwo,
ptIndyForm, ptIndyConsole);
{$ENDIF}
{$IFDEF LINUX}
TProjectType = (ptCGI, ptApache, ptCOM);
{$ENDIF}
TProjectTypes = set of TProjectType;
TWizardOption = (woUknown, woNoCrossplatformCB, woOutputToProjectDirectory, woDBXTerminateThreads);
TWizardOptions = set of TWizardOption;
{$IFDEF SHOWOLDWIZARDS}
IWebProjectCreatorExt = interface
['{5F45C5E3-5B66-4B0C-A08B-2C6A7CCF917E}']
procedure CreateModuleText(ProjectType: TProjectType;
const CoClassName: string;
const ModuleIdent, FormIdent, AncestorIdent: string;
var ModuleText, IntfText, FormText: string);
end;
IWebProjectCreatorExt3 = interface
['{60DC5444-E602-4E8F-BEF0-201B8D06D16F}']
function GetProjectFileName: string;
// procedure ValidateForm(AForm: TForm);
function HasModuleText: Boolean;
procedure BeforeCreateModule(ProjectType: TProjectType;
const CoClassName: string);
procedure AfterCreateModule(ProjectType: TProjectType;
const CoClassName: string);
function HasWebModuleFactory: Boolean;
end;
IWebWizardExt = interface(IWebProjectCreatorExt)
['{742DC18C-B219-41B7-ADA2-AE8C719FE403}']
function GetCaption: string;
function GetHelpContext: Integer;
function GetOptions: TWizardOptions;
procedure SetOptions(value: TWizardOptions);
property Options: TWizardOptions read GetOptions write SetOptions;
end;
ICustomizeForm = interface
procedure AppendFrame(AFrame: TFrame);
end;
IWebWizardExt2 = interface
['{428AC5E1-9331-4EAB-B1BB-F5521E065623}']
procedure CustomizeForm(ACustomizeForm: ICustomizeForm);
procedure ValidateForm(AForm: TForm);
end;
{$ENDIF}
// IWebWizardExt3 = interface(IWebProjectCreatorExt3)
// ['{A0BFC058-32AC-4789-9E78-75146AC814E7}']
//// function GetProjectFileName: string;
//// function HasModuleText: Boolean;
//// procedure BeforeCreateModule(ProjectType: TProjectType;
//// const CoClassName: string);
//// procedure AfterCreateModule(ProjectType: TProjectType;
//// const CoClassName: string);
//// function HasWebModuleFactory: Boolean;
// end;
{$IFDEF SHOWOLDWIZARDS}
TInetSources = class(TObject)
private
FSourceFlags: TSourceFlags;
FPropValues: TStrings;
public
property SourceFlags: TSourceFlags read FSourceFlags write FSourceFlags;
function GetInetSources(SourceIndex: TSourceIndex; const APersonality: string; APropValues: TStrings = nil): string;
constructor Create(APropValues: TStrings=nil);
destructor Destroy; override;
end;
{$ENDIF}
TCreateWebProjectOption = (wpCrossplatform, wpNamedProject, wpOutputToProjectDirectory, wbDBXTerminateThreads);
TCreateWebProjectOptions = set of TCreateWebProjectOption;
{$IFDEF SHOWOLDWIZARDS}
function ExecuteWebWizardExt(const AWebWizardExt: IWebWizardExt; const APersonality: string): Boolean;
{$ENDIF}
procedure Register;
procedure AddBCBAppUnits(AProjectType: TProjectType);
{$IFDEF SHOWOLDWIZARDS}
procedure CreateWebProject(const AWebProjectCreatorExt: IWebProjectCreatorExt; const APersonality: string; AProjectType: TProjectType;
ACoClassName: string; APort: Integer; AOptions: TCreateWebProjectOptions);
{$ENDIF}
implementation
uses {$IFDEF MSWINDOWS}HtColEdt, {$ENDIF}{$IFDEF LINUX}HtColEdtLin, {$ENDIF}
ColnEdit, LibHelp, WebConst, NetConst, Windows, Messages, SysUtils, Controls,
Dialogs, DesignIntf, DesignEditors, HTTPApp, PlatformAPI,
{$IFDEF SHOWOLDWIZARDS}
NwWebSrv,
{$ENDIF}
DMForm, Consts, IStreams, ToolsAPI, DCCStrs, CommonOptionStrs, ExpertsRepository, InetExpertsUI,
InetExpertsCreators;
{$IFDEF MSWINDOWS}
{$R *.res}
{$ENDIF}
type
{$IFDEF SHOWOLDWIZARDS}
TCreator = class(TInterfacedObject)
public
{ IOTACreator }
function GetExisting: Boolean;
function GetFileSystem: string;
function GetOwner: IOTAModule;
function GetUnnamed: Boolean;
end;
TProjectCreator = class(TCreator, IOTACreator, IOTAProjectCreator, IOTAProjectCreator80
(*,IOTAProjectCreator50*))
private
(*
FPartial: Boolean;
FDescription: string;
FName: string;
FIdent: string;
*)
private
//constructor Create(APartial: Boolean; const ADescription, AName, AIdent: string); overload;
//constructor Create(const ACreatorType: string); overload;
FPersonality: string;
property Personality: string read FPersonality;
{ IOTACreator }
function GetCreatorType: string;
{ IOTAProjectCreator80 }
function GetProjectPersonality: string;
{ IOTAProjectCreator }
function GetFileName: string;
function GetOptionFileName: string;
function GetShowSource: Boolean;
procedure NewDefaultModule;
function NewOptionSource(const ProjectName: string): IOTAFile;
procedure NewProjectResource(const Project: IOTAProject);
function NewProjectSource(const ProjectName: string): IOTAFile;
{ IOTAProjectCreator50 }
procedure NewDefaultProjectModule(const Project: IOTAProject);
public
constructor Create(const APersonality: string);
end;
TWebProjectCreator = class(TProjectCreator, IOTACreator, IOTAProjectCreator,
IOTAProjectCreator160)
private
FProjectType: TProjectType;
FCoClass: string;
FPort: Integer;
FOptions: TCreateWebProjectOptions;
{ IOTACreator }
function GetCreatorType: string;
{ IOTAProjectCreator }
function NewProjectSource(const ProjectName: string): IOTAFile;
procedure NewDefaultModule;
function GetFileName: string;
{ IExtendedSourceCreator }
function GetFileSystem: string;
function GetUnNamed: Boolean;
procedure SetOutputToProjectDirectory;
{ IOTAProjectCreator160 }
function GetFrameworkType: string;
function GetPlatforms: TArray<string>;
function GetPreferredPlatform: string;
procedure SetInitialOptions(const NewProject: IOTAProject);
public
constructor Create(ProjectType: TProjectType; const APersonality: string; AOptions: TCreateWebProjectOptions); overload;
constructor Create(const CoClass: string; const APersonality: string; AOptions: TCreateWebProjectOptions); overload;
constructor Create(ProjectType: TProjectType; const APersonality: string; APort: Integer; AOptions: TCreateWebProjectOptions); overload;
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
TModuleCreator = class(TCreator, IOTACreator, IOTAModuleCreator)
(*
private
FProject: IOTAProject;
FPartial: Boolean;
FDescription: string;
FName: string;
FIdent: string;
FSourceTemplate: string;
*)
private
{ IOTACreator }
function GetCreatorType: string;
function GetOwner: IOTAModule;
{ IOTAModuleCreator }
function GetAncestorName: string;
function GetImplFileName: string;
function GetIntfFileName: string;
function GetFormName: string;
function GetMainForm: Boolean;
function GetShowForm: Boolean;
function GetShowSource: Boolean;
function NewFormFile(const FormIdent, AncestorIdent: string): IOTAFile;
function NewImplSource(const ModuleIdent, FormIdent, AncestorIdent: string): IOTAFile;
function NewIntfSource(const ModuleIdent, FormIdent, AncestorIdent: string): IOTAFile;
procedure FormCreated(const FormEditor: IOTAFormEditor);
public
(*
constructor Create;
const ADescription, AName, AIdent: string); *)
end;
TFormModuleCreator = class(TModuleCreator, IOTAModuleCreator)
private
FCoClass: string;
FPersonality: string;
FProjectType: TProjectType;
FSourceIndex: TSourceIndex;
FIntfIndex: TSourceIndex;
FFormIndex: TSourceIndex;
FPort: Integer;
FOptions: TCreateWebProjectOptions;
{ IOTAModuleCreator }
function GetAncestorName: string;
function NewImplSource(const ModuleIdent, FormIdent, AncestorIdent: string): IOTAFile;
function NewIntfSource(const ModuleIdent, FormIdent, AncestorIdent: string): IOTAFile;
function NewFormFile(const FormIdent, AncestorIdent: string): IOTAFile;
function GetSource(AIndex: TSourceIndex): string;
property Personality: string read FPersonality;
public
constructor Create(const APersonality: string; AProjectType: TProjectType; const ACoClass: string;
APort: integer; AOptions: TCreateWebProjectOptions);
end;
TWebModuleCreator = class(TModuleCreator, IOTAModuleCreator)
private
FCoClass: string;
FProjectType: TProjectType;
FPersonality: string;
{ IOTAModuleCreator }
function GetAncestorName: string;
function NewImplSource(const ModuleIdent, FormIdent, AncestorIdent: string): IOTAFile;
function NewIntfSource(const ModuleIdent, FormIdent, AncestorIdent: string): IOTAFile;
function NewFormFile(const FormIdent, AncestorIdent: string): IOTAFile;
property Personality: string read FPersonality;
protected
function NewImplSourceText(const ModuleIdent, FormIdent, AncestorIdent: string): string; virtual;
function NewIntfSourceText(const ModuleIdent, FormIdent, AncestorIdent: string): string; virtual;
function NewFormFileText(const FormIdent, AncestorIdent: string): string; virtual;
public
constructor Create(const APersonality: string; AProjectType: TProjectType; const ACoClass: string = '');
end;
TWebExtModuleCreator = class(TWebModuleCreator)
private
FHaveText: Boolean;
FModuleText, FIntfText, FFormText: string;
FWebWizardExt: IWebProjectCreatorExt;
protected
function NewImplSourceText(const ModuleIdent, FormIdent, AncestorIdent: string): string; override;
function NewIntfSourceText(const ModuleIdent, FormIdent, AncestorIdent: string): string; override;
function NewFormFileText(const FormIdent, AncestorIdent: string): string; override;
procedure GetText(const ModuleIdent, FormIdent, AncestorIdent: string);
public
constructor Create(const APersonality: string; AProjectType: TProjectType; const ACoClass: string;
WebWizardExt: IWebProjectCreatorExt);
end;
{$ENDIF}
TOTAFile = class(TInterfacedObject, IOTAFile)
private
FContent: string;
public
constructor Create(const AContent: string);
{ IOTAFile }
function GetSource: string;
function GetAge: TDateTime;
end;
{$IFDEF SHOWOLDWIZARDS}
{ TNewWebModuleExpert }
TNewWebModuleExpert = class(TNotifierObject, IOTANotifier, IOTAWizard,
IOTARepositoryWizard, IOTAProjectWizard, IOTARepositoryWizard80)
private
FCancelled: Boolean;
FPersonality: string;
class function GetWebWizardExt: IInterface; static;
class procedure SetWebWizardExt(const Value: IInterface); static;
property Personality: string read FPersonality;
public
class property WebWizardExt: IInterface read GetWebWizardExt write SetWebWizardExt;
class procedure CreateProject(const APersonality: string; AProjectType: TProjectType;
ACoClassName: string; APort: Integer = 8080; AOptions: TCreateWebProjectOptions = []); static;
public
constructor Create(const APersonality: string);
destructor Destroy; override;
{ IOTANotifier }
procedure Destroyed;
{ IOTAWizard }
function GetIDString: string;
function GetName: string;
procedure Execute;
{ IOTARespositoryWizard }
function GetAuthor: string;
function GetComment: string;
function GetPage: string;
function GetGlyph: Cardinal;
function GetState: TWizardState;
{ IOTARepositoryWizard80 }
function GetGalleryCategory: IOTAGalleryCategory;
function GetPersonality: string;
function GetDesigner: string;
{ Flag whether the wizard was cancelled }
property Cancelled: Boolean read FCancelled;
end;
{$ENDIF}
(*
{ TNewWebProject }
TNewWebProject = class(TIProjectCreatorEx)
private
FProjectType: TProjectType;
FCoClassName: string;
function InitProject(ProjectType: TProjectType): TIProjectCreatorEx;
function InitCOMProject(const ACoClassName: string): TIProjectCreatorEx;
public
function Existing: Boolean; override;
function GetFileName: string; override;
function GetFileSystem: string; override;
function NewProjectSource(const ProjectName: string): string; override;
procedure NewDefaultModule; override;
procedure NewProjectResource(Module: TIModuleInterface); override;
function GetOptionName: string; override;
function NewOptionSource(const ProjectName: string): string; override;
end;
{ TNewWebModule }
TNewWebModule = class(TIModuleCreatorEx)
public
function Existing: Boolean; override;
function GetAncestorName: string; override;
function GetFileName: string; override;
function GetFileSystem: string; override;
function GetFormName: string; override;
function NewModuleSource(const UnitIdent, FormIdent, AncestorIdent: string): string; override;
procedure FormCreated(Form: TIFormInterface); override;
function GetIntfName: string; override;
function NewIntfSource(const UnitIdent, FormIdent, AncestorIdent: string): string; override;
end;
{ TNewFormModule }
TNewFormModule = class(TIModuleCreatorEx)
public
function Existing: Boolean; override;
function GetAncestorName: string; override;
function GetFileName: string; override;
function GetFileSystem: string; override;
function GetFormName: string; override;
function NewModuleSource(const UnitIdent, FormIdent, AncestorIdent: string): string; override;
procedure FormCreated(Form: TIFormInterface); override;
function GetIntfName: string; override;
function NewIntfSource(const UnitIdent, FormIdent, AncestorIdent: string): string; override;
end;
*)
{ TCustomWebModule }
TCustomWebModule = class(TDataModuleCustomModule)//TDataModuleDesignerCustomModule)
procedure ExecuteVerb(Index: Integer); override;
function GetVerb(Index: Integer): string; override;
function GetVerbCount: Integer; override;
procedure ValidateComponent(Component: TComponent); override;
end;
THackPersistent = class(TPersistent);
{$IFDEF SHOWOLDWIZARDS}
var
InetSources: TInetSources;
{$ENDIF}
procedure AddBCBAppUnits(AProjectType: TProjectType);
begin
// NOTE: This is done so that the linker finds the added file _before_ any user code
// otherwise the application is not initialized correctly and the app fails.
{$IFDEF MSWINDOWS}
case AProjectType of
ptWinCGI,
ptCGI: GetActiveProject.AddFile('CGIApp.obj', False); { do not localize }
ptCOM: GetActiveProject.AddFile('SockApp.obj', False); { do not localize }
ptApache: GetActiveProject.AddFile('ApacheApp.obj', False); { do not localize }
ptApacheTwo: GetActiveProject.AddFile('ApacheTwoApp.obj', False); { do not localize }
ptISAPI: GetActiveProject.AddFile('ISAPIApp.obj', False); { do not localize }
ptIndyForm: GetActiveProject.AddFile('IdHTTPWebBrokerBridge.obj', False); { do not localize }
ptIndyConsole: GetActiveProject.AddFile('IdHTTPWebBrokerBridge.obj', False); { do not localize }
end;
{$ENDIF}
{$IFDEF LINUX}
case AProjectType of
ptCGI: GetActiveProject.AddFile('CGIApp.o', False); { do not localize }
ptApache: GetActiveProject.AddFile('ApacheApp.o', False); { do not localize }
ptCOM: GetActiveProject.AddFile('SockApp.o', False); { do not localize }
end;
{$ENDIF}
end;
{$IFDEF SHOWOLDWIZARDS}
{ TNewWebModuleExpert }
constructor TNewWebmoduleExpert.Create(const APersonality: string);
begin
inherited Create;
FPersonality := APersonality;
//NewWebModuleExpertCounter := Self;
end;
destructor TNewWebModuleExpert.Destroy;
begin
//NewWebModuleExpert := nil;
inherited Destroy;
end;
function TNewWebModuleExpert.GetName: string;
begin
Result := sNewWebModuleExpertName;
end;
function TNewWebModuleExpert.GetAuthor: string;
begin
Result := 'Embarcadero'; // do not localize
end;
function TNewWebModuleExpert.GetComment: string;
begin
Result := sNewWebModuleExpertComment;
end;
function TNewWebModuleExpert.GetPage: string;
begin
Result := sNewPage;
end;
{$IFDEF MSWINDOWS}
function TNewWebModuleExpert.GetGlyph: Cardinal;
begin
Result := LoadIcon(HInstance, 'WEBAPP');
end;
{$ENDIF}
{$IFDEF LINUX}
var
(* XPM *)
InetWizLin: array[0..41] of PChar = (
(* width height ncolors chars_per_pixel *)
'32 32 9 1',
(* colors *)
' c #000000',
'. c None',
'X c #C0C0C0',
'o c #808080',
'O c #000080',
'+ c #FFFFFF',
'@ c #008000',
'# c #808000',
'$ c #0000FF',
(* pixels *)
'................................',
'.........XXXXXXX................',
'.......XXXOOOOOOOO..............',
'......XXOOOOOOOOOOOO............',
'.....XX@OOOOOOOOOOOOO...........',
'....XXO@@@@O@@OOOO@@OO..........',
'...XXOO@###@O@@@@O@@OO..........',
'...XOOO@#@@@@@@@@@@OOOO.........',
'..XXOOO@@@#@O@@@O#@OOOO.........',
'..XOOOO@@O@@@O@@@@OOOOO.........',
'..XOOOOO@@#@@#@#@@OOOOOO........',
'..XOOOOO@#@@#@@#@OOOOOOO........',
'..XOOOOO@@#@#@#@@OOOOOOo........',
'..XOOOOOO@#@@@@@@@OOOOoo........',
'..XOOOOOOOO@#@O@@@OOOOoo........',
'...OOOOOOOOO@@@OO@OOOOo.........',
'...OOOOOOO .',
'....@OOOOO $$$$$$$$$$$$ X X X o.',
'....OOOOOO o.',
'.....OOOOO ++++++++++++++++++ o.',
'......OOOO ++++++++++++++++++ o.',
'........OO ++++++++++++++++++ o.',
'.......... ++++++++++++++++++ o.',
'.......... ++++XXXXXX+XXXXXX+ o.',
'.......... ++++X++++ +X++++ + o.',
'.......... ++++X +X + o.',
'.......... ++++++++++++++++++ o.',
'.......... o.',
'..........ooooooooooooooooooooo.',
'................................',
'................................',
'................................'
);
function TNewWebModuleExpert.GetGlyph: Cardinal;
begin
Result := Cardinal(@InetWizLin);
end;
{$ENDIF}
function TNewWebModuleExpert.GetState: TWizardState;
begin
Result := [];
end;
function TNewWebModuleExpert.GetIDString: string;
begin
Result := 'Borland.NewWebModule' + '.' + Personality; // do not localize
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
type
TCustomizeForm = class(TInterfacedObject, ICustomizeForm)
private
FForm: TNewWebAppForm;
FPrevFrame: TFrame;
constructor Create(AForm: TNewWebAppForm);
procedure AppendFrame(AFrame: TFrame);
end;
constructor TCustomizeForm.Create(AForm: TNewWebAppForm);
begin
FForm := AForm;
end;
procedure TCustomizeForm.AppendFrame(AFrame: TFrame);
var
LTop: Integer;
LMargins: TRect;
begin
LMargins.Left := FForm.Panel1.Left;
LMargins.Right := FForm.Width - (FForm.Panel1.Left + FForm.Panel1.Width);
LMargins.Top := FForm.Panel1.Top;
LMargins.Bottom := LMargins.Top;
if FPrevFrame <> nil then
begin
FPrevFrame.Anchors := FPrevFrame.Anchors - [TAnchorKind.akBottom];
LTop := FPrevFrame.Top + FPrevFrame.Height + LMargins.Top;
end
else
begin
FForm.Panel1.Anchors := FForm.Panel1.Anchors - [TAnchorKind.akBottom];
LTop := FForm.Panel1.Top + FForm.Panel1.Height + LMargins.Top;
end;
FForm.Height := FForm.Height + AFrame.Height + LMargins.Top;
FPrevFrame := AFrame;
FForm.InsertControl(AFrame);
if AFrame.Width > FForm.Panel1.Width then
FForm.Width := FForm.Width + AFrame.Width - FForm.Panel1.Width;
AFrame.Top := LTop;
AFrame.Left := LMargins.Left;
AFrame.Width := FForm.Panel1.Width;
AFrame.Anchors := [TAnchorKind.akLeft, TAnchorKind.akRight, TAnchorKind.akTop];
AFrame.TabOrder := FForm.OKButton.TabOrder;
FForm.OKButton.TabOrder := FForm.OKButton.TabOrder + 1;
FForm.CancelButton.TabOrder := FForm.CancelButton.TabOrder + 1;
FForm.HelpButton.TabOrder := FForm.HelpButton.TabOrder + 1;
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
procedure TNewWebModuleExpert.Execute;
var
LWebWizardExt: IWebWizardExt;
LWebWizardExt2: IWebWizardExt2;
LNewWebAppForm: TNewWebAppForm;
LCreateWebProjectOptions: TCreateWebProjectOptions;
begin
LNewWebAppForm := TNewWebAppForm.Create(Application);
if Supports(WebWizardExt, IWebWizardExt2, LWebWizardExt2) then
LNewWebAppForm.ValidateProcedure :=
procedure
begin
LWebWizardExt2.ValidateForm(LNewWebAppForm);
end;
LCreateWebProjectOptions := [];
Supports(WebWizardExt, IWebWizardExt, LWebWizardExt);
with LNewWebAppForm do
try
if Assigned(LWebWizardExt) then
begin
Caption := LWebWizardExt.GetCaption;
HelpContext := LWebWizardExt.GetHelpContext;
{ Here the Wizard extension does not want cross-platform abilities }
if woNoCrossPlatformCB in LWebWizardExt.Options then
begin
cbCrossPlatform.Visible := False;
cbCrossPlatform.Checked := False;
end;
if woOutputToProjectDirectory in LWebWizardExt.Options then
Include(LCreateWebProjectOptions, wpOutputToProjectDirectory);
if woDBXTerminateThreads in LWebWizardExt.Options then
Include(LCreateWebProjectOptions, wbDBXTerminateThreads);
if Supports(WebWizardExt, IWebWizardExt2, LWebWizardExt2) then
LWebWizardExt2.CustomizeForm(TCustomizeForm.Create(LNewWebAppForm));
end;
FCancelled := True;
if ShowModal = mrOK then
begin
// if cbCrossPlatform.checked then
// InetSources.SourceFlags := sfClx
// else
// InetSources.SourceFlags := sfVcl;
// try
// FCancelled := False;
// if CreateNewApacheApp.Checked then
// (BorlandIDEServices as IOTAModuleServices).CreateModule(
// TWebProjectCreator.Create(ptApache, Personality))
// else if CreateNewCOMWebApp.Checked then
// (BorlandIDEServices as IOTAModuleServices).CreateModule(
// TWebProjectCreator.Create(CoClassName.Text, Personality))
// else if CreateNewCGIApp.Checked then
// (BorlandIDEServices as IOTAModuleServices).CreateModule(
// TWebProjectCreator.Create(ptCGI, Personality))
//{$IFDEF MSWINDOWS}
// else if CreateNewApacheTwoApp.Checked then
// (BorlandIDEServices as IOTAModuleServices).CreateModule(
// TWebProjectCreator.Create(ptApacheTwo, Personality))
// else if CreateNewISAPIApp.Checked then
// (BorlandIDEServices as IOTAModuleServices).CreateModule(
// TWebProjectCreator.Create(ptISAPI, Personality))
// else if CreateNewIndyConsoleApp.Checked then
// (BorlandIDEServices as IOTAModuleServices).CreateModule(
// TWebProjectCreator.Create(ptIndyConsole, Personality))
// else if CreateNewIndyVCLApp.Checked then
// (BorlandIDEServices as IOTAModuleServices).CreateModule(
// TWebProjectCreator.Create(ptIndyForm, Personality))
//{$ENDIF}
// finally
// InetSources.SourceFlags := sfActiveDesigner;
// end;
CreateProject(Personality, ProjectType, CoClassName.Text, 8080, LCreateWebProjectOptions); //cbCrossPlatform.checked);
end;
finally
Free;
end;
end;
class procedure TNewWebModuleExpert.CreateProject(const APersonality: string; AProjectType: TProjectType; ACoClassName: string;
APort: Integer; AOptions: TCreateWebProjectOptions);
begin
if wpCrossplatform in AOptions then
InetSources.SourceFlags := sfClx
else
InetSources.SourceFlags := sfVcl;
try
case AProjectType of
ptISAPI:
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebProjectCreator.Create(ptISAPI, APersonality, AOptions));
ptCGI:
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebProjectCreator.Create(ptCGI, APersonality, AOptions));
ptCOM:
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebProjectCreator.Create(ACoClassName, APersonality, AOptions));
ptApache:
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebProjectCreator.Create(ptApache, APersonality, AOptions));
ptApacheTwo:
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebProjectCreator.Create(ptApacheTwo, APersonality, AOptions));
ptIndyForm:
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebProjectCreator.Create(ptIndyForm, APersonality, APort, AOptions));
ptIndyConsole:
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebProjectCreator.Create(ptIndyConsole, APersonality, APort, AOptions));
end;
finally
InetSources.SourceFlags := sfActiveDesigner;
end;
end;
procedure TNewWebModuleExpert.Destroyed;
begin
WebWizardExt := nil;
end;
function TNewWebModuleExpert.GetDesigner: string;
begin
Result := dVCL;
end;
function TNewWebModuleExpert.GetGalleryCategory: IOTAGalleryCategory;
begin
Result := nil;
end;
function TNewWebModuleExpert.GetPersonality: string;
begin
Result := Personality;
end;
var
FStaticWebWizardExt: IInterface;
class function TNewWebModuleExpert.GetWebWizardExt: IInterface;
begin
Result := FStaticWebWizardExt;
end;
class procedure TNewWebModuleExpert.SetWebWizardExt(const Value: IInterface);
begin
FStaticWebWizardExt := Value;
end;
{$ENDIF}
{ TCustomWebModule }
procEdure TCustomWebModule.ExecuteVerb(Index: Integer);
begin
if Index = 0 then
begin
ShowCollectionEditor({TForm(Root.Owner).}Designer, Root,
TCustomWebDispatcher(Root).Actions, 'Actions');
end;
end;
function TCustomWebModule.GetVerb(Index: Integer): string;
begin
if Index = 0 then
Result := sEditURLMap
else Result := '';
end;
function TCustomWebModule.GetVerbCount: Integer;
begin
Result := 1;
end;
procedure TCustomWebModule.ValidateComponent(Component: TComponent);
begin
if (Component = nil) or (Component is TControl) then
raise Exception.CreateRes(@SControlInWebModule);
end;
{$IFDEF SHOWOLDWIZARDS}
{ TInetSources }
constructor TInetSources.Create(APropValues: TStrings);
begin
if APropValues <> nil then
FPropValues := APropValues
else
FPropValues := TStringList.Create;
FSourceFlags := sfActiveDesigner;
end;
destructor TInetSources.Destroy;
begin
FPropValues.Free;
inherited;
end;
function TInetSources.GetInetSources(
SourceIndex: TSourceIndex; const APersonality: string; APropValues: TStrings): string;
var
S: TStrings;
begin
S := TStringList.Create;
try
S.Assign(FPropValues);
S.Add(SourceTypeNames[SourceIndex] + '=TRUE'); // Do not localize
if APropValues <> nil then
S.AddStrings(APropValues);
Result := GetSourceFromTemplate(WebModFileName(APersonality), S, SourceFlags);
finally
S.Free;
end;
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
function ExecuteWebWizardExt(const AWebWizardExt: IWebWizardExt; const APersonality: string): Boolean;
var
NewWebModuleExpert: TNewWebModuleExpert;
Counter: IInterface;
begin
NewWebModuleExpert := TNewWebModuleExpert.Create(APersonality);
Counter := NewWebModuleExpert as IInterface;
TNewWebModuleExpert.WebWizardExt := AWebWizardExt;
try
NewWebModuleExpert.Execute;
finally
TNewWebModuleExpert.WebWizardExt := nil;
end;
Result := not NewWebModuleExpert.Cancelled;
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
procedure CreateWebProject(const AWebProjectCreatorExt: IWebProjectCreatorExt; const APersonality: string; AProjectType: TProjectType;
ACoClassName: string; APort: Integer; AOptions: TCreateWebProjectOptions);
begin
TNewWebModuleExpert.WebWizardExt := AWebProjectCreatorExt;
try
TNewWebModuleExpert.CreateProject(APersonality, AProjectType, ACoClassName, APort, AOptions);
finally
TNewWebModuleExpert.WebWizardExt := nil;
end;
end;
{ TCreator }
function TCreator.GetExisting: Boolean;
begin
Result := False;
end;
function TCreator.GetFileSystem: string;
begin
Result := '';
end;
function TCreator.GetOwner: IOTAModule;
begin
Result := nil;
end;
function TCreator.GetUnnamed: Boolean;
begin
Result := True;
end;
{$ENDIF}
{ TModuleCreator }
(*
constructor TModuleCreator.Create(const AProject: IOTAProject; APartial: Boolean;
const ADescription, AName, AIdent: string);
begin
FProject := AProject;
FPartial := APartial;
FDescription := ADescription;
FName := AName;
FIdent := AIdent;
FSourceTemplate := PChar(LockResource(LoadResource(HInstance,
FindResource(HInstance, 'KEYBINDINGSOURCE', RT_RCDATA))));
end;
*)
(*
constructor TModuleCreator.Create(const AProject: IOTAProject);
begin
FProject := AProject;
end;
*)
{$IFDEF SHOWOLDWIZARDS}
procedure TModuleCreator.FormCreated(const FormEditor: IOTAFormEditor);
begin
end;
function TModuleCreator.GetAncestorName: string;
begin
Result := '';
end;
function TModuleCreator.GetCreatorType: string;
begin
Result := sForm;
end;
function TModuleCreator.GetFormName: string;
begin
Result := '';
end;
function TModuleCreator.GetImplFileName: string;
begin
Result := '';
end;
function TModuleCreator.GetIntfFileName: string;
begin
Result := '';
end;
function TModuleCreator.GetMainForm: Boolean;
begin
Result := False;
end;
function TModuleCreator.GetOwner: IOTAModule;
begin
Result := GetActiveProject;
end;
function TModuleCreator.GetShowForm: Boolean;
begin
Result := True;
end;
function TModuleCreator.GetShowSource: Boolean;
begin
Result := True;
end;
function TModuleCreator.NewFormFile(const FormIdent, AncestorIdent: string): IOTAFile;
begin
Result := nil;
end;
const
BindingTypes: array[Boolean] of string = (
'btComplete', 'btPartial');
function TModuleCreator.NewImplSource(const ModuleIdent, FormIdent,
AncestorIdent: string): IOTAFile;
begin
Result := nil;
end;
function TModuleCreator.NewIntfSource(const ModuleIdent, FormIdent,
AncestorIdent: string): IOTAFile;
begin
Result := nil;
end;
{$ENDIF}
{ TProjectCreator }
(*
constructor TProjectCreator.Create(APartial: Boolean; const ADescription,
AName, AIdent: string);
begin
inherited Create;
FPartial := APartial;
FDescription := ADescription;
FName := AName;
FIdent := AIdent;
end;
constructor TProjectCreator.Create(const ACreatorType: string);
begin
FCreatorType := ACreatorType;
end;
function TProjectCreator.GetCreatorType: string;
begin
Result := FCreatorType;
end;
*)
{$IFDEF SHOWOLDWIZARDS}
constructor TProjectCreator.Create(const APersonality: string);
begin
FPersonality := APersonality;
end;
function TProjectCreator.GetCreatorType: string;
begin
Result := '';
end;
function TProjectCreator.GetFileName: string;
begin
Result := '';
end;
function TProjectCreator.GetOptionFileName: string;
begin
Result := '';
end;
function TProjectCreator.GetProjectPersonality: string;
begin
Result := Personality;
end;
function TProjectCreator.GetShowSource: Boolean;
begin
Result := True;
end;
procedure TProjectCreator.NewDefaultModule;
begin
end;
procedure TProjectCreator.NewDefaultProjectModule(const Project: IOTAProject);
begin
NewDefaultModule;
end;
function TProjectCreator.NewOptionSource(const ProjectName: string): IOTAFile;
begin
Result := nil;
end;
procedure TProjectCreator.NewProjectResource(const Project: IOTAProject);
begin
{ do nothing here }
end;
function TProjectCreator.NewProjectSource(const ProjectName: string): IOTAFile;
begin
Result := nil;
end;
{$ENDIF}
{ TOTAFile }
constructor TOTAFile.Create(const AContent: string);
begin
FContent := AContent;
end;
function TOTAFile.GetAge: TDateTime;
begin
Result := -1;
end;
function TOTAFile.GetSource: string;
begin
Result := FContent;
end;
{ Register procedure }
procedure RegisterWebProjectWizard(const APersonality: string);
begin
RegisterPackageWizard(TExpertsRepositoryProjectWizardWithProc.Create(APersonality,
sNewWebModuleExpertComment, sNewWebModuleExpertName, 'Borland.NewWebModule', // do not localize
sNewPage,
'Embarcadero', // do not localize
procedure
var
LUIModule: TInetExpertsUIModule;
begin
LUIModule := TInetExpertsUIModule.Create(nil);
try
LUIModule.WebServerProjectWizard.Execute(
procedure
var
LModule: TInetExpertsCreatorsModule;
begin
LModule := TInetExpertsCreatorsModule.Create(nil);
try
// Set personality so the correct template files are used
LModule.Personality := APersonality;
// Indicate which type of project to create
LModule.ProjectType := LUIModule.ProjectType;
// Indicate port
LModule.HTTPPort := LUIModule.HTTPPort;
LModule.HTTPS := LUIModule.HTTPS;
LModule.CertFileInfo := LUIModule.CertFileInfo;
LModule.WebProject.CreateProject(APersonality);
finally
LModule.Free;
end;
end);
finally
LUIModule.Free;
end;
end,
function: Cardinal
begin
Result := LoadIcon(HInstance, 'WEBAPP')
end,
TArray<string>.Create(cWin32Platform, cWin64Platform),
TArray<string>.Create()
) as IOTAWizard);
end;
procedure Register;
begin
RegisterCustomModule(TWebModule, TCustomWebModule);
RegisterWebProjectWizard(sDelphiPersonality);
RegisterWebProjectWizard(sCBuilderPersonality);
end;
{$IFDEF SHOWOLDWIZARDS}
procedure InitWeb;
begin
InetSources := TInetSources.Create;
end;
procedure DoneWeb;
begin
//NewWebModuleExpertCounter := nil;
FreeAndNil(InetSources);
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
{ TWebProjectCreator }
constructor TWebProjectCreator.Create(ProjectType: TProjectType; const APersonality: string; AOptions: TCreateWebProjectOptions);
begin
inherited Create(APersonality);
FOptions := AOptions;
FProjectType := ProjectType;
end;
constructor TWebProjectCreator.Create(const CoClass: string; const APersonality: string; AOptions: TCreateWebProjectOptions);
begin
FCoClass := CoClass;
Create(ptCOM, APersonality, AOptions);
end;
constructor TWebProjectCreator.Create(ProjectType: TProjectType; const APersonality: string; APort: Integer; AOptions: TCreateWebProjectOptions);
begin
FPort := APort;
Create(ProjectType, APersonality, AOptions);
end;
function TWebProjectCreator.GetCreatorType: string;
begin
case FProjectType of
ptISAPI: Result := sLibrary;
ptCGI: Result := sConsole;
ptCOM: Result := sApplication;
ptApache: Result := sLibrary;
ptApacheTwo: Result := sLibrary;
ptIndyForm: Result := sApplication;
ptIndyConsole: Result := sConsole;
else
Assert(False);
end;
{ 253813: By default C++ creates unmanaged dll's. Web projects need a managed
main source file }
if (Result = sLibrary) and (FPersonality = sCBuilderPersonality) then
Result := ToolsAPI.sCppManagedDll;
end;
function TWebProjectCreator.NewProjectSource(const ProjectName: string): IOTAFile;
var
Source, AppType: string;
SourceIndex: TSourceIndex;
LWebWizardExt3: IWebProjectCreatorExt3;
LSetWebModule: Boolean;
LPropValues: TStrings;
begin
case FProjectType of
{$IFDEF MSWINDOWS}
ptISAPI: SourceIndex := stISAPISource;
ptWinCGI: SourceIndex := stWinCGISource;
ptApacheTwo: SourceIndex := stApacheTwo;
ptIndyForm: SourceIndex := stIndyFormProjectSource;
ptIndyConsole: SourceIndex := stIndyConsoleProjectSource;
{$ENDIF}
ptCGI: SourceIndex := stCGISource;
ptApache: SourceIndex := stApache;
ptCOM: SourceIndex := stCOMProjectSource;
else
SourceIndex := stCGISource;
end;
case FProjectType of
ptCGI, ptIndyConsole:
AppType := 'CONSOLE'
else
AppType := 'GUI';
end;
// Always set webmodule class in project file unless WebSnap
LSetWebModule := True;
if Supports(TNewWebModuleExpert.WebWizardExt, IWebProjectCreatorExt3, LWebWizardExt3) then
if LWebWizardExt3.HasWebModuleFactory then
LSetWebModule := False;
LPropValues := TStringList.Create;
try
if LSetWebModule then
begin
LPropValues.Add('SetWebModuleClass=TRUE');
end;
LPropValues.Add('HTTPPort=' + IntToStr(FPort));
if wbDBXTerminateThreads in FOptions then
LPropValues.Add('DBXTerminateThreads=TRUE');
Source := InetSources.GetInetSources(SourceIndex, Personality, LPropValues);
finally
LPropValues.Free;
end;
Result := TOTAFile.Create(Format(Source, [ProjectName, AppType, '']));
end;
procedure TWebProjectCreator.NewDefaultModule;
var
LWebWizardExt3: IWebProjectCreatorExt3;
LWebWizardExt: IWebProjectCreatorExt;
begin
{ Create Form of ComApp }
if (FProjectType = ptCOM) or (FProjectType = ptIndyForm) then
begin
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TFormModuleCreator.Create(Personality, FProjectType, FCoClass, FPort, FOptions))
end;
// Check for extensions that handle their own module creation
if not Assigned(TNewWebModuleExpert.WebWizardExt) then
begin
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebModuleCreator.Create(Personality, FProjectType, FCoClass))
end
else
begin
// Let module that plug in an extension interface handle their
// own Web Module creation
Supports(TNewWebModuleExpert.WebWizardExt, IWebProjectCreatorExt3, LWebWizardExt3);
if LWebWizardExt3 <> nil then
LWebWizardExt3.BeforeCreateModule(FProjectType, FCoClass);
if (LWebWizardExt3 = nil) or LWebWizardExt3.HasModuleText then
begin
Supports(TNewWebModuleExpert.WebWizardExt, IWebProjectCreatorExt, LWebWizardExt);
(BorlandIDEServices as IOTAModuleServices).CreateModule(
TWebExtModuleCreator.Create(Personality, FProjectType, FCoClass, LWebWizardExt));
end;
if LWebWizardExt3 <> nil then
LWebWizardExt3.AfterCreateModule(FProjectType, FCoClass);
end;
if wpOutputToProjectDirectory in FOptions then
begin
SetOutputToProjectDirectory;
end;
end;
procedure TWebProjectCreator.SetInitialOptions(const NewProject: IOTAProject);
begin
NewProject.ProjectOptions.Values[CommonOptionStrs.sUsingDelphiRTL] := True;
end;
procedure TWebProjectCreator.SetOutputToProjectDirectory;
const
cOutputDir = 'OutputDir';
cFinalOutputDir = 'FinalOutputDir';
var
LProject: IOTAProject;
LProjectConfigurations: IOTAProjectOptionsConfigurations;
LConfiguration: IOTABuildConfiguration;
begin
// Executable must be in same directory as static files files, like html
LProject := GetActiveProject;
LProject.ProjectOptions.Values[cOutputDir] := '.';
LProject.ProjectOptions.Values[cFinalOutputDir] := '.';
if Supports(LProject.ProjectOptions, IOTAProjectOptionsConfigurations, LProjectConfigurations) then
begin
LConfiguration := LProjectConfigurations.BaseConfiguration;
if LConfiguration <> nil then
begin
LConfiguration.Value[DCCStrs.sExeOutput] := '.';
LConfiguration.Value[CommonOptionStrs.sFinalOutputDir] := '.';
end;
end;
end;
function TWebProjectCreator.GetFileName: string;
var
LWebWizardExt3: IWebProjectCreatorExt3;
begin
Supports(TNewWebModuleExpert.WebWizardExt, IWebProjectCreatorExt3, LWebWizardExt3);
if (LWebWizardExt3 = nil) then
Result := ''
else
Result := LWebWizardExt3.GetProjectFileName;
end;
function TWebProjectCreator.GetFileSystem: string;
begin
Result := '';
end;
function TWebProjectCreator.GetFrameworkType: string;
begin
if FProjectType in [ptCOM, ptIndyForm] then
Result := sFrameworkTypeVCL
else
Result := sFrameworkTypeNone;
end;
function TWebProjectCreator.GetPlatforms: TArray<string>;
begin
if FPersonality = sCBuilderPersonality then
Result := TArray<string>.Create(cWin32Platform)
else if FPersonality = sDelphiPersonality then
Result := TArray<string>.Create(cWin32Platform, cWin64Platform);
end;
function TWebProjectCreator.GetPreferredPlatform: string;
begin
Result := cWin32Platform;
end;
function TWebProjectCreator.GetUnNamed: Boolean;
begin
Result := not (wpNamedProject in FOptions);
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
{ TFormModuleCreator }
constructor TFormModuleCreator.Create(const APersonality: string; AProjectType: TProjectType;
const ACoClass: string; APort: Integer; AOptions: TCreateWebProjectOptions);
begin
FPort := APort;
FCoClass := ACoClass;
FPersonality := APersonality;
FProjectType := AProjectType;
FFormIndex := stUnknown;
FOptions := AOptions;
case FProjectType of
ptCOM:
begin
FSourceIndex := stCOMConsoleSource;
FIntfIndex := stComConsoleIntf;
end;
ptIndyForm:
begin
FSourceIndex := stIndyFormConsoleSource;
FIntfIndex := stIndyFormConsoleIntf;
FFormIndex := stIndyFormConsoleDFMSource;
end
else
FSourceIndex := stCOMConsoleSource;
FIntfIndex := stComConsoleIntf;
Assert(False);
end;
end;
function TFormModuleCreator.GetAncestorName: string;
begin
Result := 'Form'; // Do not localize
end;
function TFormModuleCreator.GetSource(AIndex: TSourceIndex): string;
var
LPropValues: TStrings;
begin
LPropValues := TStringList.Create;
try
LPropValues.Add('HTTPPort=' + IntToStr(FPort));
if wbDBXTerminateThreads in FOptions then
LPropValues.Add('DBXTerminateThreads=TRUE');
Result := InetSources.GetInetSources(AIndex, Personality, LPropValues);
finally
LPropValues.Free;
end;
end;
function TFormModuleCreator.NewImplSource(const ModuleIdent, FormIdent,
AncestorIdent: string): IOTAFile;
var
Source: String;
S: string;
begin
if not IsPascal(Personality) then // AddBCBAppUnits called elsewhere for other project types
AddBCBAppUnits(FProjectType);
//Source := InetSources.GetInetSources(FSourceIndex, Personality, LPorts);
Source := GetSource(FSourceIndex);
S := Format(Source, [ModuleIdent, FormIdent, AncestorIdent, FCoClass]);
Result := TOTAFile.Create(S);
end;
function TFormModuleCreator.NewIntfSource(const ModuleIdent, FormIdent,
AncestorIdent: string): IOTAFile;
var
S: string;
begin
if not IsPascal(Personality) then
begin
//S := InetSources.GetInetSources(FIntfIndex, Personality);
S := GetSource(FIntfIndex);
Result := TOTAFile.Create(Format(S, [ModuleIdent, FormIdent, AncestorIdent]));
end
else
Result := nil;
end;
function TFormModuleCreator.NewFormFile(const FormIdent, AncestorIdent: string): IOTAFile;
var
S: string;
begin
if FFormIndex <> stUnknown then
begin
//S := InetSources.GetInetSources(FFormIndex, Personality);
S := GetSource(FFormIndex);
Result := TOTAFile.Create(Format(S, [FormIdent, AncestorIdent]));
end
else
Result := nil;
end;
{$ENDIF}
{$IFDEF SHOWOLDWIZARDS}
{ TWebModuleCreator }
constructor TWebModuleCreator.Create(const APersonality: string; AProjectType: TProjectType; const ACoClass: string = '');
begin
FProjectType := AProjectType;
FPersonality := APersonality;
FCoClass := ACoClass;
Assert((FCoClass = '') or (FProjectType = ptCom));
end;
function TWebModuleCreator.GetAncestorName: string;
begin
Result := 'WebModule';
end;
function TWebModuleCreator.NewImplSourceText(const ModuleIdent, FormIdent,
AncestorIdent: string): string;
var
Source: string;
begin
Source := InetSources.GetInetSources(stWebModuleSource, Personality);
Result := Format(Source, [ModuleIdent, FormIdent, AncestorIdent]);
end;
function TWebModuleCreator.NewImplSource(const ModuleIdent, FormIdent,
AncestorIdent: string): IOTAFile;
begin
if not IsPascal(Personality) then
if FProjectType <> ptCOM then
AddBCBAppUnits(FProjectType);
Result := TOTAFile.Create(NewImplSourceText(ModuleIdent, FormIdent, AncestorIdent));
end;
function TWebModuleCreator.NewIntfSourceText(const ModuleIdent, FormIdent,
AncestorIdent: string): string;
var
S: string;
begin
S := InetSources.GetInetSources(stWebModuleIntf, Personality);
if Trim(S) <> '' then
Result := Format(S, [ModuleIdent, FormIdent, AncestorIdent])
else Result := '';
end;
function TWebModuleCreator.NewIntfSource(const ModuleIdent, FormIdent,
AncestorIdent: string): IOTAFile;
var
S: string;
begin
S := NewIntfSourceText(ModuleIdent, FormIdent, AncestorIdent);
if Trim(S) <> '' then
Result := TOTAFile.Create(S)
else Result := nil;
end;
function TWebModuleCreator.NewFormFile(const FormIdent,
AncestorIdent: string): IOTAFile;
var
S: string;
begin
S := NewFormFileText(FormIdent, AncestorIdent);
if S <> '' then
Result := TOTAFile.Create(S)
else
Result := nil;
end;
function TWebModuleCreator.NewFormFileText(const FormIdent,
AncestorIdent: string): string;
var
Source: string;
begin
Source := InetSources.GetInetSources(stWebModuleDFMSource, Personality);
Result := Format(Source, [FormIdent, AncestorIdent]);
end;
{ TWebExtModuleCreator }
constructor TWebExtModuleCreator.Create(const APersonality: string; AProjectType: TProjectType;
const ACoClass: string; WebWizardExt: IWebProjectCreatorExt);
begin
inherited Create(APersonality, AProjectType, ACoClass);
FWebWizardExt := WebWizardExt;
end;
procedure TWebExtModuleCreator.GetText(const ModuleIdent, FormIdent,
AncestorIdent: string);
begin
if not FHaveText then
begin
FHaveText := True;
FWebWizardExt.CreateModuleText(FProjectType, FCoClass,
ModuleIdent, FormIdent, AncestorIdent, FModuleText, FIntfText, FFormText);
end;
end;
function TWebExtModuleCreator.NewFormFileText(const FormIdent,
AncestorIdent: string): string;
begin
Assert(FHaveText);
Result := FFormText;
end;
function TWebExtModuleCreator.NewImplSourceText(const ModuleIdent,
FormIdent, AncestorIdent: string): string;
begin
GetText(ModuleIdent, FormIdent, AncestorIdent);
Result := FModuleText;
end;
function TWebExtModuleCreator.NewIntfSourceText(const ModuleIdent,
FormIdent, AncestorIdent: string): string;
begin
GetText(ModuleIdent, FormIdent, AncestorIdent);
Result := FIntfText;
end;
initialization
InitWeb;
finalization
DoneWeb;
{$ENDIF}
end.
|
unit UnRelatorioModelo;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, FMTBcd, DB, DBClient, Provider, SqlExpr,
{ helsonsant }
Util, DataUtil, UnModelo;
type
TRelatorioModelo = class(TModelo)
SqlTemp: TSQLDataSet;
protected
function GetSQL: TSql; override;
public
procedure CarregarResultadoGeral(const DataInicial, DataFinal: TDate); overload;
procedure CarregarResultadoGeral(const Mes: string;
const DataInicial, DataFinal: TDate); overload;
end;
implementation
uses DateUtils;
{$R *.dfm}
{ TRelatorioModelo }
procedure TRelatorioModelo.CarregarResultadoGeral(const DataInicial,
DataFinal: TDate);
var
_meses: TMap;
_mes, _ano: Integer;
_dataSet: TClientDataSet;
_competenciaInicial, _competenciaFinal: string;
function RetornarDataTexto(const Dia, Mes, Ano: Integer): string;
begin
Result := Self.FUtil.Text.EZeros(IntToStr(Dia), 2) + '/' +
Self.FUtil.Text.EZeros(IntToStr(Mes), 2) + '/' +
Self.FUtil.Text.EZeros(IntToStr(Ano), 4);
end;
begin
_meses := TMap.Create
.Gravar('1', 'JAN_')
.Gravar('2', 'FEV_')
.Gravar('3', 'MAR_')
.Gravar('4', 'ABR_')
.Gravar('5', 'MAI_')
.Gravar('6', 'JUN_')
.Gravar('7', 'JUL_')
.Gravar('8', 'AGO_')
.Gravar('9', 'SET_')
.Gravar('10', 'OUT_')
.Gravar('11', 'NOV_')
.Gravar('12', 'DEZ_');
_dataSet := Self.cds;
_dataSet.Active := False;
_dataSet.CommandText := 'SELECT CAT_OID, CAT_DES CATEGORIA, ' +
'ESCLR_MOEDA JAN_, ' +
'ESCLR_MOEDA FEV_, ' +
'ESCLR_MOEDA MAR_, ' +
'ESCLR_MOEDA ABR_, ' +
'ESCLR_MOEDA MAI_, ' +
'ESCLR_MOEDA JUN_, ' +
'ESCLR_MOEDA JUL_, ' +
'ESCLR_MOEDA AGO_, ' +
'ESCLR_MOEDA SET_, ' +
'ESCLR_MOEDA OUT_, ' +
'ESCLR_MOEDA NOV_, ' +
'ESCLR_MOEDA DEZ_ ' +
'FROM CAT, ESCLR ' +
'UNION ' +
'SELECT 5 CAT_OID, ' + QuotedStr('RESULTADO') + ' CATEGORIA, ' +
'ESCLR_MOEDA JAN_, ' +
'ESCLR_MOEDA FEV_, ' +
'ESCLR_MOEDA MAR_, ' +
'ESCLR_MOEDA ABR_, ' +
'ESCLR_MOEDA MAI_, ' +
'ESCLR_MOEDA JUN_, ' +
'ESCLR_MOEDA JUL_, ' +
'ESCLR_MOEDA AGO_, ' +
'ESCLR_MOEDA SET_, ' +
'ESCLR_MOEDA OUT_, ' +
'ESCLR_MOEDA NOV_, ' +
'ESCLR_MOEDA DEZ_ ' +
'FROM ESCLR ' +
'ORDER BY 1';
_dataSet.Open;
_competenciaInicial := FormatDateTime('yyyymm', DataInicial);
_competenciaFinal := FormatDateTime('yyyymm', DataFinal);
if _competenciaInicial = _competenciaFinal then
Self.CarregarResultadoGeral('JAN_', DataInicial, DataFinal)
else
begin
_competenciaInicial := FormatDateTime('yyyy', DataInicial);
Self.SqlTemp.Active := False;
Self.SqlTemp.CommandText := 'SELECT DISTINCT COMPETENCIA ' +
'FROM ( ' +
'SELECT DISTINCT EXTRACT(YEAR FROM CCORMV_DATA) || LPAD(EXTRACT(MONTH FROM CCORMV_DATA), 2, ''0'') COMPETENCIA ' +
'FROM CCORMV ' +
'WHERE EXTRACT(YEAR FROM CCORMV_DATA) = :ANO ' +
'UNION ' +
'SELECT DISTINCT EXTRACT(YEAR FROM CXMV_DATA) || LPAD(EXTRACT(MONTH FROM CXMV_DATA), 2, ''0'') COMPETENCIA ' +
'FROM CXMV ' +
'WHERE EXTRACT(YEAR FROM CXMV_DATA) = :ANO ' +
') ORDER BY COMPETENCIA';
Self.SqlTemp.Params.ParamByName('ANO').AsSmallInt := StrToInt(_competenciaInicial);
Self.SqlTemp.Open;
Self.SqlTemp.First;
while not Self.SqlTemp.Eof do
begin
_mes := StrToInt(Copy(Self.SqlTemp.FieldByName('competencia').AsString, 5, 2));
_ano := StrToInt(Copy(Self.SqlTemp.FieldByName('competencia').AsString, 1, 4));
_competenciaInicial := '01' + '/' + IntToStr(_mes) + '/' + IntToStr(_ano);
_competenciaFinal := IntToStr(DaysInAMonth(_ano, _mes)) + '/' + IntToStr(_mes) + '/' + IntToStr(_ano);
Self.CarregarResultadoGeral(_meses.Ler(IntToStr(_mes)).ComoTexto, StrToDate(_competenciaInicial), StrToDate(_competenciaFinal));
Self.SqlTemp.Next;
end;
end;
end;
procedure TRelatorioModelo.CarregarResultadoGeral(const Mes: string;
const DataInicial, DataFinal: TDate);
var
_receitas, _impostos, _despesasFixas, _despesasVariaveis: Real;
begin
{ RECEITAS }
Self.Sql.Active := False;
Self.Sql.CommandText := 'SELECT SUM(RECEITAS) RECEITAS ' +
'FROM ( ' +
'SELECT SUM(CXMV_VALOR) RECEITAS ' +
'FROM CXMV ' +
'WHERE CAT_OID = 0 AND CXMV_DATA BETWEEN :INICIO AND :FIM ' +
'UNION ' +
'SELECT SUM(CCORMV_VALOR) RECEITAS ' +
'FROM CCORMV ' +
'WHERE CAT_OID = 0 AND CCORMV_DATA BETWEEN :INICIO AND :FIM' +
')';
Self.Sql.Params.ParamByName('INICIO').AsDate := DataInicial;
Self.Sql.Params.ParamByName('FIM').AsDate := DataFinal;
Self.Sql.Open;
_receitas := Self.Sql.FieldByName('RECEITAS').AsCurrency;
{ IMPOSTOS }
Self.Sql.Active := False;
Self.Sql.CommandText := 'SELECT SUM(IMPOSTOS) IMPOSTOS ' +
'FROM ( ' +
'SELECT SUM(CXMV_VALOR) IMPOSTOS ' +
'FROM CXMV ' +
'WHERE CAT_OID = 3 AND CXMV_DATA BETWEEN :INICIO AND :FIM ' +
'UNION ' +
'SELECT SUM(CCORMV_VALOR) IMPOSTOS ' +
'FROM CCORMV ' +
'WHERE CAT_OID = 3 AND CCORMV_DATA BETWEEN :INICIO AND :FIM' +
')';
Self.Sql.Params.ParamByName('INICIO').AsDate := DataInicial;
Self.Sql.Params.ParamByName('FIM').AsDate := DataFinal;
Self.Sql.Open;
_impostos := Self.Sql.FieldByName('IMPOSTOS').AsCurrency;
{ DESPESAS FIXAS }
Self.Sql.Active := False;
Self.Sql.CommandText := 'SELECT SUM(DESPESAS_FIXAS) DESPESAS_FIXAS ' +
'FROM ( ' +
'SELECT SUM(CXMV_VALOR) DESPESAS_FIXAS ' +
'FROM CXMV ' +
'WHERE CAT_OID = 1 AND CXMV_DATA BETWEEN :INICIO AND :FIM ' +
'UNION ' +
'SELECT SUM(CCORMV_VALOR) DESPESAS_FIXAS ' +
'FROM CCORMV ' +
'WHERE CAT_OID = 1 AND CCORMV_DATA BETWEEN :INICIO AND :FIM' +
')';
Self.Sql.Params.ParamByName('INICIO').AsDate := DataInicial;
Self.Sql.Params.ParamByName('FIM').AsDate := DataFinal;
Self.Sql.Open;
_despesasFixas := Self.Sql.FieldByName('DESPESAS_FIXAS').AsCurrency;
{ DESPESAS VARIÁVEIS }
Self.Sql.Active := False;
Self.Sql.CommandText := 'SELECT SUM(DESPESAS_VARIAVEIS) DESPESAS_VARIAVEIS ' +
'FROM ( ' +
'SELECT SUM(CXMV_VALOR) DESPESAS_VARIAVEIS ' +
'FROM CXMV ' +
'WHERE CAT_OID = 2 AND CXMV_DATA BETWEEN :INICIO AND :FIM ' +
'UNION ' +
'SELECT SUM(CCORMV_VALOR) DESPESAS_VARIAVEIS ' +
'FROM CCORMV ' +
'WHERE CAT_OID = 2 AND CCORMV_DATA BETWEEN :INICIO AND :FIM' +
')';
Self.Sql.Params.ParamByName('INICIO').AsDate := DataInicial;
Self.Sql.Params.ParamByName('FIM').AsDate := DataFinal;
Self.Sql.Open;
_despesasVariaveis := Self.Sql.FieldByName('DESPESAS_VARIAVEIS').AsCurrency;
{ Registra Resultados }
Self.cds.First;
Self.cds.Edit;
Self.cds.FieldByName(Mes).AsCurrency := _receitas;
Self.cds.Next;
Self.cds.Edit;
Self.cds.FieldByName(Mes).AsCurrency := _impostos;
Self.cds.Next;
Self.cds.Edit;
Self.cds.FieldByName(Mes).AsCurrency := _despesasFixas;
Self.cds.Next;
Self.cds.Edit;
Self.cds.FieldByName(Mes).AsCurrency := _despesasVariaveis;
Self.cds.Next;
Self.cds.Edit;
Self.cds.FieldByName(Mes).AsCurrency := _receitas - _impostos -
_despesasFixas - _despesasVariaveis;
Self.cds.Post;
end;
function TRelatorioModelo.GetSQL: TSql;
begin
if Self.FSql = nil then
Self.FSql := TSql.Create;
Result := Self.FSql;
end;
initialization
RegisterClass(TRelatorioModelo);
end.
|
namespace WxListboxDemo;
interface
uses
Wx,
System.IO,
System.Drawing,
System;
type
MyFrame = class(Frame)
protected
mainsizer,
editsizer,
logosizer: BoxSizer;
toppanel,
logopanel,
logofillerleft,
logofillerright: Panel;
textbox: TextCtrl;
addbutton: Button;
mainlistbox: ListBox;
image: StaticBitmap;
procedure InitializeComponents;
procedure AddButtonClick(sender: Object; ev: &Event);
public
constructor;
end;
ListboxApp = class(App)
public
function OnInit: Boolean; override;
class procedure Main;
end;
implementation
procedure MyFrame.InitializeComponents;
begin
toppanel := new Panel(self, -1);
textbox := new TextCtrl(toppanel, -1, '');
addbutton := new Button(toppanel, -1, '&Add', wxDefaultPosition, wxDefaultSize, 0);
mainlistbox := new ListBox(self, -1, wxDefaultPosition, wxDefaultSize, 0, new string[0], 0);
logopanel := new Panel(self, -1);
logofillerleft := new Panel(logopanel, -1);
image := new StaticBitmap(logopanel, -1, new wx.Bitmap(
Path.Combine(Path.GetDirectoryName(typeof(MyFrame).Assembly.Location), 'powered-by-oxygene-transpare.png'),
BitmapType.wxBITMAP_TYPE_PNG));
logofillerright := new Panel(logopanel, -1);
Title := 'WxWidgets Listbox Demo';
addbutton.SetDefault();
addbutton.Click += AddButtonClick;
mainlistbox.Selection := 0;
editsizer := new BoxSizer(Orientation.wxHORIZONTAL);
editsizer.Add(textbox, 1, wx.Direction.wxALL, 8);
editsizer.Add(addbutton, 0, wx.Direction.wxALL, 8);
editsizer.Fit(toppanel);
editsizer.SetSizeHints(toppanel);
toppanel.AutoLayout := true;
toppanel.Sizer := editsizer;
logosizer := new BoxSizer(Orientation.wxHORIZONTAL);
logosizer.Add(logofillerleft, 1, wx.Stretch.wxEXPAND, 0);
logosizer.Add(image, 0, wx.Stretch.wxEXPAND or wx.Alignment.wxALIGN_CENTER_HORIZONTAL, 0);
logosizer.Add(logofillerright, 1, wx.Stretch.wxEXPAND, 0);
logosizer.Fit(logopanel);
logosizer.SetSizeHints(logopanel);
logopanel.AutoLayout := true;
logopanel.Sizer := logosizer;
mainsizer := new BoxSizer(Orientation.wxVERTICAL);
mainsizer.Add(toppanel, 0, wx.Stretch.wxEXPAND, 0);
mainsizer.Add(mainlistbox, 1, wx.Stretch.wxEXPAND, 0);
mainsizer.Add(logopanel, 0, wx.Stretch.wxEXPAND, 0);
mainsizer.Fit(self);
mainsizer.SetSizeHints(self);
AutoLayout := true;
SetSize(492, 499);
SetSizer(mainsizer);
Layout();
end;
constructor MyFrame;
begin
inherited constructor(nil, -1, 'WxWidgets ListBox Demo',
wxDefaultPosition,
new Size(492, 499),
wxDEFAULT_DIALOG_STYLE, 'MyFrame');
InitializeComponents;
end;
procedure MyFrame.AddButtonClick(sender: Object; ev: &Event);
begin
mainlistbox.Append(textbox.Title);
textbox.Title := '';
textbox.SetFocus;
end;
function ListboxApp.OnInit: Boolean;
var
Frame: MyFrame;
begin
Frame := new MyFrame;
Frame.Show(true);
Result := true;
end;
[STAThread]
class procedure ListboxApp.Main;
var
app: ListboxApp := new ListboxApp;
begin
app.Run;
end;
end.
|
unit Unit3_WithPublicVersion;
interface
uses
System.Classes,
System.SysUtils;
type
ICommand = interface
procedure Execute();
end;
TFooInfo = record
Kind: TTypeKind;
PropertyName: string;
ClassName: string;
function isAvaliableForInjection(const aInjection: TVarRec): boolean;
end;
type
TFoo3 = class(TComponent)
public
function GetElapsedTimeMs: integer;
function IsBusy: boolean; virtual;
public const
Version = '1.0';
end;
implementation
uses
System.RTTI;
const
ERRMSG_NotSupportedParameter = 'Not supported parameter type to inject!' +
'Parameter index (zaro-based): %d. Paramter type: %s';
function TFoo3.GetElapsedTimeMs: integer;
begin
Result := 0;
end;
function TFoo3.IsBusy: TTimeSpan;
begin
Result := False;
end;
end.
|
{ ****************************************************************************** }
{ Fast KDTree Single Type support }
{ ****************************************************************************** }
{ * https://zpascal.net * }
{ * https://github.com/PassByYou888/zAI * }
{ * https://github.com/PassByYou888/ZServer4D * }
{ * https://github.com/PassByYou888/PascalString * }
{ * https://github.com/PassByYou888/zRasterization * }
{ * https://github.com/PassByYou888/CoreCipher * }
{ * https://github.com/PassByYou888/zSound * }
{ * https://github.com/PassByYou888/zChinese * }
{ * https://github.com/PassByYou888/zExpression * }
{ * https://github.com/PassByYou888/zGameWare * }
{ * https://github.com/PassByYou888/zAnalysis * }
{ * https://github.com/PassByYou888/FFMPEG-Header * }
{ * https://github.com/PassByYou888/zTranslate * }
{ * https://github.com/PassByYou888/InfiniteIoT * }
{ * https://github.com/PassByYou888/FastMD5 * }
{ ****************************************************************************** }
unit FastKDTreeS;
{$INCLUDE zDefine.inc}
interface
uses CoreClasses, PascalStrings, UnicodeMixedLib, KM;
const
// Single float: KDTree
KDT1DS_Axis = 1;
KDT2DS_Axis = 2;
KDT3DS_Axis = 3;
KDT4DS_Axis = 4;
KDT5DS_Axis = 5;
KDT6DS_Axis = 6;
KDT7DS_Axis = 7;
KDT8DS_Axis = 8;
KDT9DS_Axis = 9;
KDT10DS_Axis = 10;
KDT11DS_Axis = 11;
KDT12DS_Axis = 12;
KDT13DS_Axis = 13;
KDT14DS_Axis = 14;
KDT15DS_Axis = 15;
KDT16DS_Axis = 16;
KDT17DS_Axis = 17;
KDT18DS_Axis = 18;
KDT19DS_Axis = 19;
KDT20DS_Axis = 20;
KDT21DS_Axis = 21;
KDT22DS_Axis = 22;
KDT23DS_Axis = 23;
KDT24DS_Axis = 24;
KDT48DS_Axis = 48;
KDT52DS_Axis = 52;
KDT64DS_Axis = 64;
KDT96DS_Axis = 96;
KDT128DS_Axis = 128;
KDT156DS_Axis = 156;
KDT192DS_Axis = 192;
KDT256DS_Axis = 256;
KDT384DS_Axis = 384;
KDT512DS_Axis = 512;
KDT800DS_Axis = 800;
KDT1024DS_Axis = 1024;
type
// Single float: KDTree
TKDT1DS = class; TKDT1DS_VecType = KM.TKMFloat; // 1D
TKDT2DS = class; TKDT2DS_VecType = KM.TKMFloat; // 2D
TKDT3DS = class; TKDT3DS_VecType = KM.TKMFloat; // 3D
TKDT4DS = class; TKDT4DS_VecType = KM.TKMFloat; // 4D
TKDT5DS = class; TKDT5DS_VecType = KM.TKMFloat; // 5D
TKDT6DS = class; TKDT6DS_VecType = KM.TKMFloat; // 6D
TKDT7DS = class; TKDT7DS_VecType = KM.TKMFloat; // 7D
TKDT8DS = class; TKDT8DS_VecType = KM.TKMFloat; // 8D
TKDT9DS = class; TKDT9DS_VecType = KM.TKMFloat; // 9D
TKDT10DS = class; TKDT10DS_VecType = KM.TKMFloat; // 10D
TKDT11DS = class; TKDT11DS_VecType = KM.TKMFloat; // 11D
TKDT12DS = class; TKDT12DS_VecType = KM.TKMFloat; // 12D
TKDT13DS = class; TKDT13DS_VecType = KM.TKMFloat; // 13D
TKDT14DS = class; TKDT14DS_VecType = KM.TKMFloat; // 14D
TKDT15DS = class; TKDT15DS_VecType = KM.TKMFloat; // 15D
TKDT16DS = class; TKDT16DS_VecType = KM.TKMFloat; // 16D
TKDT17DS = class; TKDT17DS_VecType = KM.TKMFloat; // 17D
TKDT18DS = class; TKDT18DS_VecType = KM.TKMFloat; // 18D
TKDT19DS = class; TKDT19DS_VecType = KM.TKMFloat; // 19D
TKDT20DS = class; TKDT20DS_VecType = KM.TKMFloat; // 20D
TKDT21DS = class; TKDT21DS_VecType = KM.TKMFloat; // 21D
TKDT22DS = class; TKDT22DS_VecType = KM.TKMFloat; // 22D
TKDT23DS = class; TKDT23DS_VecType = KM.TKMFloat; // 23D
TKDT24DS = class; TKDT24DS_VecType = KM.TKMFloat; // 24D
TKDT48DS = class; TKDT48DS_VecType = KM.TKMFloat; // 48D
TKDT52DS = class; TKDT52DS_VecType = KM.TKMFloat; // 52D
TKDT64DS = class; TKDT64DS_VecType = KM.TKMFloat; // 64D
TKDT96DS = class; TKDT96DS_VecType = KM.TKMFloat; // 96D
TKDT128DS = class; TKDT128DS_VecType = KM.TKMFloat; // 128D
TKDT156DS = class; TKDT156DS_VecType = KM.TKMFloat; // 156D
TKDT192DS = class; TKDT192DS_VecType = KM.TKMFloat; // 192D
TKDT256DS = class; TKDT256DS_VecType = KM.TKMFloat; // 256D
TKDT384DS = class; TKDT384DS_VecType = KM.TKMFloat; // 384D
TKDT512DS = class; TKDT512DS_VecType = KM.TKMFloat; // 512D
TKDT800DS = class; TKDT800DS_VecType = KM.TKMFloat; // 800D
TKDT1024DS = class; TKDT1024DS_VecType = KM.TKMFloat; // 1024D
// Single float: KDTree
TKDT1DS = class(TCoreClassObject)
public type
// code split
TKDT1DS_Vec = array [0 .. KDT1DS_Axis - 1] of TKDT1DS_VecType;
PKDT1DS_Vec = ^TKDT1DS_Vec;
TKDT1DS_DynamicVecBuffer = array of TKDT1DS_Vec;
PKDT1DS_DynamicVecBuffer = ^TKDT1DS_DynamicVecBuffer;
TKDT1DS_Source = record
buff: TKDT1DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT1DS_Source = ^TKDT1DS_Source;
TKDT1DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT1DS_Source) - 1] of PKDT1DS_Source;
PKDT1DS_SourceBuffer = ^TKDT1DS_SourceBuffer;
TKDT1DS_DyanmicSourceBuffer = array of PKDT1DS_Source;
PKDT1DS_DyanmicSourceBuffer = ^TKDT1DS_DyanmicSourceBuffer;
TKDT1DS_DyanmicStoreBuffer = array of TKDT1DS_Source;
PKDT1DS_DyanmicStoreBuffer = ^TKDT1DS_DyanmicStoreBuffer;
PKDT1DS_Node = ^TKDT1DS_Node;
TKDT1DS_Node = record
Parent, Right, Left: PKDT1DS_Node;
Vec: PKDT1DS_Source;
end;
TKDT1DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT1DS_Source; const Data: Pointer);
TKDT1DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT1DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT1DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT1DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT1DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT1DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT1DS_DyanmicStoreBuffer;
KDBuff: TKDT1DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT1DS_Node;
TestBuff: TKDT1DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT1DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT1DS_Node;
function GetData(const Index: NativeInt): PKDT1DS_Source;
public
RootNode: PKDT1DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT1DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT1DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT1DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT1DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT1DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT1DS_Node; overload;
function Search(const buff: TKDT1DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT1DS_Node; overload;
function Search(const buff: TKDT1DS_Vec; var SearchedDistanceMin: Double): PKDT1DS_Node; overload;
function Search(const buff: TKDT1DS_Vec): PKDT1DS_Node; overload;
function SearchToken(const buff: TKDT1DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT1DS_DynamicVecBuffer; var OutBuff: TKDT1DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT1DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT1DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT1DS_Vec; overload;
class function Vec(const v: TKDT1DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT1DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT1DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT2DS = class(TCoreClassObject)
public type
// code split
TKDT2DS_Vec = array [0 .. KDT2DS_Axis - 1] of TKDT2DS_VecType;
PKDT2DS_Vec = ^TKDT2DS_Vec;
TKDT2DS_DynamicVecBuffer = array of TKDT2DS_Vec;
PKDT2DS_DynamicVecBuffer = ^TKDT2DS_DynamicVecBuffer;
TKDT2DS_Source = record
buff: TKDT2DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT2DS_Source = ^TKDT2DS_Source;
TKDT2DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT2DS_Source) - 1] of PKDT2DS_Source;
PKDT2DS_SourceBuffer = ^TKDT2DS_SourceBuffer;
TKDT2DS_DyanmicSourceBuffer = array of PKDT2DS_Source;
PKDT2DS_DyanmicSourceBuffer = ^TKDT2DS_DyanmicSourceBuffer;
TKDT2DS_DyanmicStoreBuffer = array of TKDT2DS_Source;
PKDT2DS_DyanmicStoreBuffer = ^TKDT2DS_DyanmicStoreBuffer;
PKDT2DS_Node = ^TKDT2DS_Node;
TKDT2DS_Node = record
Parent, Right, Left: PKDT2DS_Node;
Vec: PKDT2DS_Source;
end;
TKDT2DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT2DS_Source; const Data: Pointer);
TKDT2DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT2DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT2DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT2DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT2DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT2DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT2DS_DyanmicStoreBuffer;
KDBuff: TKDT2DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT2DS_Node;
TestBuff: TKDT2DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT2DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT2DS_Node;
function GetData(const Index: NativeInt): PKDT2DS_Source;
public
RootNode: PKDT2DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT2DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT2DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT2DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT2DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT2DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT2DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT2DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT2DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT2DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT2DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT2DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT2DS_Node; overload;
function Search(const buff: TKDT2DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT2DS_Node; overload;
function Search(const buff: TKDT2DS_Vec; var SearchedDistanceMin: Double): PKDT2DS_Node; overload;
function Search(const buff: TKDT2DS_Vec): PKDT2DS_Node; overload;
function SearchToken(const buff: TKDT2DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT2DS_DynamicVecBuffer; var OutBuff: TKDT2DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT2DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT2DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT2DS_Vec; overload;
class function Vec(const v: TKDT2DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT2DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT2DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT3DS = class(TCoreClassObject)
public type
// code split
TKDT3DS_Vec = array [0 .. KDT3DS_Axis - 1] of TKDT3DS_VecType;
PKDT3DS_Vec = ^TKDT3DS_Vec;
TKDT3DS_DynamicVecBuffer = array of TKDT3DS_Vec;
PKDT3DS_DynamicVecBuffer = ^TKDT3DS_DynamicVecBuffer;
TKDT3DS_Source = record
buff: TKDT3DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT3DS_Source = ^TKDT3DS_Source;
TKDT3DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT3DS_Source) - 1] of PKDT3DS_Source;
PKDT3DS_SourceBuffer = ^TKDT3DS_SourceBuffer;
TKDT3DS_DyanmicSourceBuffer = array of PKDT3DS_Source;
PKDT3DS_DyanmicSourceBuffer = ^TKDT3DS_DyanmicSourceBuffer;
TKDT3DS_DyanmicStoreBuffer = array of TKDT3DS_Source;
PKDT3DS_DyanmicStoreBuffer = ^TKDT3DS_DyanmicStoreBuffer;
PKDT3DS_Node = ^TKDT3DS_Node;
TKDT3DS_Node = record
Parent, Right, Left: PKDT3DS_Node;
Vec: PKDT3DS_Source;
end;
TKDT3DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT3DS_Source; const Data: Pointer);
TKDT3DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT3DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT3DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT3DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT3DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT3DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT3DS_DyanmicStoreBuffer;
KDBuff: TKDT3DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT3DS_Node;
TestBuff: TKDT3DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT3DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT3DS_Node;
function GetData(const Index: NativeInt): PKDT3DS_Source;
public
RootNode: PKDT3DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT3DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT3DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT3DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT3DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT3DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT3DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT3DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT3DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT3DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT3DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT3DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT3DS_Node; overload;
function Search(const buff: TKDT3DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT3DS_Node; overload;
function Search(const buff: TKDT3DS_Vec; var SearchedDistanceMin: Double): PKDT3DS_Node; overload;
function Search(const buff: TKDT3DS_Vec): PKDT3DS_Node; overload;
function SearchToken(const buff: TKDT3DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT3DS_DynamicVecBuffer; var OutBuff: TKDT3DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT3DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT3DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT3DS_Vec; overload;
class function Vec(const v: TKDT3DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT3DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT3DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT4DS = class(TCoreClassObject)
public type
// code split
TKDT4DS_Vec = array [0 .. KDT4DS_Axis - 1] of TKDT4DS_VecType;
PKDT4DS_Vec = ^TKDT4DS_Vec;
TKDT4DS_DynamicVecBuffer = array of TKDT4DS_Vec;
PKDT4DS_DynamicVecBuffer = ^TKDT4DS_DynamicVecBuffer;
TKDT4DS_Source = record
buff: TKDT4DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT4DS_Source = ^TKDT4DS_Source;
TKDT4DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT4DS_Source) - 1] of PKDT4DS_Source;
PKDT4DS_SourceBuffer = ^TKDT4DS_SourceBuffer;
TKDT4DS_DyanmicSourceBuffer = array of PKDT4DS_Source;
PKDT4DS_DyanmicSourceBuffer = ^TKDT4DS_DyanmicSourceBuffer;
TKDT4DS_DyanmicStoreBuffer = array of TKDT4DS_Source;
PKDT4DS_DyanmicStoreBuffer = ^TKDT4DS_DyanmicStoreBuffer;
PKDT4DS_Node = ^TKDT4DS_Node;
TKDT4DS_Node = record
Parent, Right, Left: PKDT4DS_Node;
Vec: PKDT4DS_Source;
end;
TKDT4DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT4DS_Source; const Data: Pointer);
TKDT4DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT4DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT4DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT4DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT4DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT4DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT4DS_DyanmicStoreBuffer;
KDBuff: TKDT4DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT4DS_Node;
TestBuff: TKDT4DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT4DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT4DS_Node;
function GetData(const Index: NativeInt): PKDT4DS_Source;
public
RootNode: PKDT4DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT4DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT4DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT4DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT4DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT4DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT4DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT4DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT4DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT4DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT4DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT4DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT4DS_Node; overload;
function Search(const buff: TKDT4DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT4DS_Node; overload;
function Search(const buff: TKDT4DS_Vec; var SearchedDistanceMin: Double): PKDT4DS_Node; overload;
function Search(const buff: TKDT4DS_Vec): PKDT4DS_Node; overload;
function SearchToken(const buff: TKDT4DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT4DS_DynamicVecBuffer; var OutBuff: TKDT4DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT4DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT4DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT4DS_Vec; overload;
class function Vec(const v: TKDT4DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT4DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT4DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT5DS = class(TCoreClassObject)
public type
// code split
TKDT5DS_Vec = array [0 .. KDT5DS_Axis - 1] of TKDT5DS_VecType;
PKDT5DS_Vec = ^TKDT5DS_Vec;
TKDT5DS_DynamicVecBuffer = array of TKDT5DS_Vec;
PKDT5DS_DynamicVecBuffer = ^TKDT5DS_DynamicVecBuffer;
TKDT5DS_Source = record
buff: TKDT5DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT5DS_Source = ^TKDT5DS_Source;
TKDT5DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT5DS_Source) - 1] of PKDT5DS_Source;
PKDT5DS_SourceBuffer = ^TKDT5DS_SourceBuffer;
TKDT5DS_DyanmicSourceBuffer = array of PKDT5DS_Source;
PKDT5DS_DyanmicSourceBuffer = ^TKDT5DS_DyanmicSourceBuffer;
TKDT5DS_DyanmicStoreBuffer = array of TKDT5DS_Source;
PKDT5DS_DyanmicStoreBuffer = ^TKDT5DS_DyanmicStoreBuffer;
PKDT5DS_Node = ^TKDT5DS_Node;
TKDT5DS_Node = record
Parent, Right, Left: PKDT5DS_Node;
Vec: PKDT5DS_Source;
end;
TKDT5DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT5DS_Source; const Data: Pointer);
TKDT5DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT5DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT5DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT5DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT5DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT5DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT5DS_DyanmicStoreBuffer;
KDBuff: TKDT5DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT5DS_Node;
TestBuff: TKDT5DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT5DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT5DS_Node;
function GetData(const Index: NativeInt): PKDT5DS_Source;
public
RootNode: PKDT5DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT5DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT5DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT5DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT5DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT5DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT5DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT5DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT5DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT5DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT5DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT5DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT5DS_Node; overload;
function Search(const buff: TKDT5DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT5DS_Node; overload;
function Search(const buff: TKDT5DS_Vec; var SearchedDistanceMin: Double): PKDT5DS_Node; overload;
function Search(const buff: TKDT5DS_Vec): PKDT5DS_Node; overload;
function SearchToken(const buff: TKDT5DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT5DS_DynamicVecBuffer; var OutBuff: TKDT5DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT5DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT5DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT5DS_Vec; overload;
class function Vec(const v: TKDT5DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT5DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT5DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT6DS = class(TCoreClassObject)
public type
// code split
TKDT6DS_Vec = array [0 .. KDT6DS_Axis - 1] of TKDT6DS_VecType;
PKDT6DS_Vec = ^TKDT6DS_Vec;
TKDT6DS_DynamicVecBuffer = array of TKDT6DS_Vec;
PKDT6DS_DynamicVecBuffer = ^TKDT6DS_DynamicVecBuffer;
TKDT6DS_Source = record
buff: TKDT6DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT6DS_Source = ^TKDT6DS_Source;
TKDT6DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT6DS_Source) - 1] of PKDT6DS_Source;
PKDT6DS_SourceBuffer = ^TKDT6DS_SourceBuffer;
TKDT6DS_DyanmicSourceBuffer = array of PKDT6DS_Source;
PKDT6DS_DyanmicSourceBuffer = ^TKDT6DS_DyanmicSourceBuffer;
TKDT6DS_DyanmicStoreBuffer = array of TKDT6DS_Source;
PKDT6DS_DyanmicStoreBuffer = ^TKDT6DS_DyanmicStoreBuffer;
PKDT6DS_Node = ^TKDT6DS_Node;
TKDT6DS_Node = record
Parent, Right, Left: PKDT6DS_Node;
Vec: PKDT6DS_Source;
end;
TKDT6DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT6DS_Source; const Data: Pointer);
TKDT6DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT6DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT6DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT6DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT6DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT6DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT6DS_DyanmicStoreBuffer;
KDBuff: TKDT6DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT6DS_Node;
TestBuff: TKDT6DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT6DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT6DS_Node;
function GetData(const Index: NativeInt): PKDT6DS_Source;
public
RootNode: PKDT6DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT6DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT6DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT6DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT6DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT6DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT6DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT6DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT6DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT6DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT6DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT6DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT6DS_Node; overload;
function Search(const buff: TKDT6DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT6DS_Node; overload;
function Search(const buff: TKDT6DS_Vec; var SearchedDistanceMin: Double): PKDT6DS_Node; overload;
function Search(const buff: TKDT6DS_Vec): PKDT6DS_Node; overload;
function SearchToken(const buff: TKDT6DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT6DS_DynamicVecBuffer; var OutBuff: TKDT6DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT6DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT6DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT6DS_Vec; overload;
class function Vec(const v: TKDT6DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT6DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT6DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT7DS = class(TCoreClassObject)
public type
// code split
TKDT7DS_Vec = array [0 .. KDT7DS_Axis - 1] of TKDT7DS_VecType;
PKDT7DS_Vec = ^TKDT7DS_Vec;
TKDT7DS_DynamicVecBuffer = array of TKDT7DS_Vec;
PKDT7DS_DynamicVecBuffer = ^TKDT7DS_DynamicVecBuffer;
TKDT7DS_Source = record
buff: TKDT7DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT7DS_Source = ^TKDT7DS_Source;
TKDT7DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT7DS_Source) - 1] of PKDT7DS_Source;
PKDT7DS_SourceBuffer = ^TKDT7DS_SourceBuffer;
TKDT7DS_DyanmicSourceBuffer = array of PKDT7DS_Source;
PKDT7DS_DyanmicSourceBuffer = ^TKDT7DS_DyanmicSourceBuffer;
TKDT7DS_DyanmicStoreBuffer = array of TKDT7DS_Source;
PKDT7DS_DyanmicStoreBuffer = ^TKDT7DS_DyanmicStoreBuffer;
PKDT7DS_Node = ^TKDT7DS_Node;
TKDT7DS_Node = record
Parent, Right, Left: PKDT7DS_Node;
Vec: PKDT7DS_Source;
end;
TKDT7DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT7DS_Source; const Data: Pointer);
TKDT7DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT7DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT7DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT7DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT7DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT7DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT7DS_DyanmicStoreBuffer;
KDBuff: TKDT7DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT7DS_Node;
TestBuff: TKDT7DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT7DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT7DS_Node;
function GetData(const Index: NativeInt): PKDT7DS_Source;
public
RootNode: PKDT7DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT7DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT7DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT7DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT7DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT7DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT7DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT7DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT7DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT7DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT7DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT7DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT7DS_Node; overload;
function Search(const buff: TKDT7DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT7DS_Node; overload;
function Search(const buff: TKDT7DS_Vec; var SearchedDistanceMin: Double): PKDT7DS_Node; overload;
function Search(const buff: TKDT7DS_Vec): PKDT7DS_Node; overload;
function SearchToken(const buff: TKDT7DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT7DS_DynamicVecBuffer; var OutBuff: TKDT7DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT7DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT7DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT7DS_Vec; overload;
class function Vec(const v: TKDT7DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT7DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT7DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT8DS = class(TCoreClassObject)
public type
// code split
TKDT8DS_Vec = array [0 .. KDT8DS_Axis - 1] of TKDT8DS_VecType;
PKDT8DS_Vec = ^TKDT8DS_Vec;
TKDT8DS_DynamicVecBuffer = array of TKDT8DS_Vec;
PKDT8DS_DynamicVecBuffer = ^TKDT8DS_DynamicVecBuffer;
TKDT8DS_Source = record
buff: TKDT8DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT8DS_Source = ^TKDT8DS_Source;
TKDT8DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT8DS_Source) - 1] of PKDT8DS_Source;
PKDT8DS_SourceBuffer = ^TKDT8DS_SourceBuffer;
TKDT8DS_DyanmicSourceBuffer = array of PKDT8DS_Source;
PKDT8DS_DyanmicSourceBuffer = ^TKDT8DS_DyanmicSourceBuffer;
TKDT8DS_DyanmicStoreBuffer = array of TKDT8DS_Source;
PKDT8DS_DyanmicStoreBuffer = ^TKDT8DS_DyanmicStoreBuffer;
PKDT8DS_Node = ^TKDT8DS_Node;
TKDT8DS_Node = record
Parent, Right, Left: PKDT8DS_Node;
Vec: PKDT8DS_Source;
end;
TKDT8DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT8DS_Source; const Data: Pointer);
TKDT8DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT8DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT8DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT8DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT8DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT8DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT8DS_DyanmicStoreBuffer;
KDBuff: TKDT8DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT8DS_Node;
TestBuff: TKDT8DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT8DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT8DS_Node;
function GetData(const Index: NativeInt): PKDT8DS_Source;
public
RootNode: PKDT8DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT8DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT8DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT8DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT8DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT8DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT8DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT8DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT8DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT8DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT8DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT8DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT8DS_Node; overload;
function Search(const buff: TKDT8DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT8DS_Node; overload;
function Search(const buff: TKDT8DS_Vec; var SearchedDistanceMin: Double): PKDT8DS_Node; overload;
function Search(const buff: TKDT8DS_Vec): PKDT8DS_Node; overload;
function SearchToken(const buff: TKDT8DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT8DS_DynamicVecBuffer; var OutBuff: TKDT8DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT8DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT8DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT8DS_Vec; overload;
class function Vec(const v: TKDT8DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT8DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT8DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT9DS = class(TCoreClassObject)
public type
// code split
TKDT9DS_Vec = array [0 .. KDT9DS_Axis - 1] of TKDT9DS_VecType;
PKDT9DS_Vec = ^TKDT9DS_Vec;
TKDT9DS_DynamicVecBuffer = array of TKDT9DS_Vec;
PKDT9DS_DynamicVecBuffer = ^TKDT9DS_DynamicVecBuffer;
TKDT9DS_Source = record
buff: TKDT9DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT9DS_Source = ^TKDT9DS_Source;
TKDT9DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT9DS_Source) - 1] of PKDT9DS_Source;
PKDT9DS_SourceBuffer = ^TKDT9DS_SourceBuffer;
TKDT9DS_DyanmicSourceBuffer = array of PKDT9DS_Source;
PKDT9DS_DyanmicSourceBuffer = ^TKDT9DS_DyanmicSourceBuffer;
TKDT9DS_DyanmicStoreBuffer = array of TKDT9DS_Source;
PKDT9DS_DyanmicStoreBuffer = ^TKDT9DS_DyanmicStoreBuffer;
PKDT9DS_Node = ^TKDT9DS_Node;
TKDT9DS_Node = record
Parent, Right, Left: PKDT9DS_Node;
Vec: PKDT9DS_Source;
end;
TKDT9DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT9DS_Source; const Data: Pointer);
TKDT9DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT9DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT9DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT9DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT9DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT9DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT9DS_DyanmicStoreBuffer;
KDBuff: TKDT9DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT9DS_Node;
TestBuff: TKDT9DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT9DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT9DS_Node;
function GetData(const Index: NativeInt): PKDT9DS_Source;
public
RootNode: PKDT9DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT9DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT9DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT9DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT9DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT9DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT9DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT9DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT9DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT9DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT9DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT9DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT9DS_Node; overload;
function Search(const buff: TKDT9DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT9DS_Node; overload;
function Search(const buff: TKDT9DS_Vec; var SearchedDistanceMin: Double): PKDT9DS_Node; overload;
function Search(const buff: TKDT9DS_Vec): PKDT9DS_Node; overload;
function SearchToken(const buff: TKDT9DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT9DS_DynamicVecBuffer; var OutBuff: TKDT9DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT9DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT9DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT9DS_Vec; overload;
class function Vec(const v: TKDT9DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT9DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT9DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT10DS = class(TCoreClassObject)
public type
// code split
TKDT10DS_Vec = array [0 .. KDT10DS_Axis - 1] of TKDT10DS_VecType;
PKDT10DS_Vec = ^TKDT10DS_Vec;
TKDT10DS_DynamicVecBuffer = array of TKDT10DS_Vec;
PKDT10DS_DynamicVecBuffer = ^TKDT10DS_DynamicVecBuffer;
TKDT10DS_Source = record
buff: TKDT10DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT10DS_Source = ^TKDT10DS_Source;
TKDT10DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT10DS_Source) - 1] of PKDT10DS_Source;
PKDT10DS_SourceBuffer = ^TKDT10DS_SourceBuffer;
TKDT10DS_DyanmicSourceBuffer = array of PKDT10DS_Source;
PKDT10DS_DyanmicSourceBuffer = ^TKDT10DS_DyanmicSourceBuffer;
TKDT10DS_DyanmicStoreBuffer = array of TKDT10DS_Source;
PKDT10DS_DyanmicStoreBuffer = ^TKDT10DS_DyanmicStoreBuffer;
PKDT10DS_Node = ^TKDT10DS_Node;
TKDT10DS_Node = record
Parent, Right, Left: PKDT10DS_Node;
Vec: PKDT10DS_Source;
end;
TKDT10DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT10DS_Source; const Data: Pointer);
TKDT10DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT10DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT10DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT10DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT10DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT10DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT10DS_DyanmicStoreBuffer;
KDBuff: TKDT10DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT10DS_Node;
TestBuff: TKDT10DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT10DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT10DS_Node;
function GetData(const Index: NativeInt): PKDT10DS_Source;
public
RootNode: PKDT10DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT10DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT10DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT10DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT10DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT10DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT10DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT10DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT10DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT10DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT10DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT10DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT10DS_Node; overload;
function Search(const buff: TKDT10DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT10DS_Node; overload;
function Search(const buff: TKDT10DS_Vec; var SearchedDistanceMin: Double): PKDT10DS_Node; overload;
function Search(const buff: TKDT10DS_Vec): PKDT10DS_Node; overload;
function SearchToken(const buff: TKDT10DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT10DS_DynamicVecBuffer; var OutBuff: TKDT10DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT10DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT10DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT10DS_Vec; overload;
class function Vec(const v: TKDT10DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT10DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT10DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT11DS = class(TCoreClassObject)
public type
// code split
TKDT11DS_Vec = array [0 .. KDT11DS_Axis - 1] of TKDT11DS_VecType;
PKDT11DS_Vec = ^TKDT11DS_Vec;
TKDT11DS_DynamicVecBuffer = array of TKDT11DS_Vec;
PKDT11DS_DynamicVecBuffer = ^TKDT11DS_DynamicVecBuffer;
TKDT11DS_Source = record
buff: TKDT11DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT11DS_Source = ^TKDT11DS_Source;
TKDT11DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT11DS_Source) - 1] of PKDT11DS_Source;
PKDT11DS_SourceBuffer = ^TKDT11DS_SourceBuffer;
TKDT11DS_DyanmicSourceBuffer = array of PKDT11DS_Source;
PKDT11DS_DyanmicSourceBuffer = ^TKDT11DS_DyanmicSourceBuffer;
TKDT11DS_DyanmicStoreBuffer = array of TKDT11DS_Source;
PKDT11DS_DyanmicStoreBuffer = ^TKDT11DS_DyanmicStoreBuffer;
PKDT11DS_Node = ^TKDT11DS_Node;
TKDT11DS_Node = record
Parent, Right, Left: PKDT11DS_Node;
Vec: PKDT11DS_Source;
end;
TKDT11DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT11DS_Source; const Data: Pointer);
TKDT11DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT11DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT11DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT11DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT11DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT11DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT11DS_DyanmicStoreBuffer;
KDBuff: TKDT11DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT11DS_Node;
TestBuff: TKDT11DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT11DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT11DS_Node;
function GetData(const Index: NativeInt): PKDT11DS_Source;
public
RootNode: PKDT11DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT11DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT11DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT11DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT11DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT11DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT11DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT11DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT11DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT11DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT11DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT11DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT11DS_Node; overload;
function Search(const buff: TKDT11DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT11DS_Node; overload;
function Search(const buff: TKDT11DS_Vec; var SearchedDistanceMin: Double): PKDT11DS_Node; overload;
function Search(const buff: TKDT11DS_Vec): PKDT11DS_Node; overload;
function SearchToken(const buff: TKDT11DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT11DS_DynamicVecBuffer; var OutBuff: TKDT11DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT11DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT11DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT11DS_Vec; overload;
class function Vec(const v: TKDT11DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT11DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT11DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT12DS = class(TCoreClassObject)
public type
// code split
TKDT12DS_Vec = array [0 .. KDT12DS_Axis - 1] of TKDT12DS_VecType;
PKDT12DS_Vec = ^TKDT12DS_Vec;
TKDT12DS_DynamicVecBuffer = array of TKDT12DS_Vec;
PKDT12DS_DynamicVecBuffer = ^TKDT12DS_DynamicVecBuffer;
TKDT12DS_Source = record
buff: TKDT12DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT12DS_Source = ^TKDT12DS_Source;
TKDT12DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT12DS_Source) - 1] of PKDT12DS_Source;
PKDT12DS_SourceBuffer = ^TKDT12DS_SourceBuffer;
TKDT12DS_DyanmicSourceBuffer = array of PKDT12DS_Source;
PKDT12DS_DyanmicSourceBuffer = ^TKDT12DS_DyanmicSourceBuffer;
TKDT12DS_DyanmicStoreBuffer = array of TKDT12DS_Source;
PKDT12DS_DyanmicStoreBuffer = ^TKDT12DS_DyanmicStoreBuffer;
PKDT12DS_Node = ^TKDT12DS_Node;
TKDT12DS_Node = record
Parent, Right, Left: PKDT12DS_Node;
Vec: PKDT12DS_Source;
end;
TKDT12DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT12DS_Source; const Data: Pointer);
TKDT12DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT12DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT12DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT12DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT12DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT12DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT12DS_DyanmicStoreBuffer;
KDBuff: TKDT12DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT12DS_Node;
TestBuff: TKDT12DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT12DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT12DS_Node;
function GetData(const Index: NativeInt): PKDT12DS_Source;
public
RootNode: PKDT12DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT12DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT12DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT12DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT12DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT12DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT12DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT12DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT12DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT12DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT12DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT12DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT12DS_Node; overload;
function Search(const buff: TKDT12DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT12DS_Node; overload;
function Search(const buff: TKDT12DS_Vec; var SearchedDistanceMin: Double): PKDT12DS_Node; overload;
function Search(const buff: TKDT12DS_Vec): PKDT12DS_Node; overload;
function SearchToken(const buff: TKDT12DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT12DS_DynamicVecBuffer; var OutBuff: TKDT12DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT12DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT12DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT12DS_Vec; overload;
class function Vec(const v: TKDT12DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT12DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT12DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT13DS = class(TCoreClassObject)
public type
// code split
TKDT13DS_Vec = array [0 .. KDT13DS_Axis - 1] of TKDT13DS_VecType;
PKDT13DS_Vec = ^TKDT13DS_Vec;
TKDT13DS_DynamicVecBuffer = array of TKDT13DS_Vec;
PKDT13DS_DynamicVecBuffer = ^TKDT13DS_DynamicVecBuffer;
TKDT13DS_Source = record
buff: TKDT13DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT13DS_Source = ^TKDT13DS_Source;
TKDT13DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT13DS_Source) - 1] of PKDT13DS_Source;
PKDT13DS_SourceBuffer = ^TKDT13DS_SourceBuffer;
TKDT13DS_DyanmicSourceBuffer = array of PKDT13DS_Source;
PKDT13DS_DyanmicSourceBuffer = ^TKDT13DS_DyanmicSourceBuffer;
TKDT13DS_DyanmicStoreBuffer = array of TKDT13DS_Source;
PKDT13DS_DyanmicStoreBuffer = ^TKDT13DS_DyanmicStoreBuffer;
PKDT13DS_Node = ^TKDT13DS_Node;
TKDT13DS_Node = record
Parent, Right, Left: PKDT13DS_Node;
Vec: PKDT13DS_Source;
end;
TKDT13DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT13DS_Source; const Data: Pointer);
TKDT13DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT13DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT13DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT13DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT13DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT13DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT13DS_DyanmicStoreBuffer;
KDBuff: TKDT13DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT13DS_Node;
TestBuff: TKDT13DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT13DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT13DS_Node;
function GetData(const Index: NativeInt): PKDT13DS_Source;
public
RootNode: PKDT13DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT13DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT13DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT13DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT13DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT13DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT13DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT13DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT13DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT13DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT13DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT13DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT13DS_Node; overload;
function Search(const buff: TKDT13DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT13DS_Node; overload;
function Search(const buff: TKDT13DS_Vec; var SearchedDistanceMin: Double): PKDT13DS_Node; overload;
function Search(const buff: TKDT13DS_Vec): PKDT13DS_Node; overload;
function SearchToken(const buff: TKDT13DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT13DS_DynamicVecBuffer; var OutBuff: TKDT13DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT13DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT13DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT13DS_Vec; overload;
class function Vec(const v: TKDT13DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT13DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT13DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT14DS = class(TCoreClassObject)
public type
// code split
TKDT14DS_Vec = array [0 .. KDT14DS_Axis - 1] of TKDT14DS_VecType;
PKDT14DS_Vec = ^TKDT14DS_Vec;
TKDT14DS_DynamicVecBuffer = array of TKDT14DS_Vec;
PKDT14DS_DynamicVecBuffer = ^TKDT14DS_DynamicVecBuffer;
TKDT14DS_Source = record
buff: TKDT14DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT14DS_Source = ^TKDT14DS_Source;
TKDT14DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT14DS_Source) - 1] of PKDT14DS_Source;
PKDT14DS_SourceBuffer = ^TKDT14DS_SourceBuffer;
TKDT14DS_DyanmicSourceBuffer = array of PKDT14DS_Source;
PKDT14DS_DyanmicSourceBuffer = ^TKDT14DS_DyanmicSourceBuffer;
TKDT14DS_DyanmicStoreBuffer = array of TKDT14DS_Source;
PKDT14DS_DyanmicStoreBuffer = ^TKDT14DS_DyanmicStoreBuffer;
PKDT14DS_Node = ^TKDT14DS_Node;
TKDT14DS_Node = record
Parent, Right, Left: PKDT14DS_Node;
Vec: PKDT14DS_Source;
end;
TKDT14DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT14DS_Source; const Data: Pointer);
TKDT14DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT14DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT14DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT14DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT14DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT14DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT14DS_DyanmicStoreBuffer;
KDBuff: TKDT14DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT14DS_Node;
TestBuff: TKDT14DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT14DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT14DS_Node;
function GetData(const Index: NativeInt): PKDT14DS_Source;
public
RootNode: PKDT14DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT14DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT14DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT14DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT14DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT14DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT14DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT14DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT14DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT14DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT14DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT14DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT14DS_Node; overload;
function Search(const buff: TKDT14DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT14DS_Node; overload;
function Search(const buff: TKDT14DS_Vec; var SearchedDistanceMin: Double): PKDT14DS_Node; overload;
function Search(const buff: TKDT14DS_Vec): PKDT14DS_Node; overload;
function SearchToken(const buff: TKDT14DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT14DS_DynamicVecBuffer; var OutBuff: TKDT14DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT14DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT14DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT14DS_Vec; overload;
class function Vec(const v: TKDT14DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT14DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT14DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT15DS = class(TCoreClassObject)
public type
// code split
TKDT15DS_Vec = array [0 .. KDT15DS_Axis - 1] of TKDT15DS_VecType;
PKDT15DS_Vec = ^TKDT15DS_Vec;
TKDT15DS_DynamicVecBuffer = array of TKDT15DS_Vec;
PKDT15DS_DynamicVecBuffer = ^TKDT15DS_DynamicVecBuffer;
TKDT15DS_Source = record
buff: TKDT15DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT15DS_Source = ^TKDT15DS_Source;
TKDT15DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT15DS_Source) - 1] of PKDT15DS_Source;
PKDT15DS_SourceBuffer = ^TKDT15DS_SourceBuffer;
TKDT15DS_DyanmicSourceBuffer = array of PKDT15DS_Source;
PKDT15DS_DyanmicSourceBuffer = ^TKDT15DS_DyanmicSourceBuffer;
TKDT15DS_DyanmicStoreBuffer = array of TKDT15DS_Source;
PKDT15DS_DyanmicStoreBuffer = ^TKDT15DS_DyanmicStoreBuffer;
PKDT15DS_Node = ^TKDT15DS_Node;
TKDT15DS_Node = record
Parent, Right, Left: PKDT15DS_Node;
Vec: PKDT15DS_Source;
end;
TKDT15DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT15DS_Source; const Data: Pointer);
TKDT15DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT15DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT15DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT15DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT15DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT15DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT15DS_DyanmicStoreBuffer;
KDBuff: TKDT15DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT15DS_Node;
TestBuff: TKDT15DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT15DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT15DS_Node;
function GetData(const Index: NativeInt): PKDT15DS_Source;
public
RootNode: PKDT15DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT15DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT15DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT15DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT15DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT15DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT15DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT15DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT15DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT15DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT15DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT15DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT15DS_Node; overload;
function Search(const buff: TKDT15DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT15DS_Node; overload;
function Search(const buff: TKDT15DS_Vec; var SearchedDistanceMin: Double): PKDT15DS_Node; overload;
function Search(const buff: TKDT15DS_Vec): PKDT15DS_Node; overload;
function SearchToken(const buff: TKDT15DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT15DS_DynamicVecBuffer; var OutBuff: TKDT15DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT15DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT15DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT15DS_Vec; overload;
class function Vec(const v: TKDT15DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT15DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT15DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT16DS = class(TCoreClassObject)
public type
// code split
TKDT16DS_Vec = array [0 .. KDT16DS_Axis - 1] of TKDT16DS_VecType;
PKDT16DS_Vec = ^TKDT16DS_Vec;
TKDT16DS_DynamicVecBuffer = array of TKDT16DS_Vec;
PKDT16DS_DynamicVecBuffer = ^TKDT16DS_DynamicVecBuffer;
TKDT16DS_Source = record
buff: TKDT16DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT16DS_Source = ^TKDT16DS_Source;
TKDT16DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT16DS_Source) - 1] of PKDT16DS_Source;
PKDT16DS_SourceBuffer = ^TKDT16DS_SourceBuffer;
TKDT16DS_DyanmicSourceBuffer = array of PKDT16DS_Source;
PKDT16DS_DyanmicSourceBuffer = ^TKDT16DS_DyanmicSourceBuffer;
TKDT16DS_DyanmicStoreBuffer = array of TKDT16DS_Source;
PKDT16DS_DyanmicStoreBuffer = ^TKDT16DS_DyanmicStoreBuffer;
PKDT16DS_Node = ^TKDT16DS_Node;
TKDT16DS_Node = record
Parent, Right, Left: PKDT16DS_Node;
Vec: PKDT16DS_Source;
end;
TKDT16DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT16DS_Source; const Data: Pointer);
TKDT16DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT16DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT16DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT16DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT16DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT16DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT16DS_DyanmicStoreBuffer;
KDBuff: TKDT16DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT16DS_Node;
TestBuff: TKDT16DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT16DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT16DS_Node;
function GetData(const Index: NativeInt): PKDT16DS_Source;
public
RootNode: PKDT16DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT16DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT16DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT16DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT16DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT16DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT16DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT16DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT16DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT16DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT16DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT16DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT16DS_Node; overload;
function Search(const buff: TKDT16DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT16DS_Node; overload;
function Search(const buff: TKDT16DS_Vec; var SearchedDistanceMin: Double): PKDT16DS_Node; overload;
function Search(const buff: TKDT16DS_Vec): PKDT16DS_Node; overload;
function SearchToken(const buff: TKDT16DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT16DS_DynamicVecBuffer; var OutBuff: TKDT16DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT16DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT16DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT16DS_Vec; overload;
class function Vec(const v: TKDT16DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT16DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT16DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT17DS = class(TCoreClassObject)
public type
// code split
TKDT17DS_Vec = array [0 .. KDT17DS_Axis - 1] of TKDT17DS_VecType;
PKDT17DS_Vec = ^TKDT17DS_Vec;
TKDT17DS_DynamicVecBuffer = array of TKDT17DS_Vec;
PKDT17DS_DynamicVecBuffer = ^TKDT17DS_DynamicVecBuffer;
TKDT17DS_Source = record
buff: TKDT17DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT17DS_Source = ^TKDT17DS_Source;
TKDT17DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT17DS_Source) - 1] of PKDT17DS_Source;
PKDT17DS_SourceBuffer = ^TKDT17DS_SourceBuffer;
TKDT17DS_DyanmicSourceBuffer = array of PKDT17DS_Source;
PKDT17DS_DyanmicSourceBuffer = ^TKDT17DS_DyanmicSourceBuffer;
TKDT17DS_DyanmicStoreBuffer = array of TKDT17DS_Source;
PKDT17DS_DyanmicStoreBuffer = ^TKDT17DS_DyanmicStoreBuffer;
PKDT17DS_Node = ^TKDT17DS_Node;
TKDT17DS_Node = record
Parent, Right, Left: PKDT17DS_Node;
Vec: PKDT17DS_Source;
end;
TKDT17DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT17DS_Source; const Data: Pointer);
TKDT17DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT17DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT17DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT17DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT17DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT17DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT17DS_DyanmicStoreBuffer;
KDBuff: TKDT17DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT17DS_Node;
TestBuff: TKDT17DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT17DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT17DS_Node;
function GetData(const Index: NativeInt): PKDT17DS_Source;
public
RootNode: PKDT17DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT17DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT17DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT17DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT17DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT17DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT17DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT17DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT17DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT17DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT17DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT17DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT17DS_Node; overload;
function Search(const buff: TKDT17DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT17DS_Node; overload;
function Search(const buff: TKDT17DS_Vec; var SearchedDistanceMin: Double): PKDT17DS_Node; overload;
function Search(const buff: TKDT17DS_Vec): PKDT17DS_Node; overload;
function SearchToken(const buff: TKDT17DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT17DS_DynamicVecBuffer; var OutBuff: TKDT17DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT17DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT17DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT17DS_Vec; overload;
class function Vec(const v: TKDT17DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT17DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT17DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT18DS = class(TCoreClassObject)
public type
// code split
TKDT18DS_Vec = array [0 .. KDT18DS_Axis - 1] of TKDT18DS_VecType;
PKDT18DS_Vec = ^TKDT18DS_Vec;
TKDT18DS_DynamicVecBuffer = array of TKDT18DS_Vec;
PKDT18DS_DynamicVecBuffer = ^TKDT18DS_DynamicVecBuffer;
TKDT18DS_Source = record
buff: TKDT18DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT18DS_Source = ^TKDT18DS_Source;
TKDT18DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT18DS_Source) - 1] of PKDT18DS_Source;
PKDT18DS_SourceBuffer = ^TKDT18DS_SourceBuffer;
TKDT18DS_DyanmicSourceBuffer = array of PKDT18DS_Source;
PKDT18DS_DyanmicSourceBuffer = ^TKDT18DS_DyanmicSourceBuffer;
TKDT18DS_DyanmicStoreBuffer = array of TKDT18DS_Source;
PKDT18DS_DyanmicStoreBuffer = ^TKDT18DS_DyanmicStoreBuffer;
PKDT18DS_Node = ^TKDT18DS_Node;
TKDT18DS_Node = record
Parent, Right, Left: PKDT18DS_Node;
Vec: PKDT18DS_Source;
end;
TKDT18DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT18DS_Source; const Data: Pointer);
TKDT18DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT18DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT18DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT18DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT18DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT18DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT18DS_DyanmicStoreBuffer;
KDBuff: TKDT18DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT18DS_Node;
TestBuff: TKDT18DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT18DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT18DS_Node;
function GetData(const Index: NativeInt): PKDT18DS_Source;
public
RootNode: PKDT18DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT18DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT18DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT18DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT18DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT18DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT18DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT18DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT18DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT18DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT18DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT18DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT18DS_Node; overload;
function Search(const buff: TKDT18DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT18DS_Node; overload;
function Search(const buff: TKDT18DS_Vec; var SearchedDistanceMin: Double): PKDT18DS_Node; overload;
function Search(const buff: TKDT18DS_Vec): PKDT18DS_Node; overload;
function SearchToken(const buff: TKDT18DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT18DS_DynamicVecBuffer; var OutBuff: TKDT18DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT18DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT18DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT18DS_Vec; overload;
class function Vec(const v: TKDT18DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT18DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT18DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT19DS = class(TCoreClassObject)
public type
// code split
TKDT19DS_Vec = array [0 .. KDT19DS_Axis - 1] of TKDT19DS_VecType;
PKDT19DS_Vec = ^TKDT19DS_Vec;
TKDT19DS_DynamicVecBuffer = array of TKDT19DS_Vec;
PKDT19DS_DynamicVecBuffer = ^TKDT19DS_DynamicVecBuffer;
TKDT19DS_Source = record
buff: TKDT19DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT19DS_Source = ^TKDT19DS_Source;
TKDT19DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT19DS_Source) - 1] of PKDT19DS_Source;
PKDT19DS_SourceBuffer = ^TKDT19DS_SourceBuffer;
TKDT19DS_DyanmicSourceBuffer = array of PKDT19DS_Source;
PKDT19DS_DyanmicSourceBuffer = ^TKDT19DS_DyanmicSourceBuffer;
TKDT19DS_DyanmicStoreBuffer = array of TKDT19DS_Source;
PKDT19DS_DyanmicStoreBuffer = ^TKDT19DS_DyanmicStoreBuffer;
PKDT19DS_Node = ^TKDT19DS_Node;
TKDT19DS_Node = record
Parent, Right, Left: PKDT19DS_Node;
Vec: PKDT19DS_Source;
end;
TKDT19DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT19DS_Source; const Data: Pointer);
TKDT19DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT19DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT19DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT19DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT19DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT19DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT19DS_DyanmicStoreBuffer;
KDBuff: TKDT19DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT19DS_Node;
TestBuff: TKDT19DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT19DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT19DS_Node;
function GetData(const Index: NativeInt): PKDT19DS_Source;
public
RootNode: PKDT19DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT19DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT19DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT19DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT19DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT19DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT19DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT19DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT19DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT19DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT19DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT19DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT19DS_Node; overload;
function Search(const buff: TKDT19DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT19DS_Node; overload;
function Search(const buff: TKDT19DS_Vec; var SearchedDistanceMin: Double): PKDT19DS_Node; overload;
function Search(const buff: TKDT19DS_Vec): PKDT19DS_Node; overload;
function SearchToken(const buff: TKDT19DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT19DS_DynamicVecBuffer; var OutBuff: TKDT19DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT19DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT19DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT19DS_Vec; overload;
class function Vec(const v: TKDT19DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT19DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT19DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT20DS = class(TCoreClassObject)
public type
// code split
TKDT20DS_Vec = array [0 .. KDT20DS_Axis - 1] of TKDT20DS_VecType;
PKDT20DS_Vec = ^TKDT20DS_Vec;
TKDT20DS_DynamicVecBuffer = array of TKDT20DS_Vec;
PKDT20DS_DynamicVecBuffer = ^TKDT20DS_DynamicVecBuffer;
TKDT20DS_Source = record
buff: TKDT20DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT20DS_Source = ^TKDT20DS_Source;
TKDT20DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT20DS_Source) - 1] of PKDT20DS_Source;
PKDT20DS_SourceBuffer = ^TKDT20DS_SourceBuffer;
TKDT20DS_DyanmicSourceBuffer = array of PKDT20DS_Source;
PKDT20DS_DyanmicSourceBuffer = ^TKDT20DS_DyanmicSourceBuffer;
TKDT20DS_DyanmicStoreBuffer = array of TKDT20DS_Source;
PKDT20DS_DyanmicStoreBuffer = ^TKDT20DS_DyanmicStoreBuffer;
PKDT20DS_Node = ^TKDT20DS_Node;
TKDT20DS_Node = record
Parent, Right, Left: PKDT20DS_Node;
Vec: PKDT20DS_Source;
end;
TKDT20DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT20DS_Source; const Data: Pointer);
TKDT20DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT20DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT20DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT20DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT20DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT20DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT20DS_DyanmicStoreBuffer;
KDBuff: TKDT20DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT20DS_Node;
TestBuff: TKDT20DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT20DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT20DS_Node;
function GetData(const Index: NativeInt): PKDT20DS_Source;
public
RootNode: PKDT20DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT20DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT20DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT20DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT20DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT20DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT20DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT20DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT20DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT20DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT20DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT20DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT20DS_Node; overload;
function Search(const buff: TKDT20DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT20DS_Node; overload;
function Search(const buff: TKDT20DS_Vec; var SearchedDistanceMin: Double): PKDT20DS_Node; overload;
function Search(const buff: TKDT20DS_Vec): PKDT20DS_Node; overload;
function SearchToken(const buff: TKDT20DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT20DS_DynamicVecBuffer; var OutBuff: TKDT20DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT20DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT20DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT20DS_Vec; overload;
class function Vec(const v: TKDT20DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT20DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT20DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT21DS = class(TCoreClassObject)
public type
// code split
TKDT21DS_Vec = array [0 .. KDT21DS_Axis - 1] of TKDT21DS_VecType;
PKDT21DS_Vec = ^TKDT21DS_Vec;
TKDT21DS_DynamicVecBuffer = array of TKDT21DS_Vec;
PKDT21DS_DynamicVecBuffer = ^TKDT21DS_DynamicVecBuffer;
TKDT21DS_Source = record
buff: TKDT21DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT21DS_Source = ^TKDT21DS_Source;
TKDT21DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT21DS_Source) - 1] of PKDT21DS_Source;
PKDT21DS_SourceBuffer = ^TKDT21DS_SourceBuffer;
TKDT21DS_DyanmicSourceBuffer = array of PKDT21DS_Source;
PKDT21DS_DyanmicSourceBuffer = ^TKDT21DS_DyanmicSourceBuffer;
TKDT21DS_DyanmicStoreBuffer = array of TKDT21DS_Source;
PKDT21DS_DyanmicStoreBuffer = ^TKDT21DS_DyanmicStoreBuffer;
PKDT21DS_Node = ^TKDT21DS_Node;
TKDT21DS_Node = record
Parent, Right, Left: PKDT21DS_Node;
Vec: PKDT21DS_Source;
end;
TKDT21DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT21DS_Source; const Data: Pointer);
TKDT21DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT21DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT21DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT21DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT21DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT21DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT21DS_DyanmicStoreBuffer;
KDBuff: TKDT21DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT21DS_Node;
TestBuff: TKDT21DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT21DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT21DS_Node;
function GetData(const Index: NativeInt): PKDT21DS_Source;
public
RootNode: PKDT21DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT21DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT21DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT21DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT21DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT21DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT21DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT21DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT21DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT21DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT21DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT21DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT21DS_Node; overload;
function Search(const buff: TKDT21DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT21DS_Node; overload;
function Search(const buff: TKDT21DS_Vec; var SearchedDistanceMin: Double): PKDT21DS_Node; overload;
function Search(const buff: TKDT21DS_Vec): PKDT21DS_Node; overload;
function SearchToken(const buff: TKDT21DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT21DS_DynamicVecBuffer; var OutBuff: TKDT21DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT21DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT21DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT21DS_Vec; overload;
class function Vec(const v: TKDT21DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT21DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT21DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT22DS = class(TCoreClassObject)
public type
// code split
TKDT22DS_Vec = array [0 .. KDT22DS_Axis - 1] of TKDT22DS_VecType;
PKDT22DS_Vec = ^TKDT22DS_Vec;
TKDT22DS_DynamicVecBuffer = array of TKDT22DS_Vec;
PKDT22DS_DynamicVecBuffer = ^TKDT22DS_DynamicVecBuffer;
TKDT22DS_Source = record
buff: TKDT22DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT22DS_Source = ^TKDT22DS_Source;
TKDT22DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT22DS_Source) - 1] of PKDT22DS_Source;
PKDT22DS_SourceBuffer = ^TKDT22DS_SourceBuffer;
TKDT22DS_DyanmicSourceBuffer = array of PKDT22DS_Source;
PKDT22DS_DyanmicSourceBuffer = ^TKDT22DS_DyanmicSourceBuffer;
TKDT22DS_DyanmicStoreBuffer = array of TKDT22DS_Source;
PKDT22DS_DyanmicStoreBuffer = ^TKDT22DS_DyanmicStoreBuffer;
PKDT22DS_Node = ^TKDT22DS_Node;
TKDT22DS_Node = record
Parent, Right, Left: PKDT22DS_Node;
Vec: PKDT22DS_Source;
end;
TKDT22DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT22DS_Source; const Data: Pointer);
TKDT22DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT22DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT22DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT22DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT22DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT22DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT22DS_DyanmicStoreBuffer;
KDBuff: TKDT22DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT22DS_Node;
TestBuff: TKDT22DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT22DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT22DS_Node;
function GetData(const Index: NativeInt): PKDT22DS_Source;
public
RootNode: PKDT22DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT22DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT22DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT22DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT22DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT22DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT22DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT22DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT22DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT22DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT22DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT22DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT22DS_Node; overload;
function Search(const buff: TKDT22DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT22DS_Node; overload;
function Search(const buff: TKDT22DS_Vec; var SearchedDistanceMin: Double): PKDT22DS_Node; overload;
function Search(const buff: TKDT22DS_Vec): PKDT22DS_Node; overload;
function SearchToken(const buff: TKDT22DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT22DS_DynamicVecBuffer; var OutBuff: TKDT22DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT22DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT22DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT22DS_Vec; overload;
class function Vec(const v: TKDT22DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT22DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT22DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT23DS = class(TCoreClassObject)
public type
// code split
TKDT23DS_Vec = array [0 .. KDT23DS_Axis - 1] of TKDT23DS_VecType;
PKDT23DS_Vec = ^TKDT23DS_Vec;
TKDT23DS_DynamicVecBuffer = array of TKDT23DS_Vec;
PKDT23DS_DynamicVecBuffer = ^TKDT23DS_DynamicVecBuffer;
TKDT23DS_Source = record
buff: TKDT23DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT23DS_Source = ^TKDT23DS_Source;
TKDT23DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT23DS_Source) - 1] of PKDT23DS_Source;
PKDT23DS_SourceBuffer = ^TKDT23DS_SourceBuffer;
TKDT23DS_DyanmicSourceBuffer = array of PKDT23DS_Source;
PKDT23DS_DyanmicSourceBuffer = ^TKDT23DS_DyanmicSourceBuffer;
TKDT23DS_DyanmicStoreBuffer = array of TKDT23DS_Source;
PKDT23DS_DyanmicStoreBuffer = ^TKDT23DS_DyanmicStoreBuffer;
PKDT23DS_Node = ^TKDT23DS_Node;
TKDT23DS_Node = record
Parent, Right, Left: PKDT23DS_Node;
Vec: PKDT23DS_Source;
end;
TKDT23DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT23DS_Source; const Data: Pointer);
TKDT23DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT23DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT23DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT23DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT23DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT23DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT23DS_DyanmicStoreBuffer;
KDBuff: TKDT23DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT23DS_Node;
TestBuff: TKDT23DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT23DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT23DS_Node;
function GetData(const Index: NativeInt): PKDT23DS_Source;
public
RootNode: PKDT23DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT23DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT23DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT23DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT23DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT23DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT23DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT23DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT23DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT23DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT23DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT23DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT23DS_Node; overload;
function Search(const buff: TKDT23DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT23DS_Node; overload;
function Search(const buff: TKDT23DS_Vec; var SearchedDistanceMin: Double): PKDT23DS_Node; overload;
function Search(const buff: TKDT23DS_Vec): PKDT23DS_Node; overload;
function SearchToken(const buff: TKDT23DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT23DS_DynamicVecBuffer; var OutBuff: TKDT23DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT23DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT23DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT23DS_Vec; overload;
class function Vec(const v: TKDT23DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT23DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT23DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT24DS = class(TCoreClassObject)
public type
// code split
TKDT24DS_Vec = array [0 .. KDT24DS_Axis - 1] of TKDT24DS_VecType;
PKDT24DS_Vec = ^TKDT24DS_Vec;
TKDT24DS_DynamicVecBuffer = array of TKDT24DS_Vec;
PKDT24DS_DynamicVecBuffer = ^TKDT24DS_DynamicVecBuffer;
TKDT24DS_Source = record
buff: TKDT24DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT24DS_Source = ^TKDT24DS_Source;
TKDT24DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT24DS_Source) - 1] of PKDT24DS_Source;
PKDT24DS_SourceBuffer = ^TKDT24DS_SourceBuffer;
TKDT24DS_DyanmicSourceBuffer = array of PKDT24DS_Source;
PKDT24DS_DyanmicSourceBuffer = ^TKDT24DS_DyanmicSourceBuffer;
TKDT24DS_DyanmicStoreBuffer = array of TKDT24DS_Source;
PKDT24DS_DyanmicStoreBuffer = ^TKDT24DS_DyanmicStoreBuffer;
PKDT24DS_Node = ^TKDT24DS_Node;
TKDT24DS_Node = record
Parent, Right, Left: PKDT24DS_Node;
Vec: PKDT24DS_Source;
end;
TKDT24DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT24DS_Source; const Data: Pointer);
TKDT24DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT24DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT24DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT24DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT24DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT24DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT24DS_DyanmicStoreBuffer;
KDBuff: TKDT24DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT24DS_Node;
TestBuff: TKDT24DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT24DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT24DS_Node;
function GetData(const Index: NativeInt): PKDT24DS_Source;
public
RootNode: PKDT24DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT24DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT24DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT24DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT24DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT24DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT24DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT24DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT24DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT24DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT24DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT24DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT24DS_Node; overload;
function Search(const buff: TKDT24DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT24DS_Node; overload;
function Search(const buff: TKDT24DS_Vec; var SearchedDistanceMin: Double): PKDT24DS_Node; overload;
function Search(const buff: TKDT24DS_Vec): PKDT24DS_Node; overload;
function SearchToken(const buff: TKDT24DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT24DS_DynamicVecBuffer; var OutBuff: TKDT24DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT24DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT24DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT24DS_Vec; overload;
class function Vec(const v: TKDT24DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT24DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT24DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT48DS = class(TCoreClassObject)
public type
// code split
TKDT48DS_Vec = array [0 .. KDT48DS_Axis - 1] of TKDT48DS_VecType;
PKDT48DS_Vec = ^TKDT48DS_Vec;
TKDT48DS_DynamicVecBuffer = array of TKDT48DS_Vec;
PKDT48DS_DynamicVecBuffer = ^TKDT48DS_DynamicVecBuffer;
TKDT48DS_Source = record
buff: TKDT48DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT48DS_Source = ^TKDT48DS_Source;
TKDT48DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT48DS_Source) - 1] of PKDT48DS_Source;
PKDT48DS_SourceBuffer = ^TKDT48DS_SourceBuffer;
TKDT48DS_DyanmicSourceBuffer = array of PKDT48DS_Source;
PKDT48DS_DyanmicSourceBuffer = ^TKDT48DS_DyanmicSourceBuffer;
TKDT48DS_DyanmicStoreBuffer = array of TKDT48DS_Source;
PKDT48DS_DyanmicStoreBuffer = ^TKDT48DS_DyanmicStoreBuffer;
PKDT48DS_Node = ^TKDT48DS_Node;
TKDT48DS_Node = record
Parent, Right, Left: PKDT48DS_Node;
Vec: PKDT48DS_Source;
end;
TKDT48DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT48DS_Source; const Data: Pointer);
TKDT48DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT48DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT48DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT48DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT48DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT48DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT48DS_DyanmicStoreBuffer;
KDBuff: TKDT48DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT48DS_Node;
TestBuff: TKDT48DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT48DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT48DS_Node;
function GetData(const Index: NativeInt): PKDT48DS_Source;
public
RootNode: PKDT48DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT48DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT48DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT48DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT48DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT48DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT48DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT48DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT48DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT48DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT48DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT48DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT48DS_Node; overload;
function Search(const buff: TKDT48DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT48DS_Node; overload;
function Search(const buff: TKDT48DS_Vec; var SearchedDistanceMin: Double): PKDT48DS_Node; overload;
function Search(const buff: TKDT48DS_Vec): PKDT48DS_Node; overload;
function SearchToken(const buff: TKDT48DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT48DS_DynamicVecBuffer; var OutBuff: TKDT48DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT48DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT48DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT48DS_Vec; overload;
class function Vec(const v: TKDT48DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT48DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT48DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT52DS = class(TCoreClassObject)
public type
// code split
TKDT52DS_Vec = array [0 .. KDT52DS_Axis - 1] of TKDT52DS_VecType;
PKDT52DS_Vec = ^TKDT52DS_Vec;
TKDT52DS_DynamicVecBuffer = array of TKDT52DS_Vec;
PKDT52DS_DynamicVecBuffer = ^TKDT52DS_DynamicVecBuffer;
TKDT52DS_Source = record
buff: TKDT52DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT52DS_Source = ^TKDT52DS_Source;
TKDT52DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT52DS_Source) - 1] of PKDT52DS_Source;
PKDT52DS_SourceBuffer = ^TKDT52DS_SourceBuffer;
TKDT52DS_DyanmicSourceBuffer = array of PKDT52DS_Source;
PKDT52DS_DyanmicSourceBuffer = ^TKDT52DS_DyanmicSourceBuffer;
TKDT52DS_DyanmicStoreBuffer = array of TKDT52DS_Source;
PKDT52DS_DyanmicStoreBuffer = ^TKDT52DS_DyanmicStoreBuffer;
PKDT52DS_Node = ^TKDT52DS_Node;
TKDT52DS_Node = record
Parent, Right, Left: PKDT52DS_Node;
Vec: PKDT52DS_Source;
end;
TKDT52DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT52DS_Source; const Data: Pointer);
TKDT52DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT52DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT52DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT52DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT52DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT52DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT52DS_DyanmicStoreBuffer;
KDBuff: TKDT52DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT52DS_Node;
TestBuff: TKDT52DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT52DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT52DS_Node;
function GetData(const Index: NativeInt): PKDT52DS_Source;
public
RootNode: PKDT52DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT52DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT52DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT52DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT52DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT52DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT52DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT52DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT52DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT52DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT52DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT52DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT52DS_Node; overload;
function Search(const buff: TKDT52DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT52DS_Node; overload;
function Search(const buff: TKDT52DS_Vec; var SearchedDistanceMin: Double): PKDT52DS_Node; overload;
function Search(const buff: TKDT52DS_Vec): PKDT52DS_Node; overload;
function SearchToken(const buff: TKDT52DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT52DS_DynamicVecBuffer; var OutBuff: TKDT52DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT52DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT52DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT52DS_Vec; overload;
class function Vec(const v: TKDT52DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT52DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT52DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT64DS = class(TCoreClassObject)
public type
// code split
TKDT64DS_Vec = array [0 .. KDT64DS_Axis - 1] of TKDT64DS_VecType;
PKDT64DS_Vec = ^TKDT64DS_Vec;
TKDT64DS_DynamicVecBuffer = array of TKDT64DS_Vec;
PKDT64DS_DynamicVecBuffer = ^TKDT64DS_DynamicVecBuffer;
TKDT64DS_Source = record
buff: TKDT64DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT64DS_Source = ^TKDT64DS_Source;
TKDT64DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT64DS_Source) - 1] of PKDT64DS_Source;
PKDT64DS_SourceBuffer = ^TKDT64DS_SourceBuffer;
TKDT64DS_DyanmicSourceBuffer = array of PKDT64DS_Source;
PKDT64DS_DyanmicSourceBuffer = ^TKDT64DS_DyanmicSourceBuffer;
TKDT64DS_DyanmicStoreBuffer = array of TKDT64DS_Source;
PKDT64DS_DyanmicStoreBuffer = ^TKDT64DS_DyanmicStoreBuffer;
PKDT64DS_Node = ^TKDT64DS_Node;
TKDT64DS_Node = record
Parent, Right, Left: PKDT64DS_Node;
Vec: PKDT64DS_Source;
end;
TKDT64DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT64DS_Source; const Data: Pointer);
TKDT64DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT64DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT64DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT64DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT64DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT64DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT64DS_DyanmicStoreBuffer;
KDBuff: TKDT64DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT64DS_Node;
TestBuff: TKDT64DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT64DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT64DS_Node;
function GetData(const Index: NativeInt): PKDT64DS_Source;
public
RootNode: PKDT64DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT64DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT64DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT64DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT64DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT64DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT64DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT64DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT64DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT64DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT64DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT64DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT64DS_Node; overload;
function Search(const buff: TKDT64DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT64DS_Node; overload;
function Search(const buff: TKDT64DS_Vec; var SearchedDistanceMin: Double): PKDT64DS_Node; overload;
function Search(const buff: TKDT64DS_Vec): PKDT64DS_Node; overload;
function SearchToken(const buff: TKDT64DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT64DS_DynamicVecBuffer; var OutBuff: TKDT64DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT64DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT64DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT64DS_Vec; overload;
class function Vec(const v: TKDT64DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT64DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT64DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT96DS = class(TCoreClassObject)
public type
// code split
TKDT96DS_Vec = array [0 .. KDT96DS_Axis - 1] of TKDT96DS_VecType;
PKDT96DS_Vec = ^TKDT96DS_Vec;
TKDT96DS_DynamicVecBuffer = array of TKDT96DS_Vec;
PKDT96DS_DynamicVecBuffer = ^TKDT96DS_DynamicVecBuffer;
TKDT96DS_Source = record
buff: TKDT96DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT96DS_Source = ^TKDT96DS_Source;
TKDT96DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT96DS_Source) - 1] of PKDT96DS_Source;
PKDT96DS_SourceBuffer = ^TKDT96DS_SourceBuffer;
TKDT96DS_DyanmicSourceBuffer = array of PKDT96DS_Source;
PKDT96DS_DyanmicSourceBuffer = ^TKDT96DS_DyanmicSourceBuffer;
TKDT96DS_DyanmicStoreBuffer = array of TKDT96DS_Source;
PKDT96DS_DyanmicStoreBuffer = ^TKDT96DS_DyanmicStoreBuffer;
PKDT96DS_Node = ^TKDT96DS_Node;
TKDT96DS_Node = record
Parent, Right, Left: PKDT96DS_Node;
Vec: PKDT96DS_Source;
end;
TKDT96DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT96DS_Source; const Data: Pointer);
TKDT96DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT96DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT96DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT96DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT96DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT96DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT96DS_DyanmicStoreBuffer;
KDBuff: TKDT96DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT96DS_Node;
TestBuff: TKDT96DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT96DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT96DS_Node;
function GetData(const Index: NativeInt): PKDT96DS_Source;
public
RootNode: PKDT96DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT96DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT96DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT96DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT96DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT96DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT96DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT96DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT96DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT96DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT96DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT96DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT96DS_Node; overload;
function Search(const buff: TKDT96DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT96DS_Node; overload;
function Search(const buff: TKDT96DS_Vec; var SearchedDistanceMin: Double): PKDT96DS_Node; overload;
function Search(const buff: TKDT96DS_Vec): PKDT96DS_Node; overload;
function SearchToken(const buff: TKDT96DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT96DS_DynamicVecBuffer; var OutBuff: TKDT96DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT96DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT96DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT96DS_Vec; overload;
class function Vec(const v: TKDT96DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT96DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT96DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT128DS = class(TCoreClassObject)
public type
// code split
TKDT128DS_Vec = array [0 .. KDT128DS_Axis - 1] of TKDT128DS_VecType;
PKDT128DS_Vec = ^TKDT128DS_Vec;
TKDT128DS_DynamicVecBuffer = array of TKDT128DS_Vec;
PKDT128DS_DynamicVecBuffer = ^TKDT128DS_DynamicVecBuffer;
TKDT128DS_Source = record
buff: TKDT128DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT128DS_Source = ^TKDT128DS_Source;
TKDT128DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT128DS_Source) - 1] of PKDT128DS_Source;
PKDT128DS_SourceBuffer = ^TKDT128DS_SourceBuffer;
TKDT128DS_DyanmicSourceBuffer = array of PKDT128DS_Source;
PKDT128DS_DyanmicSourceBuffer = ^TKDT128DS_DyanmicSourceBuffer;
TKDT128DS_DyanmicStoreBuffer = array of TKDT128DS_Source;
PKDT128DS_DyanmicStoreBuffer = ^TKDT128DS_DyanmicStoreBuffer;
PKDT128DS_Node = ^TKDT128DS_Node;
TKDT128DS_Node = record
Parent, Right, Left: PKDT128DS_Node;
Vec: PKDT128DS_Source;
end;
TKDT128DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT128DS_Source; const Data: Pointer);
TKDT128DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT128DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT128DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT128DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT128DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT128DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT128DS_DyanmicStoreBuffer;
KDBuff: TKDT128DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT128DS_Node;
TestBuff: TKDT128DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT128DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT128DS_Node;
function GetData(const Index: NativeInt): PKDT128DS_Source;
public
RootNode: PKDT128DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT128DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT128DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT128DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT128DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT128DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT128DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT128DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT128DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT128DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT128DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT128DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT128DS_Node; overload;
function Search(const buff: TKDT128DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT128DS_Node; overload;
function Search(const buff: TKDT128DS_Vec; var SearchedDistanceMin: Double): PKDT128DS_Node; overload;
function Search(const buff: TKDT128DS_Vec): PKDT128DS_Node; overload;
function SearchToken(const buff: TKDT128DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT128DS_DynamicVecBuffer; var OutBuff: TKDT128DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT128DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT128DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT128DS_Vec; overload;
class function Vec(const v: TKDT128DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT128DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT128DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT156DS = class(TCoreClassObject)
public type
// code split
TKDT156DS_Vec = array [0 .. KDT156DS_Axis - 1] of TKDT156DS_VecType;
PKDT156DS_Vec = ^TKDT156DS_Vec;
TKDT156DS_DynamicVecBuffer = array of TKDT156DS_Vec;
PKDT156DS_DynamicVecBuffer = ^TKDT156DS_DynamicVecBuffer;
TKDT156DS_Source = record
buff: TKDT156DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT156DS_Source = ^TKDT156DS_Source;
TKDT156DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT156DS_Source) - 1] of PKDT156DS_Source;
PKDT156DS_SourceBuffer = ^TKDT156DS_SourceBuffer;
TKDT156DS_DyanmicSourceBuffer = array of PKDT156DS_Source;
PKDT156DS_DyanmicSourceBuffer = ^TKDT156DS_DyanmicSourceBuffer;
TKDT156DS_DyanmicStoreBuffer = array of TKDT156DS_Source;
PKDT156DS_DyanmicStoreBuffer = ^TKDT156DS_DyanmicStoreBuffer;
PKDT156DS_Node = ^TKDT156DS_Node;
TKDT156DS_Node = record
Parent, Right, Left: PKDT156DS_Node;
Vec: PKDT156DS_Source;
end;
TKDT156DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT156DS_Source; const Data: Pointer);
TKDT156DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT156DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT156DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT156DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT156DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT156DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT156DS_DyanmicStoreBuffer;
KDBuff: TKDT156DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT156DS_Node;
TestBuff: TKDT156DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT156DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT156DS_Node;
function GetData(const Index: NativeInt): PKDT156DS_Source;
public
RootNode: PKDT156DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT156DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT156DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT156DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT156DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT156DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT156DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT156DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT156DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT156DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT156DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT156DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT156DS_Node; overload;
function Search(const buff: TKDT156DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT156DS_Node; overload;
function Search(const buff: TKDT156DS_Vec; var SearchedDistanceMin: Double): PKDT156DS_Node; overload;
function Search(const buff: TKDT156DS_Vec): PKDT156DS_Node; overload;
function SearchToken(const buff: TKDT156DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT156DS_DynamicVecBuffer; var OutBuff: TKDT156DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT156DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT156DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT156DS_Vec; overload;
class function Vec(const v: TKDT156DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT156DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT156DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT192DS = class(TCoreClassObject)
public type
// code split
TKDT192DS_Vec = array [0 .. KDT192DS_Axis - 1] of TKDT192DS_VecType;
PKDT192DS_Vec = ^TKDT192DS_Vec;
TKDT192DS_DynamicVecBuffer = array of TKDT192DS_Vec;
PKDT192DS_DynamicVecBuffer = ^TKDT192DS_DynamicVecBuffer;
TKDT192DS_Source = record
buff: TKDT192DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT192DS_Source = ^TKDT192DS_Source;
TKDT192DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT192DS_Source) - 1] of PKDT192DS_Source;
PKDT192DS_SourceBuffer = ^TKDT192DS_SourceBuffer;
TKDT192DS_DyanmicSourceBuffer = array of PKDT192DS_Source;
PKDT192DS_DyanmicSourceBuffer = ^TKDT192DS_DyanmicSourceBuffer;
TKDT192DS_DyanmicStoreBuffer = array of TKDT192DS_Source;
PKDT192DS_DyanmicStoreBuffer = ^TKDT192DS_DyanmicStoreBuffer;
PKDT192DS_Node = ^TKDT192DS_Node;
TKDT192DS_Node = record
Parent, Right, Left: PKDT192DS_Node;
Vec: PKDT192DS_Source;
end;
TKDT192DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT192DS_Source; const Data: Pointer);
TKDT192DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT192DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT192DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT192DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT192DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT192DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT192DS_DyanmicStoreBuffer;
KDBuff: TKDT192DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT192DS_Node;
TestBuff: TKDT192DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT192DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT192DS_Node;
function GetData(const Index: NativeInt): PKDT192DS_Source;
public
RootNode: PKDT192DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT192DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT192DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT192DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT192DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT192DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT192DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT192DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT192DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT192DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT192DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT192DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT192DS_Node; overload;
function Search(const buff: TKDT192DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT192DS_Node; overload;
function Search(const buff: TKDT192DS_Vec; var SearchedDistanceMin: Double): PKDT192DS_Node; overload;
function Search(const buff: TKDT192DS_Vec): PKDT192DS_Node; overload;
function SearchToken(const buff: TKDT192DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT192DS_DynamicVecBuffer; var OutBuff: TKDT192DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT192DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT192DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT192DS_Vec; overload;
class function Vec(const v: TKDT192DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT192DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT192DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT256DS = class(TCoreClassObject)
public type
// code split
TKDT256DS_Vec = array [0 .. KDT256DS_Axis - 1] of TKDT256DS_VecType;
PKDT256DS_Vec = ^TKDT256DS_Vec;
TKDT256DS_DynamicVecBuffer = array of TKDT256DS_Vec;
PKDT256DS_DynamicVecBuffer = ^TKDT256DS_DynamicVecBuffer;
TKDT256DS_Source = record
buff: TKDT256DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT256DS_Source = ^TKDT256DS_Source;
TKDT256DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT256DS_Source) - 1] of PKDT256DS_Source;
PKDT256DS_SourceBuffer = ^TKDT256DS_SourceBuffer;
TKDT256DS_DyanmicSourceBuffer = array of PKDT256DS_Source;
PKDT256DS_DyanmicSourceBuffer = ^TKDT256DS_DyanmicSourceBuffer;
TKDT256DS_DyanmicStoreBuffer = array of TKDT256DS_Source;
PKDT256DS_DyanmicStoreBuffer = ^TKDT256DS_DyanmicStoreBuffer;
PKDT256DS_Node = ^TKDT256DS_Node;
TKDT256DS_Node = record
Parent, Right, Left: PKDT256DS_Node;
Vec: PKDT256DS_Source;
end;
TKDT256DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT256DS_Source; const Data: Pointer);
TKDT256DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT256DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT256DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT256DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT256DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT256DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT256DS_DyanmicStoreBuffer;
KDBuff: TKDT256DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT256DS_Node;
TestBuff: TKDT256DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT256DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT256DS_Node;
function GetData(const Index: NativeInt): PKDT256DS_Source;
public
RootNode: PKDT256DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT256DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT256DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT256DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT256DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT256DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT256DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT256DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT256DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT256DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT256DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT256DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT256DS_Node; overload;
function Search(const buff: TKDT256DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT256DS_Node; overload;
function Search(const buff: TKDT256DS_Vec; var SearchedDistanceMin: Double): PKDT256DS_Node; overload;
function Search(const buff: TKDT256DS_Vec): PKDT256DS_Node; overload;
function SearchToken(const buff: TKDT256DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT256DS_DynamicVecBuffer; var OutBuff: TKDT256DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT256DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT256DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT256DS_Vec; overload;
class function Vec(const v: TKDT256DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT256DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT256DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT384DS = class(TCoreClassObject)
public type
// code split
TKDT384DS_Vec = array [0 .. KDT384DS_Axis - 1] of TKDT384DS_VecType;
PKDT384DS_Vec = ^TKDT384DS_Vec;
TKDT384DS_DynamicVecBuffer = array of TKDT384DS_Vec;
PKDT384DS_DynamicVecBuffer = ^TKDT384DS_DynamicVecBuffer;
TKDT384DS_Source = record
buff: TKDT384DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT384DS_Source = ^TKDT384DS_Source;
TKDT384DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT384DS_Source) - 1] of PKDT384DS_Source;
PKDT384DS_SourceBuffer = ^TKDT384DS_SourceBuffer;
TKDT384DS_DyanmicSourceBuffer = array of PKDT384DS_Source;
PKDT384DS_DyanmicSourceBuffer = ^TKDT384DS_DyanmicSourceBuffer;
TKDT384DS_DyanmicStoreBuffer = array of TKDT384DS_Source;
PKDT384DS_DyanmicStoreBuffer = ^TKDT384DS_DyanmicStoreBuffer;
PKDT384DS_Node = ^TKDT384DS_Node;
TKDT384DS_Node = record
Parent, Right, Left: PKDT384DS_Node;
Vec: PKDT384DS_Source;
end;
TKDT384DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT384DS_Source; const Data: Pointer);
TKDT384DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT384DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT384DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT384DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT384DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT384DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT384DS_DyanmicStoreBuffer;
KDBuff: TKDT384DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT384DS_Node;
TestBuff: TKDT384DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT384DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT384DS_Node;
function GetData(const Index: NativeInt): PKDT384DS_Source;
public
RootNode: PKDT384DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT384DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT384DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT384DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT384DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT384DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT384DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT384DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT384DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT384DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT384DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT384DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT384DS_Node; overload;
function Search(const buff: TKDT384DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT384DS_Node; overload;
function Search(const buff: TKDT384DS_Vec; var SearchedDistanceMin: Double): PKDT384DS_Node; overload;
function Search(const buff: TKDT384DS_Vec): PKDT384DS_Node; overload;
function SearchToken(const buff: TKDT384DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT384DS_DynamicVecBuffer; var OutBuff: TKDT384DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT384DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT384DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT384DS_Vec; overload;
class function Vec(const v: TKDT384DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT384DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT384DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT512DS = class(TCoreClassObject)
public type
// code split
TKDT512DS_Vec = array [0 .. KDT512DS_Axis - 1] of TKDT512DS_VecType;
PKDT512DS_Vec = ^TKDT512DS_Vec;
TKDT512DS_DynamicVecBuffer = array of TKDT512DS_Vec;
PKDT512DS_DynamicVecBuffer = ^TKDT512DS_DynamicVecBuffer;
TKDT512DS_Source = record
buff: TKDT512DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT512DS_Source = ^TKDT512DS_Source;
TKDT512DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT512DS_Source) - 1] of PKDT512DS_Source;
PKDT512DS_SourceBuffer = ^TKDT512DS_SourceBuffer;
TKDT512DS_DyanmicSourceBuffer = array of PKDT512DS_Source;
PKDT512DS_DyanmicSourceBuffer = ^TKDT512DS_DyanmicSourceBuffer;
TKDT512DS_DyanmicStoreBuffer = array of TKDT512DS_Source;
PKDT512DS_DyanmicStoreBuffer = ^TKDT512DS_DyanmicStoreBuffer;
PKDT512DS_Node = ^TKDT512DS_Node;
TKDT512DS_Node = record
Parent, Right, Left: PKDT512DS_Node;
Vec: PKDT512DS_Source;
end;
TKDT512DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT512DS_Source; const Data: Pointer);
TKDT512DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT512DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT512DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT512DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT512DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT512DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT512DS_DyanmicStoreBuffer;
KDBuff: TKDT512DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT512DS_Node;
TestBuff: TKDT512DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT512DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT512DS_Node;
function GetData(const Index: NativeInt): PKDT512DS_Source;
public
RootNode: PKDT512DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT512DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT512DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT512DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT512DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT512DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT512DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT512DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT512DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT512DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT512DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT512DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT512DS_Node; overload;
function Search(const buff: TKDT512DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT512DS_Node; overload;
function Search(const buff: TKDT512DS_Vec; var SearchedDistanceMin: Double): PKDT512DS_Node; overload;
function Search(const buff: TKDT512DS_Vec): PKDT512DS_Node; overload;
function SearchToken(const buff: TKDT512DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT512DS_DynamicVecBuffer; var OutBuff: TKDT512DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT512DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT512DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT512DS_Vec; overload;
class function Vec(const v: TKDT512DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT512DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT512DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT800DS = class(TCoreClassObject)
public type
// code split
TKDT800DS_Vec = array [0 .. KDT800DS_Axis - 1] of TKDT800DS_VecType;
PKDT800DS_Vec = ^TKDT800DS_Vec;
TKDT800DS_DynamicVecBuffer = array of TKDT800DS_Vec;
PKDT800DS_DynamicVecBuffer = ^TKDT800DS_DynamicVecBuffer;
TKDT800DS_Source = record
buff: TKDT800DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT800DS_Source = ^TKDT800DS_Source;
TKDT800DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT800DS_Source) - 1] of PKDT800DS_Source;
PKDT800DS_SourceBuffer = ^TKDT800DS_SourceBuffer;
TKDT800DS_DyanmicSourceBuffer = array of PKDT800DS_Source;
PKDT800DS_DyanmicSourceBuffer = ^TKDT800DS_DyanmicSourceBuffer;
TKDT800DS_DyanmicStoreBuffer = array of TKDT800DS_Source;
PKDT800DS_DyanmicStoreBuffer = ^TKDT800DS_DyanmicStoreBuffer;
PKDT800DS_Node = ^TKDT800DS_Node;
TKDT800DS_Node = record
Parent, Right, Left: PKDT800DS_Node;
Vec: PKDT800DS_Source;
end;
TKDT800DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT800DS_Source; const Data: Pointer);
TKDT800DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT800DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT800DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT800DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT800DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT800DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT800DS_DyanmicStoreBuffer;
KDBuff: TKDT800DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT800DS_Node;
TestBuff: TKDT800DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT800DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT800DS_Node;
function GetData(const Index: NativeInt): PKDT800DS_Source;
public
RootNode: PKDT800DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT800DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT800DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT800DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT800DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT800DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT800DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT800DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT800DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT800DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT800DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT800DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT800DS_Node; overload;
function Search(const buff: TKDT800DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT800DS_Node; overload;
function Search(const buff: TKDT800DS_Vec; var SearchedDistanceMin: Double): PKDT800DS_Node; overload;
function Search(const buff: TKDT800DS_Vec): PKDT800DS_Node; overload;
function SearchToken(const buff: TKDT800DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT800DS_DynamicVecBuffer; var OutBuff: TKDT800DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT800DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT800DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT800DS_Vec; overload;
class function Vec(const v: TKDT800DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT800DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT800DS_Source; const Data: Pointer);
class procedure Test;
end;
TKDT1024DS = class(TCoreClassObject)
public type
// code split
TKDT1024DS_Vec = array [0 .. KDT1024DS_Axis - 1] of TKDT1024DS_VecType;
PKDT1024DS_Vec = ^TKDT1024DS_Vec;
TKDT1024DS_DynamicVecBuffer = array of TKDT1024DS_Vec;
PKDT1024DS_DynamicVecBuffer = ^TKDT1024DS_DynamicVecBuffer;
TKDT1024DS_Source = record
buff: TKDT1024DS_Vec;
Index: Int64;
Token: TPascalString;
end;
PKDT1024DS_Source = ^TKDT1024DS_Source;
TKDT1024DS_SourceBuffer = array [0 .. MaxInt div SizeOf(PKDT1024DS_Source) - 1] of PKDT1024DS_Source;
PKDT1024DS_SourceBuffer = ^TKDT1024DS_SourceBuffer;
TKDT1024DS_DyanmicSourceBuffer = array of PKDT1024DS_Source;
PKDT1024DS_DyanmicSourceBuffer = ^TKDT1024DS_DyanmicSourceBuffer;
TKDT1024DS_DyanmicStoreBuffer = array of TKDT1024DS_Source;
PKDT1024DS_DyanmicStoreBuffer = ^TKDT1024DS_DyanmicStoreBuffer;
PKDT1024DS_Node = ^TKDT1024DS_Node;
TKDT1024DS_Node = record
Parent, Right, Left: PKDT1024DS_Node;
Vec: PKDT1024DS_Source;
end;
TKDT1024DS_BuildCall = procedure(const IndexFor: NativeInt; var Source: TKDT1024DS_Source; const Data: Pointer);
TKDT1024DS_BuildMethod = procedure(const IndexFor: NativeInt; var Source: TKDT1024DS_Source; const Data: Pointer) of object;
{$IFDEF FPC}
TKDT1024DS_BuildProc = procedure(const IndexFor: NativeInt; var Source: TKDT1024DS_Source; const Data: Pointer) is nested;
{$ELSE FPC}
TKDT1024DS_BuildProc = reference to procedure(const IndexFor: NativeInt; var Source: TKDT1024DS_Source; const Data: Pointer);
{$ENDIF FPC}
private
KDStoreBuff: TKDT1024DS_DyanmicStoreBuffer;
KDBuff: TKDT1024DS_DyanmicSourceBuffer;
NodeCounter: NativeInt;
KDNodes: array of PKDT1024DS_Node;
TestBuff: TKDT1024DS_DynamicVecBuffer;
function InternalBuildKdTree(const KDSourceBufferPtr: PKDT1024DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT1024DS_Node;
function GetData(const Index: NativeInt): PKDT1024DS_Source;
public
RootNode: PKDT1024DS_Node;
constructor Create;
destructor Destroy; override;
procedure Clear;
property Count: NativeInt read NodeCounter;
function StoreBuffPtr: PKDT1024DS_DyanmicStoreBuffer;
property SourceP[const Index: NativeInt]: PKDT1024DS_Source read GetData; default;
{ bakcall build }
procedure BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildCall);
procedure BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildMethod);
procedure BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildProc);
{ fill k-means++ clusterization }
procedure BuildKDTreeWithCluster(const inBuff: TKDT1024DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray); overload;
procedure BuildKDTreeWithCluster(const inBuff: TKDT1024DS_DynamicVecBuffer; const k, Restarts: NativeInt); overload;
{ backcall k-means++ clusterization }
procedure BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildCall); overload;
procedure BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildMethod); overload;
procedure BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildProc); overload;
{ search }
function Search(const buff: TKDT1024DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT1024DS_Node; overload;
function Search(const buff: TKDT1024DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT1024DS_Node; overload;
function Search(const buff: TKDT1024DS_Vec; var SearchedDistanceMin: Double): PKDT1024DS_Node; overload;
function Search(const buff: TKDT1024DS_Vec): PKDT1024DS_Node; overload;
function SearchToken(const buff: TKDT1024DS_Vec): TPascalString;
{ parallel search }
procedure Search(const inBuff: TKDT1024DS_DynamicVecBuffer; var OutBuff: TKDT1024DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure Search(const inBuff: TKDT1024DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray); overload;
procedure SaveToStream(stream: TCoreClassStream);
procedure LoadFromStream(stream: TCoreClassStream);
procedure SaveToFile(FileName: SystemString);
procedure LoadFromFile(FileName: SystemString);
procedure PrintNodeTree(const NodePtr: PKDT1024DS_Node);
procedure PrintBuffer;
class function Vec(const s: SystemString): TKDT1024DS_Vec; overload;
class function Vec(const v: TKDT1024DS_Vec): SystemString; overload;
class function Distance(const v1, v2: TKDT1024DS_Vec): Double;
// debug time
procedure Test_BuildM(const IndexFor: NativeInt; var Source: TKDT1024DS_Source; const Data: Pointer);
class procedure Test;
end;
procedure Test_All;
implementation
uses
TextParsing, MemoryStream64, DoStatusIO;
const
SaveToken = $33;
function TKDT1DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT1DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT1DS_Node;
function SortCompare(const p1, p2: PKDT1DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT1DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT1DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT1DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT1DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT1DS.GetData(const Index: NativeInt): PKDT1DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT1DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT1DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT1DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT1DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT1DS.StoreBuffPtr: PKDT1DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT1DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT1DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT1DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT1DS.BuildKDTreeWithCluster(const inBuff: TKDT1DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT1DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT1DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT1DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT1DS.BuildKDTreeWithCluster(const inBuff: TKDT1DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT1DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1DS_BuildCall);
var
TempStoreBuff: TKDT1DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT1DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT1DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT1DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT1DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1DS_BuildMethod);
var
TempStoreBuff: TKDT1DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT1DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT1DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT1DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT1DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1DS_BuildProc);
var
TempStoreBuff: TKDT1DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT1DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT1DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT1DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT1DS.Search(const buff: TKDT1DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT1DS_Node;
var
NearestNeighbour: PKDT1DS_Node;
function FindParentNode(const buffPtr: PKDT1DS_Vec; NodePtr: PKDT1DS_Node): PKDT1DS_Node;
var
Next: PKDT1DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT1DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT1DS_Node; const buffPtr: PKDT1DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT1DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT1DS_Vec; const p1, p2: PKDT1DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT1DS_Vec);
var
i, j: NativeInt;
p, t: PKDT1DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT1DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT1DS_Node(NearestNodes[0]);
end;
end;
function TKDT1DS.Search(const buff: TKDT1DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT1DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT1DS.Search(const buff: TKDT1DS_Vec; var SearchedDistanceMin: Double): PKDT1DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT1DS.Search(const buff: TKDT1DS_Vec): PKDT1DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT1DS.SearchToken(const buff: TKDT1DS_Vec): TPascalString;
var
p: PKDT1DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT1DS.Search(const inBuff: TKDT1DS_DynamicVecBuffer; var OutBuff: TKDT1DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT1DS_DynamicVecBuffer;
outBuffPtr: PKDT1DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT1DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT1DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT1DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT1DS.Search(const inBuff: TKDT1DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT1DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT1DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT1DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT1DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT1DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT1DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT1DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT1DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT1DS_Vec)) <> SizeOf(TKDT1DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT1DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT1DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT1DS.PrintNodeTree(const NodePtr: PKDT1DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT1DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT1DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT1DS.Vec(const s: SystemString): TKDT1DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT1DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT1DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT1DS.Vec(const v: TKDT1DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT1DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT1DS.Distance(const v1, v2: TKDT1DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT1DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT1DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT1DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT1DS.Test;
var
TKDT1DS_Test: TKDT1DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT1DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT1DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT1DS_Test := TKDT1DS.Create;
n.Append('...');
SetLength(TKDT1DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT1DS_Test.TestBuff) - 1 do
for j := 0 to KDT1DS_Axis - 1 do
TKDT1DS_Test.TestBuff[i][j] := i * KDT1DS_Axis + j;
{$IFDEF FPC}
TKDT1DS_Test.BuildKDTreeM(length(TKDT1DS_Test.TestBuff), nil, @TKDT1DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT1DS_Test.BuildKDTreeM(length(TKDT1DS_Test.TestBuff), nil, TKDT1DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT1DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT1DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT1DS_Test.TestBuff) - 1 do
begin
p := TKDT1DS_Test.Search(TKDT1DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT1DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT1DS_Test.TestBuff));
TKDT1DS_Test.Search(TKDT1DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT1DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT1DS_Test.Clear;
{ kMean test }
TKDT1DS_Test.BuildKDTreeWithCluster(TKDT1DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT1DS_Test.Search(TKDT1DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT1DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT1DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT1DS_Test);
DoStatus(n);
n := '';
end;
function TKDT2DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT2DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT2DS_Node;
function SortCompare(const p1, p2: PKDT2DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT2DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT2DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT2DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT2DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT2DS.GetData(const Index: NativeInt): PKDT2DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT2DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT2DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT2DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT2DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT2DS.StoreBuffPtr: PKDT2DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT2DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT2DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT2DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT2DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT2DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT2DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT2DS.BuildKDTreeWithCluster(const inBuff: TKDT2DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT2DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT2DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT2DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT2DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT2DS.BuildKDTreeWithCluster(const inBuff: TKDT2DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT2DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT2DS_BuildCall);
var
TempStoreBuff: TKDT2DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT2DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT2DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT2DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT2DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT2DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT2DS_BuildMethod);
var
TempStoreBuff: TKDT2DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT2DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT2DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT2DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT2DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT2DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT2DS_BuildProc);
var
TempStoreBuff: TKDT2DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT2DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT2DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT2DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT2DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT2DS.Search(const buff: TKDT2DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT2DS_Node;
var
NearestNeighbour: PKDT2DS_Node;
function FindParentNode(const buffPtr: PKDT2DS_Vec; NodePtr: PKDT2DS_Node): PKDT2DS_Node;
var
Next: PKDT2DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT2DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT2DS_Node; const buffPtr: PKDT2DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT2DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT2DS_Vec; const p1, p2: PKDT2DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT2DS_Vec);
var
i, j: NativeInt;
p, t: PKDT2DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT2DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT2DS_Node(NearestNodes[0]);
end;
end;
function TKDT2DS.Search(const buff: TKDT2DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT2DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT2DS.Search(const buff: TKDT2DS_Vec; var SearchedDistanceMin: Double): PKDT2DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT2DS.Search(const buff: TKDT2DS_Vec): PKDT2DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT2DS.SearchToken(const buff: TKDT2DS_Vec): TPascalString;
var
p: PKDT2DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT2DS.Search(const inBuff: TKDT2DS_DynamicVecBuffer; var OutBuff: TKDT2DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT2DS_DynamicVecBuffer;
outBuffPtr: PKDT2DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT2DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT2DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT2DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT2DS.Search(const inBuff: TKDT2DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT2DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT2DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT2DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT2DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT2DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT2DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT2DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT2DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT2DS_Vec)) <> SizeOf(TKDT2DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT2DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT2DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT2DS.PrintNodeTree(const NodePtr: PKDT2DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT2DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT2DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT2DS.Vec(const s: SystemString): TKDT2DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT2DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT2DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT2DS.Vec(const v: TKDT2DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT2DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT2DS.Distance(const v1, v2: TKDT2DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT2DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT2DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT2DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT2DS.Test;
var
TKDT2DS_Test: TKDT2DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT2DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT2DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT2DS_Test := TKDT2DS.Create;
n.Append('...');
SetLength(TKDT2DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT2DS_Test.TestBuff) - 1 do
for j := 0 to KDT2DS_Axis - 1 do
TKDT2DS_Test.TestBuff[i][j] := i * KDT2DS_Axis + j;
{$IFDEF FPC}
TKDT2DS_Test.BuildKDTreeM(length(TKDT2DS_Test.TestBuff), nil, @TKDT2DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT2DS_Test.BuildKDTreeM(length(TKDT2DS_Test.TestBuff), nil, TKDT2DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT2DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT2DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT2DS_Test.TestBuff) - 1 do
begin
p := TKDT2DS_Test.Search(TKDT2DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT2DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT2DS_Test.TestBuff));
TKDT2DS_Test.Search(TKDT2DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT2DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT2DS_Test.Clear;
{ kMean test }
TKDT2DS_Test.BuildKDTreeWithCluster(TKDT2DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT2DS_Test.Search(TKDT2DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT2DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT2DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT2DS_Test);
DoStatus(n);
n := '';
end;
function TKDT3DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT3DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT3DS_Node;
function SortCompare(const p1, p2: PKDT3DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT3DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT3DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT3DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT3DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT3DS.GetData(const Index: NativeInt): PKDT3DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT3DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT3DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT3DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT3DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT3DS.StoreBuffPtr: PKDT3DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT3DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT3DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT3DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT3DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT3DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT3DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT3DS.BuildKDTreeWithCluster(const inBuff: TKDT3DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT3DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT3DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT3DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT3DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT3DS.BuildKDTreeWithCluster(const inBuff: TKDT3DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT3DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT3DS_BuildCall);
var
TempStoreBuff: TKDT3DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT3DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT3DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT3DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT3DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT3DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT3DS_BuildMethod);
var
TempStoreBuff: TKDT3DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT3DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT3DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT3DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT3DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT3DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT3DS_BuildProc);
var
TempStoreBuff: TKDT3DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT3DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT3DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT3DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT3DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT3DS.Search(const buff: TKDT3DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT3DS_Node;
var
NearestNeighbour: PKDT3DS_Node;
function FindParentNode(const buffPtr: PKDT3DS_Vec; NodePtr: PKDT3DS_Node): PKDT3DS_Node;
var
Next: PKDT3DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT3DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT3DS_Node; const buffPtr: PKDT3DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT3DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT3DS_Vec; const p1, p2: PKDT3DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT3DS_Vec);
var
i, j: NativeInt;
p, t: PKDT3DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT3DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT3DS_Node(NearestNodes[0]);
end;
end;
function TKDT3DS.Search(const buff: TKDT3DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT3DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT3DS.Search(const buff: TKDT3DS_Vec; var SearchedDistanceMin: Double): PKDT3DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT3DS.Search(const buff: TKDT3DS_Vec): PKDT3DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT3DS.SearchToken(const buff: TKDT3DS_Vec): TPascalString;
var
p: PKDT3DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT3DS.Search(const inBuff: TKDT3DS_DynamicVecBuffer; var OutBuff: TKDT3DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT3DS_DynamicVecBuffer;
outBuffPtr: PKDT3DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT3DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT3DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT3DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT3DS.Search(const inBuff: TKDT3DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT3DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT3DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT3DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT3DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT3DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT3DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT3DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT3DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT3DS_Vec)) <> SizeOf(TKDT3DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT3DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT3DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT3DS.PrintNodeTree(const NodePtr: PKDT3DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT3DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT3DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT3DS.Vec(const s: SystemString): TKDT3DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT3DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT3DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT3DS.Vec(const v: TKDT3DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT3DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT3DS.Distance(const v1, v2: TKDT3DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT3DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT3DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT3DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT3DS.Test;
var
TKDT3DS_Test: TKDT3DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT3DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT3DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT3DS_Test := TKDT3DS.Create;
n.Append('...');
SetLength(TKDT3DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT3DS_Test.TestBuff) - 1 do
for j := 0 to KDT3DS_Axis - 1 do
TKDT3DS_Test.TestBuff[i][j] := i * KDT3DS_Axis + j;
{$IFDEF FPC}
TKDT3DS_Test.BuildKDTreeM(length(TKDT3DS_Test.TestBuff), nil, @TKDT3DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT3DS_Test.BuildKDTreeM(length(TKDT3DS_Test.TestBuff), nil, TKDT3DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT3DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT3DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT3DS_Test.TestBuff) - 1 do
begin
p := TKDT3DS_Test.Search(TKDT3DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT3DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT3DS_Test.TestBuff));
TKDT3DS_Test.Search(TKDT3DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT3DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT3DS_Test.Clear;
{ kMean test }
TKDT3DS_Test.BuildKDTreeWithCluster(TKDT3DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT3DS_Test.Search(TKDT3DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT3DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT3DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT3DS_Test);
DoStatus(n);
n := '';
end;
function TKDT4DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT4DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT4DS_Node;
function SortCompare(const p1, p2: PKDT4DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT4DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT4DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT4DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT4DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT4DS.GetData(const Index: NativeInt): PKDT4DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT4DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT4DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT4DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT4DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT4DS.StoreBuffPtr: PKDT4DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT4DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT4DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT4DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT4DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT4DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT4DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT4DS.BuildKDTreeWithCluster(const inBuff: TKDT4DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT4DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT4DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT4DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT4DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT4DS.BuildKDTreeWithCluster(const inBuff: TKDT4DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT4DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT4DS_BuildCall);
var
TempStoreBuff: TKDT4DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT4DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT4DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT4DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT4DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT4DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT4DS_BuildMethod);
var
TempStoreBuff: TKDT4DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT4DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT4DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT4DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT4DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT4DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT4DS_BuildProc);
var
TempStoreBuff: TKDT4DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT4DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT4DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT4DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT4DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT4DS.Search(const buff: TKDT4DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT4DS_Node;
var
NearestNeighbour: PKDT4DS_Node;
function FindParentNode(const buffPtr: PKDT4DS_Vec; NodePtr: PKDT4DS_Node): PKDT4DS_Node;
var
Next: PKDT4DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT4DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT4DS_Node; const buffPtr: PKDT4DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT4DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT4DS_Vec; const p1, p2: PKDT4DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT4DS_Vec);
var
i, j: NativeInt;
p, t: PKDT4DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT4DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT4DS_Node(NearestNodes[0]);
end;
end;
function TKDT4DS.Search(const buff: TKDT4DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT4DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT4DS.Search(const buff: TKDT4DS_Vec; var SearchedDistanceMin: Double): PKDT4DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT4DS.Search(const buff: TKDT4DS_Vec): PKDT4DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT4DS.SearchToken(const buff: TKDT4DS_Vec): TPascalString;
var
p: PKDT4DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT4DS.Search(const inBuff: TKDT4DS_DynamicVecBuffer; var OutBuff: TKDT4DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT4DS_DynamicVecBuffer;
outBuffPtr: PKDT4DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT4DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT4DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT4DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT4DS.Search(const inBuff: TKDT4DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT4DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT4DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT4DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT4DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT4DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT4DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT4DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT4DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT4DS_Vec)) <> SizeOf(TKDT4DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT4DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT4DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT4DS.PrintNodeTree(const NodePtr: PKDT4DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT4DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT4DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT4DS.Vec(const s: SystemString): TKDT4DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT4DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT4DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT4DS.Vec(const v: TKDT4DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT4DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT4DS.Distance(const v1, v2: TKDT4DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT4DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT4DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT4DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT4DS.Test;
var
TKDT4DS_Test: TKDT4DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT4DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT4DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT4DS_Test := TKDT4DS.Create;
n.Append('...');
SetLength(TKDT4DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT4DS_Test.TestBuff) - 1 do
for j := 0 to KDT4DS_Axis - 1 do
TKDT4DS_Test.TestBuff[i][j] := i * KDT4DS_Axis + j;
{$IFDEF FPC}
TKDT4DS_Test.BuildKDTreeM(length(TKDT4DS_Test.TestBuff), nil, @TKDT4DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT4DS_Test.BuildKDTreeM(length(TKDT4DS_Test.TestBuff), nil, TKDT4DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT4DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT4DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT4DS_Test.TestBuff) - 1 do
begin
p := TKDT4DS_Test.Search(TKDT4DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT4DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT4DS_Test.TestBuff));
TKDT4DS_Test.Search(TKDT4DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT4DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT4DS_Test.Clear;
{ kMean test }
TKDT4DS_Test.BuildKDTreeWithCluster(TKDT4DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT4DS_Test.Search(TKDT4DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT4DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT4DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT4DS_Test);
DoStatus(n);
n := '';
end;
function TKDT5DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT5DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT5DS_Node;
function SortCompare(const p1, p2: PKDT5DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT5DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT5DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT5DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT5DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT5DS.GetData(const Index: NativeInt): PKDT5DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT5DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT5DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT5DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT5DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT5DS.StoreBuffPtr: PKDT5DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT5DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT5DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT5DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT5DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT5DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT5DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT5DS.BuildKDTreeWithCluster(const inBuff: TKDT5DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT5DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT5DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT5DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT5DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT5DS.BuildKDTreeWithCluster(const inBuff: TKDT5DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT5DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT5DS_BuildCall);
var
TempStoreBuff: TKDT5DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT5DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT5DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT5DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT5DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT5DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT5DS_BuildMethod);
var
TempStoreBuff: TKDT5DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT5DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT5DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT5DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT5DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT5DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT5DS_BuildProc);
var
TempStoreBuff: TKDT5DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT5DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT5DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT5DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT5DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT5DS.Search(const buff: TKDT5DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT5DS_Node;
var
NearestNeighbour: PKDT5DS_Node;
function FindParentNode(const buffPtr: PKDT5DS_Vec; NodePtr: PKDT5DS_Node): PKDT5DS_Node;
var
Next: PKDT5DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT5DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT5DS_Node; const buffPtr: PKDT5DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT5DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT5DS_Vec; const p1, p2: PKDT5DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT5DS_Vec);
var
i, j: NativeInt;
p, t: PKDT5DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT5DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT5DS_Node(NearestNodes[0]);
end;
end;
function TKDT5DS.Search(const buff: TKDT5DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT5DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT5DS.Search(const buff: TKDT5DS_Vec; var SearchedDistanceMin: Double): PKDT5DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT5DS.Search(const buff: TKDT5DS_Vec): PKDT5DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT5DS.SearchToken(const buff: TKDT5DS_Vec): TPascalString;
var
p: PKDT5DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT5DS.Search(const inBuff: TKDT5DS_DynamicVecBuffer; var OutBuff: TKDT5DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT5DS_DynamicVecBuffer;
outBuffPtr: PKDT5DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT5DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT5DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT5DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT5DS.Search(const inBuff: TKDT5DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT5DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT5DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT5DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT5DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT5DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT5DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT5DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT5DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT5DS_Vec)) <> SizeOf(TKDT5DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT5DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT5DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT5DS.PrintNodeTree(const NodePtr: PKDT5DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT5DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT5DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT5DS.Vec(const s: SystemString): TKDT5DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT5DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT5DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT5DS.Vec(const v: TKDT5DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT5DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT5DS.Distance(const v1, v2: TKDT5DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT5DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT5DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT5DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT5DS.Test;
var
TKDT5DS_Test: TKDT5DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT5DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT5DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT5DS_Test := TKDT5DS.Create;
n.Append('...');
SetLength(TKDT5DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT5DS_Test.TestBuff) - 1 do
for j := 0 to KDT5DS_Axis - 1 do
TKDT5DS_Test.TestBuff[i][j] := i * KDT5DS_Axis + j;
{$IFDEF FPC}
TKDT5DS_Test.BuildKDTreeM(length(TKDT5DS_Test.TestBuff), nil, @TKDT5DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT5DS_Test.BuildKDTreeM(length(TKDT5DS_Test.TestBuff), nil, TKDT5DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT5DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT5DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT5DS_Test.TestBuff) - 1 do
begin
p := TKDT5DS_Test.Search(TKDT5DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT5DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT5DS_Test.TestBuff));
TKDT5DS_Test.Search(TKDT5DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT5DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT5DS_Test.Clear;
{ kMean test }
TKDT5DS_Test.BuildKDTreeWithCluster(TKDT5DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT5DS_Test.Search(TKDT5DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT5DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT5DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT5DS_Test);
DoStatus(n);
n := '';
end;
function TKDT6DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT6DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT6DS_Node;
function SortCompare(const p1, p2: PKDT6DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT6DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT6DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT6DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT6DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT6DS.GetData(const Index: NativeInt): PKDT6DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT6DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT6DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT6DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT6DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT6DS.StoreBuffPtr: PKDT6DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT6DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT6DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT6DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT6DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT6DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT6DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT6DS.BuildKDTreeWithCluster(const inBuff: TKDT6DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT6DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT6DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT6DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT6DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT6DS.BuildKDTreeWithCluster(const inBuff: TKDT6DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT6DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT6DS_BuildCall);
var
TempStoreBuff: TKDT6DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT6DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT6DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT6DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT6DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT6DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT6DS_BuildMethod);
var
TempStoreBuff: TKDT6DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT6DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT6DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT6DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT6DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT6DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT6DS_BuildProc);
var
TempStoreBuff: TKDT6DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT6DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT6DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT6DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT6DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT6DS.Search(const buff: TKDT6DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT6DS_Node;
var
NearestNeighbour: PKDT6DS_Node;
function FindParentNode(const buffPtr: PKDT6DS_Vec; NodePtr: PKDT6DS_Node): PKDT6DS_Node;
var
Next: PKDT6DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT6DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT6DS_Node; const buffPtr: PKDT6DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT6DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT6DS_Vec; const p1, p2: PKDT6DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT6DS_Vec);
var
i, j: NativeInt;
p, t: PKDT6DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT6DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT6DS_Node(NearestNodes[0]);
end;
end;
function TKDT6DS.Search(const buff: TKDT6DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT6DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT6DS.Search(const buff: TKDT6DS_Vec; var SearchedDistanceMin: Double): PKDT6DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT6DS.Search(const buff: TKDT6DS_Vec): PKDT6DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT6DS.SearchToken(const buff: TKDT6DS_Vec): TPascalString;
var
p: PKDT6DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT6DS.Search(const inBuff: TKDT6DS_DynamicVecBuffer; var OutBuff: TKDT6DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT6DS_DynamicVecBuffer;
outBuffPtr: PKDT6DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT6DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT6DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT6DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT6DS.Search(const inBuff: TKDT6DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT6DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT6DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT6DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT6DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT6DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT6DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT6DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT6DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT6DS_Vec)) <> SizeOf(TKDT6DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT6DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT6DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT6DS.PrintNodeTree(const NodePtr: PKDT6DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT6DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT6DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT6DS.Vec(const s: SystemString): TKDT6DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT6DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT6DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT6DS.Vec(const v: TKDT6DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT6DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT6DS.Distance(const v1, v2: TKDT6DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT6DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT6DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT6DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT6DS.Test;
var
TKDT6DS_Test: TKDT6DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT6DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT6DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT6DS_Test := TKDT6DS.Create;
n.Append('...');
SetLength(TKDT6DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT6DS_Test.TestBuff) - 1 do
for j := 0 to KDT6DS_Axis - 1 do
TKDT6DS_Test.TestBuff[i][j] := i * KDT6DS_Axis + j;
{$IFDEF FPC}
TKDT6DS_Test.BuildKDTreeM(length(TKDT6DS_Test.TestBuff), nil, @TKDT6DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT6DS_Test.BuildKDTreeM(length(TKDT6DS_Test.TestBuff), nil, TKDT6DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT6DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT6DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT6DS_Test.TestBuff) - 1 do
begin
p := TKDT6DS_Test.Search(TKDT6DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT6DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT6DS_Test.TestBuff));
TKDT6DS_Test.Search(TKDT6DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT6DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT6DS_Test.Clear;
{ kMean test }
TKDT6DS_Test.BuildKDTreeWithCluster(TKDT6DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT6DS_Test.Search(TKDT6DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT6DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT6DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT6DS_Test);
DoStatus(n);
n := '';
end;
function TKDT7DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT7DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT7DS_Node;
function SortCompare(const p1, p2: PKDT7DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT7DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT7DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT7DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT7DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT7DS.GetData(const Index: NativeInt): PKDT7DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT7DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT7DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT7DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT7DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT7DS.StoreBuffPtr: PKDT7DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT7DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT7DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT7DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT7DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT7DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT7DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT7DS.BuildKDTreeWithCluster(const inBuff: TKDT7DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT7DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT7DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT7DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT7DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT7DS.BuildKDTreeWithCluster(const inBuff: TKDT7DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT7DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT7DS_BuildCall);
var
TempStoreBuff: TKDT7DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT7DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT7DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT7DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT7DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT7DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT7DS_BuildMethod);
var
TempStoreBuff: TKDT7DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT7DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT7DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT7DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT7DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT7DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT7DS_BuildProc);
var
TempStoreBuff: TKDT7DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT7DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT7DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT7DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT7DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT7DS.Search(const buff: TKDT7DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT7DS_Node;
var
NearestNeighbour: PKDT7DS_Node;
function FindParentNode(const buffPtr: PKDT7DS_Vec; NodePtr: PKDT7DS_Node): PKDT7DS_Node;
var
Next: PKDT7DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT7DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT7DS_Node; const buffPtr: PKDT7DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT7DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT7DS_Vec; const p1, p2: PKDT7DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT7DS_Vec);
var
i, j: NativeInt;
p, t: PKDT7DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT7DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT7DS_Node(NearestNodes[0]);
end;
end;
function TKDT7DS.Search(const buff: TKDT7DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT7DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT7DS.Search(const buff: TKDT7DS_Vec; var SearchedDistanceMin: Double): PKDT7DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT7DS.Search(const buff: TKDT7DS_Vec): PKDT7DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT7DS.SearchToken(const buff: TKDT7DS_Vec): TPascalString;
var
p: PKDT7DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT7DS.Search(const inBuff: TKDT7DS_DynamicVecBuffer; var OutBuff: TKDT7DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT7DS_DynamicVecBuffer;
outBuffPtr: PKDT7DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT7DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT7DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT7DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT7DS.Search(const inBuff: TKDT7DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT7DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT7DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT7DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT7DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT7DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT7DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT7DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT7DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT7DS_Vec)) <> SizeOf(TKDT7DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT7DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT7DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT7DS.PrintNodeTree(const NodePtr: PKDT7DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT7DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT7DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT7DS.Vec(const s: SystemString): TKDT7DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT7DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT7DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT7DS.Vec(const v: TKDT7DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT7DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT7DS.Distance(const v1, v2: TKDT7DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT7DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT7DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT7DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT7DS.Test;
var
TKDT7DS_Test: TKDT7DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT7DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT7DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT7DS_Test := TKDT7DS.Create;
n.Append('...');
SetLength(TKDT7DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT7DS_Test.TestBuff) - 1 do
for j := 0 to KDT7DS_Axis - 1 do
TKDT7DS_Test.TestBuff[i][j] := i * KDT7DS_Axis + j;
{$IFDEF FPC}
TKDT7DS_Test.BuildKDTreeM(length(TKDT7DS_Test.TestBuff), nil, @TKDT7DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT7DS_Test.BuildKDTreeM(length(TKDT7DS_Test.TestBuff), nil, TKDT7DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT7DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT7DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT7DS_Test.TestBuff) - 1 do
begin
p := TKDT7DS_Test.Search(TKDT7DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT7DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT7DS_Test.TestBuff));
TKDT7DS_Test.Search(TKDT7DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT7DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT7DS_Test.Clear;
{ kMean test }
TKDT7DS_Test.BuildKDTreeWithCluster(TKDT7DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT7DS_Test.Search(TKDT7DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT7DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT7DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT7DS_Test);
DoStatus(n);
n := '';
end;
function TKDT8DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT8DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT8DS_Node;
function SortCompare(const p1, p2: PKDT8DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT8DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT8DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT8DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT8DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT8DS.GetData(const Index: NativeInt): PKDT8DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT8DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT8DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT8DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT8DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT8DS.StoreBuffPtr: PKDT8DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT8DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT8DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT8DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT8DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT8DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT8DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT8DS.BuildKDTreeWithCluster(const inBuff: TKDT8DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT8DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT8DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT8DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT8DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT8DS.BuildKDTreeWithCluster(const inBuff: TKDT8DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT8DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT8DS_BuildCall);
var
TempStoreBuff: TKDT8DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT8DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT8DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT8DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT8DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT8DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT8DS_BuildMethod);
var
TempStoreBuff: TKDT8DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT8DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT8DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT8DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT8DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT8DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT8DS_BuildProc);
var
TempStoreBuff: TKDT8DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT8DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT8DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT8DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT8DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT8DS.Search(const buff: TKDT8DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT8DS_Node;
var
NearestNeighbour: PKDT8DS_Node;
function FindParentNode(const buffPtr: PKDT8DS_Vec; NodePtr: PKDT8DS_Node): PKDT8DS_Node;
var
Next: PKDT8DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT8DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT8DS_Node; const buffPtr: PKDT8DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT8DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT8DS_Vec; const p1, p2: PKDT8DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT8DS_Vec);
var
i, j: NativeInt;
p, t: PKDT8DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT8DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT8DS_Node(NearestNodes[0]);
end;
end;
function TKDT8DS.Search(const buff: TKDT8DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT8DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT8DS.Search(const buff: TKDT8DS_Vec; var SearchedDistanceMin: Double): PKDT8DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT8DS.Search(const buff: TKDT8DS_Vec): PKDT8DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT8DS.SearchToken(const buff: TKDT8DS_Vec): TPascalString;
var
p: PKDT8DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT8DS.Search(const inBuff: TKDT8DS_DynamicVecBuffer; var OutBuff: TKDT8DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT8DS_DynamicVecBuffer;
outBuffPtr: PKDT8DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT8DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT8DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT8DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT8DS.Search(const inBuff: TKDT8DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT8DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT8DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT8DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT8DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT8DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT8DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT8DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT8DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT8DS_Vec)) <> SizeOf(TKDT8DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT8DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT8DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT8DS.PrintNodeTree(const NodePtr: PKDT8DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT8DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT8DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT8DS.Vec(const s: SystemString): TKDT8DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT8DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT8DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT8DS.Vec(const v: TKDT8DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT8DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT8DS.Distance(const v1, v2: TKDT8DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT8DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT8DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT8DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT8DS.Test;
var
TKDT8DS_Test: TKDT8DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT8DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT8DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT8DS_Test := TKDT8DS.Create;
n.Append('...');
SetLength(TKDT8DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT8DS_Test.TestBuff) - 1 do
for j := 0 to KDT8DS_Axis - 1 do
TKDT8DS_Test.TestBuff[i][j] := i * KDT8DS_Axis + j;
{$IFDEF FPC}
TKDT8DS_Test.BuildKDTreeM(length(TKDT8DS_Test.TestBuff), nil, @TKDT8DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT8DS_Test.BuildKDTreeM(length(TKDT8DS_Test.TestBuff), nil, TKDT8DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT8DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT8DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT8DS_Test.TestBuff) - 1 do
begin
p := TKDT8DS_Test.Search(TKDT8DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT8DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT8DS_Test.TestBuff));
TKDT8DS_Test.Search(TKDT8DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT8DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT8DS_Test.Clear;
{ kMean test }
TKDT8DS_Test.BuildKDTreeWithCluster(TKDT8DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT8DS_Test.Search(TKDT8DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT8DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT8DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT8DS_Test);
DoStatus(n);
n := '';
end;
function TKDT9DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT9DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT9DS_Node;
function SortCompare(const p1, p2: PKDT9DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT9DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT9DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT9DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT9DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT9DS.GetData(const Index: NativeInt): PKDT9DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT9DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT9DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT9DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT9DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT9DS.StoreBuffPtr: PKDT9DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT9DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT9DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT9DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT9DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT9DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT9DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT9DS.BuildKDTreeWithCluster(const inBuff: TKDT9DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT9DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT9DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT9DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT9DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT9DS.BuildKDTreeWithCluster(const inBuff: TKDT9DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT9DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT9DS_BuildCall);
var
TempStoreBuff: TKDT9DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT9DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT9DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT9DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT9DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT9DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT9DS_BuildMethod);
var
TempStoreBuff: TKDT9DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT9DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT9DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT9DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT9DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT9DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT9DS_BuildProc);
var
TempStoreBuff: TKDT9DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT9DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT9DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT9DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT9DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT9DS.Search(const buff: TKDT9DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT9DS_Node;
var
NearestNeighbour: PKDT9DS_Node;
function FindParentNode(const buffPtr: PKDT9DS_Vec; NodePtr: PKDT9DS_Node): PKDT9DS_Node;
var
Next: PKDT9DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT9DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT9DS_Node; const buffPtr: PKDT9DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT9DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT9DS_Vec; const p1, p2: PKDT9DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT9DS_Vec);
var
i, j: NativeInt;
p, t: PKDT9DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT9DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT9DS_Node(NearestNodes[0]);
end;
end;
function TKDT9DS.Search(const buff: TKDT9DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT9DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT9DS.Search(const buff: TKDT9DS_Vec; var SearchedDistanceMin: Double): PKDT9DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT9DS.Search(const buff: TKDT9DS_Vec): PKDT9DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT9DS.SearchToken(const buff: TKDT9DS_Vec): TPascalString;
var
p: PKDT9DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT9DS.Search(const inBuff: TKDT9DS_DynamicVecBuffer; var OutBuff: TKDT9DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT9DS_DynamicVecBuffer;
outBuffPtr: PKDT9DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT9DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT9DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT9DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT9DS.Search(const inBuff: TKDT9DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT9DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT9DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT9DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT9DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT9DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT9DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT9DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT9DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT9DS_Vec)) <> SizeOf(TKDT9DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT9DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT9DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT9DS.PrintNodeTree(const NodePtr: PKDT9DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT9DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT9DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT9DS.Vec(const s: SystemString): TKDT9DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT9DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT9DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT9DS.Vec(const v: TKDT9DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT9DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT9DS.Distance(const v1, v2: TKDT9DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT9DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT9DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT9DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT9DS.Test;
var
TKDT9DS_Test: TKDT9DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT9DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT9DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT9DS_Test := TKDT9DS.Create;
n.Append('...');
SetLength(TKDT9DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT9DS_Test.TestBuff) - 1 do
for j := 0 to KDT9DS_Axis - 1 do
TKDT9DS_Test.TestBuff[i][j] := i * KDT9DS_Axis + j;
{$IFDEF FPC}
TKDT9DS_Test.BuildKDTreeM(length(TKDT9DS_Test.TestBuff), nil, @TKDT9DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT9DS_Test.BuildKDTreeM(length(TKDT9DS_Test.TestBuff), nil, TKDT9DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT9DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT9DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT9DS_Test.TestBuff) - 1 do
begin
p := TKDT9DS_Test.Search(TKDT9DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT9DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT9DS_Test.TestBuff));
TKDT9DS_Test.Search(TKDT9DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT9DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT9DS_Test.Clear;
{ kMean test }
TKDT9DS_Test.BuildKDTreeWithCluster(TKDT9DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT9DS_Test.Search(TKDT9DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT9DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT9DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT9DS_Test);
DoStatus(n);
n := '';
end;
function TKDT10DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT10DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT10DS_Node;
function SortCompare(const p1, p2: PKDT10DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT10DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT10DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT10DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT10DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT10DS.GetData(const Index: NativeInt): PKDT10DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT10DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT10DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT10DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT10DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT10DS.StoreBuffPtr: PKDT10DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT10DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT10DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT10DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT10DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT10DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT10DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT10DS.BuildKDTreeWithCluster(const inBuff: TKDT10DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT10DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT10DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT10DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT10DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT10DS.BuildKDTreeWithCluster(const inBuff: TKDT10DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT10DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT10DS_BuildCall);
var
TempStoreBuff: TKDT10DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT10DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT10DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT10DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT10DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT10DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT10DS_BuildMethod);
var
TempStoreBuff: TKDT10DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT10DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT10DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT10DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT10DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT10DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT10DS_BuildProc);
var
TempStoreBuff: TKDT10DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT10DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT10DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT10DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT10DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT10DS.Search(const buff: TKDT10DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT10DS_Node;
var
NearestNeighbour: PKDT10DS_Node;
function FindParentNode(const buffPtr: PKDT10DS_Vec; NodePtr: PKDT10DS_Node): PKDT10DS_Node;
var
Next: PKDT10DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT10DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT10DS_Node; const buffPtr: PKDT10DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT10DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT10DS_Vec; const p1, p2: PKDT10DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT10DS_Vec);
var
i, j: NativeInt;
p, t: PKDT10DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT10DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT10DS_Node(NearestNodes[0]);
end;
end;
function TKDT10DS.Search(const buff: TKDT10DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT10DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT10DS.Search(const buff: TKDT10DS_Vec; var SearchedDistanceMin: Double): PKDT10DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT10DS.Search(const buff: TKDT10DS_Vec): PKDT10DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT10DS.SearchToken(const buff: TKDT10DS_Vec): TPascalString;
var
p: PKDT10DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT10DS.Search(const inBuff: TKDT10DS_DynamicVecBuffer; var OutBuff: TKDT10DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT10DS_DynamicVecBuffer;
outBuffPtr: PKDT10DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT10DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT10DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT10DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT10DS.Search(const inBuff: TKDT10DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT10DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT10DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT10DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT10DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT10DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT10DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT10DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT10DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT10DS_Vec)) <> SizeOf(TKDT10DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT10DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT10DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT10DS.PrintNodeTree(const NodePtr: PKDT10DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT10DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT10DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT10DS.Vec(const s: SystemString): TKDT10DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT10DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT10DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT10DS.Vec(const v: TKDT10DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT10DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT10DS.Distance(const v1, v2: TKDT10DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT10DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT10DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT10DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT10DS.Test;
var
TKDT10DS_Test: TKDT10DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT10DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT10DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT10DS_Test := TKDT10DS.Create;
n.Append('...');
SetLength(TKDT10DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT10DS_Test.TestBuff) - 1 do
for j := 0 to KDT10DS_Axis - 1 do
TKDT10DS_Test.TestBuff[i][j] := i * KDT10DS_Axis + j;
{$IFDEF FPC}
TKDT10DS_Test.BuildKDTreeM(length(TKDT10DS_Test.TestBuff), nil, @TKDT10DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT10DS_Test.BuildKDTreeM(length(TKDT10DS_Test.TestBuff), nil, TKDT10DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT10DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT10DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT10DS_Test.TestBuff) - 1 do
begin
p := TKDT10DS_Test.Search(TKDT10DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT10DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT10DS_Test.TestBuff));
TKDT10DS_Test.Search(TKDT10DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT10DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT10DS_Test.Clear;
{ kMean test }
TKDT10DS_Test.BuildKDTreeWithCluster(TKDT10DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT10DS_Test.Search(TKDT10DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT10DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT10DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT10DS_Test);
DoStatus(n);
n := '';
end;
function TKDT11DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT11DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT11DS_Node;
function SortCompare(const p1, p2: PKDT11DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT11DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT11DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT11DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT11DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT11DS.GetData(const Index: NativeInt): PKDT11DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT11DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT11DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT11DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT11DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT11DS.StoreBuffPtr: PKDT11DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT11DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT11DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT11DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT11DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT11DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT11DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT11DS.BuildKDTreeWithCluster(const inBuff: TKDT11DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT11DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT11DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT11DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT11DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT11DS.BuildKDTreeWithCluster(const inBuff: TKDT11DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT11DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT11DS_BuildCall);
var
TempStoreBuff: TKDT11DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT11DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT11DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT11DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT11DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT11DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT11DS_BuildMethod);
var
TempStoreBuff: TKDT11DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT11DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT11DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT11DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT11DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT11DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT11DS_BuildProc);
var
TempStoreBuff: TKDT11DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT11DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT11DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT11DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT11DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT11DS.Search(const buff: TKDT11DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT11DS_Node;
var
NearestNeighbour: PKDT11DS_Node;
function FindParentNode(const buffPtr: PKDT11DS_Vec; NodePtr: PKDT11DS_Node): PKDT11DS_Node;
var
Next: PKDT11DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT11DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT11DS_Node; const buffPtr: PKDT11DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT11DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT11DS_Vec; const p1, p2: PKDT11DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT11DS_Vec);
var
i, j: NativeInt;
p, t: PKDT11DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT11DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT11DS_Node(NearestNodes[0]);
end;
end;
function TKDT11DS.Search(const buff: TKDT11DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT11DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT11DS.Search(const buff: TKDT11DS_Vec; var SearchedDistanceMin: Double): PKDT11DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT11DS.Search(const buff: TKDT11DS_Vec): PKDT11DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT11DS.SearchToken(const buff: TKDT11DS_Vec): TPascalString;
var
p: PKDT11DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT11DS.Search(const inBuff: TKDT11DS_DynamicVecBuffer; var OutBuff: TKDT11DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT11DS_DynamicVecBuffer;
outBuffPtr: PKDT11DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT11DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT11DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT11DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT11DS.Search(const inBuff: TKDT11DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT11DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT11DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT11DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT11DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT11DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT11DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT11DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT11DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT11DS_Vec)) <> SizeOf(TKDT11DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT11DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT11DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT11DS.PrintNodeTree(const NodePtr: PKDT11DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT11DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT11DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT11DS.Vec(const s: SystemString): TKDT11DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT11DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT11DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT11DS.Vec(const v: TKDT11DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT11DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT11DS.Distance(const v1, v2: TKDT11DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT11DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT11DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT11DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT11DS.Test;
var
TKDT11DS_Test: TKDT11DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT11DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT11DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT11DS_Test := TKDT11DS.Create;
n.Append('...');
SetLength(TKDT11DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT11DS_Test.TestBuff) - 1 do
for j := 0 to KDT11DS_Axis - 1 do
TKDT11DS_Test.TestBuff[i][j] := i * KDT11DS_Axis + j;
{$IFDEF FPC}
TKDT11DS_Test.BuildKDTreeM(length(TKDT11DS_Test.TestBuff), nil, @TKDT11DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT11DS_Test.BuildKDTreeM(length(TKDT11DS_Test.TestBuff), nil, TKDT11DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT11DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT11DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT11DS_Test.TestBuff) - 1 do
begin
p := TKDT11DS_Test.Search(TKDT11DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT11DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT11DS_Test.TestBuff));
TKDT11DS_Test.Search(TKDT11DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT11DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT11DS_Test.Clear;
{ kMean test }
TKDT11DS_Test.BuildKDTreeWithCluster(TKDT11DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT11DS_Test.Search(TKDT11DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT11DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT11DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT11DS_Test);
DoStatus(n);
n := '';
end;
function TKDT12DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT12DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT12DS_Node;
function SortCompare(const p1, p2: PKDT12DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT12DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT12DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT12DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT12DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT12DS.GetData(const Index: NativeInt): PKDT12DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT12DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT12DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT12DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT12DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT12DS.StoreBuffPtr: PKDT12DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT12DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT12DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT12DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT12DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT12DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT12DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT12DS.BuildKDTreeWithCluster(const inBuff: TKDT12DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT12DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT12DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT12DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT12DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT12DS.BuildKDTreeWithCluster(const inBuff: TKDT12DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT12DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT12DS_BuildCall);
var
TempStoreBuff: TKDT12DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT12DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT12DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT12DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT12DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT12DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT12DS_BuildMethod);
var
TempStoreBuff: TKDT12DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT12DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT12DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT12DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT12DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT12DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT12DS_BuildProc);
var
TempStoreBuff: TKDT12DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT12DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT12DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT12DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT12DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT12DS.Search(const buff: TKDT12DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT12DS_Node;
var
NearestNeighbour: PKDT12DS_Node;
function FindParentNode(const buffPtr: PKDT12DS_Vec; NodePtr: PKDT12DS_Node): PKDT12DS_Node;
var
Next: PKDT12DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT12DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT12DS_Node; const buffPtr: PKDT12DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT12DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT12DS_Vec; const p1, p2: PKDT12DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT12DS_Vec);
var
i, j: NativeInt;
p, t: PKDT12DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT12DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT12DS_Node(NearestNodes[0]);
end;
end;
function TKDT12DS.Search(const buff: TKDT12DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT12DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT12DS.Search(const buff: TKDT12DS_Vec; var SearchedDistanceMin: Double): PKDT12DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT12DS.Search(const buff: TKDT12DS_Vec): PKDT12DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT12DS.SearchToken(const buff: TKDT12DS_Vec): TPascalString;
var
p: PKDT12DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT12DS.Search(const inBuff: TKDT12DS_DynamicVecBuffer; var OutBuff: TKDT12DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT12DS_DynamicVecBuffer;
outBuffPtr: PKDT12DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT12DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT12DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT12DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT12DS.Search(const inBuff: TKDT12DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT12DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT12DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT12DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT12DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT12DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT12DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT12DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT12DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT12DS_Vec)) <> SizeOf(TKDT12DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT12DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT12DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT12DS.PrintNodeTree(const NodePtr: PKDT12DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT12DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT12DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT12DS.Vec(const s: SystemString): TKDT12DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT12DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT12DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT12DS.Vec(const v: TKDT12DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT12DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT12DS.Distance(const v1, v2: TKDT12DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT12DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT12DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT12DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT12DS.Test;
var
TKDT12DS_Test: TKDT12DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT12DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT12DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT12DS_Test := TKDT12DS.Create;
n.Append('...');
SetLength(TKDT12DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT12DS_Test.TestBuff) - 1 do
for j := 0 to KDT12DS_Axis - 1 do
TKDT12DS_Test.TestBuff[i][j] := i * KDT12DS_Axis + j;
{$IFDEF FPC}
TKDT12DS_Test.BuildKDTreeM(length(TKDT12DS_Test.TestBuff), nil, @TKDT12DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT12DS_Test.BuildKDTreeM(length(TKDT12DS_Test.TestBuff), nil, TKDT12DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT12DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT12DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT12DS_Test.TestBuff) - 1 do
begin
p := TKDT12DS_Test.Search(TKDT12DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT12DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT12DS_Test.TestBuff));
TKDT12DS_Test.Search(TKDT12DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT12DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT12DS_Test.Clear;
{ kMean test }
TKDT12DS_Test.BuildKDTreeWithCluster(TKDT12DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT12DS_Test.Search(TKDT12DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT12DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT12DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT12DS_Test);
DoStatus(n);
n := '';
end;
function TKDT13DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT13DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT13DS_Node;
function SortCompare(const p1, p2: PKDT13DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT13DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT13DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT13DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT13DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT13DS.GetData(const Index: NativeInt): PKDT13DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT13DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT13DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT13DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT13DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT13DS.StoreBuffPtr: PKDT13DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT13DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT13DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT13DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT13DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT13DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT13DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT13DS.BuildKDTreeWithCluster(const inBuff: TKDT13DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT13DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT13DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT13DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT13DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT13DS.BuildKDTreeWithCluster(const inBuff: TKDT13DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT13DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT13DS_BuildCall);
var
TempStoreBuff: TKDT13DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT13DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT13DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT13DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT13DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT13DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT13DS_BuildMethod);
var
TempStoreBuff: TKDT13DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT13DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT13DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT13DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT13DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT13DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT13DS_BuildProc);
var
TempStoreBuff: TKDT13DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT13DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT13DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT13DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT13DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT13DS.Search(const buff: TKDT13DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT13DS_Node;
var
NearestNeighbour: PKDT13DS_Node;
function FindParentNode(const buffPtr: PKDT13DS_Vec; NodePtr: PKDT13DS_Node): PKDT13DS_Node;
var
Next: PKDT13DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT13DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT13DS_Node; const buffPtr: PKDT13DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT13DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT13DS_Vec; const p1, p2: PKDT13DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT13DS_Vec);
var
i, j: NativeInt;
p, t: PKDT13DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT13DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT13DS_Node(NearestNodes[0]);
end;
end;
function TKDT13DS.Search(const buff: TKDT13DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT13DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT13DS.Search(const buff: TKDT13DS_Vec; var SearchedDistanceMin: Double): PKDT13DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT13DS.Search(const buff: TKDT13DS_Vec): PKDT13DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT13DS.SearchToken(const buff: TKDT13DS_Vec): TPascalString;
var
p: PKDT13DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT13DS.Search(const inBuff: TKDT13DS_DynamicVecBuffer; var OutBuff: TKDT13DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT13DS_DynamicVecBuffer;
outBuffPtr: PKDT13DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT13DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT13DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT13DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT13DS.Search(const inBuff: TKDT13DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT13DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT13DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT13DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT13DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT13DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT13DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT13DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT13DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT13DS_Vec)) <> SizeOf(TKDT13DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT13DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT13DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT13DS.PrintNodeTree(const NodePtr: PKDT13DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT13DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT13DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT13DS.Vec(const s: SystemString): TKDT13DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT13DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT13DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT13DS.Vec(const v: TKDT13DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT13DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT13DS.Distance(const v1, v2: TKDT13DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT13DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT13DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT13DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT13DS.Test;
var
TKDT13DS_Test: TKDT13DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT13DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT13DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT13DS_Test := TKDT13DS.Create;
n.Append('...');
SetLength(TKDT13DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT13DS_Test.TestBuff) - 1 do
for j := 0 to KDT13DS_Axis - 1 do
TKDT13DS_Test.TestBuff[i][j] := i * KDT13DS_Axis + j;
{$IFDEF FPC}
TKDT13DS_Test.BuildKDTreeM(length(TKDT13DS_Test.TestBuff), nil, @TKDT13DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT13DS_Test.BuildKDTreeM(length(TKDT13DS_Test.TestBuff), nil, TKDT13DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT13DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT13DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT13DS_Test.TestBuff) - 1 do
begin
p := TKDT13DS_Test.Search(TKDT13DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT13DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT13DS_Test.TestBuff));
TKDT13DS_Test.Search(TKDT13DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT13DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT13DS_Test.Clear;
{ kMean test }
TKDT13DS_Test.BuildKDTreeWithCluster(TKDT13DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT13DS_Test.Search(TKDT13DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT13DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT13DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT13DS_Test);
DoStatus(n);
n := '';
end;
function TKDT14DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT14DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT14DS_Node;
function SortCompare(const p1, p2: PKDT14DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT14DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT14DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT14DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT14DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT14DS.GetData(const Index: NativeInt): PKDT14DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT14DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT14DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT14DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT14DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT14DS.StoreBuffPtr: PKDT14DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT14DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT14DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT14DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT14DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT14DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT14DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT14DS.BuildKDTreeWithCluster(const inBuff: TKDT14DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT14DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT14DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT14DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT14DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT14DS.BuildKDTreeWithCluster(const inBuff: TKDT14DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT14DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT14DS_BuildCall);
var
TempStoreBuff: TKDT14DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT14DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT14DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT14DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT14DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT14DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT14DS_BuildMethod);
var
TempStoreBuff: TKDT14DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT14DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT14DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT14DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT14DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT14DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT14DS_BuildProc);
var
TempStoreBuff: TKDT14DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT14DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT14DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT14DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT14DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT14DS.Search(const buff: TKDT14DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT14DS_Node;
var
NearestNeighbour: PKDT14DS_Node;
function FindParentNode(const buffPtr: PKDT14DS_Vec; NodePtr: PKDT14DS_Node): PKDT14DS_Node;
var
Next: PKDT14DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT14DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT14DS_Node; const buffPtr: PKDT14DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT14DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT14DS_Vec; const p1, p2: PKDT14DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT14DS_Vec);
var
i, j: NativeInt;
p, t: PKDT14DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT14DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT14DS_Node(NearestNodes[0]);
end;
end;
function TKDT14DS.Search(const buff: TKDT14DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT14DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT14DS.Search(const buff: TKDT14DS_Vec; var SearchedDistanceMin: Double): PKDT14DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT14DS.Search(const buff: TKDT14DS_Vec): PKDT14DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT14DS.SearchToken(const buff: TKDT14DS_Vec): TPascalString;
var
p: PKDT14DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT14DS.Search(const inBuff: TKDT14DS_DynamicVecBuffer; var OutBuff: TKDT14DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT14DS_DynamicVecBuffer;
outBuffPtr: PKDT14DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT14DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT14DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT14DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT14DS.Search(const inBuff: TKDT14DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT14DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT14DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT14DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT14DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT14DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT14DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT14DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT14DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT14DS_Vec)) <> SizeOf(TKDT14DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT14DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT14DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT14DS.PrintNodeTree(const NodePtr: PKDT14DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT14DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT14DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT14DS.Vec(const s: SystemString): TKDT14DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT14DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT14DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT14DS.Vec(const v: TKDT14DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT14DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT14DS.Distance(const v1, v2: TKDT14DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT14DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT14DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT14DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT14DS.Test;
var
TKDT14DS_Test: TKDT14DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT14DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT14DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT14DS_Test := TKDT14DS.Create;
n.Append('...');
SetLength(TKDT14DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT14DS_Test.TestBuff) - 1 do
for j := 0 to KDT14DS_Axis - 1 do
TKDT14DS_Test.TestBuff[i][j] := i * KDT14DS_Axis + j;
{$IFDEF FPC}
TKDT14DS_Test.BuildKDTreeM(length(TKDT14DS_Test.TestBuff), nil, @TKDT14DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT14DS_Test.BuildKDTreeM(length(TKDT14DS_Test.TestBuff), nil, TKDT14DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT14DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT14DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT14DS_Test.TestBuff) - 1 do
begin
p := TKDT14DS_Test.Search(TKDT14DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT14DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT14DS_Test.TestBuff));
TKDT14DS_Test.Search(TKDT14DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT14DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT14DS_Test.Clear;
{ kMean test }
TKDT14DS_Test.BuildKDTreeWithCluster(TKDT14DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT14DS_Test.Search(TKDT14DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT14DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT14DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT14DS_Test);
DoStatus(n);
n := '';
end;
function TKDT15DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT15DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT15DS_Node;
function SortCompare(const p1, p2: PKDT15DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT15DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT15DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT15DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT15DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT15DS.GetData(const Index: NativeInt): PKDT15DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT15DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT15DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT15DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT15DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT15DS.StoreBuffPtr: PKDT15DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT15DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT15DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT15DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT15DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT15DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT15DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT15DS.BuildKDTreeWithCluster(const inBuff: TKDT15DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT15DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT15DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT15DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT15DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT15DS.BuildKDTreeWithCluster(const inBuff: TKDT15DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT15DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT15DS_BuildCall);
var
TempStoreBuff: TKDT15DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT15DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT15DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT15DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT15DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT15DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT15DS_BuildMethod);
var
TempStoreBuff: TKDT15DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT15DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT15DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT15DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT15DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT15DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT15DS_BuildProc);
var
TempStoreBuff: TKDT15DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT15DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT15DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT15DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT15DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT15DS.Search(const buff: TKDT15DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT15DS_Node;
var
NearestNeighbour: PKDT15DS_Node;
function FindParentNode(const buffPtr: PKDT15DS_Vec; NodePtr: PKDT15DS_Node): PKDT15DS_Node;
var
Next: PKDT15DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT15DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT15DS_Node; const buffPtr: PKDT15DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT15DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT15DS_Vec; const p1, p2: PKDT15DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT15DS_Vec);
var
i, j: NativeInt;
p, t: PKDT15DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT15DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT15DS_Node(NearestNodes[0]);
end;
end;
function TKDT15DS.Search(const buff: TKDT15DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT15DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT15DS.Search(const buff: TKDT15DS_Vec; var SearchedDistanceMin: Double): PKDT15DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT15DS.Search(const buff: TKDT15DS_Vec): PKDT15DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT15DS.SearchToken(const buff: TKDT15DS_Vec): TPascalString;
var
p: PKDT15DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT15DS.Search(const inBuff: TKDT15DS_DynamicVecBuffer; var OutBuff: TKDT15DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT15DS_DynamicVecBuffer;
outBuffPtr: PKDT15DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT15DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT15DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT15DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT15DS.Search(const inBuff: TKDT15DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT15DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT15DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT15DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT15DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT15DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT15DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT15DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT15DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT15DS_Vec)) <> SizeOf(TKDT15DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT15DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT15DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT15DS.PrintNodeTree(const NodePtr: PKDT15DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT15DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT15DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT15DS.Vec(const s: SystemString): TKDT15DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT15DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT15DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT15DS.Vec(const v: TKDT15DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT15DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT15DS.Distance(const v1, v2: TKDT15DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT15DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT15DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT15DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT15DS.Test;
var
TKDT15DS_Test: TKDT15DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT15DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT15DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT15DS_Test := TKDT15DS.Create;
n.Append('...');
SetLength(TKDT15DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT15DS_Test.TestBuff) - 1 do
for j := 0 to KDT15DS_Axis - 1 do
TKDT15DS_Test.TestBuff[i][j] := i * KDT15DS_Axis + j;
{$IFDEF FPC}
TKDT15DS_Test.BuildKDTreeM(length(TKDT15DS_Test.TestBuff), nil, @TKDT15DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT15DS_Test.BuildKDTreeM(length(TKDT15DS_Test.TestBuff), nil, TKDT15DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT15DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT15DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT15DS_Test.TestBuff) - 1 do
begin
p := TKDT15DS_Test.Search(TKDT15DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT15DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT15DS_Test.TestBuff));
TKDT15DS_Test.Search(TKDT15DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT15DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT15DS_Test.Clear;
{ kMean test }
TKDT15DS_Test.BuildKDTreeWithCluster(TKDT15DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT15DS_Test.Search(TKDT15DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT15DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT15DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT15DS_Test);
DoStatus(n);
n := '';
end;
function TKDT16DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT16DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT16DS_Node;
function SortCompare(const p1, p2: PKDT16DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT16DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT16DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT16DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT16DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT16DS.GetData(const Index: NativeInt): PKDT16DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT16DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT16DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT16DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT16DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT16DS.StoreBuffPtr: PKDT16DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT16DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT16DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT16DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT16DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT16DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT16DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT16DS.BuildKDTreeWithCluster(const inBuff: TKDT16DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT16DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT16DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT16DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT16DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT16DS.BuildKDTreeWithCluster(const inBuff: TKDT16DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT16DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT16DS_BuildCall);
var
TempStoreBuff: TKDT16DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT16DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT16DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT16DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT16DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT16DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT16DS_BuildMethod);
var
TempStoreBuff: TKDT16DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT16DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT16DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT16DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT16DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT16DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT16DS_BuildProc);
var
TempStoreBuff: TKDT16DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT16DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT16DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT16DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT16DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT16DS.Search(const buff: TKDT16DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT16DS_Node;
var
NearestNeighbour: PKDT16DS_Node;
function FindParentNode(const buffPtr: PKDT16DS_Vec; NodePtr: PKDT16DS_Node): PKDT16DS_Node;
var
Next: PKDT16DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT16DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT16DS_Node; const buffPtr: PKDT16DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT16DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT16DS_Vec; const p1, p2: PKDT16DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT16DS_Vec);
var
i, j: NativeInt;
p, t: PKDT16DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT16DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT16DS_Node(NearestNodes[0]);
end;
end;
function TKDT16DS.Search(const buff: TKDT16DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT16DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT16DS.Search(const buff: TKDT16DS_Vec; var SearchedDistanceMin: Double): PKDT16DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT16DS.Search(const buff: TKDT16DS_Vec): PKDT16DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT16DS.SearchToken(const buff: TKDT16DS_Vec): TPascalString;
var
p: PKDT16DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT16DS.Search(const inBuff: TKDT16DS_DynamicVecBuffer; var OutBuff: TKDT16DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT16DS_DynamicVecBuffer;
outBuffPtr: PKDT16DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT16DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT16DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT16DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT16DS.Search(const inBuff: TKDT16DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT16DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT16DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT16DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT16DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT16DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT16DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT16DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT16DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT16DS_Vec)) <> SizeOf(TKDT16DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT16DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT16DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT16DS.PrintNodeTree(const NodePtr: PKDT16DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT16DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT16DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT16DS.Vec(const s: SystemString): TKDT16DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT16DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT16DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT16DS.Vec(const v: TKDT16DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT16DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT16DS.Distance(const v1, v2: TKDT16DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT16DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT16DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT16DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT16DS.Test;
var
TKDT16DS_Test: TKDT16DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT16DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT16DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT16DS_Test := TKDT16DS.Create;
n.Append('...');
SetLength(TKDT16DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT16DS_Test.TestBuff) - 1 do
for j := 0 to KDT16DS_Axis - 1 do
TKDT16DS_Test.TestBuff[i][j] := i * KDT16DS_Axis + j;
{$IFDEF FPC}
TKDT16DS_Test.BuildKDTreeM(length(TKDT16DS_Test.TestBuff), nil, @TKDT16DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT16DS_Test.BuildKDTreeM(length(TKDT16DS_Test.TestBuff), nil, TKDT16DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT16DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT16DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT16DS_Test.TestBuff) - 1 do
begin
p := TKDT16DS_Test.Search(TKDT16DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT16DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT16DS_Test.TestBuff));
TKDT16DS_Test.Search(TKDT16DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT16DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT16DS_Test.Clear;
{ kMean test }
TKDT16DS_Test.BuildKDTreeWithCluster(TKDT16DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT16DS_Test.Search(TKDT16DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT16DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT16DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT16DS_Test);
DoStatus(n);
n := '';
end;
function TKDT17DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT17DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT17DS_Node;
function SortCompare(const p1, p2: PKDT17DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT17DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT17DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT17DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT17DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT17DS.GetData(const Index: NativeInt): PKDT17DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT17DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT17DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT17DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT17DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT17DS.StoreBuffPtr: PKDT17DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT17DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT17DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT17DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT17DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT17DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT17DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT17DS.BuildKDTreeWithCluster(const inBuff: TKDT17DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT17DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT17DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT17DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT17DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT17DS.BuildKDTreeWithCluster(const inBuff: TKDT17DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT17DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT17DS_BuildCall);
var
TempStoreBuff: TKDT17DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT17DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT17DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT17DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT17DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT17DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT17DS_BuildMethod);
var
TempStoreBuff: TKDT17DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT17DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT17DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT17DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT17DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT17DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT17DS_BuildProc);
var
TempStoreBuff: TKDT17DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT17DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT17DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT17DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT17DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT17DS.Search(const buff: TKDT17DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT17DS_Node;
var
NearestNeighbour: PKDT17DS_Node;
function FindParentNode(const buffPtr: PKDT17DS_Vec; NodePtr: PKDT17DS_Node): PKDT17DS_Node;
var
Next: PKDT17DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT17DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT17DS_Node; const buffPtr: PKDT17DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT17DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT17DS_Vec; const p1, p2: PKDT17DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT17DS_Vec);
var
i, j: NativeInt;
p, t: PKDT17DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT17DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT17DS_Node(NearestNodes[0]);
end;
end;
function TKDT17DS.Search(const buff: TKDT17DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT17DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT17DS.Search(const buff: TKDT17DS_Vec; var SearchedDistanceMin: Double): PKDT17DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT17DS.Search(const buff: TKDT17DS_Vec): PKDT17DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT17DS.SearchToken(const buff: TKDT17DS_Vec): TPascalString;
var
p: PKDT17DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT17DS.Search(const inBuff: TKDT17DS_DynamicVecBuffer; var OutBuff: TKDT17DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT17DS_DynamicVecBuffer;
outBuffPtr: PKDT17DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT17DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT17DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT17DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT17DS.Search(const inBuff: TKDT17DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT17DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT17DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT17DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT17DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT17DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT17DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT17DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT17DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT17DS_Vec)) <> SizeOf(TKDT17DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT17DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT17DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT17DS.PrintNodeTree(const NodePtr: PKDT17DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT17DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT17DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT17DS.Vec(const s: SystemString): TKDT17DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT17DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT17DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT17DS.Vec(const v: TKDT17DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT17DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT17DS.Distance(const v1, v2: TKDT17DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT17DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT17DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT17DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT17DS.Test;
var
TKDT17DS_Test: TKDT17DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT17DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT17DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT17DS_Test := TKDT17DS.Create;
n.Append('...');
SetLength(TKDT17DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT17DS_Test.TestBuff) - 1 do
for j := 0 to KDT17DS_Axis - 1 do
TKDT17DS_Test.TestBuff[i][j] := i * KDT17DS_Axis + j;
{$IFDEF FPC}
TKDT17DS_Test.BuildKDTreeM(length(TKDT17DS_Test.TestBuff), nil, @TKDT17DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT17DS_Test.BuildKDTreeM(length(TKDT17DS_Test.TestBuff), nil, TKDT17DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT17DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT17DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT17DS_Test.TestBuff) - 1 do
begin
p := TKDT17DS_Test.Search(TKDT17DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT17DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT17DS_Test.TestBuff));
TKDT17DS_Test.Search(TKDT17DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT17DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT17DS_Test.Clear;
{ kMean test }
TKDT17DS_Test.BuildKDTreeWithCluster(TKDT17DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT17DS_Test.Search(TKDT17DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT17DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT17DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT17DS_Test);
DoStatus(n);
n := '';
end;
function TKDT18DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT18DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT18DS_Node;
function SortCompare(const p1, p2: PKDT18DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT18DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT18DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT18DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT18DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT18DS.GetData(const Index: NativeInt): PKDT18DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT18DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT18DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT18DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT18DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT18DS.StoreBuffPtr: PKDT18DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT18DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT18DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT18DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT18DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT18DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT18DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT18DS.BuildKDTreeWithCluster(const inBuff: TKDT18DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT18DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT18DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT18DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT18DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT18DS.BuildKDTreeWithCluster(const inBuff: TKDT18DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT18DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT18DS_BuildCall);
var
TempStoreBuff: TKDT18DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT18DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT18DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT18DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT18DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT18DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT18DS_BuildMethod);
var
TempStoreBuff: TKDT18DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT18DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT18DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT18DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT18DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT18DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT18DS_BuildProc);
var
TempStoreBuff: TKDT18DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT18DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT18DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT18DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT18DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT18DS.Search(const buff: TKDT18DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT18DS_Node;
var
NearestNeighbour: PKDT18DS_Node;
function FindParentNode(const buffPtr: PKDT18DS_Vec; NodePtr: PKDT18DS_Node): PKDT18DS_Node;
var
Next: PKDT18DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT18DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT18DS_Node; const buffPtr: PKDT18DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT18DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT18DS_Vec; const p1, p2: PKDT18DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT18DS_Vec);
var
i, j: NativeInt;
p, t: PKDT18DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT18DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT18DS_Node(NearestNodes[0]);
end;
end;
function TKDT18DS.Search(const buff: TKDT18DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT18DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT18DS.Search(const buff: TKDT18DS_Vec; var SearchedDistanceMin: Double): PKDT18DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT18DS.Search(const buff: TKDT18DS_Vec): PKDT18DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT18DS.SearchToken(const buff: TKDT18DS_Vec): TPascalString;
var
p: PKDT18DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT18DS.Search(const inBuff: TKDT18DS_DynamicVecBuffer; var OutBuff: TKDT18DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT18DS_DynamicVecBuffer;
outBuffPtr: PKDT18DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT18DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT18DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT18DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT18DS.Search(const inBuff: TKDT18DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT18DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT18DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT18DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT18DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT18DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT18DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT18DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT18DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT18DS_Vec)) <> SizeOf(TKDT18DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT18DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT18DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT18DS.PrintNodeTree(const NodePtr: PKDT18DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT18DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT18DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT18DS.Vec(const s: SystemString): TKDT18DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT18DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT18DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT18DS.Vec(const v: TKDT18DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT18DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT18DS.Distance(const v1, v2: TKDT18DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT18DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT18DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT18DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT18DS.Test;
var
TKDT18DS_Test: TKDT18DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT18DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT18DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT18DS_Test := TKDT18DS.Create;
n.Append('...');
SetLength(TKDT18DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT18DS_Test.TestBuff) - 1 do
for j := 0 to KDT18DS_Axis - 1 do
TKDT18DS_Test.TestBuff[i][j] := i * KDT18DS_Axis + j;
{$IFDEF FPC}
TKDT18DS_Test.BuildKDTreeM(length(TKDT18DS_Test.TestBuff), nil, @TKDT18DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT18DS_Test.BuildKDTreeM(length(TKDT18DS_Test.TestBuff), nil, TKDT18DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT18DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT18DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT18DS_Test.TestBuff) - 1 do
begin
p := TKDT18DS_Test.Search(TKDT18DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT18DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT18DS_Test.TestBuff));
TKDT18DS_Test.Search(TKDT18DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT18DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT18DS_Test.Clear;
{ kMean test }
TKDT18DS_Test.BuildKDTreeWithCluster(TKDT18DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT18DS_Test.Search(TKDT18DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT18DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT18DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT18DS_Test);
DoStatus(n);
n := '';
end;
function TKDT19DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT19DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT19DS_Node;
function SortCompare(const p1, p2: PKDT19DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT19DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT19DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT19DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT19DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT19DS.GetData(const Index: NativeInt): PKDT19DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT19DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT19DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT19DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT19DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT19DS.StoreBuffPtr: PKDT19DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT19DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT19DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT19DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT19DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT19DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT19DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT19DS.BuildKDTreeWithCluster(const inBuff: TKDT19DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT19DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT19DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT19DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT19DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT19DS.BuildKDTreeWithCluster(const inBuff: TKDT19DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT19DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT19DS_BuildCall);
var
TempStoreBuff: TKDT19DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT19DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT19DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT19DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT19DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT19DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT19DS_BuildMethod);
var
TempStoreBuff: TKDT19DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT19DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT19DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT19DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT19DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT19DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT19DS_BuildProc);
var
TempStoreBuff: TKDT19DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT19DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT19DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT19DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT19DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT19DS.Search(const buff: TKDT19DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT19DS_Node;
var
NearestNeighbour: PKDT19DS_Node;
function FindParentNode(const buffPtr: PKDT19DS_Vec; NodePtr: PKDT19DS_Node): PKDT19DS_Node;
var
Next: PKDT19DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT19DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT19DS_Node; const buffPtr: PKDT19DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT19DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT19DS_Vec; const p1, p2: PKDT19DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT19DS_Vec);
var
i, j: NativeInt;
p, t: PKDT19DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT19DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT19DS_Node(NearestNodes[0]);
end;
end;
function TKDT19DS.Search(const buff: TKDT19DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT19DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT19DS.Search(const buff: TKDT19DS_Vec; var SearchedDistanceMin: Double): PKDT19DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT19DS.Search(const buff: TKDT19DS_Vec): PKDT19DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT19DS.SearchToken(const buff: TKDT19DS_Vec): TPascalString;
var
p: PKDT19DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT19DS.Search(const inBuff: TKDT19DS_DynamicVecBuffer; var OutBuff: TKDT19DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT19DS_DynamicVecBuffer;
outBuffPtr: PKDT19DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT19DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT19DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT19DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT19DS.Search(const inBuff: TKDT19DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT19DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT19DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT19DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT19DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT19DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT19DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT19DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT19DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT19DS_Vec)) <> SizeOf(TKDT19DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT19DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT19DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT19DS.PrintNodeTree(const NodePtr: PKDT19DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT19DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT19DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT19DS.Vec(const s: SystemString): TKDT19DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT19DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT19DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT19DS.Vec(const v: TKDT19DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT19DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT19DS.Distance(const v1, v2: TKDT19DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT19DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT19DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT19DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT19DS.Test;
var
TKDT19DS_Test: TKDT19DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT19DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT19DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT19DS_Test := TKDT19DS.Create;
n.Append('...');
SetLength(TKDT19DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT19DS_Test.TestBuff) - 1 do
for j := 0 to KDT19DS_Axis - 1 do
TKDT19DS_Test.TestBuff[i][j] := i * KDT19DS_Axis + j;
{$IFDEF FPC}
TKDT19DS_Test.BuildKDTreeM(length(TKDT19DS_Test.TestBuff), nil, @TKDT19DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT19DS_Test.BuildKDTreeM(length(TKDT19DS_Test.TestBuff), nil, TKDT19DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT19DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT19DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT19DS_Test.TestBuff) - 1 do
begin
p := TKDT19DS_Test.Search(TKDT19DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT19DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT19DS_Test.TestBuff));
TKDT19DS_Test.Search(TKDT19DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT19DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT19DS_Test.Clear;
{ kMean test }
TKDT19DS_Test.BuildKDTreeWithCluster(TKDT19DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT19DS_Test.Search(TKDT19DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT19DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT19DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT19DS_Test);
DoStatus(n);
n := '';
end;
function TKDT20DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT20DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT20DS_Node;
function SortCompare(const p1, p2: PKDT20DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT20DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT20DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT20DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT20DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT20DS.GetData(const Index: NativeInt): PKDT20DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT20DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT20DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT20DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT20DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT20DS.StoreBuffPtr: PKDT20DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT20DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT20DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT20DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT20DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT20DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT20DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT20DS.BuildKDTreeWithCluster(const inBuff: TKDT20DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT20DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT20DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT20DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT20DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT20DS.BuildKDTreeWithCluster(const inBuff: TKDT20DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT20DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT20DS_BuildCall);
var
TempStoreBuff: TKDT20DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT20DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT20DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT20DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT20DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT20DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT20DS_BuildMethod);
var
TempStoreBuff: TKDT20DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT20DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT20DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT20DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT20DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT20DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT20DS_BuildProc);
var
TempStoreBuff: TKDT20DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT20DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT20DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT20DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT20DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT20DS.Search(const buff: TKDT20DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT20DS_Node;
var
NearestNeighbour: PKDT20DS_Node;
function FindParentNode(const buffPtr: PKDT20DS_Vec; NodePtr: PKDT20DS_Node): PKDT20DS_Node;
var
Next: PKDT20DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT20DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT20DS_Node; const buffPtr: PKDT20DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT20DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT20DS_Vec; const p1, p2: PKDT20DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT20DS_Vec);
var
i, j: NativeInt;
p, t: PKDT20DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT20DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT20DS_Node(NearestNodes[0]);
end;
end;
function TKDT20DS.Search(const buff: TKDT20DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT20DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT20DS.Search(const buff: TKDT20DS_Vec; var SearchedDistanceMin: Double): PKDT20DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT20DS.Search(const buff: TKDT20DS_Vec): PKDT20DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT20DS.SearchToken(const buff: TKDT20DS_Vec): TPascalString;
var
p: PKDT20DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT20DS.Search(const inBuff: TKDT20DS_DynamicVecBuffer; var OutBuff: TKDT20DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT20DS_DynamicVecBuffer;
outBuffPtr: PKDT20DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT20DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT20DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT20DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT20DS.Search(const inBuff: TKDT20DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT20DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT20DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT20DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT20DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT20DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT20DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT20DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT20DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT20DS_Vec)) <> SizeOf(TKDT20DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT20DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT20DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT20DS.PrintNodeTree(const NodePtr: PKDT20DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT20DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT20DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT20DS.Vec(const s: SystemString): TKDT20DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT20DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT20DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT20DS.Vec(const v: TKDT20DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT20DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT20DS.Distance(const v1, v2: TKDT20DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT20DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT20DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT20DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT20DS.Test;
var
TKDT20DS_Test: TKDT20DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT20DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT20DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT20DS_Test := TKDT20DS.Create;
n.Append('...');
SetLength(TKDT20DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT20DS_Test.TestBuff) - 1 do
for j := 0 to KDT20DS_Axis - 1 do
TKDT20DS_Test.TestBuff[i][j] := i * KDT20DS_Axis + j;
{$IFDEF FPC}
TKDT20DS_Test.BuildKDTreeM(length(TKDT20DS_Test.TestBuff), nil, @TKDT20DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT20DS_Test.BuildKDTreeM(length(TKDT20DS_Test.TestBuff), nil, TKDT20DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT20DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT20DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT20DS_Test.TestBuff) - 1 do
begin
p := TKDT20DS_Test.Search(TKDT20DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT20DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT20DS_Test.TestBuff));
TKDT20DS_Test.Search(TKDT20DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT20DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT20DS_Test.Clear;
{ kMean test }
TKDT20DS_Test.BuildKDTreeWithCluster(TKDT20DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT20DS_Test.Search(TKDT20DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT20DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT20DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT20DS_Test);
DoStatus(n);
n := '';
end;
function TKDT21DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT21DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT21DS_Node;
function SortCompare(const p1, p2: PKDT21DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT21DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT21DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT21DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT21DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT21DS.GetData(const Index: NativeInt): PKDT21DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT21DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT21DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT21DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT21DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT21DS.StoreBuffPtr: PKDT21DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT21DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT21DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT21DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT21DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT21DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT21DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT21DS.BuildKDTreeWithCluster(const inBuff: TKDT21DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT21DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT21DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT21DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT21DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT21DS.BuildKDTreeWithCluster(const inBuff: TKDT21DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT21DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT21DS_BuildCall);
var
TempStoreBuff: TKDT21DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT21DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT21DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT21DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT21DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT21DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT21DS_BuildMethod);
var
TempStoreBuff: TKDT21DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT21DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT21DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT21DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT21DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT21DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT21DS_BuildProc);
var
TempStoreBuff: TKDT21DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT21DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT21DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT21DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT21DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT21DS.Search(const buff: TKDT21DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT21DS_Node;
var
NearestNeighbour: PKDT21DS_Node;
function FindParentNode(const buffPtr: PKDT21DS_Vec; NodePtr: PKDT21DS_Node): PKDT21DS_Node;
var
Next: PKDT21DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT21DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT21DS_Node; const buffPtr: PKDT21DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT21DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT21DS_Vec; const p1, p2: PKDT21DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT21DS_Vec);
var
i, j: NativeInt;
p, t: PKDT21DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT21DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT21DS_Node(NearestNodes[0]);
end;
end;
function TKDT21DS.Search(const buff: TKDT21DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT21DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT21DS.Search(const buff: TKDT21DS_Vec; var SearchedDistanceMin: Double): PKDT21DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT21DS.Search(const buff: TKDT21DS_Vec): PKDT21DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT21DS.SearchToken(const buff: TKDT21DS_Vec): TPascalString;
var
p: PKDT21DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT21DS.Search(const inBuff: TKDT21DS_DynamicVecBuffer; var OutBuff: TKDT21DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT21DS_DynamicVecBuffer;
outBuffPtr: PKDT21DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT21DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT21DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT21DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT21DS.Search(const inBuff: TKDT21DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT21DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT21DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT21DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT21DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT21DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT21DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT21DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT21DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT21DS_Vec)) <> SizeOf(TKDT21DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT21DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT21DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT21DS.PrintNodeTree(const NodePtr: PKDT21DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT21DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT21DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT21DS.Vec(const s: SystemString): TKDT21DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT21DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT21DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT21DS.Vec(const v: TKDT21DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT21DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT21DS.Distance(const v1, v2: TKDT21DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT21DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT21DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT21DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT21DS.Test;
var
TKDT21DS_Test: TKDT21DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT21DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT21DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT21DS_Test := TKDT21DS.Create;
n.Append('...');
SetLength(TKDT21DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT21DS_Test.TestBuff) - 1 do
for j := 0 to KDT21DS_Axis - 1 do
TKDT21DS_Test.TestBuff[i][j] := i * KDT21DS_Axis + j;
{$IFDEF FPC}
TKDT21DS_Test.BuildKDTreeM(length(TKDT21DS_Test.TestBuff), nil, @TKDT21DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT21DS_Test.BuildKDTreeM(length(TKDT21DS_Test.TestBuff), nil, TKDT21DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT21DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT21DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT21DS_Test.TestBuff) - 1 do
begin
p := TKDT21DS_Test.Search(TKDT21DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT21DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT21DS_Test.TestBuff));
TKDT21DS_Test.Search(TKDT21DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT21DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT21DS_Test.Clear;
{ kMean test }
TKDT21DS_Test.BuildKDTreeWithCluster(TKDT21DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT21DS_Test.Search(TKDT21DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT21DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT21DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT21DS_Test);
DoStatus(n);
n := '';
end;
function TKDT22DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT22DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT22DS_Node;
function SortCompare(const p1, p2: PKDT22DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT22DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT22DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT22DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT22DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT22DS.GetData(const Index: NativeInt): PKDT22DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT22DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT22DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT22DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT22DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT22DS.StoreBuffPtr: PKDT22DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT22DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT22DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT22DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT22DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT22DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT22DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT22DS.BuildKDTreeWithCluster(const inBuff: TKDT22DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT22DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT22DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT22DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT22DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT22DS.BuildKDTreeWithCluster(const inBuff: TKDT22DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT22DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT22DS_BuildCall);
var
TempStoreBuff: TKDT22DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT22DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT22DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT22DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT22DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT22DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT22DS_BuildMethod);
var
TempStoreBuff: TKDT22DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT22DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT22DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT22DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT22DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT22DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT22DS_BuildProc);
var
TempStoreBuff: TKDT22DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT22DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT22DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT22DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT22DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT22DS.Search(const buff: TKDT22DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT22DS_Node;
var
NearestNeighbour: PKDT22DS_Node;
function FindParentNode(const buffPtr: PKDT22DS_Vec; NodePtr: PKDT22DS_Node): PKDT22DS_Node;
var
Next: PKDT22DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT22DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT22DS_Node; const buffPtr: PKDT22DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT22DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT22DS_Vec; const p1, p2: PKDT22DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT22DS_Vec);
var
i, j: NativeInt;
p, t: PKDT22DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT22DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT22DS_Node(NearestNodes[0]);
end;
end;
function TKDT22DS.Search(const buff: TKDT22DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT22DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT22DS.Search(const buff: TKDT22DS_Vec; var SearchedDistanceMin: Double): PKDT22DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT22DS.Search(const buff: TKDT22DS_Vec): PKDT22DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT22DS.SearchToken(const buff: TKDT22DS_Vec): TPascalString;
var
p: PKDT22DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT22DS.Search(const inBuff: TKDT22DS_DynamicVecBuffer; var OutBuff: TKDT22DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT22DS_DynamicVecBuffer;
outBuffPtr: PKDT22DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT22DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT22DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT22DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT22DS.Search(const inBuff: TKDT22DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT22DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT22DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT22DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT22DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT22DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT22DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT22DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT22DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT22DS_Vec)) <> SizeOf(TKDT22DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT22DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT22DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT22DS.PrintNodeTree(const NodePtr: PKDT22DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT22DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT22DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT22DS.Vec(const s: SystemString): TKDT22DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT22DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT22DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT22DS.Vec(const v: TKDT22DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT22DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT22DS.Distance(const v1, v2: TKDT22DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT22DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT22DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT22DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT22DS.Test;
var
TKDT22DS_Test: TKDT22DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT22DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT22DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT22DS_Test := TKDT22DS.Create;
n.Append('...');
SetLength(TKDT22DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT22DS_Test.TestBuff) - 1 do
for j := 0 to KDT22DS_Axis - 1 do
TKDT22DS_Test.TestBuff[i][j] := i * KDT22DS_Axis + j;
{$IFDEF FPC}
TKDT22DS_Test.BuildKDTreeM(length(TKDT22DS_Test.TestBuff), nil, @TKDT22DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT22DS_Test.BuildKDTreeM(length(TKDT22DS_Test.TestBuff), nil, TKDT22DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT22DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT22DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT22DS_Test.TestBuff) - 1 do
begin
p := TKDT22DS_Test.Search(TKDT22DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT22DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT22DS_Test.TestBuff));
TKDT22DS_Test.Search(TKDT22DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT22DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT22DS_Test.Clear;
{ kMean test }
TKDT22DS_Test.BuildKDTreeWithCluster(TKDT22DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT22DS_Test.Search(TKDT22DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT22DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT22DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT22DS_Test);
DoStatus(n);
n := '';
end;
function TKDT23DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT23DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT23DS_Node;
function SortCompare(const p1, p2: PKDT23DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT23DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT23DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT23DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT23DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT23DS.GetData(const Index: NativeInt): PKDT23DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT23DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT23DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT23DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT23DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT23DS.StoreBuffPtr: PKDT23DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT23DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT23DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT23DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT23DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT23DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT23DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT23DS.BuildKDTreeWithCluster(const inBuff: TKDT23DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT23DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT23DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT23DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT23DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT23DS.BuildKDTreeWithCluster(const inBuff: TKDT23DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT23DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT23DS_BuildCall);
var
TempStoreBuff: TKDT23DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT23DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT23DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT23DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT23DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT23DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT23DS_BuildMethod);
var
TempStoreBuff: TKDT23DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT23DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT23DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT23DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT23DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT23DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT23DS_BuildProc);
var
TempStoreBuff: TKDT23DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT23DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT23DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT23DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT23DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT23DS.Search(const buff: TKDT23DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT23DS_Node;
var
NearestNeighbour: PKDT23DS_Node;
function FindParentNode(const buffPtr: PKDT23DS_Vec; NodePtr: PKDT23DS_Node): PKDT23DS_Node;
var
Next: PKDT23DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT23DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT23DS_Node; const buffPtr: PKDT23DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT23DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT23DS_Vec; const p1, p2: PKDT23DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT23DS_Vec);
var
i, j: NativeInt;
p, t: PKDT23DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT23DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT23DS_Node(NearestNodes[0]);
end;
end;
function TKDT23DS.Search(const buff: TKDT23DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT23DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT23DS.Search(const buff: TKDT23DS_Vec; var SearchedDistanceMin: Double): PKDT23DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT23DS.Search(const buff: TKDT23DS_Vec): PKDT23DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT23DS.SearchToken(const buff: TKDT23DS_Vec): TPascalString;
var
p: PKDT23DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT23DS.Search(const inBuff: TKDT23DS_DynamicVecBuffer; var OutBuff: TKDT23DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT23DS_DynamicVecBuffer;
outBuffPtr: PKDT23DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT23DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT23DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT23DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT23DS.Search(const inBuff: TKDT23DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT23DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT23DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT23DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT23DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT23DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT23DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT23DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT23DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT23DS_Vec)) <> SizeOf(TKDT23DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT23DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT23DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT23DS.PrintNodeTree(const NodePtr: PKDT23DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT23DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT23DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT23DS.Vec(const s: SystemString): TKDT23DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT23DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT23DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT23DS.Vec(const v: TKDT23DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT23DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT23DS.Distance(const v1, v2: TKDT23DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT23DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT23DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT23DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT23DS.Test;
var
TKDT23DS_Test: TKDT23DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT23DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT23DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT23DS_Test := TKDT23DS.Create;
n.Append('...');
SetLength(TKDT23DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT23DS_Test.TestBuff) - 1 do
for j := 0 to KDT23DS_Axis - 1 do
TKDT23DS_Test.TestBuff[i][j] := i * KDT23DS_Axis + j;
{$IFDEF FPC}
TKDT23DS_Test.BuildKDTreeM(length(TKDT23DS_Test.TestBuff), nil, @TKDT23DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT23DS_Test.BuildKDTreeM(length(TKDT23DS_Test.TestBuff), nil, TKDT23DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT23DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT23DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT23DS_Test.TestBuff) - 1 do
begin
p := TKDT23DS_Test.Search(TKDT23DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT23DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT23DS_Test.TestBuff));
TKDT23DS_Test.Search(TKDT23DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT23DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT23DS_Test.Clear;
{ kMean test }
TKDT23DS_Test.BuildKDTreeWithCluster(TKDT23DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT23DS_Test.Search(TKDT23DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT23DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT23DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT23DS_Test);
DoStatus(n);
n := '';
end;
function TKDT24DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT24DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT24DS_Node;
function SortCompare(const p1, p2: PKDT24DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT24DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT24DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT24DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT24DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT24DS.GetData(const Index: NativeInt): PKDT24DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT24DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT24DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT24DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT24DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT24DS.StoreBuffPtr: PKDT24DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT24DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT24DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT24DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT24DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT24DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT24DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT24DS.BuildKDTreeWithCluster(const inBuff: TKDT24DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT24DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT24DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT24DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT24DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT24DS.BuildKDTreeWithCluster(const inBuff: TKDT24DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT24DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT24DS_BuildCall);
var
TempStoreBuff: TKDT24DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT24DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT24DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT24DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT24DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT24DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT24DS_BuildMethod);
var
TempStoreBuff: TKDT24DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT24DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT24DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT24DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT24DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT24DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT24DS_BuildProc);
var
TempStoreBuff: TKDT24DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT24DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT24DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT24DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT24DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT24DS.Search(const buff: TKDT24DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT24DS_Node;
var
NearestNeighbour: PKDT24DS_Node;
function FindParentNode(const buffPtr: PKDT24DS_Vec; NodePtr: PKDT24DS_Node): PKDT24DS_Node;
var
Next: PKDT24DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT24DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT24DS_Node; const buffPtr: PKDT24DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT24DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT24DS_Vec; const p1, p2: PKDT24DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT24DS_Vec);
var
i, j: NativeInt;
p, t: PKDT24DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT24DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT24DS_Node(NearestNodes[0]);
end;
end;
function TKDT24DS.Search(const buff: TKDT24DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT24DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT24DS.Search(const buff: TKDT24DS_Vec; var SearchedDistanceMin: Double): PKDT24DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT24DS.Search(const buff: TKDT24DS_Vec): PKDT24DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT24DS.SearchToken(const buff: TKDT24DS_Vec): TPascalString;
var
p: PKDT24DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT24DS.Search(const inBuff: TKDT24DS_DynamicVecBuffer; var OutBuff: TKDT24DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT24DS_DynamicVecBuffer;
outBuffPtr: PKDT24DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT24DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT24DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT24DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT24DS.Search(const inBuff: TKDT24DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT24DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT24DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT24DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT24DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT24DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT24DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT24DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT24DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT24DS_Vec)) <> SizeOf(TKDT24DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT24DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT24DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT24DS.PrintNodeTree(const NodePtr: PKDT24DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT24DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT24DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT24DS.Vec(const s: SystemString): TKDT24DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT24DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT24DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT24DS.Vec(const v: TKDT24DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT24DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT24DS.Distance(const v1, v2: TKDT24DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT24DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT24DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT24DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT24DS.Test;
var
TKDT24DS_Test: TKDT24DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT24DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT24DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT24DS_Test := TKDT24DS.Create;
n.Append('...');
SetLength(TKDT24DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT24DS_Test.TestBuff) - 1 do
for j := 0 to KDT24DS_Axis - 1 do
TKDT24DS_Test.TestBuff[i][j] := i * KDT24DS_Axis + j;
{$IFDEF FPC}
TKDT24DS_Test.BuildKDTreeM(length(TKDT24DS_Test.TestBuff), nil, @TKDT24DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT24DS_Test.BuildKDTreeM(length(TKDT24DS_Test.TestBuff), nil, TKDT24DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT24DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT24DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT24DS_Test.TestBuff) - 1 do
begin
p := TKDT24DS_Test.Search(TKDT24DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT24DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT24DS_Test.TestBuff));
TKDT24DS_Test.Search(TKDT24DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT24DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT24DS_Test.Clear;
{ kMean test }
TKDT24DS_Test.BuildKDTreeWithCluster(TKDT24DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT24DS_Test.Search(TKDT24DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT24DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT24DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT24DS_Test);
DoStatus(n);
n := '';
end;
function TKDT48DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT48DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT48DS_Node;
function SortCompare(const p1, p2: PKDT48DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT48DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT48DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT48DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT48DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT48DS.GetData(const Index: NativeInt): PKDT48DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT48DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT48DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT48DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT48DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT48DS.StoreBuffPtr: PKDT48DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT48DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT48DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT48DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT48DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT48DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT48DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT48DS.BuildKDTreeWithCluster(const inBuff: TKDT48DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT48DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT48DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT48DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT48DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT48DS.BuildKDTreeWithCluster(const inBuff: TKDT48DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT48DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT48DS_BuildCall);
var
TempStoreBuff: TKDT48DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT48DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT48DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT48DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT48DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT48DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT48DS_BuildMethod);
var
TempStoreBuff: TKDT48DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT48DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT48DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT48DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT48DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT48DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT48DS_BuildProc);
var
TempStoreBuff: TKDT48DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT48DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT48DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT48DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT48DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT48DS.Search(const buff: TKDT48DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT48DS_Node;
var
NearestNeighbour: PKDT48DS_Node;
function FindParentNode(const buffPtr: PKDT48DS_Vec; NodePtr: PKDT48DS_Node): PKDT48DS_Node;
var
Next: PKDT48DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT48DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT48DS_Node; const buffPtr: PKDT48DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT48DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT48DS_Vec; const p1, p2: PKDT48DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT48DS_Vec);
var
i, j: NativeInt;
p, t: PKDT48DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT48DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT48DS_Node(NearestNodes[0]);
end;
end;
function TKDT48DS.Search(const buff: TKDT48DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT48DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT48DS.Search(const buff: TKDT48DS_Vec; var SearchedDistanceMin: Double): PKDT48DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT48DS.Search(const buff: TKDT48DS_Vec): PKDT48DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT48DS.SearchToken(const buff: TKDT48DS_Vec): TPascalString;
var
p: PKDT48DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT48DS.Search(const inBuff: TKDT48DS_DynamicVecBuffer; var OutBuff: TKDT48DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT48DS_DynamicVecBuffer;
outBuffPtr: PKDT48DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT48DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT48DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT48DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT48DS.Search(const inBuff: TKDT48DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT48DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT48DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT48DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT48DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT48DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT48DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT48DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT48DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT48DS_Vec)) <> SizeOf(TKDT48DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT48DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT48DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT48DS.PrintNodeTree(const NodePtr: PKDT48DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT48DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT48DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT48DS.Vec(const s: SystemString): TKDT48DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT48DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT48DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT48DS.Vec(const v: TKDT48DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT48DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT48DS.Distance(const v1, v2: TKDT48DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT48DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT48DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT48DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT48DS.Test;
var
TKDT48DS_Test: TKDT48DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT48DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT48DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT48DS_Test := TKDT48DS.Create;
n.Append('...');
SetLength(TKDT48DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT48DS_Test.TestBuff) - 1 do
for j := 0 to KDT48DS_Axis - 1 do
TKDT48DS_Test.TestBuff[i][j] := i * KDT48DS_Axis + j;
{$IFDEF FPC}
TKDT48DS_Test.BuildKDTreeM(length(TKDT48DS_Test.TestBuff), nil, @TKDT48DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT48DS_Test.BuildKDTreeM(length(TKDT48DS_Test.TestBuff), nil, TKDT48DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT48DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT48DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT48DS_Test.TestBuff) - 1 do
begin
p := TKDT48DS_Test.Search(TKDT48DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT48DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT48DS_Test.TestBuff));
TKDT48DS_Test.Search(TKDT48DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT48DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT48DS_Test.Clear;
{ kMean test }
TKDT48DS_Test.BuildKDTreeWithCluster(TKDT48DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT48DS_Test.Search(TKDT48DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT48DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT48DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT48DS_Test);
DoStatus(n);
n := '';
end;
function TKDT52DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT52DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT52DS_Node;
function SortCompare(const p1, p2: PKDT52DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT52DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT52DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT52DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT52DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT52DS.GetData(const Index: NativeInt): PKDT52DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT52DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT52DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT52DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT52DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT52DS.StoreBuffPtr: PKDT52DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT52DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT52DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT52DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT52DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT52DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT52DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT52DS.BuildKDTreeWithCluster(const inBuff: TKDT52DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT52DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT52DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT52DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT52DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT52DS.BuildKDTreeWithCluster(const inBuff: TKDT52DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT52DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT52DS_BuildCall);
var
TempStoreBuff: TKDT52DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT52DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT52DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT52DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT52DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT52DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT52DS_BuildMethod);
var
TempStoreBuff: TKDT52DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT52DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT52DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT52DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT52DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT52DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT52DS_BuildProc);
var
TempStoreBuff: TKDT52DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT52DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT52DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT52DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT52DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT52DS.Search(const buff: TKDT52DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT52DS_Node;
var
NearestNeighbour: PKDT52DS_Node;
function FindParentNode(const buffPtr: PKDT52DS_Vec; NodePtr: PKDT52DS_Node): PKDT52DS_Node;
var
Next: PKDT52DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT52DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT52DS_Node; const buffPtr: PKDT52DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT52DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT52DS_Vec; const p1, p2: PKDT52DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT52DS_Vec);
var
i, j: NativeInt;
p, t: PKDT52DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT52DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT52DS_Node(NearestNodes[0]);
end;
end;
function TKDT52DS.Search(const buff: TKDT52DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT52DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT52DS.Search(const buff: TKDT52DS_Vec; var SearchedDistanceMin: Double): PKDT52DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT52DS.Search(const buff: TKDT52DS_Vec): PKDT52DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT52DS.SearchToken(const buff: TKDT52DS_Vec): TPascalString;
var
p: PKDT52DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT52DS.Search(const inBuff: TKDT52DS_DynamicVecBuffer; var OutBuff: TKDT52DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT52DS_DynamicVecBuffer;
outBuffPtr: PKDT52DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT52DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT52DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT52DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT52DS.Search(const inBuff: TKDT52DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT52DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT52DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT52DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT52DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT52DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT52DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT52DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT52DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT52DS_Vec)) <> SizeOf(TKDT52DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT52DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT52DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT52DS.PrintNodeTree(const NodePtr: PKDT52DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT52DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT52DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT52DS.Vec(const s: SystemString): TKDT52DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT52DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT52DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT52DS.Vec(const v: TKDT52DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT52DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT52DS.Distance(const v1, v2: TKDT52DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT52DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT52DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT52DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT52DS.Test;
var
TKDT52DS_Test: TKDT52DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT52DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT52DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT52DS_Test := TKDT52DS.Create;
n.Append('...');
SetLength(TKDT52DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT52DS_Test.TestBuff) - 1 do
for j := 0 to KDT52DS_Axis - 1 do
TKDT52DS_Test.TestBuff[i][j] := i * KDT52DS_Axis + j;
{$IFDEF FPC}
TKDT52DS_Test.BuildKDTreeM(length(TKDT52DS_Test.TestBuff), nil, @TKDT52DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT52DS_Test.BuildKDTreeM(length(TKDT52DS_Test.TestBuff), nil, TKDT52DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT52DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT52DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT52DS_Test.TestBuff) - 1 do
begin
p := TKDT52DS_Test.Search(TKDT52DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT52DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT52DS_Test.TestBuff));
TKDT52DS_Test.Search(TKDT52DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT52DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT52DS_Test.Clear;
{ kMean test }
TKDT52DS_Test.BuildKDTreeWithCluster(TKDT52DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT52DS_Test.Search(TKDT52DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT52DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT52DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT52DS_Test);
DoStatus(n);
n := '';
end;
function TKDT64DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT64DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT64DS_Node;
function SortCompare(const p1, p2: PKDT64DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT64DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT64DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT64DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT64DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT64DS.GetData(const Index: NativeInt): PKDT64DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT64DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT64DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT64DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT64DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT64DS.StoreBuffPtr: PKDT64DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT64DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT64DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT64DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT64DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT64DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT64DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT64DS.BuildKDTreeWithCluster(const inBuff: TKDT64DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT64DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT64DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT64DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT64DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT64DS.BuildKDTreeWithCluster(const inBuff: TKDT64DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT64DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT64DS_BuildCall);
var
TempStoreBuff: TKDT64DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT64DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT64DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT64DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT64DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT64DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT64DS_BuildMethod);
var
TempStoreBuff: TKDT64DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT64DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT64DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT64DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT64DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT64DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT64DS_BuildProc);
var
TempStoreBuff: TKDT64DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT64DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT64DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT64DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT64DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT64DS.Search(const buff: TKDT64DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT64DS_Node;
var
NearestNeighbour: PKDT64DS_Node;
function FindParentNode(const buffPtr: PKDT64DS_Vec; NodePtr: PKDT64DS_Node): PKDT64DS_Node;
var
Next: PKDT64DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT64DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT64DS_Node; const buffPtr: PKDT64DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT64DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT64DS_Vec; const p1, p2: PKDT64DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT64DS_Vec);
var
i, j: NativeInt;
p, t: PKDT64DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT64DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT64DS_Node(NearestNodes[0]);
end;
end;
function TKDT64DS.Search(const buff: TKDT64DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT64DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT64DS.Search(const buff: TKDT64DS_Vec; var SearchedDistanceMin: Double): PKDT64DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT64DS.Search(const buff: TKDT64DS_Vec): PKDT64DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT64DS.SearchToken(const buff: TKDT64DS_Vec): TPascalString;
var
p: PKDT64DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT64DS.Search(const inBuff: TKDT64DS_DynamicVecBuffer; var OutBuff: TKDT64DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT64DS_DynamicVecBuffer;
outBuffPtr: PKDT64DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT64DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT64DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT64DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT64DS.Search(const inBuff: TKDT64DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT64DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT64DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT64DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT64DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT64DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT64DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT64DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT64DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT64DS_Vec)) <> SizeOf(TKDT64DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT64DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT64DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT64DS.PrintNodeTree(const NodePtr: PKDT64DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT64DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT64DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT64DS.Vec(const s: SystemString): TKDT64DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT64DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT64DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT64DS.Vec(const v: TKDT64DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT64DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT64DS.Distance(const v1, v2: TKDT64DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT64DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT64DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT64DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT64DS.Test;
var
TKDT64DS_Test: TKDT64DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT64DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT64DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT64DS_Test := TKDT64DS.Create;
n.Append('...');
SetLength(TKDT64DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT64DS_Test.TestBuff) - 1 do
for j := 0 to KDT64DS_Axis - 1 do
TKDT64DS_Test.TestBuff[i][j] := i * KDT64DS_Axis + j;
{$IFDEF FPC}
TKDT64DS_Test.BuildKDTreeM(length(TKDT64DS_Test.TestBuff), nil, @TKDT64DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT64DS_Test.BuildKDTreeM(length(TKDT64DS_Test.TestBuff), nil, TKDT64DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT64DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT64DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT64DS_Test.TestBuff) - 1 do
begin
p := TKDT64DS_Test.Search(TKDT64DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT64DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT64DS_Test.TestBuff));
TKDT64DS_Test.Search(TKDT64DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT64DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT64DS_Test.Clear;
{ kMean test }
TKDT64DS_Test.BuildKDTreeWithCluster(TKDT64DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT64DS_Test.Search(TKDT64DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT64DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT64DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT64DS_Test);
DoStatus(n);
n := '';
end;
function TKDT96DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT96DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT96DS_Node;
function SortCompare(const p1, p2: PKDT96DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT96DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT96DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT96DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT96DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT96DS.GetData(const Index: NativeInt): PKDT96DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT96DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT96DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT96DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT96DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT96DS.StoreBuffPtr: PKDT96DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT96DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT96DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT96DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT96DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT96DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT96DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT96DS.BuildKDTreeWithCluster(const inBuff: TKDT96DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT96DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT96DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT96DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT96DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT96DS.BuildKDTreeWithCluster(const inBuff: TKDT96DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT96DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT96DS_BuildCall);
var
TempStoreBuff: TKDT96DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT96DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT96DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT96DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT96DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT96DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT96DS_BuildMethod);
var
TempStoreBuff: TKDT96DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT96DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT96DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT96DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT96DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT96DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT96DS_BuildProc);
var
TempStoreBuff: TKDT96DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT96DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT96DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT96DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT96DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT96DS.Search(const buff: TKDT96DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT96DS_Node;
var
NearestNeighbour: PKDT96DS_Node;
function FindParentNode(const buffPtr: PKDT96DS_Vec; NodePtr: PKDT96DS_Node): PKDT96DS_Node;
var
Next: PKDT96DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT96DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT96DS_Node; const buffPtr: PKDT96DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT96DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT96DS_Vec; const p1, p2: PKDT96DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT96DS_Vec);
var
i, j: NativeInt;
p, t: PKDT96DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT96DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT96DS_Node(NearestNodes[0]);
end;
end;
function TKDT96DS.Search(const buff: TKDT96DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT96DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT96DS.Search(const buff: TKDT96DS_Vec; var SearchedDistanceMin: Double): PKDT96DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT96DS.Search(const buff: TKDT96DS_Vec): PKDT96DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT96DS.SearchToken(const buff: TKDT96DS_Vec): TPascalString;
var
p: PKDT96DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT96DS.Search(const inBuff: TKDT96DS_DynamicVecBuffer; var OutBuff: TKDT96DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT96DS_DynamicVecBuffer;
outBuffPtr: PKDT96DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT96DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT96DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT96DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT96DS.Search(const inBuff: TKDT96DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT96DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT96DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT96DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT96DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT96DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT96DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT96DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT96DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT96DS_Vec)) <> SizeOf(TKDT96DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT96DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT96DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT96DS.PrintNodeTree(const NodePtr: PKDT96DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT96DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT96DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT96DS.Vec(const s: SystemString): TKDT96DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT96DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT96DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT96DS.Vec(const v: TKDT96DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT96DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT96DS.Distance(const v1, v2: TKDT96DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT96DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT96DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT96DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT96DS.Test;
var
TKDT96DS_Test: TKDT96DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT96DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT96DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT96DS_Test := TKDT96DS.Create;
n.Append('...');
SetLength(TKDT96DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT96DS_Test.TestBuff) - 1 do
for j := 0 to KDT96DS_Axis - 1 do
TKDT96DS_Test.TestBuff[i][j] := i * KDT96DS_Axis + j;
{$IFDEF FPC}
TKDT96DS_Test.BuildKDTreeM(length(TKDT96DS_Test.TestBuff), nil, @TKDT96DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT96DS_Test.BuildKDTreeM(length(TKDT96DS_Test.TestBuff), nil, TKDT96DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT96DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT96DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT96DS_Test.TestBuff) - 1 do
begin
p := TKDT96DS_Test.Search(TKDT96DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT96DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT96DS_Test.TestBuff));
TKDT96DS_Test.Search(TKDT96DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT96DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT96DS_Test.Clear;
{ kMean test }
TKDT96DS_Test.BuildKDTreeWithCluster(TKDT96DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT96DS_Test.Search(TKDT96DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT96DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT96DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT96DS_Test);
DoStatus(n);
n := '';
end;
function TKDT128DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT128DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT128DS_Node;
function SortCompare(const p1, p2: PKDT128DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT128DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT128DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT128DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT128DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT128DS.GetData(const Index: NativeInt): PKDT128DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT128DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT128DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT128DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT128DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT128DS.StoreBuffPtr: PKDT128DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT128DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT128DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT128DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT128DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT128DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT128DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT128DS.BuildKDTreeWithCluster(const inBuff: TKDT128DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT128DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT128DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT128DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT128DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT128DS.BuildKDTreeWithCluster(const inBuff: TKDT128DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT128DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT128DS_BuildCall);
var
TempStoreBuff: TKDT128DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT128DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT128DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT128DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT128DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT128DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT128DS_BuildMethod);
var
TempStoreBuff: TKDT128DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT128DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT128DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT128DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT128DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT128DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT128DS_BuildProc);
var
TempStoreBuff: TKDT128DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT128DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT128DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT128DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT128DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT128DS.Search(const buff: TKDT128DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT128DS_Node;
var
NearestNeighbour: PKDT128DS_Node;
function FindParentNode(const buffPtr: PKDT128DS_Vec; NodePtr: PKDT128DS_Node): PKDT128DS_Node;
var
Next: PKDT128DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT128DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT128DS_Node; const buffPtr: PKDT128DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT128DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT128DS_Vec; const p1, p2: PKDT128DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT128DS_Vec);
var
i, j: NativeInt;
p, t: PKDT128DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT128DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT128DS_Node(NearestNodes[0]);
end;
end;
function TKDT128DS.Search(const buff: TKDT128DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT128DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT128DS.Search(const buff: TKDT128DS_Vec; var SearchedDistanceMin: Double): PKDT128DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT128DS.Search(const buff: TKDT128DS_Vec): PKDT128DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT128DS.SearchToken(const buff: TKDT128DS_Vec): TPascalString;
var
p: PKDT128DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT128DS.Search(const inBuff: TKDT128DS_DynamicVecBuffer; var OutBuff: TKDT128DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT128DS_DynamicVecBuffer;
outBuffPtr: PKDT128DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT128DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT128DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT128DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT128DS.Search(const inBuff: TKDT128DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT128DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT128DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT128DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT128DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT128DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT128DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT128DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT128DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT128DS_Vec)) <> SizeOf(TKDT128DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT128DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT128DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT128DS.PrintNodeTree(const NodePtr: PKDT128DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT128DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT128DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT128DS.Vec(const s: SystemString): TKDT128DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT128DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT128DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT128DS.Vec(const v: TKDT128DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT128DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT128DS.Distance(const v1, v2: TKDT128DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT128DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT128DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT128DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT128DS.Test;
var
TKDT128DS_Test: TKDT128DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT128DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT128DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT128DS_Test := TKDT128DS.Create;
n.Append('...');
SetLength(TKDT128DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT128DS_Test.TestBuff) - 1 do
for j := 0 to KDT128DS_Axis - 1 do
TKDT128DS_Test.TestBuff[i][j] := i * KDT128DS_Axis + j;
{$IFDEF FPC}
TKDT128DS_Test.BuildKDTreeM(length(TKDT128DS_Test.TestBuff), nil, @TKDT128DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT128DS_Test.BuildKDTreeM(length(TKDT128DS_Test.TestBuff), nil, TKDT128DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT128DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT128DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT128DS_Test.TestBuff) - 1 do
begin
p := TKDT128DS_Test.Search(TKDT128DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT128DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT128DS_Test.TestBuff));
TKDT128DS_Test.Search(TKDT128DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT128DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT128DS_Test.Clear;
{ kMean test }
TKDT128DS_Test.BuildKDTreeWithCluster(TKDT128DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT128DS_Test.Search(TKDT128DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT128DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT128DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT128DS_Test);
DoStatus(n);
n := '';
end;
function TKDT156DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT156DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT156DS_Node;
function SortCompare(const p1, p2: PKDT156DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT156DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT156DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT156DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT156DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT156DS.GetData(const Index: NativeInt): PKDT156DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT156DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT156DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT156DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT156DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT156DS.StoreBuffPtr: PKDT156DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT156DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT156DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT156DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT156DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT156DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT156DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT156DS.BuildKDTreeWithCluster(const inBuff: TKDT156DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT156DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT156DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT156DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT156DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT156DS.BuildKDTreeWithCluster(const inBuff: TKDT156DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT156DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT156DS_BuildCall);
var
TempStoreBuff: TKDT156DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT156DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT156DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT156DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT156DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT156DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT156DS_BuildMethod);
var
TempStoreBuff: TKDT156DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT156DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT156DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT156DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT156DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT156DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT156DS_BuildProc);
var
TempStoreBuff: TKDT156DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT156DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT156DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT156DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT156DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT156DS.Search(const buff: TKDT156DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT156DS_Node;
var
NearestNeighbour: PKDT156DS_Node;
function FindParentNode(const buffPtr: PKDT156DS_Vec; NodePtr: PKDT156DS_Node): PKDT156DS_Node;
var
Next: PKDT156DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT156DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT156DS_Node; const buffPtr: PKDT156DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT156DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT156DS_Vec; const p1, p2: PKDT156DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT156DS_Vec);
var
i, j: NativeInt;
p, t: PKDT156DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT156DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT156DS_Node(NearestNodes[0]);
end;
end;
function TKDT156DS.Search(const buff: TKDT156DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT156DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT156DS.Search(const buff: TKDT156DS_Vec; var SearchedDistanceMin: Double): PKDT156DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT156DS.Search(const buff: TKDT156DS_Vec): PKDT156DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT156DS.SearchToken(const buff: TKDT156DS_Vec): TPascalString;
var
p: PKDT156DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT156DS.Search(const inBuff: TKDT156DS_DynamicVecBuffer; var OutBuff: TKDT156DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT156DS_DynamicVecBuffer;
outBuffPtr: PKDT156DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT156DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT156DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT156DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT156DS.Search(const inBuff: TKDT156DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT156DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT156DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT156DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT156DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT156DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT156DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT156DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT156DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT156DS_Vec)) <> SizeOf(TKDT156DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT156DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT156DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT156DS.PrintNodeTree(const NodePtr: PKDT156DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT156DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT156DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT156DS.Vec(const s: SystemString): TKDT156DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT156DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT156DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT156DS.Vec(const v: TKDT156DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT156DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT156DS.Distance(const v1, v2: TKDT156DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT156DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT156DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT156DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT156DS.Test;
var
TKDT156DS_Test: TKDT156DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT156DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT156DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT156DS_Test := TKDT156DS.Create;
n.Append('...');
SetLength(TKDT156DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT156DS_Test.TestBuff) - 1 do
for j := 0 to KDT156DS_Axis - 1 do
TKDT156DS_Test.TestBuff[i][j] := i * KDT156DS_Axis + j;
{$IFDEF FPC}
TKDT156DS_Test.BuildKDTreeM(length(TKDT156DS_Test.TestBuff), nil, @TKDT156DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT156DS_Test.BuildKDTreeM(length(TKDT156DS_Test.TestBuff), nil, TKDT156DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT156DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT156DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT156DS_Test.TestBuff) - 1 do
begin
p := TKDT156DS_Test.Search(TKDT156DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT156DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT156DS_Test.TestBuff));
TKDT156DS_Test.Search(TKDT156DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT156DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT156DS_Test.Clear;
{ kMean test }
TKDT156DS_Test.BuildKDTreeWithCluster(TKDT156DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT156DS_Test.Search(TKDT156DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT156DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT156DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT156DS_Test);
DoStatus(n);
n := '';
end;
function TKDT192DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT192DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT192DS_Node;
function SortCompare(const p1, p2: PKDT192DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT192DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT192DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT192DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT192DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT192DS.GetData(const Index: NativeInt): PKDT192DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT192DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT192DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT192DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT192DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT192DS.StoreBuffPtr: PKDT192DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT192DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT192DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT192DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT192DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT192DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT192DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT192DS.BuildKDTreeWithCluster(const inBuff: TKDT192DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT192DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT192DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT192DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT192DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT192DS.BuildKDTreeWithCluster(const inBuff: TKDT192DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT192DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT192DS_BuildCall);
var
TempStoreBuff: TKDT192DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT192DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT192DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT192DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT192DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT192DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT192DS_BuildMethod);
var
TempStoreBuff: TKDT192DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT192DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT192DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT192DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT192DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT192DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT192DS_BuildProc);
var
TempStoreBuff: TKDT192DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT192DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT192DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT192DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT192DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT192DS.Search(const buff: TKDT192DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT192DS_Node;
var
NearestNeighbour: PKDT192DS_Node;
function FindParentNode(const buffPtr: PKDT192DS_Vec; NodePtr: PKDT192DS_Node): PKDT192DS_Node;
var
Next: PKDT192DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT192DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT192DS_Node; const buffPtr: PKDT192DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT192DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT192DS_Vec; const p1, p2: PKDT192DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT192DS_Vec);
var
i, j: NativeInt;
p, t: PKDT192DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT192DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT192DS_Node(NearestNodes[0]);
end;
end;
function TKDT192DS.Search(const buff: TKDT192DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT192DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT192DS.Search(const buff: TKDT192DS_Vec; var SearchedDistanceMin: Double): PKDT192DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT192DS.Search(const buff: TKDT192DS_Vec): PKDT192DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT192DS.SearchToken(const buff: TKDT192DS_Vec): TPascalString;
var
p: PKDT192DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT192DS.Search(const inBuff: TKDT192DS_DynamicVecBuffer; var OutBuff: TKDT192DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT192DS_DynamicVecBuffer;
outBuffPtr: PKDT192DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT192DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT192DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT192DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT192DS.Search(const inBuff: TKDT192DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT192DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT192DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT192DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT192DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT192DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT192DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT192DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT192DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT192DS_Vec)) <> SizeOf(TKDT192DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT192DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT192DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT192DS.PrintNodeTree(const NodePtr: PKDT192DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT192DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT192DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT192DS.Vec(const s: SystemString): TKDT192DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT192DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT192DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT192DS.Vec(const v: TKDT192DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT192DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT192DS.Distance(const v1, v2: TKDT192DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT192DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT192DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT192DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT192DS.Test;
var
TKDT192DS_Test: TKDT192DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT192DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT192DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT192DS_Test := TKDT192DS.Create;
n.Append('...');
SetLength(TKDT192DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT192DS_Test.TestBuff) - 1 do
for j := 0 to KDT192DS_Axis - 1 do
TKDT192DS_Test.TestBuff[i][j] := i * KDT192DS_Axis + j;
{$IFDEF FPC}
TKDT192DS_Test.BuildKDTreeM(length(TKDT192DS_Test.TestBuff), nil, @TKDT192DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT192DS_Test.BuildKDTreeM(length(TKDT192DS_Test.TestBuff), nil, TKDT192DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT192DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT192DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT192DS_Test.TestBuff) - 1 do
begin
p := TKDT192DS_Test.Search(TKDT192DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT192DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT192DS_Test.TestBuff));
TKDT192DS_Test.Search(TKDT192DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT192DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT192DS_Test.Clear;
{ kMean test }
TKDT192DS_Test.BuildKDTreeWithCluster(TKDT192DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT192DS_Test.Search(TKDT192DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT192DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT192DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT192DS_Test);
DoStatus(n);
n := '';
end;
function TKDT256DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT256DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT256DS_Node;
function SortCompare(const p1, p2: PKDT256DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT256DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT256DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT256DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT256DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT256DS.GetData(const Index: NativeInt): PKDT256DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT256DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT256DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT256DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT256DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT256DS.StoreBuffPtr: PKDT256DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT256DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT256DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT256DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT256DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT256DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT256DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT256DS.BuildKDTreeWithCluster(const inBuff: TKDT256DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT256DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT256DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT256DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT256DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT256DS.BuildKDTreeWithCluster(const inBuff: TKDT256DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT256DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT256DS_BuildCall);
var
TempStoreBuff: TKDT256DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT256DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT256DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT256DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT256DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT256DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT256DS_BuildMethod);
var
TempStoreBuff: TKDT256DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT256DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT256DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT256DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT256DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT256DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT256DS_BuildProc);
var
TempStoreBuff: TKDT256DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT256DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT256DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT256DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT256DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT256DS.Search(const buff: TKDT256DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT256DS_Node;
var
NearestNeighbour: PKDT256DS_Node;
function FindParentNode(const buffPtr: PKDT256DS_Vec; NodePtr: PKDT256DS_Node): PKDT256DS_Node;
var
Next: PKDT256DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT256DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT256DS_Node; const buffPtr: PKDT256DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT256DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT256DS_Vec; const p1, p2: PKDT256DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT256DS_Vec);
var
i, j: NativeInt;
p, t: PKDT256DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT256DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT256DS_Node(NearestNodes[0]);
end;
end;
function TKDT256DS.Search(const buff: TKDT256DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT256DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT256DS.Search(const buff: TKDT256DS_Vec; var SearchedDistanceMin: Double): PKDT256DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT256DS.Search(const buff: TKDT256DS_Vec): PKDT256DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT256DS.SearchToken(const buff: TKDT256DS_Vec): TPascalString;
var
p: PKDT256DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT256DS.Search(const inBuff: TKDT256DS_DynamicVecBuffer; var OutBuff: TKDT256DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT256DS_DynamicVecBuffer;
outBuffPtr: PKDT256DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT256DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT256DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT256DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT256DS.Search(const inBuff: TKDT256DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT256DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT256DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT256DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT256DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT256DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT256DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT256DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT256DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT256DS_Vec)) <> SizeOf(TKDT256DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT256DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT256DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT256DS.PrintNodeTree(const NodePtr: PKDT256DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT256DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT256DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT256DS.Vec(const s: SystemString): TKDT256DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT256DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT256DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT256DS.Vec(const v: TKDT256DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT256DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT256DS.Distance(const v1, v2: TKDT256DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT256DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT256DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT256DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT256DS.Test;
var
TKDT256DS_Test: TKDT256DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT256DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT256DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT256DS_Test := TKDT256DS.Create;
n.Append('...');
SetLength(TKDT256DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT256DS_Test.TestBuff) - 1 do
for j := 0 to KDT256DS_Axis - 1 do
TKDT256DS_Test.TestBuff[i][j] := i * KDT256DS_Axis + j;
{$IFDEF FPC}
TKDT256DS_Test.BuildKDTreeM(length(TKDT256DS_Test.TestBuff), nil, @TKDT256DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT256DS_Test.BuildKDTreeM(length(TKDT256DS_Test.TestBuff), nil, TKDT256DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT256DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT256DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT256DS_Test.TestBuff) - 1 do
begin
p := TKDT256DS_Test.Search(TKDT256DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT256DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT256DS_Test.TestBuff));
TKDT256DS_Test.Search(TKDT256DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT256DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT256DS_Test.Clear;
{ kMean test }
TKDT256DS_Test.BuildKDTreeWithCluster(TKDT256DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT256DS_Test.Search(TKDT256DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT256DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT256DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT256DS_Test);
DoStatus(n);
n := '';
end;
function TKDT384DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT384DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT384DS_Node;
function SortCompare(const p1, p2: PKDT384DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT384DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT384DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT384DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT384DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT384DS.GetData(const Index: NativeInt): PKDT384DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT384DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT384DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT384DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT384DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT384DS.StoreBuffPtr: PKDT384DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT384DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT384DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT384DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT384DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT384DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT384DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT384DS.BuildKDTreeWithCluster(const inBuff: TKDT384DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT384DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT384DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT384DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT384DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT384DS.BuildKDTreeWithCluster(const inBuff: TKDT384DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT384DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT384DS_BuildCall);
var
TempStoreBuff: TKDT384DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT384DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT384DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT384DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT384DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT384DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT384DS_BuildMethod);
var
TempStoreBuff: TKDT384DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT384DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT384DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT384DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT384DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT384DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT384DS_BuildProc);
var
TempStoreBuff: TKDT384DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT384DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT384DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT384DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT384DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT384DS.Search(const buff: TKDT384DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT384DS_Node;
var
NearestNeighbour: PKDT384DS_Node;
function FindParentNode(const buffPtr: PKDT384DS_Vec; NodePtr: PKDT384DS_Node): PKDT384DS_Node;
var
Next: PKDT384DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT384DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT384DS_Node; const buffPtr: PKDT384DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT384DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT384DS_Vec; const p1, p2: PKDT384DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT384DS_Vec);
var
i, j: NativeInt;
p, t: PKDT384DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT384DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT384DS_Node(NearestNodes[0]);
end;
end;
function TKDT384DS.Search(const buff: TKDT384DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT384DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT384DS.Search(const buff: TKDT384DS_Vec; var SearchedDistanceMin: Double): PKDT384DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT384DS.Search(const buff: TKDT384DS_Vec): PKDT384DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT384DS.SearchToken(const buff: TKDT384DS_Vec): TPascalString;
var
p: PKDT384DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT384DS.Search(const inBuff: TKDT384DS_DynamicVecBuffer; var OutBuff: TKDT384DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT384DS_DynamicVecBuffer;
outBuffPtr: PKDT384DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT384DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT384DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT384DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT384DS.Search(const inBuff: TKDT384DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT384DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT384DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT384DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT384DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT384DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT384DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT384DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT384DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT384DS_Vec)) <> SizeOf(TKDT384DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT384DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT384DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT384DS.PrintNodeTree(const NodePtr: PKDT384DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT384DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT384DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT384DS.Vec(const s: SystemString): TKDT384DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT384DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT384DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT384DS.Vec(const v: TKDT384DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT384DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT384DS.Distance(const v1, v2: TKDT384DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT384DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT384DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT384DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT384DS.Test;
var
TKDT384DS_Test: TKDT384DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT384DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT384DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT384DS_Test := TKDT384DS.Create;
n.Append('...');
SetLength(TKDT384DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT384DS_Test.TestBuff) - 1 do
for j := 0 to KDT384DS_Axis - 1 do
TKDT384DS_Test.TestBuff[i][j] := i * KDT384DS_Axis + j;
{$IFDEF FPC}
TKDT384DS_Test.BuildKDTreeM(length(TKDT384DS_Test.TestBuff), nil, @TKDT384DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT384DS_Test.BuildKDTreeM(length(TKDT384DS_Test.TestBuff), nil, TKDT384DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT384DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT384DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT384DS_Test.TestBuff) - 1 do
begin
p := TKDT384DS_Test.Search(TKDT384DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT384DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT384DS_Test.TestBuff));
TKDT384DS_Test.Search(TKDT384DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT384DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT384DS_Test.Clear;
{ kMean test }
TKDT384DS_Test.BuildKDTreeWithCluster(TKDT384DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT384DS_Test.Search(TKDT384DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT384DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT384DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT384DS_Test);
DoStatus(n);
n := '';
end;
function TKDT512DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT512DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT512DS_Node;
function SortCompare(const p1, p2: PKDT512DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT512DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT512DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT512DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT512DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT512DS.GetData(const Index: NativeInt): PKDT512DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT512DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT512DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT512DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT512DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT512DS.StoreBuffPtr: PKDT512DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT512DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT512DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT512DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT512DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT512DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT512DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT512DS.BuildKDTreeWithCluster(const inBuff: TKDT512DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT512DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT512DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT512DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT512DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT512DS.BuildKDTreeWithCluster(const inBuff: TKDT512DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT512DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT512DS_BuildCall);
var
TempStoreBuff: TKDT512DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT512DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT512DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT512DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT512DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT512DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT512DS_BuildMethod);
var
TempStoreBuff: TKDT512DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT512DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT512DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT512DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT512DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT512DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT512DS_BuildProc);
var
TempStoreBuff: TKDT512DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT512DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT512DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT512DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT512DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT512DS.Search(const buff: TKDT512DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT512DS_Node;
var
NearestNeighbour: PKDT512DS_Node;
function FindParentNode(const buffPtr: PKDT512DS_Vec; NodePtr: PKDT512DS_Node): PKDT512DS_Node;
var
Next: PKDT512DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT512DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT512DS_Node; const buffPtr: PKDT512DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT512DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT512DS_Vec; const p1, p2: PKDT512DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT512DS_Vec);
var
i, j: NativeInt;
p, t: PKDT512DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT512DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT512DS_Node(NearestNodes[0]);
end;
end;
function TKDT512DS.Search(const buff: TKDT512DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT512DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT512DS.Search(const buff: TKDT512DS_Vec; var SearchedDistanceMin: Double): PKDT512DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT512DS.Search(const buff: TKDT512DS_Vec): PKDT512DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT512DS.SearchToken(const buff: TKDT512DS_Vec): TPascalString;
var
p: PKDT512DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT512DS.Search(const inBuff: TKDT512DS_DynamicVecBuffer; var OutBuff: TKDT512DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT512DS_DynamicVecBuffer;
outBuffPtr: PKDT512DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT512DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT512DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT512DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT512DS.Search(const inBuff: TKDT512DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT512DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT512DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT512DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT512DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT512DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT512DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT512DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT512DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT512DS_Vec)) <> SizeOf(TKDT512DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT512DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT512DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT512DS.PrintNodeTree(const NodePtr: PKDT512DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT512DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT512DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT512DS.Vec(const s: SystemString): TKDT512DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT512DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT512DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT512DS.Vec(const v: TKDT512DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT512DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT512DS.Distance(const v1, v2: TKDT512DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT512DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT512DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT512DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT512DS.Test;
var
TKDT512DS_Test: TKDT512DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT512DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT512DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT512DS_Test := TKDT512DS.Create;
n.Append('...');
SetLength(TKDT512DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT512DS_Test.TestBuff) - 1 do
for j := 0 to KDT512DS_Axis - 1 do
TKDT512DS_Test.TestBuff[i][j] := i * KDT512DS_Axis + j;
{$IFDEF FPC}
TKDT512DS_Test.BuildKDTreeM(length(TKDT512DS_Test.TestBuff), nil, @TKDT512DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT512DS_Test.BuildKDTreeM(length(TKDT512DS_Test.TestBuff), nil, TKDT512DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT512DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT512DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT512DS_Test.TestBuff) - 1 do
begin
p := TKDT512DS_Test.Search(TKDT512DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT512DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT512DS_Test.TestBuff));
TKDT512DS_Test.Search(TKDT512DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT512DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT512DS_Test.Clear;
{ kMean test }
TKDT512DS_Test.BuildKDTreeWithCluster(TKDT512DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT512DS_Test.Search(TKDT512DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT512DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT512DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT512DS_Test);
DoStatus(n);
n := '';
end;
function TKDT800DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT800DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT800DS_Node;
function SortCompare(const p1, p2: PKDT800DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT800DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT800DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT800DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT800DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT800DS.GetData(const Index: NativeInt): PKDT800DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT800DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT800DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT800DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT800DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT800DS.StoreBuffPtr: PKDT800DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT800DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT800DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT800DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT800DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT800DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT800DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT800DS.BuildKDTreeWithCluster(const inBuff: TKDT800DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT800DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT800DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT800DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT800DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT800DS.BuildKDTreeWithCluster(const inBuff: TKDT800DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT800DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT800DS_BuildCall);
var
TempStoreBuff: TKDT800DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT800DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT800DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT800DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT800DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT800DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT800DS_BuildMethod);
var
TempStoreBuff: TKDT800DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT800DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT800DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT800DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT800DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT800DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT800DS_BuildProc);
var
TempStoreBuff: TKDT800DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT800DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT800DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT800DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT800DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT800DS.Search(const buff: TKDT800DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT800DS_Node;
var
NearestNeighbour: PKDT800DS_Node;
function FindParentNode(const buffPtr: PKDT800DS_Vec; NodePtr: PKDT800DS_Node): PKDT800DS_Node;
var
Next: PKDT800DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT800DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT800DS_Node; const buffPtr: PKDT800DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT800DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT800DS_Vec; const p1, p2: PKDT800DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT800DS_Vec);
var
i, j: NativeInt;
p, t: PKDT800DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT800DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT800DS_Node(NearestNodes[0]);
end;
end;
function TKDT800DS.Search(const buff: TKDT800DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT800DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT800DS.Search(const buff: TKDT800DS_Vec; var SearchedDistanceMin: Double): PKDT800DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT800DS.Search(const buff: TKDT800DS_Vec): PKDT800DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT800DS.SearchToken(const buff: TKDT800DS_Vec): TPascalString;
var
p: PKDT800DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT800DS.Search(const inBuff: TKDT800DS_DynamicVecBuffer; var OutBuff: TKDT800DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT800DS_DynamicVecBuffer;
outBuffPtr: PKDT800DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT800DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT800DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT800DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT800DS.Search(const inBuff: TKDT800DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT800DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT800DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT800DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT800DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT800DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT800DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT800DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT800DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT800DS_Vec)) <> SizeOf(TKDT800DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT800DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT800DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT800DS.PrintNodeTree(const NodePtr: PKDT800DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT800DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT800DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT800DS.Vec(const s: SystemString): TKDT800DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT800DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT800DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT800DS.Vec(const v: TKDT800DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT800DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT800DS.Distance(const v1, v2: TKDT800DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT800DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT800DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT800DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT800DS.Test;
var
TKDT800DS_Test: TKDT800DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT800DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT800DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT800DS_Test := TKDT800DS.Create;
n.Append('...');
SetLength(TKDT800DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT800DS_Test.TestBuff) - 1 do
for j := 0 to KDT800DS_Axis - 1 do
TKDT800DS_Test.TestBuff[i][j] := i * KDT800DS_Axis + j;
{$IFDEF FPC}
TKDT800DS_Test.BuildKDTreeM(length(TKDT800DS_Test.TestBuff), nil, @TKDT800DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT800DS_Test.BuildKDTreeM(length(TKDT800DS_Test.TestBuff), nil, TKDT800DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT800DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT800DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT800DS_Test.TestBuff) - 1 do
begin
p := TKDT800DS_Test.Search(TKDT800DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT800DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT800DS_Test.TestBuff));
TKDT800DS_Test.Search(TKDT800DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT800DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT800DS_Test.Clear;
{ kMean test }
TKDT800DS_Test.BuildKDTreeWithCluster(TKDT800DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT800DS_Test.Search(TKDT800DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT800DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT800DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT800DS_Test);
DoStatus(n);
n := '';
end;
function TKDT1024DS.InternalBuildKdTree(const KDSourceBufferPtr: PKDT1024DS_SourceBuffer; const PlanCount, Depth: NativeInt): PKDT1024DS_Node;
function SortCompare(const p1, p2: PKDT1024DS_Source; const axis: NativeInt): ShortInt;
begin
if p1^.buff[axis] = p2^.buff[axis] then
begin
if p1^.Index = p2^.Index then
Result := 0
else if p1^.Index < p2^.Index then
Result := -1
else
Result := 1;
end
else if p1^.buff[axis] < p2^.buff[axis] then
Result := -1
else
Result := 1;
end;
procedure InternalSort(const SortBuffer: PKDT1024DS_SourceBuffer; L, R: NativeInt; const axis: NativeInt);
var
i, j: NativeInt;
p, t: PKDT1024DS_Source;
begin
repeat
i := L;
j := R;
p := SortBuffer^[(L + R) shr 1];
repeat
while SortCompare(SortBuffer^[i], p, axis) < 0 do
Inc(i);
while SortCompare(SortBuffer^[j], p, axis) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer^[i];
SortBuffer^[i] := SortBuffer^[j];
SortBuffer^[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, axis);
L := i;
until i >= R;
end;
var
M: NativeInt;
axis: NativeInt;
kdBuffPtr: PKDT1024DS_SourceBuffer;
begin
Result := nil;
if PlanCount = 0 then
Exit;
if PlanCount = 1 then
begin
new(Result);
Result^.Parent := nil;
Result^.Right := nil;
Result^.Left := nil;
Result^.Vec := KDSourceBufferPtr^[0];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
end
else
begin
axis := Depth mod KDT1024DS_Axis;
M := PlanCount div 2;
kdBuffPtr := GetMemory(PlanCount * SizeOf(Pointer));
CopyPtr(@KDSourceBufferPtr^[0], @kdBuffPtr^[0], PlanCount * SizeOf(Pointer));
if PlanCount > 1 then
InternalSort(@kdBuffPtr^[0], 0, PlanCount - 1, axis);
new(Result);
Result^.Parent := nil;
Result^.Vec := kdBuffPtr^[M];
KDNodes[NodeCounter] := Result;
Inc(NodeCounter);
Result^.Left := InternalBuildKdTree(@kdBuffPtr^[0], M, Depth + 1);
if Result^.Left <> nil then
Result^.Left^.Parent := Result;
Result^.Right := InternalBuildKdTree(@kdBuffPtr^[M + 1], PlanCount - (M + 1), Depth + 1);
if Result^.Right <> nil then
Result^.Right^.Parent := Result;
FreeMemory(kdBuffPtr);
end;
end;
function TKDT1024DS.GetData(const Index: NativeInt): PKDT1024DS_Source;
begin
Result := @KDStoreBuff[Index];
end;
constructor TKDT1024DS.Create;
begin
inherited Create;
NodeCounter := 0;
RootNode := nil;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
Clear;
end;
destructor TKDT1024DS.Destroy;
begin
Clear;
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
inherited Destroy;
end;
procedure TKDT1024DS.Clear;
var
i: NativeInt;
begin
i := 0;
while i < length(KDNodes) do
begin
Dispose(PKDT1024DS_Node(KDNodes[i]));
Inc(i);
end;
for i := 0 to length(KDStoreBuff) - 1 do
KDStoreBuff[i].Token := '';
SetLength(KDNodes, 0);
SetLength(KDStoreBuff, 0);
SetLength(KDBuff, 0);
NodeCounter := 0;
RootNode := nil;
end;
function TKDT1024DS.StoreBuffPtr: PKDT1024DS_DyanmicStoreBuffer;
begin
Result := @KDStoreBuff;
end;
procedure TKDT1024DS.BuildKDTreeC(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildCall);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT1024DS.BuildKDTreeM(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildMethod);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
procedure TKDT1024DS.BuildKDTreeP(const PlanCount: NativeInt; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildProc);
var
i, j: NativeInt;
begin
Clear;
if PlanCount <= 0 then
Exit;
SetLength(KDStoreBuff, PlanCount);
SetLength(KDBuff, PlanCount);
SetLength(KDNodes, PlanCount);
i := 0;
while i < PlanCount do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
FillPtrByte(@KDStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec), 0);
OnTrigger(i, KDStoreBuff[i], Data);
Inc(i);
end;
j := PlanCount;
RootNode := InternalBuildKdTree(@KDBuff[0], j, 0);
end;
{ k-means++ clusterization }
procedure TKDT1024DS.BuildKDTreeWithCluster(const inBuff: TKDT1024DS_DynamicVecBuffer; const k, Restarts: NativeInt; var OutIndex: TKMIntegerArray);
var
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
SetLength(Source, length(inBuff), KDT1024DS_Axis);
for i := 0 to length(inBuff) - 1 do
for j := 0 to KDT1024DS_Axis - 1 do
Source[i, j] := inBuff[i, j];
if KMeansCluster(Source, KDT1024DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1024DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
SetLength(KArray, 0);
end;
SetLength(Source, 0);
end;
procedure TKDT1024DS.BuildKDTreeWithCluster(const inBuff: TKDT1024DS_DynamicVecBuffer; const k, Restarts: NativeInt);
var
OutIndex: TKMIntegerArray;
begin
BuildKDTreeWithCluster(inBuff, k, Restarts, OutIndex);
SetLength(OutIndex, 0);
end;
procedure TKDT1024DS.BuildKDTreeWithClusterC(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildCall);
var
TempStoreBuff: TKDT1024DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT1024DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT1024DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT1024DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1024DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT1024DS.BuildKDTreeWithClusterM(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildMethod);
var
TempStoreBuff: TKDT1024DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT1024DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT1024DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT1024DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1024DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
procedure TKDT1024DS.BuildKDTreeWithClusterP(const PlanCount, k, Restarts: NativeInt; var OutIndex: TKMIntegerArray; const Data: Pointer; const OnTrigger: TKDT1024DS_BuildProc);
var
TempStoreBuff: TKDT1024DS_DyanmicStoreBuffer;
Source: TKMFloat2DArray;
KArray: TKMFloat2DArray;
i, j: NativeInt;
begin
Clear;
SetLength(TempStoreBuff, PlanCount);
i := 0;
while i < PlanCount do
begin
TempStoreBuff[i].Index := i;
TempStoreBuff[i].Token := '';
FillPtrByte(@TempStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec), 0);
OnTrigger(i, TempStoreBuff[i], Data);
Inc(i);
end;
SetLength(Source, length(TempStoreBuff), KDT1024DS_Axis);
for i := 0 to length(TempStoreBuff) - 1 do
for j := 0 to KDT1024DS_Axis - 1 do
Source[i, j] := TempStoreBuff[i].buff[j];
if KMeansCluster(Source, KDT1024DS_Axis, k, umlMax(Restarts, 1), KArray, OutIndex) = 1 then
begin
SetLength(KDStoreBuff, k);
SetLength(KDBuff, k);
SetLength(KDNodes, k);
for i := 0 to k - 1 do
begin
KDBuff[i] := @KDStoreBuff[i];
KDStoreBuff[i].Index := i;
KDStoreBuff[i].Token := '';
for j := 0 to KDT1024DS_Axis - 1 do
KDStoreBuff[i].buff[j] := KArray[j, i];
end;
RootNode := InternalBuildKdTree(@KDBuff[0], k, 0);
for i := 0 to length(OutIndex) - 1 do
OutIndex[i] := TempStoreBuff[OutIndex[i]].Index;
SetLength(KArray, 0);
end;
SetLength(TempStoreBuff, 0);
SetLength(Source, 0);
end;
function TKDT1024DS.Search(const buff: TKDT1024DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt; const NearestNodes: TCoreClassList): PKDT1024DS_Node;
var
NearestNeighbour: PKDT1024DS_Node;
function FindParentNode(const buffPtr: PKDT1024DS_Vec; NodePtr: PKDT1024DS_Node): PKDT1024DS_Node;
var
Next: PKDT1024DS_Node;
Depth, axis: NativeInt;
begin
Result := nil;
Depth := 0;
Next := NodePtr;
while Next <> nil do
begin
Result := Next;
axis := Depth mod KDT1024DS_Axis;
if buffPtr^[axis] > Next^.Vec^.buff[axis] then
Next := Next^.Right
else
Next := Next^.Left;
Depth := Depth + 1;
end;
end;
procedure ScanSubtree(const NodePtr: PKDT1024DS_Node; const buffPtr: PKDT1024DS_Vec; const Depth: NativeInt; const NearestNodes: TCoreClassList);
var
Dist: Double;
axis: NativeInt;
begin
if NodePtr = nil then
Exit;
Inc(SearchedCounter);
if NearestNodes <> nil then
NearestNodes.Add(NodePtr);
Dist := Distance(buffPtr^, NodePtr^.Vec^.buff);
if Dist < SearchedDistanceMin then
begin
SearchedDistanceMin := Dist;
NearestNeighbour := NodePtr;
end
else if (Dist = SearchedDistanceMin) and (NodePtr^.Vec^.Index < NearestNeighbour^.Vec^.Index) then
NearestNeighbour := NodePtr;
axis := Depth mod KDT1024DS_Axis;
Dist := NodePtr^.Vec^.buff[axis] - buffPtr^[axis];
if Dist * Dist > SearchedDistanceMin then
begin
if NodePtr^.Vec^.buff[axis] > buffPtr^[axis] then
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes)
else
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end
else
begin
ScanSubtree(NodePtr^.Left, buffPtr, Depth + 1, NearestNodes);
ScanSubtree(NodePtr^.Right, buffPtr, Depth + 1, NearestNodes);
end;
end;
function SortCompare(const buffPtr: PKDT1024DS_Vec; const p1, p2: PKDT1024DS_Node): ShortInt;
var
d1, d2: Double;
begin
d1 := Distance(buffPtr^, p1^.Vec^.buff);
d2 := Distance(buffPtr^, p2^.Vec^.buff);
if d1 = d2 then
begin
if p1^.Vec^.Index = p2^.Vec^.Index then
Result := 0
else if p1^.Vec^.Index < p2^.Vec^.Index then
Result := -1
else
Result := 1;
end
else if d1 < d2 then
Result := -1
else
Result := 1;
end;
procedure InternalSort(var SortBuffer: TCoreClassPointerList; L, R: NativeInt; const buffPtr: PKDT1024DS_Vec);
var
i, j: NativeInt;
p, t: PKDT1024DS_Node;
begin
repeat
i := L;
j := R;
p := SortBuffer[(L + R) shr 1];
repeat
while SortCompare(buffPtr, SortBuffer[i], p) < 0 do
Inc(i);
while SortCompare(buffPtr, SortBuffer[j], p) > 0 do
Dec(j);
if i <= j then
begin
if i <> j then
begin
t := SortBuffer[i];
SortBuffer[i] := SortBuffer[j];
SortBuffer[j] := t;
end;
Inc(i);
Dec(j);
end;
until i > j;
if L < j then
InternalSort(SortBuffer, L, j, buffPtr);
L := i;
until i >= R;
end;
var
Parent: PKDT1024DS_Node;
begin
Result := nil;
SearchedDistanceMin := 0;
SearchedCounter := 0;
NearestNeighbour := nil;
if NearestNodes <> nil then
NearestNodes.Clear;
if RootNode = nil then
Exit;
if Count = 0 then
Exit;
Parent := FindParentNode(@buff[0], RootNode);
NearestNeighbour := Parent;
SearchedDistanceMin := Distance(buff, Parent^.Vec^.buff);
ScanSubtree(RootNode, @buff[0], 0, NearestNodes);
if NearestNeighbour = nil then
NearestNeighbour := RootNode;
Result := NearestNeighbour;
if NearestNodes <> nil then
begin
Result := NearestNeighbour;
if NearestNodes.Count > 1 then
InternalSort(NearestNodes.ListData^, 0, NearestNodes.Count - 1, @buff[0]);
if NearestNodes.Count > 0 then
Result := PKDT1024DS_Node(NearestNodes[0]);
end;
end;
function TKDT1024DS.Search(const buff: TKDT1024DS_Vec; var SearchedDistanceMin: Double; var SearchedCounter: NativeInt): PKDT1024DS_Node;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter, nil);
end;
function TKDT1024DS.Search(const buff: TKDT1024DS_Vec; var SearchedDistanceMin: Double): PKDT1024DS_Node;
var
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT1024DS.Search(const buff: TKDT1024DS_Vec): PKDT1024DS_Node;
var
SearchedDistanceMin: Double;
SearchedCounter: NativeInt;
begin
Result := Search(buff, SearchedDistanceMin, SearchedCounter);
end;
function TKDT1024DS.SearchToken(const buff: TKDT1024DS_Vec): TPascalString;
var
p: PKDT1024DS_Node;
begin
p := Search(buff);
if p <> nil then
Result := p^.Vec^.Token
else
Result := '';
end;
procedure TKDT1024DS.Search(const inBuff: TKDT1024DS_DynamicVecBuffer; var OutBuff: TKDT1024DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT1024DS_DynamicVecBuffer;
outBuffPtr: PKDT1024DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT1024DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outBuffPtr := @OutBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT1024DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outBuffPtr^[pass] := p^.Vec^.buff;
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT1024DS_Node;
begin
if length(OutBuff) <> length(OutIndex) then
Exit;
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutBuff[i] := p^.Vec^.buff;
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT1024DS.Search(const inBuff: TKDT1024DS_DynamicVecBuffer; var OutIndex: TKMIntegerArray);
{$IFDEF parallel}
var
inBuffPtr: PKDT1024DS_DynamicVecBuffer;
outIndexPtr: PKMIntegerArray;
{$IFDEF FPC}
procedure FPC_ParallelFor(pass: Integer);
var
p: PKDT1024DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end;
{$ENDIF FPC}
begin
if length(inBuff) <> length(OutIndex) then
Exit;
inBuffPtr := @inBuff;
outIndexPtr := @OutIndex;
GlobalMemoryHook.V := False;
try
{$IFDEF FPC}
FPCParallelFor(@FPC_ParallelFor, 0, length(inBuff) - 1);
{$ELSE FPC}
DelphiParallelFor(0, length(inBuff) - 1,
procedure(pass: Int64)
var
p: PKDT1024DS_Node;
begin
p := Search(inBuffPtr^[pass]);
outIndexPtr^[pass] := p^.Vec^.Index;
end);
{$ENDIF FPC}
finally
GlobalMemoryHook.V := True;
end;
end;
{$ELSE parallel}
var
i: NativeInt;
p: PKDT1024DS_Node;
begin
if length(inBuff) <> length(OutIndex) then
Exit;
for i := 0 to length(inBuff) - 1 do
begin
p := Search(inBuff[i]);
OutIndex[i] := p^.Vec^.Index;
end;
end;
{$ENDIF parallel}
procedure TKDT1024DS.SaveToStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
cnt := length(KDStoreBuff);
st := SaveToken;
ID := KDT1024DS_Axis;
stream.write(st, 4);
stream.write(ID, 4);
stream.write(cnt, 8);
i := 0;
while i < cnt do
begin
stream.write(KDStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec));
stream.write(KDStoreBuff[i].Index, 8);
token_B := KDStoreBuff[i].Token.Bytes;
token_L := length(token_B);
stream.write(token_L, 4);
if token_L > 0 then
begin
stream.write(token_B[0], token_L);
SetLength(token_B, 0);
end;
Inc(i);
end;
end;
procedure TKDT1024DS.LoadFromStream(stream: TCoreClassStream);
var
cnt: Int64;
st, ID: Integer;
i: NativeInt;
token_B: TBytes;
token_L: Integer;
begin
Clear;
stream.read(st, 4);
stream.read(ID, 4);
if st <> SaveToken then
RaiseInfo('kdtree token error!');
if ID <> KDT1024DS_Axis then
RaiseInfo('kdtree axis error!');
stream.read(cnt, 8);
SetLength(KDStoreBuff, cnt);
i := 0;
try
while i < cnt do
begin
if stream.read(KDStoreBuff[i].buff[0], SizeOf(TKDT1024DS_Vec)) <> SizeOf(TKDT1024DS_Vec) then
begin
Clear;
Exit;
end;
if stream.read(KDStoreBuff[i].Index, 8) <> 8 then
begin
Clear;
Exit;
end;
if stream.read(token_L, 4) <> 4 then
begin
Clear;
Exit;
end;
if token_L > 0 then
begin
SetLength(token_B, token_L);
if stream.read(token_B[0], token_L) <> token_L then
begin
Clear;
Exit;
end;
KDStoreBuff[i].Token.Bytes := token_B;
SetLength(token_B, 0);
end
else
KDStoreBuff[i].Token := '';
Inc(i);
end;
except
Clear;
Exit;
end;
SetLength(KDBuff, cnt);
SetLength(KDNodes, cnt);
i := 0;
while i < cnt do
begin
KDBuff[i] := @KDStoreBuff[i];
Inc(i);
end;
if cnt > 0 then
RootNode := InternalBuildKdTree(@KDBuff[0], cnt, 0);
end;
procedure TKDT1024DS.SaveToFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
fs := TCoreClassFileStream.Create(FileName, fmCreate);
try
SaveToStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT1024DS.LoadFromFile(FileName: SystemString);
var
fs: TCoreClassFileStream;
begin
try
fs := TCoreClassFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
except
Exit;
end;
try
LoadFromStream(fs);
finally
DisposeObject(fs);
end;
end;
procedure TKDT1024DS.PrintNodeTree(const NodePtr: PKDT1024DS_Node);
procedure DoPrintNode(prefix: SystemString; const p: PKDT1024DS_Node);
begin
DoStatus('%s +%d (%s) ', [prefix, p^.Vec^.Index, Vec(p^.Vec^.buff)]);
if p^.Left <> nil then
DoPrintNode(prefix + ' |-----', p^.Left);
if p^.Right <> nil then
DoPrintNode(prefix + ' |-----', p^.Right);
end;
begin
DoPrintNode('', NodePtr);
end;
procedure TKDT1024DS.PrintBuffer;
var
i: NativeInt;
begin
for i := 0 to length(KDStoreBuff) - 1 do
DoStatus('%d - %d : %s ', [i, KDStoreBuff[i].Index, Vec(KDStoreBuff[i].buff)]);
end;
class function TKDT1024DS.Vec(const s: SystemString): TKDT1024DS_Vec;
var
t: TTextParsing;
SplitOutput: TArrayPascalString;
i, j: NativeInt;
begin
for i := 0 to KDT1024DS_Axis - 1 do
Result[i] := 0;
t := TTextParsing.Create(s, tsText, nil);
if t.SplitChar(1, ', ', '', SplitOutput) > 0 then
begin
j := 0;
for i := 0 to length(SplitOutput) - 1 do
if umlGetNumTextType(SplitOutput[i]) <> ntUnknow then
begin
Result[j] := umlStrToFloat(SplitOutput[i], 0);
Inc(j);
if j >= KDT1024DS_Axis then
Break;
end;
end;
DisposeObject(t);
end;
class function TKDT1024DS.Vec(const v: TKDT1024DS_Vec): SystemString;
var
i: NativeInt;
begin
Result := '';
for i := 0 to KDT1024DS_Axis - 1 do
begin
if i > 0 then
Result := Result + ',';
Result := Result + umlFloatToStr(v[i]);
end;
end;
class function TKDT1024DS.Distance(const v1, v2: TKDT1024DS_Vec): Double;
var
i: NativeInt;
begin
Result := 0;
for i := 0 to KDT1024DS_Axis - 1 do
Result := Result + (v2[i] - v1[i]) * (v2[i] - v1[i]);
end;
procedure TKDT1024DS.Test_BuildM(const IndexFor: NativeInt; var Source: TKDT1024DS_Source; const Data: Pointer);
begin
Source.buff := TestBuff[IndexFor];
Source.Token := umlIntToStr(IndexFor);
end;
class procedure TKDT1024DS.Test;
var
TKDT1024DS_Test: TKDT1024DS;
t: TTimeTick;
i, j: NativeInt;
TestResultBuff: TKDT1024DS_DynamicVecBuffer;
TestResultIndex: TKMIntegerArray;
KMeanOutIndex: TKMIntegerArray;
errored: Boolean;
m64: TMemoryStream64;
p: PKDT1024DS_Node;
n: TPascalString;
begin
errored := False;
n := PFormat('test %s...', [ClassName]);
t := GetTimeTick;
n.Append('...build');
TKDT1024DS_Test := TKDT1024DS.Create;
n.Append('...');
SetLength(TKDT1024DS_Test.TestBuff, 1000);
for i := 0 to length(TKDT1024DS_Test.TestBuff) - 1 do
for j := 0 to KDT1024DS_Axis - 1 do
TKDT1024DS_Test.TestBuff[i][j] := i * KDT1024DS_Axis + j;
{$IFDEF FPC}
TKDT1024DS_Test.BuildKDTreeM(length(TKDT1024DS_Test.TestBuff), nil, @TKDT1024DS_Test.Test_BuildM);
{$ELSE FPC}
TKDT1024DS_Test.BuildKDTreeM(length(TKDT1024DS_Test.TestBuff), nil, TKDT1024DS_Test.Test_BuildM);
{$ENDIF FPC}
{ save/load test }
n.Append('...save/load');
m64 := TMemoryStream64.CustomCreate(1024 * 1024);
TKDT1024DS_Test.SaveToStream(m64);
m64.Position := 0;
TKDT1024DS_Test.LoadFromStream(m64);
for i := 0 to length(TKDT1024DS_Test.TestBuff) - 1 do
begin
p := TKDT1024DS_Test.Search(TKDT1024DS_Test.TestBuff[i]);
if p^.Vec^.Index <> i then
errored := True;
if not p^.Vec^.Token.Same(umlIntToStr(i)) then
errored := True;
if errored then
Break;
end;
DisposeObject(m64);
if not errored then
begin
{ parallel search test }
n.Append('...parallel');
SetLength(TestResultBuff, length(TKDT1024DS_Test.TestBuff));
SetLength(TestResultIndex, length(TKDT1024DS_Test.TestBuff));
TKDT1024DS_Test.Search(TKDT1024DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if Distance(TKDT1024DS_Test.TestBuff[TestResultIndex[i]], TestResultBuff[TestResultIndex[i]]) <> 0 then
errored := True;
end;
if not errored then
begin
n.Append('...kMean');
TKDT1024DS_Test.Clear;
{ kMean test }
TKDT1024DS_Test.BuildKDTreeWithCluster(TKDT1024DS_Test.TestBuff, 10, 1, KMeanOutIndex);
{ parallel search test }
TKDT1024DS_Test.Search(TKDT1024DS_Test.TestBuff, TestResultBuff, TestResultIndex);
for i := 0 to length(TestResultIndex) - 1 do
if TestResultIndex[i] <> KMeanOutIndex[i] then
errored := True;
end;
SetLength(TKDT1024DS_Test.TestBuff, 0);
SetLength(TestResultBuff, 0);
SetLength(TestResultIndex, 0);
SetLength(KMeanOutIndex, 0);
TKDT1024DS_Test.Clear;
n.Append('...');
if errored then
n.Append('error!')
else
n.Append('passed ok %dms', [GetTimeTick - t]);
DisposeObject(TKDT1024DS_Test);
DoStatus(n);
n := '';
end;
procedure Test_All;
begin
TKDT1DS.Test();
TKDT2DS.Test();
TKDT3DS.Test();
TKDT4DS.Test();
TKDT5DS.Test();
TKDT6DS.Test();
TKDT7DS.Test();
TKDT8DS.Test();
TKDT9DS.Test();
TKDT10DS.Test();
TKDT11DS.Test();
TKDT12DS.Test();
TKDT13DS.Test();
TKDT14DS.Test();
TKDT15DS.Test();
TKDT16DS.Test();
TKDT17DS.Test();
TKDT18DS.Test();
TKDT19DS.Test();
TKDT20DS.Test();
TKDT21DS.Test();
TKDT22DS.Test();
TKDT23DS.Test();
TKDT24DS.Test();
TKDT48DS.Test();
TKDT52DS.Test();
TKDT64DS.Test();
TKDT96DS.Test();
TKDT128DS.Test();
TKDT156DS.Test();
TKDT192DS.Test();
TKDT256DS.Test();
TKDT384DS.Test();
TKDT512DS.Test();
TKDT800DS.Test();
TKDT1024DS.Test();
end;
initialization
finalization
end.
|
{*!
* Fano Web Framework (https://fanoframework.github.io)
*
* @link https://github.com/fanoframework/fano
* @copyright Copyright (c) 2018 Zamrony P. Juhara
* @license https://github.com/fanoframework/fano/blob/master/LICENSE (MIT)
*}
unit ControllerImpl;
interface
{$MODE OBJFPC}
uses
DependencyIntf,
ResponseIntf,
RequestIntf,
RouteHandlerIntf,
RouteHandlerImpl,
MiddlewareCollectionIntf,
ViewIntf,
ViewParametersIntf;
type
(*!------------------------------------------------
* basic controller implementation class
*
* @author Zamrony P. Juhara <zamronypj@yahoo.com>
*-----------------------------------------------*)
TController = class(TRouteHandler, IDependency)
protected
gView : IView;
viewParams : IViewParameters;
public
constructor create(
const beforeMiddlewares : IMiddlewareCollection;
const afterMiddlewares : IMiddlewareCollection;
const viewInst : IView;
const viewParamsInst : IViewParameters
);
destructor destroy(); override;
function handleRequest(
const request : IRequest;
const response : IResponse
) : IResponse; override;
end;
implementation
constructor TController.create(
const beforeMiddlewares : IMiddlewareCollection;
const afterMiddlewares : IMiddlewareCollection;
const viewInst : IView;
const viewParamsInst : IViewParameters
);
begin
inherited create(beforeMiddlewares, afterMiddlewares);
gView := viewInst;
viewParams := viewParamsInst;
end;
destructor TController.destroy();
begin
inherited destroy();
gView := nil;
viewParams := nil;
end;
function TController.handleRequest(
const request : IRequest;
const response : IResponse
) : IResponse;
begin
result := gView.render(viewParams, response);
end;
end.
|
namespace RemObjects.Elements.System;
interface
uses
Foundation;
type
NSCountedSet<T> = public class mapped to Foundation.NSCountedSet
where T is class;
public
{ Class Constructors }
class method &set: id; mapped to &set;
class method setWithArray(&array: NSArray<T>): id; mapped to setWithArray(&array);
class method setWithObject(&object: T): id; mapped to setWithObject(&object);
//class method setWithObjects(firstObject: id; params param1: array of id); mapped to setWithObjects(firstObject, param1);
class method setWithObjects(objects: ^T) count(cnt: NSUInteger): id; mapped to setWithObjects(^id(objects)) count(cnt);
class method setWithSet(&set: NSSet<T>): id; mapped to setWithSet(&set);
{ Instance Methods }
{$HIDE W8}
method addObserver(observer: NSObject) forKeyPath(keyPath: NSString) options(options: NSKeyValueObservingOptions) context(var context); mapped to addObserver(observer) forKeyPath(keyPath) options(options) context(@context);
{$SHOW W8}
method containsObject(anObject: T): Boolean; mapped to containsObject(anObject);
method descriptionWithLocale(locale: id): NSString; mapped to descriptionWithLocale(locale);
method enumerateObjectsUsingBlock(&block: block(obj: T; stop: ^Boolean)); mapped to enumerateObjectsUsingBlock(NSSetEnumerateBlock(&block));
method enumerateObjectsWithOptions(opts: NSEnumerationOptions) usingBlock(&block: block(obj: T; stop: ^Boolean)); mapped to enumerateObjectsWithOptions(opts) usingBlock(NSSetEnumerateBlock(&block));
method filteredSetUsingPredicate(predicate: NSPredicate): NSSet<T>; mapped to filteredSetUsingPredicate(predicate);
method intersectsSet(otherSet: NSSet<T>): Boolean; mapped to intersectsSet(otherSet);
method isEqualToSet(otherSet: NSSet<T>): Boolean; mapped to isEqualToSet(otherSet);
method isSubsetOfSet(otherSet: NSSet<T>): Boolean; mapped to isSubsetOfSet(otherSet);
method makeObjectsPerformSelector(aSelector: SEL); mapped to makeObjectsPerformSelector(aSelector);
method makeObjectsPerformSelector(aSelector: SEL) withObject(argument: id); mapped to makeObjectsPerformSelector(aSelector) withObject(argument);
method member(&object: T): T; mapped to member(&object);
method objectsPassingTest(predicate: block(obj: T; stop: ^Boolean): Boolean); mapped to objectsPassingTest(NSSetTestBlock(predicate));
method objectsWithOptions(opts: NSEnumerationOptions) passingTest(predicate: block(obj: T; stop: ^Boolean): Boolean); mapped to objectsWithOptions(opts) passingTest(NSSetTestBlock(predicate));
method setByAddingObject(anObject: T): NSSet<T>; mapped to setByAddingObject(anObject);
method setByAddingObjectsFromArray(other: NSArray<T>): NSSet<T>; mapped to setByAddingObjectsFromArray(other);
method setByAddingObjectsFromSet(other: NSSet<T>): NSSet<T>; mapped to setByAddingObjectsFromSet(other);
method sortedArrayUsingDescriptors(sortDescriptors: NSArray): NSArray<T>; mapped to sortedArrayUsingDescriptors(sortDescriptors);
{ Instance Properties }
property allObjects: NSArray<T> read mapped.allObjects;
property anyObject: T read mapped.anyObject;
property count: NSUInteger read mapped.count;
property objectEnumerator: NSEnumerator read mapped.objectEnumerator;
{ NSMutableSet }
class method setWithCapacity(numItems: NSUInteger): id; mapped to setWithCapacity(numItems);
method addObject(object: T); mapped to addObject(object);
method addObjectsFromArray(&array: NSArray<T>); mapped to addObjectsFromArray(&array);
method filterUsingPredicate(predicate: NSPredicate); mapped to filterUsingPredicate(predicate);
method intersectSet(otherSet: NSSet<T>); mapped to intersectSet(otherSet);
method minusSet(otherSet: NSSet<T>); mapped to minusSet(otherSet);
method removeAllObjects; mapped to removeAllObjects;
method removeObject(object: T); mapped to removeObject(object);
method setSet(otherSet: NSSet<T>); mapped to setSet(otherSet);
method unionSet(otherSet: NSSet<T>); mapped to unionSet(otherSet);
{ NSCountedSet }
method countForObject(anObject: T): NSUInteger; mapped to countForObject(anObject);
end;
implementation
end. |
unit OS.MutexManager;
interface
uses
Windows;
type
TMutexManager = class
private
MutexHandle: THandle;
MutexName: String;
public
constructor Create(const MutexNameToUse: String);
destructor Destroy; override;
function OpenMutex: Boolean;
function CreateMutex: Boolean;
procedure ReleaseMutex;
end;
implementation
{ TMutexManager }
constructor TMutexManager.Create(const MutexNameToUse: String);
begin
MutexName := MutexNameToUse;
end;
procedure TMutexManager.ReleaseMutex;
begin
Windows.ReleaseMutex(MutexHandle);
CloseHandle(MutexHandle);
MutexHandle := 0;
end;
function TMutexManager.CreateMutex: Boolean;
begin
MutexHandle := Windows.CreateMutex(nil, true, PChar(MutexName));
result :=
(MutexHandle <> INVALID_HANDLE_VALUE) and
(MutexHandle <> 0);
end;
destructor TMutexManager.Destroy;
begin
if MutexHandle <> 0 then
ReleaseMutex;
inherited;
end;
function TMutexManager.OpenMutex: Boolean;
begin
MutexHandle := Windows.OpenMutex(MUTEX_ALL_ACCESS, false, PChar(MutexName));
result :=
(MutexHandle <> INVALID_HANDLE_VALUE) and
(MutexHandle <> 0);
end;
end.
|
////////////////////////////////////////////////////////////////////////////////
// IdSyslogServer component
// Server-side implementation of the RFC 3164 "The BSD syslog Protocol"
// Original Author: Stephane Grobety (grobety@fulgan.com)
// Copyright the Indy pit crew
// Release history:
// 08/09/01: Dev started
unit IdSysLogServer;
interface
uses
Classes,
IdAssignedNumbers,
IdBaseComponent,
IdComponent,
IdException,
IdGlobal,
IdSocketHandle,
IdStackConsts,
IdThread,
IdUDPBase,
IdUDPServer,
IdSysLogMessage,
IdSysLog;
type
TOnSyslogEvent = procedure(Sender: TObject; ASysLogMessage: TIdSysLogMessage;
ABinding: TIdSocketHandle) of object;
TIdSyslogServer = class(TIdUDPServer)
protected
FOnSyslog: TOnSyslogEvent;
//
procedure DoSyslogEvent(AMsg: TIdSysLogMessage; ABinding: TIdSocketHandle); virtual;
procedure DoUDPRead(AData: TStream; ABinding: TIdSocketHandle); override;
public
constructor Create(AOwner: TComponent); override;
published
property DefaultPort default IdPORT_syslog;
property OnSyslog: TOnSyslogEvent read FOnSyslog write FOnSysLog;
end;
implementation
uses
SysUtils;
{ TIdSyslogServer }
procedure TIdSyslogServer.DoUDPRead(AData: TStream; ABinding: TIdSocketHandle);
var
LMsg: TIdSysLogMessage;
begin
inherited DoUDPRead(AData,ABinding);
LMsg := TIdSysLogMessage.Create(Self);
try
LMsg.ReadFromStream(AData, (AData as TMemoryStream).Size, ABinding.PeerIP);
DoSyslogEvent(LMsg, ABinding);
finally
FreeAndNil(LMsg)
end;
end;
constructor TIdSyslogServer.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
DefaultPort := IdPORT_syslog;
end;
procedure TIdSyslogServer.DoSyslogEvent(AMsg: TIdSysLogMessage; ABinding: TIdSocketHandle);
begin
if Assigned(FOnSyslog) and assigned(AMsg)then begin
FOnSyslog(Self, AMsg, ABinding);
end;
end;
end.
|
unit AManutencaoNotas;
{ Autor: Rafael Budag
Data Criação: 19/05/1999;
Função: Consultar as notas fiscais
Motivo alteração:
}
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
formularios, StdCtrls, Componentes1, ExtCtrls, PainelGradiente,
Localizacao, Buttons, Db, DBTables, ComCtrls, Grids,
DBGrids, printers, Mask, numericos, Tabela, DBCtrls, DBKeyViolation,
Geradores, UnNotaFiscal, UnEDi, FileCtrl, UnDadosProduto, FMTBcd, SqlExpr,
DBClient, UnNfe, Menus;
type
TFManutencaoNotas = class(TFormularioPermissao)
PainelGradiente1: TPainelGradiente;
PanelColor1: TPanelColor;
PanelColor2: TPanelColor;
Localiza: TConsultaPadrao;
NOTAS: TSQL;
DATANOTAS: TDataSource;
BitBtn3: TBitBtn;
PageControl1: TPageControl;
NOTASI_NRO_NOT: TFMTBCDField;
NOTASC_NOM_CLI: TWideStringField;
NOTASC_TIP_CAD: TWideStringField;
NOTASC_FLA_ECF: TWideStringField;
PanelColor3: TPanelColor;
Label8: TLabel;
Label10: TLabel;
Label3: TLabel;
Label1: TLabel;
Label7: TLabel;
SpeedButton4: TSpeedButton;
Label11: TLabel;
Data1: TCalendario;
data2: TCalendario;
EClientes: TEditLocaliza;
NOTASc_not_can: TWideStringField;
NOTASL_OBS_NOT: TWideStringField;
NOTASN_TOT_PRO: TFMTBCDField;
NOTASN_TOT_NOT: TFMTBCDField;
NOTASI_NRO_LOJ: TFMTBCDField;
NOTASI_NRO_CAI: TFMTBCDField;
MObs: TDBMemoColor;
NotaGrid: TGridIndice;
NOTASC_NOT_IMP: TWideStringField;
BCancelaNota: TBitBtn;
BExcuiNota: TBitBtn;
NOTASI_EMP_FIL: TFMTBCDField;
NOTASI_SEQ_NOT: TFMTBCDField;
T: TPainelTempo;
NOTASD_DAT_EMI: TSQLTimeStampField;
NOTASC_NOM_NAT: TWideStringField;
BNotaDevolucaoFornecedor: TBitBtn;
NOTASC_NOT_DEV: TWideStringField;
Label27: TLabel;
SpeedButton2: TSpeedButton;
ENatureza: TEditLocaliza;
Label4: TLabel;
NOTASC_TIP_NOT: TWideStringField;
ENota: TEditColor;
NOTASNatureza: TWideStringField;
NOTASi_COD_CLI: TFMTBCDField;
NOTASC_COD_NAT: TWideStringField;
MovNatureza: TSQLQuery;
EItemNat: TEditColor;
NOTASI_ITE_NAT: TFMTBCDField;
NOTASC_SER_NOT: TWideStringField;
ESerie: TEditColor;
Label12: TLabel;
BEDI: TBitBtn;
BVerNota: TBitBtn;
NOTASC_CHA_NFE: TWideStringField;
NOTASC_REC_NFE: TWideStringField;
NOTASC_PRO_NFE: TWideStringField;
NOTASC_STA_NFE: TWideStringField;
NOTASC_MOT_NFE: TWideStringField;
BInutilizar: TBitBtn;
NOTASC_NOM_USU: TWideStringField;
NOTASD_DAT_CAN: TSQLTimeStampField;
NOTASUSUARIOCANCELAMENTO: TWideStringField;
BNotaDevolucao: TBitBtn;
BConsultaSefaz: TBitBtn;
NOTASC_NOT_INU: TWideStringField;
NOTASC_ENV_NFE: TWideStringField;
ETipoDocumento: TComboBoxColor;
Label2: TLabel;
Label5: TLabel;
EInutilizacao: TComboBoxColor;
CChaveAcessovazia: TCheckBox;
NOTASC_MOC_NFE: TWideStringField;
Label6: TLabel;
ESituacaoNota: TComboBoxColor;
PopupMenu1: TPopupMenu;
AlterarCliente1: TMenuItem;
procedure FormCreate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure ENotasRetorno(Retorno1, Retorno2: String);
procedure Data1Exit(Sender: TObject);
procedure BitBtn3Click(Sender: TObject);
procedure NOTASAfterScroll(DataSet: TDataSet);
procedure BExcuiNotaClick(Sender: TObject);
procedure BCancelaNotaClick(Sender: TObject);
procedure CupomNotaClick(Sender: TObject);
procedure BNotaDevolucaoFornecedorClick(Sender: TObject);
procedure ENotaKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure ENaturezaRetorno(Retorno1, Retorno2: String);
procedure BEDIClick(Sender: TObject);
procedure BVerNotaClick(Sender: TObject);
procedure NotaGridOrdem(Ordem: String);
procedure BInutilizarClick(Sender: TObject);
procedure BNotaDevolucaoClick(Sender: TObject);
procedure BConsultaSefazClick(Sender: TObject);
procedure NotaGridDrawColumnCell(Sender: TObject; const Rect: TRect;
DataCol: Integer; Column: TColumn; State: TGridDrawState);
procedure BConhecimentoClick(Sender: TObject);
procedure AlterarCliente1Click(Sender: TObject);
private
VprOrdem : string;
VprDNota : TRBDNotaFiscal;
DevolucaoCupomNotaFiscal : Boolean;
FunEDI : TRBFuncoesEDI;
FunNfe : TRBFuncoesNFe;
procedure ConfiguraPermissaoUsuario;
procedure PosicionaNota(VpaGuardarPosicao : Boolean = false);
procedure AdicionaFiltros(VpaSelect : TStrings);
procedure CarNotasSelecionadas(VpaNotas : TList);
public
{ Public declarations }
end;
var
FManutencaoNotas: TFManutencaoNotas;
implementation
uses APrincipal, Constantes, Fundata, ConstMsg,
Funstring, FunNumeros, FunSql, funObjeto,
AItensNatureza, ANovaNotaFiscalNota, ANovaNotaFiscaisFor,
AConhecimentoTransporte, AConhecimentoTransporteSaida, ANovoCliente;
{$R *.DFM}
{ ****************** Na criação do Formulário ******************************** }
procedure TFManutencaoNotas.FormCreate(Sender: TObject);
begin
Data1.DateTime := PrimeiroDiaMes(date);
Data2.DateTime := UltimoDiaMes(Date);
ETipoDocumento.ItemIndex := 1;
EInutilizacao.ItemIndex := 2;
ESituacaoNota.ItemIndex := 2;
VprOrdem := 'order by NF.I_NRO_NOT';
PosicionaNota;
FunEDI := TRBFuncoesEDI.cria;
FunNfe := TRBFuncoesNFe.cria(fPrincipal.BaseDados);
ConfiguraPermissaoUsuario;
end;
{ ******************* Quando o formulario e fechado ************************** }
procedure TFManutencaoNotas.FormClose(Sender: TObject; var Action: TCloseAction);
begin
FechaTabela(Notas);
FechaTabela(MovNatureza);
FunEdi.free;
FunNFE.Free;
Action := CaFree;
end;
{(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
Eventos da Consulta
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))}
{******************************************************************************}
procedure TFManutencaoNotas.ConfiguraPermissaoUsuario;
begin
AlterarVisibleDet([BNotaDevolucaoFornecedor,BCancelaNota,BExcuiNota,BEDI],false);
if (puFAManutencaoNota in varia.PermissoesUsuario)then
AlterarVisibleDet([BNotaDevolucaoFornecedor,BCancelaNota,BExcuiNota,BEDI],true);
end;
{*********************** atualiza a consulta **********************************}
procedure TFManutencaoNotas.PosicionaNota(VpaGuardarPosicao : Boolean = false);
Var
VpfPosicao : TBookMark;
begin
VpfPosicao := NOTAS.GetBookmark;
LimpaSQLTabela(Notas);
Notas.Sql.Add(' select ' +
' NF.I_NRO_NOT, Cli.C_NOM_CLI, Cli.C_TIP_CAD, NF.C_FLA_ECF, NF.c_not_can, NF.L_OBS_NOT, ' +
' NF.N_TOT_PRO, NF.N_TOT_NOT, NF.I_NRO_LOJ, NF.I_NRO_CAI, NF.I_EMP_FIL, NF.I_SEQ_NOT, ' +
' NF.D_DAT_EMI, NF.C_COD_NAT,Nat.C_Cod_Nat ||''-''|| nat.C_NOM_NAT Natureza, nat.C_NOM_NAT,' +
' NF.C_NOT_DEV, NF.C_NOT_IMP, NF.C_TIP_NOT, NF.I_COD_CLI, NF.I_ITE_NAT, NF.C_SER_NOT, ' +
' NF.C_CHA_NFE, NF.C_REC_NFE, NF.C_PRO_NFE, NF.C_STA_NFE, NF.C_MOT_NFE, NF.D_DAT_CAN, '+
' NF.C_NOT_INU, NF.C_ENV_NFE, NF.C_MOC_NFE, '+
' USU.C_NOM_USU, '+
' USC.C_NOM_USU USUARIOCANCELAMENTO '+
' from ' +
' CadNotaFiscais NF, CadClientes CLI, CadNatureza Nat, CADUSUARIOS USU, CADUSUARIOS USC '+
' where NF.I_EMP_FIL = ' + IntToStr(Varia.CodigoEmpFil) +
' and nf.i_nro_not is not null ' +
' and '+SQLTextoRightJoin('NF.I_COD_CLI','CLI.I_COD_CLI')+
' and '+SQLTextoRightJoin('NF.C_COD_NAT','NAT.C_COD_NAT')+
' and '+SQLTextoRightJoin('NF.I_USU_CAN','USC.I_COD_USU')+
' AND NF.I_COD_USU = USU.I_COD_USU');
AdicionaFiltros(Notas.Sql);
Notas.Sql.Add(VprOrdem);
NOTAS.open;
NotaGrid.ALinhaSQLOrderBy := NOTAS.Sql.Count - 1;
try
if (VpaGuardarPosicao) and (not Notas.eof) then
NOTAS.GotoBookmark(VpfPosicao);
NOTAS.FreeBookmark(VpfPosicao);
except
end;
end;
{**************** adiciona os filtros da select *******************************}
procedure TFManutencaoNotas.AdicionaFiltros(VpaSelect : TStrings);
begin
if ENota.Text <> '' Then
VpaSelect.Add(' and NF.I_Nro_not = '+ ENota.Text)
else
begin
VpaSelect.Add(SQLTextoDataEntreAAAAMMDD( ' NF.D_DAT_EMI ', Data1.Date, Data2.Date, true));
if (EClientes.Text <> '') then
VpaSelect.Add(' and NF.I_COD_CLI = ' + EClientes.Text);
if ENatureza.Text <> '' then
VpaSelect.Add(' and NF.C_COD_NAT = ''' + ENatureza.Text + '''' +
' and i_ite_nat = ' + EItemNat.text );
case ETipoDocumento.ItemIndex of
0 : VpaSelect.Add(' and NF.C_FLA_ECF = ''S''');
1 : VpaSelect.Add(' and '+SqlTextoIsNull('NF.C_FLA_ECF','''N''')+' = ''N'''+
' and '+SqlTextoIsNull('NF.C_VEN_CON','''N''')+' = ''N''' );
2 : VpaSelect.Add(' and NF.C_VEN_CON = ''S''');
end;
case ESituacaoNota.ItemIndex of
0 : VpaSelect.Add(' and NF.C_NOT_CAN = ''S''');
1 : VpaSelect.Add(' and NF.C_NOT_CAN = ''N''');
end;
case EInutilizacao.ItemIndex of
0 : VpaSelect.Add(' and NF.C_NOT_INU = ''S''');
1 : VpaSelect.Add(' and NF.C_NOT_INU = ''N''');
end;
if CChaveAcessovazia.Checked then
VpaSelect.Add(' AND NF.C_CHA_NFE IS NULL');
if ESerie.Text <> '' then
VpaSelect.Add(' and NF.C_SER_NOT = ''' + ESerie.Text + '''' );
end;
end;
{******************************************************************************}
procedure TFManutencaoNotas.CarNotasSelecionadas(VpaNotas : TList);
var
VpfLaco : Integer;
VpfDNota : TRBDNotaFiscal;
begin
FreeTObjectsList(VpaNotas);
if (NotaGrid.SelectedRows.Count = 0) and (NOTASI_SEQ_NOT.AsInteger <> 0) then
begin
VpfDNota := TRBDNotaFiscal.cria;
FunNotaFiscal.CarDNotaFiscal(VpfDNota,NOTASI_EMP_FIL.AsInteger,NOTASI_SEQ_NOT.AsInteger);
VpaNotas.add(VpfDNota);
end
else
begin
for VpfLaco := 0 to NotaGrid.SelectedRows.Count - 1 do
begin
NOTAS.GotoBookmark(TBookmark(NotaGrid.SelectedRows.Items[VpfLaco]));
VpfDNota := TRBDNotaFiscal.cria;
FunNotaFiscal.CarDNotaFiscal(VpfDNota,NOTASI_EMP_FIL.AsInteger,NOTASI_SEQ_NOT.AsInteger);
VpaNotas.add(VpfDNota);
end;
end;
end;
{(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
Evetos dos filtros superiores
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))}
{***************** atualica a consulta da grade *******************************}
procedure TFManutencaoNotas.ENotasRetorno(Retorno1, Retorno2: String);
begin
PosicionaNota;
end;
{****************** retorno da natureza ************************************* }
procedure TFManutencaoNotas.ENaturezaRetorno(Retorno1, Retorno2: String);
begin
if Retorno1 <> '' then
begin
// verifica natureza
FunNotaFiscal.LocalizaMovNatureza(MovNatureza, retorno1, false );
if MovNatureza.RecordCount > 1 then
begin
FItensNatureza := TFItensNatureza.CriarSDI(application, '', true);
FItensNatureza.PosicionaNatureza(MovNatureza);
end;
EItemNat.Text := MovNatureza.fieldByName('i_seq_mov').AsString;
if EItemNat.Text = '' then
EItemNat.Text := '0';
end
else
EItemNat.Text := '';
PosicionaNota;
end;
{**************** chama a rotina para atualizar a consulta ********************}
procedure TFManutencaoNotas.Data1Exit(Sender: TObject);
begin
PosicionaNota;
end;
{(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
eventos dos botões inferiores
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))}
{*********************** fecha o formulario ***********************************}
procedure TFManutencaoNotas.BConhecimentoClick(Sender: TObject);
begin
FConhecimentoTransporteSaida := TFConhecimentoTransporteSaida.CriarSDI(self,'',true);
FConhecimentoTransporteSaida.NovoConhecimento;
FConhecimentoTransporteSaida.Free;
end;
{ *************************************************************************** }
procedure TFManutencaoNotas.BConsultaSefazClick(Sender: TObject);
begin
FunNfe.ConsultapelaChave(NOTASC_CHA_NFE.AsString);
end;
{ *************************************************************************** }
procedure TFManutencaoNotas.BitBtn3Click(Sender: TObject);
begin
Close;
end;
{************************ exclui a nota fiscal *******************************}
procedure TFManutencaoNotas.BExcuiNotaClick(Sender: TObject);
var
VpfDNotaFiscal : TRBDNotaFiscal;
VpfTransacao : TTransactionDesc;
VpfREsultado : string;
begin
if confirmacao(CT_DeletaRegistro) then
begin
VpfTransacao.IsolationLevel :=xilREADCOMMITTED;
FPrincipal.BaseDados.StartTransaction(vpfTransacao);
T.Execute('Excluindo nota fiscal...');
VpfDNotaFiscal := TRBDNotaFiscal.cria;
VpfDNotaFiscal.CodFilial := NOTASI_EMP_FIL.AsInteger;
VpfDNotaFiscal.SeqNota := NOTASI_SEQ_NOT.AsInteger;
FunNotaFiscal.CarDNotaFiscal(VpfDNotaFiscal);
VpfREsultado := FunNotaFiscal.ExcluiNotaFiscal(VpfDNotaFiscal);
PosicionaNota(True);
if VpfResultado <> '' then
begin
FPrincipal.BaseDados.Rollback(VpfTransacao);
aviso(VpfResultado);
end
else
FPrincipal.BaseDados.Commit(VpfTransacao);
T.Fecha;
end;
end;
procedure TFManutencaoNotas.BInutilizarClick(Sender: TObject);
var
vpfResultado : String;
begin
if NOTASI_NRO_NOT.AsInteger <> 0 then
begin
if confirmacao('Tem certeza que deseja inutilizar o número da nota?') then
VpfREsultado := FunNfe.InutilizaNumero(NOTASI_EMP_FIL.AsInteger,NOTASI_SEQ_NOT.AsInteger, NOTASI_NRO_NOT.AsInteger);
if vpfResultado <> '' then
aviso(vpfresultado);
end;
end;
{******************* cancela a nota fiscal ************************************}
procedure TFManutencaoNotas.AlterarCliente1Click(Sender: TObject);
begin
if NOTASI_NRO_NOT.AsInteger <> 0 then
begin
FNovoCliente := TFNovoCliente.CriarSDI(application,'', FPrincipal.VerificaPermisao('FNovoCliente'));
AdicionaSqlAbreTabela(FNovoCliente.CadClientes,'Select * from CadClientes '+
' Where I_COD_CLI = '+NOTASi_COD_CLI.AsString);
FNovoCliente.CadClientes.Edit;
FNovoCliente.ShowModal;
FNovoCliente.Free;
end;
end;
{******************************************************************************}
procedure TFManutencaoNotas.BCancelaNotaClick(Sender: TObject);
var
VpfResultado : String;
VpfDNota : TRBDNotaFiscal;
VpfTransacao : TTransactionDesc;
begin
if NOTASI_SEQ_NOT.AsInteger <> 0 then
begin
VpfTransacao.IsolationLevel :=xilREADCOMMITTED;
FPrincipal.BaseDados.StartTransaction(vpfTransacao);
T.Execute('Cancelando nota fiscal...');
VpfDNota := TRBDNotaFiscal.cria;
FunNotaFiscal.CarDNotaFiscal(VpfDNota,NOTASI_EMP_FIL.AsInteger,NOTASI_SEQ_NOT.AsInteger);
VpfResultado := FunNotaFiscal.CancelaNotaFiscal(VpfDNota,true,true);
VpfDNota.Free;
PosicionaNota(true);
T.Fecha;
if VpfResultado <> '' then
begin
FPrincipal.BaseDados.Rollback(VpfTransacao);
aviso(VpfResultado);
end
else
FPrincipal.BaseDados.Commit(VpfTransacao);
end;
end;
{******************************************************************************}
procedure TFManutencaoNotas.CupomNotaClick(Sender: TObject);
begin
PosicionaNota;
end;
{******************** devolucao do cupom fiscal *******************************}
procedure TFManutencaoNotas.BNotaDevolucaoClick(Sender: TObject);
begin
if NOTASI_SEQ_NOT.AsInteger <> 0 then
begin
FNovaNotaFiscalNota:= TFNovaNotaFiscalNota.CriarSDI(Application,'',True);
if FNovaNotaFiscalNota.NotaDevolucao(NOTASI_EMP_FIL.AsInteger,NOTASI_SEQ_NOT.AsInteger) then
PosicionaNota(true);
FNovaNotaFiscalNota.Free;
end;
end;
{******************************************************************************}
procedure TFManutencaoNotas.BNotaDevolucaoFornecedorClick(Sender: TObject);
var
VpfNotas : TList;
begin
VpfNotas := TList.create;
CarNotasSelecionadas(VpfNotas);
FNovaNotaFiscaisFor := TFNovaNotaFiscaisFor.criarSDI(Application,'',FPrincipal.VerificaPermisao('FNovaNotaFiscaisFor'));
FNovaNotaFiscaisFor.GeraNotaDevolucao(VpfNotas);
FNovaNotaFiscaisFor.free;
FreeTObjectsList(VpfNotas);
VpfNotas.free;
end;
{(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((
eventos diversos
)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))}
{************************* apos o scrool da tabela ****************************}
procedure TFManutencaoNotas.NOTASAfterScroll(DataSet: TDataSet);
begin
// AlterarEnabledDet([BExcuiNota, BCancelaNota, BNotaDevolucaoFornecedor ], false);
// if CupomNota.ItemIndex = 1 then
begin
// BExcuiNota.Enabled := (NOTASC_NOT_IMP.AsString = 'N') AND (NOTASC_NOT_DEV.AsString = 'N') and (NOTASC_ENV_NFE.AsString = 'N');
BCancelaNota.Enabled := (NOTASC_NOT_DEV.AsString = 'N') AND (NOTASC_NOT_CAN.AsString = 'N');
BNotaDevolucaoFornecedor.Enabled := (NOTASC_NOT_DEV.AsString = 'N') AND (NOTASC_NOT_CAN.AsString = 'N') AND (NOTASC_TIP_NOT.AsString = 'S');
end;
// else
begin
BNotaDevolucaoFornecedor.Enabled := (NOTASC_NOT_DEV.AsString = 'N') AND (NOTASC_NOT_CAN.AsString = 'N');
end;
end;
{********************* atualiza a consulta ************************************}
procedure TFManutencaoNotas.ENotaKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
case key of
13 : PosicionaNota;
end;
end;
procedure TFManutencaoNotas.BEDIClick(Sender: TObject);
begin
if NOTASI_NRO_NOT.AsInteger <> 0 then
begin
FunEDI.GeraArquivoEDI(NOTASI_EMP_FIL.AsString,NOTASI_SEQ_NOT.AsString);
end;
end;
{******************************************************************************}
procedure TFManutencaoNotas.BVerNotaClick(Sender: TObject);
begin
VprDNota := TRBDNotaFiscal.cria;
VprDNota.CodFilial := NOTASI_EMP_FIL.AsInteger;
VprDNota.SeqNota := NOTASI_SEQ_NOT.AsInteger;
FunNotaFiscal.CarDNotaFiscal(VprDNota);
FNovaNotaFiscalNota := TFNovaNotaFiscalNota.CriarSDI(self,'',true);
FNovaNotaFiscalNota.ConsultaNota(VprDNota);
FNovaNotaFiscalNota.free;
PosicionaNota(True);
end;
{******************************************************************************}
procedure TFManutencaoNotas.NotaGridDrawColumnCell(Sender: TObject;
const Rect: TRect; DataCol: Integer; Column: TColumn; State: TGridDrawState);
begin
if NOTASc_not_can.AsString = 'S' then
begin
NotaGrid.Canvas.Font.Color:= clred;
NotaGrid.DefaultDrawDataCell(Rect, NotaGrid.columns[datacol].field, State);
end;
end;
{******************************************************************************}
procedure TFManutencaoNotas.NotaGridOrdem(Ordem: String);
begin
VprOrdem := Ordem;
end;
Initialization
RegisterClasses([TFManutencaoNotas]);
end.
|
{*******************************************************}
{ }
{ Delphi DBX Framework }
{ }
{ Copyright(c) 1995-2011 Embarcadero Technologies, Inc. }
{ }
{*******************************************************}
unit Data.DBXJSONCommon;
interface
uses
System.Classes,
Data.DBXCommon,
Data.DBXJSON;
type
TDBXJSONTools = class
public
/// <summary> Returns the JSONValue equivalent of a TDBXValueType instance.
/// </summary>
/// <remarks>
/// The caller assumes the JSON object ownership
///
/// </remarks>
/// <param name="dataType">DBX value type instance, not null</param>
/// <returns>JSON equivalent</returns>
class function ValueTypeToJSON(const DataType: TDBXValueType): TJSONArray; static;
/// <summary> Creates TDBXValueType out of its JSON equivalent.
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="jsonArray">JSON value type representation, normally created by
/// valueTypeToJSON function</param>
/// <returns>TDBXValueType instance </returns>
class function JSONToValueType(const JsonArray: TJSONArray): TDBXValueType; static;
/// <summary> Creates the JSON equivalent of a DBX table. The result is suitable for asynchronous
/// </summary>
/// <remarks> The result is suitable for asynchronous
/// calls and should not be used for large table. It is recommended use of Data Converters
/// if the table is expected to be large
///
/// The caller assumes JSON object ownership
///
/// </remarks>
/// <param name="value">DBXReader object, never null</param>
/// <param name="RowCount">Number of rows to populate</param>
/// <param name="isLocalConnection">true if the connection is in-process, dictates memory ownership policy</param>
/// <returns>JSON equivalent</returns>
class function TableToJSON(const Value: TDBXReader; const RowCount: Integer; const IsLocalConnection: Boolean): TJSONObject; static;
/// <summary> Creates JSON representation of a DBX value.
/// </summary>
/// <remarks>
/// JSON value will most likely not carry meta-data with it hence the need for
/// data type.
///
/// </remarks>
/// <param name="value">DBX value, never null</param>
/// <param name="dataType">value type</param>
/// <param name="IsLocalConnection">true if the connection is in-process, dictates memory ownership policy</param>
/// <returns>JSONValue</returns>
class function DBXToJSON(const Value: TDBXValue; const DataType: Integer; const IsLocalConnection: Boolean): TJSONValue; static;
/// <summary> Assigns DBXValue with proper content out of a JSON object. The method works
/// </summary>
/// <remarks> The method works
/// in tandem with DBXToJSON.
///
/// Supports limited implicit conversion across types. For example the string
/// 'False' means DBX false (observe the case sensitivity). Also in DBX 'True'
/// means boolean true.
///
/// </remarks>
/// <param name="data">JSONValue, never null</param>
/// <param name="value">value DBX container</param>
/// <param name="dataType">DBX expected type</param>
/// <param name="isLocalConnection">true if the DBX value is to be used with a local DSServer</param>
/// <param name="OwnsJSONValue">true if the JSON value is to be automically freed when no longer is use</param>
class procedure JSONToDBX(const Data: TJSONValue; const Value: TDBXWritableValue; const DataType: Integer; const IsLocalConnection: Boolean;
const OwnsJSONValue: Boolean = False); static;
/// <summary> Creates the JSON equivalent of a DBX stream.
/// </summary>
/// <remarks> The result is suitable for asynchronous calls and should not be used for large streams.
/// The use of Data Converters is recommended if the stream is expected to be large.
///
/// The caller assumes JSON array ownership
///
/// </remarks>
/// <param name="stream">InputStream object, never null</param>
/// <param name="offset">the zero-based index of the first byte to read from</param>
/// <param name="byteCount">the number of bytes to limit the result to</param>
/// <returns>JSON array equivalent of the stream</returns>
class function StreamToJSON(const Stream: TStream; const Offset: Integer; const ByteCount: Integer): TJSONArray; static;
/// <summary> Creates a stream from the JSON byte array provided.
/// </summary>
/// <param name="data">the JSON Array of bytes to create the stream from. Must not be null.</param>
/// <returns>the Stream created from the JSON Array</returns>
class function JSONToStream(const Data: TJSONArray): TStream; static;
end;
const
TABLE_PAIR = 'table';
implementation
uses
Data.DBXCommonTable,
Data.DBXPlatform,
System.SysUtils,
Data.DBXCommonResStrs
;
class function TDBXJSONTools.ValueTypeToJSON(const DataType: TDBXValueType): TJSONArray;
var
Meta: TJSONArray;
begin
Meta := TJSONArray.Create;
Meta.Add(DataType.Name);
// Meta.Add(DataType.DisplayName);
Meta.Add(DataType.DataType);
Meta.Add(DataType.Ordinal);
Meta.Add(DataType.SubType);
Meta.Add(DataType.Scale);
Meta.Add(DataType.Size);
Meta.Add(DataType.Precision);
Meta.Add(DataType.ChildPosition);
// meta.add(dataType.getValueTypeFlags());
Meta.Add(DataType.Nullable);
Meta.Add(DataType.Hidden);
Meta.Add(DataType.ParameterDirection);
Meta.Add(DataType.ValueParameter);
Meta.Add(DataType.Literal);
Result := Meta;
end;
class function TDBXJSONTools.JSONToValueType(const JsonArray: TJSONArray): TDBXValueType;
var
DataType: TDBXValueType;
begin
DataType := TDBXValueType.Create;
DataType.Name := (TJSONString(JsonArray.Get(0))).Value;
//DataType.DisplayName := (TJSONString(JsonArray.Get(1))).Value;
DataType.DataType := (TJSONNumber(JsonArray.Get(1))).AsInt;
DataType.Ordinal := (TJSONNumber(JsonArray.Get(2))).AsInt;
DataType.SubType := (TJSONNumber(JsonArray.Get(3))).AsInt;
DataType.Scale := (TJSONNumber(JsonArray.Get(4))).AsInt;
DataType.Size := (TJSONNumber(JsonArray.Get(5))).AsInt;
DataType.Precision := (TJSONNumber(JsonArray.Get(6))).AsInt;
DataType.ChildPosition := (TJSONNumber(JsonArray.Get(7))).AsInt;
// dataType.setValueTypeFlags(((JSONNumber)jsonArray.get(9)).getAsInt());
DataType.Nullable := JsonArray.Get(8) is TJSONTrue;
DataType.Hidden := JsonArray.Get(9) is TJSONTrue;
DataType.ParameterDirection := (TJSONNumber(JsonArray.Get(10))).AsInt;
DataType.ValueParameter := JsonArray.Get(11) is TJSONTrue;
DataType.Literal := JsonArray.Get(12) is TJSONTrue;
Result := DataType;
end;
class function TDBXJSONTools.TableToJSON(const Value: TDBXReader; const RowCount: Integer; const IsLocalConnection: Boolean): TJSONObject;
var
I: Integer;
C: Integer;
JTable: TJSONObject;
Count: Integer;
JsonCols: array of TJSONArray;
Meta: TJSONArray;
Header: Boolean;
JsonCell: TJSONValue;
begin
if Value = nil then
Exit(TJSONObject.Create);
JTable := TJSONObject.Create;
Count := Value.ColumnCount;
SetLength(JsonCols,Count);
Meta := TJSONArray.Create;
JTable.AddPair(TABLE_PAIR, Meta);
Header := True;
C := RowCount;
while Value.Next and (C > 0) do
begin
for I := 0 to Count - 1 do
begin
if Header then
begin
JsonCols[I] := TJSONArray.Create;
JTable.AddPair(Value.ValueType[I].Name, JsonCols[I]);
Meta.AddElement(ValueTypeToJSON(Value.ValueType[I]));
end;
JsonCell := DBXToJSON(Value.Value[I], Value.ValueType[I].DataType, IsLocalConnection);
JsonCols[I].AddElement(JsonCell);
end;
Header := False;
DecrAfter(C);
end;
Value.Close;
if IsLocalConnection then
Value.Free;
Result := JTable;
end;
class function TDBXJSONTools.DBXToJSON(const Value: TDBXValue; const DataType: Integer; const IsLocalConnection: Boolean): TJSONValue;
begin
if Value = nil then
Result := nil
else if Value.IsNull then
Result := TJSONNull.Create
else
case DataType of
TDBXDataTypes.JsonValueType:
Result := Value.GetJSONValue(False);
TDBXDataTypes.Int8Type,
TDBXDataTypes.Int16Type,
TDBXDataTypes.Int32Type,
TDBXDataTypes.UInt16Type,
TDBXDataTypes.UInt32Type,
TDBXDataTypes.DoubleType,
TDBXDataTypes.CurrencyType,
TDBXDataTypes.BcdType:
Result := TJSONNumber.Create(Value.AsDouble);
TDBXDataTypes.UInt64Type,
TDBXDataTypes.Int64Type:
Result := TJSONNumber.Create(Value.AsInt64);
TDBXDataTypes.SingleType:
Result := TJSONNumber.Create(Value.AsSingle);
TDBXDataTypes.UInt8Type:
Result := TJSONNumber.Create(Value.AsUInt8);
TDBXDataTypes.BooleanType:
if Value.GetBoolean then
Result := TJSONTrue.Create
else
Result := TJSONFalse.Create;
TDBXDataTypes.AnsiStringType,
TDBXDataTypes.TimeStampType,
TDBXDataTypes.WideStringType,
TDBXDataTypes.DateType,
TDBXDataTypes.DatetimeType,
TDBXDataTypes.TimeType:
Result := TJSONString.Create(Value.AsString);
TDBXDataTypes.TableType:
if IsLocalConnection then
Result := TableToJSON(Value.GetDBXReader(False), High(Integer), IsLocalConnection)
else
Result := TableToJSON(Value.GetDBXReader, High(Integer), IsLocalConnection);
TDBXDataTypes.BlobType,
TDBXDataTypes.BinaryBlobType:
Result := StreamToJSON(Value.GetStream(True), 0, High(Integer));
else
raise TDBXError.Create(0, Format(SNoConversionToJSON, [TDBXValueType.DataTypeName(DataType)]));
end;
end;
class procedure TDBXJSONTools.JSONToDBX(const Data: TJSONValue; const Value: TDBXWritableValue; const DataType: Integer; const IsLocalConnection: Boolean;
const OwnsJSONValue: Boolean);
var
DataToFree: TJSONValue;
procedure SetObjectValueData;
begin
if DataToFree = Data then
begin
DataToFree := nil;
Value.SetObjectValue(Data, True);
end
else
Value.SetObjectValue(Data, False);
end;
var
BoolValue: Boolean;
Num: Integer;
begin
if OwnsJSONValue then
DataToFree := Data
else
DataToFree := nil;
if Data = nil then
Value.SetNull
else if Data is TJSONNull then
begin
if DataType = TDBXDataTypes.JsonValueType then
SetObjectValueData // Value.SetObjectValue(Data, False)
else
Value.SetNull;
end
else if Data is TJSONNumber then
case DataType of
TDBXDataTypes.AnsiStringType,
TDBXDataTypes.TimeStampType,
TDBXDataTypes.Int8Type,
TDBXDataTypes.Int16Type,
TDBXDataTypes.Int32Type,
TDBXDataTypes.UInt8Type,
TDBXDataTypes.UInt16Type,
TDBXDataTypes.UInt32Type,
TDBXDataTypes.Int64Type,
TDBXDataTypes.UInt64Type,
TDBXDataTypes.WideStringType:
Value.AsString := (TJSONNumber(Data)).Value;
TDBXDataTypes.DoubleType,
TDBXDataTypes.CurrencyType,
TDBXDataTypes.BcdType,
TDBXDataTypes.SingleType:
Value.AsDouble := (TJSONNumber(Data)).AsDouble;
TDBXDataTypes.BooleanType:
Value.AsBoolean := (TJSONNumber(Data)).AsInt = 1;
TDBXDataTypes.JsonValueType:
SetObjectValueData // Value.SetObjectValue(Data, False);
else
raise TDBXError.Create(0, Format(SNoConversionToDBX, [Data.ToString,TDBXValueType.DataTypeName(DataType)]));
end
else if Data is TJSONString then
case DataType of
TDBXDataTypes.AnsiStringType:
Value.SetAnsiString(AnsiString((TJSONString(Data)).Value));
TDBXDataTypes.TimeStampType,
TDBXDataTypes.WideStringType,
TDBXDataTypes.DateType,
TDBXDataTypes.TimeType,
TDBXDataTypes.DatetimeType:
Value.AsString := (TJSONString(Data)).Value;
TDBXDataTypes.Int16Type,
TDBXDataTypes.Int32Type,
TDBXDataTypes.UInt16Type,
TDBXDataTypes.UInt32Type,
TDBXDataTypes.Int8Type,
TDBXDataTypes.Int64Type,
TDBXDataTypes.DoubleType,
TDBXDataTypes.SingleType,
TDBXDataTypes.CurrencyType,
TDBXDataTypes.BcdType:
if TDBXPlatform.IsBoolean((TJSONString(Data)).Value) then
begin
BoolValue := StrToBool((TJSONString(Data)).Value);
if BoolValue then
Value.AsDouble := 1
else
Value.AsDouble := 0;
end
else
case DataType of
TDBXDataTypes.DoubleType,
TDBXDataTypes.CurrencyType,
TDBXDataTypes.SingleType,
TDBXDataTypes.BcdType:
Value.AsDouble := TDBXPlatform.JsonToFloat(TJSONString(Data).Value);
else
Value.AsString := (TJSONString(Data)).Value;
end;
TDBXDataTypes.BooleanType:
Value.AsBoolean := StrToBool((TJSONString(Data)).Value);
TDBXDataTypes.UInt8Type:
if TDBXPlatform.IsBoolean((TJSONString(Data)).Value) then
begin
BoolValue := StrToBool((TJSONString(Data)).Value);
if BoolValue then
Value.AsUInt8 := 1
else
Value.AsUInt8 := 0;
end
else
Value.AsUInt8 := StrToInt((TJSONString(Data)).Value);
TDBXDataTypes.JsonValueType:
SetObjectValueData // Value.SetObjectValue(Data, False);
else
raise TDBXError.Create(0, Format(SNoConversionToDBX, [Data.ToString,TDBXValueType.DataTypeName(DataType)]));
end
else if (Data is TJSONTrue) or (Data is TJSONFalse) then
begin
BoolValue := (Data is TJSONTrue);
if BoolValue then
Num := 1
else
Num := 0;
case DataType of
TDBXDataTypes.BooleanType:
Value.AsBoolean := BoolValue;
TDBXDataTypes.Int8Type,
TDBXDataTypes.Int16Type,
TDBXDataTypes.Int32Type,
TDBXDataTypes.Int64Type,
TDBXDataTypes.UInt16Type,
TDBXDataTypes.UInt32Type,
TDBXDataTypes.UInt64Type,
TDBXDataTypes.DoubleType,
TDBXDataTypes.CurrencyType,
TDBXDataTypes.BcdType,
TDBXDataTypes.SingleType:
Value.AsDouble := Num;
TDBXDataTypes.UInt8Type:
Value.AsUInt8 := Num;
TDBXDataTypes.TimeStampType:
Value.AsDateTime := Num;
TDBXDataTypes.AnsiStringType:
Value.SetAnsiString(AnsiString((BoolToStr(BoolValue))));
TDBXDataTypes.WideStringType:
Value.SetWideString(BoolToStr(BoolValue));
TDBXDataTypes.JsonValueType:
SetObjectValueData // Value.SetObjectValue(Data, False);
else
raise TDBXError.Create(0, Format(SNoConversionToDBX, [Data.ToString,TDBXValueType.DataTypeName(DataType)]));
end;
end
else if Data is TJSONObject then
case DataType of
TDBXDataTypes.JsonValueType:
if Value.ValueType.SubType = TDBXDataTypes.UserSubType then
Value.SetObjectValue(TJSONValue(Data.Clone), not IsLocalConnection)
else
SetObjectValueData; // Value.SetObjectValue(Data, OwnsJSONValue);
TDBXDataTypes.TableType:
begin
Value.SetDBXReader(TDBXJSONTableReader.Create(nil, TJSONObject(Data), OwnsJSONValue), True);
DataToFree := nil;
end
else
raise TDBXError.Create(0, Format(SNoConversionToDBX, [Data.ToString,TDBXValueType.DataTypeName(DataType)]));
end
else if Data is TJSONArray then
case DataType of
TDBXDataTypes.JsonValueType:
SetObjectValueData; // Value.SetObjectValue(Data, OwnsJSONValue);
TDBXDataTypes.BlobType,
TDBXDataTypes.BinaryBlobType:
Value.SetStream(JSONToStream(TJSONArray(Data)), not IsLocalConnection);
else
raise TDBXError.Create(0, Format(SNoConversionToDBX, [Data.ToString,TDBXValueType.DataTypeName(DataType)]));
end
else
raise TDBXError.Create(0, Format(SNoJSONConversion, [Data.ToString]));
DataToFree.Free;
end;
class function TDBXJSONTools.JSONToStream(const Data: TJSONArray): TStream;
var
Bytes: TBytes;
I: Integer;
Num: TJSONNumber;
ByteVal: Integer;
begin
SetLength(Bytes,Data.Size);
for I := 0 to Data.Size - 1 do
begin
if Data.Get(I) is TJSONNumber then
begin
Num := TJSONNumber(Data.Get(I));
ByteVal := Num.AsInt;
if (ByteVal >= 0) and (ByteVal <= 255) then
Bytes[I] := Byte(ByteVal)
else
raise TDBXError.Create(0, SInvalidJsonStream);
end
else
raise TDBXError.Create(0, SInvalidJsonStream);
end;
Result := TBytesStream.Create(Bytes);
end;
class function TDBXJSONTools.StreamToJSON(const Stream: TStream; const Offset: Integer; const ByteCount: Integer): TJSONArray;
var
JArray: TJSONArray;
Data: TBytes;
Iterations: Integer;
Appended: Integer;
begin
JArray := TJSONArray.Create;
if Stream = nil then
Exit(JArray);
SetLength(Data,1);
Iterations := 0;
Appended := 0;
while Appended < ByteCount do
begin
try
if Stream.Read(Data[0],1) > 0 then
begin
if Iterations >= Offset then
begin
JArray.Add(Integer(Data[0]));
IncrAfter(Appended);
end;
end
else
break;
except
on E: Exception do
raise TDBXError.Create(0, E.Message, E);
end;
IncrAfter(Iterations);
end;
Result := JArray;
end;
end.
|
unit PathGroups;
interface
uses classes,
sysUtils,
// DirectoryStat,
ExtensionTypeManager;
type
TPathGroups = class(TStringList)
protected
// (object associé) mysuminfo : Tsuminfo;
private
fReference : TStringList;
function GetGroupName(Key : String) : String;
procedure SetGroupName(Key : String; value : String);
public
constructor Create();
destructor Destroy; override;
property GroupName[Key : String] : String read GetGroupName write SetGroupName;
procedure AddGroup(P: String; Gname: String);
function AddUnique(S : String) : Integer;
function ReferenceExists(S : String) : Boolean;
function ExtensionTypeMan(S : String) : TExtensionTypeManager;
procedure DumpData(S : String);
end;
EPathGroupsNotUnique = class(Exception);
implementation
constructor TPathGroups.Create();
begin
fReference := TStringList.create();
fReference.Duplicates := dupError;
fReference.Sorted := true;
fReference.OwnsObjects := true;
Duplicates := dupError;
OwnsObjects := False;
Sorted := True;
end;
destructor TPathGroups.Destroy;
begin
fReference.free;
inherited Destroy;
end;
Procedure TPathGroups.AddGroup(P: String; Gname: String);
var Dup : string;
begin
try
GroupName[LowerCase(P)] := LowerCase(GName);
except
on EStringListError do
begin
Dup := Values[LowerCase(P)];
raise EPathGroupsNotUnique.create('['+Gname+'->'+P+'] duplicates on type ['+Dup+']');
end;
end;
end;
function TPathGroups.GetGroupName(Key : String) : String;
begin
result := Values[LowerCase(Key)];
end;
procedure TPathGroups.SetGroupName(Key : String; value : String);
begin
// writeln('Set GroupName[',Key,'] a [',Value,']');
Values[LowerCase(Key)] := LowerCase(Value);
end;
function TPathGroups.AddUnique(S : String) : Integer;
begin
try
// writeln('ajout PathGroups de ',S);
Result := fReference.Add(LowerCase(S));
fReference.objects[Result] := TExtensionTypeManager.Create();
except
on EStringListError do raise EPathGroupsNotUnique.create('['+S+'] Duplicates');
end;
end;
function TPathGroups.ReferenceExists(S : String) : Boolean;
begin
Result := fReference.indexOf(Lowercase(S))<>-1;
end;
function TPathGroups.ExtensionTypeMan(S : String) : TExtensionTypeManager;
var i : Integer;
begin
result := nil;
i := fReference.indexOf(Lowercase(S));
if i<>-1 then
Result := fReference.objects[i] as TExtensionTypeManager;
end;
procedure TPathGroups.dumpData(S : String);
var i : Integer;
begin
Writeln(S:10,' Value:':25 , '':3, 'Name:':25);
for i := 0 to pred(fReference.count) do
begin
Writeln(i:10,' => ':4,fReference[i]:25);
(fReference.objects[i] as TExtensionTypeManager).DumpExtensions;
end;
end;
end. |
unit BaseComponentsQuery;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs,
FireDAC.Stan.Intf, FireDAC.Stan.Option, FireDAC.Stan.Param,
FireDAC.Stan.Error, FireDAC.DatS, FireDAC.Phys.Intf, FireDAC.DApt.Intf,
FireDAC.Stan.Async, FireDAC.DApt, Data.DB, FireDAC.Comp.DataSet,
FireDAC.Comp.Client, Vcl.StdCtrls, CustomComponentsQuery, ApplyQueryFrame,
SearchComponentOrFamilyQuery;
type
TQueryBaseComponents = class(TQueryCustomComponents)
private
FClone: TFDMemTable;
FqSearchComponent: TQuerySearchComponentOrFamily;
procedure DoBeforeOpen(Sender: TObject);
function GetqSearchComponent: TQuerySearchComponentOrFamily;
{ Private declarations }
protected
procedure ApplyDelete(ASender: TDataSet; ARequest: TFDUpdateRequest;
var AAction: TFDErrorAction; AOptions: TFDUpdateRowOptions); override;
procedure ApplyInsert(ASender: TDataSet; ARequest: TFDUpdateRequest;
var AAction: TFDErrorAction; AOptions: TFDUpdateRowOptions); override;
procedure ApplyUpdate(ASender: TDataSet; ARequest: TFDUpdateRequest;
var AAction: TFDErrorAction; AOptions: TFDUpdateRowOptions); override;
property qSearchComponent: TQuerySearchComponentOrFamily
read GetqSearchComponent;
public
constructor Create(AOwner: TComponent); override;
function Exists(AParentProductID: Integer): Boolean;
{ Public declarations }
end;
implementation
{$R *.dfm}
uses NotifyEvents, DBRecordHolder, DefaultParameters;
{ TQueryComponentsBase }
constructor TQueryBaseComponents.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
TNotifyEventWrap.Create(W.BeforeOpen, DoBeforeOpen, W.EventList);
FClone := W.AddClone('');
end;
procedure TQueryBaseComponents.ApplyDelete(ASender: TDataSet;
ARequest: TFDUpdateRequest; var AAction: TFDErrorAction;
AOptions: TFDUpdateRowOptions);
begin
Assert(ASender = FDQuery);
if W.ID.F.AsInteger > 0 then
begin
// Удаляем сам дочерний компонент
qProducts.DeleteRecord(W.ID.F.AsInteger);
end;
inherited;
end;
procedure TQueryBaseComponents.ApplyInsert(ASender: TDataSet;
ARequest: TFDUpdateRequest; var AAction: TFDErrorAction;
AOptions: TFDUpdateRowOptions);
var
ARH: TRecordHolder;
begin
Assert(ASender = FDQuery);
// Если такого компонента ещё нет
if qSearchComponent.SearchComponent(W.ParentProductID.F.AsInteger,
W.Value.F.AsString) = 0 then
begin
ARH := TRecordHolder.Create(ASender);
try
qProducts.InsertRecord(ARH);
finally
FreeAndNil(ARH);
end;
// Запоминаем сгенерированный первичный ключ
FetchFields([W.PKFieldName], [qProducts.PKValue], ARequest, AAction,
AOptions);
end
else
begin
// Если такой компонент уже есть
// Запоминаем найденный первичный ключ
FetchFields([W.PKFieldName], [qSearchComponent.W.PK.Value], ARequest,
AAction, AOptions);
end;
Assert(W.PK.AsInteger > 0);
inherited;
end;
procedure TQueryBaseComponents.ApplyUpdate(ASender: TDataSet;
ARequest: TFDUpdateRequest; var AAction: TFDErrorAction;
AOptions: TFDUpdateRowOptions);
var
ARH: TRecordHolder;
begin
ARH := TRecordHolder.Create(ASender);
try
qProducts.UpdateRecord(ARH);
finally
FreeAndNil(ARH);
end;
inherited;
end;
procedure TQueryBaseComponents.DoBeforeOpen(Sender: TObject);
begin
FDQuery.ParamByName('PackagePinsParamSubParamID').AsInteger :=
TDefaultParameters.PackagePinsParamSubParamID;
end;
function TQueryBaseComponents.GetqSearchComponent
: TQuerySearchComponentOrFamily;
begin
if FqSearchComponent = nil then
FqSearchComponent := TQuerySearchComponentOrFamily.Create(Self);
Result := FqSearchComponent;
end;
function TQueryBaseComponents.Exists(AParentProductID: Integer): Boolean;
begin
Result := False;
if FDQuery.RecordCount = 0 then
Exit;
if W.ParentProductID.F.AsInteger = AParentProductID then
begin
Result := True;
Exit;
end;
// if not (FDQuery.State in [dsBrowse]) then
// Exit;
// Клон нужен так как набор данных может быть не в режиме dsBrowse
Result := not VarIsNull(FClone.LookupEx(W.ParentProductID.FieldName,
AParentProductID, W.PKFieldName));
end;
end.
|
(*
* (c) Copyright 1994, MAP Ltd., Veldhoven
*
* Function : SPV11.PAS
*
* Abstract : Set Ports Version 1.1
*
* Description : see Summary
*
* History : MV ð Menno A.P.J. Vogels
*
* Version 1.0 source, 94-05
*
* 940616, added DecodeStr function & StripZeroParam procedure and
* changed help screen, MV
* 940730, changed CopyRight strings implementation for Help function, MV
* 941114, updated error messages, MV
* 950113, simplified addressing the memory addresses, MV
* 950225, improved DecodeStr function, MV
*
* Version 1.1 source, yy-mm
*
* Summary :
*
* Error msg. : 0 : No error
* 1 : Invalid Option
* 2 : Invalid Switch
*)
program
Set__Ports (input, output);
(*--- USED UNITS ---*)
uses
Crt, Dos;
(*--- GLOBAL TYPES ---*)
type
IOPorts = (Com1, Com2, Com3, Com4, Lpt1, Lpt2, Lpt3);
IOPortType = array[IOPorts] of record
Clear : Boolean;
Change : Boolean;
PortStr : String[4];
MemAddr : Word;
PortAddr: Word;
end;
(*--- GLOBAL CONSTANTS ---*)
const
ProgramName : array[1..9] of Byte =
{ S e t P o r t s }
( 83,101,116, 32, 80,111,114,116,115);
Version : array[1..12] of Byte =
{ V e r s i o n 1 . 1 á }
( 86,101,114,115,105,111,110, 32, 49, 46, 49,225);
Company : array[1..8] of Byte =
{ M A P L t d . }
( 77, 65, 80, 32, 76,116,100, 46);
Year : array[1..3] of Byte =
{ ' 9 4 }
( 39, 57, 52);
NumberOfPorts = 7; { Com1, Com2, ..., Lpt3 }
SwitchInd = ['/','-'];
ChangeCom : Boolean = FALSE;
ChangeLpt : Boolean = FALSE;
Default : Boolean = FALSE;
Quiet : Boolean = FALSE;
Ports : IOPortType =
( { begin of Ports }
(Clear:FALSE; Change:FALSE; PortStr:'Com1'; MemAddr:$400; PortAddr:$3F8),
(Clear:FALSE; Change:FALSE; PortStr:'Com2'; MemAddr:$402; PortAddr:$2F8),
(Clear:FALSE; Change:FALSE; PortStr:'Com3'; MemAddr:$404; PortAddr:$3E8),
(Clear:FALSE; Change:FALSE; PortStr:'Com4'; MemAddr:$406; PortAddr:$2E8),
(Clear:FALSE; Change:FALSE; PortStr:'Lpt1'; MemAddr:$408; PortAddr:$378),
(Clear:FALSE; Change:FALSE; PortStr:'Lpt2'; MemAddr:$40A; PortAddr:$278),
(Clear:FALSE; Change:FALSE; PortStr:'Lpt3'; MemAddr:$40C; PortAddr:$3BC)
); { end of Ports }
(*--- FUNCTION AND PROCEDURE DEFINITIONS ---*)
(*
* Function : Replicate
*
* Abstract :
*
* Decisions : Repeat the input character a number of times
*)
function Replicate(C:Char; N:Byte): String;
var TempStr: String;
begin
if N = 0 then
TempStr := ''
else begin
If (N > 255) then N := 1;
FillChar(TempStr, N+1, C);
TempStr[0] := Chr(N);
end;
Replicate := Tempstr;
end; { of Replicate }
(*
* Function : Byte2HexStr
*
* Abstract : Byte-decimals to Hexadecimal-string
*
* Decisions : Changes a byte to a hexadecimal string
*)
function Byte2HexStr(B: Byte): String;
const HexString: String[16] = '0123456789ABCDEF';
begin
Byte2HexStr := HexString[(B DIV 16) +1] +HexString[(B MOD 16) +1];
end; { of Byte2HexStr }
(*
* Function : Str2Word
*
* Abstract : String to Word
*
* Decisions : Converts the input string to a word
*)
function Str2Word(S: String): Word;
var ErrorCode: Integer;
W: Word;
begin
if Length(S) = 0 then
Str2Word := 0
else begin
Val(S, W, ErrorCode);
if ErrorCode = 0 then
Str2Word := W
else
Str2Word := 0;
end;
end; { of Str2Word }
(*
* Function : UpStr
*
* Abstract : String to Upper Case
*
* Decisions : Converts all lower case characters of
* the input string to upper case
*)
function UpStr(S: String): String;
var i: Integer;
begin
for i := 1 to Length(S) do begin
S[i] := UpCase(S[i]);
end;
UpStr := S;
end; { of UpStr }
(*
* Function : DecodeStr
*
* Abstract : Decode the input string
*
* Decisions : Get the address' for the ports in the range from the
* first to the last port from the input string
*)
procedure DecodeStr(InStr: String; FirstPort,LastPort: IOPorts);
var NextPort, QuitLoop: Boolean;
CommaPos: Byte;
p: IOPorts;
begin
Delete(InStr, 1, Pos(':', InStr));
p := FirstPort;
NextPort := FALSE;
QuitLoop := FALSE;
while (p <= LastPort) AND (NOT QuitLoop) do begin
if NextPort then p := Succ(p);
CommaPos := Pos(',', InStr);
if CommaPos = 0 then CommaPos := Length(InStr) +1;
if CommaPos = 1 then
Ports[p].Clear := TRUE
else begin
Ports[p].Change := TRUE;
Ports[p].PortAddr := Str2Word('$' +Copy(InStr, 1, CommaPos -1));
end;
Delete(InStr, 1, CommaPos);
NextPort := TRUE;
if p = LastPort then QuitLoop := TRUE;
end; { of while }
end; { of DecodeStr }
(*
* Function : ReadPortsFromMemory
*
* Abstract :
*
* Decisions : Reads the address' of the ports from
* memory and displays them on screen
*)
procedure ReadPortsFromMemory;
var LowStr,HighStr: String;
p: IOPorts;
begin
for p := IOPorts(0) to IOPorts(NumberOfPorts -1) do begin
LowStr := Byte2HexStr(Mem[$0:Ports[p].MemAddr ]);
HighStr := Byte2HexStr(Mem[$0:Ports[p].MemAddr +$1]);
Write(Ports[p].PortStr +':' +HighStr +LowStr +' ');
end;
WriteLn;
end; { of ReadPortsFromMemory }
(*
* Function : WritePortsToMemory
*
* Abstract :
*
* Decisions : Writes the address' of the ports to memory
*)
procedure WritePortsToMemory;
var p: IOPorts;
begin
for p := IOPorts(0) to IOPorts(NumberOfPorts -1) do begin
if Ports[p].Clear = TRUE then
begin
Mem[$0:Ports[p].MemAddr ] := Lo($0);
Mem[$0:Ports[p].MemAddr +$1] := Hi($0);
end
else if Ports[p].Change = TRUE then
begin
Mem[$0:Ports[p].MemAddr ] := Lo(Ports[p].PortAddr);
Mem[$0:Ports[p].MemAddr +$1] := Hi(Ports[p].PortAddr);
end;
end; { of for p }
end; { of WritePortsToMemory }
(*
* Function : StripZeroParam
*
* Abstract : Strip the first commandline parameter-string
*
* Decisions : The first parameter-string from the commandline
* contains the full path and name of the program
* that is executed. Strip the path and the extension
* of the executable so that its name remains.
*)
function StripZeroParam: String;
var TempStr: String;
begin
TempStr := ParamStr(0);
while Pos('\', TempStr) <> 0 do Delete(TempStr, 1, Pos('\', TempStr));
if Pos('.', TempStr) <> 0 then
Delete(TempStr, Pos('.', TempStr), Length(TempStr)-(Pos('.', TempStr)-1));
StripZeroParam := TempStr;
end; { of StripZeroParam }
(*
* Function : Help
*
* Abstract :
*
* Decisions :
*)
procedure Help;
var NumberOfSpaces,b: Byte;
TempStr: String;
begin
TempStr := StripZeroParam;
NumberOfSpaces :=
80 - { screen width }
(2 + { left margin }
SizeOf(ProgramName) + { size of the ProgramName array }
2 + { space between ProgamName & Version }
SizeOf(Version) + { size of the Version array }
1 + { min. space between Version & Company }
SizeOf(Company) + { size of the Company array }
1 + { space between Company & Year }
SizeOf(Year) + { size of the Year array }
2 { rigth margin }
);
WriteLn;
Write (' ');
for b := 1 to SizeOf(ProgramName) do Write(Chr(ProgramName[b]));
Write (' ');
for b := 1 to SizeOf(Version) do Write(Chr(Version[b]));
Write (' '+Replicate(' ',NumberOfSpaces));
for b := 1 to SizeOf(Company) do Write(Chr(Company[b]));
Write (' ');
for b := 1 to SizeOf(Year) do Write(Chr(Year[b]));
WriteLn;
WriteLn;
WriteLn(' Usage : '+TempStr+' [/|-][ports:address('')|D(efault)|Q(uiet)|V(iew)|?]');
WriteLn(' ports : C(om), C1, C2, C3, C4, L(pt), L1, L2, L3');
WriteLn(' e.g. : '+TempStr+' /C:3F8,2F8,3E8,2E8 /L:378,278,3BC');
WriteLn(' '+TempStr+' /C clears address'' of all com-ports');
WriteLn(' '+TempStr+' /C1 clears address of com-port 1');
WriteLn(' '+TempStr+' /C:,,2E8 clears address'' of first two & the last com-port');
Write (Replicate(' ',Length(' '+TempStr)));
WriteLn( ' and sets address of com-port 3 to 2E8 hex');
WriteLn(' '+TempStr+' /C1:3F8 /L2:278 sets address of com-port 1 and lpt-port 2');
end; { of Help }
(*
* Function : GetCommandLine
*
* Abstract :
*
* Decisions :
*)
procedure GetCommandLine;
var Count,LenStr: Byte;
Str: ComStr;
p: IOPorts;
begin
for Count := 1 to ParamCount do begin
Str := UpStr(ParamStr(Count));
LenStr := Length(Str);
if Str[1] in SwitchInd then
case Str[2] of
'C': if (NOT Default) then begin
ChangeCom := TRUE;
if (LenStr in [2,3]) AND
(Str[LenStr] in ['C','1','2','3','4']) then
(*
* Clear the address(') for one or more COM-ports
*)
begin
case Str[LenStr] of
'C': for p := Com1 to Com4 do begin
Ports[p].Clear := TRUE;
end;
'1': Ports[Com1].Clear := TRUE;
'2': Ports[Com2].Clear := TRUE;
'3': Ports[Com3].Clear := TRUE;
'4': Ports[Com4].Clear := TRUE;
end; { of case }
end
else if ((LenStr > 3) AND (Str[3] = ':')) then
(*
* Set the address for one or more COM-ports
*)
begin
DecodeStr(Str,Com1,Com4);
end
else if ((LenStr > 4) AND (Str[4] = ':')) then
(*
* Set the address for -one- COM-port
*)
begin
case Str[3] of
'1': DecodeStr(Str,Com1,Com1);
'2': DecodeStr(Str,Com2,Com2);
'3': DecodeStr(Str,Com3,Com3);
'4': DecodeStr(Str,Com4,Com4);
end; { of case Str[3] }
end;
end; { of 'C' }
'D': if (NOT ChangeCom) AND (NOT ChangeLpt) then begin
Default := TRUE;
for p := IOPorts(0) to IOPorts(NumberOfPorts -1) do begin
Ports[p].Change := TRUE;
end;
end; { of 'D' }
'L': if (NOT Default) then begin
ChangeLpt := TRUE;
if (LenStr in [2,3]) AND
(Str[LenStr] in ['L','1','2','3']) then
(*
* Clear the address(') for one or more LPT-ports
*)
begin
case Str[LenStr] of
'L': for p := Lpt1 to Lpt3 do begin
Ports[p].Clear := TRUE;
end;
'1': Ports[Lpt1].Clear := TRUE;
'2': Ports[Lpt2].Clear := TRUE;
'3': Ports[Lpt3].Clear := TRUE;
end; { of case }
end
else if ((LenStr > 3) AND (Str[3] = ':')) then
(*
* Set the address for one or more LPT-ports
*)
begin
DecodeStr(Str,Lpt1,Lpt3);
end
else if ((LenStr > 4) AND (Str[4] = ':')) then
(*
* Set the address for -one- LPT-port
*)
begin
case Str[3] of
'1': DecodeStr(Str,Lpt1,Lpt1);
'2': DecodeStr(Str,Lpt2,Lpt2);
'3': DecodeStr(Str,Lpt3,Lpt3);
end; { of case Str[3] }
end;
end; { of 'L' }
'Q': Quiet := TRUE;
'V': begin
ReadPortsFromMemory;
Halt(0); { Error: none }
end; { of 'V' }
'?': begin
Help;
Halt(0); { Error: none }
end; { of '?' }
else begin
if (NOT Quiet) then WriteLn('Invalid option: ',Str[2]);
Halt(1); { Error: invalid option }
end;
end {of case}
else
begin
if (NOT Quiet) then WriteLn('Invalid switch: ',Str[1]);
Halt(2); { Error: invalid switch }
end;
end; { of for Count }
end; { of GetCommandLine }
(*
* Function : Main
*
* Abstract :
*
* Decisions :
*)
BEGIN
GetCommandLine;
WritePortsToMemory;
if NOT Quiet then ReadPortsFromMemory;
END. { of Main } |
unit uMain;
interface
procedure RestartService(const AServiceName: string; const AExeName: string);
procedure RestartJYAppUpdateService;
implementation
uses
Windows, Psapi, SysUtils, StrUtils;
//var
// strCurrPath: string;
{function GetCurrPath: string;
begin
result := ExtractFilePath(Application.ExeName);
end; }
{function WriteVBEFile: boolean;
var
F: TextFile;
begin
result := false;
try
AssignFile(F, Format('%sgetpids.vbe', [strCurrPath]));
ReWrite(F);
WriteLn(F, 'set fso=createobject("scripting.filesystemobject")');
WriteLn(F, Format('if (fso.fileexists("%s~pids.txt")) then', [strCurrPath]));
WriteLn(F, Format(' set file=fso.opentextfile("%s~pids.txt",2,true)', [strCurrPath]));
WriteLn(F, 'else');
WriteLn(F, Format(' set file=fso.createtextfile("%s~pids.txt",2,true)', [strCurrPath]));
WriteLn(F, 'end if');
WriteLn(F, 'wscript.echo "PID ProcessName"');
WriteLn(F, 'for each ps in getobject("winmgmts:\\.\root\cimv2:win32_process").instances_');
WriteLn(F, 'wscript.echo ps.handle&vbtab&ps.name');
WriteLn(F, 'file.writeline ps.handle&vbtab&ps.name');
WriteLn(F, 'next');
WriteLn(F, 'file.close');
CloseFile(F);
result := true;
except
end;
end; }
{function WriteBATFile: boolean;
var
F: TextFile;
s: string;
begin
result := false;
try
AssignFile(F, Format('%sgetpids.bat', [strCurrPath]));
ReWrite(F);
s := Format('"%sgetpids.vbe"', [strCurrPath]);
WriteLn(F, s);
CloseFile(F);
result := true;
except
end;
end;}
{function GetProcessPID(const AExeName: string): integer;
var
F: TextFile;
s: string;
begin
result := -1;
try
if not FileExists(Format('%s~pids.txt', [strCurrPath])) then exit;
AssignFile(F, Format('%s~pids.txt', [strCurrPath]));
Reset(F);
while not Eof(F) do
begin
ReadLn(F, s);
s := Trim(LowerCase(s));
if Pos(Trim(LowerCase(AExeName)), s) > 0 then
begin
result := StrToInt(LeftStr(s, Pos(' ', s)-1));
break;
end;
end;
except
end;
end; }
function GetExePID(const AExeName: string): int64;
var
aProcesses: array[0..1023] of LongWord;
cbNeeded: LongWord;
i: integer;
hProcess: THandle;
hMod: HModule;
BaseName: array[0..1023] of char;
strBaseName: string;
begin
result := -1;
if not EnumProcesses(@aProcesses[0], sizeof(aProcesses), cbNeeded) then exit;
for i:=0 to trunc(cbNeeded/sizeof(longword))-1 do
begin
if aProcesses[i] = 0 then continue;
hProcess := OpenProcess(PROCESS_QUERY_INFORMATION or PROCESS_VM_READ, FALSE, aProcesses[i]);
if hProcess > 0 then
begin
if EnumProcessModules(hProcess, @hMod, sizeof(hMod), cbNeeded) then
begin
ZeroMemory(@BaseName[0], 1024);
GetModuleBaseName(hProcess, hMod, @BaseName[0], sizeof(BaseName));
strBaseName := pchar(@BaseName[0]);
strBaseName := Trim(LowerCase(strBaseName));
if Pos(Trim(LowerCase(AExeName)), strBaseName) > 0 then
begin
result := aProcesses[i];
break;
end;
end;
end;
CloseHandle(hProcess);
end;
end;
procedure RestartService(const AServiceName: string; const AExeName: string);
var
pid: integer;
begin
{ if not WriteVBEFile then exit;
if not WriteBATFile then exit;
DeleteFile(Format('%s~pids.txt', [strCurrPath]));
if WinExec(pchar(Format('"%sgetpids.bat"', [strCurrPath])), SW_HIDE) <= 31 then exit;
pid := GetProcessPID(AExeName); }
pid := GetExePID(AExeName);
if pid > 0 then WinExec(PChar(format('ntsd -c q -p %d', [pid])), SW_HIDE);
sleep(3000);
WinExec(PChar(Format('net start %s', [AServiceName])), SW_HIDE);
end;
procedure RestartJYAppUpdateService;
begin
RestartService('jyappupdateservice', 'JYUpdateService.exe');
end;
//initialization
// strCurrPath := ExtractFilePath(Application.ExeName);
end.
|
unit iaUnitTest.TThreadedQueue.ExerciseQueue;
interface
uses
DUnitX.TestFramework,
System.Generics.Collections,
iaExample.ProducerThread,
iaExample.ConsumerThread;
type
[TestFixture]
TiaTestMultiThreadedProducerAndConsumer = class(TObject)
private
fConsumers:Array of TExampleLinkedConsumerThread;
fProducers:Array of TExampleLinkedProducerThread;
fTasksConsumed:Integer;
fTasksUnderflow:Integer;
fTasksProduced:Integer;
fTasksOverflow:Integer;
fQueueProducerFailures:Integer;
fQueueConsumerFailures:Integer;
protected
procedure CreateConsumers(const pConsumerThreadCount:Integer; const pTaskQueue:TThreadedQueue<TObject>; const pPopTimeout:Cardinal);
procedure CreateProducers(const pProducerThreadCount:Integer; const pTaskQueue:TThreadedQueue<TObject>; const pPushTimeout:Cardinal; const pTaskCount:Integer);
procedure FreeConsumers();
procedure FreeProducers();
public
[Test]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1,0,0,1,1,1')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1,0,0,1,1,2')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1,0,0,1,1,3')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1,0,0,1,1,100000')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1,0,0,2,2,1')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1,0,0,2,2,2')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1,0,0,2,2,3')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1,0,0,2,2,100000')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1,0,0,40,40,1')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1,0,0,40,40,2')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1,0,0,40,40,3')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1,0,0,40,40,100000')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1,0,0,1,40,1')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1,0,0,1,40,2')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1,0,0,1,40,3')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1,0,0,1,40,100000')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1,0,0,2,40,1')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1,0,0,2,40,2')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1,0,0,2,40,3')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1,0,0,2,40,100000')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1,0,0,40,1,1')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1,0,0,40,1,2')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1,0,0,40,1,3')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1,0,0,40,1,100000')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1,0,0,40,2,1')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1,0,0,40,2,2')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1,0,0,40,2,3')]
[TestCase('1 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1,0,0,40,2,100000')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1,1,1,1,1,1')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1,1,1,1,1,2')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1,1,1,1,1,3')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1,1,1,1,1,100000')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1,1,1,2,2,1')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1,1,1,2,2,2')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1,1,1,2,2,3')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1,1,1,2,2,100000')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1,1,1,40,40,1')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1,1,1,40,40,2')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1,1,1,40,40,3')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1,1,1,40,40,100000')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1,1,1,1,40,1')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1,1,1,1,40,2')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1,1,1,1,40,3')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1,1,1,1,40,100000')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1,1,1,2,40,1')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1,1,1,2,40,2')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1,1,1,2,40,3')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1,1,1,2,40,100000')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1,1,1,40,1,1')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1,1,1,40,1,2')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1,1,1,40,1,3')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1,1,1,40,1,100000')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1,1,1,40,2,1')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1,1,1,40,2,2')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1,1,1,40,2,3')]
[TestCase('1 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1,1,1,40,2,100000')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1,1000,1000,1,1,1')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1,1000,1000,1,1,2')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1,1000,1000,1,1,3')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1,1000,1000,1,1,100000')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1,1000,1000,2,2,1')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1,1000,1000,2,2,2')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1,1000,1000,2,2,3')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1,1000,1000,2,2,100000')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1,1000,1000,40,40,1')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1,1000,1000,40,40,2')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1,1000,1000,40,40,3')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1,1000,1000,40,40,100000')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1,1000,1000,1,40,1')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1,1000,1000,1,40,2')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1,1000,1000,1,40,3')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1,1000,1000,1,40,100000')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1,1000,1000,2,40,1')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1,1000,1000,2,40,2')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1,1000,1000,2,40,3')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1,1000,1000,2,40,100000')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1,1000,1000,40,1,1')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1,1000,1000,40,1,2')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1,1000,1000,40,1,3')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1,1000,1000,40,1,100000')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1,1000,1000,40,2,1')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1,1000,1000,40,2,2')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1,1000,1000,40,2,3')]
[TestCase('1 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1,1000,1000,40,2,100000')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1,$FFFFFFFF,$FFFFFFFF,1,1,1')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1,$FFFFFFFF,$FFFFFFFF,1,1,2')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1,$FFFFFFFF,$FFFFFFFF,1,1,3')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1,$FFFFFFFF,$FFFFFFFF,1,1,100000')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1,$FFFFFFFF,$FFFFFFFF,2,2,1')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1,$FFFFFFFF,$FFFFFFFF,2,2,2')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1,$FFFFFFFF,$FFFFFFFF,2,2,3')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1,$FFFFFFFF,$FFFFFFFF,2,2,100000')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1,$FFFFFFFF,$FFFFFFFF,40,40,1')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1,$FFFFFFFF,$FFFFFFFF,40,40,2')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1,$FFFFFFFF,$FFFFFFFF,40,40,3')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1,$FFFFFFFF,$FFFFFFFF,40,40,100000')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1,$FFFFFFFF,$FFFFFFFF,1,40,1')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1,$FFFFFFFF,$FFFFFFFF,1,40,2')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1,$FFFFFFFF,$FFFFFFFF,1,40,3')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1,$FFFFFFFF,$FFFFFFFF,1,40,100000')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1,$FFFFFFFF,$FFFFFFFF,2,40,1')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1,$FFFFFFFF,$FFFFFFFF,2,40,2')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1,$FFFFFFFF,$FFFFFFFF,2,40,3')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1,$FFFFFFFF,$FFFFFFFF,2,40,100000')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1,$FFFFFFFF,$FFFFFFFF,40,1,1')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1,$FFFFFFFF,$FFFFFFFF,40,1,2')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1,$FFFFFFFF,$FFFFFFFF,40,1,3')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1,$FFFFFFFF,$FFFFFFFF,40,1,100000')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1,$FFFFFFFF,$FFFFFFFF,40,2,1')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1,$FFFFFFFF,$FFFFFFFF,40,2,2')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1,$FFFFFFFF,$FFFFFFFF,40,2,3')]
[TestCase('1 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1,$FFFFFFFF,$FFFFFFFF,40,2,100000')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','10,0,0,1,1,1')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','10,0,0,1,1,2')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','10,0,0,1,1,3')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','10,0,0,1,1,100000')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','10,0,0,2,2,1')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','10,0,0,2,2,2')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','10,0,0,2,2,3')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','10,0,0,2,2,100000')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','10,0,0,40,40,1')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','10,0,0,40,40,2')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','10,0,0,40,40,3')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','10,0,0,40,40,100000')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','10,0,0,1,40,1')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','10,0,0,1,40,2')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','10,0,0,1,40,3')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','10,0,0,1,40,100000')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','10,0,0,2,40,1')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','10,0,0,2,40,2')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','10,0,0,2,40,3')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','10,0,0,2,40,100000')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','10,0,0,40,1,1')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','10,0,0,40,1,2')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','10,0,0,40,1,3')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','10,0,0,40,1,100000')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','10,0,0,40,2,1')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','10,0,0,40,2,2')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','10,0,0,40,2,3')]
[TestCase('10 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','10,0,0,40,2,100000')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','10,1,1,1,1,1')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','10,1,1,1,1,2')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','10,1,1,1,1,3')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','10,1,1,1,1,100000')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','10,1,1,2,2,1')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','10,1,1,2,2,2')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','10,1,1,2,2,3')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','10,1,1,2,2,100000')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','10,1,1,40,40,1')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','10,1,1,40,40,2')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','10,1,1,40,40,3')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','10,1,1,40,40,100000')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','10,1,1,1,40,1')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','10,1,1,1,40,2')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','10,1,1,1,40,3')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','10,1,1,1,40,100000')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','10,1,1,2,40,1')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','10,1,1,2,40,2')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','10,1,1,2,40,3')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','10,1,1,2,40,100000')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','10,1,1,40,1,1')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','10,1,1,40,1,2')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','10,1,1,40,1,3')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','10,1,1,40,1,100000')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','10,1,1,40,2,1')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','10,1,1,40,2,2')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','10,1,1,40,2,3')]
[TestCase('10 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','10,1,1,40,2,100000')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','10,1000,1000,1,1,1')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','10,1000,1000,1,1,2')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','10,1000,1000,1,1,3')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','10,1000,1000,1,1,100000')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','10,1000,1000,2,2,1')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','10,1000,1000,2,2,2')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','10,1000,1000,2,2,3')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','10,1000,1000,2,2,100000')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','10,1000,1000,40,40,1')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','10,1000,1000,40,40,2')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','10,1000,1000,40,40,3')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','10,1000,1000,40,40,100000')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','10,1000,1000,1,40,1')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','10,1000,1000,1,40,2')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','10,1000,1000,1,40,3')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','10,1000,1000,1,40,100000')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','10,1000,1000,2,40,1')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','10,1000,1000,2,40,2')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','10,1000,1000,2,40,3')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','10,1000,1000,2,40,100000')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','10,1000,1000,40,1,1')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','10,1000,1000,40,1,2')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','10,1000,1000,40,1,3')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','10,1000,1000,40,1,100000')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','10,1000,1000,40,2,1')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','10,1000,1000,40,2,2')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','10,1000,1000,40,2,3')]
[TestCase('10 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','10,1000,1000,40,2,100000')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','10,$FFFFFFFF,$FFFFFFFF,1,1,1')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','10,$FFFFFFFF,$FFFFFFFF,1,1,2')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','10,$FFFFFFFF,$FFFFFFFF,1,1,3')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','10,$FFFFFFFF,$FFFFFFFF,1,1,100000')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','10,$FFFFFFFF,$FFFFFFFF,2,2,1')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','10,$FFFFFFFF,$FFFFFFFF,2,2,2')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','10,$FFFFFFFF,$FFFFFFFF,2,2,3')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','10,$FFFFFFFF,$FFFFFFFF,2,2,100000')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','10,$FFFFFFFF,$FFFFFFFF,40,40,1')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','10,$FFFFFFFF,$FFFFFFFF,40,40,2')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','10,$FFFFFFFF,$FFFFFFFF,40,40,3')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','10,$FFFFFFFF,$FFFFFFFF,40,40,100000')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','10,$FFFFFFFF,$FFFFFFFF,1,40,1')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','10,$FFFFFFFF,$FFFFFFFF,1,40,2')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','10,$FFFFFFFF,$FFFFFFFF,1,40,3')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','10,$FFFFFFFF,$FFFFFFFF,1,40,100000')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','10,$FFFFFFFF,$FFFFFFFF,2,40,1')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','10,$FFFFFFFF,$FFFFFFFF,2,40,2')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','10,$FFFFFFFF,$FFFFFFFF,2,40,3')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','10,$FFFFFFFF,$FFFFFFFF,2,40,100000')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','10,$FFFFFFFF,$FFFFFFFF,40,1,1')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','10,$FFFFFFFF,$FFFFFFFF,40,1,2')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','10,$FFFFFFFF,$FFFFFFFF,40,1,3')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','10,$FFFFFFFF,$FFFFFFFF,40,1,100000')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','10,$FFFFFFFF,$FFFFFFFF,40,2,1')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','10,$FFFFFFFF,$FFFFFFFF,40,2,2')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','10,$FFFFFFFF,$FFFFFFFF,40,2,3')]
[TestCase('10 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','10,$FFFFFFFF,$FFFFFFFF,40,2,100000')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1000,0,0,1,1,1')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1000,0,0,1,1,2')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1000,0,0,1,1,3')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1000,0,0,1,1,100000')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1000,0,0,2,2,1')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1000,0,0,2,2,2')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1000,0,0,2,2,3')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1000,0,0,2,2,100000')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1000,0,0,40,40,1')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1000,0,0,40,40,2')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1000,0,0,40,40,3')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1000,0,0,40,40,100000')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1000,0,0,1,40,1')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1000,0,0,1,40,2')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1000,0,0,1,40,3')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1000,0,0,1,40,100000')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1000,0,0,2,40,1')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1000,0,0,2,40,2')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1000,0,0,2,40,3')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1000,0,0,2,40,100000')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1000,0,0,40,1,1')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1000,0,0,40,1,2')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1000,0,0,40,1,3')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1000,0,0,40,1,100000')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1000,0,0,40,2,1')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1000,0,0,40,2,2')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1000,0,0,40,2,3')]
[TestCase('1000 Depth, Zero Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1000,0,0,40,2,100000')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1000,1,1,1,1,1')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1000,1,1,1,1,2')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1000,1,1,1,1,3')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1000,1,1,1,1,100000')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1000,1,1,2,2,1')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1000,1,1,2,2,2')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1000,1,1,2,2,3')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1000,1,1,2,2,100000')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1000,1,1,40,40,1')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1000,1,1,40,40,2')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1000,1,1,40,40,3')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1000,1,1,40,40,100000')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1000,1,1,1,40,1')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1000,1,1,1,40,2')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1000,1,1,1,40,3')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1000,1,1,1,40,100000')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1000,1,1,2,40,1')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1000,1,1,2,40,2')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1000,1,1,2,40,3')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1000,1,1,2,40,100000')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1000,1,1,40,1,1')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1000,1,1,40,1,2')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1000,1,1,40,1,3')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1000,1,1,40,1,100000')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1000,1,1,40,2,1')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1000,1,1,40,2,2')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1000,1,1,40,2,3')]
[TestCase('1000 Depth, 1 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1000,1,1,40,2,100000')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1000,1000,0,1,1,1')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1000,1000,0,1,1,2')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1000,1000,0,1,1,3')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1000,1000,0,1,1,100000')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1000,1000,0,2,2,1')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1000,1000,0,2,2,2')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1000,1000,0,2,2,3')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1000,1000,0,2,2,100000')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1000,1000,0,40,40,1')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1000,1000,0,40,40,2')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1000,1000,0,40,40,3')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1000,1000,0,40,40,100000')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1000,1000,0,1,40,1')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1000,1000,0,1,40,2')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1000,1000,0,1,40,3')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1000,1000,0,1,40,100000')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1000,1000,0,2,40,1')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1000,1000,0,2,40,2')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1000,1000,0,2,40,3')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1000,1000,0,2,40,100000')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1000,1000,0,40,1,1')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1000,1000,0,40,1,2')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1000,1000,0,40,1,3')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1000,1000,0,40,1,100000')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1000,1000,0,40,2,1')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1000,1000,0,40,2,2')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1000,1000,0,40,2,3')]
[TestCase('1000 Depth, 1000 Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1000,1000,0,40,2,100000')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 1 Task','1000,$FFFFFFFF,$FFFFFFFF,1,1,1')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 2 Task','1000,$FFFFFFFF,$FFFFFFFF,1,1,2')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 3 Task','1000,$FFFFFFFF,$FFFFFFFF,1,1,3')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer/Producer Thread, 100000 Task','1000,$FFFFFFFF,$FFFFFFFF,1,1,100000')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 1 Task','1000,$FFFFFFFF,$FFFFFFFF,2,2,1')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 2 Task','1000,$FFFFFFFF,$FFFFFFFF,2,2,2')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 3 Task','1000,$FFFFFFFF,$FFFFFFFF,2,2,3')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer/Producer Thread, 100000 Task','1000,$FFFFFFFF,$FFFFFFFF,2,2,100000')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 1 Task','1000,$FFFFFFFF,$FFFFFFFF,40,40,1')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 2 Task','1000,$FFFFFFFF,$FFFFFFFF,40,40,2')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 3 Task','1000,$FFFFFFFF,$FFFFFFFF,40,40,3')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer/Producer Thread, 100000 Task','1000,$FFFFFFFF,$FFFFFFFF,40,40,100000')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 1 Task','1000,$FFFFFFFF,$FFFFFFFF,1,40,1')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 2 Task','1000,$FFFFFFFF,$FFFFFFFF,1,40,2')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 3 Task','1000,$FFFFFFFF,$FFFFFFFF,1,40,3')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 1 Consumer 40 Producer Thread, 100000 Task','1000,$FFFFFFFF,$FFFFFFFF,1,40,100000')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 1 Task','1000,$FFFFFFFF,$FFFFFFFF,2,40,1')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 2 Task','1000,$FFFFFFFF,$FFFFFFFF,2,40,2')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 3 Task','1000,$FFFFFFFF,$FFFFFFFF,2,40,3')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 2 Consumer 40 Producer Thread, 100000 Task','1000,$FFFFFFFF,$FFFFFFFF,2,40,100000')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 1 Task','1000,$FFFFFFFF,$FFFFFFFF,40,1,1')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 2 Task','1000,$FFFFFFFF,$FFFFFFFF,40,1,2')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 3 Task','1000,$FFFFFFFF,$FFFFFFFF,40,1,3')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 1 Producer Thread, 100000 Task','1000,$FFFFFFFF,$FFFFFFFF,40,1,100000')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 1 Task','1000,$FFFFFFFF,$FFFFFFFF,40,2,1')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 2 Task','1000,$FFFFFFFF,$FFFFFFFF,40,2,2')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 3 Task','1000,$FFFFFFFF,$FFFFFFFF,40,2,3')]
[TestCase('1000 Depth, Infinite Push/Pop Timeout, 40 Consumer 2 Producer Thread, 100000 Task','1000,$FFFFFFFF,$FFFFFFFF,40,2,100000')]
procedure ExerciseQueue(const pQueueDepth:Integer; const pPushTimeout, pPopTimeout:Cardinal; const pConsumerThreadCount, pProducerThreadCount, pTaskCount:Integer);
end;
implementation
uses
System.SysUtils,
System.Classes,
System.Threading,
iaTestSupport.Log;
procedure TiaTestMultiThreadedProducerAndConsumer.ExerciseQueue(const pQueueDepth:Integer; const pPushTimeout, pPopTimeout:Cardinal; const pConsumerThreadCount, pProducerThreadCount, pTaskCount:Integer);
var
vQueue:TThreadedQueue<TObject>;
vProducing:Boolean;
vProducer:TExampleLinkedProducerThread;
vTasksPerThread:Integer;
begin
LogIt(Format('Test started: Queue Depth: %d Push Timeout: %d Pop Timeout: %d ConsumerThreads: %d ProducerThreads %d Tasks: %d',[pQueueDepth, pPushTimeout, pPopTimeout, pConsumerThreadCount, pProducerThreadCount, pTaskCount]));
if pQueueDepth = 0 then
begin
Assert.Fail('Queue Depth cannot be zero');
end;
if pProducerThreadCount = 0 then
begin
Assert.Fail('Producer Thread Count cannot be zero');
end;
vQueue := TThreadedQueue<TObject>.Create(pQueueDepth, pPushTimeout, pPopTimeout);
try
vTasksPerThread := pTaskCount div pProducerThreadCount;
if vTasksPerThread = 0 then
begin
vTasksPerThread := 1;
end;
CreateConsumers(pConsumerThreadCount, vQueue, pPopTimeout);
CreateProducers(pProducerThreadCount, vQueue, pPushTimeout, vTasksPerThread);
LogIt(Format('Producing %d tasks', [vTasksPerThread*pProducerThreadCount]));
vProducing := True;
while vProducing do
begin
vProducing := False;
for vProducer in fProducers do
begin
if vProducer.ThreadState = TProducerState.ProducerWorking then
begin
vProducing := True;
end;
end;
TThread.CurrentThread.Yield;
end;
LogIt('Production completed, waiting for consumers to finish');
while vQueue.QueueSize <> 0 do
begin
TThread.CurrentThread.Yield;
end;
LogIt('Shutting down queue');
vQueue.DoShutDown();
FreeProducers();
FreeConsumers();
Assert.AreEqual(fTasksProduced, fTasksConsumed, 'Did not consume as many tasks produced');
Assert.AreEqual(fQueueProducerFailures, 0, 'Queue producer errors not zero');
Assert.AreEqual(fQueueConsumerFailures, 0, 'Queue consumer errors not zero');
finally
LogIt('Freeing queue');
vQueue.Free();
end;
LogIt('Test completed');
end;
procedure TiaTestMultiThreadedProducerAndConsumer.CreateConsumers(const pConsumerThreadCount:Integer; const pTaskQueue:TThreadedQueue<TObject>; const pPopTimeout:Cardinal);
var
i:Integer;
begin
LogIt(Format('Creating %d consumer threads', [pConsumerThreadCount]));
fTasksConsumed := 0;
fTasksUnderflow := 0;
fQueueConsumerFailures := 0;
SetLength(fConsumers, pConsumerThreadCount);
for i := 0 to pConsumerThreadCount-1 do
begin
fConsumers[i] := TExampleLinkedConsumerThread.Create(pTaskQueue, pPopTimeout);
end;
end;
procedure TiaTestMultiThreadedProducerAndConsumer.CreateProducers(const pProducerThreadCount:Integer; const pTaskQueue:TThreadedQueue<TObject>; const pPushTimeout:Cardinal; const pTaskCount:Integer);
var
i:Integer;
begin
LogIt(Format('Creating %d producer threads', [pProducerThreadCount]));
fTasksProduced := 0;
fTasksOverflow := 0;
fQueueProducerFailures := 0;
SetLength(fProducers, pProducerThreadCount);
for i := 0 to pProducerThreadCount-1 do
begin
fProducers[i] := TExampleLinkedProducerThread.Create(pTaskQueue, pPushTimeout, pTaskCount);
end;
end;
procedure TiaTestMultiThreadedProducerAndConsumer.FreeConsumers();
var
vThread:TExampleLinkedProducerThread;
begin
LogIt('Freeing producer threads');
for vThread in fProducers do
begin
Inc(fTasksProduced, vThread.TasksProduced);
Inc(fTasksOverflow, vThread.TasksOverflow);
Inc(fQueueProducerFailures, vThread.QueueFailures);
vThread.Free();
end;
end;
procedure TiaTestMultiThreadedProducerAndConsumer.FreeProducers();
var
vThread:TExampleLinkedConsumerThread;
begin
LogIt('Freeing consumer threads');
for vThread in fConsumers do
begin
Inc(fTasksConsumed, vThread.TasksConsumed);
Inc(fTasksUnderflow, vThread.TasksUnderflow);
Inc(fQueueConsumerFailures, vThread.QueueFailures);
vThread.Free();
end;
end;
end.
|
unit mainform;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.Menus, Vcl.Grids, Vcl.ValEdit, Vcl.ComCtrls, Vcl.ExtCtrls,
Ap, mlpbase, calc_utils;
type
TMainFormExtrapolation = class(TForm)
MainMenu: TMainMenu;
NInsertData: TMenuItem;
NInsertResults: TMenuItem;
NTeaching: TMenuItem;
NSolve: TMenuItem;
NPreferences: TMenuItem;
NHelp: TMenuItem;
pcData: TPageControl;
tsData: TTabSheet;
tsPrediction: TTabSheet;
NInsertAtPrediction: TMenuItem;
tsPreferences: TTabSheet;
vleNeuroPreferences: TValueListEditor;
sgDataTeachingSrc: TStringGrid;
Splitter1: TSplitter;
sgDataTeachingResult: TStringGrid;
sgDataPredictionSrc: TStringGrid;
Splitter2: TSplitter;
sgDataPredictionResult: TStringGrid;
procedure NInsertDataClick(Sender: TObject);
procedure NInsertResultsClick(Sender: TObject);
procedure NInsertAtPredictionClick(Sender: TObject);
procedure NTeachingClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure FormShow(Sender: TObject);
procedure NSolveClick(Sender: TObject);
private
{ Private declarations }
HNetwork: MultiLayerPerceptron;
HOptions: TCalcNeuroOptions;
public
{ Public declarations }
procedure UpdateNeuroOptionsFromForm;
end;
var
MainFormExtrapolation: TMainFormExtrapolation;
implementation
uses Math, ClipBrd;
{$R *.dfm}
procedure TMainFormExtrapolation.FormClose(Sender: TObject; var Action: TCloseAction);
begin
MLPFree(HNetwork);
end;
procedure TMainFormExtrapolation.FormShow(Sender: TObject);
begin
pcData.TabIndex := 0;
end;
procedure TMainFormExtrapolation.NInsertAtPredictionClick(Sender: TObject);
begin
Clipboard.Open;
try
InsertDataFromClipboardToGrid(Clipboard.AsText, sgDataPredictionSrc);
finally
Clipboard.Close;
end;
end;
procedure TMainFormExtrapolation.NInsertDataClick(Sender: TObject);
begin
Clipboard.Open;
try
InsertDataFromClipboardToGrid(Clipboard.AsText, sgDataTeachingSrc);
finally
Clipboard.Close;
end;
end;
procedure TMainFormExtrapolation.NInsertResultsClick(Sender: TObject);
begin
Clipboard.Open;
try
InsertDataFromClipboardToGrid(Clipboard.AsText, sgDataTeachingResult);
finally
Clipboard.Close;
end;
end;
procedure TMainFormExtrapolation.NSolveClick(Sender: TObject);
var
row, col: Integer;
lX: TReal1DArray;
lY: TReal1DArray;
begin
SetLength(lX, sgDataPredictionSrc.ColCount);
SetLength(lY, sgDataTeachingResult.ColCount);
sgDataPredictionResult.ColCount := sgDataTeachingResult.ColCount;
sgDataPredictionResult.RowCount := sgDataPredictionSrc.RowCount;
try
for row := 0 to sgDataPredictionSrc.RowCount - 1 do
begin
for col := 0 to sgDataPredictionSrc.ColCount - 1 do
lX[col] := StrToFloatEx(sgDataPredictionSrc.Cells[col, row]);
NeuroRegression(HNetwork, lX, lY);
for col := 0 to sgDataPredictionResult.ColCount - 1 do
sgDataPredictionResult.Cells[col, row] := FloatToStr(lY[col]);
end;
finally
SetLength(lX, 0);
SetLength(lY, 0);
end;
end;
procedure TMainFormExtrapolation.NTeachingClick(Sender: TObject);
var
zlXY: TReal2DArray;
begin
try
ConstructMatrixFromGrid(sgDataTeachingSrc, sgDataTeachingResult, zlXY);
UpdateNeuroOptionsFromForm;
HOptions.lPoints := Length(zlXY);
HOptions.Layer1PtsCount := sgDataTeachingSrc.ColCount;
HOptions.OutPtsCount := sgDataTeachingResult.ColCount;
CalcNeuroMatrix(HOptions, zlXY, HNetwork);
finally
SetLength(zlXY, 0);
end;
end;
procedure TMainFormExtrapolation.UpdateNeuroOptionsFromForm;
begin
HOptions.lMaxIts := StrToIntDef(vleNeuroPreferences.Values['Максимум итераций'], 300);
HOptions.lMaxStep := StrToFloatDef(vleNeuroPreferences.Values['Максимальный шаг'], 0.001);
HOptions.lRestarts := StrToIntDef(vleNeuroPreferences.Values['Рестартов'], 1000);
HOptions.lDecay := StrToFloatDef(vleNeuroPreferences.Values['Максимальная ошибка'], 0.001);
HOptions.lPoints := 0;
HOptions.LayerCount := StrToIntDef(vleNeuroPreferences.Values['Слоёв'], 3);
HOptions.Layer1PtsCount := 0;
HOptions.Layer2PtsCount := StrToIntDef(vleNeuroPreferences.Values['Нейронов во втором слое'], 8);
HOptions.Layer3PtsCount := StrToIntDef(vleNeuroPreferences.Values['Нейронов во третьем слое'], 8);
HOptions.OutPtsCount := 0;
HOptions.IsClassificator := false;
end;
end.
|
unit UnContasPagarListaRegistrosView;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, Grids, DBGrids, StdCtrls, JvExControls, JvButton, DB,
JvTransparentButton, ExtCtrls,
{ Fluente }
Util, DataUtil, UnModelo, UnContasPagarListaRegistrosModelo, Componentes,
UnAplicacao, JvExDBGrids, JvDBGrid, JvDBUltimGrid;
type
TContasPagarListaRegistrosView = class(TForm, ITela)
pnlTitulo: TPanel;
btnIncluir: TJvTransparentButton;
btnMenu: TJvTransparentButton;
pnlFiltro: TPanel;
EdtContaPagar: TEdit;
gContasPagar: TJvDBUltimGrid;
procedure EdtContaPagarChange(Sender: TObject);
procedure btnIncluirClick(Sender: TObject);
procedure gContasPagarDblClick(Sender: TObject);
private
FControlador: IResposta;
FContasPagarListaRegistrosModelo: TContasPagarListaRegistrosModelo;
public
function Controlador(const Controlador: IResposta): ITela;
function Descarregar: ITela;
function Modelo(const Modelo: TModelo): ITela;
function Preparar: ITela;
function ExibirTela: Integer;
end;
implementation
{$R *.dfm}
{ TContaPagarListaRegistrosView }
function TContasPagarListaRegistrosView.Controlador(
const Controlador: IResposta): ITela;
begin
Self.FControlador := Controlador;
Result := Self;
end;
function TContasPagarListaRegistrosView.Descarregar: ITela;
begin
Self.FControlador := nil;
Self.FContasPagarListaRegistrosModelo := nil;
Result := Self;
end;
function TContasPagarListaRegistrosView.ExibirTela: Integer;
begin
Result := Self.ShowModal;
end;
function TContasPagarListaRegistrosView.Modelo(
const Modelo: TModelo): ITela;
begin
Self.FContasPagarListaRegistrosModelo :=
(Modelo as TContasPagarListaRegistrosModelo);
Result := Self;
end;
function TContasPagarListaRegistrosView.Preparar: ITela;
begin
Self.gContasPagar.DataSource :=
Self.FContasPagarListaRegistrosModelo.DataSource;
Result := Self;
end;
procedure TContasPagarListaRegistrosView.EdtContaPagarChange(
Sender: TObject);
begin
if Self.EdtContaPagar.Text = '' then
Self.FContasPagarListaRegistrosModelo.Carregar
else
Self.FContasPagarListaRegistrosModelo.CarregarPor(
Criterio.Campo('FORN_NOME').como(Self.EdtContaPagar.Text).obter());
end;
procedure TContasPagarListaRegistrosView.btnIncluirClick(Sender: TObject);
var
_chamada: TChamada;
_parametros: TMap;
begin
_parametros := Self.FContasPagarListaRegistrosModelo.Parametros;
_parametros
.Gravar('acao', Ord(adrIncluir));
_chamada := TChamada.Create
.Chamador(Self)
.Parametros(_parametros);
Self.FControlador.Responder(_chamada);
end;
procedure TContasPagarListaRegistrosView.gContasPagarDblClick(
Sender: TObject);
var
_chamada: TChamada;
_dataSet: TDataSet;
begin
_dataSet := Self.FContasPagarListaRegistrosModelo.DataSet;
_chamada := TChamada.Create
.Chamador(Self)
.Parametros(TMap.Create
.Gravar('acao', Ord(adrCarregar))
.Gravar('oid', _dataSet.FieldByName('tit_oid').AsString)
);
Self.FControlador.Responder(_chamada)
end;
end.
|
{*******************************************************}
{ }
{ Borland Delphi Visual Component Library }
{ Remote Data Module support }
{ }
{ Copyright (c) 1997,98 Inprise Corporation }
{ }
{*******************************************************}
unit DataBkr;
interface
uses Classes, ActiveX, StdVcl, Forms;
type
{ TRemoteDataModule }
TRemoteDataModule = class(TDataModule, IDataBroker)
end;
{ IDataBroker support }
procedure EnumIProviderProps(TypeInfo: ITypeInfo; PropNames: TStrings);
function VarArrayFromStrings(Strings: TStrings): Variant;
implementation
uses ComObj;
{ IDataBroker support }
function VarArrayFromStrings(Strings: TStrings): Variant;
var
I: Integer;
begin
Result := Null;
if Strings.Count > 0 then
begin
Result := VarArrayCreate([0, Strings.Count - 1], varOleStr);
for I := 0 to Strings.Count - 1 do Result[I] := WideString(Strings[I]);
end;
end;
procedure EnumIProviderProps(TypeInfo: ITypeInfo; PropNames: TStrings);
procedure SaveName(const TypeInfo: ITypeInfo; Id: Integer);
var
Name: WideString;
begin
OleCheck(TypeInfo.GetDocumentation(Id, @Name, nil, nil, nil));
PropNames.Add(Name);
end;
function IsProviderProp(const TypeInfo: ITypeInfo; TypeDesc: PTypeDesc): Boolean;
var
RefInfo: ITypeInfo;
RefAttr: PTypeAttr;
begin
Result := False;
if TypeDesc.vt = VT_PTR then
begin
TypeDesc := TypeDesc.ptdesc;
if TypeDesc.vt <> VT_USERDEFINED then Exit;
OleCheck(TypeInfo.GetRefTypeInfo(TypeDesc.hreftype, RefInfo));
OleCheck(RefInfo.GetTypeAttr(RefAttr));
try
Result := IsEqualGUID(RefAttr.guid, IProvider);
finally
RefInfo.ReleaseTypeAttr(RefAttr);
end;
end;
end;
var
I: Integer;
TypeAttr: PTypeAttr;
FuncDesc: PFuncDesc;
VarDesc: PVarDesc;
TI: ITypeInfo;
RefType: HRefType;
begin
OleCheck(TypeInfo.GetTypeAttr(TypeAttr));
try
if (TypeAttr.typekind = TKIND_DISPATCH)
and (TypeAttr.wTypeFlags and TYPEFLAG_FDUAL <> 0) then
begin
OleCheck(TypeInfo.GetRefTypeOfImplType(-1, RefType));
OleCheck(TypeInfo.GetRefTypeInfo(RefType, TI));
end
else
TI := TypeInfo;
finally
TypeInfo.ReleaseTypeAttr(TypeAttr);
end;
OleCheck(TI.GetTypeAttr(TypeAttr));
try
for I := 0 to TypeAttr.cVars - 1 do
begin
OleCheck(TypeInfo.GetVarDesc(I, VarDesc));
try
if IsProviderProp(TI, @VarDesc.elemdescVar.tdesc) then
SaveName(TI, VarDesc.memid);
finally
TI.ReleaseVarDesc(VarDesc);
end;
end;
for I := 0 to TypeAttr.cFuncs - 1 do
begin
OleCheck(TI.GetFuncDesc(I, FuncDesc));
try
if (FuncDesc.invkind = INVOKE_PROPERTYGET) then
begin
if TypeAttr.TypeKind = TKIND_INTERFACE then
begin
if (FuncDesc.cParams > 0) and
(FuncDesc.lprgelemdescParam[0].tdesc.vt = VT_PTR) and
(IsProviderProp(TI, FuncDesc.lprgelemdescParam[0].tdesc.ptdesc)) then
SaveName(TI, FuncDesc.memid);
end
else if IsProviderProp(TI, @FuncDesc.elemdescFunc.tdesc) then
SaveName(TI, FuncDesc.memid);
end;
finally
TI.ReleaseFuncDesc(FuncDesc);
end;
end;
finally
TI.ReleaseTypeAttr(TypeAttr);
end;
end;
function GetProviderNamesFromObject(Component: TComponent): Variant;
var
VCLComObject: IVCLComObject;
TypeInfo: ITypeInfo;
Count: Integer;
ProviderNames: TStrings;
begin
Result := Null;
VCLComObject := Component.ComObject as IVCLComObject;
OleCheck(VCLComObject.GetTypeInfoCount(Count));
if Count > 0 then
begin
ProviderNames := TStringList.Create;
try
OleCheck(VCLComObject.GetTypeInfo(0, 0, TypeInfo));
EnumIProviderProps(TypeInfo, ProviderNames);
Result := VarArrayFromStrings(ProviderNames);
finally
ProviderNames.Free;
end;
end;
end;
procedure RegisterAsDataBroker(Register: Boolean; const ClassID, ProgID: string);
begin
if Register then
CreateRegKey('CLSID\' + ClassID + '\Borland DataBroker', '', '') else
DeleteRegKey('CLSID\' + ClassID + '\Borland DataBroker');
end;
initialization
Forms.GetDataModuleProviderNames := GetProviderNamesFromObject;
Forms.UpdateDataModuleRegistry := RegisterAsDataBroker;
end.
|
unit uQuoteCommandHandler;
interface
uses uCommandHandler, uTokenizer, dmConnection;
type
TQuoteCommandHandler = class(TCommandHandler)
function HandleCommand(const AConnection: TConnectionData; const ATarget: string; const ATokenizer: TTokenizer): string; override;
end;
implementation
uses SysUtils;
{ TQuoteCommandHandler }
function TQuoteCommandHandler.HandleCommand(const AConnection: TConnectionData;
const ATarget: string; const ATokenizer: TTokenizer): string;
var
Line: string;
begin
if not ATokenizer.HasMoreTokens then
Exit;
Line := ATokenizer.NextToken;
while ATokenizer.HasMoreTokens do
Line := Line + ' ' + ATokenizer.NextToken;
AConnection.SendRaw(Line);
end;
initialization
TCommandHandlerFactory.GetInstance.RegisterClass('/quote', TQuoteCommandHandler);
end.
|
unit UnitFormInterrogate;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics, System.Generics.Collections,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.Grids, stringgridutils,
stringutils, System.ImageList, Vcl.ImgList, UnitFormCurrentParty;
type
TCommTransaction = record
Request: string;
Response: string;
Port: string;
Duration: string;
Ok: boolean;
end;
TFormInterrogate = class(TForm)
StringGrid1: TStringGrid;
procedure StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure FormCreate(Sender: TObject);
procedure StringGrid1DblClick(Sender: TObject);
procedure FormResize(Sender: TObject);
private
{ Private declarations }
FOk: TList<boolean>;
public
{ Public declarations }
procedure setupColsWidths;
procedure AddCommTransaction(C: TCommTransaction);
procedure AddLine(AComport, ARequest, AResponse: string; Ok: boolean);
end;
var
FormInterrogate: TFormInterrogate;
implementation
uses myutils, dateutils, UnitFormPopup;
{$R *.dfm}
procedure TFormInterrogate.FormCreate(Sender: TObject);
var
i: Integer;
begin
with StringGrid1 do
begin
ColCount := 4;
RowCount := 1;
FixedCols := 0;
FixedRows := 0;
end;
FOk := TList<boolean>.create;
FOk.Add(true);
end;
procedure TFormInterrogate.FormResize(Sender: TObject);
begin
setupColsWidths;
end;
procedure TFormInterrogate.StringGrid1DblClick(Sender: TObject);
begin
FormPopup.ShowStringGridCellText(StringGrid1);
end;
procedure TFormInterrogate.StringGrid1DrawCell(Sender: TObject;
ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
var
grd: TStringGrid;
cnv: TCanvas;
ta: TAlignment;
AText: string;
floatValue: double;
function ColIs(s: string): boolean;
begin
Result := ARow = grd.Rows[0].IndexOf(s);
end;
begin
grd := StringGrid1;
cnv := grd.Canvas;
cnv.Brush.Color := clWhite;
cnv.Font.Assign(grd.Font);
AText := grd.Cells[ACol, ARow];
if (gdSelected in State) then
cnv.Brush.Color := clGradientInactiveCaption;
if not FOk[ARow] then
cnv.Font.Color := clRed;
StringGrid_DrawCellText(StringGrid1, ACol, ARow, Rect,
taLeftJustify, AText);
StringGrid_DrawCellBounds(cnv, ACol, ARow, Rect);
end;
procedure TFormInterrogate.AddLine(AComport, ARequest, AResponse: string;
Ok: boolean);
var
r: TStrings;
begin
with StringGrid1 do
begin
if RowCount > 100 then
begin
StringGrid_DeleteRow(StringGrid1, 0);
FOk.Delete(0);
end;
if Cells[0, 0] <> '' then
begin
RowCount := RowCount + 1;
FOk.Add(Ok);
end;
r := Rows[RowCount - 1];
r[0] := FormatDateTime('hh:nn:ss.zzz', now);
r[1] := AComport;
r[2] := ARequest;
r[3] := AResponse;
FOk[RowCount - 1] := Ok;
Row := RowCount - 1;
end;
end;
procedure TFormInterrogate.AddCommTransaction(C: TCommTransaction);
begin
AddLine(C.Port, C.Request, C.Response + ' ' + C.Duration, c.Ok);
end;
procedure TFormInterrogate.setupColsWidths;
var
w: Integer;
begin
With StringGrid1 do
begin
ColWidths[0] := 100;
ColWidths[1] := 60;
w := Self.Width - 50 - ColWidths[0] - ColWidths[1];
ColWidths[2] := w div 3;
ColWidths[3] := w - ColWidths[2];
end;
end;
end.
|
{*******************************************************}
{ }
{ Delphi REST Client Framework }
{ }
{ Copyright(c) 2014-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit REST.Backend.KinveyApi;
{$SCOPEDENUMS ON}
interface
uses
System.Classes, System.SysUtils, System.Generics.Collections, System.JSON,
REST.Client, REST.Types, REST.Backend.Exception;
type
EKinveyAPIError = class(EBackendAPIError)
private
FError: string;
FDescription: string;
public
constructor Create(const AError, ADescription: string); overload;
property Error: string read FError;
property Description: string read FDescription;
end;
TKinveyAPIErrorClass = class of EKinveyAPIError;
/// <summary>
/// <para>
/// TKinveyApi implements REST requests based on Kinvey's REST API. See
/// <see href="http://devcenter.kinvey.com/rest/" />
/// </para>
/// </summary>
TKinveyApi = class(TComponent)
public type
TPlatformType = (IOS, Android);
TConnectionInfo = record
private
public
ApiVersion: string;
AppKey: string;
AppSecret: string;
MasterSecret: string;
UserName: string;
Password: string;
ProxyPassword: string;
ProxyPort: Integer;
ProxyServer: string;
ProxyUsername: string;
constructor Create(const AApiVersion, AAppKey: String); overload;
end;
TUpdatedAt = record
private
FUpdatedAt: TDateTime;
public
constructor Create(AUpdatedAt: TDateTime);
property UpdatedAt: TDateTime read FUpdatedAt;
end;
TObjectID = record
private
FCreatedAt: TDateTime;
FUpdatedAt: TDateTime;
FObjectID: string;
FBackendCollectionName: string;
public
constructor Create(const ABackendCollectionName: string; AObjectID: string);
property CreatedAt: TDateTime read FCreatedAt;
property UpdatedAt: TDateTime read FUpdatedAt;
property ObjectID: string read FObjectID;
property BackendCollectionName: string read FBackendCollectionName;
end;
TFile = record
private
FID: string;
FFileName: string;
FDownloadURL: string;
FExpiresAt: TDateTime;
public
constructor Create(const AID: string);
property FileName: string read FFileName;
property DownloadURL: string read FDownloadURL;
property ID: string read FID;
property ExpiresAt: TDateTime read FExpiresAt;
end;
TUser = record
private
FCreatedAt: TDateTime;
FUpdatedAt: TDateTime;
FObjectID: string;
FUserName: string;
public
constructor Create(const AUserName: string);
property CreatedAt: TDateTime read FCreatedAt;
property UpdatedAt: TDateTime read FUpdatedAt;
property ObjectID: string read FObjectID;
property UserName: string read FUserName;
end;
TUserGroup = record
private
FCreatedAt: TDateTime;
FUpdatedAt: TDateTime;
FObjectID: string;
public
property CreatedAt: TDateTime read FCreatedAt;
property UpdatedAt: TDateTime read FUpdatedAt;
property ObjectID: string read FObjectID;
end;
TLogin = record
private
FAuthToken: string;
FUser: TUser;
public
constructor Create(const AAuthToken: string; const AUser: TUser);
property AuthToken: string read FAuthToken;
property User: TUser read FUser;
end;
TAuthentication = (Default, MasterSecret, AppSecret, UserName, Session, None);
TDefaultAuthentication = (MasterSecret, AppSecret, UserName, Session, None);
TFindObjectProc = reference to procedure(const AID: TObjectID; const AObj: TJSONObject);
TQueryUserNameProc = reference to procedure(const AUser: TUser; const AObj: TJSONObject);
TLoginProc = reference to procedure(const ALogin: TLogin; const AObj: TJSONObject);
TRetrieveUserProc = reference to procedure(const AUser: TUser; const AObj: TJSONObject);
TRetrieveFileProc = reference to procedure(const AFile: TFile; const AObj: TJSONObject);
TRetrieveUserGroupProc = reference to procedure(const AUserGroup: TUserGroup; const AObj: TJSONObject);
public
const
DateTimeIsUTC = True;
public
class var
EmptyConnectionInfo: TConnectionInfo;
private
const
sAppKey = 'appKey';
sDateCreated = 'ect';
sDateUpdated = 'lmt';
cDateTimeIsUTC = True;
sDataStore = 'appdata';
sUserGroup = 'group';
sBlob = 'blob';
sUser = 'user';
sLogin = 'login';
sPush = 'push';
sRpc = 'rpc';
sRegisterDevice = 'register-device';
sUnregisterDevice = 'unregister-device';
sAppKeySegment = '/{' + sAppKey + '}';
sUserAppKey = sUser + sAppKeySegment;
sDataStoreAppKey = sDataStore + sAppKeySegment;
sUserGroupAppKey = sUserGroup + sAppKeySegment;
sPushAppKey = sPush + sAppKeySegment;
sBlobAppKey = sBlob + sAppKeySegment;
sRpcAppKey = sRpc + sAppKeySegment;
sMessageElement = 'message';
sIOSApsElement = 'iosaps';
sIOSExtrasElement = 'iosextras';
sAndroidPayloadElement = 'androidpayload';
sUsersElement = 'users';
public
const
cDefaultApiVersion = '3';
cDefaultBaseURL = 'https://baas.kinvey.com/'; // do not localize
private
FRESTClient: TRESTClient;
FRequest: TRESTRequest;
FResponse: TRESTResponse;
FBaseURL: string;
FOwnsResponse: Boolean;
FConnectionInfo: TConnectionInfo;
FSessionAuthToken: string;
FAuthentication: TAuthentication;
FDefaultAuthentication: TDefaultAuthentication;
procedure SetBaseURL(const Value: string);
procedure SetConnectionInfo(const Value: TConnectionInfo);
function GetLoggedIn: Boolean;
protected
function GetActualAuthentication: TAuthentication;
function CreateException(const ARequest: TRESTRequest; const AClass: TKinveyAPIErrorClass):
EKInveyAPIError;
procedure AddAuthParameter; overload;
procedure AddAuthParameter(Authentication: TAuthentication); overload;
procedure ApplyConnectionInfo;
procedure CheckForResponseError(const ARequest: TRESTRequest); overload;
procedure CheckForResponseError; overload;
procedure CheckForResponseError(AValidStatusCodes: array of Integer); overload;
procedure PostObject(const AResource, ABackendCollectionName: string; const AACL, AJSON: TJSONObject; out ANewObject: TObjectID; AReset: Boolean); overload;
procedure PostObject(const AResource, ABackendCollectionName: string; const AJSON: TJSONObject; out ANewObject: TObjectID; AReset: Boolean); overload;
procedure PutObject(const AResource, ABackendCollectionName, AObjectID: string; const AJSON: TJSONObject; out AObject: TObjectID; AReset: Boolean); overload;
procedure PutObject(const AResource, ABackendCollectionName, AObjectID: string; const AACL, AJSON: TJSONObject; out AObject: TObjectID; AReset: Boolean); overload;
//function ObjectIDFromObject(const ABackendCollectionName: string; const AJSONObject: TJSONObject): TObjectID; overload;
function ObjectIDFromObject(const ABackendCollectionName, AObjectID: string; const AJSONObject: TJSONObject): TObjectID; overload;
function FileFromObject(const AFileName: string; const AJSONObject: TJSONObject): TFile; overload;
function FileFromObject(const AJSONObject: TJSONObject): TFile; overload;
function DeleteObject(const AResource: string; AReset: Boolean): Integer;
function FindAppData(const ABackendCollectionName, AObjectID: string; out AFoundObject: TObjectID; const AJSON: TJSONArray; AProc: TFindObjectProc): Boolean; overload;
function LoginFromObject(const AUserName: string; const AJSONObject: TJSONObject): TLogin;
procedure LoginUser(const AUserName, APassword: string; out ALogin: TLogin; const AJSON: TJSONArray; AProc: TLoginProc); overload;
function QueryUserName(const AUserName: string; out AUser: TUser; const AJSON: TJSONArray; AProc: TQueryUserNameProc): Boolean; overload;
function UpdatedAtFromObject(const AJSONObject: TJSONObject): TUpdatedAt;
function UserFromObject(const AUserName: string; const AJSONObject: TJSONObject): TUser; overload;
function UserGroupFromObject(const AUserGroupName: string; const AJSONObject: TJSONObject): TUserGroup; overload;
function DeleteOrSuspendUser(const AObjectID: string; ADelete: Boolean): Boolean;
function RetrieveUser(const AObjectID: string; out AUser: TUser; const AJSON: TJSONArray; AProc: TRetrieveUserProc): Boolean; overload;
procedure QueryResource(const AResource: string; const AQuery: array of string; const AJSONArray: TJSONArray; AReset: Boolean);
function RetrieveFile(const AFileID: string; out AFile: TFile; const AJSON: TJSONArray; AProc: TRetrieveFileProc): Boolean; overload;
function RetrieveUserGroup(const AObjectID: string; out AUserGroup: TUserGroup; const AJSON: TJSONArray; AProc: TRetrieveUserGroupProc): Boolean; overload;
function RetrieveUserGroup(const AObjectID: string; AProc: TRetrieveUserGroupProc): Boolean; overload;
procedure InvokeEndpoint(const AEndpointName: string; const AJSONParameters: TJSONObject; AReset: Boolean; ACheckError: Boolean); overload;
property RestClient: TRESTClient read FRESTClient;
property Request: TRESTRequest read FRequest;
public
constructor Create(AOwner: TComponent; const AResponse: TRESTResponse = nil); reintroduce; overload;
destructor Destroy; override;
// Utilities
function UserFromObject(const AJSONObject: TJSONObject): TUser; overload;
function ObjectIDFromObject(const ABackendCollectionName: string;
const AJSONObject: TJSONObject): TObjectID; overload;
// Handshake
procedure AppHandshake(const AJSONArray: TJSONArray);
// Installations
procedure PushRegisterDevice(APlatformType: TPlatformType; const ADeviceID, AUserID: string); overload;
procedure PushRegisterDevice(APlatformType: TPlatformType; const ADeviceID: string); overload;
procedure PushRegisterDevice(APlatformType: TPlatformType; const ADeviceID: string; const AUser: TUser); overload;
procedure PushUnregisterDevice(APlatformType: TPlatformType; const ADeviceID, AUserID: string); overload;
procedure PushUnregisterDevice(APlatformType: TPlatformType; const ADeviceID: string; const AUser: TUser); overload;
procedure PushUnregisterDevice(APlatformType: TPlatformType; const ADeviceID: string); overload;
// AppData
procedure CreateAppData(const ABackendCollectionName: string; const AACL, AJSON: TJSONObject; out ANewObject: TObjectID); overload;
procedure CreateAppData(const ABackendCollectionName: string; const AJSON: TJSONObject; out ANewObject: TObjectID); overload;
function FindAppData(const AObject: TObjectID; AProc: TFindObjectProc): Boolean; overload;
function FindAppData(const AObject: TObjectID; out AFoundObject: TObjectID; const AJSON: TJSONArray = nil): Boolean; overload;
function FindAppData(const ABackendCollectionName, AObjectID: string; AProc: TFindObjectProc): Boolean; overload;
function FindAppData(const ABackendCollectionName, AObjectID: string; out AFoundObject: TObjectID; const AJSON: TJSONArray = nil): Boolean; overload;
function DeleteAppData(const AObject: TObjectID): Integer; overload;
function DeleteAppData(const ABackendCollectionName: string; const AObjectID: string): Integer ;overload;
function DeleteAppDataCollection(const ABackendCollectionName: string): Integer;
procedure UpdateAppData(const AObject: TObjectID; const AJSONObject: TJSONObject; out AUpdateObject: TObjectID); overload;
procedure UpdateAppData(const ABackendCollectionName, AObjectID: string; const AJSONObject: TJSONObject; out AUpdateObject: TObjectID); overload;
procedure QueryAppData(const ABackendCollectionName: string;
const AQuery: array of string; const AJSONArray: TJSONArray); overload;
procedure QueryAppData(const ABackendCollectionName: string;
const AQuery: array of string; const AJSONArray: TJSONArray; out AObjects: TArray<TObjectID>); overload;
// Files
function DeleteFile(const AFile: TFile): Boolean; overload;
function DeleteFile(const AFileID: string): Boolean; overload;
procedure UploadFile(const AFileName: string; AContentType: string; APublic: Boolean; const AUserFields: TJSONObject; out ANewFile: TFile); overload;
procedure UploadFile(const AFileName: string; const AStream: TStream; AContentType: string; APublic: Boolean; const AUserFields: TJSONObject; out ANewFile: TFile); overload;
procedure DownloadFile(const AFile: TFile; const AStream: TStream);
procedure QueryFiles(const AQuery: array of string;
const AJSONArray: TJSONArray); overload;
procedure QueryFiles(const AQuery: array of string;
const AJSONArray: TJSONArray; out AFiles: TArray<TFile>); overload;
function RetrieveFile(const AFile: TFile; AProc: TRetrieveFileProc): Boolean; overload;
function RetrieveFile(const AFile: TFile; out AFoundFile: TFile; const AJSON: TJSONArray = nil): Boolean; overload;
function RetrieveFile(const AFileID: string; out AFile: TFile; const AJSON: TJSONArray = nil): Boolean; overload;
function RetrieveFile(const AFileID: string; AProc: TRetrieveFileProc): Boolean; overload;
// User groups
procedure CreateUserGroup(const AID: string; const AACL, AUsersAndGroups: TJSONObject; out ANewUserGroup: TUserGroup); overload;
procedure CreateUserGroup(const AID: string; const AUsersAndGroups: TJSONObject; out ANewUserGroup: TUserGroup); overload;
procedure UpdateUserGroup(const AID: string; const AUsersAndGroups: TJSONObject; out AUpdateObject: TObjectID); overload;
procedure UpdateUserGroup(const AUserGroup: TUserGroup; const AUsersAndGroups: TJSONObject; out AUpdateObject: TObjectID); overload;
function DeleteUserGroup(const AUserGroup: TUserGroup): Boolean; overload;
function DeleteUserGroup(const AID: string): Boolean; overload;
function RetrieveUserGroup(const AUserGroup: TUserGroup; AProc: TRetrieveUserGroupProc): Boolean; overload;
function RetrieveUserGroup(const AUserGroup: TUserGroup; out AFoundUserGroup: TUserGroup; const AJSON: TJSONArray = nil): Boolean; overload;
function RetrieveUserGroup(const AObjectID: string; out AUserGroup: TUserGroup; const AJSON: TJSONArray = nil): Boolean; overload;
// Users
function QueryUserName(const AUserName: string; AProc: TQueryUserNameProc): Boolean; overload;
function QueryUserName(const AUserName: string; out AUser: TUser; const AJSON: TJSONArray = nil): Boolean; overload;
function RetrieveUser(const AUser: TUser; AProc: TRetrieveUserProc): Boolean; overload;
function RetrieveUser(const AUser: TUser; out AFoundUser: TUser; const AJSON: TJSONArray = nil): Boolean; overload;
function RetrieveUser(const AObjectID: string; out AUser: TUser; const AJSON: TJSONArray = nil): Boolean; overload;
function RetrieveUser(const AObjectID: string; AProc: TRetrieveUserProc): Boolean; overload;
procedure SignupUser(const AUserName, APassword: string; const AUserFields: TJSONObject; out ALogin: TLogin);
procedure LoginUser(const AUserName, APassword: string; AProc: TLoginProc); overload;
procedure LoginUser(const AUserName, APassword: string; out ALogin: TLogin; const AJSON: TJSONArray = nil); overload;
procedure LogoutUser;
procedure RestoreSuspendedUser(const AObjectID: string); overload;
procedure RestoreSuspendedUser(const AUser: TUser); overload;
function RetrieveCurrentUser(AProc: TRetrieveUserProc): Boolean; overload;
function RetrieveCurrentUser(out AUser: TUser; const AJSON: TJSONArray = nil): Boolean; overload;
procedure UpdateUser(const AObjectID: string; const AUserObject: TJSONObject; out AUpdatedAt: TUpdatedAt); overload;
procedure UpdateUser(const AUser: TUser; const AUserObject: TJSONObject; out AUpdatedAt: TUpdatedAt); overload;
function DeleteUser(const AObjectID: string): Boolean; overload;
function DeleteUser(const AUser: TUser): Boolean; overload;
function SuspendUser(const AObjectID: string): Boolean; overload;
function SuspendUser(const AUser: TUser): Boolean; overload;
procedure QueryUsers(const AQuery: array of string; const AJSONArray: TJSONArray); overload;
procedure QueryUsers(const AQuery: array of string; const AJSONArray: TJSONArray; out AUsers: TArray<TUser>); overload;
{ Endpoints }
procedure InvokeCustomEndpoint(const AEndpointName: string; const AJSONParameters: TJSONObject; const AJSONResult: TJSONArray);
procedure InvokeEndpoint(const AEndpointName: string; const AJSONParameters: TJSONObject; const AJSONResult: TJSONArray); overload;
{ Messaging }
procedure BroadcastMessage(const AEndpointName: string; const AMessage: string);
procedure SendMessage(const AEndpointName: string; AUsers: array of TUser; const AMessage: string);
procedure BroadcastPayload(const AEndpointName: string; const AIOSAps, AIOSExtras, AAndroidPayload: TJSONObject);
procedure SendPayload(const AEndpointName: string; AUsers: array of TUser; const AIOSAps, AIOSExtras, AAndroidPayload: TJSONObject); overload;
procedure SendPayload(const AEndpointName: string; AUsers: array of string; const AIOSAps, AIOSExtras, AAndroidPayload: TJSONObject); overload;
procedure Login(const ASessionAuthToken: string); overload;
procedure Login(const ALogin: TLogin); overload;
procedure Logout;
property LoggedIn: Boolean read GetLoggedIn;
property Authentication: TAuthentication read FAuthentication write FAuthentication;
property DefaultAuthentication: TDefaultAuthentication read FDefaultAuthentication write FDefaultAuthentication;
property Response: TRESTResponse read FResponse;
property BaseURL: string read FBaseURL write SetBaseURL;
property ConnectionInfo: TConnectionInfo read FConnectionInfo write SetConnectionInfo;
end;
EKinveyDuplicateUser = class(EKinveyAPIError);
EKinveyFileNotFound = class(EKinveyAPIError);
implementation
uses
System.Rtti,
REST.JSON.Types,
REST.Consts, REST.Backend.Consts, System.TypInfo;
procedure CheckObjectID(const AObjectID: string);
begin
if AObjectID = '' then
raise EKinveyAPIError.Create(sObjectIDRequired);
end;
procedure CheckAuthToken(const AAuthToken: string);
begin
if AAuthToken = '' then
raise EKinveyAPIError.Create(sAuthTokenRequired);
end;
procedure CheckBackendCollectionName(const ABackendCollectionName: string);
begin
if ABackendCollectionName = '' then
raise EKinveyAPIError.Create(sBackendCollectionNameRequired);
end;
procedure CheckJSONObject(const AJSON: TJSONObject);
begin
if AJSON = nil then
raise EKinveyAPIError.Create(sJSONObjectRequired);
end;
{ TKinveyApi }
// GET /appdata/:appKey
// Host: baas.kinvey.com
// Authorization: [Basic Auth with app credentials]
procedure TKinveyApi.AppHandshake(const AJSONArray: TJSONArray);
begin
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmGET;
FRequest.Resource := sDataStoreAppKey;
AddAuthParameter(TAuthentication.AppSecret);
FRequest.Execute;
CheckForResponseError;
if Assigned(AJSONArray) then
AJSONArray.AddElement(FRequest.Response.JSONValue.Clone as TJSONObject);
end;
const
Codes64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
Pad = '=';
function EncodeBytes64(asBytes: TArray<Byte>): string;
var
bitIdx, Count, Data, I, Remainder: Integer;
begin
bitIdx := 0;
Remainder := 0;
Count := Length(asBytes);
for I := 0 to Count - 1 do
begin
Data := Ord(asBytes[I]);
Remainder := (Remainder shl 8) or Data;
bitIdx := bitIdx + 8;
while bitIdx >= 6 do
begin
bitIdx := bitIdx - 6;
Data := Remainder div (1 shl bitIdx);
Remainder := Remainder mod (1 shl bitIdx);
Result := Result + Codes64.Chars[Data];
end;
end;
if bitIdx > 0 then
begin
Data := Remainder shl (6 - bitIdx);
Result := Result + Codes64.Chars[Data];
end;
case Count mod 3 of
1: Result := Result + Pad + Pad;
2: Result := Result + Pad;
end;
end;
function Encode64(Str: string): string;
begin
Result := EncodeBytes64(TEncoding.UTF8.GetBytes(Str));
end;
procedure TKinveyApi.ApplyConnectionInfo;
begin
FRESTClient.Params.AddHeader('X-Kinvey-API-Version', FConnectionInfo.ApiVersion); // do not localize
FRESTClient.Params.AddUrlSegment(sAppKey, FConnectionInfo.AppKey);
FRESTClient.ProxyPort := FConnectionInfo.ProxyPort;
FRESTClient.ProxyPassword := FConnectionInfo.ProxyPassword;
FRESTClient.ProxyUsername := FConnectionInfo.ProxyUsername;
FRESTClient.ProxyServer := FConnectionInfo.ProxyServer;
end;
// Invoke custom endpoint to broadcast a message, such as:
(*
function onRequest(request, response, modules){
var message = request.body.message;
var push = modules.push;
push.broadcastMessage(message);
response.complete( 200 );
}
*)
procedure TKinveyApi.BroadcastMessage(const AEndpointName, AMessage: string);
var
LJSONObject: TJSONObject;
begin
LJSONObject := TJSONObject.Create;
try
LJSONObject.AddPair(sMessageElement, AMessage);
InvokeCustomEndPoint(AEndpointName, LJSONObject, nil);
finally
LJSONObject.Free;
end;
end;
// Invoke custom endpoint to broadcast a payload, such as:
(*
function onRequest(request, response, modules){
var iosaps = request.body.iosaps;
var iosextras = request.body.iosextras;
var androidpayload = request.body.androidpayload;
var push = modules.push;
push.broadcastPayload(iosaps, iosextras, androidpayload);
response.complete( 200 );
}
*)
procedure TKinveyApi.BroadcastPayload(const AEndpointName: string;
const AIOSAps, AIOSExtras, AAndroidPayload: TJSONObject);
var
LJSONObject: TJSONObject;
begin
LJSONObject := TJSONObject.Create;
try
if AIOSAps <> nil then
LJSONObject.AddPair(sIOSApsElement, AIOSAps.Clone as TJSONObject);
if AIOSExtras <> nil then
LJSONObject.AddPair(sIOSExtrasElement, AIOSExtras.Clone as TJSONObject);
if AAndroidPayload <> nil then
LJSONObject.AddPair(sAndroidPayloadElement, AAndroidPayload.Clone as TJSONObject);
InvokeCustomEndPoint(AEndpointName, LJSONObject, nil);
finally
LJSONObject.Free;
end;
end;
// Invoke custom endpoint to send a message, such as:
(*
function onRequest(request, response, modules){
var users = request.body.users;
var message = request.body.message;
var push = modules.push;
push.sendMessage(users, message);
response.complete( 200 );
}
*)
procedure TKinveyApi.SendMessage(const AEndpointName: string;
AUsers: array of TUser; const AMessage: string);
var
LJSONObject: TJSONObject;
LJSONArray: TJSONArray;
LUser: TUser;
begin
LJSONObject := TJSONObject.Create;
try
LJSONArray := TJSONArray.Create;
LJSONObject.AddPair(sUsersElement, LJSONArray);
for LUser in AUsers do
begin
Assert(LUser.FObjectID <> '');
if LUser.FObjectID <> '' then
LJSONArray.Add(LUser.FObjectID);
end;
LJSONObject.AddPair(sMessageElement, AMessage);
InvokeCustomEndPoint(AEndpointName, LJSONObject, nil);
finally
LJSONObject.Free;
end;
end;
// Invoke custom endpoint to send a payload, such as:
(*
function onRequest(request, response, modules){
var users = request.body.users;
var iosaps = request.body.iosaps;
var iosextras = request.body.iosextras;
var androidpayload = request.body.androidpayload;
var push = modules.push;
push.sendPayload(users, iosaps, iosextras, androidpayload);
response.complete( 200 );
}
*)
procedure TKinveyApi.SendPayload(const AEndpointName: string;
AUsers: array of TUser; const AIOSAps, AIOSExtras,
AAndroidPayload: TJSONObject);
var
LUsers: TStrings;
LUser: TUser;
begin
LUsers := TStringList.Create;
try
for LUser in AUsers do
begin
Assert(LUser.FObjectID <> '');
if LUser.FObjectID <> '' then
LUsers.Add(LUser.FObjectID);
end;
SendPayload(AEndpointName,
LUsers.ToStringArray, AIOSAps, AIOSExtras,
AAndroidPayload);
finally
LUsers.Free;
end;
end;
procedure TKinveyApi.SendPayload(const AEndpointName: string;
AUsers: array of string; const AIOSAps, AIOSExtras,
AAndroidPayload: TJSONObject);
var
LJSONObject: TJSONObject;
LJSONArray: TJSONArray;
LUser: string;
begin
LJSONObject := TJSONObject.Create;
try
LJSONArray := TJSONArray.Create;
LJSONObject.AddPair(sUsersElement, LJSONArray);
for LUser in AUsers do
begin
Assert(LUser <> '');
if LUser <> '' then
LJSONArray.Add(LUser);
end;
if AIOSAps <> nil then
LJSONObject.AddPair(sIOSApsElement, AIOSAps.Clone as TJSONObject);
if AIOSExtras <> nil then
LJSONObject.AddPair(sIOSExtrasElement, AIOSExtras.Clone as TJSONObject);
if AAndroidPayload <> nil then
LJSONObject.AddPair(sAndroidPayloadElement, AAndroidPayload.Clone as TJSONObject);
InvokeCustomEndPoint(AEndpointName, LJSONObject, nil);
finally
LJSONObject.Free;
end;
end;
function TKinveyApi.GetActualAuthentication: TAuthentication;
var
LAuthentication: TAuthentication;
begin
LAuthentication := FAuthentication;
if LAuthentication = TAuthentication.Default then
case FDefaultAuthentication of
TDefaultAuthentication.MasterSecret:
LAuthentication := TAuthentication.MasterSecret;
TDefaultAuthentication.UserName:
LAuthentication := TAuthentication.UserName;
TKinveyApi.TDefaultAuthentication.Session:
LAuthentication := TAuthentication.Session;
TKinveyApi.TDefaultAuthentication.None:
LAuthentication := TAuthentication.None;
else
Assert(False);
end;
Result := LAuthentication;
end;
procedure TKinveyApi.AddAuthParameter;
var
LAuthentication: TAuthentication;
begin
LAuthentication := GetActualAuthentication;
case LAuthentication of
TKinveyApi.TAuthentication.UserName,
TKinveyApi.TAuthentication.MasterSecret,
TKinveyApi.TAuthentication.AppSecret,
TKinveyApi.TAuthentication.Session:
AddAuthParameter(LAuthentication);
TKinveyApi.TAuthentication.None:
;
else
Assert(False);
end;
end;
procedure TKinveyApi.AddAuthParameter(Authentication: TAuthentication);
var
LCredentials: String;
begin
case Authentication of
TAuthentication.AppSecret:
begin
if FConnectionInfo.AppKey = '' then
raise EKinveyAPIError.Create(sAppKeyRequired);
if FConnectionInfo.AppSecret = '' then
raise EKinveyAPIError.Create(sAppSecretRequired);
LCredentials := 'Basic ' + Encode64(FConnectionInfo.AppKey + ':' + FConnectionInfo.AppSecret); // Do not localize
end;
TAuthentication.MasterSecret:
begin
if FConnectionInfo.AppKey = '' then
raise EKinveyAPIError.Create(sAppKeyRequired);
if FConnectionInfo.MasterSecret = '' then
raise EKinveyAPIError.Create(sMasterSecretRequired);
LCredentials := 'Basic ' + Encode64(FConnectionInfo.AppKey + ':' + FConnectionInfo.MasterSecret); // Do not localize
end;
TAuthentication.UserName:
begin
if FConnectionInfo.UserName = '' then
raise EKinveyAPIError.Create(sUserNameRequired);
LCredentials := 'Basic ' + Encode64(FConnectionInfo.UserName + ':' + FConnectionInfo.Password); // Do not localize
end;
TAuthentication.Session:
begin
if FSessionAuthToken = '' then
raise EKinveyAPIError.Create(sAuthTokenRequired);
LCredentials := 'Kinvey ' + FSessionAuthToken; // Do not localize
end;
else
Assert(False);
end;
if LCredentials <> '' then
FRequest.AddAuthParameter(HTTP_HEADERFIELD_AUTH, LCredentials, TRESTRequestParameterKind.pkHTTPHEADER,
[TRESTRequestParameterOption.poDoNotEncode]);
end;
procedure TKinveyApi.CheckForResponseError;
begin
CheckForResponseError(FRequest);
end;
function TKinveyApi.CreateException(const ARequest: TRESTRequest;
const AClass: TKinveyAPIErrorClass): EKinveyAPIError;
var
LError: string;
LDescription: string;
LJSONError: TJSONValue;
LJSONDescription: TJSONValue;
begin
if ARequest.Response.JSONValue <> nil then
begin
LJSONError := (ARequest.Response.JSONValue as TJSONObject).GetValue('error'); // Do not localize
if LJSONError <> nil then
LError := LJSONError.Value;
LJSONDescription := (ARequest.Response.JSONValue as TJSONObject).GetValue('description'); // Do not localize
if LJSONDescription <> nil then
LDescription := LJSONDescription.Value;
if (LJSONError <> nil) and (LJSONDescription <> nil) then
Result := AClass.Create(LError, LDescription)
else if LJSONDescription <> nil then
Result := AClass.Create(LDescription)
else if LJSONError <> nil then
Result := AClass.Create(LError)
else
Result := AClass.Create(ARequest.Response.Content);
end
else
Result := AClass.Create(ARequest.Response.Content);
end;
procedure TKinveyApi.CheckForResponseError(const ARequest: TRESTRequest);
begin
if ARequest.Response.StatusCode >= 300 then
raise CreateException(ARequest, EKinveyAPIError);
end;
procedure TKinveyApi.CheckForResponseError(AValidStatusCodes: array of Integer);
var
LCode: Integer;
LResponseCode: Integer;
begin
LResponseCode := FRequest.Response.StatusCode;
for LCode in AValidStatusCodes do
if LResponseCode = LCode then
Exit; // Code is valid, exit with no exception
CheckForResponseError;
end;
constructor TKinveyApi.Create(AOwner: TComponent; const AResponse: TRESTResponse);
begin
inherited Create(AOwner);
FRESTClient := TRESTClient.Create(nil);
FRESTClient.SynchronizedEvents := False;
FRequest := TRESTRequest.Create(nil);
FRequest.SynchronizedEvents := False;
FRequest.Client := FRESTClient;
FOwnsResponse := AResponse = nil;
if FOwnsResponse then
FResponse := TRESTResponse.Create(nil)
else
FResponse := AResponse;
FRequest.Response := FResponse;
SetBaseURL(cDefaultBaseURL);
FConnectionInfo := TConnectionInfo.Create(cDefaultApiVersion, '');
ApplyConnectionInfo;
end;
// POST /appdata/:appKey/:collectionName HTTP/1.1
// Host: baas.kinvey.com
// Authorization: [user credentials]
// Content-Type: application/json
//
// <JSON-Document-representing-Entity>
procedure TKinveyApi.CreateAppData(const ABackendCollectionName: string; const AJSON: TJSONObject; out ANewObject: TObjectID);
begin
CreateAppData(ABackendCollectionName, nil, AJSON, ANewObject);
end;
procedure TKinveyApi.CreateAppData(const ABackendCollectionName: string;
const AACL, AJSON: TJSONObject; out ANewObject: TObjectID);
begin
PostObject(sDataStoreAppKey, ABackendCollectionName, AACL, AJSON, ANewObject, True)
end;
function TKinveyApi.DeleteAppData(const AObject: TObjectID): Integer;
begin
Result := DeleteAppData(AObject.BackendCollectionName, AObject.ObjectID);
end;
// DELETE /appdata/:appKey/:collectionName/?query=... HTTP/1.1
// Host: baas.kinvey.com
// X-Kinvey-API-Version: 2
// Authorization: [user credentials]
// HTTP/1.1 200 OK
// Content-Type: application/json
//
// {
// "count": 5
// }
function TKinveyApi.DeleteAppData(const ABackendCollectionName, AObjectID: string): Integer;
begin
CheckBackendCollectionName(ABackendCollectionName);
CheckObjectID(AObjectID);
FRequest.ResetToDefaults;
AddAuthParameter;
Result := DeleteObject(sDataStoreAppKey + '/' + ABackendCollectionName + '/' + AObjectID, False);
end;
// POST /rpc/:appKey/remove-collection HTTP/1.1
// Host: baas.kinvey.com
// Content-Type: application/json
// Authorization: [master credentials]
// X-Kinvey-API-Version: 2
// X-Kinvey-Delete-Entire-Collection: true
//
// {
// "collectionName": "your-collection-name"
// }
function TKinveyApi.DeleteAppDataCollection(const ABackendCollectionName: string): Integer;
var
LJSON: TJSONObject;
LDeleted: Boolean;
LResponse: TJSONObject;
begin
LJSON := TJSONObject.Create;
try
LJSON.AddPair('collectionName', ABackendCollectionName); // Do not localize
FRequest.ResetToDefaults;
AddAuthParameter(TAuthentication.MasterSecret);
FRequest.Params.AddHeader('X-Kinvey-Delete-Entire-Collection', 'true'); // Do not localize
InvokeEndpoint('remove-collection', LJSON, False, False); // Do not localize
CheckForResponseError([404]);
LDeleted := FRequest.Response.StatusCode <> 404;
if LDeleted then
begin
LResponse := FRequest.Response.JSONValue as TJSONObject;
Result := StrToInt(LResponse.GetValue('count').Value) // Do not localize
end
else
Result := -1;
finally
LJSON.Free;
end;
end;
function TKinveyApi.DeleteObject(const AResource: string; AReset: Boolean): Integer;
var
ObjectDeleted: Boolean;
LResponse: TJSONObject;
begin
Assert(AResource <> '');
if AReset then
begin
FRequest.ResetToDefaults;
AddAuthParameter;
end;
FRequest.Method := TRESTRequestMethod.rmDELETE;
FRequest.Resource := AResource;
FRequest.Execute;
CheckForResponseError([404]);
ObjectDeleted := FRequest.Response.StatusCode <> 404;
if ObjectDeleted then
begin
LResponse := FRequest.Response.JSONValue as TJSONObject;
Result := StrToInt(LResponse.GetValue('count').Value) // Do not localize
end
else
Result := -1;
end;
destructor TKinveyApi.Destroy;
begin
FRESTClient.Free;
FRequest.Free;
if FOwnsResponse then
FResponse.Free;
inherited;
end;
function TKinveyApi.FindAppData(const AObject: TObjectID; AProc: TFindObjectProc): Boolean;
begin
Result := FindAppData(AObject.BackendCollectionName, AObject.ObjectID, AProc);
end;
function TKinveyApi.FindAppData(const AObject: TObjectID; out AFoundObject: TObjectID; const AJSON: TJSONArray = nil): Boolean;
begin
Result := FindAppData(AObject.BackendCollectionName, AObject.ObjectID, AFoundObject, AJSON, nil);
end;
function TKinveyApi.FindAppData(const ABackendCollectionName, AObjectID: string; out AFoundObject: TObjectID; const AJSON: TJSONArray = nil): Boolean;
begin
Result := FindAppData(ABackendCollectionName, AObjectID, AFoundObject, AJSON, nil);
end;
function TKinveyApi.FindAppData(const ABackendCollectionName, AObjectID: string; AProc: TFindObjectProc): Boolean;
var
LObject: TObjectID;
begin
Result := FindAppData(ABackendCollectionName, AObjectID, LObject, nil, AProc);
end;
// GET /appdata/:appKey/:collectionName/:id HTTP/1.1
// Host: baas.kinvey.com
// Authorization: [user credentials]
function TKinveyApi.FindAppData(const ABackendCollectionName, AObjectID: string; out AFoundObject: TObjectID; const AJSON: TJSONArray; AProc: TFindObjectProc): Boolean;
var
LResponse: TJSONObject;
begin
CheckBackendCollectionName(ABackendCollectionName);
CheckObjectID(AObjectID);
Assert(Assigned(AProc));
Result := False;
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmGET;
FRequest.Resource := sDataStoreAppKey + '/' + ABackendCollectionName + '/' + AObjectID;
AddAuthParameter;
FRequest.Execute;
CheckForResponseError([404]); // 404 = not found
if FRequest.Response.StatusCode <> 404 then
begin
Result := True;
LResponse := FRequest.Response.JSONValue as TJSONObject;
AFoundObject := ObjectIDFromObject(ABackendCollectionName, LResponse);
if Assigned(AJSON) then
AJSON.AddElement(LResponse.Clone as TJSONObject);
if Assigned(AProc) then
AProc(AFoundObject, LResponse);
end;
end;
function TKinveyApi.GetLoggedIn: Boolean;
begin
Result := FSessionAuthToken <> '';
end;
procedure TKinveyApi.InvokeCustomEndpoint(const AEndpointName: string;
const AJSONParameters: TJSONObject; const AJSONResult: TJSONArray);
begin
InvokeEndPoint('custom/' + AEndpointName, AJSONParameters, AJSONResult); // Do not localize
end;
procedure TKinveyApi.InvokeEndpoint(const AEndpointName: string;
const AJSONParameters: TJSONObject; const AJSONResult: TJSONArray);
begin
InvokeEndPoint(AEndpointName, AJSONParameters, True, True);
if AJSONResult <> nil then
AJSONResult.AddElement((FRequest.Response.JSONValue as TJSONObject).Clone as TJSONObject);
end;
procedure TKinveyApi.InvokeEndpoint(const AEndpointName: string;
const AJSONParameters: TJSONObject; AReset: Boolean; ACheckError: Boolean);
begin
if AReset then
begin
FRequest.ResetToDefaults;
AddAuthParameter;
end;
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sRpcAppKey + '/' + AEndpointName;
if AJSONParameters <> nil then
FRequest.AddBody(AJSONParameters);
FRequest.Execute;
if ACheckError then
CheckForResponseError;
end;
function TKinveyApi.ObjectIDFromObject(const ABackendCollectionName: string; const AJSONObject: TJSONObject): TObjectID;
begin
Result := ObjectIDFromObject(ABackendCollectionName, AJSONObject.GetValue('_id').Value, AJSONObject); // Do not localize
end;
function TKinveyApi.ObjectIDFromObject(const ABackendCollectionName, AObjectID: string;
const AJSONObject: TJSONObject): TObjectID;
var
LInnerJSONObject: TJSONObject;
begin
Result := TObjectID.Create(ABackendCollectionName, AObjectID);
LInnerJSONObject := AJSONObject.GetValue('_kmd') as TJSONObject; // Do not localize
if LInnerJSONObject.GetValue(sDateCreated) <> nil then
Result.FCreatedAt := TJSONDates.AsDateTime(LInnerJSONObject.GetValue(sDateCreated), TJSONDates.TFormat.ISO8601, cDateTimeIsUTC);
if LInnerJSONObject.GetValue(sDateUpdated) <> nil then
Result.FUpdatedAt := TJSONDates.AsDateTime(LInnerJSONObject.GetValue(sDateUpdated), TJSONDates.TFormat.ISO8601, cDateTimeIsUTC);
end;
function TKinveyApi.FileFromObject(const AFileName: string; const AJSONObject: TJSONObject): TFile;
var
LJSONValue: TJSONValue;
LID: string;
begin
LJSONValue := AJSONObject.GetValue('_id'); // Do not localize
if LJSONValue <> nil then
LID := LJSONValue.Value;
Result := TFile.Create(LID);
Result.FFileName := AFileName;
LJSONValue := AJSONObject.GetValue('_downloadURL'); // Do not localize
if LJSONValue <> nil then
Result.FDownloadURL := LJSONValue.Value;
LJSONValue := AJSONObject.GetValue('_expiresAt'); // Do not localize
if LJSONValue <> nil then
Result.FExpiresAt := TJSONDates.AsDateTime(LJSONValue, TJSONDates.TFormat.ISO8601, cDateTimeIsUTC);
end;
function TKinveyApi.FileFromObject(const AJSONObject: TJSONObject): TFile;
var
LJSONValue: TJSONValue;
LFileName: string;
begin
LJSONValue := AJSONObject.GetValue('_filename'); // Do not localize
if LJSONValue <> nil then
LFileName := LJSONValue.Value;
Result := FileFromObject(LFileName, AJSONObject);
end;
procedure TKinveyApi.Login(const ASessionAuthToken: string);
begin
FSessionAuthToken := ASessionAuthToken;
FAuthentication := TAuthentication.Session;
end;
procedure TKinveyApi.Login(const ALogin: TLogin);
begin
Login(ALogin.AuthToken);
end;
function TKinveyApi.LoginFromObject(const AUserName: string; const AJSONObject: TJSONObject): TLogin;
var
LUser: TUser;
LAuthToken: string;
LInnerJSONObject: TJSONObject;
LJSONValue: TJSONValue;
begin
LUser := UserFromObject(AUserName, AJSONObject);
LInnerJSONObject := AJSONObject.GetValue('_kmd') as TJSONObject; // Do not localize
Assert(LInnerJSONObject <> nil);
LJSONValue := nil;
if LInnerJSONObject <> nil then
LJSONValue := LInnerJSONObject.GetValue('authtoken'); // Do not localize
Assert(LJSONValue <> nil);
if LJSONValue <> nil then
LAuthToken := LJSONValue.Value;
Assert(LAuthToken <> '');
Result := TLogin.Create(LAuthToken, LUser);
end;
function TKinveyApi.UpdatedAtFromObject(const AJSONObject: TJSONObject): TUpdatedAt;
var
LUpdatedAt: TDateTime;
begin
if AJSONObject.GetValue(sDateUpdated) <> nil then
LUpdatedAt := TJSONDates.AsDateTime(AJSONObject.GetValue(sDateUpdated), TJSONDates.TFormat.ISO8601, DateTimeIsUTC)
else
LUpdatedAt := 0;
Result := TUpdatedAt.Create(LUpdatedAt);
end;
procedure TKinveyApi.UpdateUser(const AUser: TUser;
const AUserObject: TJSONObject; out AUpdatedAt: TUpdatedAt);
begin
UpdateUser(AUser.ObjectID, AUserObject, AUpdatedAt);
end;
function TKinveyApi.UserFromObject(const AUserName: string; const AJSONObject: TJSONObject): TUser;
var
LInnerJSONObject: TJSONObject;
LJSONValue: TJSONValue;
begin
Result := TUser.Create(AUserName);
LJSONValue := AJSONObject.GetValue('_id'); // Do not localize
if LJSONValue <> nil then
Result.FObjectID := LJSONValue.Value;
Assert(Result.FObjectID <> '');
LInnerJSONObject := AJSONObject.GetValue('_kmd') as TJSONObject; // Do not localize
Assert(LInnerJSONObject <> nil);
if LInnerJSONObject.GetValue(sDateCreated) <> nil then
Result.FCreatedAt := TJSONDates.AsDateTime(LInnerJSONObject.GetValue(sDateCreated), TJSONDates.TFormat.ISO8601, DateTimeIsUTC);
if LInnerJSONObject.GetValue(sDateUpdated) <> nil then
Result.FUpdatedAt := TJSONDates.AsDateTime(LInnerJSONObject.GetValue(sDateUpdated), TJSONDates.TFormat.ISO8601, DateTimeIsUTC);
end;
function TKinveyApi.UserGroupFromObject(const AUserGroupName: string; const AJSONObject: TJSONObject): TUserGroup;
var
LInnerJSONObject: TJSONObject;
LJSONValue: TJSONValue;
begin
LJSONValue := AJSONObject.GetValue('_id'); // Do not localize
if LJSONValue <> nil then
Result.FObjectID := LJSONValue.Value;
Assert(Result.FObjectID <> '');
LInnerJSONObject := AJSONObject.GetValue('_kmd') as TJSONObject; // Do not localize
Assert(LInnerJSONObject <> nil);
if LInnerJSONObject.GetValue(sDateCreated) <> nil then
Result.FCreatedAt := TJSONDates.AsDateTime(LInnerJSONObject.GetValue(sDateCreated), TJSONDates.TFormat.ISO8601, DateTimeIsUTC);
if LInnerJSONObject.GetValue(sDateUpdated) <> nil then
Result.FUpdatedAt := TJSONDates.AsDateTime(LInnerJSONObject.GetValue(sDateUpdated), TJSONDates.TFormat.ISO8601, DateTimeIsUTC);
end;
function TKinveyApi.UserFromObject(const AJSONObject: TJSONObject): TUser;
var
LUserName: string;
begin
if AJSONObject.GetValue('username') <> nil then // Do not localize
LUserName := AJSONObject.GetValue('username').Value; // Do not localize
Assert(LUserName <> '');
Result := UserFromObject(LUserName, AJSONObject);
end;
procedure TKinveyApi.PostObject(const AResource, ABackendCollectionName: string; const AJSON: TJSONObject;
out ANewObject: TObjectID; AReset: Boolean);
begin
PostObject(AResource, ABackendCollectionName, nil, AJSON, ANewObject, AReset);
end;
procedure TKinveyApi.PostObject(const AResource, ABackendCollectionName: string; const AACL, AJSON: TJSONObject;
out ANewObject: TObjectID; AReset: Boolean);
var
LResponse: TJSONObject;
LJSON: TJSONObject;
begin
CheckJSONObject(AJSON);
// NEW : POST
if AReset then
begin
FRequest.ResetToDefaults;
AddAuthParameter;
end;
LJSON := nil;
try
if (AACL <> nil) and (AJSON <> nil) then
begin
LJSON := AJSON.Clone as TJSONObject;
LJSON.AddPair('_acl', AACL.Clone as TJSONObject); // Do not localize
end
else if AACL <> nil then
LJSON := AACL
else
LJSON := AJSON;
FRequest.Method := TRESTRequestMethod.rmPOST;
if ABackendCollectionName <> '' then
FRequest.Resource := AResource + '/' + ABackendCollectionName
else
FRequest.Resource := AResource;
FRequest.AddBody(LJSON);
FRequest.Execute;
CheckForResponseError;
LResponse := FRequest.Response.JSONValue as TJSONObject;
ANewObject := ObjectIDFromObject(ABackendCollectionName, LResponse);
finally
if (LJSON <> AACL) and (LJSON <> AJSON) then
LJSON.Free;
end;
end;
procedure TKinveyApi.PutObject(const AResource, ABackendCollectionName, AObjectID: string; const AJSON: TJSONObject; out AObject: TObjectID; AReset: Boolean);
begin
PutObject(AResource, ABackendCollectionName, AObjectID, nil, AJSON, AObject, AReset);
end;
procedure TKinveyApi.PutObject(const AResource, ABackendCollectionName, AObjectID: string; const AACL, AJSON: TJSONObject; out AObject: TObjectID; AReset: Boolean);
var
LResponse: TJSONObject;
LJSON: TJSONObject;
begin
CheckJSONObject(AJSON);
if AReset then
begin
FRequest.ResetToDefaults;
AddAuthParameter;
end;
LJSON := nil;
try
if (AACL <> nil) and (AJSON <> nil) then
begin
LJSON := AJSON.Clone as TJSONObject;
LJSON.AddPair('_acl', AACL.Clone as TJSONObject); // Do not localize
end
else if AACL <> nil then
LJSON := AACL
else
LJSON := AJSON;
FRequest.Method := TRESTRequestMethod.rmPUT;
if ABackendCollectionName <> '' then
FRequest.Resource := AResource+ '/' + ABackendCollectionName + '/' + AObjectID
else
FRequest.Resource := AResource+ '/' + AObjectID;
FRequest.AddBody(LJSON);
FRequest.Execute;
CheckForResponseError;
LResponse := FRequest.Response.JSONValue as TJSONObject;
AObject := ObjectIDFromObject(ABackendCollectionName, AObjectID, LResponse);
finally
if (LJSON <> AACL) and (LJSON <> AJSON) then
LJSON.Free;
end;
end;
procedure TKinveyApi.SetBaseURL(const Value: string);
begin
FBaseURL := Value;
FRESTClient.BaseURL := Value;
end;
procedure TKinveyApi.SetConnectionInfo(const Value: TConnectionInfo);
begin
FConnectionInfo := Value;
ApplyConnectionInfo;
end;
procedure TKinveyApi.UpdateAppData(const AObject: TObjectID; const AJSONObject: TJSONObject; out AUpdateObject: TObjectID);
begin
UpdateAppData(AObject.BackendCollectionName, AObject.ObjectID, AJSONObject, AUpdateObject);
end;
// PUT /appdata/:appKey/:collectionName/:id HTTP/1.1
// Host: baas.kinvey.com
// Authorization: [user credentials]
// Content-Type: application/json
//
// <JSON-Document-representing-Entity>
procedure TKinveyApi.UpdateAppData(const ABackendCollectionName, AObjectID: string; const AJSONObject: TJSONObject; out AUpdateObject: TObjectID);
begin
CheckBackendCollectionName(ABackendCollectionName);
CheckObjectID(AObjectID);
FRequest.ResetToDefaults;
AddAuthParameter;
PutObject(sDataStoreAppKey, ABackendCollectionName, AObjectID, AJSONObject, AUpdateObject, False);
end;
function PlatformTypeToString(ADeviceType: TKinveyAPI.TPlatformType): string;
begin
case ADeviceType of
TKinveyAPI.TPlatformType.Android:
Result := 'android'; // Do not localize
TKinveyAPI.TPlatformType.IOS:
Result := 'ios'; // Do not localize
else
Assert(False);
end;
end;
//POST /push/:appKey/register-device HTTP/1.1
//Host: baas.kinvey.com
//Authorization: [master credentials]
//Content-Type: application/json
//
//{
// 'platform': 'ios',
// 'deviceId': 'device ID goes here',
// 'userId': '5058c666474f050906000001'
//}
procedure TKinveyApi.PushRegisterDevice(APlatformType: TPlatformType; const ADeviceID,
AUserID: string);
var
LJSONObject : TJSONObject;
begin
FRequest.ResetToDefaults;
if AUserId <> '' then
AddAuthParameter(TAuthentication.MasterSecret)
else
AddAuthParameter(TAuthentication.UserName);
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sPushAppKey + '/' + sRegisterDevice;
LJSONObject:= TJSONObject.Create;
try
LJSONObject.AddPair( 'platform', PlatformTypeToString(APlatformType)); // Do not localize
LJSONObject.AddPair( 'deviceId', ADeviceID ); // Do not localize
if AUserId <> '' then
LJSONObject.AddPair( 'userId', AUserId ); // Do not localize
FRequest.AddBody(LJSONObject);
finally
LJSONObject.Free;
end;
FRequest.Execute;
if FRequest.Response.StatusCode >= 300 then
raise EKinveyAPIError.Create(FRequest.Response.StatusText);
end;
procedure TKinveyApi.PushRegisterDevice(APlatformType: TPlatformType; const ADeviceID: string);
begin
PushRegisterDevice(APlatformType, ADeviceID, '');
end;
procedure TKinveyApi.PushRegisterDevice(APlatformType: TPlatformType; const ADeviceID: string;
const AUser: TUser);
begin
PushRegisterDevice(APlatformType, ADeviceID, AUser.ObjectID);
end;
//
//POST /push/:appKey/unregister-device HTTP/1.1
//Host: baas.kinvey.com
//Authorization: [master credentials]
//Content-Type: application/json
//
//{
// 'platform': 'ios',
// 'deviceId': 'device ID goes here',
// 'userId': '5058c666474f050906000001'
//}
procedure TKinveyApi.PushUnregisterDevice(APlatformType: TPlatformType; const ADeviceID,
AUserID: string);
var
LJSONObject : TJSONObject;
begin
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sPushAppKey + '/' + sUnRegisterDevice;
if AUserId <> '' then
AddAuthParameter(TAuthentication.MasterSecret)
else
AddAuthParameter(TAuthentication.UserName);
LJSONObject:= TJSONObject.Create;
try
LJSONObject.AddPair( 'platform', PlatformTypeToString(APlatformType)); // Do not localize
LJSONObject.AddPair( 'deviceId', ADeviceID ); // Do not localize
if AUserId <> '' then
LJSONObject.AddPair( 'userId', AUserId ); // Do not localize
FRequest.AddBody(LJSONObject);
finally
LJSONObject.Free;
end;
FRequest.Execute;
if FRequest.Response.StatusCode >= 300 then
raise EKinveyAPIError.Create(FRequest.Response.StatusText);
end;
procedure TKinveyApi.PushUnregisterDevice(APlatformType: TPlatformType; const ADeviceID: string);
begin
PushUnregisterDevice(APlatformType, ADeviceID, '');
end;
procedure TKinveyApi.PushUnregisterDevice(APlatformType: TPlatformType; const ADeviceID: string;
const AUser: TUser);
begin
PushUnregisterDevice(APlatformType, ADeviceID, AUser.ObjectID);
end;
procedure TKinveyApi.QueryAppData(const ABackendCollectionName: string; const AQuery: array of string; const AJSONArray: TJSONArray;
out AObjects: TArray<TObjectID>);
var
LJSONValue: TJSONValue;
LList: TList<TObjectID>;
LObjectID: TObjectID;
begin
QueryAppData(ABackendCollectionName, AQuery, AJSONArray);
LList := TList<TObjectID>.Create;
try
for LJSONValue in AJSONArray do
begin
if LJSONValue is TJSONObject then
begin
LObjectID := ObjectIDFromObject(ABackendCollectionName, TJSONObject(LJSONValue));
LList.Add(LObjectID);
end
else
raise EKinveyAPIError.Create(sJSONObjectExpected);
end;
AObjects := LList.ToArray;
finally
LList.Free;
end;
end;
procedure TKinveyApi.QueryResource(const AResource: string; const AQuery: array of string; const AJSONArray: TJSONArray;
AReset: Boolean);
var
LRoot: TJSONArray;
S: String;
I: Integer;
LTrim: string;
LJSONValue: TJSONValue;
begin
if AReset then
begin
FRequest.ResetToDefaults;
AddAuthParameter;
end;
FRequest.Method := TRESTRequestMethod.rmGET;
FRequest.Resource := AResource;
for S in AQuery do
begin
LTrim := Trim(S);
if LTrim = '' then
continue;
I := LTrim.IndexOf('=');
if I > 0 then
FRequest.AddParameter(S.Substring(0, I).Trim, S.Substring(I+1).Trim);
end;
FRequest.Execute;
CheckForResponseError([404]); // 404 = not found
if AJSONArray <> nil then
if FRequest.Response.StatusCode <> 404 then
begin
LRoot := FRequest.Response.JSONValue as TJSONArray;
for LJSONValue in LRoot do
AJSONArray.AddElement(TJSONValue(LJSONValue.Clone))
end;
end;
procedure TKinveyApi.QueryAppData(const ABackendCollectionName: string; const AQuery: array of string; const AJSONArray: TJSONArray);
var
LResource: string;
begin
CheckBackendCollectionName(ABackendCollectionName);
FRequest.ResetToDefaults;
AddAuthParameter;
LResource := sDataStoreAppKey + '/' + ABackendCollectionName + '/';
QueryResource(LResource, AQuery, AJSONArray, False);
end;
function TKinveyApi.DeleteFile(const AFile: TFile): Boolean;
begin
Result := DeleteFile(AFile.ID);
end;
function TKinveyApi.DeleteFile(const AFileID: string): Boolean;
begin
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmDELETE;
FRequest.Resource := sBlob + '/' + FConnectionInfo.AppKey + '/{fileId}'; // Do not localize
FRequest.AddParameter( 'fileId', AFileID, TRESTRequestParameterKind.pkURLSEGMENT ); // Do not localize
AddAuthParameter;
FRequest.Execute;
CheckForResponseError([404]);
Result := FRequest.Response.StatusCode <> 404
end;
procedure TKinveyApi.DownloadFile(const AFile: TFile; const AStream: TStream);
var
LDownloadURL : string;
LRequest : TRESTRequest;
LClient : TRESTClient;
LResponseObject: TJSONObject;
LJSONValue: TJSONValue;
begin
/// downloading files from kiney needs two steps:
///
/// (1) sending an "download-request" to kinvey
/// this step justs requests an download-url
/// where the actual file-content can be
/// downloaded from. this first step /does not/
/// contain the content of the file.
///
/// (2) receiving the actual file-content from
/// the download-url received in step #1
///
/// ** please note: currently (2014) kinvey makes
/// use of "GoogleCloudStorage" for file-storage
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmGET;
FRequest.Resource := sBlobAppKey + '/{fileId}'; // Do not localize
FRequest.AddParameter( 'fileId', AFile.ID, TRESTRequestParameterKind.pkURLSEGMENT ); // Do not localize
AddAuthParameter;
FRequest.Execute;
// a very common exception can be "404 - file not found"
if FRequest.Response.StatusCode = 404 then
raise CreateException(FRequest, EKinveyFileNotFound);
CheckForResponseError;
LResponseObject := FRequest.Response.JSONValue as TJSONObject;
LJSONValue := LResponseObject.GetValue('_downloadURL'); // Do not localize
if LJSONValue <> nil then
LDownloadURL := LJSONValue.Value;
LClient:= TRESTClient.Create( LDownloadURL );
LRequest:= TRESTRequest.Create(LClient);
try
LClient.FallbackCharsetEncoding := REST_NO_FALLBACK_CHARSET;
LRequest.URLAlreadyEncoded := true;
LRequest.Method := TRESTRequestMethod.rmGET;
LRequest.Params.CreateGetParamsFromUrl( LDownloadURL );
LRequest.Execute;
if LRequest.Response.StatusCode < 400 then
AStream.Write(LRequest.Response.RawBytes, 0, Length(LRequest.Response.RawBytes));
finally
LRequest.Free;
LClient.Free;
end;
end;
procedure TKinveyApi.UploadFile(const AFileName: string; AContentType: string; APublic: Boolean; const AUserFields: TJSONObject; out ANewFile: TFile);
var
LStream: TFileStream;
begin
LStream := TFileStream.Create(AFileName, fmOpenRead or fmShareDenyWrite);
try
UploadFile(AFileName, LStream, AContentType, APublic, AUserFields, ANewFile);
finally
LStream.Free;
end;
end;
procedure TKinveyApi.UploadFile(const AFileName: string; const AStream: TStream; AContentType: string; APublic: Boolean; const AUserFields: TJSONObject; out ANewFile: TFile);
var
LJSONValue: TJSONValue;
LUploadURL: string;
LJSON: TJsonObject;
LRequest : TRESTRequest;
LClient : TRESTClient;
LResponseObject: TJSONObject;
LRequiredHeaders: TJsonObject;
LHeader: TJSONPair;
LContentType: TRESTContentType;
begin
/// uploading files to kiney needs two steps:
///
/// (1) sending an "upload-request" to kinvey
/// this step justs requests an upload-url
/// where the actual file-content can be
/// uploaded to. this first step /does not/
/// contain the content of the file.
///
/// (2) sending the actual file-content to the
/// upload-url received in step #1
///
/// ** please note: currently (2014) kinvey makes
/// use of "GoogleCloudStorage" for file-storage
FRequest.ResetToDefaults;
AddAuthParameter;
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sBlob + '/' + FConnectionInfo.AppKey; //'blob/{appKey}';
if AContentType = '' then
LContentType := TRESTContentType.ctAPPLICATION_OCTET_STREAM
else
LContentType := ContentTypeFromString(AContentType);
FRequest.AddParameter('X-Kinvey-Content-Type',// Do not localize
ContentTypeToString(LContentType),
TRESTRequestParameterKind.pkHTTPHEADER, [TRESTRequestParameterOption.poDoNotEncode]);
// prepare meta-data
if AUserFields <> nil then
LJSON := AUserFields.Clone as TJSONObject
else
LJSON := TJsonObject.Create;
try
LJSON.AddPair('_filename', AFileName); // Do not localize
if APublic then
LJSON.AddPair('_public', TJSONTrue.Create); // Do not localize
LJSON.AddPair('size', TJSONNumber.Create(AStream.Size));
FRequest.AddBody(LJSON);
finally
LJSON.Free;
end;
FRequest.Execute;
CheckForResponseError;
LResponseObject := FRequest.Response.JSONValue as TJSONObject;
ANewFile := FileFromObject(AFileName, LResponseObject);
LJSONValue := LResponseObject.GetValue('_uploadURL'); // Do not localize
if LJSONValue <> nil then
LUploadURL := LJSONValue.Value;
Assert(LUploadURL <> '');
// Kinvey tells us what headers to send with the upload
LJSONValue := LResponseObject.GetValue('_requiredHeaders'); // Do not localize
if LJSONValue <> nil then
LRequiredHeaders := LJSONValue as TJSONObject
else
LRequiredHeaders := nil;
// now send the file-content to the upload-url
LClient:= TRESTClient.Create( LUploadURL );
LRequest:= TRESTRequest.Create(LClient);
try
LClient.ProxyServer := FRESTClient.ProxyServer;
LClient.ProxyPort := FRESTClient.ProxyPort;
LClient.ProxyUsername := FRESTClient.ProxyUsername;
LClient.ProxyPassword := FRESTClient.ProxyPassword;
LRequest.URLAlreadyEncoded := true;
LRequest.Method := TRESTRequestMethod.rmPUT;
LRequest.AddBody(AStream, LContentType);
if LRequiredHeaders <> nil then
for LHeader in LRequiredHeaders do
LRequest.AddParameter(LHeader.JsonString.Value, LHeader.JsonValue.Value, TRESTRequestParameterKind.pkHTTPHEADER);
LRequest.Execute;
CheckForResponseError(LRequest);
finally
LRequest.Free;
LClient.Free;
end;
end;
function TKinveyAPI.DeleteOrSuspendUser(const AObjectID: string; ADelete: Boolean): Boolean;
begin
FRequest.ResetToDefaults;
AddAuthParameter;
FRequest.Method := TRESTRequestMethod.rmDELETE;
FRequest.Resource := sUserAppKey + '/{userId}'; // do not localize
FRequest.AddParameter('userId', AObjectID, TRESTRequestParameterKind.pkURLSEGMENT); // Do not localize
if ADelete then
FRequest.AddParameter('hard', 'true', TRESTRequestParameterKind.pkGETorPOST) // Do not localize
else
FRequest.AddParameter('soft', 'true', TRESTRequestParameterKind.pkGETorPOST); // Do not localize
FRequest.Execute;
CheckForResponseError([404]);
Result := FRequest.Response.StatusCode <> 404
end;
function TKinveyAPI.DeleteUser(const AObjectID: string): Boolean;
begin
Result := DeleteOrSuspendUser(AObjectID, True);
end;
function TKinveyAPI.DeleteUser(const AUser: TUser): Boolean;
begin
Result := DeleteOrSuspendUser(AUser.FObjectID, True);
end;
function TKinveyAPI.SuspendUser(const AObjectID: string): Boolean;
begin
Result := DeleteOrSuspendUser(AObjectID, False);
end;
function TKinveyAPI.SuspendUser(const AUser: TUser): Boolean;
begin
Result := DeleteOrSuspendUser(AUser.FObjectID, False);
end;
procedure TKinveyApi.UpdateUser(const AObjectID: string;
const AUserObject: TJSONObject; out AUpdatedAt: TUpdatedAt);
var
LResponse: TJSONObject;
begin
FRequest.ResetToDefaults;
AddAuthParameter;
FRequest.Method := TRESTRequestMethod.rmPUT;
FRequest.Resource := sUserAppKey + '/{userId}'; // do not localize // Do not localize
FRequest.AddParameter('userId', AObjectID, TRESTRequestParameterKind.pkURLSEGMENT); // Do not localize
FRequest.AddBody(AUserObject);
FRequest.Execute;
CheckForResponseError;
LResponse := FRequest.Response.JSONValue as TJSONObject;
AUpdatedAt := UpdatedAtFromObject(LResponse);
end;
procedure TKinveyApi.QueryUsers(const AQuery: array of string; const AJSONArray: TJSONArray);
var
LResource: string;
begin
LResource := sUserAppKey + '/';
QueryResource(LResource, AQuery, AJSONArray, True);
end;
procedure TKinveyApi.QueryUsers(const AQuery: array of string; const AJSONArray: TJSONArray; out AUsers: TArray<TUser>);
var
LJSONValue: TJSONValue;
LList: TList<TUser>;
LUser: TUser;
LResource: string;
begin
LResource := sUserAppKey + '/';
QueryResource(LResource, AQuery, AJSONArray, True);
LList := TList<TUser>.Create;
try
for LJSONValue in AJSONArray do
begin
if LJSONValue is TJSONObject then
begin
LUser := UserFromObject(TJSONObject(LJSONValue));
LList.Add(LUser);
end
else
raise EKinveyAPIError.Create(sJSONObjectExpected);
end;
AUsers := LList.ToArray;
finally
LList.Free;
end;
end;
procedure TKinveyApi.LoginUser(const AUserName, APassword: string; out ALogin: TLogin; const AJSON: TJSONArray; AProc: TLoginProc);
var
LJSON : TJSONObject;
LResponse: TJSONObject;
begin
FRequest.ResetToDefaults;
AddAuthParameter(TAuthentication.AppSecret); // Always use AppSecret
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sUserAppKey + '/' + sLogin; // do not localize
LJSON:= TJSONObject.Create;
try
LJSON.AddPair('username', AUsername); // do not localize
LJSON.AddPair('password', APassword); // do not localize
FRequest.AddBody(LJSON);
finally
LJSON.Free;
end;
FRequest.Execute;
CheckForResponseError;
LResponse := FRequest.Response.JSONValue as TJSONObject;
ALogin := LoginFromObject(AUserName, LResponse);
if Assigned(AJSON) then
AJSON.AddElement(LResponse.Clone as TJSONObject);
if Assigned(AProc) then
AProc(ALogin, LResponse);
end;
procedure TKinveyApi.LoginUser(const AUserName, APassword: string; out ALogin: TLogin; const AJSON: TJSONArray);
begin
LoginUser(AUserName, APassword, ALogin, AJSON, nil);
end;
procedure TKinveyApi.LoginUser(const AUserName, APassword: string; AProc: TLoginProc);
var
LLogin: TLogin;
begin
LoginUser(AUserName, APassword, LLogin, nil, AProc);
end;
procedure TKinveyApi.Logout;
begin
FSessionAuthToken := '';
if FAuthentication = TAuthentication.Session then
FAuthentication := TAuthentication.Default;
end;
//POST /user/:appKey/_logout HTTP/1.1
//X-Kinvey-Api-Version: 1
//Authorization: Kinvey [auth token]
procedure TKinveyApi.LogoutUser;
begin
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sUserAppKey + '/_logout'; // Do not localize
AddAuthParameter(TAuthentication.Session); // Required
FRequest.Execute;
CheckForResponseError;
FSessionAuthToken := ''; // No longer valid
end;
//POST /user/:appKey/:id/_restore HTTP/1.1
//Host: baas.kinvey.com
//Authorization: [master secret]
//X-Kinvey-API-Version: 1
procedure TKinveyApi.RestoreSuspendedUser(const AObjectID: string);
begin
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sUserAppKey + '/' + AObjectID + '/_restore'; // Do not localize
AddAuthParameter(TAuthentication.MasterSecret); // Required
FRequest.Execute;
CheckForResponseError;
end;
procedure TKinveyApi.RestoreSuspendedUser(const AUser: TUser);
begin
RestoreSuspendedUser(AUser.ObjectID);
end;
// POST /user/:appKey/ HTTP/1.1
// Host: baas.kinvey.com
// Authorization: [Basic Auth with app credentials]
// Content-Type: application/json
//
// [optional body]
procedure TKinveyApi.SignupUser(const AUserName, APassword: string;
const AUserFields: TJSONObject; out ALogin: TLogin);
var
LJSON : TJSONObject;
LResponse: TJsonObject;
begin
FRequest.ResetToDefaults;
AddAuthParameter(TAuthentication.AppSecret); // Required
FRequest.Method := TRESTRequestMethod.rmPOST;
FRequest.Resource := sUserAppKey;
if AUserFields <> nil then
LJSON := AUserFields.Clone as TJSONObject
else
LJSON := TJSONObject.Create;
try
LJSON.AddPair('username', AUserName); // do not localize
LJSON.AddPair('password', APassword); // do not localize
FRequest.AddBody(LJSON);
finally
LJSON.Free;
end;
FRequest.Execute;
CheckForResponseError([409]);
if FRequest.Response.StatusCode = 409 then
raise CreateException(FRequest, EKinveyDuplicateUser);
LResponse := FRequest.Response.JSONValue as TJsonObject;
ALogin := LoginFromObject(AUserName, LResponse);
end;
function TKinveyApi.QueryUserName(const AUserName: string; out AUser: TUser; const AJSON: TJSONArray; AProc: TQueryUserNameProc): Boolean;
var
LUsers: TJSONArray;
LUserObject: TJSONObject;
begin
FRequest.ResetToDefaults;
AddAuthParameter;
FRequest.Method := TRESTRequestMethod.rmGET;
// Closing '/' required
FRequest.Resource := sUserAppKey + '/';
FRequest.AddParameter('query', '{"username":"'+AUserName+'"}', TRESTRequestParameterKind.pkGETorPOST); // Do not localize
FRequest.Execute;
CheckForResponseError;
LUsers := FRequest.Response.JSONValue as TJSONArray;
if LUsers.Count > 1 then
raise EKinveyAPIError.Create(sOneUserExpected);
Result := LUsers.Count = 1;
if Result then
begin
LUserObject := LUsers.Items[0] as TJSONObject;
AUser := UserFromObject(LUserObject);
if Assigned(AJSON) then
AJSON.AddElement(LUserObject.Clone as TJSONObject);
if Assigned(AProc) then
AProc(AUser, LUserObject);
end;
end;
function TKinveyApi.QueryUserName(const AUserName: string;
AProc: TQueryUserNameProc): Boolean;
var
LUser: TUser;
begin
Result := QueryUserName(AUserName, LUser, nil, AProc);
end;
function TKinveyApi.QueryUserName(const AUserName: string; out AUser: TUser;
const AJSON: TJSONArray): Boolean;
begin
Result := QueryUserName(AUserName, AUser, AJSON, nil);
end;
function TKinveyApi.RetrieveUser(const AObjectID: string; out AUser: TUser; const AJSON: TJSONArray; AProc: TRetrieveUserProc): Boolean;
var
LResponse: TJSONObject;
begin
Result := False;
CheckObjectID(AObjectID);
FRequest.ResetToDefaults;
AddAuthParameter;
FRequest.Method := TRESTRequestMethod.rmGET;
FRequest.Resource := sUserAppKey + '/{userId}'; // do not localize
FRequest.AddParameter('userId', AObjectID, TRESTRequestParameterKind.pkURLSEGMENT);
FRequest.Execute;
CheckForResponseError([404]); // 404 = not found
if FRequest.Response.StatusCode <> 404 then
begin
Result := True;
LResponse := FRequest.Response.JSONValue as TJSONObject;
AUser := UserFromObject(LResponse);
if Assigned(AJSON) then
AJSON.AddElement(LResponse.Clone as TJSONObject);
if Assigned(AProc) then
AProc(AUser, LResponse);
end
end;
function TKinveyApi.RetrieveUser(const AObjectID: string; AProc: TRetrieveUserProc): Boolean;
var
LUser: TUser;
begin
Result := RetrieveUser(AObjectID, LUser, nil, AProc);
end;
function TKinveyApi.RetrieveUser(const AUser: TUser; out AFoundUser: TUser;
const AJSON: TJSONArray): Boolean;
begin
Result := RetrieveUser(AUser.ObjectID, AFoundUser, AJSON, nil);
end;
function TKinveyApi.RetrieveUser(const AUser: TUser; AProc: TRetrieveUserProc): Boolean;
var
LUser: TUser;
begin
Result := RetrieveUser(AUser.ObjectID, LUser, nil, AProc);
end;
function TKinveyApi.RetrieveUser(const AObjectID: string; out AUser: TUser; const AJSON: TJSONArray): Boolean;
begin
Result := RetrieveUser(AObjectID, AUser, AJSON, nil);
end;
function TKinveyAPI.RetrieveCurrentUser(AProc: TRetrieveUserProc): Boolean;
var
LUser: TUser;
begin
Result := RetrieveUser('_me', LUser, nil, AProc); // Do not localize
end;
function TKinveyAPI.RetrieveCurrentUser(out AUser: TUser; const AJSON: TJSONArray): Boolean;
begin
Result := RetrieveUser('_me', AUser, AJSON, nil); // Do not localize
end;
procedure TKinveyApi.QueryFiles(const AQuery: array of string; const AJSONArray: TJSONArray);
var
LResource: string;
begin
LResource := sBlobAppKey;
QueryResource(LResource, AQuery, AJSONArray, True);
end;
procedure TKinveyApi.QueryFiles(const AQuery: array of string; const AJSONArray: TJSONArray; out AFiles: TArray<TFile>);
var
LJSONValue: TJSONValue;
LList: TList<TFile>;
LFile: TFile;
LResource: string;
begin
LResource := sBlobAppKey;
QueryResource(LResource, AQuery, AJSONArray, True);
LList := TList<TFile>.Create;
try
for LJSONValue in AJSONArray do
begin
if LJSONValue is TJSONObject then
begin
LFile := FileFromObject(TJSONObject(LJSONValue));
LList.Add(LFile);
end
else
raise EKinveyAPIError.Create(sJSONObjectExpected);
end;
AFiles := LList.ToArray;
finally
LList.Free;
end;
end;
function TKinveyApi.RetrieveFile(const AFileID: string; out AFile: TFile; const AJSON: TJSONArray; AProc: TRetrieveFileProc): Boolean;
var
LResponse: TJSONObject;
begin
Result := False;
CheckObjectID(AFileID);
FRequest.ResetToDefaults;
FRequest.Method := TRESTRequestMethod.rmGET;
FRequest.Resource := sBlobAppKey + '/{Id}'; // do not localize
FRequest.AddParameter('Id', AFileID, TRESTRequestParameterKind.pkURLSEGMENT);
AddAuthParameter;
FRequest.Execute;
CheckForResponseError([404]); // 404 = not found
if FRequest.Response.StatusCode <> 404 then
begin
Result := True;
LResponse := FRequest.Response.JSONValue as TJSONObject;
AFile := FileFromObject(LResponse);
if Assigned(AJSON) then
AJSON.AddElement(LResponse.Clone as TJSONObject);
if Assigned(AProc) then
AProc(AFile, LResponse);
end
end;
function TKinveyApi.RetrieveFile(const AFileID: string; AProc: TRetrieveFileProc): Boolean;
var
LFile: TFile;
begin
Result := RetrieveFile(AFileID, LFile, nil, AProc);
end;
function TKinveyApi.RetrieveFile(const AFile: TFile; AProc: TRetrieveFileProc): Boolean;
var
LFile: TFile;
begin
Result := RetrieveFile(AFile.ID, LFile, nil, AProc);
end;
function TKinveyApi.RetrieveFile(const AFileID: string; out AFile: TFile; const AJSON: TJSONArray): Boolean;
begin
Result := RetrieveFile(AFileID, AFile, AJSON, nil);
end;
function TKinveyApi.RetrieveFile(const AFile: TFile; out AFoundFile: TFile; const AJSON: TJSONArray): Boolean;
begin
Result := RetrieveFile(AFile.ID, AFoundFile, AJSON, nil);
end;
{ User groups }
// AID may be blank, to generate id
procedure TKinveyApi.CreateUserGroup(const AID: string; const AUsersAndGroups: TJSONObject; out ANewUserGroup: TUserGroup);
begin
CreateUserGroup(AID, nil, AUsersAndGroups, ANewUserGroup);
end;
procedure TKinveyApi.CreateUserGroup(const AID: string; const AACL, AUsersAndGroups: TJSONObject; out ANewUserGroup: TUserGroup);
var
LNewObject: TObjectID;
LJSON: TJSONObject;
begin
LJSON := nil;
try
if AID <> '' then
begin
if AUsersAndGroups <> nil then
LJSON := AUsersAndGroups.Clone as TJSONObject
else
LJSON := TJSONObject.Create;
LJSON.AddPair('_id', AID); // Do not localize
end
else
LJSON := AUsersAndGroups;
PostObject(sUserGroupAppKey, '', AACL, LJSON, LNewObject, True);
ANewUserGroup.FObjectID := LNewObject.ObjectID;
finally
if LJSON <> AUsersAndGroups then
LJSON.Free;
end;
end;
procedure TKinveyApi.UpdateUserGroup(const AID: string; const AUsersAndGroups: TJSONObject; out AUpdateObject: TObjectID);
begin
CheckObjectID(AID);
FRequest.ResetToDefaults;
AddAuthParameter;
PutObject(sUserGroupAppKey, '', AID, AUsersAndGroups, AUpdateObject, False);
end;
procedure TKinveyApi.UpdateUserGroup(const AUserGroup: TUserGroup; const AUsersAndGroups: TJSONObject; out AUpdateObject: TObjectID);
begin
UpdateUserGroup(AUserGroup.ObjectID, AUsersAndGroups, AUpdateObject);
end;
function TKinveyApi.DeleteUserGroup(const AUserGroup: TUserGroup): Boolean;
begin
Result := DeleteUserGroup(AUserGroup.ObjectID);
end;
function TKinveyApi.DeleteUserGroup(const AID: string): Boolean;
begin
FRequest.ResetToDefaults;
AddAuthParameter;
FRequest.Method := TRESTRequestMethod.rmDELETE;
FRequest.Resource := sUserGroupAppKey + '/{Id}'; // do not localize
FRequest.AddParameter('Id', AID, TRESTRequestParameterKind.pkURLSEGMENT); // Do not localize
FRequest.Execute;
CheckForResponseError([404]);
Result := FRequest.Response.StatusCode <> 404
end;
function TKinveyApi.RetrieveUserGroup(const AObjectID: string; out AUserGroup: TUserGroup; const AJSON: TJSONArray; AProc: TRetrieveUserGroupProc): Boolean;
var
LResponse: TJSONObject;
begin
Result := False;
CheckObjectID(AObjectID);
FRequest.ResetToDefaults;
AddAuthParameter;
FRequest.Method := TRESTRequestMethod.rmGET;
FRequest.Resource := sUserGroupAppKey + '/{Id}'; // do not localize
FRequest.AddParameter('Id', AObjectID, TRESTRequestParameterKind.pkURLSEGMENT);
FRequest.Execute;
CheckForResponseError([404]); // 404 = not found
if FRequest.Response.StatusCode <> 404 then
begin
Result := True;
LResponse := FRequest.Response.JSONValue as TJSONObject;
AUserGroup := UserGroupFromObject('', LResponse);
if Assigned(AJSON) then
AJSON.AddElement(LResponse.Clone as TJSONObject);
if Assigned(AProc) then
AProc(AUserGroup, LResponse);
end
end;
function TKinveyApi.RetrieveUserGroup(const AObjectID: string; AProc: TRetrieveUserGroupProc): Boolean;
var
LUser: TUserGroup;
begin
Result := RetrieveUserGroup(AObjectID, LUser, nil, AProc);
end;
function TKinveyApi.RetrieveUserGroup(const AUserGroup: TUserGroup; out AFoundUserGroup: TUserGroup;
const AJSON: TJSONArray): Boolean;
begin
Result := RetrieveUserGroup(AUserGroup.ObjectID, AFoundUserGroup, AJSON, nil);
end;
function TKinveyApi.RetrieveUserGroup(const AUserGroup: TUserGroup; AProc: TRetrieveUserGroupProc): Boolean;
var
LUser: TUserGroup;
begin
Result := RetrieveUserGroup(AUserGroup.ObjectID, LUser, nil, AProc);
end;
function TKinveyApi.RetrieveUserGroup(const AObjectID: string; out AUserGroup: TUserGroup; const AJSON: TJSONArray): Boolean;
begin
Result := RetrieveUserGroup(AObjectID, AUserGroup, AJSON, nil);
end;
function ValueToJsonValue(AValue: TValue): TJSONValue;
begin
if AValue.IsType<Int64> then
Result := TJSONNumber.Create(AValue.AsInt64)
else if AValue.IsType<Extended> then
Result := TJSONNumber.Create(AValue.AsExtended)
else if AValue.IsType<string> then
Result := TJSONString.Create(AValue.AsString)
else
Result := TJSONString.Create(AValue.ToString)
end;
{ TKinveyAPI.TKinveyConnectionInfo }
constructor TKinveyAPI.TConnectionInfo.Create(const AApiVersion, AAppKey: string);
begin
ApiVersion := AApiVersion;
AppKey := AAppKey;
end;
{ TObjectID }
constructor TKinveyAPI.TObjectID.Create(const ABackendCollectionName: string; AObjectID: string);
begin
FBackendCollectionName := ABackendCollectionName;
FObjectID := AObjectID;
end;
{ TKinveyApi.TFile}
constructor TKinveyApi.TFile.Create(const AID: string);
begin
FID := AID;
end;
{ TKinveyApi.TUserID }
constructor TKinveyApi.TUser.Create(const AUserName: string);
begin
FUserName := AUserName;
end;
{ TKinveyApi.TLogin }
constructor TKinveyApi.TLogin.Create(const AAuthToken: string;
const AUser: TUser);
begin
FAuthToken := AAuthToken;
FUser := AUser;
end;
{ TKinveyApi.TUpdatedAt }
constructor TKinveyApi.TUpdatedAt.Create(AUpdatedAt: TDateTime);
begin
FUpdatedAt := AUpdatedAt;
end;
{ EKinveyAPIError }
constructor EKinveyAPIError.Create(const AError, ADescription: string);
begin
FDescription := ADescription;
FError := AError;
inherited CreateFmt(sFormatKinveyError, [Self.Error, Self.Description]);
end;
end.
|
unit UnProdutoSearch;
interface
uses Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.StdCtrls, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.ExtCtrls, Vcl.ComCtrls, Data.DB, Data.SqlExpr, Data.FMTBcd,
Datasnap.Provider, Datasnap.DBClient, Data.DBXFirebird, Vcl.Grids, Vcl.DBGrids
{ Fluente }
;
type
TProdutoLookUp = class(TObject)
private
FDataSource: TDataSource;
FEdit: TCustomEdit;
FList: TDBGrid;
FObserver: TNotifyEvent;
FParent: TControl;
protected
procedure ActivateList(const Sender: TObject);
procedure DeactivateList(const Sender: TObject);
procedure SelectProduto;
public
constructor Create(const EditControl: TCustomEdit;
const DataSource: TDataSource; const Parent: TControl;
const Observer: TNotifyEvent); reintroduce;
procedure OnChange(Sender: TObject);
procedure OnEnter(Sender: TObject);
procedure OnExit(Sender: TObject);
procedure OnKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
procedure OnKeyPress(Sender: TObject);
procedure OnKeyUp(Sender: TObject);
procedure ListOnKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
procedure ListOnDblClick(Sender: TObject);
end;
var
ProdutoLookUp: TProdutoLookUp;
implementation
procedure TProdutoLookUp.ActivateList(const Sender: TObject);
begin
if not Self.FList.Visible then
begin
Self.FList.Align := alClient;
Self.FList.Visible := True;
Self.FList.Parent := TWinControl(Sender);
Self.FParent.Height := 240;
Self.FParent.Visible := True;
end;
end;
constructor TProdutoLookUp.Create(const EditControl: TCustomEdit;
const DataSource: TDataSource; const Parent: TControl;
const Observer: TNotifyEvent);
begin
inherited Create();
Self.FDataSource := DataSource;
Self.FParent := Parent;
Self.FObserver := Observer;
// Referência ao Controle de Edição
Self.FEdit := EditControl;
//
// to-do: ligar eventos aos métodos
//
TEdit(Self.FEdit).OnChange := Self.OnChange;
TEdit(Self.FEdit).OnKeyDown := Self.OnKeyDown;
// Grid
Self.FList := TDBGrid.Create(nil);
Self.FList.Visible := False;
Self.FList.DataSource := Self.FDataSource;
Self.FList.Ctl3D := False;
Self.FList.Options := Self.FList.Options - [dgTitles, dgEditing, dgIndicator, dgColLines, dgRowLines] + [dgRowSelect];
Self.FList.Font.Name := 'Segoe UI';
Self.FList.Font.Size := 12;
Self.FList.Font.Style := [fsBold];
Self.FList.OnKeyDown := Self.ListOnKeyDown;
Self.FList.OnDblClick := Self.ListOnDblClick;
end;
procedure TProdutoLookUp.DeactivateList(const Sender: TObject);
begin
Self.FParent.Visible := False;
Self.FList.Visible := False;
end;
procedure TProdutoLookUp.ListOnDblClick(Sender: TObject);
begin
Self.SelectProduto();
Self.DeactivateList(Sender);
end;
procedure TProdutoLookUp.ListOnKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
if Key = VK_RETURN then
begin
Self.SelectProduto();
Self.DeactivateList(Sender);
end
else
if not (Key in [VK_DOWN, VK_UP]) then
Self.FEdit.SetFocus();
end;
procedure TProdutoLookUp.OnChange(Sender: TObject);
var
iDataSet: TClientDataSet;
begin
Self.ActivateList(Self.FParent);
iDataSet := TClientDataSet(Self.FDataSource.DataSet);
iDataSet.Active := False;
iDataSet.CommandText := Format('SELECT PRO_OID, PRO_DES, PRO_VENDA FROM PRO WHERE PRO_DES LIKE %s ORDER BY PRO_DES', [QuotedStr('%' + TEdit(Sender).Text + '%')]);
iDataSet.Active := True;
end;
procedure TProdutoLookUp.OnEnter(Sender: TObject);
begin
end;
procedure TProdutoLookUp.OnExit(Sender: TObject);
begin
end;
procedure TProdutoLookUp.OnKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
if Key = VK_ESCAPE then
else
if Key = VK_RETURN then
begin
Self.SelectProduto();
Self.DeactivateList(Sender);
end
else
if Key = VK_DOWN then
Self.FList.SetFocus()
else
TCustomEdit(Sender).SetFocus();
end;
procedure TProdutoLookUp.OnKeyPress(Sender: TObject);
begin
end;
procedure TProdutoLookUp.OnKeyUp(Sender: TObject);
begin
end;
procedure TProdutoLookUp.SelectProduto;
begin
if Assigned(Self.FObserver) then
Self.FObserver(Self)
end;
end.
|
unit WinAPI.HSTRINGIterables;
interface
uses
System.Win.WinRT, WinAPI.CommonTypes, System.Generics.Collections,
WinAPI.WinRT;
type
THSTRINGList = class(TList<HSTRING>)
public
procedure AddAsCopy(const AHSTRING: HSTRING);
end;
TIterableHSTRING = class(TInspectableObject, IIterable_1__HSTRING)
private
FList: THSTRINGList;
public
constructor Create;
destructor Destroy; override;
function First: IIterator_1__HSTRING; safecall;
procedure Add(AValue: HSTRING);
end;
TIteratorHSTRING = class(TInspectableObject, IIterator_1__HSTRING)
private
FList: THSTRINGList;
FIndex: Integer;
public
constructor Create(const AListOfHSTRING: THSTRINGList);
destructor Destroy; override;
function MoveNext: Boolean; safecall;
function get_Current: HSTRING; safecall;
function get_HasCurrent: Boolean; safecall;
function GetMany(itemsSize: Cardinal; items: PHSTRING): Cardinal; safecall;
end;
function CreateHSTRING(const S: string): HSTRING;
function CreateHSTRINGRef(var S: string): HSTRING;
function HSTRINGToString(const hs: HSTRING): string;
function HSTRINGIsNullOrEmpty(const hs: HSTRING): Boolean;
procedure DeleteHSTRING(const hs: HSTRING);
implementation
uses
System.SysUtils, WinAPI.Windows, System.Classes;
resourcestring
StrCannotCreateHSTRING = 'Cannot create HSTRING';
StrCannotCreateHSTRINGRef = 'Cannot create HSTRINGRef';
StrCannotDeleteHSTRING = 'Cannot delete HSTRING';
StrCannotCopyHSTRING = 'Cannot copy HSTRING';
StrNotImplemented = 'Not Implemented';
function CreateHSTRING(const S: string): HSTRING;
begin
if not Succeeded(WindowsCreateString(PChar(S), System.Length(S), Result)) then
raise Exception.Create(StrCannotCreateHSTRING);
end;
function CreateHSTRINGRef(var S: string): HSTRING;
var
P: HSTRING_HEADER;
begin
if not Succeeded(WindowsCreateStringReference(PChar(S), System.Length(S), P, Result)) then
raise Exception.Create(StrCannotCreateHSTRINGRef);
end;
function HSTRINGToString(const hs: HSTRING): string;
begin
Result := WindowsGetStringRawBuffer(hs, nil);
end;
function HSTRINGIsNullOrEmpty(const hs: HSTRING): Boolean;
begin
Result := WindowsIsStringEmpty(hs);
end;
procedure DeleteHSTRING(const hs: HSTRING);
begin
if not Succeeded(WindowsDeleteString(hs)) then
raise Exception.Create(StrCannotDeleteHSTRING);
end;
{ TIterableHSTRING }
procedure TIterableHSTRING.Add(AValue: HSTRING);
begin
FList.Add(AValue);
end;
constructor TIterableHSTRING.Create;
begin
inherited;
FList := THSTRINGList.Create;
end;
destructor TIterableHSTRING.Destroy;
begin
inherited;
end;
function TIterableHSTRING.First: IIterator_1__HSTRING;
begin
Result := TIteratorHSTRING.Create(FList);
end;
{ TIteratorHSTRING }
constructor TIteratorHSTRING.Create(const AListOfHSTRING: THSTRINGList);
var
lHSTRING, lOutHSTRING: HSTRING;
begin
inherited Create;
FList := THSTRINGList.Create;
for lHSTRING in AListOfHSTRING do
begin
if not Succeeded(WindowsDuplicateString(lHSTRING, lOutHSTRING)) then
raise Exception.Create(StrCannotCopyHSTRING);
FList.Add(lOutHSTRING);
end;
FIndex := 0;
end;
destructor TIteratorHSTRING.Destroy;
begin
FList.Free;
inherited;
end;
function TIteratorHSTRING.GetMany(itemsSize: Cardinal; items: PHSTRING): Cardinal;
begin
raise Exception.Create(StrNotImplemented);
end;
function TIteratorHSTRING.get_Current: HSTRING;
begin
Result := FList[FIndex];
end;
function TIteratorHSTRING.get_HasCurrent: Boolean;
begin
Result := FIndex < FList.Count;
end;
function TIteratorHSTRING.MoveNext: Boolean;
begin
Result := FIndex < (FList.Count - 1);
if Result then
Inc(FIndex);
end;
{ THSTRINGList }
procedure THSTRINGList.AddAsCopy(const AHSTRING: HSTRING);
var
lOutHSTRING: HSTRING;
begin
if not Succeeded(WindowsDuplicateString(AHSTRING, lOutHSTRING)) then
raise Exception.Create(StrCannotCopyHSTRING);
Add(lOutHSTRING);
end;
end.
|
unit NtUtils.Security.AppContainer;
interface
uses
Winapi.WinNt, Ntapi.ntrtl, NtUtils.Exceptions, NtUtils.Security.Sid;
{ Capabilities }
// Convert a capability name to a SID
function RtlxLookupCapability(Name: String; out CapabilityGroupSid,
CapabilitySid: ISid): TNtxStatus;
{ AppContainer }
// Convert an AppContainer name to a SID
function RtlxAppContainerNameToSid(Name: String; out Sid: ISid): TNtxStatus;
// Get a child AppContainer SID based on its name and parent
function RtlxAppContainerChildNameToSid(ParentSid: ISid; Name: String;
out ChildSid: ISid): TNtxStatus;
// Convert a SID to an AppContainer name
function RtlxAppContainerSidToName(Sid: PSid; out Name: String): TNtxStatus;
// Get type of an SID
function RtlxGetAppContainerType(Sid: PSid): TAppContainerSidType;
// Get a SID of a parent AppContainer
function RtlxGetAppContainerParent(AppContainerSid: PSid;
out AppContainerParent: ISid): TNtxStatus;
implementation
uses
Ntapi.ntdef, NtUtils.Ldr, Winapi.UserEnv, Ntapi.ntstatus;
function RtlxLookupCapability(Name: String; out CapabilityGroupSid,
CapabilitySid: ISid): TNtxStatus;
var
BufferGroup, BufferSid: PSid;
NameStr: UNICODE_STRING;
begin
Result := LdrxCheckNtDelayedImport('RtlDeriveCapabilitySidsFromName');
if not Result.IsSuccess then
Exit;
NameStr.FromString(Name);
BufferGroup := nil;
BufferSid := nil;
try
BufferGroup := AllocMem(RtlLengthRequiredSid(
SECURITY_INSTALLER_GROUP_CAPABILITY_RID_COUNT));
BufferSid := AllocMem(RtlLengthRequiredSid(
SECURITY_INSTALLER_CAPABILITY_RID_COUNT));
Result.Location := 'RtlDeriveCapabilitySidsFromName';
Result.Status := RtlDeriveCapabilitySidsFromName(NameStr, BufferGroup,
BufferSid);
if Result.IsSuccess then
begin
CapabilityGroupSid := TSid.CreateCopy(BufferGroup);
CapabilitySid := TSid.CreateCopy(BufferSid);
end;
finally
FreeMem(BufferGroup);
FreeMem(BufferSid);
end;
end;
function RtlxAppContainerNameToSid(Name: String; out Sid: ISid): TNtxStatus;
var
Buffer: PSid;
begin
Result := LdrxCheckModuleDelayedImport(kernelbase,
'AppContainerDeriveSidFromMoniker');
if not Result.IsSuccess then
Exit;
Result.Location := 'AppContainerDeriveSidFromMoniker';
Result.HResult := AppContainerDeriveSidFromMoniker(PWideChar(Name),
Buffer);
if Result.IsSuccess then
begin
Sid := TSid.CreateCopy(Buffer);
RtlFreeSid(Buffer);
end;
end;
function RtlxAppContainerChildNameToSid(ParentSid: ISid; Name: String;
out ChildSid: ISid): TNtxStatus;
var
Sid: ISid;
i: Integer;
SubAuthorities: TArray<Cardinal>;
begin
// Construct the SID manually by reproducing the behavior of
// DeriveRestrictedAppContainerSidFromAppContainerSidAndRestrictedName
if RtlxGetAppContainerType(ParentSid.Sid) <> ParentAppContainerSidType then
begin
Result.Location := 'RtlxAppContainerRestrictedNameToSid';
Result.Status := STATUS_INVALID_SID;
Exit;
end;
// Construct an SID using the child's name as it is a parent's name
Result := RtlxAppContainerNameToSid(Name, Sid);
if not Result.IsSuccess then
Exit;
SetLength(SubAuthorities, SECURITY_CHILD_PACKAGE_RID_COUNT);
// Copy all parent sub-authorities (8 of 12 available)
for i := 0 to ParentSid.SubAuthorities - 1 do
SubAuthorities[i] := ParentSid.SubAuthority(i);
// Append the last four child's sub-authorities to the SID
for i := SECURITY_PARENT_PACKAGE_RID_COUNT to
SECURITY_CHILD_PACKAGE_RID_COUNT - 1 do
SubAuthorities[i] := Sid.SubAuthority(i - SECURITY_CHILD_PACKAGE_RID_COUNT
+ SECURITY_PARENT_PACKAGE_RID_COUNT);
// Make a child SID with these sub-authorities
ChildSid := TSid.Create(SECURITY_APP_PACKAGE_AUTHORITY, SubAuthorities);
end;
function RtlxAppContainerSidToName(Sid: PSid; out Name: String): TNtxStatus;
var
Buffer: PWideChar;
begin
Result := LdrxCheckModuleDelayedImport(kernelbase,
'AppContainerLookupMoniker');
if not Result.IsSuccess then
Exit;
Result := LdrxCheckModuleDelayedImport(kernelbase, 'AppContainerFreeMemory');
if not Result.IsSuccess then
Exit;
Result.Location := 'AppContainerLookupMoniker';
Result.HResult := AppContainerLookupMoniker(Sid, Buffer);
if Result.IsSuccess then
begin
Name := String(Buffer);
AppContainerFreeMemory(Buffer);
end;
end;
function RtlxGetAppContainerType(Sid: PSid): TAppContainerSidType;
begin
// If ntdll does not have this function then
// the OS probably does not support appcontainers
if not LdrxCheckNtDelayedImport('RtlGetAppContainerSidType').IsSuccess or
not NT_SUCCESS(RtlGetAppContainerSidType(Sid, Result)) then
Result := NotAppContainerSidType;
end;
function RtlxGetAppContainerParent(AppContainerSid: PSid;
out AppContainerParent: ISid): TNtxStatus;
var
Buffer: PSid;
begin
Result := LdrxCheckNtDelayedImport('RtlGetAppContainerParent');
if not Result.IsSuccess then
Exit;
Result.Location := 'RtlGetAppContainerParent';
Result.Status := RtlGetAppContainerParent(AppContainerSid, Buffer);
if Result.IsSuccess then
begin
AppContainerParent := TSid.CreateCopy(Buffer);
RtlFreeSid(Buffer);
end;
end;
end.
|
unit fInspector;
interface
uses
Windows, Types, UITypes, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
Ex_Grid, Ex_Inspector, StdCtrls, ExtCtrls, ImgList,
FlexBase, FlexProps, FlexControls,
cxGraphics, cxControls, cxLookAndFeels, cxLookAndFeelPainters, cxContainer, cxEdit, cxScrollBox,
dxSkinsCore, cxLabel, cxTextEdit, cxMaskEdit, cxSplitter, cxColorComboBox, cxMemo, cxProgressBar,
cxDropDownEdit, cxCalendar, dxSkinscxPCPainter, dxBarBuiltInMenu, cxPC, cxTimeEdit, cxRadioGroup,
cxGroupBox, cxSpinEdit, cxCheckBox, cxButtonEdit, cxButtons, cxCheckListBox, cxListBox, cxListView,
cxImage, dxSkinOffice2010Silver;
const
WM_REFRESH_DATA = WM_USER + 1;
type
TfmInspector = class(TForm)
Panel1: TcxGroupBox;
cbInspItems: TcxComboBox;
imgCtrlIcons: TImageList;
grInspector: TExInspector;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure grInspectorGetCellText(Sender: TObject; Cell: TGridCell;
var Value: String);
procedure grInspectorGetEditStyle(Sender: TObject; Cell: TGridCell;
var Style: TGridEditStyle);
procedure grInspectorEditButtonPress(Sender: TObject; Cell: TGridCell);
procedure grInspectorSetEditText(Sender: TObject; Cell: TGridCell;
var Value: String);
procedure grInspectorGetEditList(Sender: TObject; Cell: TGridCell;
Items: TStrings);
procedure grInspectorChange(Sender: TObject; Cell: TGridCell;
Selected: Boolean);
procedure grInspectorDblClick(Sender: TObject);
procedure cbInspItemsDrawItem(AControl: TcxCustomComboBox; ACanvas: TcxCanvas; AIndex: Integer; const ARect: TRect; AState: TOwnerDrawState);
procedure cbInspItemsChange(Sender: TObject);
private
{ Private declarations }
FActiveFlex: TFlexPanel;
FFlexControl: TFlexControl;
FLastPropName: string;
procedure grInspectorEditCanModify(Sender: TObject; Cell: TGridCell;
var CanModify: Boolean);
procedure grInspectorEditCloseUp(Sender: TObject; Cell: TGridCell;
ItemIndex: Integer; var Accept: Boolean);
function GetControlIconIndex(AControl: TFlexControl): integer;
procedure SetActiveFlex(const Value: TFlexPanel);
procedure SetFlexControl(const Value: TFlexControl);
procedure ChangePropValue(Cell: TGridCell; var Value: string;
var Accept: Boolean);
procedure WMRefreshData(var Message: TMessage); message WM_REFRESH_DATA;
procedure SetcbInspItemsItemIndex(n: integer);
public
{ Public declarations }
procedure UpdateData;
procedure UpdateProps(Prop: TCustomProp);
property ActiveFlex: TFlexPanel read FActiveFlex write SetActiveFlex;
property Control: TFlexControl read FFlexControl write SetFlexControl;
end;
var
fmInspector: TfmInspector;
implementation
{$R *.DFM}
uses
ToolMngr, FlexActions;
procedure TfmInspector.FormCreate(Sender: TObject);
begin
RegisterToolForm(Self);
grInspector.Columns[0].Width := 80;
grInspector.OnEditCanModify := grInspectorEditCanModify;
grInspector.OnEditCloseUp := grInspectorEditCloseUp;
end;
procedure TfmInspector.FormDestroy(Sender: TObject);
begin
UnRegisterToolForm(Self);
fmInspector := Nil;
end;
procedure TfmInspector.FormShow(Sender: TObject);
begin
// Avoid align bug
cbInspItems.Align := alTop;
cbInspItems.Width := Self.ClientWidth;
end;
procedure TfmInspector.SetActiveFlex(const Value: TFlexPanel);
begin
if Value = FActiveFlex then exit;
{if not Assigned(Value) then }Control := Nil;
FActiveFlex := Value;
UpdateData;
UpdateProps(Nil);
end;
procedure TfmInspector.SetcbInspItemsItemIndex(n: integer);
begin
cbInspItems.Properties.OnChange := nil;
cbInspItems.ItemIndex := n;
cbInspItems.Properties.OnChange := cbInspItemsChange;
end;
procedure TfmInspector.SetFlexControl(const Value: TFlexControl);
var i: integer;
begin
if Value = FFlexControl then exit;
if Assigned(FActiveFlex) and not
(csDestroying in FActiveFlex.ComponentState) then
grInspector.Editing := False;
grInspector.AllowEdit := False;
try
FFlexControl := Value;
if Assigned(FActiveFlex) and Assigned(FFlexControl) then begin
SetcbInspItemsItemIndex(cbInspItems.Properties.Items.IndexOfObject(FFlexControl));
FFlexControl.Props.Sort();
grInspector.Rows.Count := FFlexControl.Props.VisibleCount;
for i:=0 to grInspector.Rows.Count-1 do
if CompareStr(FLastPropName,
FFlexControl.Props.VisiblePropNames[i]) = 0 then begin
grInspector.CellFocused := GridCell(1, i);
break;
end;
if grInspector.EditCell.Row >= 0 then begin
grInspector.Editing := True;
grInspector.Edit.Text :=
FFlexControl.Props.VisibleProps[grInspector.EditCell.Row].DisplayValue;
end;
end else begin
SetcbInspItemsItemIndex(-1);
grInspector.Rows.Count := 0;
end;
finally
grInspector.AllowEdit := True;
if grInspector.Rows.Count > 0 then begin
grInspector.AlwaysEdit := True;
grInspector.Editing := True;
end;
end;
end;
procedure TfmInspector.UpdateData;
var Msg: TMsg;
begin
if HandleAllocated then begin
// Remove all existing refresh messages
while PeekMessage(Msg, Handle, WM_REFRESH_DATA, WM_REFRESH_DATA, PM_REMOVE) do ;
// Add new refresh message to the end
PostMessage(Handle, WM_REFRESH_DATA, 0, 0);
end;
end;
procedure TfmInspector.WMRefreshData(var Message: TMessage);
var SelControl, Control, NewControl: TFlexControl;
StrList, LayersList: TStringList;
Flex: TFlexPanel;
Scheme: TFlexCustomScheme;
PassRec: TPassControlRec;
i, j, Level, DLevel: integer;
AName, APrefix, NewPrefix: string;
begin
StrList := Nil;
cbInspItems.Properties.Items.BeginUpdate;
try
{ if cbInspItems.ItemIndex >= 0
then SelControl := cbInspItems.Items.Objects[cbInspItems.ItemIndex]
else SelControl := Nil; }
SelControl := Nil;
StrList := TStringList.Create;
Flex := ActiveFlex;
if Assigned(Flex) and not (csDestroying in Flex.ComponentState) then begin
if Flex.SelectedCount = 1 then SelControl := Flex.Selected[0];
Scheme := Flex.ActiveScheme;
if Assigned(Scheme) then begin
APrefix := '';
Control := Scheme;
FirstControl(Control, PassRec);
while Assigned(Control) do begin
AName := Control.Name;
StrList.AddObject(APrefix + AName, Control);
Level := High(PassRec.Indexes);
Control := NextControl(PassRec);
DLevel := High(PassRec.Indexes) - Level;
if DLevel = 0 then continue;
NewPrefix := '';
NewControl := Control;
for i:=0 to Abs(DLevel)-1 do
if DLevel > 0 then begin
NewControl := NewControl.Parent;
if not (NewControl is TFlexScheme) then
NewPrefix := NewControl.Name + '.' + NewPrefix;
end else begin
j := Length(APrefix) - 1;
while (j > 0) and (APrefix[j] <> '.') do dec(j);
SetLength(APrefix, j);
end;
APrefix := APrefix + NewPrefix;
end;
StrList.Sort;
i := StrList.IndexOfObject(Scheme);
if i >= 0 then StrList.Move(i, 0);
end;
if Flex.Layers.Count > 0 then begin
LayersList := TStringList.Create;
try
for i:=0 to Flex.Layers.Count-1 do
LayersList.AddObject(Flex.Layers[i].Name, Flex.Layers[i]);
LayersList.Sort;
j := 0;
if (StrList.Count > 0) and (StrList.Objects[0] is TFlexScheme) then inc(j);
for i:=LayersList.Count-1 downto 0 do
StrList.InsertObject(j, LayersList[i], LayersList.Objects[i]);
finally
LayersList.Free;
end;
end;
end;
cbInspItems.Properties.Items.Assign(StrList);
SetcbInspItemsItemIndex(cbInspItems.Properties.Items.IndexOfObject(SelControl));
Self.Control := SelControl;
finally
cbInspItems.Properties.Items.EndUpdate;
StrList.Free;
end;
end;
procedure TfmInspector.UpdateProps(Prop: TCustomProp);
var Index: integer;
Value: string;
begin
if Assigned(Prop) and Assigned(FFlexControl) then begin
Index := FFlexControl.Props.VisibleIndexOf(Prop);
if Index >= 0 then begin
if grInspector.EditCell.Row = Index then begin
Value := '';
grInspectorGetCellText(grInspector, GridCell(1, Index), Value);
if grInspector.Edit.DropListVisible and
Assigned(grInspector.Edit.ActiveList) then
with TGridListBox(grInspector.Edit.ActiveList) do begin
Index := Items.IndexOf(Value);
ItemIndex := Index;
end
else
grInspector.Edit.Text := Value;
end else
grInspector.InvalidateCell(GridCell(1, Index));
end;
end else
grInspector.Refresh(); // InvalidateColumn(1)
end;
procedure TfmInspector.grInspectorGetCellText(Sender: TObject;
Cell: TGridCell; var Value: String);
begin
if not Assigned(FFlexControl) then exit;
try
if Cell.Col = 0 then
Value := FFlexControl.Props.VisiblePropTranslatedNames[Cell.Row]
else
Value := FFlexControl.Props.VisibleProps[Cell.Row].DisplayValue;
except
Value := '';
end;
end;
procedure TfmInspector.grInspectorGetEditStyle(Sender: TObject;
Cell: TGridCell; var Style: TGridEditStyle);
var Prop: TCustomProp;
begin
if not Assigned(FFlexControl) then exit;
Prop := FFlexControl.Props.VisibleProps[Cell.Row];
if psEditForm in Prop.Style then
Style := geEllipsis
else
if Prop.IsEnum then
Style := gePickList
else
Style := geSimple;
end;
procedure TfmInspector.ChangePropValue(Cell: TGridCell; var Value: string;
var Accept: Boolean);
var Prop: TCustomProp;
// CanModify: boolean;
begin
Accept := false;
if not Assigned(FFlexControl) or grInspector.IsCellReadOnly(Cell) then exit;
// grInspectorEditCanModify(grInspector, Cell, CanModify);
Prop := Nil;
try
Prop := FFlexControl.Props.VisibleProps[Cell.Row];
if psReadOnly in Prop.Style then exit;
if Prop.DisplayValue <> Value then begin
FActiveFlex.History.BeginPanelGroup(TPanelPropsHistoryGroup);
try
Prop.DisplayValue := Value;
Accept := true;
finally
FActiveFlex.History.EndPanelGroup(TPanelPropsHistoryGroup);
end;
end else
exit;
except
Application.HandleException(Self);
end;
if Assigned(Prop) then
try
Value := Prop.DisplayValue;
except
Value := '';
end;
end;
procedure TfmInspector.grInspectorEditCloseUp(Sender: TObject;
Cell: TGridCell; ItemIndex: Integer; var Accept: Boolean);
var Prop: TCustomProp;
Value: string;
begin
if not Assigned(FFlexControl) or (ItemIndex < 0) then exit;
Prop := FFlexControl.Props.VisibleProps[Cell.Row];
Value := TGridListBox(grInspector.Edit.ActiveList).Items[ItemIndex];
ChangePropValue(Cell, Value, Accept);
UpdateProps(Prop);
// Accept := true;
end;
procedure TfmInspector.grInspectorEditButtonPress(Sender: TObject;
Cell: TGridCell);
begin
if not Assigned(FFlexControl) then exit;
FFlexControl.Props.VisibleProps[Cell.Row].Edit;
end;
procedure TfmInspector.grInspectorSetEditText(Sender: TObject;
Cell: TGridCell; var Value: String);
var Accept: boolean;
begin
ChangePropValue(Cell, Value, Accept);
end;
procedure TfmInspector.grInspectorGetEditList(Sender: TObject;
Cell: TGridCell; Items: TStrings);
begin
if (Cell.Col <> 1) or not Assigned(FFlexControl) then exit;
FFlexControl.Props.VisibleProps[Cell.Row].GetEnumList(Items);
end;
procedure TfmInspector.grInspectorEditCanModify(Sender: TObject;
Cell: TGridCell; var CanModify: Boolean);
begin
if (Cell.Col <> 1) or not Assigned(FFlexControl) then
CanModify := False
else
with FFlexControl.Props.VisibleProps[Cell.Row] do
CanModify :=
not (psReadOnly in Style) and
( not (psEditForm in Style) and not IsEnum or (psDisplayEdit in Style) );
{ CanModify := not (ReadOnly or IsEnum or IsFormEdit) or IsDisplayEditEnabled; }
end;
procedure TfmInspector.grInspectorChange(Sender: TObject; Cell: TGridCell;
Selected: Boolean);
begin
if Assigned(FFlexControl) and Selected then
FLastPropName := FFlexControl.Props.VisiblePropNames[Cell.Row];
end;
procedure TfmInspector.grInspectorDblClick(Sender: TObject);
var Items: TStrings;
Prop: TCustomProp;
NewIndex: integer;
Value: string;
Accept: boolean;
begin
if not Assigned(FFlexControl) then exit;
Prop := FFlexControl.Props.VisibleProps[grInspector.Row];
if Prop is TEnumProp then begin
with TEnumProp(Prop) do
if EnumIndex = EnumCount - 1
then NewIndex := 0
else NewIndex := EnumIndex + 1;
Items := TStringList.Create;
try
TEnumProp(Prop).GetEnumList(Items);
Value := Items[NewIndex];
finally
Items.Free;
end;
ChangePropValue(grInspector.EditCell, Value, Accept);
end;
end;
function TfmInspector.GetControlIconIndex(AControl: TFlexControl): integer;
var CType: TClass;
begin
Result := -1;
if not Assigned(AControl) then exit;
CType := AControl.ClassType;
if CType = TFlexScheme then Result := 0 else
if CType = TFlexLayer then Result := 1 else
if CType = TFlexBox then Result := 2 else
if CType = TFlexEllipse then Result := 3 else
if CType = TFlexCurve then Result := 4 else
if CType = TFlexRegularPolygon then Result := 4 else
if CType = TFlexText then Result := 5 else
if CType = TFlexPicture then Result := 6 else
if CType = TFlexGroup then Result := 7 else
if CType = TFlexConnector then Result := 9
else Result := 8;
end;
procedure TfmInspector.cbInspItemsDrawItem(AControl: TcxCustomComboBox; ACanvas: TcxCanvas; AIndex: Integer; const ARect: TRect; AState: TOwnerDrawState);
var s: string;
Idx: integer;
FlexControl: TFlexControl;
Org, Cli: TPoint;
begin
with cbInspItems do begin
ACanvas.Canvas.FillRect(ARect);
FlexControl := TFlexControl(Properties.Items.Objects[AIndex]);
Idx := GetControlIconIndex(FlexControl);
if Idx >= 0 then begin
imgCtrlIcons.Draw(ACanvas.Canvas, ARect.Left+2, ARect.Top+2, Idx);
end;
s := Properties.Items[AIndex];
ACanvas.Canvas.TextOut(ARect.Left+22, ARect.Top +
((ARect.Bottom - ARect.Top) - ACanvas.Canvas.TextHeight(s)) div 2, s);
GetDCOrgEx(ACanvas.Canvas.Handle, Org);
Cli := ClientToScreen(Point(Top, Left));
if (AIndex < Properties.Items.Count-1) and (Org.Y <> Cli.Y) and
((FlexControl is TFlexScheme) or (FlexControl is TFlexLayer)) then begin
FlexControl := TFlexControl(Properties.Items.Objects[AIndex+1]);
if not (FlexControl is TFlexScheme) and
not (FlexControl is TFlexLayer) then
with ACanvas.Canvas do begin
Pen.Color := clBlack;
Pen.Style := psSolid;
Pen.Mode := pmCopy;
MoveTo(ARect.Left, ARect.Bottom-1);
LineTo(ARect.Right, ARect.Bottom-1);
end;
end;
end;
end;
procedure TfmInspector.cbInspItemsChange(Sender: TObject);
var AControl: TFlexControl;
begin
if not Assigned(FActiveFlex) then exit;
AControl := TFlexControl(cbInspItems.Properties.Items.Objects[cbInspItems.ItemIndex]);
with FActiveFlex do begin
UnselectAll;
Select(AControl);
end;
Control := AControl;
end;
end.
|
unit DUnitXMLParser;
interface
uses
System.SysUtils, System.Variants, Xml.xmldom, Xml.XMLIntf, Xml.Win.msxmldom, Xml.XMLDoc, TestStructureUnit, RTTI,
System.Generics.Collections;
type
TTestsXMLParser = class
private
FXMLFileName: string;
FXMLDocument: IXMLDocument;
function GetRootNode: IXMLNode;
function GetChildNodeByIndex(Node: IXMLNode; aNodeIndex: Integer): IXMLNode;
function GetAttribute(Node: IXMLNode; aAttributeName: string): String;
function CheckNodeName(Node: IXMLNode; ExpectedName: string): Boolean;
function IsChildExists(Node: IXMLNode): Boolean;
function GetChildCount(Node: IXMLNode): integer;
function LoadXML: Boolean;
procedure UnLoadXML;
public
constructor Create(aXMLFileName: string);
procedure RunXMLParsing(var aTestCaseList: TTestCaseList; var aSuiteList: TSuiteList);
end;
procedure LoadTestsFromXML(aXMLFileName: string; var aSuiteList: TSuiteList; var aTestCaseList: TTestCaseList);
implementation
function TTestsXMLParser.CheckNodeName(Node: IXMLNode; ExpectedName: string): Boolean;
begin
Result := AnsiLowerCase(Node.NodeName) = AnsiLowerCase(ExpectedName);
end;
constructor TTestsXMLParser.Create(aXMLFileName: string);
begin
FXMLDocument := TXMLDocument.Create(nil);
FXMLFileName := aXMLFileName;
end;
function TTestsXMLParser.GetRootNode: IXMLNode;
begin
Result := FXMLDocument.ChildNodes[0];
end;
function TTestsXMLParser.GetChildNodeByIndex(Node: IXMLNode; aNodeIndex: Integer): IXMLNode;
begin
Result := Node.ChildNodes[aNodeIndex];
end;
function TTestsXMLParser.GetAttribute(Node: IXMLNode; aAttributeName: string): String;
begin
Result := Node.Attributes[aAttributeName];
end;
function TTestsXMLParser.IsChildExists(Node: IXMLNode): Boolean;
begin
Result := Node.HasChildNodes;
end;
function TTestsXMLParser.GetChildCount(Node: IXMLNode): integer;
begin
Result := Node.ChildNodes.Count;
end;
function TTestsXMLParser.LoadXML: Boolean;
begin
Result := false;
try
if FileExists(FXMLFileName) then
begin
FXMLDocument.LoadFromFile(FXMLFileName);
if not FXMLDocument.IsEmptyDoc then
Result := true;
end
else
Result := False;
except
Result := False;
end;
FXMLDocument.Active := Result;
end;
procedure TTestsXMLParser.UnLoadXML;
begin
FXMLDocument.Active := false;
end;
procedure TTestsXMLParser.RunXMLParsing(var aTestCaseList: TTestCaseList; var aSuiteList: TSuiteList);
// Мама - рекурсия, папа - стакан портвейна!
procedure GetDataFromNode(RootNode: IXMLNode; var aSuitesCounter: Integer; var aTestsCounter: Integer;
var aSuiteList: TSuiteList; var aTestCaseList: TTestCaseList);
var
iNodesCounter: Integer;
iParamsCounter: Integer;
sSuiteName: string;
sTestCaseClass: string;
ParamsArray: TInputDataArray;
begin
// Корень - уровень Zero
if CheckNodeName(RootNode, 'Tests') then
begin
for iNodesCounter := 0 to GetChildCount(RootNode) - 1 do
begin
// Падаем на 1
GetDataFromNode(GetChildNodeByIndex(RootNode, iNodesCounter), aSuitesCounter, aTestsCounter, aSuiteList, aTestCaseList)
end;
end;
// TestSuites - уровень 1
if CheckNodeName(RootNode, 'TestSuite') and IsChildExists(RootNode) then
begin
SetLength(aSuiteList, aSuitesCounter + 1);
sSuiteName := GetAttribute(RootNode, 'Name') + ': ' + GetAttribute(RootNode, 'Description');
sTestCaseClass := GetAttribute(RootNode, 'ClassName');
aSuiteList[aSuitesCounter].SuiteName := sSuiteName;
aSuiteList[aSuitesCounter].SuiteClassName := sTestCaseClass;
for iNodesCounter := 0 to GetChildCount(RootNode) - 1 do
begin
SetLength(aTestCaseList, aTestsCounter + 1);
aTestCaseList[aTestsCounter].SuiteName := sSuiteName;
aTestCaseList[aTestsCounter].TestCaseClass := sTestCaseClass;
// Опускаемся на 2
GetDataFromNode(GetChildNodeByIndex(RootNode, iNodesCounter), aSuitesCounter, aTestsCounter, aSuiteList, aTestCaseList);
end;
Inc(aSuitesCounter);
end;
// TestCases - уровень 2
if CheckNodeName(RootNode, 'TestCase') and IsChildExists(RootNode) then
begin
aTestCaseList[aTestsCounter].TestCaseName := GetAttribute(RootNode, 'Name') + ': ' + GetAttribute(RootNode, 'Description');
aTestCaseList[aTestsCounter].MethodName := GetAttribute(RootNode, 'MethodName');
for iNodesCounter := 0 to GetChildCount(RootNode) - 1 do
begin
// Последний уровень 3, ниже некуда
GetDataFromNode(GetChildNodeByIndex(RootNode, iNodesCounter), aSuitesCounter, aTestsCounter, aSuiteList, aTestCaseList);
end;
Inc(aTestsCounter);
end;
// InputData - уровень 3
if CheckNodeName(RootNode, 'InputData') then
begin
iParamsCounter := 0;
While RootNode.HasAttribute('Param' + IntToStr(iParamsCounter)) do
begin
SetLength(ParamsArray, iParamsCounter + 1);
ParamsArray[iParamsCounter] := TValue.From<String>(GetAttribute(RootNode, 'Param' + IntToStr(iParamsCounter)));
Inc(iParamsCounter);
end;
DataArray.Add(aTestCaseList[aTestsCounter].TestCaseName, ParamsArray);
ParamsArray := nil;
end;
// ExpectedResult - уровень 3
if CheckNodeName(RootNode, 'ExpectedResult') then
begin
SetLength(ParamsArray, Length(DataArray.Items[aTestCaseList[aTestsCounter].TestCaseName]));
ParamsArray := DataArray.Items[aTestCaseList[aTestsCounter].TestCaseName];
SetLength(ParamsArray, Length(ParamsArray) + 3);
ParamsArray[Length(ParamsArray) - 3] := TValue.From<String>(GetAttribute(RootNode, 'Value'));
ParamsArray[Length(ParamsArray) - 2] := TValue.From<String>(GetAttribute(RootNode, 'FailMessageText'));
ParamsArray[Length(ParamsArray) - 1] := TValue.From<String>(GetAttribute(RootNode, 'Operation'));
DataArray.Items[aTestCaseList[aTestsCounter].TestCaseName] := ParamsArray;
ParamsArray := nil;
end;
end;
// Конец рекурсивного угробища и начало процедуры
var
iSuitesCounter: integer;
iTestsCounter: Integer;
begin // RunXMLParsing
iSuitesCounter := 0;
iTestsCounter := 0;
LoadXML;
GetDataFromNode(GetRootNode, iSuitesCounter, iTestsCounter, aSuiteList, aTestCaseList);
UnLoadXML;
end; // RunXMLParsing
procedure LoadTestsFromXML(aXMLFileName: string; var aSuiteList: TSuiteList; var aTestCaseList: TTestCaseList);
var
XMLParser: TTestsXMLParser;
begin
XMLParser := TTestsXMLParser.Create(aXMLFileName);
try
XMLParser.RunXMLParsing(aTestCaseList, aSuiteList);
finally
FreeAndNil(XMLParser);
end;
end;
end.
|
{*************************************************************}
{ }
{ Embarcadero Delphi Visual Component Library }
{ InterBase Express core components }
{ }
{ Copyright (c) 1998-2017 Embarcadero Technologies, Inc.}
{ All rights reserved }
{ }
{ Code created by Jeff Overcash used with permission. }
{*************************************************************}
unit IBX.IBSubscription;
interface
uses
System.Classes, IBX.IBDatabase;
type
TIBSubscriptions = class;
TIBSubscriptionItem = class;
TIBDmlAction = (diInsert, diUpdate, diDelete);
TIBDmlActions = Set of TIBDmlAction;
TIBSubscriptionInfo = class(TCollectionItem)
private
FForTable : String;
FColumnList : TStrings;
FDmlActions : TIBDmlActions;
procedure SetColumnList(const Value: TStrings);
function GetDatabase: TIBDataBase;
function GetTransaction: TIBTransaction;
protected
function GetDisplayName: string; override;
public
constructor Create(Collection: TCollection); override;
destructor Destroy; override;
procedure AddColumn(AColumn : string);
procedure AddColumns(Columns : TStrings);
function CreateSQL : String;
procedure Clear;
function GetColumns: String;
procedure Assign(Source: TPersistent); override;
property Database : TIBDataBase read GetDatabase;
property Transaction : TIBTransaction read GetTransaction;
published
property ForTable : string read FForTable write FForTable;
property DmlActions : TIBDmlActions read FDmlActions write FDmlActions;
property Columns : TStrings read FColumnList write SetColumnList;
end;
TIBSubscriptionInfos = class(TOwnedCollection)
private
function GetSubscriptionInfos(Index: Integer): TIBSubscriptionInfo;
procedure SetSubscriptionInfos(Index: Integer; const Value: TIBSubscriptionInfo);
function GetDatabase: TIBDataBase;
function GetTransaction: TIBTransaction;
public
constructor Create(AOwner: TIBSubscriptionItem);
function Add: TIBSubscriptionInfo; overload;
function Add(ForTable : String): TIBSubscriptionInfo; overload;
procedure DeleteInfo(info : TIBSubscriptionInfo);
property Database : TIBDataBase read GetDatabase;
property Transaction : TIBTransaction read GetTransaction;
property SubscriptionInfos[Index: Integer]: TIBSubscriptionInfo read GetSubscriptionInfos write SetSubscriptionInfos; default;
end;
TIBSubscriptionItem = class(TCollectionItem)
private
FSubscriptionName : String;
FSubscriptionInfos: TIBSubscriptionInfos;
FDescription: String;
function GetDatabase: TIBDataBase;
function GetTransaction: TIBTransaction;
protected
function GetDisplayName: string; override;
public
constructor Create(Collection: TCollection); override;
destructor Destroy; override;
function CreateSQL : String;
procedure Clear;
procedure RetriveInfo;
procedure Assign(Source: TPersistent); override;
function SubscriptionNames : TStrings;
property Database : TIBDataBase read GetDatabase;
property Transaction : TIBTransaction read GetTransaction;
published
property SubscriptionInfos : TIBSubscriptionInfos read FSubscriptionInfos write FSubscriptionInfos;
property SubscriptionName : String read FSubscriptionName write FSubscriptionName;
property Description : String read FDescription write FDescription;
end;
TIBSubscriptionItems = class(TOwnedCollection)
private
function GetSubscriptionItems(Index: Integer): TIBSubscriptionItem;
procedure SetSubscriptionItems(Index: Integer; const Value: TIBSubscriptionItem);
function GetDatabase: TIBDataBase;
function GetTransaction: TIBTransaction;
public
constructor Create(AOwner: TIBSubscriptions);
function Add: TIBSubscriptionItem;
function SubscriptionList : String;
function SubscriptionNames : TStrings;
procedure DeleteItem(item : TIBSubscriptionItem);
property SubscriptionItems[Index: Integer]: TIBSubscriptionItem read GetSubscriptionItems write SetSubscriptionItems; default;
property Database : TIBDataBase read GetDatabase;
property Transaction : TIBTransaction read GetTransaction;
end;
[ComponentPlatformsAttribute(pidAllPlatforms)]
TIBSubscriptions = class(TComponent)
private
FBase: TIBBase;
FDestination: String;
FSubscriptions : TIBSubscriptionItems;
FActive: Boolean;
FNameList : TStringList;
function GetTransaction: TIBTransaction;
procedure SetDatabase(const Value: TIBDatabase);
procedure SetTransaction(const Value: TIBTransaction);
procedure SetActive(const Value: Boolean);
procedure DoBeforeTransactionEnd(Sender: TObject);
function GetDatabase: TIBDatabase;
protected
procedure ActivateConnection;
public
constructor Create(AOwner : TComponent); override;
destructor Destroy; override;
procedure CreateSubscriptions;
function CreateScript : string;
procedure DropSubscriptions(Cascade : Boolean = False);
procedure GrantTo(UserName : string);
procedure RevokeFrom(UserName : string);
function Add(SubscriptionName : string) : TIBSubscriptionItem;
function Find(SubscriptionName : string) : TIBSubscriptionItem;
procedure Delete(SubscriptionName : string);
procedure RetrieveFullInfo;
procedure Clear;
procedure Assign(Source: TPersistent); override;
function SubscriptionNames : TStrings;
property Active : Boolean read FActive write SetActive;
property Destination : String read FDestination write FDestination;
published
property SubscriptionItems : TIBSubscriptionItems read FSubscriptions write FSubscriptions;
property Database : TIBDatabase read GetDatabase write SetDatabase;
property Transaction : TIBTransaction read GetTransaction write SetTransaction;
end;
implementation
{ TIBSubscription }
uses
IBX.IBXConst, System.SysUtils, IBX.IB, IBX.IBSQL, IBX.IBUtils;
procedure TIBSubscriptions.ActivateConnection;
begin
if not Assigned(Database) then
IBError(ibxeDatabaseNotAssigned, [nil]);
if not Assigned(Transaction) then
IBError(ibxeTransactionNotAssigned, [nil]);
if not Database.Connected then Database.Open;
end;
function TIBSubscriptions.Add(SubscriptionName: string): TIBSubscriptionItem;
begin
Result := FSubscriptions.Add;
Result.SubscriptionName := SubscriptionName;
end;
procedure TIBSubscriptions.Assign(Source: TPersistent);
begin
if Source is TIBSubscriptions then
begin
Database := TIBSubscriptions(Source).Database;
Transaction := TIBSubscriptions(Source).Transaction;
SubscriptionItems.Assign(TIBSubscriptions(Source).SubscriptionItems);
end
else
inherited;
end;
procedure TIBSubscriptions.Clear;
begin
FSubscriptions.Clear;
end;
constructor TIBSubscriptions.Create(AOwner: TComponent);
begin
inherited;
FBase := TIBBase.Create(Self);
FBase.BeforeTransactionEnd := DoBeforeTransactionEnd;
if AOwner is TIBDatabase then
Database := TIBDatabase(AOwner)
else
if AOwner is TIBTransaction then
Transaction := TIBTransaction(AOwner);
FSubscriptions := TIBSubscriptionItems.Create(Self);
FNameList := TStringList.Create;
end;
function TIBSubscriptions.CreateScript: string;
var
MyElem : TCollectionItem;
begin
for MyElem in FSubscriptions do
begin
if Result <> '' then
Result := Result + CRLF + CRLF;
Result := Result + (MyElem as TIBSubscriptionItem).CreateSQL + ';';
end;
end;
procedure TIBSubscriptions.CreateSubscriptions;
var
MyElem : TCollectionItem;
SQL : string;
begin
for MyElem in FSubscriptions do
begin
SQL := TIBSubscriptionItem(MyElem).CreateSQL;
Database.ExecuteImmediate(SQL);
end;
end;
procedure TIBSubscriptions.Delete(SubscriptionName: string);
var
i : Integer;
begin
for i := FSubscriptions.Count - 1 downto 0 do
begin
if FSubscriptions[i].SubscriptionName = SubscriptionName then
FSubscriptions.Delete(I);
end;
end;
destructor TIBSubscriptions.Destroy;
begin
FBase.DisposeOf;
FNameList.Free;
inherited;
end;
procedure TIBSubscriptions.DoBeforeTransactionEnd(Sender: TObject);
begin
FActive := False;
end;
procedure TIBSubscriptions.DropSubscriptions(Cascade : Boolean);
var
MyElem : TCollectionItem;
SQL : string;
begin
for MyElem in FSubscriptions do
begin
SQL := 'DROP SUBSCRIPTION ' + TIBSubscriptionItem(MyElem).SubscriptionName; { do not localize }
if Cascade then
SQL := SQL + ' CASCADE';
Database.ExecuteImmediate(SQL);
end;
end;
function TIBSubscriptions.Find(SubscriptionName: string): TIBSubscriptionItem;
var
i : Integer;
begin
i := 0;
Result := nil;
while not Assigned(Result) and (i < FSubscriptions.Count) do
begin
if FSubscriptions[i].SubscriptionName = SubscriptionName then
Result := FSubscriptions[i];
end;
end;
function TIBSubscriptions.GetDatabase: TIBDatabase;
begin
result := FBase.Database;
end;
function TIBSubscriptions.GetTransaction: TIBTransaction;
begin
result := FBase.Transaction;
end;
procedure TIBSubscriptions.GrantTo(UserName: string);
var
MyElem : TCollectionItem;
SQL : string;
begin
for MyElem in FSubscriptions do
begin
SQL := 'GRANT SUBSCRIBE ON SUBSCRIPTION ' + TIBSubscriptionItem(MyElem).SubscriptionName + { do not localize }
' TO ' + UserName; { do not localize }
Database.ExecuteImmediate(SQL);
end;
end;
procedure TIBSubscriptions.RetrieveFullInfo;
var
MyElem : TCollectionItem;
begin
ActivateConnection;
for MyElem in FSubscriptions do
(MyElem as TIBSubscriptionItem).RetriveInfo;
end;
procedure TIBSubscriptions.RevokeFrom(UserName: string);
var
MyElem : TCollectionItem;
SQL : string;
begin
for MyElem in FSubscriptions do
begin
SQL := 'REVOKE SUBSCRIBE ON SUBSCRIPTION ' + TIBSubscriptionItem(MyElem).SubscriptionName + { do not localize }
' FROM ' + UserName; { do not localize }
Database.ExecuteImmediate(SQL);
end;
end;
procedure TIBSubscriptions.SetActive(const Value: Boolean);
var
SQL : string;
begin
if Value <> FActive then
begin
SQL := 'SET SUBSCRIPTION '; {do not localize }
SQL := SQL + FSubscriptions.SubscriptionList;
if Destination <> '' then
SQL := SQL + ' AT ' + QuotedStr(Destination); {do not localize }
if Value then
SQL := SQL + ' ACTIVE' {do not localize }
else
SQL := SQL + ' INACTIVE'; {do not localize }
Database.ExecuteImmediate(SQL, Transaction);
FActive := Value;
end;
end;
procedure TIBSubscriptions.SetDatabase(const Value: TIBDatabase);
begin
if (FBase.Database <> Value) then
FBase.Database := Value;
end;
procedure TIBSubscriptions.SetTransaction(const Value: TIBTransaction);
begin
if (FBase.Transaction <> Value) then
FBase.Transaction := Value;
end;
function TIBSubscriptions.SubscriptionNames: TStrings;
var
Query : TIBSQL;
begin
FNameList.clear;
if not (csReading in ComponentState) then
begin
ActivateConnection;
Query := TIBSQL.Create(self);
Database.InternalTransaction.StartTransaction;
try
Query.GoToFirstRecordOnExecute := False;
Query.Database := DataBase;
Query.Transaction := Database.InternalTransaction;
Query.SQL.Text := 'Select distinct RDB$SUBSCRIPTION_NAME from RDB$SUBSCRIPTIONS'; {do not localize}
Query.Prepare;
Query.ExecQuery;
while (not Query.EOF) and (Query.Next <> nil) do
FNameList.Add(TrimRight(Query.Current.ByName('RDB$SUBSCRIPTION_NAME').AsString)); {do not localize}
finally
Query.Free;
Database.InternalTransaction.Commit;
end;
end;
Result := FNameList;
end;
{ TIBSubscription }
procedure TIBSubscriptionItem.Assign(Source: TPersistent);
begin
if Source is TIBSubscriptionItem then
begin
FSubscriptionName := TIBSubscriptionItem(Source).SubscriptionName;
FDescription := TIBSubscriptionItem(Source).Description;
FSubscriptionInfos.Assign(TIBSubscriptionItem(Source).SubscriptionInfos);
end
else
inherited;
end;
procedure TIBSubscriptionItem.Clear;
var
MyElem : TCollectionItem;
begin
FSubscriptionName := ''; {do not localize }
FDescription := ''; {do not localize }
for MyElem in FSubscriptionInfos do
TIBSubscriptionInfo(MyElem).Clear;
end;
constructor TIBSubscriptionItem.Create(Collection: TCollection);
begin
inherited;
FSubscriptionInfos := TIBSubscriptionInfos.Create(Self);
end;
function TIBSubscriptionItem.CreateSQL: String;
var
First : Boolean;
MyElem : TCollectionItem;
begin
if Assigned(Database) then
Result := 'CREATE SUBSCRIPTION ' + QuoteIdentifier(Database.SQLDialect, SubscriptionName) + ' ON ' + CRLF {do not localize }
else
Result := 'CREATE SUBSCRIPTION ' + QuoteIdentifier(3, SubscriptionName) + ' ON ' + CRLF; {do not localize }
First := true;
for MyElem in FSubscriptionInfos do
begin
if First then
begin
Result := Result + TIBSubscriptionInfo(MyElem).CreateSQL;
First := false;
end
else
Result := Result + ',' + CRLF + TIBSubscriptionInfo(MyElem).CreateSQL; {do not localize }
end;
if FDescription <> '' then {do not localize }
Result := Result + CRLF + 'DESCRIPTION ''' + FDescription + ''''; {do not localize }
end;
destructor TIBSubscriptionItem.Destroy;
begin
inherited;
end;
function TIBSubscriptionItem.GetDatabase: TIBDataBase;
begin
Result := (GetOwner as TIBSubscriptionItems).Database;
end;
function TIBSubscriptionItem.GetDisplayName: string;
begin
Result := FSubscriptionName;
end;
function TIBSubscriptionItem.GetTransaction: TIBTransaction;
begin
Result := (GetOwner as TIBSubscriptionItems).Transaction;
end;
function TIBSubscriptionItem.SubscriptionNames: TStrings;
begin
Result := (GetOwner as TIBSubscriptionItems).SubscriptionNames;
end;
procedure TIBSubscriptionItem.RetriveInfo;
const
SNamedSubscription = 'select SBS.RDB$SUBSCRIPTION_NAME, SBS.RDB$OWNER_NAME, SBS.RDB$DESCRIPTION ' + {do not localize}
' from RDB$SUBSCRIPTIONS SBS ' + {do not localize}
' where SBS.RDB$RELATION_NAME IS NULL AND ' + {do not localize}
' SBS.RDB$SUBSCRIPTION_NAME = :subscription_name'; {do not localize}
STables = 'select RDB$RELATION_NAME, RDB$RELATION_COUNTER, RDB$CHANGE, RDB$INSERT, ' + {do not localize}
' RDB$UPDATE, RDB$DELETE ' + {do not localize}
' from RDB$SUBSCRIPTIONS SBS2 ' + {do not localize}
' where SBS2.RDB$SUBSCRIPTION_NAME = :subscription_name AND ' + {do not localize}
' SBS2.RDB$RELATION_NAME is not NULL AND ' + {do not localize}
' SBS2.RDB$FIELD_NAME is NULL ' + {do not localize}
' ORDER BY SBS2.RDB$SUBSCRIPTION_NAME, SBS2.RDB$RELATION_COUNTER, SBS2.RDB$FLAGS '; {do not localize}
SColumns = 'select * ' + {do not localize}
' from RDB$SUBSCRIPTIONS SBS3 ' + {do not localize}
' where SBS3.RDB$SUBSCRIPTION_NAME = :subscription_name AND ' + {do not localize}
' SBS3.RDB$RELATION_COUNTER = :RELATION_COUNTER AND ' + {do not localize}
' SBS3.RDB$FIELD_NAME is not NULL AND ' + {do not localize}
' SBS3.RDB$FLAGS = 0 ' + {do not localize}
' ORDER BY SBS3.RDB$SUBSCRIPTION_NAME, SBS3.RDB$RELATION_COUNTER '; {do not localize}
var
sql, sqlCol : TIBSQL;
Item : TIBSubscriptionInfo;
begin
SubscriptionInfos.Clear;
sql := TIBSQL.Create(nil);
sqlCol := TIBSQL.Create(nil);
try
sql.Database := Database;
sql.Transaction := Database.InternalTransaction;
sql.Transaction.StartTransaction;
sqlCol.Database := Database;
sqlCol.Transaction := Database.InternalTransaction;
sqlCol.SQL.Text := SColumns;
sql.SQL.Text := SNamedSubscription;
sql.ParamByName('subscription_name').AsString := SubscriptionName; {do not localize}
sql.ExecQuery;
Description := sql.FieldByName('RDB$DESCRIPTION').AsString; {do not localize}
sql.Close;
sql.SQL.Text := STables;
sql.ParamByName('subscription_name').AsString := SubscriptionName; {do not localize}
sql.ExecQuery;
while not sql.Eof do
begin
Item := SubscriptionInfos.Add(sql.FieldByName('RDB$RELATION_NAME').AsString.Trim); {do not localize}
if sql.FieldByName('RDB$INSERT').AsBoolean then {do not localize}
Item.DmlActions := Item.DmlActions + [diInsert];
if sql.FieldByName('RDB$UPDATE').AsBoolean then {do not localize}
Item.DmlActions := Item.DmlActions + [diUpdate];
if sql.FieldByName('RDB$DELETE').AsBoolean then {do not localize}
Item.DmlActions := Item.DmlActions + [diDelete];
sqlCol.ParamByName('subscription_name').AsString := SubscriptionName; {do not localize}
sqlCol.ParamByName('relation_counter').AsInteger := sql.FieldByName('RDB$RELATION_COUNTER').AsInteger; {do not localize}
try
sqlCol.ExecQuery;
while not sqlCol.Eof do
begin
Item.AddColumn(sqlCol.FieldByName('RDB$FIELD_NAME').AsString.Trim); {do not localize}
sqlCol.Next;
end;
finally
sqlCol.Close;
end;
sql.Next;
end;
finally
sql.Transaction.Commit;
sql.Free;
sqlCol.Free;
end;
end;
{ TIBSubscriptionCollection }
function TIBSubscriptionItems.Add: TIBSubscriptionItem;
begin
Result := TIBSubscriptionItem(inherited Add);
end;
constructor TIBSubscriptionItems.Create(AOwner: TIBSubscriptions);
begin
inherited Create(AOwner, TIBSubscriptionItem);
end;
procedure TIBSubscriptionItems.DeleteItem(item: TIBSubscriptionItem);
var
i : Integer;
begin
i := 0;
while i < Count do
if Items[i] = item then
begin
Delete(i);
Exit;
end
else
Inc(i);
end;
function TIBSubscriptionItems.GetDatabase: TIBDataBase;
begin
Result := (GetOwner as TIBSubscriptions).Database;
end;
function TIBSubscriptionItems.GetSubscriptionItems(Index: Integer): TIBSubscriptionItem;
begin
Result := TIBSubscriptionItem(inherited GetItem(Index));
end;
function TIBSubscriptionItems.GetTransaction: TIBTransaction;
begin
Result := (GetOwner as TIBSubscriptions).Transaction;
end;
procedure TIBSubscriptionItems.SetSubscriptionItems(Index: Integer;
const Value: TIBSubscriptionItem);
begin
inherited SetItem(Index, Value);
end;
function TIBSubscriptionItems.SubscriptionList: String;
var
MyEnum : TCollectionEnumerator;
First : Boolean;
begin
First := True;
MyEnum := GetEnumerator;
while MyEnum.MoveNext do
begin
if First then
begin
Result := TIBSubscriptionItem(MyEnum.Current).SubscriptionName;
First := False;
end
else
Result := Result + ', ' + TIBSubscriptionItem(MyEnum.Current).SubscriptionName; {do not localize }
end;
MyEnum.Free;
end;
function TIBSubscriptionItems.SubscriptionNames: TStrings;
begin
Result := (GetOwner as TIBSubscriptions).SubscriptionNames;
end;
{ TIBSubscriptionInfoCollection }
function TIBSubscriptionInfos.Add: TIBSubscriptionInfo;
begin
Result := TIBSubscriptionInfo(inherited Add);
end;
function TIBSubscriptionInfos.Add(
ForTable: String): TIBSubscriptionInfo;
begin
Result := Add;
Result.ForTable := ForTable;
end;
constructor TIBSubscriptionInfos.Create(AOwner: TIBSubscriptionItem);
begin
inherited Create(AOwner, TIBSubscriptionInfo);
end;
procedure TIBSubscriptionInfos.DeleteInfo(info: TIBSubscriptionInfo);
var
i : Integer;
begin
i := 0;
while i < Count do
if Items[i] = info then
begin
Delete(i);
Exit;
end
else
Inc(i);
end;
function TIBSubscriptionInfos.GetDatabase: TIBDataBase;
begin
Result := (Owner as TIBSubscriptionItem).Database;
end;
function TIBSubscriptionInfos.GetSubscriptionInfos(Index: Integer): TIBSubscriptionInfo;
begin
Result := TIBSubscriptionInfo(inherited GetItem(Index));
end;
function TIBSubscriptionInfos.GetTransaction: TIBTransaction;
begin
Result := (Owner as TIBSubscriptionItem).Transaction;
end;
procedure TIBSubscriptionInfos.SetSubscriptionInfos(Index: Integer;
const Value: TIBSubscriptionInfo);
begin
inherited SetItem(Index, Value);
end;
{ TIBSubscriptionInfoItem }
procedure TIBSubscriptionInfo.AddColumn(AColumn: string);
begin
if FColumnList.IndexOf(AColumn) < 0 then
FColumnList.Add(AColumn);
end;
procedure TIBSubscriptionInfo.AddColumns(Columns: TStrings);
begin
FColumnList.CommaText := Columns.CommaText;
end;
procedure TIBSubscriptionInfo.Assign(Source: TPersistent);
begin
if Source is TIBSubscriptionInfo then
begin
FForTable := TIBSubscriptionInfo(Source).ForTable;
FColumnList.Assign(TIBSubscriptionInfo(Source).Columns);
FDmlActions := TIBSubscriptionInfo(Source).DmlActions;
end
else
inherited;
end;
procedure TIBSubscriptionInfo.Clear;
begin
FForTable := ''; {do not localize }
FColumnList.Clear;
FDmlActions := [];
end;
constructor TIBSubscriptionInfo.Create(Collection: TCollection);
begin
inherited Create(Collection);
FColumnList := TStringList.Create;
end;
function TIBSubscriptionInfo.CreateSQL: String;
var
IntroString : String;
begin
if Assigned(Database) then
Result := ' ' + QuoteIdentifier(Database.SQLDialect, ForTable) + GetColumns {do not localize }
else
Result := ' ' + QuoteIdentifier(3, ForTable) + GetColumns; {do not localize }
if FDmlActions <> [] then
Result := Result + ' FOR ROW '; {do not localize }
IntroString := '';
if diInsert in FDmlActions then
if IntroString.Length = 0 then
IntroString := '(INSERT' {do not localize }
else
IntroString := IntroString + ', INSERT'; {do not localize }
if diUpdate in FDmlActions then
if IntroString.Length = 0 then
IntroString := '(UPDATE' {do not localize }
else
IntroString := IntroString + ', UPDATE'; {do not localize }
if diDelete in FDmlActions then
if IntroString.Length = 0 then
IntroString := '(DELETE' {do not localize }
else
IntroString := IntroString + ', DELETE'; {do not localize }
if IntroString.Length > 0 then
Result := Result + IntroString + ')'; {do not localize }
end;
destructor TIBSubscriptionInfo.Destroy;
begin
FColumnList.Free;
inherited;
end;
function TIBSubscriptionInfo.GetColumns: String;
var
tmpList : TStringList;
i : Integer;
SQLDialect : Integer;
begin
if FColumnList.Count > 0 then
begin
if Assigned(Database) then
SQLDialect := Database.SQLDialect
else
SQLDialect := 3;
tmpList := TStringList.Create;
try
tmpList.Assign(FColumnList);
tmpList.QuoteChar := #0;
for i := 0 to tmpList.Count - 1 do
tmpList[i] := QuoteIdentifier(SQLDialect, tmpList[i]);
Result := tmpList.DelimitedText;
Result := ' (' + StringReplace(Result, ',', ', ', [rfReplaceAll]) + ')'; {do not localize }
finally
tmpList.Free;
end;
end
else
Result := ''; {do not localize }
end;
function TIBSubscriptionInfo.GetDatabase: TIBDataBase;
begin
Result := (Collection as TIBSubscriptionInfos).Database;
end;
function TIBSubscriptionInfo.GetDisplayName: string;
begin
Result := FForTable;
end;
function TIBSubscriptionInfo.GetTransaction: TIBTransaction;
begin
Result := (Collection as TIBSubscriptionInfos).Transaction;
end;
procedure TIBSubscriptionInfo.SetColumnList(const Value: TStrings);
begin
FColumnList.CommaText := Value.CommaText;
end;
initialization
RegisterClasses([TIBSubscriptionInfos, TIBSubscriptionInfo,
TIBSubscriptionItems, TIBSubscriptionItem]);
end.
|
unit mCoverSheetDisplayPanel_CPRS_Appts;
{
================================================================================
*
* Application: CPRS - Coversheet
* Developer: doma.user@domain.ext
* Site: Salt Lake City ISC
* Date: 2015-12-08
*
* Description: Customized display panel for appts/visits/admissions.
*
* Notes:
*
================================================================================
}
interface
uses
Winapi.Windows,
Winapi.Messages,
System.SysUtils,
System.Variants,
System.Classes,
System.ImageList,
Vcl.Graphics,
Vcl.Controls,
Vcl.Forms,
Vcl.Dialogs,
Vcl.ExtCtrls,
Vcl.Menus,
Vcl.ImgList,
Vcl.ComCtrls,
Vcl.StdCtrls,
Vcl.Buttons,
mCoverSheetDisplayPanel_CPRS,
iCoverSheetIntf,
oDelimitedString;
type
TfraCoverSheetDisplayPanel_CPRS_Appts = class(TfraCoverSheetDisplayPanel_CPRS)
private
{ Private declarations }
protected
{ Overridden events - TfraCoverSheetDisplayPanel_CPRS }
procedure OnAddItems(aList: TStrings); override;
procedure OnGetDetail(aRec: TDelimitedString; aResult: TStrings); override;
public
constructor Create(aOwner: TComponent); override;
end;
var
fraCoverSheetDisplayPanel_CPRS_Appts: TfraCoverSheetDisplayPanel_CPRS_Appts;
implementation
uses
uCore,
ORFn,
ORNet;
{$R *.dfm}
{ TfraCoverSheetDisplayPanel_CPRS_Appts }
constructor TfraCoverSheetDisplayPanel_CPRS_Appts.Create(aOwner: TComponent);
begin
inherited;
AddColumn(0, 'Date/Time');
AddColumn(1, 'Location');
AddColumn(2, 'Action Req');
CollapseColumns;
end;
procedure TfraCoverSheetDisplayPanel_CPRS_Appts.OnAddItems(aList: TStrings);
var
aRec: TDelimitedString;
aStr: string;
begin
if aList.Count = 0 then
aList.Append('^No Visit Data.');
try
lvData.Items.BeginUpdate;
with TDelimitedString.Create(aList[0]) do
try
if GetPieceIsNull(1) then
begin
CollapseColumns;
lvData.Items.Add.Caption := 'No Visit Data.';
Exit;
end
else
ExpandColumns;
finally
Free;
end;
for aStr in aList do
begin
aRec := TDelimitedString.Create(aStr);
with lvData.Items.Add do
begin
if aRec.GetPieceIsNull(1) then
Caption := aRec.GetPiece(2)
else
Caption := FormatDateTime(DT_FORMAT, aRec.GetPieceAsTDateTime(2));
SubItems.Add(MixedCase(aRec.GetPiece(3)));
SubItems.Add(MixedCase(aRec.GetPiece(4)));
Data := aRec;
end;
end;
finally
lvData.Items.EndUpdate;
end;
end;
procedure TfraCoverSheetDisplayPanel_CPRS_Appts.OnGetDetail(aRec: TDelimitedString; aResult: TStrings);
begin
CallVistA(CPRSParams.DetailRPC, [Patient.DFN, '', aRec.GetPiece(1)], aResult);
end;
end.
|
unit Model.CoffeMachine;
interface
uses
SysUtils,
Math;
type
TGrindSize = (gsSuperFine, gsFine, gsMediumFine, gsMedium);
TCoffeeSelection = (csNone, csRistretto, csEspresso, csDoppio, csLungo);
TBeanAmount = (baClassic, baLight, bsExtraStrong);
TMachineWarning = (mnNonw, mwNoBeans, mwNoWater, mvGrinderJammed,
mvDeviceDamage);
type
TCoffee = record
Selection: TCoffeeSelection;
TemperatureC: double;
WaterML: double;
class function Create(aSelection: TCoffeeSelection; aTemperatureC: double;
aWaterML: double): TCoffee; static;
function ToString: string;
end;
TBeanPortion = record
end;
TWaterPortion = record
end;
type
IBeansContainer = interface(IInvokable)
function IsContainerLoaded: boolean;
function AreBeansAvaliable: boolean;
function ProvideCoffeeBeans: TBeanPortion;
end;
IGrinder = interface(IInvokable)
function IsReady: boolean;
procedure SetGrindSize(aGrindSize: TGrindSize);
procedure GrindCoffeeBeans(aWeightInGrams: double);
end;
IWaterContainer = interface(IInvokable)
function IsContainerLoaded: boolean;
function IsWarterAvaliable: boolean;
function ProvideWarer(aMilliliters: double): TWaterPortion;
end;
IUserPanel = interface(IInvokable)
procedure SetWarning(aWarning: TMachineWarning; aStatus: boolean);
procedure CoffeeInProgress(isInProgress: boolean);
end;
IBrewingUnit = interface(IInvokable)
procedure SetWaterTemperature(aWaterTemperatureInCelsius: double);
procedure PressCoffe;
procedure BrewWater(aMilliliters: double);
procedure PressWater(aBarPressure: double);
procedure TrashCoffe;
end;
IMachineTester = interface(IInvokable)
function IsReadyToBrewCoffee: boolean;
procedure DisplayStatus(aUserPanel: IUserPanel);
end;
TMachineTester = class(TInterfacedObject, IMachineTester)
strict private
fBeansContainer: IBeansContainer;
fGrinder: IGrinder;
fWaterContainer: IWaterContainer;
public
constructor Create(aBeansContainer: IBeansContainer; aGrinder: IGrinder;
aWaterContainer: IWaterContainer);
function IsReadyToBrewCoffee: boolean;
procedure DisplayStatus(aUserPanel: IUserPanel);
end;
TCoffeeMachine = class
strict private
fGrinder: IGrinder;
fBrewingUnit: IBrewingUnit;
fUserPanel: IUserPanel;
fMachineTester: IMachineTester;
private
fBeanAmount: TBeanAmount;
function GetCoffeeWeight(aSelection: TCoffeeSelection): double;
function GetWaterAmount(aSelection: TCoffeeSelection): double;
function GetGrindSize(aSelection: TCoffeeSelection): TGrindSize;
protected
public
constructor Create(aBrewingUnit: IBrewingUnit; aGrinder: IGrinder;
aUserPanel: IUserPanel; aMachineTester: IMachineTester);
procedure SetBeanAmount(aBeanAmount: TBeanAmount);
function BrewCoffee(aSelection: TCoffeeSelection): TCoffee;
end;
type
EMachineError = class(Exception);
implementation
constructor TCoffeeMachine.Create(aBrewingUnit: IBrewingUnit;
aGrinder: IGrinder; aUserPanel: IUserPanel; aMachineTester: IMachineTester);
begin
fGrinder := aGrinder;
fBrewingUnit := aBrewingUnit;
fUserPanel := aUserPanel;
fMachineTester := aMachineTester;
fBeanAmount := baClassic;
end;
function TCoffeeMachine.GetCoffeeWeight(aSelection: TCoffeeSelection): double;
const
aCoffeeWeight: array [TBeanAmount, TCoffeeSelection] of double =
{ baClassic: } ((0, 7.0, 8.0, 16.0, 8.0),
{ baLight: } (0, 7.0, 7.0, 14.0, 7.0),
{ bsExtraStrong: } (0, 8.0, 9.0, 18.0, 9.0));
begin
Result := aCoffeeWeight[fBeanAmount, aSelection];
end;
function TCoffeeMachine.GetWaterAmount(aSelection: TCoffeeSelection): double;
begin
Result := 0;
case aSelection of
csRistretto:
Result := 20.0;
csEspresso:
Result := 30.0;
csDoppio:
Result := 60.0;
csLungo:
Result := 45.0
else
Result := 0
end;
end;
function TCoffeeMachine.GetGrindSize(aSelection: TCoffeeSelection): TGrindSize;
begin
Result := gsFine;
case aSelection of
csRistretto:
Result := gsSuperFine;
csEspresso, csDoppio:
Result := gsFine;
csLungo:
Result := gsFine;
end;
end;
procedure TCoffeeMachine.SetBeanAmount(aBeanAmount: TBeanAmount);
begin
fBeanAmount := aBeanAmount;
end;
function TCoffeeMachine.BrewCoffee(aSelection: TCoffeeSelection): TCoffee;
const
WaterTemperatureInCelsius = 85;
WaterPressureInBars = 9.0;
var
aWaterAmount: double;
begin
Result.Selection := csNone;
fBrewingUnit.SetWaterTemperature(WaterTemperatureInCelsius);
if fMachineTester.IsReadyToBrewCoffee then
begin
fUserPanel.CoffeeInProgress(True);
try
fGrinder.SetGrindSize(GetGrindSize(aSelection));
fGrinder.GrindCoffeeBeans(GetCoffeeWeight(aSelection));
fBrewingUnit.PressCoffe;
aWaterAmount := GetWaterAmount(aSelection);
fBrewingUnit.BrewWater(aWaterAmount);
fBrewingUnit.PressWater(WaterPressureInBars);
Result.Selection := aSelection;
Result.TemperatureC := WaterTemperatureInCelsius;
Result.WaterML := aWaterAmount;
fBrewingUnit.TrashCoffe;
finally
fUserPanel.CoffeeInProgress(False);
end;
end;
fMachineTester.DisplayStatus(fUserPanel);
end;
{ TMachineTester }
constructor TMachineTester.Create(aBeansContainer: IBeansContainer;
aGrinder: IGrinder; aWaterContainer: IWaterContainer);
begin
fBeansContainer := aBeansContainer;
fGrinder := aGrinder;
fWaterContainer := aWaterContainer;
end;
procedure TMachineTester.DisplayStatus(aUserPanel: IUserPanel);
begin
end;
function TMachineTester.IsReadyToBrewCoffee: boolean;
begin
Result :=
{} fBeansContainer.IsContainerLoaded and
{} fBeansContainer.AreBeansAvaliable and
{} fGrinder.IsReady and
{} fWaterContainer.IsContainerLoaded and
{} fWaterContainer.IsWarterAvaliable;
end;
class function TCoffee.Create(aSelection: TCoffeeSelection;
aTemperatureC, aWaterML: double): TCoffee;
begin
Result.Selection := aSelection;
Result.TemperatureC := aTemperatureC;
Result.WaterML := aWaterML;
end;
function TCoffee.ToString: string;
begin
case Selection of
csRistretto:
Result := Format('Ristretto (%.1f°C, %.0f ml)', [TemperatureC, WaterML]);
csEspresso:
Result := Format('Espresso (%.1f°C, %.0f ml)', [TemperatureC, WaterML]);
csDoppio:
Result := Format('Doppio (%.1f°C, %.0f ml)', [TemperatureC, WaterML]);
csLungo:
Result := Format('Lungo (%.1f°C, %.0f ml)', [TemperatureC, WaterML]);
else
Result := '-- no coffee --';
end;
end;
end.
|
{*****************************************}
{ TeeChart Pro }
{ TPoint3DSeries }
{ Copyright (c) 1995-2004 David Berneda }
{*****************************************}
unit TeePoin3;
{$I TeeDefs.inc}
interface
Uses {$IFNDEF LINUX}
Windows, Messages,
{$ENDIF}
SysUtils, Classes,
{$IFDEF CLX}
QGraphics, Types,
{$ELSE}
Graphics,
{$ENDIF}
TeEngine, TeeSurfa, Series, TeCanvas;
type
TPoint3DSeries=class;
TSeriesClickPointer3DEvent=Procedure( Sender:TPoint3DSeries;
ValueIndex:Integer;
X, Y: Integer) of object;
TPoint3DSeries = class(TCustom3DSeries)
private
FBaseLine : TChartHiddenPen;
FDepthSize : Double;
FPointer : TSeriesPointer;
{ events }
FOnClickPointer : TSeriesClickPointer3DEvent;
FOnGetPointerStyle : TOnGetPointerStyle;
{ internal }
IOldX : Integer;
IOldY : Integer;
IOldZ : Integer;
Function GetLinePen:TChartPen;
procedure SetBaseLine(const Value: TChartHiddenPen);
Procedure SetDepthSize(Const Value:Double);
Procedure SetPointer(Value:TSeriesPointer);
protected
Procedure AddSampleValues(NumValues:Integer; OnlyMandatory:Boolean=False); override;
Procedure CalcHorizMargins(Var LeftMargin,RightMargin:Integer); override;
Procedure CalcVerticalMargins(Var TopMargin,BottomMargin:Integer); override;
Procedure CalcZPositions(ValueIndex:Integer); virtual;
class Procedure CreateSubGallery(AddSubChart:TChartSubGalleryProc); override;
Procedure DrawLegendShape(ValueIndex:Integer; Const Rect:TRect); override;
Procedure DrawMark( ValueIndex:Integer; Const St:String;
APosition:TSeriesMarkPosition); override;
Procedure DrawValue(ValueIndex:Integer); override; // 7.0 moved from public
Function GetDepthSize(ValueIndex:Integer):Integer; virtual;
class Function GetEditorClass:String; override;
Procedure PrepareForGallery(IsEnabled:Boolean); override;
Procedure SetParentChart(Const Value:TCustomAxisPanel); override;
class Procedure SetSubGallery(ASeries:TChartSeries; Index:Integer); override;
class Function SubGalleryStyles:Boolean; virtual;
public
Constructor Create(AOwner: TComponent); override;
Destructor Destroy; override;
Procedure Assign(Source:TPersistent); override;
Function Clicked(x,y:Integer):Integer; override;
Function MaxZValue:Double; override;
published
property Active;
property ColorEachPoint;
property ColorSource;
property Cursor;
property HorizAxis;
property Marks;
property ParentChart;
property DataSource;
property PercentFormat;
property SeriesColor;
property ShowInLegend;
property Title;
property ValueFormat;
property VertAxis;
property XLabelsSource;
{ events }
property AfterDrawValues;
property BeforeDrawValues;
property OnAfterAdd;
property OnBeforeAdd;
property OnClearValues;
property OnClick;
property OnDblClick;
property OnGetMarkText;
property OnMouseEnter;
property OnMouseLeave;
property BaseLine:TChartHiddenPen read FBaseLine write SetBaseLine; // 6.02
property DepthSize:Double read FDepthSize write SetDepthSize;
property LinePen:TChartPen read GetLinePen write SetPen;
property Pointer:TSeriesPointer read FPointer write SetPointer;
property TimesZOrder;
property XValues;
property YValues;
property ZValues;
{ events }
property OnClickPointer:TSeriesClickPointer3DEvent read FOnClickPointer
write FOnClickPointer;
property OnGetPointerStyle:TOnGetPointerStyle read FOnGetPointerStyle
write FOnGetPointerStyle;
end;
TBubble3DSeries = class(TPoint3DSeries)
private
FRadiusValues : TChartValueList; { <-- Bubble's radius storage }
Function ApplyRadius( Const Value:Double;
AList:TChartValueList;
Increment:Boolean):Double;
Procedure SetRadiusValues(Value:TChartValueList);
protected
Procedure AddSampleValues(NumValues:Integer; OnlyMandatory:Boolean=False); override; { <-- to add random radius values }
Procedure CalcZPositions(ValueIndex:Integer); override;
procedure DrawValue(ValueIndex:Integer); override; { <-- main draw method }
Function GetDepthSize(ValueIndex:Integer):Integer; override;
Procedure PrepareForGallery(IsEnabled:Boolean); override;
class Function SubGalleryStyles:Boolean; override;
public
Constructor Create(AOwner: TComponent); override;
Function AddBubble(Const AX,AY,AZ,ARadius:Double; Const AXLabel:String='';
AColor:TColor=clTeeColor):Integer;
Function IsValidSourceOf(Value:TChartSeries):Boolean; override;
Function MaxYValue:Double; override; // adds radius
Function MinYValue:Double; override; // substracts radius
Function MaxZValue:Double; override;
Function MinZValue:Double; override;
published
property ColorEachPoint default True;
property RadiusValues:TChartValueList read FRadiusValues write SetRadiusValues;
end;
implementation
Uses Math, Chart, TeeConst, TeeProCo;
{ TPoint3DSeries }
Constructor TPoint3DSeries.Create(AOwner: TComponent);
begin
inherited;
FPointer:=TSeriesPointer.Create(Self);
FBaseLine:=TChartHiddenPen.Create(CanvasChanged);
end;
Destructor TPoint3DSeries.Destroy;
begin
FBaseLine.Free;
FPointer.Free;
inherited;
end;
class Function TPoint3DSeries.SubGalleryStyles:Boolean;
begin
result:=True;
end;
Procedure TPoint3DSeries.SetPointer(Value:TSeriesPointer);
Begin
FPointer.Assign(Value);
end;
Procedure TPoint3DSeries.CalcZPositions(ValueIndex:Integer);
var tmp : Integer;
begin
// do not call inherited here
MiddleZ:=CalcZPos(ValueIndex);
tmp:=Math.Max(1,GetDepthSize(ValueIndex));
StartZ:=MiddleZ-tmp;
EndZ:=MiddleZ+tmp;
end;
Function TPoint3DSeries.GetLinePen:TChartPen;
begin
result:=Pen;
end;
type TPointerAccess=class(TSeriesPointer);
Procedure TPoint3DSeries.CalcHorizMargins(Var LeftMargin,RightMargin:Integer);
begin
inherited;
TPointerAccess(FPointer).CalcHorizMargins(LeftMargin,RightMargin);
end;
Procedure TPoint3DSeries.CalcVerticalMargins(Var TopMargin,BottomMargin:Integer);
begin
inherited;
TPointerAccess(FPointer).CalcVerticalMargins(TopMargin,BottomMargin);
end;
Procedure TPoint3DSeries.DrawValue(ValueIndex:Integer);
var tmpColor : TColor;
tmpStyle : TSeriesPointerStyle;
tmpX : Integer;
tmpY : Integer;
tmpZ : Integer;
tmpFirst : Integer;
begin
tmpColor:=ValueColor[ValueIndex];
if tmpColor<clNone then // 7.0
begin
CalcZPositions(ValueIndex);
With Pointer do
begin
tmpX:=CalcXPos(ValueIndex);
tmpY:=CalcYPos(ValueIndex);
if Visible then
begin { emulate TCustomSeries.DrawPointer method }
PrepareCanvas(ParentChart.Canvas,tmpColor);
if Assigned(FOnGetPointerStyle) then
tmpStyle:=FOnGetPointerStyle(Self,ValueIndex)
else
tmpStyle:=FPointer.Style;
DrawPointer( ParentChart.Canvas,ParentChart.View3D,
tmpX,tmpY,HorizSize,VertSize,tmpColor,tmpStyle);
end;
if BaseLine.Visible then
begin
tmpZ:=CalcZPos(ValueIndex);
ParentChart.Canvas.AssignVisiblePen(BaseLine);
ParentChart.Canvas.MoveTo3D(tmpX,tmpY+VertSize,tmpZ);
ParentChart.Canvas.LineTo3D(tmpX,GetVertAxis.IEndPos,tmpZ);
end;
tmpFirst:=FirstDisplayedIndex; // Problem when ValueColor[First] is clNone (null point)
if (ValueIndex<>tmpFirst) and LinePen.Visible then
With ParentChart.Canvas do
begin
AssignVisiblePen(LinePen);
BackMode:=cbmTransparent;
MoveTo3D(IOldX,IOldY,IOldZ);
LineTo3D(tmpX,tmpY,MiddleZ);
end;
IOldX:=tmpX;
IOldY:=tmpY;
IOldZ:=MiddleZ;
end;
end;
end;
Procedure TPoint3DSeries.DrawLegendShape(ValueIndex:Integer; Const Rect:TRect);
var tmpColor : TColor;
begin
if FPointer.Visible then
begin
if ValueIndex=TeeAllValues then tmpColor:=SeriesColor
else tmpColor:=ValueColor[ValueIndex];
TeePointerDrawLegend(Pointer,tmpColor,Rect,LinePen.Visible);
end
else inherited;
end;
Procedure TPoint3DSeries.AddSampleValues(NumValues:Integer; OnlyMandatory:Boolean=False);
var t : Integer;
Begin
for t:=1 to NumValues do
AddXYZ( RandomValue(100), RandomValue(100), RandomValue(100));
end;
Procedure TPoint3DSeries.SetDepthSize(Const Value:Double);
begin
SetDoubleProperty(FDepthSize,Value);
end;
Function TPoint3DSeries.MaxZValue:Double;
begin
result:=ZValues.MaxValue+FDepthSize;
end;
Procedure TPoint3DSeries.DrawMark( ValueIndex:Integer; Const St:String;
APosition:TSeriesMarkPosition);
begin
CalcZPositions(ValueIndex);
if FPointer.Visible then Marks.ZPosition:=MiddleZ
else Marks.ZPosition:=StartZ;
Marks.ApplyArrowLength(APosition);
inherited;
end;
Procedure TPoint3DSeries.Assign(Source:TPersistent);
begin
if Source is TPoint3DSeries then
With TPoint3DSeries(Source) do
begin
Self.Pointer :=FPointer;
Self.FDepthSize:=FDepthSize;
Self.BaseLine :=BaseLine;
end;
inherited;
end;
class Function TPoint3DSeries.GetEditorClass:String;
Begin
result:='TPoint3DSeriesEditor'; { <-- dont translate ! }
end;
Procedure TPoint3DSeries.PrepareForGallery(IsEnabled:Boolean);
begin
inherited;
LinePen.Color:=clNavy;
ParentChart.View3DOptions.Zoom:=60;
end;
Function TPoint3DSeries.Clicked(x,y:Integer):Integer;
var t : Integer;
tmpX : Integer;
tmpY : Integer;
OldX : Integer;
OldY : Integer;
begin
OldX:=X;
OldY:=Y;
result:=inherited Clicked(x,y);
if result=TeeNoPointClicked then
if FPointer.Visible then
for t:=0 to Count-1 do
begin
tmpX:=CalcXPos(t);
tmpY:=CalcYPos(t);
X:=OldX;
Y:=OldY;
if Assigned(ParentChart) then
ParentChart.Canvas.Calculate2DPosition(X,Y,CalcZPos(t));
if (Abs(tmpX-X)<FPointer.HorizSize) and { <-- Canvas.Zoom? }
(Abs(tmpY-Y)<FPointer.VertSize) then
begin
if Assigned(FOnClickPointer) then FOnClickPointer(Self,t,OldX,OldY);
result:=t;
break;
end;
end;
end;
procedure TPoint3DSeries.SetParentChart(const Value: TCustomAxisPanel);
begin
inherited;
if Assigned(Value) then { 5.01 }
FPointer.ParentChart:=Value;
end;
class procedure TPoint3DSeries.CreateSubGallery(
AddSubChart: TChartSubGalleryProc);
begin
inherited;
AddSubChart(TeeMsg_NoPoint);
AddSubChart(TeeMsg_Lines);
AddSubChart(TeeMsg_NoLine);
AddSubChart(TeeMsg_Colors);
AddSubChart(TeeMsg_Marks);
AddSubChart(TeeMsg_Hollow);
AddSubChart(TeeMsg_NoBorder);
if SubGalleryStyles then
begin
AddSubChart(TeeMsg_Point2D);
AddSubChart(TeeMsg_Triangle);
AddSubChart(TeeMsg_Star);
AddSubChart(TeeMsg_Circle);
AddSubChart(TeeMsg_DownTri);
AddSubChart(TeeMsg_Cross);
AddSubChart(TeeMsg_Diamond);
end;
end;
class procedure TPoint3DSeries.SetSubGallery(ASeries: TChartSeries;
Index: Integer);
begin
With TPoint3DSeries(ASeries) do
Case Index of
1: Pointer.Hide;
2: BaseLine.Visible:=True;
3: Pen.Hide;
4: ColorEachPoint:=True;
5: Marks.Visible:=True;
6: Pointer.Brush.Style:=bsClear;
7: Pointer.Pen.Hide;
8: Pointer.Draw3D:=False;
9: Pointer.Style:=psTriangle;
10: Pointer.Style:=psStar;
11: Pointer.Style:=psCircle;
12: Pointer.Style:=psDownTriangle;
13: Pointer.Style:=psCross;
14: Pointer.Style:=psDiamond;
else inherited;
end;
end;
procedure TPoint3DSeries.SetBaseLine(const Value: TChartHiddenPen);
begin
FBaseLine.Assign(Value);
end;
function TPoint3DSeries.GetDepthSize(ValueIndex: Integer): Integer;
begin
result:=ParentChart.DepthAxis.CalcSizeValue(FDepthSize) div 2;
end;
{ TBubble3DSeries }
Constructor TBubble3DSeries.Create(AOwner: TComponent);
begin
inherited;
FRadiusValues:=TChartValueList.Create(Self,TeeMsg_ValuesBubbleRadius); { <-- radius storage }
TPointerAccess(Pointer).AllowChangeSize:=False;
Pointer.Style:=psCircle;
ColorEachPoint:=True;
LinePen.Visible:=False;
end;
function TBubble3DSeries.AddBubble(const AX, AY, AZ, ARadius: Double;
const AXLabel: String; AColor: TColor): Integer;
begin
RadiusValues.TempValue:=ARadius;
result:=AddXYZ(AX,AY,AZ,AXLabel,AColor);
end;
procedure TBubble3DSeries.AddSampleValues(NumValues: Integer;
OnlyMandatory: Boolean);
Var t : Integer;
s : TSeriesRandomBounds;
Begin
s:=RandomBounds(NumValues);
with s do
for t:=1 to NumValues do { some sample values to see something in design mode }
Begin
AddBubble( tmpX, { X }
RandomValue(Round(DifY)), { Y }
RandomValue(200), { Z }
(DifY/15.0)+Round(DifY/(10+RandomValue(15))) { <- Radius }
);
tmpX:=tmpX+StepX;
end;
end;
Function TBubble3DSeries.GetDepthSize(ValueIndex:Integer):Integer;
begin
result:=ParentChart.DepthAxis.CalcSizeValue(RadiusValues.Value[ValueIndex]);
end;
procedure TBubble3DSeries.DrawValue(ValueIndex: Integer);
var tmpSize : Integer;
begin
tmpSize:=GetVertAxis.CalcSizeValue(RadiusValues.Value[ValueIndex]);
TPointerAccess(Pointer).ChangeHorizSize(tmpSize);
TPointerAccess(Pointer).ChangeVertSize(tmpSize);
inherited;
end;
function TBubble3DSeries.IsValidSourceOf(Value: TChartSeries): Boolean;
begin // Only 3D Bubbles can be assigned to 3D Bubbles
result:=Value is TBubble3DSeries;
end;
procedure TBubble3DSeries.SetRadiusValues(Value: TChartValueList);
begin
SetChartValueList(FRadiusValues,Value);
end;
function TBubble3DSeries.ApplyRadius(const Value: Double;
AList: TChartValueList; Increment: Boolean): Double;
var t : Integer;
begin
result:=Value;
for t:=0 to Count-1 do
if Increment then
result:=Math.Max(result,AList.Value[t]+RadiusValues.Value[t])
else
result:=Math.Min(result,AList.Value[t]-RadiusValues.Value[t]);
end;
function TBubble3DSeries.MaxYValue: Double;
begin
result:=ApplyRadius(inherited MaxYValue,YValues,True);
end;
function TBubble3DSeries.MaxZValue: Double;
begin
result:=ApplyRadius(inherited MaxZValue,ZValues,True);
end;
function TBubble3DSeries.MinYValue: Double;
begin
result:=ApplyRadius(inherited MinYValue,YValues,False);
end;
function TBubble3DSeries.MinZValue: Double;
begin
result:=ApplyRadius(inherited MinZValue,ZValues,False);
end;
class Function TBubble3DSeries.SubGalleryStyles:Boolean;
begin
result:=False;
end;
procedure TBubble3DSeries.CalcZPositions(ValueIndex: Integer);
var tmp : Integer;
begin
if Pointer.Draw3D and ParentChart.Canvas.SupportsFullRotation then
inherited
else
begin
StartZ:=CalcZPos(ValueIndex);
tmp:=Math.Max(1,GetDepthSize(ValueIndex));
MiddleZ:=StartZ+tmp;
EndZ:=MiddleZ+tmp;
end;
end;
procedure TBubble3DSeries.PrepareForGallery(IsEnabled: Boolean);
begin
inherited;
Pointer.Gradient.Visible:=True;
end;
initialization
RegisterTeeSeries(TPoint3DSeries, {$IFNDEF CLR}@{$ENDIF}TeeMsg_GalleryPoint3D,
{$IFNDEF CLR}@{$ENDIF}TeeMsg_Gallery3D,1);
RegisterTeeSeries(TBubble3DSeries, {$IFNDEF CLR}@{$ENDIF}TeeMsg_GalleryBubble3D,
{$IFNDEF CLR}@{$ENDIF}TeeMsg_Gallery3D,1);
finalization
UnRegisterTeeSeries([TPoint3DSeries,TBubble3DSeries]);
end.
|
unit uFuncionarioEdt;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.Buttons, Vcl.ExtCtrls,
Vcl.ComCtrls, ENumEd, EChkCPF, Vcl.Mask, EDBDate, EDateEd, Vcl.Grids,
Vcl.Samples.Calendar, Vcl.DBCtrls;
type
TOperacao = (OpIncluir, OpAlterar, OpExcluir);
TfrmFuncionarioEdt = class(TForm)
pnlRodape: TPanel;
pnlControle: TPanel;
btnFechar: TBitBtn;
btnOK: TBitBtn;
gpDadospessoai: TGroupBox;
lb2: TLabel;
lb3: TLabel;
lb4: TLabel;
edtPON_NOME_FUN: TEdit;
mePON_CPF_FUN: TMaskEdit;
pgcCorpo: TPageControl;
tsDadosPessoais: TTabSheet;
tsEndereco: TTabSheet;
gpEndereco: TGroupBox;
lb8: TLabel;
lb9: TLabel;
lb10: TLabel;
lb11: TLabel;
lb12: TLabel;
edPON_CIDADE_FUN: TEdit;
mePON_CEP_FUN: TMaskEdit;
cbbPON_ESTADO_FUN: TComboBox;
edPON_BAIRRO_FUN: TEdit;
edPON_ENDERECO_FUN: TEdit;
tsContato: TTabSheet;
gpContato: TGroupBox;
lb5: TLabel;
lb7: TLabel;
lb13: TLabel;
edPON_EMAIL_FUN: TEdit;
mePON_CELULAR_FUN: TMaskEdit;
mePON_TEL_FUN: TMaskEdit;
tsHorarioPonto: TTabSheet;
gp1: TGroupBox;
lb1: TLabel;
lb14: TLabel;
lstHorarioInicial: TListBox;
lstHorarioFinal: TListBox;
edtPON_DATANASC_FUN: TEvDateEdit;
dblst1: TDBListBox;
procedure btnOKClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure mePON_CPF_FUNExit(Sender: TObject);
private
{ Private declarations }
procedure carregarRegistro;
procedure carregarPONTBBAT;
procedure moverDadosFormulario;
procedure limparCampos;
function testarDados: Boolean;
function incluir: Boolean;
function alterar: Boolean;
function excluir: Boolean;
public
{ Public declarations }
Operacao: TOperacao;
pPON_PK_SEQ_FUN: Integer;
end;
var
frmFuncionarioEdt: TfrmFuncionarioEdt;
implementation
{$R *.dfm}
uses uDmDados, uConstates, uTipoFeriado, uFuncionario, uFuncoes;
{ TfrmTipoFeriadoEdt }
function TfrmFuncionarioEdt.alterar: Boolean;
begin
carregarRegistro;
if not dmDados.cdsPONTBTPF.IsEmpty then
begin
try
dmDados.cdsPONTBTPF.Edit;
dmDados.cdsPONTBTPF.FieldByName('PON_DESC_TPF').AsString :=
edtPON_NOME_FUN.Text;
dmDados.cdsPONTBTPF.Post;
dmDados.cdsPONTBTPF.ApplyUpdates(0);
frmTipoFeriado.AtualizaGrid;
except
on e: Exception do
begin
ShowMessage('Erro ao alterar tipo de feriado: ' + e.Message);
end;
end;
end;
Result := True;
end;
procedure TfrmFuncionarioEdt.btnOKClick(Sender: TObject);
begin
if testarDados then
begin
if Operacao = OpIncluir then
begin
if incluir then
begin
ShowMessage('Registro incluido com sucesso!');
limparCampos;
pgcCorpo.ActivePageIndex := 0;
if edtPON_NOME_FUN.CanFocus then
edtPON_NOME_FUN.SetFocus;
end;
end
else if Operacao = OpAlterar then
begin
if alterar then
begin
ShowMessage('Registro alterado com sucesso!');
ModalResult := mrOk;
end;
end
else
begin
if MessageDlg('Tem certeza que deseja excluir esse registro?',
mtConfirmation, [mbYes, mbNo], 0) = mrYes then
begin
if excluir then
begin
ShowMessage('Registro excluído com sucesso!');
ModalResult := mrOk;
end;
end;
end;
end;
end;
procedure TfrmFuncionarioEdt.carregarRegistro;
begin
dmDados.cdsPONTBFUN.Close;
dmDados.cdsPONTBFUN.CommandText := ' SELECT * FROM PONTBFUN WHERE PON_PK_SEQ_FUN = ' +
QuotedStr(VarToStr(pPON_PK_SEQ_FUN));
dmDados.cdsPONTBFUN.Open;
end;
function TfrmFuncionarioEdt.excluir: Boolean;
begin
carregarRegistro;
if not dmDados.cdsPONTBTPF.IsEmpty then
begin
try
dmDados.cdsPONTBTPF.Delete;
dmDados.cdsPONTBTPF.ApplyUpdates(0);
frmTipoFeriado.AtualizaGrid;
except
on e: Exception do
begin
ShowMessage('Erro ao ecluir tipo de feriado: ' + e.Message);
end;
end;
end;
Result := True;
end;
procedure TfrmFuncionarioEdt.FormShow(Sender: TObject);
begin
if Operacao = OpIncluir then
begin
Caption := 'Inclusão funcionário';
pgcCorpo.ActivePageIndex := 0;
edtPON_NOME_FUN.SetFocus;
edtPON_DATANASC_FUN.DateText := DateToStr(Now);
CarregarPONTBBAT;
end
else if Operacao = OpAlterar then
begin
Caption := 'Alteração de funcionário';
carregarRegistro;
moverDadosFormulario;
frmFuncionario.AtualizaGrid;
end
else
begin
Caption := 'Exclusão de tipo de feriado';
carregarRegistro;
CarregarPONTBBAT;
// MoverDadosFormularios;
frmTipoFeriado.AtualizaGrid;
pnlControle.Enabled := False;
btnOK.SetFocus;
end;
end;
function TfrmFuncionarioEdt.incluir: Boolean;
begin
try
dmDados.carregarPONTBFUN;
dmDados.cdsPONTBFUN.Insert;
// Mover dados pessoais
dmDados.cdsPONTBFUN.FieldByName('PON_PK_SEQ_FUN').AsInteger := 0;
dmDados.cdsPONTBFUN.FieldByName('PON_NOME_FUN').AsString := edtPON_NOME_FUN.Text;
dmDados.cdsPONTBFUN.FieldByName('PON_CPF_FUN').AsString := mePON_CPF_FUN.Text;
dmDados.cdsPONTBFUN.FieldByName('PON_DATANASC_FUN').AsDateTime := StrToDateTime(edtPON_DATANASC_FUN.DateText);
// Mover dados do Endereço
dmDados.cdsPONTBFUN.FieldByName('PON_CEP_FUN').AsString := mePON_CEP_FUN.Text;
if cbbPON_ESTADO_FUN.ItemIndex > -1 then
dmDados.cdsPONTBFUN.FieldByName('PON_ESTADO_FUN').AsString := cbbPON_ESTADO_FUN.Text;
dmDados.cdsPONTBFUN.FieldByName('PON_CIDADE_FUN').AsString := edPON_CIDADE_FUN.Text;
dmDados.cdsPONTBFUN.FieldByName('PON_BAIRRO_FUN').AsString := edPON_BAIRRO_FUN.Text;
dmDados.cdsPONTBFUN.FieldByName('PON_ENDERECO_FUN').AsString := edPON_ENDERECO_FUN.Text;
// Mover dados contato
dmDados.cdsPONTBFUN.FieldByName('PON_CELULAR_FUN').AsString := mePON_CELULAR_FUN.Text;
dmDados.cdsPONTBFUN.FieldByName('PON_TEL_FUN').AsString := mePON_TEL_FUN.Text;
dmDados.cdsPONTBFUN.FieldByName('PON_EMAIL_FUN').AsString := edPON_EMAIL_FUN.Text;
// Mover dados da batida de ponto
dmDados.cdsPONTBFUN.FieldByName('PON_BATMANHA_FUN').AsInteger := lstHorarioInicial.ItemIndex;
dmDados.cdsPONTBFUN.FieldByName('PON_BATTARDE_FUN').AsInteger := lstHorarioFinal.ItemIndex;
dmDados.cdsPONTBFUN.Post;
dmDados.cdsPONTBFUN.ApplyUpdates(0);
frmFuncionario.AtualizaGrid;
except
on e: Exception do
begin
ShowMessage('Erro ao inserir funcionário: ' + e.Message);
end;
end;
Result := True;
end;
procedure TfrmFuncionarioEdt.mePON_CPF_FUNExit(Sender: TObject);
begin
if Trim(mePON_CPF_FUN.Text) <> '' then
begin
if not uFuncoes.testacpf(mePON_CPF_FUN.Text) then
ShowMessage('CPF Invalido!');
end;
end;
procedure TfrmFuncionarioEdt.CarregarPONTBBAT;
var
horarios : string;
numero: Integer;
begin
horarios := '';
numero := 0;
dmDados.carregarPONTBBAT;
while not dmDados.cdsPONTBBAT.Eof do
begin
horarios := dmDados.cdsPONTBBAT.FieldByName('PON_HORAINICIAL_BAT').AsString + ' ás ' +
dmDados.cdsPONTBBAT.FieldByName('PON_HORAFINAL_BAT').AsString;
lstHorarioInicial.Items[numero] := horarios;
lstHorarioFinal.Items[numero] := horarios;
dmDados.cdsPONTBBAT.Next;
uFuncoes.Inc(numero);
end;
end;
procedure TfrmFuncionarioEdt.moverDadosFormulario;
begin
try
// Mover dados pessoais
edtPON_NOME_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_NOME_FUN').AsString;
mePON_CPF_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_CPF_FUN').AsString;
edtPON_DATANASC_FUN.DateText := dmDados.cdsPONTBFUN.FieldByName('PON_DATANASC_FUN').AsString;
// Mover dados do Endereço
mePON_CEP_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_CEP_FUN').AsString;
cbbPON_ESTADO_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_ESTADO_FUN').AsString;
edPON_CIDADE_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_CIDADE_FUN').AsString;
edPON_BAIRRO_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_BAIRRO_FUN').AsString;
edPON_ENDERECO_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_ENDERECO_FUN').AsString;
// Mover dados contato
mePON_CELULAR_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_CELULAR_FUN').AsString;
mePON_TEL_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_TEL_FUN').AsString;
edPON_EMAIL_FUN.Text := dmDados.cdsPONTBFUN.FieldByName('PON_EMAIL_FUN').AsString;
// // Mover dados da batida de ponto
// dmDados.cdsPONTBFUN.FieldByName('PON_BATMANHA_FUN').AsInteger := 3;
// dmDados.cdsPONTBFUN.FieldByName('PON_BATTARDE_FUN').AsInteger := 5;
except
on e: Exception do
begin
ShowMessage('Erro ao mover funcionário para formulário: ' + e.Message);
end;
end;
end;
procedure TfrmFuncionarioEdt.limparCampos;
begin
// Mover dados pessoais
edtPON_NOME_FUN.Text := '';
mePON_CPF_FUN.Text := '';
edtPON_DATANASC_FUN.DateText := DateToStr(now);
// Mover dados do Endereço
mePON_CEP_FUN.Text := '';
cbbPON_ESTADO_FUN.Text := '';
edPON_CIDADE_FUN.Text := '';
edPON_BAIRRO_FUN.Text := '';
edPON_ENDERECO_FUN.Text := '';
// Mover dados contato
mePON_CELULAR_FUN.Text := '';
mePON_TEL_FUN.Text := '';
edPON_EMAIL_FUN.Text := '';
// // Mover dados da batida de ponto
// dmDados.cdsPONTBFUN.FieldByName('PON_BATMANHA_FUN').AsInteger := 3;
// dmDados.cdsPONTBFUN.FieldByName('PON_BATTARDE_FUN').AsInteger := 5;
end;
function TfrmFuncionarioEdt.testarDados: Boolean;
begin
Result := False;
if (Operacao = OpIncluir) or (Operacao = OpAlterar) then
begin
if edtPON_NOME_FUN.Text = '' then
begin
ShowMessage('Informe o nome do funcionário.');
if edtPON_NOME_FUN.CanFocus then
edtPON_NOME_FUN.SetFocus;
Exit;
end;
if (edtPON_DATANASC_FUN.DateText = '') then
begin
ShowMessage('Data de nascimento deve ser infomada.');
if edtPON_DATANASC_FUN.CanFocus then
edtPON_DATANASC_FUN.SetFocus;
Exit;
end;
if mePON_CPF_FUN.Text = '' then
begin
ShowMessage('CPF deve ser infomado');
if mePON_CPF_FUN.CanFocus then
mePON_CPF_FUN.SetFocus;
Exit;
end
end;
Result := True;
end;
end.
|
unit Module.ValueObject.StringVO;
interface
type
IStringVO = interface(IInterface)
['{A362E218-6B58-4837-A4BF-E2CD070C7C49}']
function AsString: string;
end;
implementation
end.
|
unit uUploadVio;
interface
uses
System.Classes, SysUtils, ActiveX, uGlobal, uRequestItf, uJsonUtils,
FireDAC.Comp.Client, Generics.Collections;
type
TUploadVioThread = class(TThread)
private
procedure UploadVio(systemid: String);
procedure GetVio;
protected
procedure Execute; override;
end;
implementation
{
Important: Methods and properties of objects in visual components can only be
used in a method called using Synchronize, for example,
Synchronize(UpdateCaption);
and UpdateCaption could look like,
procedure TUploadVioThread.UpdateCaption;
begin
Form1.Caption := 'Updated in a thread';
end;
or
Synchronize(
procedure
begin
Form1.Caption := 'Updated in thread via an anonymous method'
end
)
);
where an anonymous method is passed.
Similarly, the developer can call the Queue method with similar parameters as
above, instead passing another TThread class as the first parameter, putting
the calling thread in a queue with the other thread.
}
{ TUploadVioThread }
procedure TUploadVioThread.Execute;
begin
ActiveX.CoInitialize(nil);
gLogger.Info('Upload Vio Thread Start');
GetVio();
gLogger.Info('Upload Vio Thread End');
ActiveX.CoUninitialize;
end;
procedure TUploadVioThread.GetVio;
var
s: String;
begin
s := 'select a.systemid from T_VIO_HIS a inner join S_Device b on a.WFDD = b.SBBH where b.AutoUpload = 1 and a.zt=''2''';
s := s + ' union ';
s := s + ' select systemid from T_VIO_HIS where DATEDIFF(DAY, WFSJ, GETDATE()) >= 10 and zt = ''2'' ';
with gSQLHelper.Query(s) do
begin
while not Eof do
begin
UploadVio(Fields[0].AsString);
Next;
end;
Free;
end;
end;
procedure TUploadVioThread.UploadVio(systemid: String);
var
s: string;
begin
s := TRequestItf.DbQuery('UploadVio', 'systemid=' + systemid);
gLogger.Info('[UploadVio] ' + systemid + ',ÉÏ´«½á¹û:' + s);
end;
end.
|
unit LoanList;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, BaseDocked, Vcl.StdCtrls, RzLabel,
Vcl.ExtCtrls, RzPanel, Data.DB, Vcl.Mask, RzEdit, Vcl.Grids, Vcl.DBGrids,
RzDBGrid, LoanListIntf, DockedFormIntf, AppConstants, ADODB, System.Rtti,
Vcl.DBCtrls, RzDBCmbo, RzButton, RzRadChk, RzDBChk, RzDBEdit, RzCmboBx;
type
TfrmLoanList = class(TfrmBaseDocked, ILoanListFilter, IDockedForm)
pnlSearch: TRzPanel;
Label1: TLabel;
edSearchKey: TRzEdit;
pnlList: TRzPanel;
grList: TRzDBGrid;
pnlDockMain: TRzPanel;
urlPending: TRzURLLabel;
urlAssessed: TRzURLLabel;
urlApproved: TRzURLLabel;
urlActive: TRzURLLabel;
urlCancelled: TRzURLLabel;
urlRejected: TRzURLLabel;
urlClosed: TRzURLLabel;
procedure grListDblClick(Sender: TObject);
procedure edSearchKeyChange(Sender: TObject);
procedure urlPendingClick(Sender: TObject);
procedure urlAssessedClick(Sender: TObject);
procedure urlApprovedClick(Sender: TObject);
procedure urlActiveClick(Sender: TObject);
procedure urlCancelledClick(Sender: TObject);
procedure urlRejectedClick(Sender: TObject);
procedure urlClosedClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
procedure FilterList(const filterType: TLoanFilterType);
procedure SetTitle(const title: string);
end;
implementation
{$R *.dfm}
uses
AppData, FormsUtil, Loan, DockIntf, LoanClient, Employer;
procedure TfrmLoanList.edSearchKeyChange(Sender: TObject);
var
filter: string;
begin
inherited;
if Trim(edSearchKey.Text) <> '' then
filter := 'name like ''*' + edSearchKey.Text + '*'''
else
filter := '';
grList.DataSource.DataSet.Filter := filter;
end;
procedure TfrmLoanList.FilterList(const filterType: TLoanFilterType);
begin
with (grList.DataSource.DataSet as TADODataSet).Parameters do
ParamByName('@filter_type').Value := filterType;
OpenGridDataSources(pnlList);
end;
procedure TfrmLoanList.grListDblClick(Sender: TObject);
var
id: string;
intf: IDock;
empl: TEmployer;
begin
with grList.DataSource.DataSet do
begin
if RecordCount > 0 then
begin
empl := TEmployer.Create(FieldByName('emp_id').AsString,
FieldByName('emp_name').AsString,
FieldByName('emp_add').AsString,nil);
id := FieldByName('loan_id').AsString;
ln := TLoan.Create;
ln.Id := id;
ln.Client := TLoanClient.Create(FieldByName('entity_id').AsString,
FieldByName('name').AsString, empl,
FieldByName('client_addr').AsString,
FieldByName('age').AsInteger,
FieldByName('net_pay').AsCurrency,
FieldByName('valid_ident_docs').AsInteger);
ln.Status := FieldByName('status_id').AsString;
ln.Action := laNone;
if Supports(Application.MainForm,IDock,intf) then
intf.DockForm(fmLoanMain);
end;
end;
end;
procedure TfrmLoanList.SetTitle(const title: string);
begin
lblTitle.Caption := title;
end;
procedure TfrmLoanList.urlActiveClick(Sender: TObject);
begin
inherited;
FilterList(lftActive);
SetTitle('Active loans');
end;
procedure TfrmLoanList.urlApprovedClick(Sender: TObject);
begin
inherited;
FilterList(lftApproved);
SetTitle('Approved loans');
end;
procedure TfrmLoanList.urlAssessedClick(Sender: TObject);
begin
inherited;
FilterList(lftAssessed);
SetTitle('Assessed loans');
end;
procedure TfrmLoanList.urlCancelledClick(Sender: TObject);
begin
inherited;
FilterList(lftCancelled);
SetTitle('Cancelled loans');
end;
procedure TfrmLoanList.urlClosedClick(Sender: TObject);
begin
inherited;
FilterList(lftClosed);
SetTitle('Closed loans');
end;
procedure TfrmLoanList.urlPendingClick(Sender: TObject);
begin
inherited;
FilterList(lftPending);
SetTitle('Pending loans');
end;
procedure TfrmLoanList.urlRejectedClick(Sender: TObject);
begin
inherited;
FilterList(lftRejected);
SetTitle('Rejected loans');
end;
end.
|
unit ClassLetterStack;
interface
uses ClassLetters;
type TStack = array[1..7] of TLetter;
TLetterStack = class
private
FLetters : TLetters;
FStack : TStack;
public
constructor Create( Letters : TLetters );
destructor Destroy; override;
procedure PopStack( Letters : array of TLetter );
procedure TakeNew;
procedure ChangeStack;
procedure ChangeSomeLetters( Letters : array of TLetter );
property Stack : TStack read FStack;
end;
implementation
//==============================================================================
// Constructor / destructor
//==============================================================================
constructor TLetterStack.Create( Letters : TLetters );
begin
inherited Create;
FLetters := Letters;
end;
destructor TLetterStack.Destroy;
begin
inherited;
end;
//==============================================================================
// P U B L I C
//==============================================================================
procedure TLetterStack.PopStack( Letters : array of TLetter );
var I, J : integer;
begin
for I := Low( Letters ) to High( Letters ) do
for J := Low( FStack ) to High( FStack ) do
if ((FStack[J].C = Letters[I].C) and
(FStack[J].Value = Letters[I].Value)) then
begin
FStack[J].C := #0;
FStack[J].Value := 0;
break;
end;
for I := Low( FStack ) to High( FStack ) do
if (FStack[I].C = #0) then
for J := I+1 to High( FStack ) do
if (FStack[J].C <> #0) then
begin
FStack[I].C := FStack[J].C;
FStack[I].Value := FStack[J].Value;
FStack[J].C := #0;
FStack[J].Value := 0;
break;
end;
end;
procedure TLetterStack.TakeNew;
var I : integer;
begin
for I := Low( FStack ) to High( FStack ) do
if (FStack[I].C = #0) then
begin
FStack[I] := FLetters.GetLetter;
if (FStack[I].C = #0) then
break;
end;
end;
procedure TLetterStack.ChangeStack;
var New : TNewLetters;
I : integer;
begin
New := FLetters.ChangeLetters( FStack );
for I := 1 to 7 do
FStack[I].C := #0;
for I := 0 to Length( New )-1 do
FStack[I+1] := New[I];
end;
procedure TLetterStack.ChangeSomeLetters( Letters : array of TLetter );
var New : TNewLetters;
I, J, K : integer;
begin
New := FLetters.ChangeLetters( Letters );
K := 0;
for I := Low( Letters ) to High( Letters ) do
for J := Low( FStack )to High( FStack ) do
if (Letters[I].C = FStack[J].C) then
begin
FStack[J] := New[K];
Inc( K );
if (K > High( New )) then
exit
else
break;
end;
end;
end.
|
{**********************************************}
{ TRotateTool Editor }
{ Copyright (c) 1999-2004 by David Berneda }
{**********************************************}
unit TeeRotateToolEditor;
{$I TeeDefs.inc}
interface
uses {$IFNDEF LINUX}
Windows, Messages,
{$ENDIF}
SysUtils, Classes,
{$IFDEF CLX}
QGraphics, QControls, QForms, QDialogs, QStdCtrls,
{$ELSE}
Graphics, Controls, Forms, Dialogs, StdCtrls,
{$ENDIF}
TeeTools, TeCanvas, TeePenDlg;
type
TRotateToolEditor = class(TForm)
CBInverted: TCheckBox;
Label1: TLabel;
CBStyle: TComboFlat;
CBButton: TComboFlat;
Label2: TLabel;
BOutline: TButtonPen;
procedure FormCreate(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure CBInvertedClick(Sender: TObject);
procedure CBStyleChange(Sender: TObject);
procedure CBButtonChange(Sender: TObject);
private
{ Private declarations }
Tool : TRotateTool;
public
{ Public declarations }
end;
implementation
{$IFNDEF CLX}
{$R *.DFM}
{$ELSE}
{$R *.xfm}
{$ENDIF}
procedure TRotateToolEditor.FormCreate(Sender: TObject);
begin
Align:=alClient;
end;
procedure TRotateToolEditor.FormShow(Sender: TObject);
begin
Tool:=TRotateTool(Tag);
if Assigned(Tool) then
with Tool do
begin
CBInverted.Checked:=Inverted;
CBStyle.ItemIndex:=Ord(Style);
// 6.01
case Button of
mbLeft: CBButton.ItemIndex:=0;
mbMiddle: CBButton.ItemIndex:=1;
else
CBButton.ItemIndex:=2;
end;
BOutline.LinkPen(Pen);
end;
end;
procedure TRotateToolEditor.CBInvertedClick(Sender: TObject);
begin
Tool.Inverted:=CBInverted.Checked;
end;
procedure TRotateToolEditor.CBStyleChange(Sender: TObject);
begin
Tool.Style:=TRotateToolStyles(CBStyle.ItemIndex);
end;
procedure TRotateToolEditor.CBButtonChange(Sender: TObject);
begin
// 6.01
Case CBButton.ItemIndex of
0: Tool.Button:=mbLeft;
1: Tool.Button:=mbMiddle;
else
Tool.Button:=mbRight;
end;
end;
initialization
RegisterClass(TRotateToolEditor);
end.
|
unit ProcRefUnit;
interface
uses NotifyEvents;
type
// —сылка на метод обрабатывающий данные запроса
TProcRef = reference to procedure(ASender: TObject);
IHandling = interface(IInterface)
procedure Process(AProcRef: TProcRef; ANotifyEventRef: TNotifyEventRef);
end;
implementation
end.
|
object FormBitPatternHelp: TFormBitPatternHelp
Left = 0
Top = 0
BorderStyle = bsToolWindow
Caption = 'Bit Pattern Usage'
ClientHeight = 536
ClientWidth = 769
Color = clBtnFace
Font.Charset = DEFAULT_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'Tahoma'
Font.Style = []
FormStyle = fsStayOnTop
OldCreateOrder = False
OnCreate = FormCreate
PixelsPerInch = 96
TextHeight = 13
object PanelMemoContainer: TPanel
AlignWithMargins = True
Left = 0
Top = 0
Width = 769
Height = 536
Margins.Left = 0
Margins.Top = 0
Margins.Right = 0
Margins.Bottom = 0
Align = alClient
BevelOuter = bvNone
Enabled = False
TabOrder = 0
ExplicitLeft = 64
ExplicitTop = 36
ExplicitWidth = 185
ExplicitHeight = 41
object JvRichEditUsage: TJvRichEdit
AlignWithMargins = True
Left = 0
Top = 0
Width = 769
Height = 536
Margins.Left = 0
Margins.Top = 0
Margins.Right = 0
Margins.Bottom = 0
Align = alClient
AutoSize = False
Flat = True
Font.Charset = ANSI_CHARSET
Font.Color = clWindowText
Font.Height = -11
Font.Name = 'Tahoma'
Font.Style = []
ParentFlat = False
ParentFont = False
ReadOnly = True
TabOrder = 0
WordSelection = False
ExplicitLeft = 3
ExplicitTop = 3
ExplicitWidth = 763
ExplicitHeight = 492
end
end
end
|
unit uEventModel;
interface
uses uBase, Classes, SysUtils, Generics.Collections, uExceptions, uExceptionCodes,
Variants;
type
TEventID = string;
ISubscriber = interface
procedure ProcessEvent( const aEventID : TEventID; const aEventData : variant );
end;
TBaseSubscriber = class( TBaseObject, ISubscriber )
procedure ProcessEvent( const aEventID : TEventID; const aEventData : variant ); virtual;
end;
TInnerEventData = class( TBaseObject )
public
EventID : TEventID;
Subscriber : ISubscriber;
end;
TEventModel = class( TBaseObject )
strict private
FList : TObjectList<TInnerEventData>;
public
constructor Create;
destructor Destroy; override;
procedure RegisterSubscriber( const aEventID : TEventID; const aSubscriber : ISubscriber );
procedure UnRegister( const aEventID : TEventID; const aSubscriber : ISubscriber ); overload;
procedure UnRegister( const aSubscriber : ISubscriber ); overload;
procedure Event( const aEventID : TEventID; const aEventData : variant ); overload;
procedure Event( const aEventID : TEventID ); overload;
end;
implementation
{ TBaseSubscriber }
procedure TBaseSubscriber.ProcessEvent(const aEventID: TEventID; const aEventData: variant );
begin
RaiseFatalException( SYS_EXCEPT );
end;
{ TEventModel }
constructor TEventModel.Create;
begin
inherited Create;
FList := TObjectList<TInnerEventData>.Create;
end;
destructor TEventModel.Destroy;
begin
FList.Clear;
inherited;
end;
procedure TEventModel.Event(const aEventID: TEventID);
begin
Event( aEventID, unassigned );
end;
procedure TEventModel.Event(const aEventID: TEventID; const aEventData: variant );
var
InnerData : TInnerEventData;
begin
for InnerData in FList do begin
if CompareStr( InnerData.EventID, aEventID ) = 0 then begin
InnerData.Subscriber.ProcessEvent( aEventID, aEventData );
end;
end;
end;
procedure TEventModel.RegisterSubscriber(const aEventID: TEventID;
const aSubscriber: ISubscriber);
var
InnerData : TInnerEventData;
begin
InnerData := TInnerEventData.Create;
InnerData.EventID := aEventID;
InnerData.Subscriber := aSubscriber;
FList.Add( InnerData );
end;
procedure TEventModel.UnRegister(const aSubscriber: ISubscriber);
var
i : integer;
InnerData : TInnerEventData;
begin
i := 0;
while i < FList.Count do begin
InnerData := FList.Items[i];
if InnerData.Subscriber = aSubscriber then begin
FList.Delete(i);
continue;
end;
Inc(i);
end;
end;
procedure TEventModel.UnRegister(const aEventID: TEventID;
const aSubscriber: ISubscriber);
var
InnerData : TInnerEventData;
i : integer;
begin
for i := 0 to FList.Count - 1 do begin
InnerData := FList.Items[ i ];
if ( aSubscriber = InnerData.Subscriber ) and
( CompareStr( aEventID, InnerData.EventID ) = 0 ) then begin
FList.Delete( i );
break;
end;
end;
end;
end.
|
unit ExportCSV;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, Buttons, ExtCtrls, Menus, db, Oracle, OracleData, RXCtrls, Animate, GIFCtrl, ImgList;
type
TFmExportCSV = class(TForm)
Panel1: TPanel;
OracleQuery1: TOracleQuery;
Image1: TImage;
RxGIFAnimator1: TRxGIFAnimator;
Image2: TImage;
Label1: TLabel;
Label2: TLabel;
ImageList1: TImageList;
BitBtn1: TBitBtn;
procedure OracleQuery1ThreadExecuted(Sender: TOracleQuery);
procedure OracleQuery1ThreadFinished(Sender: TOracleQuery);
procedure OracleQuery1ThreadRecord(Sender: TOracleQuery);
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
procedure FormCreate(Sender: TObject);
private
FFilename: string;
FFieldNames: array of string;
FHeader: string;
FS: TFileStream;
public
{ Public declarations }
end;
procedure OracleDataSetToCSV(const ADataSet: TOracleDataSet; const AFilename: string; const AFieldNames: array of string);
implementation
{$R *.DFM}
const
SEPARATOR_CSV = ';';
procedure OracleDataSetToCSV(const ADataSet: TOracleDataSet; const AFilename: string; const AFieldNames: array of string);
var
LC: Integer;
begin
with TFmExportCSV.Create(Application) do
try
OracleQuery1.Session := ADataSet.Session;
OracleQuery1.SQL.Assign(ADataSet.SQL);
FFilename := AFilename;
SetLength(FFieldNames, Length(AFieldNames));
for LC := 0 to Length(AFieldNames)-1 do
FFieldNames[LC] := AFieldNames[LC];
if Length(FFieldNames) > 0 then
begin
FHeader := '';
for LC := 0 to Length(FFieldNames)-1 do
FHeader := FHeader + ADataSet.FieldByName(FFieldNames[LC]).DisplayLabel + SEPARATOR_CSV;
FHeader := FHeader + #13#10;
RxGIFAnimator1.Animate := True;
OracleQuery1.Execute;
ShowModal;
end;
finally
Free;
end;
end;
procedure TFmExportCSV.OracleQuery1ThreadExecuted(Sender: TOracleQuery);
var
LC: Integer;
Linia: string;
begin
FS := TFileStream.Create(FFilename, fmCreate);
FS.Size := 0;
FS.Position := 0;
if Length(FHeader) > 0 then
FS.Write(PChar(FHeader)^, Length(FHeader));
end;
procedure TFmExportCSV.OracleQuery1ThreadFinished(Sender: TOracleQuery);
var
TmpIcon: TIcon;
begin
FS.Free;
RxGIFAnimator1.Animate := False;
RxGIFAnimator1.Hide;
Label2.Hide;
Label1.Caption := 'Data export finished';
BitBtn1.Show;
TmpIcon := TIcon.Create;
try
ImageList1.GetIcon(2, TmpIcon);
Image1.Picture.Icon := TmpIcon;
ImageList1.GetIcon(3, TmpIcon);
Image2.Picture.Icon := TmpIcon;
finally
TmpIcon.Free;
end;
end;
procedure TFmExportCSV.OracleQuery1ThreadRecord(Sender: TOracleQuery);
var
LC: Integer;
Line: string;
begin
Line := '';
for LC := 0 to Length(FFieldNames)-1 do
Line := Line + Sender.FieldAsString(FFieldNames[LC]) + SEPARATOR_CSV;
if (Sender.RowsProcessed and 63) = 63 then
begin
Label2.Caption := 'Processed records: ' + IntToStr(Sender.RowsProcessed);
Label2.Refresh;
end;
Line := Line + #13#10;
FS.Write(PChar(Line)^, Length(Line));
end;
procedure TFmExportCSV.FormCloseQuery(Sender: TObject; var CanClose: Boolean);
begin
CanClose := ModalResult <> mrNone;
end;
procedure TFmExportCSV.FormCreate(Sender: TObject);
var
TmpIcon: TIcon;
begin
TmpIcon := TIcon.Create;
try
ImageList1.GetIcon(0, TmpIcon);
Image1.Picture.Icon := TmpIcon;
ImageList1.GetIcon(1, TmpIcon);
Image2.Picture.Icon := TmpIcon;
finally
TmpIcon.Free;
end;
end;
end.
|
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, TlHelp32;
type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Button4: TButton;
Memo1: TMemo;
Button5: TButton;
Button6: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
procedure Button5Click(Sender: TObject);
procedure Button6Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
Procedure FinalizaProcesso(ProcessID: integer);
var
SnapShot : THandle;
pe : TProcessEntry32;
codigo : string;
processo : dword;
C : integer;
begin
try
TerminateProcess(OpenProcess($0001,false,ProcessID),0); // $0001 = Process_Terminate.
codigo := '';
processo := 0;
except
MessageDLG('Falha ao encerrar o processo!',mtInformation,[mbOK],0);
end;
end;
function WinExecProcess(FileName: String; Visibility: integer): integer;
var
zAppName: array[0..512] of char;
zCurDir: array[0..255] of char;
WorkDir: String;
StartupInfo: TStartupInfo;
ProcessInfo: TProcessInformation;
Res: UINT;
begin
StrPCopy(zAppName, FileName);
GetDir(0, WorkDir);
StrPCopy(zCurDir, WorkDir);
FillChar(StartupInfo, Sizeof(StartupInfo), #0);
StartupInfo.cb := Sizeof(StartupInfo);
StartupInfo.dwFlags := STARTF_USESHOWWINDOW;
StartupInfo.wShowWindow := Visibility;
if not (CreateProcess(nil,
zAppName, { pointer to command line string }
nil, { pointer to process security attributes}
nil, { pointer to thread security attributes }
false, { handle inheritance flag }
CREATE_NEW_CONSOLE or { creation flags }
NORMAL_PRIORITY_CLASS,
nil, { pointer to new environment block }
nil, { pointer to current directory name }
StartupInfo, { pointer to STARTUPINFO }
ProcessInfo)) then { pointer to PROCESS_INF }
Result := -1
else
begin
GetExitCodeProcess(ProcessInfo.hProcess, Res);
{Added v2.4.4 (JS)}
CloseHandle(ProcessInfo.hProcess);
CloseHandle(ProcessInfo.hThread);
Result := ProcessInfo.dwProcessId;
end;
end;
procedure ExecNewProcess(ProgramName : String; Wait: Boolean);
var
StartInfo : TStartupInfo;
ProcInfo : TProcessInformation;
CreateOK : Boolean;
begin
{ fill with known state }
FillChar(StartInfo,SizeOf(TStartupInfo),#0);
FillChar(ProcInfo,SizeOf(TProcessInformation),#0);
StartInfo.cb := SizeOf(TStartupInfo);
CreateOK := CreateProcessW(nil, pChar(ProgramName), nil, nil,False,
CREATE_NEW_PROCESS_GROUP+NORMAL_PRIORITY_CLASS,
nil, nil, StartInfo, ProcInfo);
{ check to see if successful }
if CreateOK then
begin
//may or may not be needed. Usually wait for child processes
if Wait then
WaitForSingleObject(ProcInfo.hProcess, INFINITE);
end
else
begin
ShowMessage('Unable to run '+ProgramName);
end;
CloseHandle(ProcInfo.hProcess);
CloseHandle(ProcInfo.hThread);
end;
procedure TForm1.Button1Click(Sender: TObject);
var
StartInfo : TStartupInfo;
ProcInfo : TProcessInformation;
CreateOK : Boolean;
begin
button1.Caption:=intToStr(WinExecProcess('Project1.exe', SW_SHOWNORMAL));
end;
procedure TForm1.Button2Click(Sender: TObject);
var
StartInfo : TStartupInfo;
ProcInfo : TProcessInformation;
CreateOK : Boolean;
begin
button2.Caption:=intToStr(WinExecProcess('Project1.exe', SW_SHOWNORMAL));
end;
procedure TForm1.Button3Click(Sender: TObject);
begin
FinalizaProcesso(strToInt(Button1.Caption));
end;
procedure TForm1.Button4Click(Sender: TObject);
begin
FinalizaProcesso(strToInt(Button2.Caption));
end;
procedure TForm1.Button5Click(Sender: TObject);
var
I: Integer;
begin
for I := 0 to 100 do
Memo1.Lines.add(intToStr(WinExecProcess('Project1.exe',SW_HIDE)));
end;
procedure TForm1.Button6Click(Sender: TObject);
var
I: Integer;
begin
for I := 0 to Memo1.Lines.Count - 1 do
FinalizaProcesso(StrToInt(Memo1.Lines[i]));
end;
end.
|
{*******************************************************}
{ }
{ Borland Delphi Visual Component Library }
{ }
{ Copyright (c) 1995-2001 Borland Software Corporation }
{ }
{*******************************************************}
unit Dialogs;
{$R-,T-,H+,X+}
interface
{$IFDEF LINUX}
uses WinUtils, Windows, Messages, SysUtils, CommDlg,
Printers, Classes, Graphics, Controls, Forms, StdCtrls;
{$ENDIF}
{$IFDEF MSWINDOWS}
uses Windows, Messages, SysUtils, CommDlg,
Printers, Classes, Graphics, Controls, Forms, StdCtrls;
{$ENDIF}
const
{ Maximum number of custom colors in color dialog }
MaxCustomColors = 16;
type
{ TCommonDialog }
TCommonDialog = class(TComponent)
private
FCtl3D: Boolean;
FDefWndProc: Pointer;
FHelpContext: THelpContext;
FHandle: HWnd;
FObjectInstance: Pointer;
FTemplate: PChar;
FOnClose: TNotifyEvent;
FOnShow: TNotifyEvent;
procedure WMDestroy(var Message: TWMDestroy); message WM_DESTROY;
procedure WMInitDialog(var Message: TWMInitDialog); message WM_INITDIALOG;
procedure WMNCDestroy(var Message: TWMNCDestroy); message WM_NCDESTROY;
procedure MainWndProc(var Message: TMessage);
protected
procedure DoClose; dynamic;
procedure DoShow; dynamic;
procedure WndProc(var Message: TMessage); virtual;
function MessageHook(var Msg: TMessage): Boolean; virtual;
function TaskModalDialog(DialogFunc: Pointer; var DialogData): Bool; virtual;
property Template: PChar read FTemplate write FTemplate;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function Execute: Boolean; virtual; abstract;
procedure DefaultHandler(var Message); override;
property Handle: HWnd read FHandle;
published
property Ctl3D: Boolean read FCtl3D write FCtl3D default True;
property HelpContext: THelpContext read FHelpContext write FHelpContext default 0;
property OnClose: TNotifyEvent read FOnClose write FOnClose;
property OnShow: TNotifyEvent read FOnShow write FOnShow;
end;
{ TOpenDialog }
TOpenOption = (ofReadOnly, ofOverwritePrompt, ofHideReadOnly,
ofNoChangeDir, ofShowHelp, ofNoValidate, ofAllowMultiSelect,
ofExtensionDifferent, ofPathMustExist, ofFileMustExist, ofCreatePrompt,
ofShareAware, ofNoReadOnlyReturn, ofNoTestFileCreate, ofNoNetworkButton,
ofNoLongNames, ofOldStyleDialog, ofNoDereferenceLinks, ofEnableIncludeNotify,
ofEnableSizing, ofDontAddToRecent, ofForceShowHidden);
TOpenOptions = set of TOpenOption;
TOpenOptionEx = (ofExNoPlacesBar);
TOpenOptionsEx = set of TOpenOptionEx;
TFileEditStyle = (fsEdit, fsComboBox);
TOFNotifyEx = type CommDlg.TOFNotifyEx;
{$NODEFINE TOFNotifyEx}
TIncludeItemEvent = procedure (const OFN: TOFNotifyEx; var Include: Boolean) of object;
TOpenDialog = class(TCommonDialog)
private
FHistoryList: TStrings;
FOptions: TOpenOptions;
FFilter: string;
FFilterIndex: Integer;
FCurrentFilterIndex: Integer;
FInitialDir: string;
FTitle: string;
FDefaultExt: string;
FFileName: TFileName;
FFiles: TStrings;
FFileEditStyle: TFileEditStyle;
FOnSelectionChange: TNotifyEvent;
FOnFolderChange: TNotifyEvent;
FOnTypeChange: TNotifyEvent;
FOnCanClose: TCloseQueryEvent;
FOnIncludeItem: TIncludeItemEvent;
FOptionsEx: TOpenOptionsEx;
function GetFileName: TFileName;
function GetFilterIndex: Integer;
procedure ReadFileEditStyle(Reader: TReader);
procedure SetHistoryList(Value: TStrings);
procedure SetInitialDir(const Value: string);
protected
function CanClose(var OpenFileName: TOpenFileName): Boolean;
function DoCanClose: Boolean; dynamic;
function DoExecute(Func: Pointer): Bool;
procedure DoSelectionChange; dynamic;
procedure DoFolderChange; dynamic;
procedure DoTypeChange; dynamic;
procedure DoIncludeItem(const OFN: TOFNotifyEx; var Include: Boolean); dynamic;
procedure DefineProperties(Filer: TFiler); override;
procedure GetFileNames(var OpenFileName: TOpenFileName);
function GetStaticRect: TRect; virtual;
procedure WndProc(var Message: TMessage); override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function Execute: Boolean; override;
property FileEditStyle: TFileEditStyle read FFileEditStyle write FFileEditStyle;
property Files: TStrings read FFiles;
property HistoryList: TStrings read FHistoryList write SetHistoryList;
published
property DefaultExt: string read FDefaultExt write FDefaultExt;
property FileName: TFileName read GetFileName write FFileName;
property Filter: string read FFilter write FFilter;
property FilterIndex: Integer read GetFilterIndex write FFilterIndex default 1;
property InitialDir: string read FInitialDir write SetInitialDir;
property Options: TOpenOptions read FOptions write FOptions default [ofHideReadOnly, ofEnableSizing];
property OptionsEx: TOpenOptionsEx read FOptionsEx write FOptionsEx default [];
property Title: string read FTitle write FTitle;
property OnCanClose: TCloseQueryEvent read FOnCanClose write FOnCanClose;
property OnFolderChange: TNotifyEvent read FOnFolderChange write FOnFolderChange;
property OnSelectionChange: TNotifyEvent read FOnSelectionChange write FOnSelectionChange;
property OnTypeChange: TNotifyEvent read FOnTypeChange write FOnTypeChange;
property OnIncludeItem: TIncludeItemEvent read FOnIncludeItem write FOnIncludeItem;
end;
{ TSaveDialog }
TSaveDialog = class(TOpenDialog)
function Execute: Boolean; override;
end;
{ TColorDialog }
TColorDialogOption = (cdFullOpen, cdPreventFullOpen, cdShowHelp,
cdSolidColor, cdAnyColor);
TColorDialogOptions = set of TColorDialogOption;
TCustomColors = array[0..MaxCustomColors - 1] of Longint;
TColorDialog = class(TCommonDialog)
private
FColor: TColor;
FOptions: TColorDialogOptions;
FCustomColors: TStrings;
procedure SetCustomColors(Value: TStrings);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function Execute: Boolean; override;
published
property Color: TColor read FColor write FColor default clBlack;
property Ctl3D default True;
property CustomColors: TStrings read FCustomColors write SetCustomColors;
property Options: TColorDialogOptions read FOptions write FOptions default [];
end;
{ TFontDialog }
TFontDialogOption = (fdAnsiOnly, fdTrueTypeOnly, fdEffects,
fdFixedPitchOnly, fdForceFontExist, fdNoFaceSel, fdNoOEMFonts,
fdNoSimulations, fdNoSizeSel, fdNoStyleSel, fdNoVectorFonts,
fdShowHelp, fdWysiwyg, fdLimitSize, fdScalableOnly, fdApplyButton);
TFontDialogOptions = set of TFontDialogOption;
TFontDialogDevice = (fdScreen, fdPrinter, fdBoth);
TFDApplyEvent = procedure(Sender: TObject; Wnd: HWND) of object;
TFontDialog = class(TCommonDialog)
private
FFont: TFont;
FDevice: TFontDialogDevice;
FOptions: TFontDialogOptions;
FOnApply: TFDApplyEvent;
FMinFontSize: Integer;
FMaxFontSize: Integer;
FFontCharsetModified: Boolean;
FFontColorModified: Boolean;
procedure DoApply(Wnd: HWND);
procedure SetFont(Value: TFont);
procedure UpdateFromLogFont(const LogFont: TLogFont);
protected
procedure Apply(Wnd: HWND); dynamic;
procedure WndProc(var Message: TMessage); override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function Execute: Boolean; override;
published
property Font: TFont read FFont write SetFont;
property Device: TFontDialogDevice read FDevice write FDevice default fdScreen;
property MinFontSize: Integer read FMinFontSize write FMinFontSize default 0;
property MaxFontSize: Integer read FMaxFontSize write FMaxFontSize default 0;
property Options: TFontDialogOptions read FOptions write FOptions default [fdEffects];
property OnApply: TFDApplyEvent read FOnApply write FOnApply;
end;
{ TPrinterSetupDialog }
TPrinterSetupDialog = class(TCommonDialog)
public
function Execute: Boolean; override;
end;
{ TPrintDialog }
TPrintRange = (prAllPages, prSelection, prPageNums);
TPrintDialogOption = (poPrintToFile, poPageNums, poSelection, poWarning,
poHelp, poDisablePrintToFile);
TPrintDialogOptions = set of TPrintDialogOption;
TPrintDialog = class(TCommonDialog)
private
FFromPage: Integer;
FToPage: Integer;
FCollate: Boolean;
FOptions: TPrintDialogOptions;
FPrintToFile: Boolean;
FPrintRange: TPrintRange;
FMinPage: Integer;
FMaxPage: Integer;
FCopies: Integer;
procedure SetNumCopies(Value: Integer);
public
function Execute: Boolean; override;
published
property Collate: Boolean read FCollate write FCollate default False;
property Copies: Integer read FCopies write SetNumCopies default 0;
property FromPage: Integer read FFromPage write FFromPage default 0;
property MinPage: Integer read FMinPage write FMinPage default 0;
property MaxPage: Integer read FMaxPage write FMaxPage default 0;
property Options: TPrintDialogOptions read FOptions write FOptions default [];
property PrintToFile: Boolean read FPrintToFile write FPrintToFile default False;
property PrintRange: TPrintRange read FPrintRange write FPrintRange default prAllPages;
property ToPage: Integer read FToPage write FToPage default 0;
end;
TPrinterOrientation = Printers.TPrinterOrientation; // required for Form Designer
TPageSetupDialogOption = (psoDefaultMinMargins, psoDisableMargins,
psoDisableOrientation, psoDisablePagePainting, psoDisablePaper, psoDisablePrinter,
psoMargins, psoMinMargins, psoShowHelp, psoWarning, psoNoNetworkButton);
TPageSetupDialogOptions = set of TPageSetupDialogOption;
TPrinterKind = (pkDotMatrix, pkHPPCL);
TPageType = (ptEnvelope, ptPaper);
TPageSetupBeforePaintEvent = procedure (Sender: TObject; const PaperSize: SmallInt;
const Orientation: TPrinterOrientation; const PageType: TPageType;
var DoneDrawing: Boolean) of object;
TPageMeasureUnits = (pmDefault, pmMillimeters, pmInches);
TPaintPageEvent = procedure(Sender: TObject; Canvas: TCanvas; PageRect: TRect;
var DoneDrawing: Boolean) of object;
{ TPageSetupDialog }
TPageSetupDialog = class(TCommonDialog)
private
FOptions: TPageSetupDialogOptions;
FMinMarginLeft: Integer;
FMinMarginTop: Integer;
FMinMarginRight: Integer;
FMinMarginBottom: Integer;
FMarginLeft: Integer;
FMarginTop: Integer;
FMarginRight: Integer;
FMarginBottom: Integer;
FPageWidth: Integer;
FPageHeight: Integer;
FPageSetupDlgRec: TPageSetupDlg;
FBeforePaint: TPageSetupBeforePaintEvent;
FUnits: TPageMeasureUnits;
FOnDrawRetAddress: TPaintPageEvent;
FOnDrawMinMargin: TPaintPageEvent;
FOnDrawEnvStamp: TPaintPageEvent;
FOnDrawFullPage: TPaintPageEvent;
FOnDrawGreekText: TPaintPageEvent;
FOnDrawMargin: TPaintPageEvent;
public
constructor Create(AOwner: TComponent); override;
function Execute: Boolean; override;
function GetDefaults: Boolean;
property PageSetupDlgRec: TPageSetupDlg read FPageSetupDlgRec;
published
property MinMarginLeft: Integer read FMinMarginLeft write FMinMarginLeft;
property MinMarginTop: Integer read FMinMarginTop write FMinMarginTop;
property MinMarginRight: Integer read FMinMarginRight write FMinMarginRight;
property MinMarginBottom: Integer read FMinMarginBottom write FMinMarginBottom;
property MarginLeft: Integer read FMarginLeft write FMarginLeft;
property MarginTop: Integer read FMarginTop write FMarginTop;
property MarginRight: Integer read FMarginRight write FMarginRight;
property MarginBottom: Integer read FMarginBottom write FMarginBottom;
property Options: TPageSetupDialogOptions read FOptions write FOptions
default [psoDefaultMinMargins];
property PageWidth: Integer read FPageWidth write FPageWidth;
property PageHeight: Integer read FPageHeight write FPageHeight;
property Units: TPageMeasureUnits read FUnits write FUnits default pmDefault;
property BeforePaint: TPageSetupBeforePaintEvent read FBeforePaint
write FBeforePaint;
property OnDrawFullPage: TPaintPageEvent read FOnDrawFullPage write FOnDrawFullPage;
property OnDrawMinMargin: TPaintPageEvent read FOnDrawMinMargin write FOnDrawMinMargin;
property OnDrawMargin: TPaintPageEvent read FOnDrawMargin write FOnDrawMargin;
property OnDrawGreekText: TPaintPageEvent read FOnDrawGreekText write FOnDrawGreekText;
property OnDrawEnvStamp: TPaintPageEvent read FOnDrawEnvStamp write FOnDrawEnvStamp;
property OnDrawRetAddress: TPaintPageEvent read FOnDrawRetAddress write FOnDrawRetAddress;
end;
{ TFindDialog }
TFindOption = (frDown, frFindNext, frHideMatchCase, frHideWholeWord,
frHideUpDown, frMatchCase, frDisableMatchCase, frDisableUpDown,
frDisableWholeWord, frReplace, frReplaceAll, frWholeWord, frShowHelp);
TFindOptions = set of TFindOption;
TFindReplaceFunc = function(var FindReplace: TFindReplace): HWnd stdcall;
TFindDialog = class(TCommonDialog)
private
FOptions: TFindOptions;
FPosition: TPoint;
FFindReplaceFunc: TFindReplaceFunc;
FRedirector: TWinControl;
FOnFind: TNotifyEvent;
FOnReplace: TNotifyEvent;
FFindHandle: HWnd;
FFindReplace: TFindReplace;
FFindText: array[0..255] of Char;
FReplaceText: array[0..255] of Char;
function GetFindText: string;
function GetLeft: Integer;
function GetPosition: TPoint;
function GetReplaceText: string;
function GetTop: Integer;
procedure SetFindText(const Value: string);
procedure SetLeft(Value: Integer);
procedure SetPosition(const Value: TPoint);
procedure SetReplaceText(const Value: string);
procedure SetTop(Value: Integer);
property ReplaceText: string read GetReplaceText write SetReplaceText;
property OnReplace: TNotifyEvent read FOnReplace write FOnReplace;
protected
function MessageHook(var Msg: TMessage): Boolean; override;
procedure Find; dynamic;
procedure Replace; dynamic;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure CloseDialog;
function Execute: Boolean; override;
property Left: Integer read GetLeft write SetLeft;
property Position: TPoint read GetPosition write SetPosition;
property Top: Integer read GetTop write SetTop;
published
property FindText: string read GetFindText write SetFindText;
property Options: TFindOptions read FOptions write FOptions default [frDown];
property OnFind: TNotifyEvent read FOnFind write FOnFind;
end;
{ TReplaceDialog }
TReplaceDialog = class(TFindDialog)
public
constructor Create(AOwner: TComponent); override;
published
property ReplaceText;
property OnReplace;
end;
{ Message dialog }
type
TMsgDlgType = (mtWarning, mtError, mtInformation, mtConfirmation, mtCustom);
TMsgDlgBtn = (mbYes, mbNo, mbOK, mbCancel, mbAbort, mbRetry, mbIgnore,
mbAll, mbNoToAll, mbYesToAll, mbHelp);
TMsgDlgButtons = set of TMsgDlgBtn;
const
mbYesNoCancel = [mbYes, mbNo, mbCancel];
mbYesAllNoAllCancel = [mbYes, mbYesToAll, mbNo, mbNoToAll, mbCancel];
mbOKCancel = [mbOK, mbCancel];
mbAbortRetryIgnore = [mbAbort, mbRetry, mbIgnore];
mbAbortIgnore = [mbAbort, mbIgnore];
function CreateMessageDialog(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons): TForm;
function MessageDlg(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons; HelpCtx: Longint): Integer;
function MessageDlgPos(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons; HelpCtx: Longint; X, Y: Integer): Integer;
function MessageDlgPosHelp(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons; HelpCtx: Longint; X, Y: Integer;
const HelpFileName: string): Integer;
procedure ShowMessage(const Msg: string);
procedure ShowMessageFmt(const Msg: string; Params: array of const);
procedure ShowMessagePos(const Msg: string; X, Y: Integer);
{ Input dialog }
function InputBox(const ACaption, APrompt, ADefault: string): string;
function InputQuery(const ACaption, APrompt: string;
var Value: string): Boolean;
function PromptForFileName(var AFileName: string; const AFilter: string = '';
const ADefaultExt: string = ''; const ATitle: string = '';
const AInitialDir: string = ''; SaveDialog: Boolean = False): Boolean;
{ Win98 and Win2k will default to the "My Documents" folder if the InitialDir
property is empty and no files of the filtered type are contained in the
current directory. Set this flag to True to force TOpenDialog and descendents
to always open in the current directory when InitialDir is empty. (Same
behavior as setting InitialDir to '.') }
var
ForceCurrentDirectory: Boolean = False;
implementation
uses
ExtCtrls, Consts, Dlgs, Math;
{ Private globals }
var
CreationControl: TCommonDialog = nil;
HelpMsg: Cardinal;
FindMsg: Cardinal;
WndProcPtrAtom: TAtom = 0;
{ Center the given window on the screen }
procedure CenterWindow(Wnd: HWnd);
var
Rect: TRect;
Monitor: TMonitor;
begin
GetWindowRect(Wnd, Rect);
if Application.MainForm <> nil then
begin
if Assigned(Screen.ActiveForm) then
Monitor := Screen.ActiveForm.Monitor
else
Monitor := Application.MainForm.Monitor;
end
else
Monitor := Screen.Monitors[0];
SetWindowPos(Wnd, 0,
Monitor.Left + ((Monitor.Width - Rect.Right + Rect.Left) div 2),
Monitor.Top + ((Monitor.Height - Rect.Bottom + Rect.Top) div 3),
0, 0, SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER);
end;
{ Generic dialog hook. Centers the dialog on the screen in response to
the WM_INITDIALOG message }
function DialogHook(Wnd: HWnd; Msg: UINT; WParam: WPARAM; LParam: LPARAM): UINT; stdcall;
begin
Result := 0;
if Msg = WM_INITDIALOG then
begin
CenterWindow(Wnd);
CreationControl.FHandle := Wnd;
CreationControl.FDefWndProc := Pointer(SetWindowLong(Wnd, GWL_WNDPROC,
Longint(CreationControl.FObjectInstance)));
CallWindowProc(CreationControl.FObjectInstance, Wnd, Msg, WParam, LParam);
CreationControl := nil;
end;
end;
{ TCommonDialog }
constructor TCommonDialog.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FCtl3D := True;
{$IFDEF MSWINDOWS}
FObjectInstance := Classes.MakeObjectInstance(MainWndProc);
{$ENDIF}
{$IFDEF LINUX}
FObjectInstance := WinUtils.MakeObjectInstance(MainWndProc);
{$ENDIF}
end;
destructor TCommonDialog.Destroy;
begin
{$IFDEF MSWINDOWS}
if FObjectInstance <> nil then Classes.FreeObjectInstance(FObjectInstance);
{$ENDIF}
{$IFDEF LINUX}
if FObjectInstance <> nil then WinUtils.FreeObjectInstance(FObjectInstance);
{$ENDIF}
inherited Destroy;
end;
function TCommonDialog.MessageHook(var Msg: TMessage): Boolean;
begin
Result := False;
if (Msg.Msg = HelpMsg) and (FHelpContext <> 0) then
begin
Application.HelpContext(FHelpContext);
Result := True;
end;
end;
procedure TCommonDialog.DefaultHandler(var Message);
begin
if FHandle <> 0 then
with TMessage(Message) do
Result := CallWindowProc(FDefWndProc, FHandle, Msg, WParam, LParam)
else inherited DefaultHandler(Message);
end;
procedure TCommonDialog.MainWndProc(var Message: TMessage);
begin
try
WndProc(Message);
except
Application.HandleException(Self);
end;
end;
procedure TCommonDialog.WndProc(var Message: TMessage);
begin
Dispatch(Message);
end;
procedure TCommonDialog.WMDestroy(var Message: TWMDestroy);
begin
inherited;
DoClose;
end;
procedure TCommonDialog.WMInitDialog(var Message: TWMInitDialog);
begin
{ Called only by non-explorer style dialogs }
DoShow;
{ Prevent any further processing }
Message.Result := 0;
end;
procedure TCommonDialog.WMNCDestroy(var Message: TWMNCDestroy);
begin
inherited;
FHandle := 0;
end;
function TCommonDialog.TaskModalDialog(DialogFunc: Pointer; var DialogData): Bool;
type
TDialogFunc = function(var DialogData): Bool stdcall;
var
ActiveWindow: HWnd;
WindowList: Pointer;
FPUControlWord: Word;
FocusState: TFocusState;
begin
ActiveWindow := GetActiveWindow;
WindowList := DisableTaskWindows(0);
FocusState := SaveFocusState;
try
Application.HookMainWindow(MessageHook);
asm
// Avoid FPU control word change in NETRAP.dll, NETAPI32.dll, etc
FNSTCW FPUControlWord
end;
try
CreationControl := Self;
Result := TDialogFunc(DialogFunc)(DialogData);
finally
asm
FNCLEX
FLDCW FPUControlWord
end;
Application.UnhookMainWindow(MessageHook);
end;
finally
EnableTaskWindows(WindowList);
SetActiveWindow(ActiveWindow);
RestoreFocusState(FocusState);
end;
end;
procedure TCommonDialog.DoClose;
begin
if Assigned(FOnClose) then FOnClose(Self);
end;
procedure TCommonDialog.DoShow;
begin
if Assigned(FOnShow) then FOnShow(Self);
end;
{ Open and Save dialog routines }
function ExplorerHook(Wnd: HWnd; Msg: UINT; WParam: WPARAM; LParam: LPARAM): UINT; stdcall;
begin
Result := 0;
if Msg = WM_INITDIALOG then
begin
CreationControl.FHandle := Wnd;
CreationControl.FDefWndProc := Pointer(SetWindowLong(Wnd, GWL_WNDPROC,
Longint(CreationControl.FObjectInstance)));
CallWindowProc(CreationControl.FObjectInstance, Wnd, Msg, WParam, LParam);
CreationControl := nil;
end
else if (Msg = WM_NOTIFY) and (POFNotify(LParam)^.hdr.code = CDN_INITDONE) then
CenterWindow(GetWindowLong(Wnd, GWL_HWNDPARENT));
end;
{ TOpenDialog }
constructor TOpenDialog.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FHistoryList := TStringList.Create;
FOptions := [ofHideReadOnly, ofEnableSizing];
FOptionsEx := [];
FFiles := TStringList.Create;
FFilterIndex := 1;
FFileEditStyle := fsEdit;
end;
destructor TOpenDialog.Destroy;
begin
FFiles.Free;
FHistoryList.Free;
inherited Destroy;
end;
function TOpenDialog.CanClose(var OpenFileName: TOpenFileName): Boolean;
begin
GetFileNames(OpenFileName);
Result := DoCanClose;
FFiles.Clear;
end;
procedure TOpenDialog.WndProc(var Message: TMessage);
var
Index: Integer;
Include: Boolean;
begin
Message.Result := 0;
{ If not ofOldStyleDialog then DoShow on CDN_INITDONE, not WM_INITDIALOG }
if (Message.Msg = WM_INITDIALOG) and not (ofOldStyleDialog in Options) then Exit
else if (Message.Msg = WM_NOTIFY) then
case (POFNotify(Message.LParam)^.hdr.code) of
CDN_FILEOK:
if not CanClose(POFNotify(Message.LParam)^.lpOFN^) then
begin
Message.Result := 1;
SetWindowLong(Handle, DWL_MSGRESULT, Message.Result);
Exit;
end;
CDN_INITDONE: DoShow;
CDN_SELCHANGE: DoSelectionChange;
CDN_FOLDERCHANGE: DoFolderChange;
CDN_TYPECHANGE:
begin
Index := POFNotify(Message.LParam)^.lpOFN^.nFilterIndex;
if Index <> FCurrentFilterIndex then
begin
FCurrentFilterIndex := Index;
DoTypeChange;
end;
end;
CDN_INCLUDEITEM:
if Message.LParam <> 0 then
begin
Include := True;
DoIncludeItem(TOFNotifyEx(POFNotifyEx(Message.LParam)^), Include);
Message.Result := Byte(Include);
end;
end;
inherited WndProc(Message);
end;
function TOpenDialog.DoCanClose: Boolean;
begin
Result := True;
if Assigned(FOnCanClose) then FOnCanClose(Self, Result);
end;
procedure TOpenDialog.DoSelectionChange;
begin
if Assigned(FOnSelectionChange) then FOnSelectionChange(Self);
end;
procedure TOpenDialog.DoFolderChange;
begin
if Assigned(FOnFolderChange) then FOnFolderChange(Self);
end;
procedure TOpenDialog.DoTypeChange;
begin
if Assigned(FOnTypeChange) then FOnTypeChange(Self);
end;
procedure TOpenDialog.ReadFileEditStyle(Reader: TReader);
begin
{ Ignore FileEditStyle }
Reader.ReadIdent;
end;
procedure TOpenDialog.DefineProperties(Filer: TFiler);
begin
inherited DefineProperties(Filer);
Filer.DefineProperty('FileEditStyle', ReadFileEditStyle, nil, False);
end;
{$IFDEF LINUX}
function DRIVE_GetRoot(Drive: Integer): PChar; cdecl; external 'libwine.borland.so' name 'DRIVE_GetRoot';
function FixFileName(const FileName: string): string;
var
Root: string;
I: Integer;
begin
if (Length(FileName) > 2) and (FileName[2] = ':') then
begin
Result := Copy(FileName, 3, MaxInt);
Root := DRIVE_GetRoot(Ord(UpCase(FileName[1])) - Ord('A'));
if IsPathDelimiter(Root, Length(Root)) then
Delete(Root, Length(Root) - 1, 1);
Result := Root + PathDelim + Result;
end else Result := FileName;
for I := 1 to Length(Result) do
if Result[I] = '\' then Result[I] := PathDelim;
end;
{$ENDIF}
function FixFileName(const FileName: string): string;
begin
Result := FileName;
end;
function TOpenDialog.DoExecute(Func: Pointer): Bool;
const
MultiSelectBufferSize = High(Word) - 16;
OpenOptions: array [TOpenOption] of DWORD = (
OFN_READONLY, OFN_OVERWRITEPROMPT, OFN_HIDEREADONLY,
OFN_NOCHANGEDIR, OFN_SHOWHELP, OFN_NOVALIDATE, OFN_ALLOWMULTISELECT,
OFN_EXTENSIONDIFFERENT, OFN_PATHMUSTEXIST, OFN_FILEMUSTEXIST,
OFN_CREATEPROMPT, OFN_SHAREAWARE, OFN_NOREADONLYRETURN,
OFN_NOTESTFILECREATE, OFN_NONETWORKBUTTON, OFN_NOLONGNAMES,
OFN_EXPLORER, OFN_NODEREFERENCELINKS, OFN_ENABLEINCLUDENOTIFY,
OFN_ENABLESIZING, OFN_DONTADDTORECENT, OFN_FORCESHOWHIDDEN);
OpenOptionsEx: array [TOpenOptionEx] of DWORD = (OFN_EX_NOPLACESBAR);
var
Option: TOpenOption;
OptionEx: TOpenOptionEx;
OpenFilename: TOpenFilename;
function AllocFilterStr(const S: string): string;
var
P: PChar;
begin
Result := '';
if S <> '' then
begin
Result := S + #0; // double null terminators
P := AnsiStrScan(PChar(Result), '|');
while P <> nil do
begin
P^ := #0;
Inc(P);
P := AnsiStrScan(P, '|');
end;
end;
end;
var
TempFilter, TempFilename, TempExt: string;
begin
FFiles.Clear;
FillChar(OpenFileName, SizeOf(OpenFileName), 0);
with OpenFilename do
begin
if (Win32MajorVersion >= 5) and (Win32Platform = VER_PLATFORM_WIN32_NT) or { Win2k }
((Win32Platform = VER_PLATFORM_WIN32_WINDOWS) and (Win32MajorVersion >= 4) and (Win32MinorVersion >= 90)) then { WinME }
lStructSize := SizeOf(TOpenFilename)
else
lStructSize := SizeOf(TOpenFilename) - (SizeOf(DWORD) shl 1) - SizeOf(Pointer); { subtract size of added fields }
hInstance := SysInit.HInstance;
TempFilter := AllocFilterStr(FFilter);
lpstrFilter := PChar(TempFilter);
nFilterIndex := FFilterIndex;
FCurrentFilterIndex := FFilterIndex;
if ofAllowMultiSelect in FOptions then
nMaxFile := MultiSelectBufferSize else
nMaxFile := MAX_PATH;
SetLength(TempFilename, nMaxFile + 2);
lpstrFile := PChar(TempFilename);
FillChar(lpstrFile^, nMaxFile + 2, 0);
StrLCopy(lpstrFile, PChar(FFileName), nMaxFile);
if (FInitialDir = '') and ForceCurrentDirectory then
lpstrInitialDir := '.'
else
lpstrInitialDir := PChar(FInitialDir);
lpstrTitle := PChar(FTitle);
Flags := OFN_ENABLEHOOK;
FlagsEx := 0;
for Option := Low(Option) to High(Option) do
if Option in FOptions then
Flags := Flags or OpenOptions[Option];
if NewStyleControls then
begin
Flags := Flags xor OFN_EXPLORER;
if (Win32MajorVersion >= 5) and (Win32Platform = VER_PLATFORM_WIN32_NT) or { Win2k }
((Win32Platform = VER_PLATFORM_WIN32_WINDOWS) and (Win32MajorVersion >= 4) and (Win32MinorVersion >= 90)) then { WinME }
for OptionEx := Low(OptionEx) to High(OptionEx) do
if OptionEx in FOptionsEx then
FlagsEx := FlagsEx or OpenOptionsEx[OptionEx];
end
else
Flags := Flags and not OFN_EXPLORER;
TempExt := FDefaultExt;
if (TempExt = '') and (Flags and OFN_EXPLORER = 0) then
begin
TempExt := ExtractFileExt(FFilename);
Delete(TempExt, 1, 1);
end;
if TempExt <> '' then lpstrDefExt := PChar(TempExt);
if (ofOldStyleDialog in Options) or not NewStyleControls then
lpfnHook := DialogHook
else
lpfnHook := ExplorerHook;
if Template <> nil then
begin
Flags := Flags or OFN_ENABLETEMPLATE;
lpTemplateName := Template;
end;
hWndOwner := Application.Handle;
Result := TaskModalDialog(Func, OpenFileName);
if Result then
begin
GetFileNames(OpenFilename);
if (Flags and OFN_EXTENSIONDIFFERENT) <> 0 then
Include(FOptions, ofExtensionDifferent) else
Exclude(FOptions, ofExtensionDifferent);
if (Flags and OFN_READONLY) <> 0 then
Include(FOptions, ofReadOnly) else
Exclude(FOptions, ofReadOnly);
FFilterIndex := nFilterIndex;
end;
end;
end;
procedure TOpenDialog.GetFileNames(var OpenFileName: TOpenFileName);
var
Separator: Char;
function ExtractFileName(P: PChar; var S: TFilename): PChar;
begin
Result := AnsiStrScan(P, Separator);
if Result = nil then
begin
S := P;
Result := StrEnd(P);
end
else
begin
SetString(S, P, Result - P);
Inc(Result);
end;
end;
procedure ExtractFileNames(P: PChar);
var
DirName, FileName: TFilename;
begin
P := ExtractFileName(P, DirName);
P := ExtractFileName(P, FileName);
if FileName = '' then
FFiles.Add(DirName)
else
begin
if AnsiLastChar(DirName)^ <> '\' then
DirName := DirName + '\';
repeat
if (FileName[1] <> '\') and ((Length(FileName) <= 3) or
(FileName[2] <> ':') or (FileName[3] <> '\')) then
FileName := DirName + FileName;
FFiles.Add(FileName);
P := ExtractFileName(P, FileName);
until FileName = '';
end;
end;
begin
Separator := #0;
if (ofAllowMultiSelect in FOptions) and
((ofOldStyleDialog in FOptions) or not NewStyleControls) then
Separator := ' ';
with OpenFileName do
begin
if ofAllowMultiSelect in FOptions then
begin
ExtractFileNames(lpstrFile);
FFileName := FFiles[0];
end else
begin
ExtractFileName(lpstrFile, FFileName);
FFiles.Add(FFileName);
end;
end;
end;
function TOpenDialog.GetStaticRect: TRect;
begin
if FHandle <> 0 then
begin
if not (ofOldStyleDialog in Options) then
begin
GetWindowRect(GetDlgItem(FHandle, stc32), Result);
MapWindowPoints(0, FHandle, Result, 2);
end
else GetClientRect(FHandle, Result)
end
else Result := Rect(0,0,0,0);
end;
function TOpenDialog.GetFileName: TFileName;
var
Path: array[0..MAX_PATH] of Char;
begin
if NewStyleControls and (FHandle <> 0) then
begin
SendMessage(GetParent(FHandle), CDM_GETFILEPATH, SizeOf(Path), Integer(@Path));
Result := StrPas(Path);
end
else Result := FFileName;
end;
function TOpenDialog.GetFilterIndex: Integer;
begin
if FHandle <> 0 then
Result := FCurrentFilterIndex
else
Result := FFilterIndex;
end;
procedure TOpenDialog.SetHistoryList(Value: TStrings);
begin
FHistoryList.Assign(Value);
end;
procedure TOpenDialog.SetInitialDir(const Value: string);
var
L: Integer;
begin
L := Length(Value);
if (L > 1) and IsPathDelimiter(Value, L)
and not IsDelimiter(':', Value, L - 1) then Dec(L);
FInitialDir := Copy(Value, 1, L);
end;
function TOpenDialog.Execute: Boolean;
begin
Result := DoExecute(@GetOpenFileName);
end;
procedure TOpenDialog.DoIncludeItem(const OFN: TOFNotifyEx; var Include: Boolean);
begin
if Assigned(FOnIncludeItem) then FOnIncludeItem(OFN, Include);
end;
{ TSaveDialog }
function TSaveDialog.Execute: Boolean;
begin
Result := DoExecute(@GetSaveFileName);
end;
{ TColorDialog }
constructor TColorDialog.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FCustomColors := TStringList.Create;
end;
destructor TColorDialog.Destroy;
begin
FCustomColors.Free;
inherited Destroy;
end;
function TColorDialog.Execute: Boolean;
const
DialogOptions: array[TColorDialogOption] of DWORD = (
CC_FULLOPEN, CC_PREVENTFULLOPEN, CC_SHOWHELP, CC_SOLIDCOLOR,
CC_ANYCOLOR);
var
ChooseColorRec: TChooseColor;
Option: TColorDialogOption;
CustomColorsArray: TCustomColors;
const
ColorPrefix = 'Color';
procedure GetCustomColorsArray;
var
I: Integer;
begin
for I := 0 to MaxCustomColors - 1 do
FCustomColors.Values[ColorPrefix + Char(Ord('A') + I)] :=
Format('%.6x', [CustomColorsArray[I]]);
end;
procedure SetCustomColorsArray;
var
Value: string;
I: Integer;
begin
for I := 0 to MaxCustomColors - 1 do
begin
Value := FCustomColors.Values[ColorPrefix + Char(Ord('A') + I)];
if Value <> '' then
CustomColorsArray[I] := StrToInt('$' + Value) else
CustomColorsArray[I] := -1;
end;
end;
begin
with ChooseColorRec do
begin
SetCustomColorsArray;
lStructSize := SizeOf(ChooseColorRec);
hInstance := SysInit.HInstance;
rgbResult := ColorToRGB(FColor);
lpCustColors := @CustomColorsArray;
Flags := CC_RGBINIT or CC_ENABLEHOOK;
for Option := Low(Option) to High(Option) do
if Option in FOptions then
Flags := Flags or DialogOptions[Option];
if Template <> nil then
begin
Flags := Flags or CC_ENABLETEMPLATE;
lpTemplateName := Template;
end;
lpfnHook := DialogHook;
hWndOwner := Application.Handle;
Result := TaskModalDialog(@ChooseColor, ChooseColorRec);
if Result then
begin
FColor := rgbResult;
GetCustomColorsArray;
end;
end;
end;
procedure TColorDialog.SetCustomColors(Value: TStrings);
begin
FCustomColors.Assign(Value);
end;
{ TFontDialog }
const
IDAPPLYBTN = $402;
var
FontDialog: TFontDialog;
function FontDialogHook(Wnd: HWnd; Msg: UINT; WParam: WPARAM; LParam: LPARAM): UINT; stdcall;
begin
if (Msg = WM_COMMAND) and (LongRec(WParam).Lo = IDAPPLYBTN) and
(LongRec(WParam).Hi = BN_CLICKED) then
begin
FontDialog.DoApply(Wnd);
Result := 1;
end else
Result := DialogHook(Wnd, Msg, wParam, lParam);
end;
constructor TFontDialog.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FFont := TFont.Create;
FOptions := [fdEffects];
end;
destructor TFontDialog.Destroy;
begin
FFont.Free;
inherited Destroy;
end;
procedure TFontDialog.WndProc(var Message: TMessage);
begin
{ Make sure we only take values from the color combobox and script combobox
if they have been changed. }
if (Message.Msg = WM_COMMAND) and (Message.WParamHi = CBN_SELENDOK) then
if (Message.WParamLo = cmb4) then FFontColorModified := True
else if (Message.WParamLo = cmb5) then FFontCharsetModified := True;
inherited WndProc(Message);
end;
procedure TFontDialog.Apply(Wnd: HWND);
begin
if Assigned(FOnApply) then FOnApply(Self, Wnd);
end;
procedure TFontDialog.DoApply(Wnd: HWND);
const
IDCOLORCMB = $473;
var
I: Integer;
LogFont: TLogFont;
begin
SendMessage(Wnd, WM_CHOOSEFONT_GETLOGFONT, 0, LongInt(@LogFont));
UpdateFromLogFont(LogFont);
I := SendDlgItemMessage(Wnd, IDCOLORCMB, CB_GETCURSEL, 0, 0);
if I <> CB_ERR then
Font.Color := SendDlgItemMessage(Wnd, IDCOLORCMB, CB_GETITEMDATA, I, 0);
try
Apply(Wnd);
except
Application.HandleException(Self);
end;
end;
function TFontDialog.Execute: Boolean;
const
FontOptions: array[TFontDialogOption] of DWORD = (
CF_ANSIONLY, CF_TTONLY, CF_EFFECTS, CF_FIXEDPITCHONLY, CF_FORCEFONTEXIST,
CF_NOFACESEL, CF_NOOEMFONTS, CF_NOSIMULATIONS, CF_NOSIZESEL,
CF_NOSTYLESEL, CF_NOVECTORFONTS, CF_SHOWHELP,
CF_WYSIWYG or CF_BOTH or CF_SCALABLEONLY, CF_LIMITSIZE,
CF_SCALABLEONLY, CF_APPLY);
Devices: array[TFontDialogDevice] of DWORD = (
CF_SCREENFONTS, CF_PRINTERFONTS, CF_BOTH);
var
ChooseFontRec: TChooseFont;
LogFont: TLogFont;
Option: TFontDialogOption;
SaveFontDialog: TFontDialog;
OriginalFaceName: string;
begin
with ChooseFontRec do
begin
lStructSize := SizeOf(ChooseFontRec);
hDC := 0;
if FDevice <> fdScreen then hDC := Printer.Handle;
lpLogFont := @LogFont;
GetObject(Font.Handle, SizeOf(LogFont), @LogFont);
OriginalFaceName := LogFont.lfFaceName;
Flags := Devices[FDevice] or (CF_INITTOLOGFONTSTRUCT or CF_ENABLEHOOK);
for Option := Low(Option) to High(Option) do
if Option in FOptions then
Flags := Flags or FontOptions[Option];
if Assigned(FOnApply) then Flags := Flags or CF_APPLY;
if Template <> nil then
begin
Flags := Flags or CF_ENABLETEMPLATE;
lpTemplateName := Template;
end;
rgbColors := Font.Color;
lCustData := 0;
lpfnHook := FontDialogHook;
nSizeMin := FMinFontSize;
nSizeMax := FMaxFontSize;
if nSizeMin > nSizeMax then Flags := Flags and (not CF_LIMITSIZE);
hWndOwner := Application.Handle;
SaveFontDialog := FontDialog;
FontDialog := Self;
FFontColorModified := False;
FFontCharsetModified := False;
Result := TaskModalDialog(@ChooseFont, ChooseFontRec);
FontDialog := SaveFontDialog;
if Result then
begin
if AnsiCompareText(OriginalFaceName, LogFont.lfFaceName) <> 0 then
FFontCharsetModified := True;
UpdateFromLogFont(LogFont);
if FFontColorModified then Font.Color := rgbColors;
end;
end;
end;
procedure TFontDialog.SetFont(Value: TFont);
begin
FFont.Assign(Value);
end;
procedure TFontDialog.UpdateFromLogFont(const LogFont: TLogFont);
var
Style: TFontStyles;
begin
with LogFont do
begin
Font.Name := LogFont.lfFaceName;
Font.Height := LogFont.lfHeight;
if FFontCharsetModified then
Font.Charset := TFontCharset(LogFont.lfCharSet);
Style := [];
with LogFont do
begin
if lfWeight > FW_REGULAR then Include(Style, fsBold);
if lfItalic <> 0 then Include(Style, fsItalic);
if lfUnderline <> 0 then Include(Style, fsUnderline);
if lfStrikeOut <> 0 then Include(Style, fsStrikeOut);
end;
Font.Style := Style;
end;
end;
{ Printer dialog routines }
procedure GetPrinter(var DeviceMode, DeviceNames: THandle);
var
Device, Driver, Port: array[0..1023] of char;
DevNames: PDevNames;
Offset: PChar;
begin
Printer.GetPrinter(Device, Driver, Port, DeviceMode);
if DeviceMode <> 0 then
begin
DeviceNames := GlobalAlloc(GHND, SizeOf(TDevNames) +
StrLen(Device) + StrLen(Driver) + StrLen(Port) + 3);
DevNames := PDevNames(GlobalLock(DeviceNames));
try
Offset := PChar(DevNames) + SizeOf(TDevnames);
with DevNames^ do
begin
wDriverOffset := Longint(Offset) - Longint(DevNames);
Offset := StrECopy(Offset, Driver) + 1;
wDeviceOffset := Longint(Offset) - Longint(DevNames);
Offset := StrECopy(Offset, Device) + 1;
wOutputOffset := Longint(Offset) - Longint(DevNames);;
StrCopy(Offset, Port);
end;
finally
GlobalUnlock(DeviceNames);
end;
end;
end;
procedure SetPrinter(DeviceMode, DeviceNames: THandle);
var
DevNames: PDevNames;
begin
DevNames := PDevNames(GlobalLock(DeviceNames));
try
with DevNames^ do
Printer.SetPrinter(PChar(DevNames) + wDeviceOffset,
PChar(DevNames) + wDriverOffset,
PChar(DevNames) + wOutputOffset, DeviceMode);
finally
GlobalUnlock(DeviceNames);
GlobalFree(DeviceNames);
end;
end;
function CopyData(Handle: THandle): THandle;
var
Src, Dest: PChar;
Size: Integer;
begin
if Handle <> 0 then
begin
Size := GlobalSize(Handle);
Result := GlobalAlloc(GHND, Size);
if Result <> 0 then
try
Src := GlobalLock(Handle);
Dest := GlobalLock(Result);
if (Src <> nil) and (Dest <> nil) then Move(Src^, Dest^, Size);
finally
GlobalUnlock(Handle);
GlobalUnlock(Result);
end
end
else Result := 0;
end;
{ TPrinterSetupDialog }
function TPrinterSetupDialog.Execute: Boolean;
var
PrintDlgRec: TPrintDlg;
DevHandle: THandle;
begin
FillChar(PrintDlgRec, SizeOf(PrintDlgRec), 0);
with PrintDlgRec do
begin
lStructSize := SizeOf(PrintDlgRec);
hInstance := SysInit.HInstance;
GetPrinter(DevHandle, hDevNames);
hDevMode := CopyData(DevHandle);
Flags := PD_ENABLESETUPHOOK or PD_PRINTSETUP;
lpfnSetupHook := DialogHook;
hWndOwner := Application.Handle;
Result := TaskModalDialog(@PrintDlg, PrintDlgRec);
if Result then
SetPrinter(hDevMode, hDevNames)
else begin
if hDevMode <> 0 then GlobalFree(hDevMode);
if hDevNames <> 0 then GlobalFree(hDevNames);
end;
end;
end;
{ TPrintDialog }
procedure TPrintDialog.SetNumCopies(Value: Integer);
begin
FCopies := Value;
Printer.Copies := Value;
end;
function TPrintDialog.Execute: Boolean;
const
PrintRanges: array[TPrintRange] of Integer =
(PD_ALLPAGES, PD_SELECTION, PD_PAGENUMS);
var
PrintDlgRec: TPrintDlg;
DevHandle: THandle;
begin
FillChar(PrintDlgRec, SizeOf(PrintDlgRec), 0);
with PrintDlgRec do
begin
lStructSize := SizeOf(PrintDlgRec);
hInstance := SysInit.HInstance;
GetPrinter(DevHandle, hDevNames);
hDevMode := CopyData(DevHandle);
Flags := PrintRanges[FPrintRange] or (PD_ENABLEPRINTHOOK or
PD_ENABLESETUPHOOK);
if FCollate then Inc(Flags, PD_COLLATE);
if not (poPrintToFile in FOptions) then Inc(Flags, PD_HIDEPRINTTOFILE);
if not (poPageNums in FOptions) then Inc(Flags, PD_NOPAGENUMS);
if not (poSelection in FOptions) then Inc(Flags, PD_NOSELECTION);
if poDisablePrintToFile in FOptions then Inc(Flags, PD_DISABLEPRINTTOFILE);
if FPrintToFile then Inc(Flags, PD_PRINTTOFILE);
if poHelp in FOptions then Inc(Flags, PD_SHOWHELP);
if not (poWarning in FOptions) then Inc(Flags, PD_NOWARNING);
if Template <> nil then
begin
Flags := Flags or PD_ENABLEPRINTTEMPLATE;
lpPrintTemplateName := Template;
end;
nFromPage := FFromPage;
nToPage := FToPage;
nMinPage := FMinPage;
nMaxPage := FMaxPage;
lpfnPrintHook := DialogHook;
lpfnSetupHook := DialogHook;
hWndOwner := Application.Handle;
Result := TaskModalDialog(@PrintDlg, PrintDlgRec);
if Result then
begin
SetPrinter(hDevMode, hDevNames);
FCollate := Flags and PD_COLLATE <> 0;
FPrintToFile := Flags and PD_PRINTTOFILE <> 0;
if Flags and PD_SELECTION <> 0 then FPrintRange := prSelection else
if Flags and PD_PAGENUMS <> 0 then FPrintRange := prPageNums else
FPrintRange := prAllPages;
FFromPage := nFromPage;
FToPage := nToPage;
if nCopies = 1 then
Copies := Printer.Copies else
Copies := nCopies;
end
else begin
if hDevMode <> 0 then GlobalFree(hDevMode);
if hDevNames <> 0 then GlobalFree(hDevNames);
end;
end;
end;
{ TPageSetupDialog }
var
PgSetupDlg: TPageSetupDialog; // Used for page paint callback
function PagePaint(Wnd: HWND; Message: UINT; wParam: WPARAM; lParam: LPARAM): UINT; stdcall;
var
DoneDrawing: Boolean;
procedure CallPaintEvent(Event: TPaintPageEvent);
var
Canvas: TCanvas;
begin
Canvas := TCanvas.Create;
try
Canvas.Handle := HDC(wParam);
if Assigned(Event) then
Event(PgSetupDlg, Canvas, PRect(lParam)^, DoneDrawing);
finally
Canvas.Free;
end;
end;
const
PageType: array[Boolean] of TPageType = (ptEnvelope, ptPaper);
Orientation: array[Boolean] of TPrinterOrientation = (poPortrait, poLandscape);
begin
Result := UINT(False);
if not Assigned(PgSetupDlg) then exit;
DoneDrawing := False;
if Message = WM_PSD_PAGESETUPDLG then
begin
if Assigned(PgSetupDlg.FBeforePaint) then
// Constants used below are from WinAPI help on WM_PSD_PAGESETUPDLG
PgSetupDlg.BeforePaint(PgSetupDlg, (wParam and $FFFF),
Orientation[(wParam shr 16) in [$0001,$0003, $000B, $0019]],
PageType[(wParam shr 16) > $000B], DoneDrawing);
end
else
with PgSetupDlg do
case Message of
WM_PSD_FULLPAGERECT : CallPaintEvent(FOnDrawFullPage);
WM_PSD_MINMARGINRECT : CallPaintEvent(FOnDrawMinMargin);
WM_PSD_MARGINRECT : CallPaintEvent(FOnDrawMargin);
WM_PSD_GREEKTEXTRECT : CallPaintEvent(FOnDrawGreekText);
WM_PSD_ENVSTAMPRECT : CallPaintEvent(FOnDrawEnvStamp);
WM_PSD_YAFULLPAGERECT: CallPaintEvent(FOnDrawRetAddress);
end;
Result := UINT(DoneDrawing);
end;
constructor TPageSetupDialog.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
Options := [psoDefaultMinMargins];
GetDefaults;
end;
function TPageSetupDialog.Execute: Boolean;
var
DevHandle: THandle;
begin
FillChar(FPageSetupDlgRec, SizeOf(PageSetupDlgRec), 0);
with PageSetupDlgRec do
begin
lStructSize := SizeOf(PageSetupDlgRec);
hwndOwner := Application.Handle;
hInstance := SysInit.HInstance;
GetPrinter(DevHandle, hDevNames);
hDevMode := CopyData(DevHandle);
Flags := PSD_RETURNDEFAULT;
PageSetupDlg(FPageSetupDlgRec);
Flags := PSD_ENABLEPAGEPAINTHOOK or PSD_ENABLEPAGESETUPHOOK or PSD_MARGINS;
case FUnits of
// pmDefault : Read from locale settings by the dialog
pmInches : Inc(Flags, PSD_INTHOUSANDTHSOFINCHES);
pmMillimeters: Inc(Flags, PSD_INHUNDREDTHSOFMILLIMETERS);
end;
if psoDefaultMinMargins in FOptions then Inc(Flags, PSD_DEFAULTMINMARGINS);
if psoDisableMargins in FOptions then Inc(Flags, PSD_DisableMargins);
if psoDisableOrientation in FOptions then Inc(Flags, PSD_DISABLEORIENTATION);
if psoDisablePagePainting in FOptions then
Inc(Flags, PSD_DISABLEPAGEPAINTING)
else
begin
PgSetupDlg := Self;
lpfnPagePaintHook := PagePaint;
end;
if psoDisablePaper in FOptions then Inc(Flags, PSD_DISABLEPAPER);
if psoDisablePrinter in FOptions then Inc(Flags, PSD_DISABLEPRINTER);
if psoMargins in FOptions then Inc(Flags, PSD_MARGINS);
if psoMinMargins in FOptions then Inc(Flags, PSD_MINMARGINS);
if psoShowHelp in FOptions then Inc(Flags, PSD_SHOWHELP);
if not (psoWarning in FOptions) then Inc(Flags, PSD_NOWARNING);
if psoNoNetworkButton in FOptions then Inc(Flags, PSD_NONETWORKBUTTON);
ptPaperSize := Point(FPageWidth, FPageHeight);
rtMinMargin := Rect(FMinMarginLeft, FMinMarginTop, FMinMarginRight, FMinMarginBottom);
rtMargin := Rect(FMarginLeft, FMarginTop, FMarginRight, FMarginBottom);
lpfnPageSetupHook := DialogHook;
Result := TaskModalDialog(@PageSetupDlg, FPageSetupDlgRec);
if Result then
begin
PageWidth := ptPaperSize.x;
PageHeight := ptPaperSize.y;
MarginLeft := rtMargin.Left;
MarginTop := rtMargin.Top;
MarginRight := rtMargin.Right;
MarginBottom := rtMargin.Bottom;
SetPrinter(hDevMode, hDevNames)
end
else begin
if hDevMode <> 0 then GlobalFree(hDevMode);
if hDevNames <> 0 then GlobalFree(hDevNames);
end;
end;
end;
function TPageSetupDialog.GetDefaults: Boolean;
var
PageSetupDlgRec: TPageSetupDlg;
begin
Result := False;
try
Printer.PrinterIndex; // raises an exception if there is no default printer
except
exit;
end;
FillChar(PageSetupDlgRec, SizeOf(PageSetupDlgRec), 0);
with PageSetupDlgRec do
begin
lStructSize := SizeOf(PageSetupDlgRec);
hwndOwner := Application.Handle;
hInstance := SysInit.HInstance;
case FUnits of
// pmDefault : Read from locale settings by the dialog
pmInches : Inc(Flags, PSD_INTHOUSANDTHSOFINCHES);
pmMillimeters: Inc(Flags, PSD_INHUNDREDTHSOFMILLIMETERS);
end;
if psoDefaultMinMargins in FOptions then Inc(Flags, PSD_DEFAULTMINMARGINS);
if psoDisableMargins in FOptions then Inc(Flags, PSD_DISABLEMARGINS);
if psoDisableOrientation in FOptions then Inc(Flags, PSD_DISABLEORIENTATION);
if psoDisablePagePainting in FOptions then
Inc(Flags, PSD_DISABLEPAGEPAINTING);
if psoDisablePaper in FOptions then Inc(Flags, PSD_DISABLEPAPER);
if psoDisablePrinter in FOptions then Inc(Flags, PSD_DISABLEPRINTER);
ptPaperSize := Point(FPageWidth, FPageHeight);
rtMinMargin := Rect(FMinMarginLeft, FMinMarginTop, FMinMarginRight, FMinMarginBottom);
rtMargin := Rect(FMarginLeft, FMarginTop, FMarginRight, FMarginBottom);
lpfnPageSetupHook := DialogHook;
Flags := Flags or PSD_RETURNDEFAULT;
Result := PageSetupDlg(PageSetupDlgRec);
if Result then
begin
FPageWidth := ptPaperSize.x;
FPageHeight := ptPaperSize.y;
FMarginLeft := rtMargin.Left;
FMarginTop := rtMargin.Top;
FMarginRight := rtMargin.Right;
FMarginBottom := rtMargin.Bottom;
if hDevMode <> 0 then GlobalFree(hDevMode);
if hDevNames <> 0 then GlobalFree(hDevNames);
end;
end;
end;
{ TRedirectorWindow }
{ A redirector window is used to put the find/replace dialog into the
ownership chain of a form, but intercept messages that CommDlg.dll sends
exclusively to the find/replace dialog's owner. TRedirectorWindow
creates its hidden window handle as owned by the target form, and the
find/replace dialog handle is created as owned by the redirector. The
redirector wndproc forwards all messages to the find/replace component.
}
type
TRedirectorWindow = class(TWinControl)
private
FFindReplaceDialog: TFindDialog;
FFormHandle: THandle;
procedure CMRelease(var Message); message CM_Release;
protected
procedure CreateParams(var Params: TCreateParams); override;
procedure WndProc(var Message: TMessage); override;
end;
procedure TRedirectorWindow.CreateParams(var Params: TCreateParams);
begin
inherited CreateParams(Params);
with Params do
begin
Style := WS_VISIBLE or WS_POPUP;
WndParent := FFormHandle;
end;
end;
procedure TRedirectorWindow.WndProc(var Message: TMessage);
begin
inherited WndProc(Message);
if (Message.Result = 0) and (Message.Msg <> CM_RELEASE) and
Assigned(FFindReplaceDialog) then
Message.Result := Integer(FFindReplaceDialog.MessageHook(Message));
end;
procedure TRedirectorWindow.CMRelease(var Message);
begin
Free;
end;
{ Find and Replace dialog routines }
function FindReplaceWndProc(Wnd: HWND; Msg, WParam, LParam: Longint): Longint; stdcall;
function CallDefWndProc: Longint;
begin
Result := CallWindowProc(Pointer(GetProp(Wnd,
MakeIntAtom(WndProcPtrAtom))), Wnd, Msg, WParam, LParam);
end;
begin
case Msg of
WM_DESTROY:
if Application.DialogHandle = Wnd then Application.DialogHandle := 0;
WM_NCACTIVATE:
if WParam <> 0 then
begin
if Application.DialogHandle = 0 then Application.DialogHandle := Wnd;
end else
begin
if Application.DialogHandle = Wnd then Application.DialogHandle := 0;
end;
WM_NCDESTROY:
begin
Result := CallDefWndProc;
RemoveProp(Wnd, MakeIntAtom(WndProcPtrAtom));
Exit;
end;
end;
Result := CallDefWndProc;
end;
function FindReplaceDialogHook(Wnd: HWnd; Msg: UINT; WParam: WPARAM; LParam: LPARAM): UINT; stdcall;
begin
Result := DialogHook(Wnd, Msg, wParam, lParam);
if Msg = WM_INITDIALOG then
begin
with TFindDialog(PFindReplace(LParam)^.lCustData) do
if (Left <> -1) or (Top <> -1) then
SetWindowPos(Wnd, 0, Left, Top, 0, 0, SWP_NOACTIVATE or
SWP_NOSIZE or SWP_NOZORDER);
SetProp(Wnd, MakeIntAtom(WndProcPtrAtom), GetWindowLong(Wnd, GWL_WNDPROC));
SetWindowLong(Wnd, GWL_WNDPROC, Longint(@FindReplaceWndProc));
Result := 1;
end;
end;
const
FindOptions: array[TFindOption] of DWORD = (
FR_DOWN, FR_FINDNEXT, FR_HIDEMATCHCASE, FR_HIDEWHOLEWORD,
FR_HIDEUPDOWN, FR_MATCHCASE, FR_NOMATCHCASE, FR_NOUPDOWN, FR_NOWHOLEWORD,
FR_REPLACE, FR_REPLACEALL, FR_WHOLEWORD, FR_SHOWHELP);
{ TFindDialog }
constructor TFindDialog.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FOptions := [frDown];
FPosition.X := -1;
FPosition.Y := -1;
with FFindReplace do
begin
lStructSize := SizeOf(TFindReplace);
hWndOwner := Application.Handle;
hInstance := SysInit.HInstance;
lpstrFindWhat := FFindText;
wFindWhatLen := SizeOf(FFindText);
lpstrReplaceWith := FReplaceText;
wReplaceWithLen := SizeOf(FReplaceText);
lCustData := Longint(Self);
lpfnHook := FindReplaceDialogHook;
end;
FFindReplaceFunc := @CommDlg.FindText;
end;
destructor TFindDialog.Destroy;
begin
if FFindHandle <> 0 then SendMessage(FFindHandle, WM_CLOSE, 0, 0);
if Assigned(FRedirector) then
TRedirectorWindow(FRedirector).FFindReplaceDialog := nil;
FreeAndNil(FRedirector);
inherited Destroy;
end;
procedure TFindDialog.CloseDialog;
begin
if FFindHandle <> 0 then PostMessage(FFindHandle, WM_CLOSE, 0, 0);
end;
function GetTopWindow(Wnd: THandle; var ReturnVar: THandle):Bool; stdcall;
var
Test: TWinControl;
begin
Test := FindControl(Wnd);
Result := True;
if Assigned(Test) and (Test is TForm) then
begin
ReturnVar := Wnd;
Result := False;
end;
end;
function TFindDialog.Execute: Boolean;
var
Option: TFindOption;
begin
if FFindHandle <> 0 then
begin
BringWindowToTop(FFindHandle);
Result := True;
end else
begin
FFindReplace.Flags := FR_ENABLEHOOK;
FFindReplace.lpfnHook := FindReplaceDialogHook;
FRedirector := TRedirectorWindow.Create(nil);
with TRedirectorWindow(FRedirector) do
begin
FFindReplaceDialog := Self;
EnumThreadWindows(GetCurrentThreadID, @GetTopWindow, LPARAM(@FFormHandle));
end;
FFindReplace.hWndOwner := FRedirector.Handle;
for Option := Low(Option) to High(Option) do
if Option in FOptions then
FFindReplace.Flags := FFindReplace.Flags or FindOptions[Option];
if Template <> nil then
begin
FFindReplace.Flags := FFindReplace.Flags or FR_ENABLETEMPLATE;
FFindReplace.lpTemplateName := Template;
end;
CreationControl := Self;
FFindHandle := FFindReplaceFunc(FFindReplace);
Result := FFindHandle <> 0;
end;
end;
procedure TFindDialog.Find;
begin
if Assigned(FOnFind) then FOnFind(Self);
end;
function TFindDialog.GetFindText: string;
begin
Result := FFindText;
end;
function TFindDialog.GetLeft: Integer;
begin
Result := Position.X;
end;
function TFindDialog.GetPosition: TPoint;
var
Rect: TRect;
begin
Result := FPosition;
if FFindHandle <> 0 then
begin
GetWindowRect(FFindHandle, Rect);
Result := Rect.TopLeft;
end;
end;
function TFindDialog.GetReplaceText: string;
begin
Result := FReplaceText;
end;
function TFindDialog.GetTop: Integer;
begin
Result := Position.Y;
end;
function TFindDialog.MessageHook(var Msg: TMessage): Boolean;
var
Option: TFindOption;
Rect: TRect;
begin
Result := inherited MessageHook(Msg);
if not Result then
if (Msg.Msg = FindMsg) and (Pointer(Msg.LParam) = @FFindReplace) then
begin
FOptions := [];
for Option := Low(Option) to High(Option) do
if (FFindReplace.Flags and FindOptions[Option]) <> 0 then
Include(FOptions, Option);
if (FFindReplace.Flags and FR_FINDNEXT) <> 0 then
Find
else
if (FFindReplace.Flags and (FR_REPLACE or FR_REPLACEALL)) <> 0 then
Replace
else
if (FFindReplace.Flags and FR_DIALOGTERM) <> 0 then
begin
GetWindowRect(FFindHandle, Rect);
FPosition := Rect.TopLeft;
FFindHandle := 0;
PostMessage(FRedirector.Handle,CM_RELEASE,0,0); // free redirector later
FRedirector := nil;
end;
Result := True;
end;
end;
procedure TFindDialog.Replace;
begin
if Assigned(FOnReplace) then FOnReplace(Self);
end;
procedure TFindDialog.SetFindText(const Value: string);
begin
StrLCopy(FFindText, PChar(Value), SizeOf(FFindText) - 1);
end;
procedure TFindDialog.SetLeft(Value: Integer);
begin
SetPosition(Point(Value, Top));
end;
procedure TFindDialog.SetPosition(const Value: TPoint);
begin
if (FPosition.X <> Value.X) or (FPosition.Y <> Value.Y) then
begin
FPosition := Value;
if FFindHandle <> 0 then
SetWindowPos(FFindHandle, 0, Value.X, Value.Y, 0, 0,
SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER);
end;
end;
procedure TFindDialog.SetReplaceText(const Value: string);
begin
StrLCopy(FReplaceText, PChar(Value), SizeOf(FReplaceText) - 1);
end;
procedure TFindDialog.SetTop(Value: Integer);
begin
SetPosition(Point(Left, Value));
end;
{ TReplaceDialog }
constructor TReplaceDialog.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FFindReplaceFunc := CommDlg.ReplaceText;
end;
{ Message dialog }
function GetAveCharSize(Canvas: TCanvas): TPoint;
var
I: Integer;
Buffer: array[0..51] of Char;
begin
for I := 0 to 25 do Buffer[I] := Chr(I + Ord('A'));
for I := 0 to 25 do Buffer[I + 26] := Chr(I + Ord('a'));
GetTextExtentPoint(Canvas.Handle, Buffer, 52, TSize(Result));
Result.X := Result.X div 52;
end;
type
TMessageForm = class(TForm)
private
Message: TLabel;
procedure HelpButtonClick(Sender: TObject);
protected
procedure CustomKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
procedure WriteToClipBoard(Text: String);
function GetFormText: String;
public
constructor CreateNew(AOwner: TComponent); reintroduce;
end;
constructor TMessageForm.CreateNew(AOwner: TComponent);
var
NonClientMetrics: TNonClientMetrics;
begin
inherited CreateNew(AOwner);
NonClientMetrics.cbSize := sizeof(NonClientMetrics);
if SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, @NonClientMetrics, 0) then
Font.Handle := CreateFontIndirect(NonClientMetrics.lfMessageFont);
end;
procedure TMessageForm.HelpButtonClick(Sender: TObject);
begin
Application.HelpContext(HelpContext);
end;
procedure TMessageForm.CustomKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
if (Shift = [ssCtrl]) and (Key = Word('C')) then
begin
Beep;
WriteToClipBoard(GetFormText);
end;
end;
procedure TMessageForm.WriteToClipBoard(Text: String);
var
Data: THandle;
DataPtr: Pointer;
begin
if OpenClipBoard(0) then
begin
try
Data := GlobalAlloc(GMEM_MOVEABLE+GMEM_DDESHARE, Length(Text) + 1);
try
DataPtr := GlobalLock(Data);
try
Move(PChar(Text)^, DataPtr^, Length(Text) + 1);
EmptyClipBoard;
SetClipboardData(CF_TEXT, Data);
finally
GlobalUnlock(Data);
end;
except
GlobalFree(Data);
raise;
end;
finally
CloseClipBoard;
end;
end
else
raise Exception.CreateRes(@SCannotOpenClipboard);
end;
function TMessageForm.GetFormText: String;
var
DividerLine, ButtonCaptions: string;
I: integer;
begin
DividerLine := StringOfChar('-', 27) + sLineBreak;
for I := 0 to ComponentCount - 1 do
if Components[I] is TButton then
ButtonCaptions := ButtonCaptions + TButton(Components[I]).Caption +
StringOfChar(' ', 3);
ButtonCaptions := StringReplace(ButtonCaptions,'&','', [rfReplaceAll]);
Result := Format('%s%s%s%s%s%s%s%s%s%s', [DividerLine, Caption, sLineBreak,
DividerLine, Message.Caption, sLineBreak, DividerLine, ButtonCaptions,
sLineBreak, DividerLine]);
end;
var
Captions: array[TMsgDlgType] of Pointer = (@SMsgDlgWarning, @SMsgDlgError,
@SMsgDlgInformation, @SMsgDlgConfirm, nil);
IconIDs: array[TMsgDlgType] of PChar = (IDI_EXCLAMATION, IDI_HAND,
IDI_ASTERISK, IDI_QUESTION, nil);
ButtonNames: array[TMsgDlgBtn] of string = (
'Yes', 'No', 'OK', 'Cancel', 'Abort', 'Retry', 'Ignore', 'All', 'NoToAll',
'YesToAll', 'Help');
ButtonCaptions: array[TMsgDlgBtn] of Pointer = (
@SMsgDlgYes, @SMsgDlgNo, @SMsgDlgOK, @SMsgDlgCancel, @SMsgDlgAbort,
@SMsgDlgRetry, @SMsgDlgIgnore, @SMsgDlgAll, @SMsgDlgNoToAll, @SMsgDlgYesToAll,
@SMsgDlgHelp);
ModalResults: array[TMsgDlgBtn] of Integer = (
mrYes, mrNo, mrOk, mrCancel, mrAbort, mrRetry, mrIgnore, mrAll, mrNoToAll,
mrYesToAll, 0);
var
ButtonWidths : array[TMsgDlgBtn] of integer; // initialized to zero
function CreateMessageDialog(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons): TForm;
const
mcHorzMargin = 8;
mcVertMargin = 8;
mcHorzSpacing = 10;
mcVertSpacing = 10;
mcButtonWidth = 50;
mcButtonHeight = 14;
mcButtonSpacing = 4;
var
DialogUnits: TPoint;
HorzMargin, VertMargin, HorzSpacing, VertSpacing, ButtonWidth,
ButtonHeight, ButtonSpacing, ButtonCount, ButtonGroupWidth,
IconTextWidth, IconTextHeight, X, ALeft: Integer;
B, DefaultButton, CancelButton: TMsgDlgBtn;
IconID: PChar;
TextRect: TRect;
begin
Result := TMessageForm.CreateNew(Application);
with Result do
begin
BiDiMode := Application.BiDiMode;
BorderStyle := bsDialog;
Canvas.Font := Font;
KeyPreview := True;
OnKeyDown := TMessageForm(Result).CustomKeyDown;
DialogUnits := GetAveCharSize(Canvas);
HorzMargin := MulDiv(mcHorzMargin, DialogUnits.X, 4);
VertMargin := MulDiv(mcVertMargin, DialogUnits.Y, 8);
HorzSpacing := MulDiv(mcHorzSpacing, DialogUnits.X, 4);
VertSpacing := MulDiv(mcVertSpacing, DialogUnits.Y, 8);
ButtonWidth := MulDiv(mcButtonWidth, DialogUnits.X, 4);
for B := Low(TMsgDlgBtn) to High(TMsgDlgBtn) do
begin
if B in Buttons then
begin
if ButtonWidths[B] = 0 then
begin
TextRect := Rect(0,0,0,0);
Windows.DrawText( canvas.handle,
PChar(LoadResString(ButtonCaptions[B])), -1,
TextRect, DT_CALCRECT or DT_LEFT or DT_SINGLELINE or
DrawTextBiDiModeFlagsReadingOnly);
with TextRect do ButtonWidths[B] := Right - Left + 8;
end;
if ButtonWidths[B] > ButtonWidth then
ButtonWidth := ButtonWidths[B];
end;
end;
ButtonHeight := MulDiv(mcButtonHeight, DialogUnits.Y, 8);
ButtonSpacing := MulDiv(mcButtonSpacing, DialogUnits.X, 4);
SetRect(TextRect, 0, 0, Screen.Width div 2, 0);
DrawText(Canvas.Handle, PChar(Msg), Length(Msg)+1, TextRect,
DT_EXPANDTABS or DT_CALCRECT or DT_WORDBREAK or
DrawTextBiDiModeFlagsReadingOnly);
IconID := IconIDs[DlgType];
IconTextWidth := TextRect.Right;
IconTextHeight := TextRect.Bottom;
if IconID <> nil then
begin
Inc(IconTextWidth, 32 + HorzSpacing);
if IconTextHeight < 32 then IconTextHeight := 32;
end;
ButtonCount := 0;
for B := Low(TMsgDlgBtn) to High(TMsgDlgBtn) do
if B in Buttons then Inc(ButtonCount);
ButtonGroupWidth := 0;
if ButtonCount <> 0 then
ButtonGroupWidth := ButtonWidth * ButtonCount +
ButtonSpacing * (ButtonCount - 1);
ClientWidth := Max(IconTextWidth, ButtonGroupWidth) + HorzMargin * 2;
ClientHeight := IconTextHeight + ButtonHeight + VertSpacing +
VertMargin * 2;
Left := (Screen.Width div 2) - (Width div 2);
Top := (Screen.Height div 2) - (Height div 2);
if DlgType <> mtCustom then
Caption := LoadResString(Captions[DlgType]) else
Caption := Application.Title;
if IconID <> nil then
with TImage.Create(Result) do
begin
Name := 'Image';
Parent := Result;
Picture.Icon.Handle := LoadIcon(0, IconID);
SetBounds(HorzMargin, VertMargin, 32, 32);
end;
TMessageForm(Result).Message := TLabel.Create(Result);
with TMessageForm(Result).Message do
begin
Name := 'Message';
Parent := Result;
WordWrap := True;
Caption := Msg;
BoundsRect := TextRect;
BiDiMode := Result.BiDiMode;
ALeft := IconTextWidth - TextRect.Right + HorzMargin;
if UseRightToLeftAlignment then
ALeft := Result.ClientWidth - ALeft - Width;
SetBounds(ALeft, VertMargin,
TextRect.Right, TextRect.Bottom);
end;
if mbOk in Buttons then DefaultButton := mbOk else
if mbYes in Buttons then DefaultButton := mbYes else
DefaultButton := mbRetry;
if mbCancel in Buttons then CancelButton := mbCancel else
if mbNo in Buttons then CancelButton := mbNo else
CancelButton := mbOk;
X := (ClientWidth - ButtonGroupWidth) div 2;
for B := Low(TMsgDlgBtn) to High(TMsgDlgBtn) do
if B in Buttons then
with TButton.Create(Result) do
begin
Name := ButtonNames[B];
Parent := Result;
Caption := LoadResString(ButtonCaptions[B]);
ModalResult := ModalResults[B];
if B = DefaultButton then Default := True;
if B = CancelButton then Cancel := True;
SetBounds(X, IconTextHeight + VertMargin + VertSpacing,
ButtonWidth, ButtonHeight);
Inc(X, ButtonWidth + ButtonSpacing);
if B = mbHelp then
OnClick := TMessageForm(Result).HelpButtonClick;
end;
end;
end;
function MessageDlg(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons; HelpCtx: Longint): Integer;
begin
Result := MessageDlgPosHelp(Msg, DlgType, Buttons, HelpCtx, -1, -1, '');
end;
function MessageDlgPos(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons; HelpCtx: Longint; X, Y: Integer): Integer;
begin
Result := MessageDlgPosHelp(Msg, DlgType, Buttons, HelpCtx, X, Y, '');
end;
function MessageDlgPosHelp(const Msg: string; DlgType: TMsgDlgType;
Buttons: TMsgDlgButtons; HelpCtx: Longint; X, Y: Integer;
const HelpFileName: string): Integer;
begin
with CreateMessageDialog(Msg, DlgType, Buttons) do
try
HelpContext := HelpCtx;
HelpFile := HelpFileName;
if X >= 0 then Left := X;
if Y >= 0 then Top := Y;
if (Y < 0) and (X < 0) then Position := poScreenCenter;
Result := ShowModal;
finally
Free;
end;
end;
procedure ShowMessage(const Msg: string);
begin
ShowMessagePos(Msg, -1, -1);
end;
procedure ShowMessageFmt(const Msg: string; Params: array of const);
begin
ShowMessage(Format(Msg, Params));
end;
procedure ShowMessagePos(const Msg: string; X, Y: Integer);
begin
MessageDlgPos(Msg, mtCustom, [mbOK], 0, X, Y);
end;
{ Input dialog }
function InputQuery(const ACaption, APrompt: string;
var Value: string): Boolean;
var
Form: TForm;
Prompt: TLabel;
Edit: TEdit;
DialogUnits: TPoint;
ButtonTop, ButtonWidth, ButtonHeight: Integer;
begin
Result := False;
Form := TForm.Create(Application);
with Form do
try
Canvas.Font := Font;
DialogUnits := GetAveCharSize(Canvas);
BorderStyle := bsDialog;
Caption := ACaption;
ClientWidth := MulDiv(180, DialogUnits.X, 4);
Position := poScreenCenter;
Prompt := TLabel.Create(Form);
with Prompt do
begin
Parent := Form;
Caption := APrompt;
Left := MulDiv(8, DialogUnits.X, 4);
Top := MulDiv(8, DialogUnits.Y, 8);
Constraints.MaxWidth := MulDiv(164, DialogUnits.X, 4);
WordWrap := True;
end;
Edit := TEdit.Create(Form);
with Edit do
begin
Parent := Form;
Left := Prompt.Left;
Top := Prompt.Top + Prompt.Height + 5;
Width := MulDiv(164, DialogUnits.X, 4);
MaxLength := 255;
Text := Value;
SelectAll;
end;
ButtonTop := Edit.Top + Edit.Height + 15;
ButtonWidth := MulDiv(50, DialogUnits.X, 4);
ButtonHeight := MulDiv(14, DialogUnits.Y, 8);
with TButton.Create(Form) do
begin
Parent := Form;
Caption := SMsgDlgOK;
ModalResult := mrOk;
Default := True;
SetBounds(MulDiv(38, DialogUnits.X, 4), ButtonTop, ButtonWidth,
ButtonHeight);
end;
with TButton.Create(Form) do
begin
Parent := Form;
Caption := SMsgDlgCancel;
ModalResult := mrCancel;
Cancel := True;
SetBounds(MulDiv(92, DialogUnits.X, 4), Edit.Top + Edit.Height + 15,
ButtonWidth, ButtonHeight);
Form.ClientHeight := Top + Height + 13;
end;
if ShowModal = mrOk then
begin
Value := Edit.Text;
Result := True;
end;
finally
Form.Free;
end;
end;
function InputBox(const ACaption, APrompt, ADefault: string): string;
begin
Result := ADefault;
InputQuery(ACaption, APrompt, Result);
end;
function PromptForFileName(var AFileName: string; const AFilter: string = '';
const ADefaultExt: string = ''; const ATitle: string = '';
const AInitialDir: string = ''; SaveDialog: Boolean = False): Boolean;
var
Dialog: TOpenDialog;
begin
if SaveDialog then
begin
Dialog := TSaveDialog.Create(nil);
Dialog.Options := Dialog.Options + [ofOverwritePrompt];
end
else
Dialog := TOpenDialog.Create(nil);
with Dialog do
try
Title := ATitle;
DefaultExt := ADefaultExt;
if AFilter = '' then
Filter := SDefaultFilter else
Filter := AFilter;
InitialDir := AInitialDir;
FileName := AFileName;
Result := Execute;
if Result then
AFileName := FileName;
finally
Free;
end;
end;
{ Initialization and cleanup }
procedure InitGlobals;
var
AtomText: array[0..31] of Char;
begin
HelpMsg := RegisterWindowMessage(HelpMsgString);
FindMsg := RegisterWindowMessage(FindMsgString);
WndProcPtrAtom := GlobalAddAtom(StrFmt(AtomText,
'WndProcPtr%.8X%.8X', [HInstance, GetCurrentThreadID]));
end;
initialization
InitGlobals;
StartClassGroup(TControl);
ActivateClassGroup(TControl);
GroupDescendentsWith(TCommonDialog, TControl);
finalization
if WndProcPtrAtom <> 0 then GlobalDeleteAtom(WndProcPtrAtom);
end.
|
unit Unit1;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls, Menus, engine.databases;
type
{ TMainForm }
TMainForm = class(TForm)
MainMenu: TMainMenu;
Memo: TMemo;
MenuItemGetCountMsgs: TMenuItem;
MenuItemGetFriendCount: TMenuItem;
MenuItemFile: TMenuItem;
MenuItemGetUsersCount: TMenuItem;
MenuItemDeleteUser: TMenuItem;
MenuItem12: TMenuItem;
MenuItemSetNewUserInfo: TMenuItem;
MenuItemFindUser: TMenuItem;
MenuItemFriends: TMenuItem;
MenuItemMsgs: TMenuItem;
MenuItemNewFriend: TMenuItem;
MenuItemRemoveFriend: TMenuItem;
MenuItem19: TMenuItem;
MenuItemUsers: TMenuItem;
MenuItemGetFriendInfo: TMenuItem;
MenuItemSetFriendInfo: TMenuItem;
MenuItemNewMsg: TMenuItem;
MenuItemRemoveMsg: TMenuItem;
MenuItemGetMsgInfo: TMenuItem;
MenuItemOpenDB: TMenuItem;
MenuItemCreateDB: TMenuItem;
MenuItemClose: TMenuItem;
MenuItem5: TMenuItem;
MenuItemNewUser: TMenuItem;
MenuItemSetUserAvatar: TMenuItem;
MenuItemGetUserAvatar: TMenuItem;
MenuItemGetUsersInfo: TMenuItem;
OpenDialog: TOpenDialog;
SaveDialog: TSaveDialog;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure MenuItemGetCountMsgsClick(Sender: TObject);
procedure MenuItemGetFriendCountClick(Sender: TObject);
procedure MenuItemGetUsersCountClick(Sender: TObject);
procedure MenuItemDeleteUserClick(Sender: TObject);
procedure MenuItemSetNewUserInfoClick(Sender: TObject);
procedure MenuItemFindUserClick(Sender: TObject);
procedure MenuItemNewFriendClick(Sender: TObject);
procedure MenuItemRemoveFriendClick(Sender: TObject);
procedure MenuItemGetFriendInfoClick(Sender: TObject);
procedure MenuItemSetFriendInfoClick(Sender: TObject);
procedure MenuItemNewMsgClick(Sender: TObject);
procedure MenuItemRemoveMsgClick(Sender: TObject);
procedure MenuItemGetMsgInfoClick(Sender: TObject);
procedure MenuItemCreateDBClick(Sender: TObject);
procedure MenuItemCloseClick(Sender: TObject);
procedure MenuItemNewUserClick(Sender: TObject);
procedure MenuItemSetUserAvatarClick(Sender: TObject);
procedure MenuItemGetUserAvatarClick(Sender: TObject);
procedure MenuItemGetUsersInfoClick(Sender: TObject);
procedure MenuItemOpenDBClick(Sender: TObject);
private
procedure SetLog(AValue: string);
{ private declarations }
public
{ public declarations }
db: TCustomDataBase;
property Log: string write SetLog;
end;
var
MainForm: TMainForm;
implementation
{$R *.lfm}
{ TMainForm }
procedure TMainForm.FormCreate(Sender: TObject);
begin
db := TCustomDataBase.Create;
end;
procedure TMainForm.FormDestroy(Sender: TObject);
begin
DB.Free;
end;
procedure TMainForm.MenuItemCloseClick(Sender: TObject);
begin
Close;
end;
procedure TMainForm.SetLog(AValue: string);
// Заносим в журнал данные или рисуем линию
var
buf: string;
i: integer;
begin
Buf := '';
if AnsiLowerCase(AValue) = 'nl' then
begin
for i := 1 to 80 do
Buf += '*';
Memo.Lines.Add(Buf);
end
else
Memo.Lines.Add(AValue);
end;
procedure TMainForm.MenuItemGetFriendCountClick(Sender: TObject);
// Получить количество друзей
begin
Log := 'nl';
Log := 'ПОЛУЧАЕМ КОЛИЧЕСТВО ДРУЗЕЙ ПОЛЬЗОВАТЕЛЯ №1';
Log := 'nl';
if DB.GetFriendsCount(1) <> INVALID_VALUE then
Log := 'Количество друзей: ' + IntToStr(DB.GetFriendsCount(1))
else
Log := 'Ошибка получения количества друзей';
Log := '';
end;
procedure TMainForm.MenuItemNewUserClick(Sender: TObject);
// Создание нового пользователя
begin
Log := 'nl';
Log := 'ДОБАВЛЕНИЕ НОВОГО ПОЛЬЗОВАТЕЛЯ В БД БЕЗ АВАТАРКИ';
Log := 'nl';
if DB.AddUser('Test1', 'pass1', 'Test1@Email.ru') then
begin
Log := 'Пользователь создан:';
Log := #9 + 'Имя: ' + DB.GetUserNickName(DB.GetUsersCount);
Log := #9 + 'Мыло:' + DB.GetUserEMail(DB.GetUsersCount);
Log := #9 + 'Хэш: ' + DB.GetUserPasswordHash(DB.GetUsersCount);
end
else
Log := 'Ошибка создания нового пользователя';
Log := '';
Log := 'nl';
Log := 'ДОБАВЛЕНИЕ НОВОГО ПОЛЬЗОВАТЕЛЯ В БД С АВАТАРКОЙ';
Log := 'nl';
if OpenDialog.Execute then
if DB.AddUser('Test2', 'pass2', 'Test2@Email.ru', OpenDialog.FileName) then
begin
Log := 'Пользователь создан:';
Log := #9 + 'Имя: ' + DB.GetUserNickName(DB.GetUsersCount);
Log := #9 + 'Мыло:' + DB.GetUserEMail(DB.GetUsersCount);
Log := #9 + 'Хэш: ' + DB.GetUserPasswordHash(DB.GetUsersCount);
end
else
Log := 'Ошибка создания нового пользователя';
Log := '';
end;
procedure TMainForm.MenuItemSetUserAvatarClick(Sender: TObject);
// Установить новую аватарку
begin
Log := 'nl';
Log := 'УСТАНОВКА ПОЛЬЗОВАТЕЛЮ №1 АВАТАРКИ';
Log := 'nl';
if OpenDialog.Execute then
Log := BoolToStr(DB.SetUserAvatar(1, OpenDialog.FileName), 'Установлена аватарка: ' + OpenDialog.FileName, 'Ошибка установки аватарки');
Log := '';
end;
procedure TMainForm.MenuItemGetUserAvatarClick(Sender: TObject);
// Сохранить аватарку пользователя
var
MemoryStream: TMemoryStream;
begin
Log := 'nl';
Log := 'СОХРАНЕНИЕ В ФАЙЛ АВАТАРКИ ПОЛЬЗОВАТЕЛЯ №2';
Log := 'nl';
if SaveDialog.Execute then
begin
MemoryStream := TMemoryStream.Create;
if DB.SaveUserAvatarToStream(2, MemoryStream) then
Log := 'Аватарка сохранена успешно: ' + SaveDialog.FileName
else
Log := 'Ошибка сохранения аватарки в файл';
MemoryStream.SaveToFile(SaveDialog.FileName);
MemoryStream.Free;
end;
Log := '';
end;
procedure TMainForm.MenuItemGetUsersInfoClick(Sender: TObject);
// Получаем информацию о пользователе
var
EMail: string;
PassHash: string;
Nick: string;
i: integer;
begin
Log := 'nl';
Log := 'ПОЛУЧИТЬ ИНФОРМАЦИЮ О ПОЛЬЗОВАТЕЛЯХ';
Log := 'nl';
if DB.GetUsersCount <> INVALID_VALUE then
for i := 1 to DB.GetUsersCount do
begin
DB.GetUserInfo(i, Nick, PassHash, EMail);
Log := 'ID: ' + IntToStr(i);
Log := 'Имя: ' + Nick;
Log := 'Хэш: ' + PassHash;
Log := 'Мыло: ' + EMail;
Log := '';
end;
end;
procedure TMainForm.MenuItemOpenDBClick(Sender: TObject);
// Открытие БД
begin
Log := 'nl';
Log := 'ОТКРЫТИЕ БД';
Log := 'nl';
if OpenDialog.Execute then
Log := BoolToStr(DB.OpenDataBase(OpenDialog.FileName), 'Смог открыть БД: ' + OpenDialog.FileName, 'Ошибка открытия БД');
Log := '';
end;
procedure TMainForm.MenuItemCreateDBClick(Sender: TObject);
// создание БД
begin
Log := 'nl';
Log := 'СОЗДАНИЕ БД';
Log := 'nl';
if SaveDialog.Execute then
Log := BoolToStr(DB.CreateDataBase(SaveDialog.FileName), 'БД создана: ' + SaveDialog.FileName, 'Ошибка создания БД');
Log := '';
end;
procedure TMainForm.MenuItemGetUsersCountClick(Sender: TObject);
// Количество пользователей
begin
Log := 'nl';
Log := 'КОЛИЧЕСТВО ПОЛЬЗОВАТЕЛЕЙ В БД';
Log := 'nl';
LOG := 'Пользователей в БД: ' + IntToStr(DB.GetUsersCount);
Log := '';
end;
procedure TMainForm.MenuItemDeleteUserClick(Sender: TObject);
// Удаляем друга
begin
Log := 'nl';
Log := 'УДАЛЯЕМ ПОЛЬЗОВАТЕЛЯ №1 В БД';
Log := 'nl';
Log := BoolToStr(DB.RemoveUser(1), 'Пользователь удалён', 'Ошибка удаления пользователея');
Log := '';
end;
procedure TMainForm.MenuItemSetNewUserInfoClick(Sender: TObject);
// Изменяем данные пользователя
begin
Log := 'nl';
Log := 'ИЗМЕНЯЕМ ДАННЫЕ ПОЛЬЗОВАТЕЛЯ №2 В БД';
Log := 'nl';
Log := 'Текущая информация пользователя №2:';
Memo.Lines.Add(DB.GetUserNickName(2));
Memo.Lines.Add(DB.GetUserEMail(2));
Memo.Lines.Add(DB.GetUserPasswordHash(2));
Log := 'Изменяем информацию о пользователе: ';
if DB.SetUserEMail(2, 'NewEmail@NewEmail.NewEmail') and DB.SetUserNickName(2, 'NewNickName') then
Log := 'Данные пользователя успешно изменены: '
else
Log := 'Ошибка изменения информации о пользователе:';
Memo.Lines.Add(DB.GetUserNickName(2));
Memo.Lines.Add(DB.GetUserEMail(2));
Memo.Lines.Add(DB.GetUserPasswordHash(2));
Log := '';
end;
procedure TMainForm.MenuItemFindUserClick(Sender: TObject);
// Узнать наличие пользователя
begin
Log := 'nl';
Log := 'ИЩЕМ ПОЛЬЗОВАТЕЛЯ В БД ПО НЕКОЙ СТРОКЕ';
Log := 'nl';
Log := 'Ищем пользователя с мылом - NewEmail@NewEmail.NewEmail';
Log := 'ID: ' + IntToStr(DB.UserExist('NewEmail@NewEmail.NewEmail'));
Log := 'Ищем пользователя с именем - Test2';
Log := 'ID: ' + IntToStr(DB.UserExist('Test2'));
Log := '';
end;
procedure TMainForm.MenuItemNewFriendClick(Sender: TObject);
// Добавление друга
begin
Log := 'nl';
Log := 'ДОБАВЛЯЕМ НОВОГО ДРУГА БЕЗ АВАТАРКИ';
Log := 'nl';
if DB.AddFriend(1, 'Friend', 'Friend@Friend.Friend') then
begin
Log := 'Друг создан:';
Log := #9 + 'Имя: ' + DB.GetFriendNickName(1, DB.GetUsersCount);
Log := #9 + 'Мыло:' + DB.GetFriendEmail(1, DB.GetUsersCount);
end
else
Log := 'Ошибка создания нового друга';
Log := '';
Log := 'nl';
Log := 'ДОБАВЛЯЕМ НОВОГО ДРУГА С АВАТАРКОЙ';
Log := 'nl';
if OpenDialog.Execute then
if DB.AddFriend(1, 'Friend', 'Friend@Friend.Friend', OpenDialog.FileName) then
begin
Log := 'Друг создан:';
Log := #9 + 'Имя: ' + DB.GetFriendNickName(1, DB.GetUsersCount);
Log := #9 + 'Мыло:' + DB.GetFriendEmail(1, DB.GetUsersCount);
end
else
Log := 'Ошибка создания нового друга';
Log := '';
end;
procedure TMainForm.MenuItemRemoveFriendClick(Sender: TObject);
// Удаление друга
begin
Log := 'nl';
Log := 'УДАЛЯЕМ ДРУГА №2 ПОЛЬЗОВАТЕЛЯ № 1 В БД';
Log := 'nl';
Log := BoolToStr(DB.RemoveFriend(1, 2), 'Друг №2 удалён из БД', 'Ошибка удаления друга из БД');
Log := '';
end;
procedure TMainForm.MenuItemGetFriendInfoClick(Sender: TObject);
// Получить информацию о друге
var
i: integer;
begin
Log := 'nl';
Log := 'ПОЛУЧАЕМ ИНФОРМАЦИЮ О ДРУЗЬЯХ ПОЛЬЗОВАТЕЛЯ №1';
Log := 'nl';
if DB.GetFriendsCount(1) <> INVALID_VALUE then
for i := 1 to DB.GetFriendsCount(1) do
begin
Log := 'id: ' + IntToStr(i);
Log := 'Имя: ' + DB.GetFriendNickName(1, i);
Log := 'Мыло: ' + DB.GetFriendEmail(1, i);
Log := '';
end;
end;
procedure TMainForm.MenuItemSetFriendInfoClick(Sender: TObject);
// Установить информацию о друге
begin
Log := 'nl';
Log := 'УСТАНАВЛИВАЕМ НОВЫЕ ДАННЫЕ ДРУГУ №1 ПОЛЬЗОВАТЕЛЯ №1';
Log := 'nl';
Log := 'Старые данные:';
Log := 'Имя: ' + DB.GetFriendNickName(1, 1);
Log := 'Мыло: ' + DB.GetFriendEmail(1, 1);
Log := 'Установка новых данных:';
if not DB.SetFriendEmail(1, 1, 'test@friend.ru') then
Log := 'Ошибка установки нового мыла';
if not DB.SetFriendNickName(1, 1, 'nick@friend') then
Log := 'Ошибка установки нового имени';
Log := 'Новые данные:';
Log := 'Имя: ' + DB.GetFriendNickName(1, 1);
Log := 'Мыло: ' + DB.GetFriendEmail(1, 1);
Log := '';
end;
procedure TMainForm.MenuItemNewMsgClick(Sender: TObject);
// Добавить сообщения
var
Message: TMemoryStream;
BlowFishKey: TMemoryStream;
PrivateKey: TMemoryStream;
OpenKey: TMemoryStream;
Status: boolean;
begin
Log := 'nl';
Log := 'СОЗДАНИЕ СООБЩЕНИЙ МЕЖДУ ДРУГОМ №1 И ПОЛЬЗОВАТЕЛЯМ №1';
Log := 'nl';
Message := TMemoryStream.Create;
Message.LoadFromFile(Application.ExeName + '.lpi');
BlowFishKey := TMemoryStream.Create;
BlowFishKey.LoadFromFile(Application.ExeName + '.lpi');
PrivateKey := TMemoryStream.Create;
PrivateKey.LoadFromFile(Application.ExeName + '.lpi');
OpenKey := TMemoryStream.Create;
OpenKey.LoadFromFile(Application.ExeName + '.lpi');
try
Status := True;
Status := Status and DB.AddMessage(1, 1, TMsgDirection.mdoutgoingMsg, TMsgType.mtAddFriend, Message, OpenKey, PrivateKey, BlowFishKey);
Status := Status and DB.AddMessage(1, 1, TMsgDirection.mdoutgoingMsg, TMsgType.mtExchangeKey, Message, OpenKey, PrivateKey, BlowFishKey);
Status := Status and DB.AddMessage(1, 1, TMsgDirection.mdoutgoingMsg, TMsgType.mtMessage, Message, OpenKey, PrivateKey, BlowFishKey);
Status := Status and DB.AddMessage(1, 1, TMsgDirection.mdIncomingMsg, TMsgType.mtAddFriend, Message, OpenKey, PrivateKey, BlowFishKey);
Status := Status and DB.AddMessage(1, 1, TMsgDirection.mdIncomingMsg, TMsgType.mtExchangeKey, Message, OpenKey, PrivateKey, BlowFishKey);
Status := Status and DB.AddMessage(1, 1, TMsgDirection.mdIncomingMsg, TMsgType.mtMessage, Message, OpenKey, PrivateKey, BlowFishKey);
finally
Message.Free;
BlowFishKey.Free;
PrivateKey.Free;
OpenKey.Free;
end;
if Status then
Log := 'Все пользователи созданы успешно'
else
Log := 'Ошибка создания новых пользователей';
Log := '';
end;
procedure TMainForm.MenuItemRemoveMsgClick(Sender: TObject);
// Удалить сообщения
begin
Log := 'nl';
Log := 'УДАЛЯЕМ СООБЩЕНИЕ №3 ДРУГА №2 ПОЛЬЗОВАТЕЛЯ № 1 В БД';
Log := 'nl';
Log := BoolToStr(DB.RemoveMessage(1, 1, 1), 'Сообщение успешно удалено', 'Ошибка удаления сообщения');
Log := '';
end;
procedure TMainForm.MenuItemGetMsgInfoClick(Sender: TObject);
// Получить информацию о сообщении
var
StringStream: TStringStream;
begin
Log := 'nl';
Log := 'ПОЛУЧИТЬ ИНФОРМАЦИЮ О СООБЩЕНИИ №1 ДРУГА №2 ПОЛЬЗОВАТЕЛЯ № 1 В БД';
Log := 'nl';
case DB.GetMessageType(1, 1, 1) of
mtAddFriend: Log := 'Тип сообщения: Добавление в друзья';
mtExchangeKey: Log := 'Тип сообщения: Обмен ключами';
mtMessage: Log := 'Тип сообщения: Сообщение';
end;
if DB.GetMessageDirection(1, 1, 1) = mdIncomingMsg then
Log := 'Входящее сообщение'
else
Log := 'Исходящее сообщение';
Log := 'Дата сообщения: ' + DateTimeToStr(DB.GetMessageDate(1, 1, 2));
StringStream:= TStringStream.Create('');
db.GetMessage(1, 1, 1, StringStream);
Log := 'Текст сообщения: ';
Log := StringStream.DataString;
Log := '';
end;
procedure TMainForm.MenuItemGetCountMsgsClick(Sender: TObject);
// Получить количество сообщений
begin
Log := 'nl';
Log := 'КОЛИЧЕСТВО СООБЩЕНИЙ В БД';
Log := 'nl';
LOG := 'Сообщений в БД: ' + IntToStr(DB.GetMessagesCount(1, 1));
Log := '';
end;
end.
|
unit VM_INTF;
interface
{$IFDEF FPC}
{$MODE DELPHI}
{$ENDIF}
uses SysUtils, VM.Invoke, xmldom, XMLDoc, XMlIntf;
implementation
type
IMyIntf = interface
['{965AC8F3-6952-41C7-BFB9-41D48BF3D860}']
function GetInt: Integer;
procedure SetInt(V: Integer);
end;
TMyIntf = class(TInterfacedObject, IMyIntf)
FInt: Integer;
function GetInt: Integer;
procedure SetInt(V: Integer);
public
destructor Destroy; override;
end;
function GetIntf: IMyIntf;
begin
Result := TMyIntf.Create;
end;
function GetIUnknown: IInterface;
begin
Result := TInterfacedObject.Create;
end;
procedure XCreateGUID(out GUID: TGUID);
begin
CreateGUID(GUID);
end;
var
_G: TGUID;
procedure WriteGUID(const GUID: TGUID);
begin
_G := GUID;
end;
procedure ReadGUID(out GUID: TGUID);
begin
GUID := _G;
end;
procedure RegisterVM_System;
begin
RegisterProc('SYS', 'GetIUnknown', @GetIUnknown);
RegisterProc('SYS', 'GetIntf', @GetIntf);
RegisterProc('SYS', 'NewXMLDocument', @NewXMLDocument);
RegisterProc('system', 'CreateGUID', @XCreateGUID);
RegisterProc('system', 'WriteGUID', @WriteGUID);
RegisterProc('system', 'ReadGUID', @ReadGUID);
end;
{ TMyIntf }
destructor TMyIntf.Destroy;
begin
inherited;
end;
function TMyIntf.GetInt: Integer;
begin
Result := FInt;
end;
procedure TMyIntf.SetInt(V: Integer);
begin
FInt := V;
end;
var
Doc: IXMLDocument;
Node: IXMLNode;
initialization
Doc := NewXMLDocument;
Node := Doc.AddChild('root');
RegisterVM_System;
end.
|
//
// This unit is part of the GLScene Project, http://glscene.org
//
{ : GLSDLWindow<p>
Non visual wrapper around basic SDL window features.<p>
<u>Notes to Self:</u><br>
Unit must ultimately *NOT* make use of any platform specific stuff,
*EVEN* through the use of conditionnals.<br>
SDL-specifics should also be avoided in the "interface" section.<p>
Written and maintained by Eric Grange (http://glscene.org),
this component uses JEDI-SDL conversion (http://delphi-jedi.org),
which is a Delphi header conversion for SDL (http://libsdl.org)<p>
<b>History : </b><font size=-1><ul>
<li>17/11/09 - DaStr - Improved Unix compatibility
(thanks Predator) (BugtrackerID = 2893580)
<li>16/10/08 - UweR - Compatibility fix for Delphi 2009
<li>07/06/07 - DaStr - Added $I GLScene.inc
<li>17/03/07 - DaStr - Dropped Kylix support in favor of FPC (BugTracekrID=1681585)
<li>16/12/01 - Egg - Resize no longer recreates SDL surface in OpenGL mode
<li>12/12/01 - Egg - Fixes & additions (code from Dominique Louis),
Added doc tags, Stencil buffer and others.
<li>11/12/01 - Egg - Creation
</ul></font>
}
unit GLSDLWindow;
interface
{$I GLScene.inc}
uses
Classes, SysUtils, SyncObjs,
// SDL
SDL;
type
// TSDLWindowPixelDepth
//
{ : Pixel Depth options.<p>
<ul>
<li>vpd16bits: 16bpp graphics (565) (and 16 bits depth buffer for OpenGL)
<li>vpd24bits: 24bpp graphics (565) (and 24 bits depth buffer for OpenGL)
</ul> }
TSDLWindowPixelDepth = (vpd16bits, vpd24bits);
// TSDLWindowOptions
//
{ : Specifies optional settings for the SDL window.<p>
Those options are a simplified subset of the SDL options:<ul>
<li>voDoubleBuffer: create a double-buffered window
<li>voHardwareAccel: enables all hardware acceleration options (software
only if not defined).
<li>voOpenGL: requires OpenGL capability for the window
<li>voResizable: window should be resizable
<li>voFullScreen: requires a fullscreen "window" (screen resolution may
be changed)
<li>voStencilBuffer: requires a stencil buffer (8bits, use along voOpenGL)
</ul> }
TSDLWindowOption = (voDoubleBuffer, voHardwareAccel, voOpenGL, voResizable,
voFullScreen, voStencilBuffer);
TSDLWindowOptions = set of TSDLWindowOption;
TSDLEvent = procedure(sender: TObject; const event: TSDL_Event) of object;
const
cDefaultSDLWindowOptions = [voDoubleBuffer, voHardwareAccel, voOpenGL,
voResizable];
type
// TSDLWindow
//
{ : A basic SDL-based window (non-visual component).<p>
Only a limited subset of SDL's features are available, and this window
is heavily oriented toward using it for OpenGL rendering.<p>
Be aware SDL is currently limited to a single window at any time...
so you may have multiple components, but only one can be used. }
TSDLWindow = class(TComponent)
private
{ Private Declarations }
FWidth: Integer;
FHeight: Integer;
FPixelDepth: TSDLWindowPixelDepth;
FOptions: TSDLWindowOptions;
FActive: Boolean;
FOnOpen: TNotifyEvent;
FOnClose: TNotifyEvent;
FOnResize: TNotifyEvent;
FOnSDLEvent: TSDLEvent;
FOnEventPollDone: TNotifyEvent;
FCaption: String;
FThreadSleepLength: Integer;
FThreadPriority: TThreadPriority;
FThreadedEventPolling: Boolean;
FThread: TThread;
FSDLSurface: PSDL_Surface;
FWindowHandle: Longword;
protected
{ Protected Declarations }
procedure SetWidth(const val: Integer);
procedure SetHeight(const val: Integer);
procedure SetPixelDepth(const val: TSDLWindowPixelDepth);
procedure SetOptions(const val: TSDLWindowOptions);
procedure SetActive(const val: Boolean);
procedure SetCaption(const val: String);
procedure SetThreadSleepLength(const val: Integer);
procedure SetThreadPriority(const val: TThreadPriority);
procedure SetThreadedEventPolling(const val: Boolean);
function BuildSDLVideoFlags: Cardinal;
procedure SetSDLGLAttributes;
procedure CreateOrRecreateSDLSurface;
procedure ResizeGLWindow;
procedure SetupSDLEnvironmentValues;
procedure StartThread;
procedure StopThread;
public
{ Public Declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
{ : Initializes and Opens an SDL window }
procedure Open;
{ : Closes an already opened SDL Window.<p>
NOTE: will also kill the app due to an SDL limitation... }
procedure Close;
{ : Applies changes (size, pixeldepth...) to the opened window. }
procedure UpdateWindow;
{ : Swap front and back buffer.<p> }
procedure SwapBuffers;
{ : Polls SDL events.<p>
SDL events can be either polled "manually", through a call to this
method, or automatically via ThreadEventPolling. }
procedure PollEvents;
{ : Is the SDL window active (opened)?<p>
Adjusting this value as the same effect as invoking Open/Close. }
property Active: Boolean read FActive write SetActive;
{ : Presents the SDL surface of the window.<p>
If Active is False, this value is undefined. }
property Surface: PSDL_Surface read FSDLSurface;
{ : Experimental: ask SDL to reuse and existing WindowHandle }
property WindowHandle: Cardinal read FWindowHandle write FWindowHandle;
published
{ Published Declarations }
{ : Width of the SDL window.<p>
To apply changes to an active window, call UpdateWindow. }
property Width: Integer read FWidth write SetWidth default 640;
{ : Height of the SDL window.<p>
To apply changes to an active window, call UpdateWindow. }
property Height: Integer read FHeight write SetHeight default 480;
{ : PixelDepth of the SDL window.<p>
To apply changes to an active window, call UpdateWindow. }
property PixelDepth: TSDLWindowPixelDepth read FPixelDepth
write SetPixelDepth default vpd24bits;
{ : Options for the SDL window.<p>
To apply changes to an active window, call UpdateWindow. }
property Options: TSDLWindowOptions read FOptions write SetOptions
default cDefaultSDLWindowOptions;
{ : Caption of the SDL window }
property Caption: String read FCaption write SetCaption;
{ : Controls automatic threaded event polling. }
property ThreadedEventPolling: Boolean read FThreadedEventPolling
write SetThreadedEventPolling default True;
{ : Sleep length between pollings in the polling thread. }
property ThreadSleepLength: Integer read FThreadSleepLength
write SetThreadSleepLength default 1;
{ : Priority of the event polling thread. }
property ThreadPriority: TThreadPriority read FThreadPriority
write SetThreadPriority default tpLower;
{ : Fired whenever Open succeeds.<p>
The SDL surface is defined and usable when the event happens. }
property OnOpen: TNotifyEvent read FOnOpen write FOnOpen;
{ : Fired whenever closing the window.<p>
The SDL surface is still defined and usable when the event happens. }
property OnClose: TNotifyEvent read FOnClose write FOnClose;
{ : Fired whenever the window is resized.<p>
Note: glViewPort call is handled automatically for OpenGL windows }
property OnResize: TNotifyEvent read FOnResize write FOnResize;
{ : Fired whenever an SDL Event is polled.<p>
SDL_QUITEV and SDL_VIDEORESIZE are not passed to this event handler,
they are passed via OnClose and OnResize respectively. }
property OnSDLEvent: TSDLEvent read FOnSDLEvent write FOnSDLEvent;
{ : Fired whenever an event polling completes with no events left to poll. }
property OnEventPollDone: TNotifyEvent read FOnEventPollDone
write FOnEventPollDone;
end;
// ESDLError
//
{ : Generic SDL or SDLWindow exception. }
ESDLError = class(Exception);
procedure Register;
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
implementation
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
uses
OpenGLAdapter, GLContext, GLVectorGeometry;
var
vSDLCS: TCriticalSection;
vSDLActive: Boolean; // will be removed once SDL supports multiple windows
type
// TSDLEventThread
//
TSDLEventThread = class(TThread)
Owner: TSDLWindow;
procedure Execute; override;
procedure DoPollEvents;
end;
procedure Register;
begin
RegisterComponents('GLScene Utils', [TSDLWindow]);
end;
// RaiseSDLError
//
procedure RaiseSDLError(const msg: String = '');
begin
if msg <> '' then
raise ESDLError.Create(msg + #13#10 + SDL_GetError)
else
raise ESDLError.Create(SDL_GetError);
end;
// ------------------
// ------------------ TSDLEventThread ------------------
// ------------------
// Execute
//
procedure TSDLEventThread.Execute;
begin
try
while not Terminated do
begin
vSDLCS.Enter;
try
SDL_Delay(Owner.ThreadSleepLength);
finally
vSDLCS.Leave;
end;
Synchronize(DoPollEvents);
end;
except
// bail out asap, problem wasn't here anyway
end;
vSDLCS.Enter;
try
if Assigned(Owner) then
Owner.FThread := nil;
finally
vSDLCS.Leave;
end;
end;
// DoPollEvents
//
procedure TSDLEventThread.DoPollEvents;
begin
// no need for a CS here, we're in the main thread
if Assigned(Owner) then
Owner.PollEvents;
end;
// ------------------
// ------------------ TSDLWindow ------------------
// ------------------
// Create
//
constructor TSDLWindow.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FWidth := 640;
FHeight := 480;
FPixelDepth := vpd24bits;
FThreadedEventPolling := True;
FThreadSleepLength := 1;
FThreadPriority := tpLower;
FOptions := cDefaultSDLWindowOptions;
end;
// Destroy
//
destructor TSDLWindow.Destroy;
begin
Close;
inherited Destroy;
end;
// SetWidth
//
procedure TSDLWindow.SetWidth(const val: Integer);
begin
if FWidth <> val then
if val > 0 then
FWidth := val;
end;
// SetHeight
//
procedure TSDLWindow.SetHeight(const val: Integer);
begin
if FHeight <> val then
if val > 0 then
FHeight := val;
end;
// SetPixelDepth
//
procedure TSDLWindow.SetPixelDepth(const val: TSDLWindowPixelDepth);
begin
FPixelDepth := val;
end;
// SetOptions
//
procedure TSDLWindow.SetOptions(const val: TSDLWindowOptions);
begin
FOptions := val;
end;
// BuildSDLVideoFlags
//
function TSDLWindow.BuildSDLVideoFlags: Cardinal;
var
videoInfo: PSDL_VideoInfo;
begin
videoInfo := SDL_GetVideoInfo;
if not Assigned(videoInfo) then
raise ESDLError.Create('Video query failed.');
Result := 0;
if voOpenGL in Options then
Result := Result + SDL_OPENGL;
if voDoubleBuffer in Options then
Result := Result + SDL_DOUBLEBUF;
if voResizable in Options then
Result := Result + SDL_RESIZABLE;
if voFullScreen in Options then
Result := Result + SDL_FULLSCREEN;
if voHardwareAccel in Options then
begin
if videoInfo.hw_available <> 0 then
Result := Result + SDL_HWPALETTE + SDL_HWSURFACE
else
Result := Result + SDL_SWSURFACE;
if videoInfo.blit_hw <> 0 then
Result := Result + SDL_HWACCEL;
end
else
Result := Result + SDL_SWSURFACE;
end;
// SetSDLGLAttributes
//
procedure TSDLWindow.SetSDLGLAttributes;
begin
case PixelDepth of
vpd16bits:
begin
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 6);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 5);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
end;
vpd24bits:
begin
SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
end;
else
Assert(False);
end;
if voStencilBuffer in Options then
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8)
else
SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
if voDoubleBuffer in Options then
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1)
else
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 0)
end;
// CreateOrRecreateSDLSurface
//
procedure TSDLWindow.CreateOrRecreateSDLSurface;
const
cPixelDepthToBpp: array [Low(TSDLWindowPixelDepth)
.. High(TSDLWindowPixelDepth)] of Integer = (16, 24);
var
videoFlags: Integer;
begin
videoFlags := BuildSDLVideoFlags;
if voOpenGL in Options then
SetSDLGLAttributes;
FSDLSurface := SDL_SetVideoMode(Width, Height, cPixelDepthToBpp[PixelDepth],
videoFlags);
if not Assigned(FSDLSurface) then
RaiseSDLError('Unable to create surface.');
SDL_WM_SetCaption(PAnsiChar(AnsiString(FCaption)), nil);
if voOpenGL in Options then
ResizeGLWindow;
end;
// SetupSDLEnvironmentValues
//
procedure TSDLWindow.SetupSDLEnvironmentValues;
var
envVal: String;
begin
if FWindowHandle <> 0 then
begin
envVal := '';
{$IFDEF MSWINDOWS}
SDL_putenv('SDL_VIDEODRIVER=windib');
envVal := 'SDL_WINDOWID=' + IntToStr(Integer(FWindowHandle));
{$ELSE} // Not Windows.
{$IFDEF UNIX}
.. .Unsupported UNIX target.implement your target code here ! .. .
{$ENDIF} // UNIX
{$ENDIF} // MSWINDOWS
SDL_putenv(PAnsiChar(AnsiString(envVal)));
end;
end;
// Open
//
procedure TSDLWindow.Open;
begin
if Active then
Exit;
if vSDLActive then
raise ESDLError.Create('Only one SDL window can be opened at a time...')
else
vSDLActive := True;
if SDL_Init(SDL_INIT_VIDEO) < 0 then
raise ESDLError.Create('Could not initialize SDL.');
if voOpenGL in Options then
InitOpenGL;
SetupSDLEnvironmentValues;
CreateOrRecreateSDLSurface;
FActive := True;
if Assigned(FOnOpen) then
FOnOpen(Self);
if Assigned(FOnResize) then
FOnResize(Self);
if ThreadedEventPolling then
StartThread;
end;
// Close
//
procedure TSDLWindow.Close;
begin
if not Active then
Exit;
if Assigned(FOnClose) then
FOnClose(Self);
FActive := False;
StopThread;
SDL_Quit; // SubSystem(SDL_INIT_VIDEO);
FSDLSurface := nil;
vSDLActive := False;
end;
// UpdateWindow
//
procedure TSDLWindow.UpdateWindow;
begin
if Active then
CreateOrRecreateSDLSurface;
end;
// SwapBuffers
//
procedure TSDLWindow.SwapBuffers;
begin
if Active then
if voOpenGL in Options then
SDL_GL_SwapBuffers
else
SDL_Flip(Surface);
end;
// ResizeGLWindow
//
procedure TSDLWindow.ResizeGLWindow;
var
RC: TGLContext;
begin
RC := CurrentGLContext;
if Assigned(RC) then
RC.GLStates.ViewPort := Vector4iMake(0, 0, Width, Height);
end;
// SetActive
//
procedure TSDLWindow.SetActive(const val: Boolean);
begin
if val <> FActive then
if val then
Open
else
Close;
end;
// SetCaption
//
procedure TSDLWindow.SetCaption(const val: String);
begin
if FCaption <> val then
begin
FCaption := val;
if Active then
SDL_WM_SetCaption(PAnsiChar(AnsiString(FCaption)), nil);
end;
end;
// SetThreadSleepLength
//
procedure TSDLWindow.SetThreadSleepLength(const val: Integer);
begin
if val >= 0 then
FThreadSleepLength := val;
end;
// SetThreadPriority
//
procedure TSDLWindow.SetThreadPriority(const val: TThreadPriority);
begin
FThreadPriority := val;
if Assigned(FThread) then
FThread.Priority := val;
end;
// SetThreadedEventPolling
//
procedure TSDLWindow.SetThreadedEventPolling(const val: Boolean);
begin
if FThreadedEventPolling <> val then
begin
FThreadedEventPolling := val;
if ThreadedEventPolling then
begin
if Active and (not Assigned(FThread)) then
StartThread;
end
else if Assigned(FThread) then
StopThread;
end;
end;
// StartThread
//
procedure TSDLWindow.StartThread;
begin
if Active and ThreadedEventPolling and (not Assigned(FThread)) then
begin
FThread := TSDLEventThread.Create(True);
TSDLEventThread(FThread).Owner := Self;
FThread.Priority := ThreadPriority;
FThread.FreeOnTerminate := True;
FThread.Resume;
end;
end;
// StopThread
//
procedure TSDLWindow.StopThread;
begin
if Assigned(FThread) then
begin
vSDLCS.Enter;
try
TSDLEventThread(FThread).Owner := nil;
FThread.Terminate;
finally
vSDLCS.Leave;
end;
end;
end;
// PollEvents
//
procedure TSDLWindow.PollEvents;
var
event: TSDL_Event;
begin
if Active then
begin
while SDL_PollEvent(@event) > 0 do
begin
case event.type_ of
SDL_QUITEV:
begin
Close;
Break;
end;
SDL_VIDEORESIZE:
begin
FWidth := event.resize.w;
FHeight := event.resize.h;
if voOpenGL in Options then
ResizeGLWindow
else
begin
CreateOrRecreateSDLSurface;
if not Assigned(FSDLSurface) then
RaiseSDLError('Could not get a surface after resize.');
end;
if Assigned(FOnResize) then
FOnResize(Self);
end;
else
if Assigned(FOnSDLEvent) then
FOnSDLEvent(Self, event);
end;
end;
if Active then
if Assigned(FOnEventPollDone) then
FOnEventPollDone(Self);
end;
end;
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
initialization
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// We DON'T free this stuff manually,
// automatic release will take care of this
vSDLCS := TCriticalSection.Create;
end.
|
unit uFileCopyEx;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
const
FILE_COPY_NO_BUFFERING = $01;
type
TFileCopyProgress = function(TotalBytes, DoneBytes: Int64; UserData: Pointer): LongBool;
TFileCopyEx = function(const Source, Target: String; Options: UInt32;
UpdateProgress: TFileCopyProgress; UserData: Pointer): LongBool;
var
FileCopyEx: TFileCopyEx = nil;
implementation
{$IF DEFINED(MSWINDOWS)}
uses
Windows, DCWindows, DCOSUtils;
type
TCopyInfo = class
UserData: Pointer;
UpdateProgress: TFileCopyProgress;
end;
function Progress(TotalFileSize, TotalBytesTransferred, StreamSize, StreamBytesTransferred: LARGE_INTEGER; dwStreamNumber, dwCallbackReason: DWord; hSourceFile, hDestinationFile: THandle; lpdata: pointer): Dword; Stdcall;
var
ACopyInfo: TCopyInfo absolute lpData;
begin
if ACopyInfo.UpdateProgress(TotalFileSize.QuadPart, TotalBytesTransferred.QuadPart, ACopyInfo.UserData) then
Result:= PROGRESS_CONTINUE
else begin
Result:= PROGRESS_CANCEL;
end;
end;
function CopyFile(const Source, Target: String; Options: UInt32;
UpdateProgress: TFileCopyProgress; UserData: Pointer): LongBool;
var
ACopyInfo: TCopyInfo;
dwCopyFlags: DWORD = COPY_FILE_ALLOW_DECRYPTED_DESTINATION;
begin
ACopyInfo:= TCopyInfo.Create;
ACopyInfo.UserData:= UserData;
ACopyInfo.UpdateProgress:= UpdateProgress;
if (Options and FILE_COPY_NO_BUFFERING <> 0) then
begin
if (Win32MajorVersion > 5) then
dwCopyFlags:= dwCopyFlags or COPY_FILE_NO_BUFFERING;
end;
Result:= CopyFileExW(PWideChar(UTF16LongName(Source)), PWideChar(UTF16LongName(Target)), @Progress, ACopyInfo, nil, dwCopyFlags) <> 0;
ACopyInfo.Free;
end;
initialization
FileCopyEx:= @CopyFile;
{$ENDIF}
end.
|
unit eBackupSystemHelpers;
interface
uses Windows;
function GetFolderDate(const iFolder:string):TDateTime;
function FileTimeToDateTime(const iTime:TFileTime):TDateTime;
implementation
uses SysUtils;
function GetFolderDate(const iFolder:string):TDateTime;
var lSearch:TSearchRec;
lOk:dword;
lDate:TFileTime;
begin
lOk := FindFirst(iFolder+'\*.*',$3f,lSearch);
try
if lOk <> 0 then
raise Exception.CreateFmt('Folder "%s" nor found',[iFolder]);
result := FileTimeToDateTime(lSearch.FindData.ftLastWriteTime);
finally
FindClose(lSearch);
end;
end;
function FileTimeToDateTime(const iTime:TFileTime):TDateTime;
var lLocalFileTime: TFileTime;
lFileDate:integer;
begin
FileTimeToLocalFileTime(iTime, lLocalFileTime);
if not FileTimeToDosDateTime(lLocalFileTime, LongRec(lFileDate).Hi, LongRec(lFileDate).Lo) then RaiseLastOsError();
result := FileDateToDateTime(lFileDate);
end;
end.
|
unit testnearestneighborunit;
interface
uses Math, Sysutils, Ap, tsort, nearestneighbor;
function TestNearestNeighbor(Silent : Boolean):Boolean;
function testnearestneighborunit_test_silent():Boolean;
function testnearestneighborunit_test():Boolean;
implementation
procedure Unset2D(var A : TComplex2DArray);forward;
procedure Unset1D(var A : TReal1DArray);forward;
function KDTResultsDifferent(const RefXY : TReal2DArray;
NTotal : AlglibInteger;
const QX : TReal2DArray;
const QXY : TReal2DArray;
const QT : TInteger1DArray;
N : AlglibInteger;
NX : AlglibInteger;
NY : AlglibInteger):Boolean;forward;
function VNorm(const X : TReal1DArray;
N : AlglibInteger;
NormType : AlglibInteger):Double;forward;
procedure TestKDTUniform(const XY : TReal2DArray;
const N : AlglibInteger;
const NX : AlglibInteger;
const NY : AlglibInteger;
const NormType : AlglibInteger;
var KDTErrors : Boolean);forward;
(*************************************************************************
Testing Nearest Neighbor Search
*************************************************************************)
function TestNearestNeighbor(Silent : Boolean):Boolean;
var
XY : TReal2DArray;
I : AlglibInteger;
J : AlglibInteger;
V : Double;
NormType : AlglibInteger;
NX : AlglibInteger;
NY : AlglibInteger;
N : AlglibInteger;
SmallN : AlglibInteger;
LargeN : AlglibInteger;
PassCount : AlglibInteger;
Pass : AlglibInteger;
WasErrors : Boolean;
KDTErrors : Boolean;
begin
KDTErrors := False;
PassCount := 2;
SmallN := 256;
LargeN := 2048;
NY := 3;
//
//
//
Pass:=1;
while Pass<=PassCount do
begin
NormType:=0;
while NormType<=2 do
begin
NX:=1;
while NX<=3 do
begin
//
// Test in hypercube
//
SetLength(XY, LargeN, NX+NY);
I:=0;
while I<=LargeN-1 do
begin
J:=0;
while J<=NX+NY-1 do
begin
XY[I,J] := 10*RandomReal-5;
Inc(J);
end;
Inc(I);
end;
N:=1;
while N<=10 do
begin
TestKDTUniform(XY, N, NX, RandomInteger(NY+1), NormType, KDTErrors);
Inc(N);
end;
TestKDTUniform(XY, LargeN, NX, RandomInteger(NY+1), NormType, KDTErrors);
//
// Test clustered (2*N points, pairs of equal points)
//
SetLength(XY, 2*SmallN, NX+NY);
I:=0;
while I<=SmallN-1 do
begin
J:=0;
while J<=NX+NY-1 do
begin
XY[2*I+0,J] := 10*RandomReal-5;
XY[2*I+1,J] := XY[2*I+0,J];
Inc(J);
end;
Inc(I);
end;
TestKDTUniform(XY, 2*SmallN, NX, RandomInteger(NY+1), NormType, KDTErrors);
//
// Test degenerate case: all points are same except for one
//
SetLength(XY, SmallN, NX+NY);
V := RandomReal;
I:=0;
while I<=SmallN-2 do
begin
J:=0;
while J<=NX+NY-1 do
begin
XY[I,J] := V;
Inc(J);
end;
Inc(I);
end;
J:=0;
while J<=NX+NY-1 do
begin
XY[SmallN-1,J] := 10*RandomReal-5;
Inc(J);
end;
TestKDTUniform(XY, SmallN, NX, RandomInteger(NY+1), NormType, KDTErrors);
Inc(NX);
end;
Inc(NormType);
end;
Inc(Pass);
end;
//
// report
//
WasErrors := KDTErrors;
if not Silent then
begin
Write(Format('TESTING NEAREST NEIGHBOR SEARCH'#13#10'',[]));
Write(Format('* KD TREES: ',[]));
if not KDTErrors then
begin
Write(Format('OK'#13#10'',[]));
end
else
begin
Write(Format('FAILED'#13#10'',[]));
end;
if WasErrors then
begin
Write(Format('TEST FAILED'#13#10'',[]));
end
else
begin
Write(Format('TEST PASSED'#13#10'',[]));
end;
Write(Format(''#13#10''#13#10'',[]));
end;
Result := not WasErrors;
end;
(*************************************************************************
Unsets 2D array.
*************************************************************************)
procedure Unset2D(var A : TComplex2DArray);
begin
SetLength(A, 0+1, 0+1);
A[0,0] := C_Complex(2*RandomReal-1);
end;
(*************************************************************************
Unsets 1D array.
*************************************************************************)
procedure Unset1D(var A : TReal1DArray);
begin
SetLength(A, 0+1);
A[0] := 2*RandomReal-1;
end;
(*************************************************************************
Compare results from different queries:
* X just X-values
* XY X-values and Y-values
* XT X-values and tag values
*************************************************************************)
function KDTResultsDifferent(const RefXY : TReal2DArray;
NTotal : AlglibInteger;
const QX : TReal2DArray;
const QXY : TReal2DArray;
const QT : TInteger1DArray;
N : AlglibInteger;
NX : AlglibInteger;
NY : AlglibInteger):Boolean;
var
I : AlglibInteger;
J : AlglibInteger;
begin
Result := False;
I:=0;
while I<=N-1 do
begin
if (QT[I]<0) or (QT[I]>=NTotal) then
begin
Result := True;
Exit;
end;
J:=0;
while J<=NX-1 do
begin
Result := Result or AP_FP_Neq(QX[I,J],RefXY[QT[I],J]);
Result := Result or AP_FP_Neq(QXY[I,J],RefXY[QT[I],J]);
Inc(J);
end;
J:=0;
while J<=NY-1 do
begin
Result := Result or AP_FP_Neq(QXY[I,NX+J],RefXY[QT[I],NX+J]);
Inc(J);
end;
Inc(I);
end;
end;
(*************************************************************************
Returns norm
*************************************************************************)
function VNorm(const X : TReal1DArray;
N : AlglibInteger;
NormType : AlglibInteger):Double;
var
I : AlglibInteger;
begin
Result := RandomReal;
if NormType=0 then
begin
Result := 0;
I:=0;
while I<=N-1 do
begin
Result := Max(Result, AbsReal(X[I]));
Inc(I);
end;
Exit;
end;
if NormType=1 then
begin
Result := 0;
I:=0;
while I<=N-1 do
begin
Result := Result+AbsReal(X[I]);
Inc(I);
end;
Exit;
end;
if NormType=2 then
begin
Result := 0;
I:=0;
while I<=N-1 do
begin
Result := Result+AP_Sqr(X[I]);
Inc(I);
end;
Result := Sqrt(Result);
Exit;
end;
end;
(*************************************************************************
Testing Nearest Neighbor Search on uniformly distributed hypercube
NormType: 0, 1, 2
D: space dimension
N: points count
*************************************************************************)
procedure TestKDTUniform(const XY : TReal2DArray;
const N : AlglibInteger;
const NX : AlglibInteger;
const NY : AlglibInteger;
const NormType : AlglibInteger;
var KDTErrors : Boolean);
var
ErrTol : Double;
Tags : TInteger1DArray;
PtX : TReal1DArray;
TmpX : TReal1DArray;
TmpB : TBoolean1DArray;
TreeX : KDTree;
TreeXY : KDTree;
TreeXT : KDTree;
QX : TReal2DArray;
QXY : TReal2DArray;
QTags : TInteger1DArray;
QR : TReal1DArray;
KX : AlglibInteger;
KXY : AlglibInteger;
KT : AlglibInteger;
KR : AlglibInteger;
Eps : Double;
I : AlglibInteger;
J : AlglibInteger;
K : AlglibInteger;
Task : AlglibInteger;
IsEqual : Boolean;
R : Double;
Q : AlglibInteger;
QCount : AlglibInteger;
begin
QCount := 10;
//
// Tol - roundoff error tolerance (for '>=' comparisons)
//
ErrTol := 100000*MachineEpsilon;
//
// fill tags
//
SetLength(Tags, N);
I:=0;
while I<=N-1 do
begin
Tags[I] := I;
Inc(I);
end;
//
// build trees
//
KDTreeBuild(XY, N, NX, 0, NormType, TreeX);
KDTreeBuild(XY, N, NX, NY, NormType, TreeXY);
KDTreeBuildTagged(XY, Tags, N, NX, 0, NormType, TreeXT);
//
// allocate arrays
//
SetLength(TmpX, NX);
SetLength(TmpB, N);
SetLength(QX, N, NX);
SetLength(QXY, N, NX+NY);
SetLength(QTags, N);
SetLength(QR, N);
SetLength(PtX, NX);
//
// test general K-NN queries (with self-matches):
// * compare results from different trees (must be equal) and
// check that correct (value,tag) pairs are returned
// * test results from XT tree - let R be radius of query result.
// then all points not in result must be not closer than R.
//
Q:=1;
while Q<=QCount do
begin
//
// Select K: 1..N
//
if AP_FP_Greater(RandomReal,0.5) then
begin
K := 1+RandomInteger(N);
end
else
begin
K := 1;
end;
//
// Select point (either one of the points, or random)
//
if AP_FP_Greater(RandomReal,0.5) then
begin
I := RandomInteger(N);
APVMove(@PtX[0], 0, NX-1, @XY[I][0], 0, NX-1);
end
else
begin
I:=0;
while I<=NX-1 do
begin
PtX[I] := 2*RandomReal-1;
Inc(I);
end;
end;
//
// Test:
// * consistency of results from different queries
// * points in query are IN the R-sphere (or at the boundary),
// and points not in query are outside of the R-sphere (or at the boundary)
// * distances are correct and are ordered
//
KX := KDTreeQueryKNN(TreeX, PtX, K, True);
KXY := KDTreeQueryKNN(TreeXY, PtX, K, True);
KT := KDTreeQueryKNN(TreeXT, PtX, K, True);
if (KX<>K) or (KXY<>K) or (KT<>K) then
begin
KDTErrors := True;
Exit;
end;
KX := 0;
KXY := 0;
KT := 0;
KDTreeQueryResultsX(TreeX, QX, KX);
KDTreeQueryResultsXY(TreeXY, QXY, KXY);
KDTreeQueryResultsTags(TreeXT, QTags, KT);
KDTreeQueryResultsDistances(TreeXT, QR, KR);
if (KX<>K) or (KXY<>K) or (KT<>K) or (KR<>K) then
begin
KDTErrors := True;
Exit;
end;
KDTErrors := KDTErrors or KDTResultsDifferent(XY, N, QX, QXY, QTags, K, NX, NY);
I:=0;
while I<=N-1 do
begin
TmpB[I] := True;
Inc(I);
end;
R := 0;
I:=0;
while I<=K-1 do
begin
TmpB[QTags[I]] := False;
APVMove(@TmpX[0], 0, NX-1, @PtX[0], 0, NX-1);
APVSub(@TmpX[0], 0, NX-1, @QX[I][0], 0, NX-1);
R := Max(R, VNorm(TmpX, NX, NormType));
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
if TmpB[I] then
begin
APVMove(@TmpX[0], 0, NX-1, @PtX[0], 0, NX-1);
APVSub(@TmpX[0], 0, NX-1, @XY[I][0], 0, NX-1);
KDTErrors := KDTErrors or AP_FP_Less(VNorm(TmpX, NX, NormType),R*(1-ErrTol));
end;
Inc(I);
end;
I:=0;
while I<=K-2 do
begin
KDTErrors := KDTErrors or AP_FP_Greater(QR[I],QR[I+1]);
Inc(I);
end;
I:=0;
while I<=K-1 do
begin
APVMove(@TmpX[0], 0, NX-1, @PtX[0], 0, NX-1);
APVSub(@TmpX[0], 0, NX-1, @XY[QTags[I]][0], 0, NX-1);
KDTErrors := KDTErrors or AP_FP_Greater(AbsReal(VNorm(TmpX, NX, NormType)-QR[I]),ErrTol);
Inc(I);
end;
Inc(Q);
end;
//
// test general approximate K-NN queries (with self-matches):
// * compare results from different trees (must be equal) and
// check that correct (value,tag) pairs are returned
// * test results from XT tree - let R be radius of query result.
// then all points not in result must be not closer than R/(1+Eps).
//
Q:=1;
while Q<=QCount do
begin
//
// Select K: 1..N
//
if AP_FP_Greater(RandomReal,0.5) then
begin
K := 1+RandomInteger(N);
end
else
begin
K := 1;
end;
//
// Select Eps
//
Eps := 0.5+RandomReal;
//
// Select point (either one of the points, or random)
//
if AP_FP_Greater(RandomReal,0.5) then
begin
I := RandomInteger(N);
APVMove(@PtX[0], 0, NX-1, @XY[I][0], 0, NX-1);
end
else
begin
I:=0;
while I<=NX-1 do
begin
PtX[I] := 2*RandomReal-1;
Inc(I);
end;
end;
//
// Test:
// * consistency of results from different queries
// * points in query are IN the R-sphere (or at the boundary),
// and points not in query are outside of the R-sphere (or at the boundary)
// * distances are correct and are ordered
//
KX := KDTreeQueryAKNN(TreeX, PtX, K, True, Eps);
KXY := KDTreeQueryAKNN(TreeXY, PtX, K, True, Eps);
KT := KDTreeQueryAKNN(TreeXT, PtX, K, True, Eps);
if (KX<>K) or (KXY<>K) or (KT<>K) then
begin
KDTErrors := True;
Exit;
end;
KX := 0;
KXY := 0;
KT := 0;
KDTreeQueryResultsX(TreeX, QX, KX);
KDTreeQueryResultsXY(TreeXY, QXY, KXY);
KDTreeQueryResultsTags(TreeXT, QTags, KT);
KDTreeQueryResultsDistances(TreeXT, QR, KR);
if (KX<>K) or (KXY<>K) or (KT<>K) or (KR<>K) then
begin
KDTErrors := True;
Exit;
end;
KDTErrors := KDTErrors or KDTResultsDifferent(XY, N, QX, QXY, QTags, K, NX, NY);
I:=0;
while I<=N-1 do
begin
TmpB[I] := True;
Inc(I);
end;
R := 0;
I:=0;
while I<=K-1 do
begin
TmpB[QTags[I]] := False;
APVMove(@TmpX[0], 0, NX-1, @PtX[0], 0, NX-1);
APVSub(@TmpX[0], 0, NX-1, @QX[I][0], 0, NX-1);
R := Max(R, VNorm(TmpX, NX, NormType));
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
if TmpB[I] then
begin
APVMove(@TmpX[0], 0, NX-1, @PtX[0], 0, NX-1);
APVSub(@TmpX[0], 0, NX-1, @XY[I][0], 0, NX-1);
KDTErrors := KDTErrors or AP_FP_Less(VNorm(TmpX, NX, NormType),R*(1-ErrTol)/(1+Eps));
end;
Inc(I);
end;
I:=0;
while I<=K-2 do
begin
KDTErrors := KDTErrors or AP_FP_Greater(QR[I],QR[I+1]);
Inc(I);
end;
I:=0;
while I<=K-1 do
begin
APVMove(@TmpX[0], 0, NX-1, @PtX[0], 0, NX-1);
APVSub(@TmpX[0], 0, NX-1, @XY[QTags[I]][0], 0, NX-1);
KDTErrors := KDTErrors or AP_FP_Greater(AbsReal(VNorm(TmpX, NX, NormType)-QR[I]),ErrTol);
Inc(I);
end;
Inc(Q);
end;
//
// test general R-NN queries (with self-matches):
// * compare results from different trees (must be equal) and
// check that correct (value,tag) pairs are returned
// * test results from XT tree - let R be radius of query result.
// then all points not in result must be not closer than R.
//
Q:=1;
while Q<=QCount do
begin
//
// Select R
//
if AP_FP_Greater(RandomReal,0.3) then
begin
R := Max(RandomReal, MachineEpsilon);
end
else
begin
R := MachineEpsilon;
end;
//
// Select point (either one of the points, or random)
//
if AP_FP_Greater(RandomReal,0.5) then
begin
I := RandomInteger(N);
APVMove(@PtX[0], 0, NX-1, @XY[I][0], 0, NX-1);
end
else
begin
I:=0;
while I<=NX-1 do
begin
PtX[I] := 2*RandomReal-1;
Inc(I);
end;
end;
//
// Test:
// * consistency of results from different queries
// * points in query are IN the R-sphere (or at the boundary),
// and points not in query are outside of the R-sphere (or at the boundary)
// * distances are correct and are ordered
//
KX := KDTreeQueryRNN(TreeX, PtX, R, True);
KXY := KDTreeQueryRNN(TreeXY, PtX, R, True);
KT := KDTreeQueryRNN(TreeXT, PtX, R, True);
if (KXY<>KX) or (KT<>KX) then
begin
KDTErrors := True;
Exit;
end;
KX := 0;
KXY := 0;
KT := 0;
KDTreeQueryResultsX(TreeX, QX, KX);
KDTreeQueryResultsXY(TreeXY, QXY, KXY);
KDTreeQueryResultsTags(TreeXT, QTags, KT);
KDTreeQueryResultsDistances(TreeXT, QR, KR);
if (KXY<>KX) or (KT<>KX) or (KR<>KX) then
begin
KDTErrors := True;
Exit;
end;
KDTErrors := KDTErrors or KDTResultsDifferent(XY, N, QX, QXY, QTags, KX, NX, NY);
I:=0;
while I<=N-1 do
begin
TmpB[I] := True;
Inc(I);
end;
I:=0;
while I<=KX-1 do
begin
TmpB[QTags[I]] := False;
Inc(I);
end;
I:=0;
while I<=N-1 do
begin
APVMove(@TmpX[0], 0, NX-1, @PtX[0], 0, NX-1);
APVSub(@TmpX[0], 0, NX-1, @XY[I][0], 0, NX-1);
if TmpB[I] then
begin
KDTErrors := KDTErrors or AP_FP_Less(VNorm(TmpX, NX, NormType),R*(1-ErrTol));
end
else
begin
KDTErrors := KDTErrors or AP_FP_Greater(VNorm(TmpX, NX, NormType),R*(1+ErrTol));
end;
Inc(I);
end;
I:=0;
while I<=KX-2 do
begin
KDTErrors := KDTErrors or AP_FP_Greater(QR[I],QR[I+1]);
Inc(I);
end;
Inc(Q);
end;
//
// Test self-matching:
// * self-match - nearest neighbor of each point in XY is the point itself
// * no self-match - nearest neighbor is NOT the point itself
//
if N>1 then
begin
//
// test for N=1 have non-general form, but it is not really needed
//
Task:=0;
while Task<=1 do
begin
I:=0;
while I<=N-1 do
begin
APVMove(@PtX[0], 0, NX-1, @XY[I][0], 0, NX-1);
KX := KDTreeQueryKNN(TreeX, PtX, 1, Task=0);
KDTreeQueryResultsX(TreeX, QX, KX);
if KX<>1 then
begin
KDTErrors := True;
Exit;
end;
IsEqual := True;
J:=0;
while J<=NX-1 do
begin
IsEqual := IsEqual and AP_FP_Eq(QX[0,J],PtX[J]);
Inc(J);
end;
if Task=0 then
begin
KDTErrors := KDTErrors or not IsEqual;
end
else
begin
KDTErrors := KDTErrors or IsEqual;
end;
Inc(I);
end;
Inc(Task);
end;
end;
end;
(*************************************************************************
Silent unit test
*************************************************************************)
function testnearestneighborunit_test_silent():Boolean;
begin
Result := TestNearestNeighbor(True);
end;
(*************************************************************************
Unit test
*************************************************************************)
function testnearestneighborunit_test():Boolean;
begin
Result := TestNearestNeighbor(False);
end;
end. |
unit uFrmAutoEntity;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, ImgList, ComCtrls, AdvMemo, ExtCtrls, ToolWin, DB, ADODB,
IniFiles, StdCtrls;
type
TFrmAutoEntity = class(TForm)
tlb1: TToolBar;
spl1: TSplitter;
tvTables: TTreeView;
btn2: TToolButton;
btnConnect: TToolButton;
btnCloseConnect: TToolButton;
ilList: TImageList;
btnExit: TToolButton;
ConMain: TADOConnection;
mmo1: TMemo;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure btnExitClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure btnConnectClick(Sender: TObject);
procedure tvTablesClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
private
FConfig: TMemIniFile;
FAppPath: string;
procedure LoadDBTables;
public
{ Public declarations }
end;
var
FrmAutoEntity: TFrmAutoEntity;
implementation
{$R *.dfm}
procedure ShowMsg(const AText: string; const ACaption: string = '提示');
begin
Application.MessageBox(PWideChar(AText), PWideChar(ACaption),
MB_ICONINFORMATION + MB_OK);
end;
function ShowConfirm(const AText: string; const ACaption: string = '确认'): Boolean;
begin
Result := Application.MessageBox(PWideChar(AText), PWideChar(ACaption),
MB_ICONINFORMATION + MB_OKCANCEL) = IDOK;
end;
procedure TFrmAutoEntity.btnConnectClick(Sender: TObject);
var
lLinkStr: string;
begin
lLinkStr := PromptDataSource(Self.Handle, ConMain.ConnectionString);
if ConMain.Connected then
ConMain.Connected := False;
ConMain.ConnectionString := lLinkStr;
try
ConMain.Connected := True;
FConfig.WriteString('DBLink', 'ConStr', lLinkStr);
FConfig.UpdateFile;
LoadDBTables;
except
on E: Exception do
begin
ShowMessage('连接失败：' + E.Message);
end;
end;
end;
procedure TFrmAutoEntity.btnExitClick(Sender: TObject);
begin
Close;
end;
procedure TFrmAutoEntity.FormClose(Sender: TObject; var Action: TCloseAction);
begin
ConMain.Connected := False;
end;
procedure TFrmAutoEntity.FormCreate(Sender: TObject);
begin
FAppPath := ExtractFilePath(ParamStr(0));
Self.Width := 800;
Self.Height := 600;
Self.WindowState := wsMaximized;
FConfig := TMemIniFile.Create(FAppPath + 'Config.ini');
end;
procedure TFrmAutoEntity.FormDestroy(Sender: TObject);
begin
FConfig.Free;
end;
procedure TFrmAutoEntity.FormShow(Sender: TObject);
var
lConStr: string;
begin
lConStr := FConfig.ReadString('DBLink', 'ConStr', '');
if lConStr <> '' then
begin
ConMain.Connected := False;
ConMain.ConnectionString := lConStr;
try
ConMain.Connected := True;
LoadDBTables;
except
ShowMsg('数据库连接失败！');
end;
end;
end;
procedure TFrmAutoEntity.LoadDBTables;
var
lDBNode: TTreeNode;
lList: TStrings;
I: Integer;
begin
if not ConMain.Connected then Exit;
tvTables.Items.Clear;
lDBNode := tvTables.Items.Add(nil, ConMain.DefaultDatabase);
lList := TStringList.Create;
try
ConMain.GetTableNames(lList);
for I := 0 to lList.Count - 1 do
tvTables.Items.AddChild(lDBNode, UpperCase(lList[I]));
tvTables.FullExpand;
finally
lList.Free;
end;
end;
procedure TFrmAutoEntity.tvTablesClick(Sender: TObject);
begin
mmo1.Lines.Clear;
if tvTables.Selected = nil then Exit;
if tvTables.Selected.Level = 0 then Exit;
end;
end.
|
unit PascalCoin.RPC.Node;
interface
uses System.Generics.Collections,
PascalCoin.Utils.Interfaces, PascalCoin.RPC.Interfaces, System.JSON;
type
TPascalCoinNodeStatus = class(TInterfacedObject, IPascalCoinNodeStatus)
private
FReady: Boolean;
FReady_S: String;
FStatus_S: String;
FPort: Integer;
FLocked: Boolean;
FTimeStamp: Integer;
FVersion: String;
FNetProtocol: IPascalCoinNetProtocol;
FBlocks: Integer;
FNetStats: IPascalNetStats;
FNdeServers: IPascalCoinList<IPascalCoinServer>;
FSBH: String;
FPOW: String;
FOpenSSL: String;
procedure LoadFromJSON(const Value: TJSONValue);
protected
function GetReady: Boolean;
procedure SetReady(Const Value: Boolean);
function GetReady_S: String;
procedure SetReady_S(Const Value: String);
function GetStatus_S: String;
procedure SetStatus_S(Const Value: String);
function GetPort: Integer;
procedure SetPort(Const Value: Integer);
function GetLocked: Boolean;
procedure SetLocked(Const Value: Boolean);
function GetTimeStamp: Integer;
procedure SetTimeStamp(Const Value: Integer);
function GetVersion: String;
procedure SetVersion(Const Value: String);
function GetNetProtocol: IPascalCoinNetProtocol;
function GetBlocks: Integer;
procedure SetBlocks(Const Value: Integer);
function GetNetStats: IPascalNetStats;
function GetNodeServers: IPascalCoinList<IPascalCoinServer>;
function GetSBH: String;
procedure SetSBH(const Value: String);
function GetPOW: String;
procedure SetPOW(const Value: String);
function GetOpenSSL: String;
procedure SetOpenSSL(const Value: String);
function GetTimeStampAsDateTime: TDateTime;
procedure SetTimeStampAsDateTime(const Value: TDateTime);
public
constructor Create(const AJSON: TJSONValue);
end;
TNetProtocol = class(TInterfacedObject, IPascalCoinNetProtocol)
private
FVer: Integer;
FVer_A: Integer;
protected
function GetVer: Integer;
procedure SetVer(const Value: Integer);
function GetVer_A: Integer;
procedure SetVer_A(const Value: Integer);
public
end;
TPascalCoinNetStats = class(TInterfacedObject, IPascalNetStats)
private
FActive: Integer;
FClients: Integer;
FServers: Integer;
FServers_t: Integer;
FTotal: Integer;
FTClients: Integer;
FTServers: Integer;
FBReceived: Integer;
FBSend: Integer;
protected
function GetActive: Integer;
procedure SetActive(const Value: Integer);
function GetClients: Integer;
procedure SetClients(const Value: Integer);
function GetServers: Integer;
procedure SetServers(const Value: Integer);
function GetServers_t: Integer;
procedure SetServers_t(const Value: Integer);
function GetTotal: Integer;
procedure SetTotal(const Value: Integer);
function GetTClients: Integer;
procedure SetTClients(const Value: Integer);
function GetTServers: Integer;
procedure SetTServers(const Value: Integer);
function GetBReceived: Integer;
procedure SetBReceived(const Value: Integer);
function GetBSend: Integer;
procedure SetBSend(const Value: Integer);
public
end;
TPascalCoinServer = class(TInterfacedObject, IPascalCoinServer)
private
FIP: String;
FPort: Integer;
FLastCon: Integer;
FAttempts: Integer;
protected
function GetIP: String;
procedure SetIP(const Value: String);
function GetPort: Integer;
procedure SetPort(const Value: Integer);
function GetLastCon: Integer;
procedure SetLastCon(const Value: Integer);
function GetAttempts: Integer;
procedure SetAttempts(const Value: Integer);
function GetLastConAsDateTime: TDateTime;
procedure SetLastConAsDateTime(const Value: TDateTime);
public
end;
implementation
uses System.DateUtils, Rest.JSON, PascalCoin.Utils.Classes;
{ TPascalCoinNodeStatus }
constructor TPascalCoinNodeStatus.Create(const AJSON: TJSONValue);
begin
inherited Create;
FNdeServers := TPascalCoinList<IPascalCoinServer>.Create;
if AJSON <> nil then
LoadFromJSON(AJSON);
end;
function TPascalCoinNodeStatus.GetBlocks: Integer;
begin
result := FBlocks;
end;
function TPascalCoinNodeStatus.GetLocked: Boolean;
begin
result := FLocked;
end;
function TPascalCoinNodeStatus.GetNodeServers
: IPascalCoinList<IPascalCoinServer>;
begin
result := FNdeServers;
end;
function TPascalCoinNodeStatus.GetNetProtocol: IPascalCoinNetProtocol;
begin
if FNetProtocol = nil then
FNetProtocol := TNetProtocol.Create;
result := FNetProtocol;
end;
function TPascalCoinNodeStatus.GetNetStats: IPascalNetStats;
begin
result := FNetStats;
end;
function TPascalCoinNodeStatus.GetOpenSSL: String;
begin
result := FOpenSSL;
end;
function TPascalCoinNodeStatus.GetPort: Integer;
begin
result := FPort;
end;
function TPascalCoinNodeStatus.GetPOW: String;
begin
result := FPOW;
end;
function TPascalCoinNodeStatus.GetReady: Boolean;
begin
result := FReady;
end;
function TPascalCoinNodeStatus.GetReady_S: String;
begin
result := FReady_S;
end;
function TPascalCoinNodeStatus.GetSBH: String;
begin
result := FSBH;
end;
function TPascalCoinNodeStatus.GetStatus_S: String;
begin
result := FStatus_S;
end;
function TPascalCoinNodeStatus.GetTimeStamp: Integer;
begin
result := FTimeStamp;
end;
function TPascalCoinNodeStatus.GetTimeStampAsDateTime: TDateTime;
begin
result := UnixToDateTime(FTimeStamp);
end;
function TPascalCoinNodeStatus.GetVersion: String;
begin
result := FVersion;
end;
procedure TPascalCoinNodeStatus.LoadFromJSON(const Value: TJSONValue);
var
lObj, sObj: TJSONObject;
lArr: TJSONArray;
lJV: TJSONValue;
lServer: IPascalCoinServer;
begin
lObj := (Value as TJSONObject);
TJSON.JSONToObject(Self, lObj);
sObj := lObj.GetValue('netprotocol') as TJSONObject;
FNetProtocol := TJSON.JSONToObject<TNetProtocol>(sObj);
sObj := lObj.GetValue('netstats') as TJSONObject;
FNetStats := TJSON.JSONToObject<TPascalCoinNetStats>(sObj);
lArr := lObj.GetValue('nodeservers') as TJSONArray;
if Assigned(lArr) and (lArr.Count > 0) then
begin
for lJV in lArr do
begin
lServer := TJSON.JSONToObject<TPascalCoinServer>(lJV as TJSONObject);
FNdeServers.Add(lServer)
end;
end;
end;
procedure TPascalCoinNodeStatus.SetBlocks(const Value: Integer);
begin
FBlocks := Value;
end;
procedure TPascalCoinNodeStatus.SetLocked(const Value: Boolean);
begin
FLocked := Value;
end;
procedure TPascalCoinNodeStatus.SetOpenSSL(const Value: String);
begin
FOpenSSL := Value;
end;
procedure TPascalCoinNodeStatus.SetPort(const Value: Integer);
begin
FPort := Value;
end;
procedure TPascalCoinNodeStatus.SetPOW(const Value: String);
begin
FPOW := Value;
end;
procedure TPascalCoinNodeStatus.SetReady(const Value: Boolean);
begin
FReady := Value;
end;
procedure TPascalCoinNodeStatus.SetReady_S(const Value: String);
begin
FReady_S := Value;
end;
procedure TPascalCoinNodeStatus.SetSBH(const Value: String);
begin
FSBH := Value;
end;
procedure TPascalCoinNodeStatus.SetStatus_S(const Value: String);
begin
FStatus_S := Value;
end;
procedure TPascalCoinNodeStatus.SetTimeStamp(const Value: Integer);
begin
FTimeStamp := Value;
end;
procedure TPascalCoinNodeStatus.SetTimeStampAsDateTime(const Value: TDateTime);
begin
FTimeStamp := DateTimeToUnix(Value);
end;
procedure TPascalCoinNodeStatus.SetVersion(const Value: String);
begin
FVersion := Value;
end;
{ TNetProtocol }
function TNetProtocol.GetVer: Integer;
begin
result := FVer;
end;
function TNetProtocol.GetVer_A: Integer;
begin
result := FVer_A;
end;
procedure TNetProtocol.SetVer(const Value: Integer);
begin
FVer := Value;
end;
procedure TNetProtocol.SetVer_A(const Value: Integer);
begin
FVer_A := Value;
end;
{ TPascalCoinServer }
function TPascalCoinServer.GetAttempts: Integer;
begin
result := FAttempts;
end;
function TPascalCoinServer.GetIP: String;
begin
result := FIP;
end;
function TPascalCoinServer.GetLastCon: Integer;
begin
result := FLastCon;
end;
function TPascalCoinServer.GetLastConAsDateTime: TDateTime;
begin
result := UnixToDateTime(FLastCon);
end;
function TPascalCoinServer.GetPort: Integer;
begin
result := FPort;
end;
procedure TPascalCoinServer.SetAttempts(const Value: Integer);
begin
FAttempts := Value;
end;
procedure TPascalCoinServer.SetIP(const Value: String);
begin
FIP := Value;
end;
procedure TPascalCoinServer.SetLastCon(const Value: Integer);
begin
FLastCon := Value;
end;
procedure TPascalCoinServer.SetLastConAsDateTime(const Value: TDateTime);
begin
FLastCon := DateTimeToUnix(Value);
end;
procedure TPascalCoinServer.SetPort(const Value: Integer);
begin
FPort := Value;
end;
{ TPascalCoinNetStats }
function TPascalCoinNetStats.GetActive: Integer;
begin
result := FActive;
end;
function TPascalCoinNetStats.GetBReceived: Integer;
begin
result := FBReceived;
end;
function TPascalCoinNetStats.GetBSend: Integer;
begin
result := FBSend;
end;
function TPascalCoinNetStats.GetClients: Integer;
begin
result := FClients;
end;
function TPascalCoinNetStats.GetServers: Integer;
begin
result := FServers;
end;
function TPascalCoinNetStats.GetServers_t: Integer;
begin
result := FServers_t;
end;
function TPascalCoinNetStats.GetTClients: Integer;
begin
result := FTClients;
end;
function TPascalCoinNetStats.GetTotal: Integer;
begin
result := FTotal;
end;
function TPascalCoinNetStats.GetTServers: Integer;
begin
result := FTServers;
end;
procedure TPascalCoinNetStats.SetActive(const Value: Integer);
begin
FActive := Value;
end;
procedure TPascalCoinNetStats.SetBReceived(const Value: Integer);
begin
FBReceived := Value;
end;
procedure TPascalCoinNetStats.SetBSend(const Value: Integer);
begin
FBSend := Value;
end;
procedure TPascalCoinNetStats.SetClients(const Value: Integer);
begin
FClients := Value;
end;
procedure TPascalCoinNetStats.SetServers(const Value: Integer);
begin
FServers := Value;
end;
procedure TPascalCoinNetStats.SetServers_t(const Value: Integer);
begin
FServers_t := Value;
end;
procedure TPascalCoinNetStats.SetTClients(const Value: Integer);
begin
FTClients := Value;
end;
procedure TPascalCoinNetStats.SetTotal(const Value: Integer);
begin
FTotal := Value;
end;
procedure TPascalCoinNetStats.SetTServers(const Value: Integer);
begin
FTServers := Value;
end;
end.
|
{*******************************************************}
{ }
{ Delphi Visual Component Library }
{ }
{ Copyright(c) 1995-2018 Embarcadero Technologies, Inc. }
{ All rights reserved }
{ }
{*******************************************************}
unit MaskText;
interface
uses Windows, Classes, Graphics, Forms, Controls, StdCtrls, Buttons, DesignIntf,
DesignEditors, Mask;
type
{ TMaskTextProperty
Property editor for the Caption and Text properties. Removes auto-update
feature of normal text property to allow validation. }
TMaskTextProperty = class(TStringProperty)
public
function GetAttributes: TPropertyAttributes; override;
procedure Edit; override;
end;
type
TMaskTextForm = class(TForm)
Label3: TLabel;
TestEdit: TMaskEdit;
Label1: TLabel;
EditMask: TLabel;
OKButton: TButton;
CancelButton: TButton;
HelpButton: TButton;
procedure FormCreate(Sender: TObject);
procedure HelpButtonClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
MaskTextForm: TMaskTextForm;
function EditMaskText(const Mask: string; var MaskText: string): Boolean;
implementation
uses SysUtils, LibHelp;
{$R *.dfm}
function EditMaskText(const Mask: string; var MaskText: string): Boolean;
var
Frm : TMaskTextForm;
begin
Frm := TMaskTextForm.Create(Application);
try
Frm.TestEdit.EditMask := Mask;
Frm.TestEdit.Text := MaskText;
Frm.TestEdit.SelectAll;
if Mask <> '' then Frm.EditMask.Caption := Mask;
Result := Frm.ShowModal = mrOk;
if Result then MaskText := Frm.TestEdit.Text;
finally
Frm.Free;
end;
end;
{ TMaskTextForm }
procedure TMaskTextForm.FormCreate(Sender: TObject);
begin
HelpContext := hcDMaskedTextEditor;
end;
procedure TMaskTextForm.HelpButtonClick(Sender: TObject);
begin
Application.HelpContext(HelpContext);
end;
{ TMaskTextProperty }
function TMaskTextProperty.GetAttributes: TPropertyAttributes;
begin
Result := [paDialog];
end;
procedure TMaskTextProperty.Edit;
var
Ed: TMaskEdit;
Text: string;
begin
Ed := TMaskEdit(GetComponent(0));
Text := Ed.Text;
if EditMaskText(Ed.EditMask, Text) and (Text <> Ed.Text) then
begin
Ed.Text := Text;
Modified;
end;
end;
end.
|
unit ccdatasetutils;
{
Dataset Utils - Delphi / Lazarus Helper
------------------------------------
Author : Tigor M Manurung
Email : tigor@tigorworks.com
Helper for TDataset :)
}
interface
uses
classes,sysutils,db;
type
{$IFNDEF fpc}
TDatasetLoopProc = reference to procedure();
TDatasetLoopProcField = reference to procedure(AField: TFields);
{$ENDIF}
TCCDatasetHelper = class helper for TDataSet
function ToJson: string;
procedure SaveToCSV(const AFilename: string);
function NotEof: Boolean;
{$IFNDEF fpc}
procedure WhileNotEof(OnLoop: TDatasetLoopProc ; MoveFirst: boolean = false);overload;
procedure WhileNotEof(OnLoop: TDatasetLoopProcField ; MoveFirst: boolean = false);overload;
{$ENDIF}
end;
implementation
{ TCCDatasetHelper }
procedure TCCDatasetHelper.SaveToCSV(const AFilename: string);
var
c: integer;
header,row: string;
rows: TStringList;
begin
First;
rows := TStringList.Create;
try
for c := 0 to Fields.Count - 1 do
header := header + Fields[c].FieldName + ',';
System.Delete(header,Length(header),1);
rows.Add(header);
while not Eof do
begin
row := '';
for c := 0 to Fields.Count - 1 do
begin
case Fields[c].DataType of
ftDate: row := row + '"' + FormatDateTime('yyyy-mm-dd',Fields[c].AsDateTime) + '",';
ftDateTime: row := row + '"' + FormatDateTime('yyyy-mm-dd hh:mm:ss',Fields[c].AsDateTime) + '",';
else
row := row + '"' + Fields[c].AsString + '",';
end;
end;
System.Delete(row,Length(row),1);
rows.Add(row);
Next;
end;
finally
if Trim(rows.Text) <> '' then
rows.SaveToFile(AFilename);
FreeAndNil(rows);
end;
end;
function TCCDatasetHelper.ToJson: string;
var
c: integer;
jsonarray,jsonobject,_temp,row,rows: string;
begin
jsonarray := '[%s]';
jsonobject := '"%s":%s';
First;
rows := '';
while not Eof do
begin
row := '';
for c := 0 to Fields.Count - 1 do
begin
case Fields[c].DataType of
ftLargeint,ftInteger,ftSmallint,ftWord: _temp := Format(jsonobject,[Fields[c].FieldName,Fields[c].AsString]);
ftBoolean:
begin
if Fields[c].AsBoolean then
_temp := Format(jsonobject,[Fields[c].FieldName,Fields[c],'true'])
else
_temp := Format(jsonobject,[Fields[c].FieldName,Fields[c],'false'])
end;
ftDate: _temp := Format(jsonobject,[Fields[c].FieldName,'"' + FormatDateTime('yyyy-mm-dd',Fields[c].AsDateTime) + '"']);
ftDateTime: _temp := Format(jsonobject,[Fields[c].FieldName,'"' + FormatDateTime('yyyy-mm-dd hh:mm:ss',Fields[c].AsDateTime) + '"']);
else
_temp := Format(jsonobject,[Fields[c].FieldName,format('"%s"',[Fields[c].AsString])])
end;
row := row + _temp + ',';
end;
System.Delete(row,Length(row),1);
rows := Format('%s{%s},',[rows,row]);
Next;
end;
System.Delete(rows,Length(rows),1);
rows := Format(jsonarray,[rows]);
result := rows;
end;
procedure TCCDatasetHelper.WhileNotEof(OnLoop: TDatasetLoopProcField ; MoveFirst: boolean = false);
var
bkCurrent: TBookmark;
begin
bkCurrent := Bookmark;
if MoveFirst then
First;
while NotEof do
begin
OnLoop(Fields);
Next;
end;
self.Bookmark := bkCurrent
end;
procedure TCCDatasetHelper.WhileNotEof(OnLoop: TDatasetLoopProc ; MoveFirst: boolean = false);
var
bkCurrent: TBookmark;
begin
bkCurrent := Bookmark;
if MoveFirst then
First;
while NotEof do
begin
OnLoop();
Next;
end;
self.Bookmark := bkCurrent
end;
function TCCDatasetHelper.NotEof: Boolean;
begin
Result := not Eof;
end;
end.
//love u my little angle caca :) :*
|
unit FlowTestForm;
interface
// running this program raises an exception by design
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.StdCtrls,
FMX.Layouts, FMX.Memo, FMX.Controls.Presentation, FMX.ScrollBox;
type
TForm1 = class(TForm)
Memo1: TMemo;
Button1: TButton;
Button2: TButton;
Button3: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
private
{ Private declarations }
public
procedure Show (const msg: string);
end;
var
Form1: TForm1;
implementation
{$R *.fmx}
procedure TForm1.Button1Click(Sender: TObject);
var
S: string;
I: Integer;
Found: Boolean;
begin
S := 'Hello World';
Found := False;
for I := Low (S) to High (S) do
if (S[I]) = 'o' then
Found := True;
Show ('Found : ' + BoolToStr (Found, True));
end;
procedure TForm1.Button2Click(Sender: TObject);
var
S: string;
I: Integer;
Found: Boolean;
begin
S := 'Hello World';
Found := False;
I := Low (S);
while not Found and (I <= High(S)) do
begin
if (S[I]) = 'o' then
Found := True;
Inc (I);
end;
Show ('Found : ' + BoolToStr (Found, True));
end;
procedure TForm1.Button3Click(Sender: TObject);
var
S: string;
I: Integer;
Found: Boolean;
begin
S := 'Hello World';
Found := False;
for I := Low (S) to High (S) do
if (S[I]) = 'o' then
begin
Found := True;
Break; // jumps out of the for loop
end;
Show ('Found : ' + BoolToStr (Found, True));
end;
procedure TForm1.Show(const Msg: string);
begin
Memo1.Lines.Add(Msg);
end;
end.
|
unit IdComponent;
interface
uses
Classes,
IdAntiFreezeBase, IdBaseComponent, IdGlobal, IdStack, IdResourceStrings,
SysUtils;
type
TIdStatus = (hsResolving,
hsConnecting,
hsConnected,
hsDisconnecting,
hsDisconnected,
hsText);
const
IdStati: array[TIdStatus] of string = (
RSStatusResolving,
RSStatusConnecting,
RSStatusConnected,
RSStatusDisconnecting,
RSStatusDisconnected,
RSStatusText);
type
TIdStatusEvent = procedure(axSender: TObject; const axStatus: TIdStatus;
const asStatusText: string) of object;
TWorkMode = (wmRead, wmWrite);
TWorkInfo = record
Current: Integer;
Max: Integer;
Level: Integer;
end;
TWorkBeginEvent = procedure(Sender: TObject; AWorkMode: TWorkMode;
const AWorkCountMax: Integer) of object;
TWorkEndEvent = procedure(Sender: TObject; AWorkMode: TWorkMode) of object;
TWorkEvent = procedure(Sender: TObject; AWorkMode: TWorkMode; const
AWorkCount: Integer)
of object;
TIdComponent = class(TIdBaseComponent)
protected
FOnStatus: TIdStatusEvent;
FOnWork: TWorkEvent;
FOnWorkBegin: TWorkBeginEvent;
FOnWorkEnd: TWorkEndEvent;
FWorkInfos: array[TWorkMode] of TWorkInfo;
procedure DoStatus(axStatus: TIdStatus); overload;
procedure DoStatus(axStatus: TIdStatus; const aaArgs: array of const);
overload;
function GetLocalName: string;
property OnWork: TWorkEvent read FOnWork write FOnWork;
property OnWorkBegin: TWorkBeginEvent read FOnWorkBegin write FOnWorkBegin;
property OnWorkEnd: TWorkEndEvent read FOnWorkEnd write FOnWorkEnd;
public
procedure BeginWork(AWorkMode: TWorkMode; const ASize: Integer = 0);
virtual;
constructor Create(axOwner: TComponent); override;
destructor Destroy; override;
procedure DoWork(AWorkMode: TWorkMode; const ACount: Integer); virtual;
procedure EndWork(AWorkMode: TWorkMode); virtual;
property LocalName: string read GetLocalName;
published
property OnStatus: TIdStatusEvent read FOnStatus write FOnStatus;
end;
implementation
var
gnInstanceCount: Integer = 0;
constructor TIdComponent.Create(axOwner: TComponent);
begin
inherited;
if GStack = nil then
begin
GStack := TIdStack.CreateStack;
end;
Inc(gnInstanceCount);
end;
destructor TIdComponent.Destroy;
begin
Dec(gnInstanceCount);
if gnInstanceCount = 0 then
begin
GStack.free;
GStack := nil;
end;
inherited;
end;
procedure TIdComponent.DoStatus(axStatus: TIdStatus);
begin
DoStatus(axStatus, []);
end;
procedure TIdComponent.DoStatus(axStatus: TIdStatus; const aaArgs: array of
const);
begin
if assigned(OnStatus) then
begin
OnStatus(Self, axStatus, Format(IdStati[axStatus], aaArgs));
end;
end;
function TIdComponent.GetLocalName: string;
begin
result := GStack.WSGetHostName;
end;
procedure TIdComponent.BeginWork(AWorkMode: TWorkMode; const ASize: Integer =
0);
begin
Inc(FWorkInfos[AWorkMode].Level);
if FWorkInfos[AWorkMode].Level = 1 then
begin
FWorkInfos[AWorkMode].Max := ASize;
FWorkInfos[AWorkMode].Current := 0;
if assigned(OnWorkBegin) then
begin
OnWorkBegin(Self, AWorkMode, ASize);
end;
end;
end;
procedure TIdComponent.DoWork(AWorkMode: TWorkMode; const ACount: Integer);
begin
if FWorkInfos[AWorkMode].Level > 0 then
begin
Inc(FWorkInfos[AWorkMode].Current, ACount);
if assigned(OnWork) then
begin
OnWork(Self, AWorkMode, FWorkInfos[AWorkMode].Current);
end;
end;
end;
procedure TIdComponent.EndWork(AWorkMode: TWorkMode);
begin
if FWorkInfos[AWorkMode].Level = 1 then
begin
if assigned(OnWorkEnd) then
begin
OnWorkEnd(Self, AWorkMode);
end;
end;
Dec(FWorkInfos[AWorkMode].Level);
end;
end.
|
unit LoanAssessmentDetail;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, BasePopupDetail, Data.DB, Vcl.Grids,
Vcl.DBGrids, RzDBGrid, RzDBEdit, Vcl.StdCtrls, Vcl.Mask, RzEdit, RzButton,
RzTabs, RzLabel, Vcl.Imaging.pngimage, Vcl.ExtCtrls,
RzPanel, RzGrids, FinInfo, MonthlyExpense, Vcl.DBCtrls, RzDBCmbo;
type
TfrmLoanAssessmentDetail = class(TfrmBasePopupDetail)
dteDateAssessed: TRzDBDateTimeEdit;
edRecAmount: TRzDBNumericEdit;
pcAssessment: TRzPageControl;
tsFinInfo: TRzTabSheet;
tsMonExp: TRzTabSheet;
grFinInfo: TRzStringGrid;
grMonExp: TRzStringGrid;
urlAppliedAmount: TRzURLLabel;
mmRemarks: TRzDBMemo;
pnlAdd: TRzPanel;
btnAdd: TRzShapeButton;
pnlRemoveComaker: TRzPanel;
btnRemove: TRzShapeButton;
RzDBMemo1: TRzDBMemo;
RzDBMemo2: TRzDBMemo;
RzDBMemo3: TRzDBMemo;
RzDBMemo4: TRzDBMemo;
RzDBMemo5: TRzDBMemo;
dbluRecommendation: TRzDBLookupComboBox;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Label7: TLabel;
Label8: TLabel;
Label9: TLabel;
Label10: TLabel;
procedure FormShow(Sender: TObject);
procedure grFinInfoDblClick(Sender: TObject);
procedure grMonExpDblClick(Sender: TObject);
procedure urlAppliedAmountClick(Sender: TObject);
procedure btnAddClick(Sender: TObject);
procedure btnRemoveClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure dbluRecommendationClick(Sender: TObject);
private
{ Private declarations }
procedure AddFinancialInfo;
procedure AddMonthlyExpense;
procedure PopulateFinInfo;
procedure PopulateMonthlyExpense;
procedure AddRow(fin: TFinInfo);
procedure AddRowExp(exp: TMonthlyExpense);
procedure ModifyRemoveExp(const remove: boolean = false);
procedure ModifyRemove(const remove: boolean = false);
procedure ClearRow(grid: TRzStringGrid; const row: integer);
public
{ Public declarations }
protected
procedure Save; override;
procedure Cancel; override;
procedure BindToObject; override;
function ValidEntry: boolean; override;
end;
var
frmLoanAssessmentDetail: TfrmLoanAssessmentDetail;
implementation
{$R *.dfm}
uses
FinInfoDetail, MonthlyExpenseDetail, Loan, LoanData, DecisionBox, FormsUtil,
IFinanceDialogs, LoansAuxData, Assessment;
procedure TfrmLoanAssessmentDetail.ClearRow(grid: TRzStringGrid; const row: Integer);
var
rw, cl: integer;
begin
// move up all rows
for rw := row + 1 to grid.RowCount - 1 do
begin
for cl := 0 to grid.ColCount - 1 do
grid.Cells[cl,rw-1] := grid.Cells[cl,rw];
if Assigned(grid.Objects[0,rw]) then grid.Objects[0,rw-1] := grid.Objects[0,rw];
end;
// decrease row count
grid.RowCount := grid.RowCount - 1;
end;
procedure TfrmLoanAssessmentDetail.dbluRecommendationClick(Sender: TObject);
begin
inherited;
urlAppliedAmount.Enabled := ln.Assessment.Recommendation = rcApprove;
edRecAmount.Enabled := ln.Assessment.Recommendation = rcApprove;
if ln.Assessment.Recommendation = rcReject then edRecAmount.Clear;
end;
procedure TfrmLoanAssessmentDetail.ModifyRemove(const remove: boolean);
const
CONF = 'Are you sure you want to remove the selected financial information?';
var
r: integer;
compId: string;
begin
inherited;
with dmLoan.dstFinInfo, grFinInfo do
begin
if not Assigned(Objects[0,Row]) then Exit;
r := Row;
compId := (Objects[0,r] as TFinInfo).CompanyId;
// locate the record in the dataset
Locate('comp_id',compId,[]);
end;
if not remove then
begin
with TfrmFinInfoDetail.Create(self) do
begin
ShowModal;
// update row
if ModalResult = mrOk then
begin
grFinInfo.Cells[0,r] := ln.FinancialInfo[r-1].CompanyName;
grFinInfo.Cells[1,r] := ln.FinancialInfo[r-1].Monthly;
grFinInfo.Cells[2,r] := ln.FinancialInfo[r-1].Balance;
grFinInfo.Objects[0,r] := ln.FinancialInfo[r-1];
end;
Free;
end;
end
else
begin
with TfrmDecisionBox.Create(nil,CONF) do
begin
try
ShowModal;
if ModalResult = mrYes then
begin
ln.RemoveFinancialInfo(compId);
ClearRow(grFinInfo,r);
end;
Free;
except
on e: Exception do
ShowErrorBox(e.Message);
end;
end;
end;
end;
procedure TfrmLoanAssessmentDetail.ModifyRemoveExp(const remove: boolean);
const
CONF = 'Are you sure you want to remove the selected expense?';
var
r: integer;
expType: string;
begin
inherited;
with dmLoan.dstMonExp, grMonExp do
begin
if not Assigned(Objects[0,Row]) then Exit;
r := Row;
expType := (Objects[0,Row] as TMonthlyExpense).ExpenseType;
Locate('exp_type',expType,[]);
end;
if not remove then
begin
with TfrmMonthlyExpDetail.Create(self) do
begin
ShowModal;
// update row
if ModalResult = mrOk then
begin
grMonExp.Cells[0,r] := ln.MonthlyExpense[r-1].ExpenseName;
grMonExp.Cells[1,r] := ln.MonthlyExpense[r-1].ExpenseAmount;
grMonExp.Objects[0,r] := ln.MonthlyExpense[r-1];
end;
Free;
end;
end
else
begin
with TfrmDecisionBox.Create(nil,CONF) do
begin
try
ShowModal;
if ModalResult = mrYes then
begin
ln.RemoveMonthlyExpense(expType);
ClearRow(grMonExp,r);
end;
Free;
except
on e: Exception do
ShowErrorBox(e.Message);
end;
end;
end;
end;
procedure TfrmLoanAssessmentDetail.AddRow(fin: TFinInfo);
var
r: integer;
begin
with grFinInfo do
begin
RowCount := RowCount + 1;
r := RowCount - 2;
Cells[0,r] := fin.CompanyName;
Cells[1,r] := fin.Monthly;
Cells[2,r] := fin.Balance;
Objects[0,r] := fin;
end;
end;
procedure TfrmLoanAssessmentDetail.AddRowExp(exp: TMonthlyExpense);
var
r: integer;
begin
with grMonExp do
begin
RowCount := RowCount + 1;
r := RowCount - 2;
Cells[0,r] := exp.ExpenseName;
Cells[1,r] := exp.ExpenseAmount;
Objects[0,r] := exp;
end;
end;
procedure TfrmLoanAssessmentDetail.BindToObject;
begin
inherited;
end;
procedure TfrmLoanAssessmentDetail.PopulateFinInfo;
var
i, cnt: integer;
begin
with grFinInfo do
begin
RowCount := RowCount + 1;
FixedRows := 1;
// headers
Cells[0,0] := 'Company';
Cells[1,0] := 'Monthly';
Cells[2,0] := 'Balance';
// widths
ColWidths[0] := 150;
ColWidths[1] := 70;
ColWidths[2] := 70;
cnt := ln.FinancialInfoCount;
for i := 0 to cnt - 1 do
AddRow(ln.FinancialInfo[i]);
end;
end;
procedure TfrmLoanAssessmentDetail.PopulateMonthlyExpense;
var
i, cnt: integer;
begin
with grMonExp do
begin
RowCount := RowCount + 1;
FixedRows := 1;
// headers
Cells[0,0] := 'Expense';
Cells[1,0] := 'Amount';
// widths
ColWidths[0] := 125;
ColWidths[1] := 70;
cnt := ln.MonthlyExpenseCount;
for i := 0 to cnt - 1 do
AddRowExp(ln.MonthlyExpense[i]);
end;
end;
procedure TfrmLoanAssessmentDetail.btnAddClick(Sender: TObject);
begin
inherited;
if pcAssessment.ActivePage = tsFinInfo then
AddFinancialInfo
else
AddMonthlyExpense;
end;
procedure TfrmLoanAssessmentDetail.btnRemoveClick(Sender: TObject);
begin
inherited;
if pcAssessment.ActivePage = tsFinInfo then
ModifyRemove(true)
else
ModifyRemoveExp(true);
end;
procedure TfrmLoanAssessmentDetail.grFinInfoDblClick(Sender: TObject);
begin
ModifyRemove;
end;
procedure TfrmLoanAssessmentDetail.grMonExpDblClick(Sender: TObject);
begin
ModifyRemoveExp;
end;
procedure TfrmLoanAssessmentDetail.AddFinancialInfo;
begin
with TfrmFinInfoDetail.Create(nil) do
begin
try
ln.AppendFinancialInfo;
ShowModal;
if ModalResult = mrOk then AddRow(ln.FinancialInfo[ln.FinancialInfoCount - 1]);
Free;
except
on e: Exception do
ShowErrorBox(e.Message);
end;
end;
end;
procedure TfrmLoanAssessmentDetail.AddMonthlyExpense;
begin
with TfrmMonthlyExpDetail.Create(nil) do
begin
try
ln.AppendMonthlyExpense;
ShowModal;
if ModalResult = mrOk then AddRowExp(ln.MonthlyExpense[ln.MonthlyExpenseCount - 1]);
Free;
except
on e: Exception do
ShowErrorBox(e.Message);
end;
end;
end;
procedure TfrmLoanAssessmentDetail.Save;
begin
ln.Save;
end;
procedure TfrmLoanAssessmentDetail.urlAppliedAmountClick(Sender: TObject);
begin
inherited;
if ((ln.Action = laAssessing) or (ln.IsPending)) and (ln.Assessment.Recommendation = rcApprove) then
edRecAmount.Value := ln.AppliedAmount;
end;
procedure TfrmLoanAssessmentDetail.Cancel;
begin
ln.Cancel;
end;
procedure TfrmLoanAssessmentDetail.FormCreate(Sender: TObject);
begin
inherited;
OpenDropdownDataSources(tsDetail);
end;
procedure TfrmLoanAssessmentDetail.FormShow(Sender: TObject);
begin
inherited;
PopulateFinInfo;
PopulateMonthlyExpense;
ExtendLastColumn(grFinInfo);
ExtendLastColumn(grMonExp);
// applied amount
urlAppliedAmount.Caption := FormatCurr('###,##0.00',ln.AppliedAmount);
end;
function TfrmLoanAssessmentDetail.ValidEntry: boolean;
var
error: string;
begin
if dteDateAssessed.Text = '' then
error := 'Please enter date assessed.'
else if dbluRecommendation.Text = '' then
error := 'Please select a recommendation.'
else if (ln.Assessment.Recommendation = rcApprove) and (edRecAmount.Value <= 0) then
error := 'Invalid value for recommended amount.'
else if edRecAmount.Value > ln.LoanClass.MaxLoan then
error := 'Recommended amount exceeds the maximum loanable amount for the selected loan class.';
Result := error = '';
if not Result then ShowErrorBox(error);
end;
end.
|
unit uFaixaInteger;
interface
type
TFaixaInteger = record
fiDe, fiAte : Integer;
end;
TArrayFaixaInteger = Array of TFaixaInteger;
function ArrayFaixaIntegerToString(A: TArrayFaixaInteger): String;
procedure ArrayFaixaIntegerFromString(var A: TArrayFaixaInteger; S: String);
function IntegerDentroFaixa(A: TArrayFaixaInteger; V: Integer): Boolean;
implementation
uses sysutils;
function IntegerDentroFaixa(A: TArrayFaixaInteger; V: Integer): Boolean;
var I : Integer;
begin
for I := 0 to High(A) do with A[I] do
if (V>=fiDe) and (V<=fiAte) then begin
Result := True;
Exit;
end;
Result := False;
end;
function ArrayFaixaIntegerToString(A: TArrayFaixaInteger): String;
var i: integer;
begin
Result := '';
for I := 0 to High(A) do with A[i] do begin
if I>0 then Result := Result+',';
Result := Result + IntToStr(fiDe);
if fiAte<>fiDe then
Result := Result + '-' + IntToStr(fiAte);
end;
end;
procedure ArrayFaixaIntegerFromString(var A: TArrayFaixaInteger; S: String);
var
Prox: String;
I, F, T: Integer;
function Proximo: String;
var P: Integer;
begin
P := Pos(',', S);
if P>0 then begin
Result := Copy(S, 1, P-1);
Delete(S, 1, P);
end else begin
Result := S;
S := '';
end;
Result := Trim(Result);
end;
function CalcIF(Str: String): Boolean;
var P: Integer;
begin
Result := False;
F := 0;
I := 0;
P := Pos('-', Str);
if P>0 then begin
if not TryStrToInt(Trim(Copy(Str, 1, P-1)), I) then Exit;
if not TryStrToInt(Trim(Copy(Str, P+1, 100)), F) then Exit;
end else begin
if not TryStrToInt(Trim(Str), I) then Exit;
F := I;
end;
Result := True;
end;
begin
SetLength(A, 0);
T := 0;
repeat
Prox := Proximo;
if (prox>'') and CalcIF(Prox) then begin
SetLength(A, T+1);
A[T].fiDe := I;
A[T].fiAte := I;
Inc(T);
end;
until S='';
end;
end.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.