mirror of
https://github.com/Laex/Delphi-OpenCV.git
synced 2024-11-16 08:15:52 +01:00
1613 lines
46 KiB
ObjectPascal
1613 lines
46 KiB
ObjectPascal
// *****************************************************************
|
||
// Delphi-OpenCV Demo
|
||
// Copyright (C) 2013 Project Delphi-OpenCV
|
||
// ****************************************************************
|
||
// Contributor:
|
||
// Laentir Valetov
|
||
// email:laex@bk.ru
|
||
// ****************************************************************
|
||
// You may retrieve the latest version of this file at the GitHub,
|
||
// located at git://github.com/Laex/Delphi-OpenCV.git
|
||
// ****************************************************************
|
||
// The contents of this file are used with permission, 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/MPL-1_1Final.html
|
||
//
|
||
// 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 uOCVImageOperation;
|
||
|
||
interface
|
||
|
||
uses
|
||
Winapi.Windows,
|
||
System.SysUtils,
|
||
System.Classes,
|
||
System.SyncObjs,
|
||
System.Types,
|
||
uOCVTypes,
|
||
core.types_c, Vcl.Graphics;
|
||
|
||
type
|
||
|
||
TocvCustomImageOperation = class(TPersistent)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
CS: TCriticalSection;
|
||
FOwner: TComponent;
|
||
FFloatParams: TArray<Double>;
|
||
FIntParams: TArray<Integer>;
|
||
FBoolParams: TArray<Boolean>;
|
||
FOnGetParams: TNotifyEvent;
|
||
function GetFloatParam(const index: Integer): Double;
|
||
function GetIntParam(const index: Integer): Integer;
|
||
procedure SetFloatParam(const index: Integer; const Value: Double);
|
||
procedure SetIntParam(const index: Integer; const Value: Integer);
|
||
procedure NotifyGetParams;
|
||
function GetBoolParam(const index: Integer): Boolean;
|
||
procedure SetBoolParam(const index: Integer; const Value: Boolean);
|
||
protected
|
||
function LockTransform: Boolean;
|
||
procedure UnlockTransform;
|
||
property FloatParams[const index: Integer]: Double Read GetFloatParam write SetFloatParam;
|
||
property IntParams[const index: Integer]: Integer Read GetIntParam write SetIntParam;
|
||
property BoolParams[const index: Integer]: Boolean Read GetBoolParam write SetBoolParam;
|
||
public
|
||
constructor Create(AOwner: TComponent); virtual;
|
||
destructor Destroy; override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; virtual; abstract;
|
||
published
|
||
property OnGetParams: TNotifyEvent read FOnGetParams write FOnGetParams;
|
||
end;
|
||
|
||
TocvImageOperationClass = class of TocvCustomImageOperation;
|
||
|
||
TocvNoneOperation = class(TocvCustomImageOperation)
|
||
public
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
end;
|
||
|
||
TocvGrayScaleOperation = class(TocvCustomImageOperation)
|
||
public
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
end;
|
||
|
||
TovcCannyOperation = class(TocvCustomImageOperation)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
FThreshold2: Double;
|
||
FThreshold1: Double;
|
||
FApertureSize: Integer;
|
||
procedure SetApertureSize(const Value: Integer);
|
||
procedure SetThreshold1(const Value: Double);
|
||
procedure SetThreshold2(const Value: Double);
|
||
protected
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
published
|
||
property Threshold1: Double Read FThreshold1 write SetThreshold1;
|
||
property Threshold2: Double Read FThreshold2 write SetThreshold2;
|
||
property ApertureSize: Integer Read FApertureSize write SetApertureSize default 100;
|
||
end;
|
||
|
||
TocvErodeDilateMode = (SHAPE_RECT, SHAPE_CROSS, SHAPE_ELLIPSE, SHAPE_CUSTOM);
|
||
|
||
TovcCustomErodeDilateOperation = class(TocvCustomImageOperation)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
FRadius: Integer;
|
||
FIterations: Integer;
|
||
FMorphOp: TocvErodeDilateMode;
|
||
procedure SetRadius(const Value: Integer);
|
||
procedure SetIterations(const Value: Integer);
|
||
procedure SetMorphOp(const Value: TocvErodeDilateMode);
|
||
protected
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
published
|
||
property Radius: Integer Read FRadius write SetRadius default 5;
|
||
property Iterations: Integer Read FIterations write SetIterations default 5;
|
||
property MorphOp: TocvErodeDilateMode read FMorphOp write SetMorphOp default SHAPE_RECT;
|
||
end;
|
||
|
||
TovcErodeOperation = class(TovcCustomErodeDilateOperation)
|
||
public
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
end;
|
||
|
||
TovcDilateOperation = class(TovcCustomErodeDilateOperation)
|
||
public
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
end;
|
||
|
||
TocvLaplaceOperation = class(TocvCustomImageOperation)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
FAperture: Integer;
|
||
procedure SetAperture(const Value: Integer);
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
published
|
||
property Aperture: Integer read FAperture write SetAperture default 3;
|
||
end;
|
||
|
||
TovcSobelOperation = class(TocvCustomImageOperation)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
FXOrder: Integer;
|
||
FYOrder: Integer;
|
||
FAperture: Integer;
|
||
procedure SetAperture(const Value: Integer);
|
||
procedure SetXOrder(const Value: Integer);
|
||
procedure SetYOrder(const Value: Integer);
|
||
protected
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
published
|
||
property XOrder: Integer read FXOrder write SetXOrder default 1;
|
||
property YOrder: Integer read FYOrder write SetYOrder default 1;
|
||
property Aperture: Integer read FAperture write SetAperture default 3;
|
||
end;
|
||
|
||
TocvSmoothOperations = (BLUR_NO_SCALE, BLUR, GAUSSIAN, MEDIAN, BILATERAL);
|
||
|
||
TovcSmoothOperation = class(TocvCustomImageOperation)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
FSigma2: Double;
|
||
FSize2: Integer;
|
||
FSigma1: Double;
|
||
FSize1: Integer;
|
||
FSmoothOperation: TocvSmoothOperations;
|
||
procedure SetSigma1(const Value: Double);
|
||
procedure Setsigma2(const Value: Double);
|
||
procedure SetSize1(const Value: Integer);
|
||
procedure SetSize2(const Value: Integer);
|
||
procedure SetSmoothOperation(const Value: TocvSmoothOperations);
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
published
|
||
property sigma1: Double read FSigma1 write SetSigma1;
|
||
property sigma2: Double read FSigma2 write Setsigma2;
|
||
property size1: Integer read FSize1 write SetSize1 default 3;
|
||
property size2: Integer read FSize2 write SetSize2 default 3;
|
||
property SmoothOperation: TocvSmoothOperations read FSmoothOperation write SetSmoothOperation default GAUSSIAN;
|
||
end;
|
||
|
||
TocvThresholdType = (THRESH_BINARY, THRESH_BINARY_INV, THRESH_TRUNC, THRESH_TOZERO, THRESH_TOZERO_INV, THRESH_MASK,
|
||
THRESH_OTSU);
|
||
|
||
TocvCustomThresholdOperation = class(TocvCustomImageOperation)
|
||
private
|
||
function GetThresholdType: TocvThresholdType;
|
||
procedure SetThresholdType(const Value: TocvThresholdType);
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
published
|
||
property MaxValue: Double index 0 Read GetFloatParam write SetFloatParam; // default 250;
|
||
property ThresholdType: TocvThresholdType read GetThresholdType write SetThresholdType default THRESH_BINARY; // index 0
|
||
end;
|
||
|
||
TocvThresholdOperation = class(TocvCustomThresholdOperation)
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
published
|
||
property Threshold: Double index 1 Read GetFloatParam write SetFloatParam; // default 50;
|
||
end;
|
||
|
||
TocvAdaptiveThresholdType = (ADAPTIVE_THRESH_MEAN_C, ADAPTIVE_THRESH_GAUSSIAN_C);
|
||
|
||
TocvAdaptiveThresholdOperation = class(TocvCustomThresholdOperation)
|
||
private
|
||
function GetAdaptiveThresholdType: TocvAdaptiveThresholdType;
|
||
procedure SetAdaptiveThresholdType(const Value: TocvAdaptiveThresholdType);
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
published
|
||
property AdaptiveThresholdType: TocvAdaptiveThresholdType read GetAdaptiveThresholdType write SetAdaptiveThresholdType
|
||
default ADAPTIVE_THRESH_MEAN_C; // index 1
|
||
property BlockSize: Integer index 2 Read GetIntParam write SetIntParam; // 3
|
||
property Param: Double index 1 Read GetFloatParam write SetFloatParam; // 5;
|
||
end;
|
||
|
||
TocvRotateOperation = class(TocvCustomImageOperation)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
FAngle: Integer;
|
||
procedure SetAngle(const Value: Integer);
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
published
|
||
property Angle: Integer Read FAngle write SetAngle default 90;
|
||
end;
|
||
|
||
TocvPoint = class(TPersistent)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
private
|
||
FPoint: TPoint;
|
||
published
|
||
property X: Integer read FPoint.X write FPoint.X;
|
||
property Y: Integer read FPoint.Y write FPoint.Y;
|
||
end;
|
||
|
||
IocvEditorPropertiesContainer = interface
|
||
['{418F88DD-E35D-4425-BF24-E753E83D35D6}']
|
||
function GetProperties: TocvCustomImageOperation;
|
||
function GetPropertiesClass: TocvImageOperationClass;
|
||
procedure SetPropertiesClass(Value: TocvImageOperationClass);
|
||
end;
|
||
|
||
TocvContourRetrievalModes = (RETR_EXTERNAL, RETR_LIST, RETR_CCOMP, RETR_TREE, RETR_FLOODFILL);
|
||
|
||
TocvContourApproximationMethods = (CHAIN_CODE, CHAIN_APPROX_NONE, CHAIN_APPROX_SIMPLE, CHAIN_APPROX_TC89_L1,
|
||
CHAIN_APPROX_TC89_KCOS, LINK_RUNS);
|
||
|
||
TocvLineType = (LT_FILLED, LT_8, LT_AA);
|
||
|
||
TocvContourDraw = class(TPersistent)
|
||
protected
|
||
procedure AssignTo(Dest: TPersistent); override;
|
||
function GetOwner: TPersistent; override;
|
||
private
|
||
FOwner: TPersistent;
|
||
FOffset: TocvPoint;
|
||
FDrawContours: Boolean;
|
||
FMaxLevel: Integer;
|
||
FHoleColor: TColor;
|
||
FThickness: Integer;
|
||
FLineType: TocvLineType;
|
||
FExternalColor: TColor;
|
||
public
|
||
constructor Create(AOwner: TPersistent);
|
||
destructor Destroy; override;
|
||
published
|
||
property DrawContours: Boolean read FDrawContours write FDrawContours default false;
|
||
property ExternalColor: TColor read FExternalColor write FExternalColor default clGreen;
|
||
property HoleColor: TColor read FHoleColor write FHoleColor default clRed;
|
||
property MaxLevel: Integer read FMaxLevel write FMaxLevel default 2;
|
||
property Thickness: Integer read FThickness write FThickness default 2;
|
||
property LineType: TocvLineType read FLineType write FLineType default LT_AA;
|
||
property Offset: TocvPoint read FOffset write FOffset;
|
||
end;
|
||
|
||
TocvContoursOperation = class(TocvCustomImageOperation, IocvEditorPropertiesContainer)
|
||
private
|
||
CS: TCriticalSection;
|
||
FOperation: TocvCustomImageOperation;
|
||
FOperationClass: TocvImageOperationClass;
|
||
FRetrievalMode: TocvContourRetrievalModes;
|
||
FApproximationMethod: TocvContourApproximationMethods;
|
||
FOffset: TocvPoint;
|
||
FContourDraw: TocvContourDraw;
|
||
function LockTransform: Boolean;
|
||
procedure UnlockTransform;
|
||
procedure CreateProperties;
|
||
procedure DestroyProperties;
|
||
procedure RecreateProperties;
|
||
function GetPropertiesClassName: string;
|
||
procedure SetProperties(const Value: TocvCustomImageOperation);
|
||
procedure SetPropertiesClass(Value: TocvImageOperationClass);
|
||
procedure SetPropertiesClassName(const Value: string);
|
||
protected
|
||
function GetProperties: TocvCustomImageOperation;
|
||
function GetPropertiesClass: TocvImageOperationClass;
|
||
{IInterface}
|
||
function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
|
||
function _AddRef: Integer; stdcall;
|
||
function _Release: Integer; stdcall;
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
destructor Destroy; override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean; override;
|
||
property OperationClass: TocvImageOperationClass read GetPropertiesClass write SetPropertiesClass;
|
||
published
|
||
property OperationClassName: string read GetPropertiesClassName write SetPropertiesClassName;
|
||
property Preprocessing: TocvCustomImageOperation read GetProperties write SetProperties;
|
||
property RetrievalMode: TocvContourRetrievalModes read FRetrievalMode write FRetrievalMode default RETR_LIST;
|
||
property ApproximationMethod: TocvContourApproximationMethods read FApproximationMethod write FApproximationMethod
|
||
default CHAIN_APPROX_SIMPLE;
|
||
property Offset: TocvPoint read FOffset write FOffset;
|
||
property ContourDraw: TocvContourDraw read FContourDraw write FContourDraw;
|
||
end;
|
||
|
||
TocvImageOperationCollectionItem = class(TCollectionItem, IocvEditorPropertiesContainer)
|
||
private
|
||
CS: TCriticalSection;
|
||
FOperation: TocvCustomImageOperation;
|
||
FOperationClass: TocvImageOperationClass;
|
||
function LockTransform: Boolean;
|
||
procedure UnlockTransform;
|
||
procedure CreateProperties;
|
||
procedure DestroyProperties;
|
||
procedure RecreateProperties;
|
||
function GetPropertiesClassName: string;
|
||
procedure SetProperties(const Value: TocvCustomImageOperation);
|
||
procedure SetPropertiesClass(Value: TocvImageOperationClass);
|
||
procedure SetPropertiesClassName(const Value: string);
|
||
protected
|
||
function GetProperties: TocvCustomImageOperation;
|
||
function GetPropertiesClass: TocvImageOperationClass;
|
||
function GetDisplayName: string; override;
|
||
{IInterface}
|
||
function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
|
||
function _AddRef: Integer; stdcall;
|
||
function _Release: Integer; stdcall;
|
||
public
|
||
constructor Create(Collection: TCollection); override;
|
||
destructor Destroy; override;
|
||
function Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
procedure Assign(Source: TPersistent); override;
|
||
property OperationClass: TocvImageOperationClass read GetPropertiesClass write SetPropertiesClass;
|
||
published
|
||
property OperationClassName: string read GetPropertiesClassName write SetPropertiesClassName;
|
||
property Operation: TocvCustomImageOperation read GetProperties write SetProperties;
|
||
end;
|
||
|
||
TocvImageOperationCollection = class(TOwnedCollection);
|
||
|
||
TocvImageOperation = class(TocvDataSourceAndReceiver, IocvEditorPropertiesContainer)
|
||
private
|
||
CS: TCriticalSection;
|
||
FOperation: TocvCustomImageOperation;
|
||
FOperationClass: TocvImageOperationClass;
|
||
FOperations: TocvImageOperationCollection;
|
||
function LockTransform: Boolean;
|
||
procedure UnlockTransform;
|
||
procedure CreateProperties;
|
||
procedure DestroyProperties;
|
||
procedure RecreateProperties;
|
||
function GetPropertiesClassName: string;
|
||
procedure SetProperties(const Value: TocvCustomImageOperation);
|
||
procedure SetPropertiesClass(Value: TocvImageOperationClass);
|
||
procedure SetPropertiesClassName(const Value: string);
|
||
protected
|
||
procedure TakeImage(const IplImage: pIplImage); override;
|
||
function GetProperties: TocvCustomImageOperation;
|
||
function GetPropertiesClass: TocvImageOperationClass;
|
||
public
|
||
constructor Create(AOwner: TComponent); override;
|
||
destructor Destroy; override;
|
||
property OperationClass: TocvImageOperationClass read GetPropertiesClass write SetPropertiesClass;
|
||
published
|
||
property OperationClassName: string read GetPropertiesClassName write SetPropertiesClassName;
|
||
property Operation: TocvCustomImageOperation read GetProperties write SetProperties;
|
||
property Operations: TocvImageOperationCollection Read FOperations write FOperations;
|
||
end;
|
||
|
||
TRegisteredImageOperations = class(TStringList)
|
||
public
|
||
function FindByClassName(const ClassName: String): TocvImageOperationClass;
|
||
function FindByName(const Name: String): TocvImageOperationClass;
|
||
function GetNameByClass(const IOClass: TClass): String;
|
||
procedure RegisterIOClass(const IOClass: TClass; const ClassName: String);
|
||
end;
|
||
|
||
function GetRegisteredImageOperations: TRegisteredImageOperations;
|
||
|
||
implementation
|
||
|
||
Uses
|
||
core_c,
|
||
imgproc_c,
|
||
imgproc.types_c;
|
||
|
||
Var
|
||
_RegisteredImageOperations: TRegisteredImageOperations = nil;
|
||
|
||
function GetRegisteredImageOperations: TRegisteredImageOperations;
|
||
begin
|
||
if not Assigned(_RegisteredImageOperations) then
|
||
_RegisteredImageOperations := TRegisteredImageOperations.Create;
|
||
Result := _RegisteredImageOperations;
|
||
end;
|
||
|
||
{TocvImageOperation}
|
||
|
||
procedure TocvImageOperation.SetProperties(const Value: TocvCustomImageOperation);
|
||
begin
|
||
if (FOperation <> nil) and (Value <> nil) then
|
||
FOperation.Assign(Value);
|
||
end;
|
||
|
||
procedure TocvImageOperation.SetPropertiesClass(Value: TocvImageOperationClass);
|
||
begin
|
||
if FOperationClass <> Value then
|
||
begin
|
||
FOperationClass := Value;
|
||
RecreateProperties;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvImageOperation.CreateProperties;
|
||
begin
|
||
if FOperationClass <> nil then
|
||
FOperation := FOperationClass.Create(Self);
|
||
end;
|
||
|
||
procedure TocvImageOperation.DestroyProperties;
|
||
begin
|
||
FreeAndNil(FOperation);
|
||
end;
|
||
|
||
procedure TocvImageOperation.RecreateProperties;
|
||
begin
|
||
DestroyProperties;
|
||
CreateProperties;
|
||
end;
|
||
|
||
procedure TocvImageOperation.SetPropertiesClassName(const Value: string);
|
||
begin
|
||
OperationClass := TocvImageOperationClass(GetRegisteredImageOperations.FindByClassName(Value));
|
||
end;
|
||
|
||
constructor TocvImageOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
CS := TCriticalSection.Create;
|
||
FOperations := TocvImageOperationCollection.Create(Self, TocvImageOperationCollectionItem);
|
||
end;
|
||
|
||
destructor TocvImageOperation.Destroy;
|
||
begin
|
||
if LockTransform then
|
||
if Assigned(FOperation) then
|
||
FreeAndNil(FOperation);
|
||
FOperations.Free;
|
||
CS.Free;
|
||
inherited;
|
||
end;
|
||
|
||
function TocvImageOperation.GetProperties: TocvCustomImageOperation;
|
||
begin
|
||
if not Assigned(FOperation) then
|
||
FOperation := TocvNoneOperation.Create(Self);
|
||
Result := FOperation;
|
||
end;
|
||
|
||
function TocvImageOperation.GetPropertiesClass: TocvImageOperationClass;
|
||
begin
|
||
Result := TocvImageOperationClass(Operation.ClassType);
|
||
end;
|
||
|
||
function TocvImageOperation.GetPropertiesClassName: string;
|
||
begin
|
||
Result := Operation.ClassName;
|
||
end;
|
||
|
||
function TocvImageOperation.LockTransform: Boolean;
|
||
begin
|
||
Result := CS.TryEnter;
|
||
end;
|
||
|
||
procedure TocvImageOperation.TakeImage(const IplImage: pIplImage);
|
||
var
|
||
Destanation: pIplImage;
|
||
SourceDestanation: pIplImage;
|
||
i: Integer;
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
if FOperations.Count > 0 then
|
||
begin
|
||
SourceDestanation := IplImage;
|
||
for i := 0 to FOperations.Count - 1 do
|
||
begin
|
||
if not(FOperations.Items[i] as TocvImageOperationCollectionItem).Transform(SourceDestanation, Destanation) then
|
||
Exit;
|
||
if SourceDestanation <> IplImage then
|
||
cvReleaseImage(SourceDestanation);
|
||
SourceDestanation := Destanation;
|
||
end;
|
||
NotifyReceiver(SourceDestanation);
|
||
end
|
||
else if Assigned(FOperation) and FOperation.Transform(IplImage, Destanation) then
|
||
NotifyReceiver(Destanation);
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvImageOperation.UnlockTransform;
|
||
begin
|
||
CS.Leave;
|
||
end;
|
||
|
||
{TovcImageOperationCanny}
|
||
|
||
procedure TovcCannyOperation.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TovcCannyOperation then
|
||
begin
|
||
FThreshold1 := (Dest as TovcCannyOperation).FThreshold1;
|
||
FThreshold2 := (Dest as TovcCannyOperation).FThreshold2;
|
||
FApertureSize := (Dest as TovcCannyOperation).FApertureSize;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TovcCannyOperation.Create {(AOwner: TPersistent)};
|
||
begin
|
||
inherited;
|
||
FThreshold1 := 10;
|
||
FThreshold2 := 100;
|
||
FApertureSize := 3;
|
||
end;
|
||
|
||
procedure TovcCannyOperation.SetApertureSize(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FApertureSize := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TovcCannyOperation.SetThreshold1(const Value: Double);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FThreshold1 := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TovcCannyOperation.SetThreshold2(const Value: Double);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FThreshold2 := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
function TovcCannyOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
gray: pIplImage;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
// c<><63><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
gray := cvCreateImage(cvGetSize(Source), IPL_DEPTH_8U, 1);
|
||
Destanation := cvCreateImage(cvGetSize(Source), IPL_DEPTH_8U, 1);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> c<><63><EFBFBD><EFBFBD><EFBFBD>
|
||
cvCvtColor(Source, gray, CV_RGB2GRAY);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
cvCanny(gray, Destanation, Threshold1, Threshold2, ApertureSize);
|
||
cvReleaseImage(gray);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TocvImageOperationGrayScale}
|
||
|
||
function TocvGrayScaleOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
Destanation := cvCreateImage(cvGetSize(Source), IPL_DEPTH_8U, 1);
|
||
cvCvtColor(Source, Destanation, CV_RGB2GRAY);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TocvImageOperationNone}
|
||
|
||
function TocvNoneOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
Destanation := cvCloneImage(Source);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TCustomOpenCVImgOperation}
|
||
|
||
procedure TocvCustomImageOperation.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TocvCustomImageOperation then
|
||
begin
|
||
FFloatParams := (Dest as TocvCustomImageOperation).FFloatParams;
|
||
FIntParams := (Dest as TocvCustomImageOperation).FIntParams;
|
||
FBoolParams := (Dest as TocvCustomImageOperation).FBoolParams;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TocvCustomImageOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited Create;
|
||
FOwner := AOwner;
|
||
CS := TCriticalSection.Create;
|
||
end;
|
||
|
||
destructor TocvCustomImageOperation.Destroy;
|
||
begin
|
||
CS.Free;
|
||
inherited;
|
||
end;
|
||
|
||
function TocvCustomImageOperation.GetBoolParam(const index: Integer): Boolean;
|
||
begin
|
||
if (index >= 0) and (index < Length(FBoolParams)) then
|
||
Result := FBoolParams[index]
|
||
else
|
||
Result := false;
|
||
end;
|
||
|
||
function TocvCustomImageOperation.GetFloatParam(const index: Integer): Double;
|
||
begin
|
||
if (index >= 0) and (index < Length(FFloatParams)) then
|
||
Result := FFloatParams[index]
|
||
else
|
||
Result := 0;
|
||
end;
|
||
|
||
function TocvCustomImageOperation.GetIntParam(const index: Integer): Integer;
|
||
begin
|
||
if (index >= 0) and (index < Length(FIntParams)) then
|
||
Result := FIntParams[index]
|
||
else
|
||
Result := 0;
|
||
end;
|
||
|
||
function TocvCustomImageOperation.LockTransform: Boolean;
|
||
begin
|
||
Result := CS.TryEnter;
|
||
end;
|
||
|
||
procedure TocvCustomImageOperation.NotifyGetParams;
|
||
begin
|
||
if Assigned(OnGetParams) then
|
||
OnGetParams(Self);
|
||
end;
|
||
|
||
procedure TocvCustomImageOperation.SetBoolParam(const index: Integer; const Value: Boolean);
|
||
begin
|
||
if (index >= 0) and LockTransform then
|
||
try
|
||
if index > High(FBoolParams) then
|
||
SetLength(FBoolParams, index + 1);
|
||
FBoolParams[index] := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvCustomImageOperation.SetFloatParam(const index: Integer; const Value: Double);
|
||
begin
|
||
if (index >= 0) and LockTransform then
|
||
try
|
||
if index > High(FFloatParams) then
|
||
SetLength(FFloatParams, index + 1);
|
||
FFloatParams[index] := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvCustomImageOperation.SetIntParam(const index: Integer; const Value: Integer);
|
||
begin
|
||
if (index >= 0) and LockTransform then
|
||
try
|
||
if index > High(FIntParams) then
|
||
SetLength(FIntParams, index + 1);
|
||
FIntParams[index] := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvCustomImageOperation.UnlockTransform;
|
||
begin
|
||
CS.Leave;
|
||
end;
|
||
|
||
{TovcImageOperationSmooth}
|
||
Const
|
||
ocvSmoothOperations: array [TocvSmoothOperations] of Integer = (CV_BLUR_NO_SCALE, CV_BLUR, CV_GAUSSIAN, CV_MEDIAN,
|
||
CV_BILATERAL);
|
||
|
||
procedure TovcSmoothOperation.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TovcSmoothOperation then
|
||
begin
|
||
FSmoothOperation := (Dest as TovcSmoothOperation).FSmoothOperation;
|
||
FSize1 := (Dest as TovcSmoothOperation).FSize1;
|
||
FSize2 := (Dest as TovcSmoothOperation).FSize2;
|
||
FSigma1 := (Dest as TovcSmoothOperation).FSigma1;
|
||
FSigma2 := (Dest as TovcSmoothOperation).FSigma2;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TovcSmoothOperation.Create {(AOwner: TPersistent)};
|
||
begin
|
||
inherited;
|
||
FSmoothOperation := GAUSSIAN;
|
||
FSize1 := 3;
|
||
FSize2 := 3;
|
||
FSigma1 := 0;
|
||
FSigma2 := 0;
|
||
end;
|
||
|
||
procedure TovcSmoothOperation.SetSigma1(const Value: Double);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FSigma1 := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
//
|
||
procedure TovcSmoothOperation.Setsigma2(const Value: Double);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FSigma2 := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
//
|
||
procedure TovcSmoothOperation.SetSize1(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FSize1 := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
//
|
||
procedure TovcSmoothOperation.SetSize2(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FSize2 := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TovcSmoothOperation.SetSmoothOperation(const Value: TocvSmoothOperations);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FSmoothOperation := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
function TovcSmoothOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
Destanation := cvCloneImage(Source);
|
||
cvSmooth(Source, Destanation, ocvSmoothOperations[SmoothOperation], size1, size2, sigma1, sigma2);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TRegisteredImageOperations}
|
||
|
||
function TRegisteredImageOperations.FindByClassName(const ClassName: String): TocvImageOperationClass;
|
||
Var
|
||
i: Integer;
|
||
begin
|
||
for i := 0 to Count - 1 do
|
||
if TocvImageOperationClass(Objects[i]).ClassName = ClassName then
|
||
Exit(TocvImageOperationClass(Objects[i]));
|
||
end;
|
||
|
||
function TRegisteredImageOperations.FindByName(const Name: String): TocvImageOperationClass;
|
||
Var
|
||
i: Integer;
|
||
begin
|
||
i := IndexOf(Name);
|
||
if i <> -1 then
|
||
Result := TocvImageOperationClass(Objects[i])
|
||
else
|
||
Result := Nil;
|
||
end;
|
||
|
||
function TRegisteredImageOperations.GetNameByClass(const IOClass: TClass): String;
|
||
Var
|
||
i: Integer;
|
||
begin
|
||
Result := '';
|
||
for i := 0 to Count - 1 do
|
||
if Integer(Objects[i]) = Integer(IOClass) then
|
||
begin
|
||
Result := Self[i];
|
||
Break;
|
||
end;
|
||
end;
|
||
|
||
procedure TRegisteredImageOperations.RegisterIOClass(const IOClass: TClass; const ClassName: String);
|
||
begin
|
||
AddObject(ClassName, TObject(IOClass));
|
||
RegisterClass(TPersistentClass(IOClass));
|
||
end;
|
||
|
||
{TovcCustomErodeDilate}
|
||
|
||
procedure TovcCustomErodeDilateOperation.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TovcCustomErodeDilateOperation then
|
||
begin
|
||
FRadius := (Dest as TovcCustomErodeDilateOperation).Radius;
|
||
FIterations := (Dest as TovcCustomErodeDilateOperation).Iterations;
|
||
FMorphOp := (Dest as TovcCustomErodeDilateOperation).MorphOp;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TovcCustomErodeDilateOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
FRadius := 5;
|
||
FIterations := 5;
|
||
end;
|
||
|
||
procedure TovcCustomErodeDilateOperation.SetIterations(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FIterations := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TovcCustomErodeDilateOperation.SetMorphOp(const Value: TocvErodeDilateMode);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FMorphOp := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TovcCustomErodeDilateOperation.SetRadius(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FRadius := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
const
|
||
EDMorpgOp: array [TocvErodeDilateMode] of Integer = (CV_SHAPE_RECT, CV_SHAPE_CROSS, CV_SHAPE_ELLIPSE, CV_SHAPE_CUSTOM);
|
||
|
||
{TovcErode}
|
||
|
||
function TovcErodeOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
Kern: pIplConvKernel;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
Destanation := cvCloneImage(Source);
|
||
Kern := cvCreateStructuringElementEx(Radius * 2 + 1, Radius * 2 + 1, Radius, Radius, EDMorpgOp[FMorphOp]);
|
||
cvErode(Source, Destanation, Kern, Iterations);
|
||
cvReleaseStructuringElement(Kern);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TovcDilate}
|
||
|
||
function TovcDilateOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
Kern: pIplConvKernel;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
Destanation := cvCloneImage(Source);
|
||
Kern := cvCreateStructuringElementEx(Radius * 2 + 1, Radius * 2 + 1, Radius, Radius, EDMorpgOp[FMorphOp]);
|
||
cvDilate(Source, Destanation, Kern, Iterations);
|
||
cvReleaseStructuringElement(Kern);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TocvLaplace}
|
||
|
||
procedure TocvLaplaceOperation.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TocvLaplaceOperation then
|
||
begin
|
||
FAperture := (Dest as TocvLaplaceOperation).Aperture;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TocvLaplaceOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
FAperture := 3;
|
||
end;
|
||
|
||
procedure TocvLaplaceOperation.SetAperture(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FAperture := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
function TocvLaplaceOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
D: pIplImage;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
D := cvCreateImage(cvGetSize(Source), IPL_DEPTH_16S, Source^.nChannels);
|
||
Destanation := cvCreateImage(cvGetSize(Source), Source^.depth, Source^.nChannels);
|
||
cvLaplace(Source, D, Aperture);
|
||
cvConvertScale(D, Destanation);
|
||
cvReleaseImage(D);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TovcSobel}
|
||
|
||
procedure TovcSobelOperation.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TovcSobelOperation then
|
||
begin
|
||
FXOrder := (Dest as TovcSobelOperation).XOrder;
|
||
FYOrder := (Dest as TovcSobelOperation).YOrder;
|
||
FAperture := (Dest as TovcSobelOperation).Aperture;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TovcSobelOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
FXOrder := 1;
|
||
FYOrder := 1;
|
||
FAperture := 3;
|
||
end;
|
||
|
||
procedure TovcSobelOperation.SetAperture(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FAperture := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TovcSobelOperation.SetXOrder(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
if (YOrder <> 0) and (Value <> 0) then
|
||
FXOrder := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TovcSobelOperation.SetYOrder(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
if (XOrder <> 0) and (Value <> 0) then
|
||
FYOrder := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
function TovcSobelOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
D: pIplImage;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
D := cvCreateImage(cvGetSize(Source), IPL_DEPTH_16S, Source^.nChannels);
|
||
Destanation := cvCreateImage(cvGetSize(Source), Source^.depth, Source^.nChannels);
|
||
cvSobel(Source, D, XOrder, YOrder, Aperture);
|
||
cvConvertScale(D, Destanation);
|
||
cvReleaseImage(D);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TocvImageOperationCollectionItem}
|
||
|
||
procedure TocvImageOperationCollectionItem.Assign(Source: TPersistent);
|
||
begin
|
||
if Source is TocvImageOperationCollectionItem then
|
||
Operation.Assign(TocvImageOperationCollectionItem(Source).Operation)
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TocvImageOperationCollectionItem.Create(Collection: TCollection);
|
||
begin
|
||
inherited;
|
||
CS := TCriticalSection.Create;
|
||
end;
|
||
|
||
procedure TocvImageOperationCollectionItem.CreateProperties;
|
||
begin
|
||
if FOperationClass <> nil then
|
||
FOperation := FOperationClass.Create(nil);
|
||
end;
|
||
|
||
destructor TocvImageOperationCollectionItem.Destroy;
|
||
begin
|
||
if Assigned(FOperation) then
|
||
FOperation.Free;
|
||
CS.Free;
|
||
inherited;
|
||
end;
|
||
|
||
procedure TocvImageOperationCollectionItem.DestroyProperties;
|
||
begin
|
||
FreeAndNil(FOperation);
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem.GetDisplayName: string;
|
||
begin
|
||
Result := GetRegisteredImageOperations.GetNameByClass(FOperation.ClassType);
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem.GetProperties: TocvCustomImageOperation;
|
||
begin
|
||
if not Assigned(FOperation) then
|
||
FOperation := TocvNoneOperation.Create(nil);
|
||
Result := FOperation;
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem.GetPropertiesClass: TocvImageOperationClass;
|
||
begin
|
||
Result := TocvImageOperationClass(Operation.ClassType);
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem.GetPropertiesClassName: string;
|
||
begin
|
||
Result := Operation.ClassName;
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem.LockTransform: Boolean;
|
||
begin
|
||
Result := CS.TryEnter;
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem.QueryInterface(const IID: TGUID; out Obj): HResult;
|
||
begin
|
||
if GetInterface(IID, Obj) then
|
||
Result := 0
|
||
else
|
||
Result := E_NOINTERFACE;
|
||
end;
|
||
|
||
procedure TocvImageOperationCollectionItem.RecreateProperties;
|
||
begin
|
||
DestroyProperties;
|
||
CreateProperties;
|
||
end;
|
||
|
||
procedure TocvImageOperationCollectionItem.SetProperties(const Value: TocvCustomImageOperation);
|
||
begin
|
||
if (FOperation <> nil) and (Value <> nil) then
|
||
FOperation.Assign(Value);
|
||
end;
|
||
|
||
procedure TocvImageOperationCollectionItem.SetPropertiesClass(Value: TocvImageOperationClass);
|
||
begin
|
||
if FOperationClass <> Value then
|
||
begin
|
||
FOperationClass := Value;
|
||
RecreateProperties;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvImageOperationCollectionItem.SetPropertiesClassName(const Value: string);
|
||
begin
|
||
OperationClass := TocvImageOperationClass(GetRegisteredImageOperations.FindByClassName(Value));
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
Result := Assigned(FOperation) and FOperation.Transform(Source, Destanation)
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvImageOperationCollectionItem.UnlockTransform;
|
||
begin
|
||
CS.Leave;
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem._AddRef: Integer;
|
||
begin
|
||
Result := -1;
|
||
end;
|
||
|
||
function TocvImageOperationCollectionItem._Release: Integer;
|
||
begin
|
||
Result := -1;
|
||
end;
|
||
|
||
{TocvThresholdOperation}
|
||
|
||
Const
|
||
cThreshold: array [TocvThresholdType] of Integer = (CV_THRESH_BINARY, CV_THRESH_BINARY_INV, CV_THRESH_TRUNC, CV_THRESH_TOZERO,
|
||
CV_THRESH_TOZERO_INV, CV_THRESH_MASK, CV_THRESH_OTSU);
|
||
|
||
constructor TocvThresholdOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
Threshold := 50;
|
||
end;
|
||
|
||
constructor TocvCustomThresholdOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
MaxValue := 250;
|
||
ThresholdType := THRESH_BINARY;
|
||
end;
|
||
|
||
function TocvCustomThresholdOperation.GetThresholdType: TocvThresholdType;
|
||
begin
|
||
Result := TocvThresholdType(GetIntParam(0));
|
||
end;
|
||
|
||
procedure TocvCustomThresholdOperation.SetThresholdType(const Value: TocvThresholdType);
|
||
begin
|
||
SetIntParam(0, Integer(Value));
|
||
end;
|
||
|
||
function TocvThresholdOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
D: pIplImage;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
D := cvCreateImage(cvGetSize(Source), IPL_DEPTH_8U, 1);
|
||
cvCvtColor(Source, D, CV_RGB2GRAY);
|
||
Destanation := cvCreateImage(cvGetSize(Source), IPL_DEPTH_8U, 1);
|
||
cvThreshold(D, Destanation, Threshold, MaxValue, cThreshold[ThresholdType]);
|
||
cvReleaseImage(D);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TocvAdaptiveThresholdOperation}
|
||
|
||
const
|
||
cAdaptiveThresholdType: array [TocvAdaptiveThresholdType] of Integer = (CV_ADAPTIVE_THRESH_MEAN_C,
|
||
CV_ADAPTIVE_THRESH_GAUSSIAN_C);
|
||
|
||
constructor TocvAdaptiveThresholdOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
AdaptiveThresholdType := ADAPTIVE_THRESH_MEAN_C;
|
||
BlockSize := 3;
|
||
Param := 5;
|
||
end;
|
||
|
||
function TocvAdaptiveThresholdOperation.GetAdaptiveThresholdType: TocvAdaptiveThresholdType;
|
||
begin
|
||
Result := TocvAdaptiveThresholdType(GetIntParam(1));
|
||
end;
|
||
|
||
procedure TocvAdaptiveThresholdOperation.SetAdaptiveThresholdType(const Value: TocvAdaptiveThresholdType);
|
||
begin
|
||
SetIntParam(1, Integer(Value));
|
||
end;
|
||
|
||
function TocvAdaptiveThresholdOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
D: pIplImage;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
D := cvCreateImage(cvGetSize(Source), IPL_DEPTH_8U, 1);
|
||
cvCvtColor(Source, D, CV_RGB2GRAY);
|
||
Destanation := cvCreateImage(cvGetSize(Source), IPL_DEPTH_8U, 1);
|
||
cvAdaptiveThreshold(D, Destanation, MaxValue, cAdaptiveThresholdType[AdaptiveThresholdType], cThreshold[ThresholdType],
|
||
BlockSize, Param);
|
||
cvReleaseImage(D);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TocvContoursOperation}
|
||
|
||
constructor TocvContoursOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
CS := TCriticalSection.Create;
|
||
FOffset := TocvPoint.Create;
|
||
FContourDraw := TocvContourDraw.Create(Self);
|
||
OperationClass := TocvThresholdOperation;
|
||
With Preprocessing as TocvThresholdOperation do
|
||
begin
|
||
Threshold := 128;
|
||
MaxValue := 255;
|
||
ThresholdType := THRESH_BINARY_INV;
|
||
end;
|
||
RetrievalMode := RETR_LIST;
|
||
ApproximationMethod := CHAIN_APPROX_SIMPLE;
|
||
end;
|
||
|
||
procedure TocvContoursOperation.CreateProperties;
|
||
begin
|
||
if FOperationClass <> nil then
|
||
FOperation := FOperationClass.Create(nil);
|
||
end;
|
||
|
||
destructor TocvContoursOperation.Destroy;
|
||
begin
|
||
if Assigned(FOperation) then
|
||
FOperation.Free;
|
||
CS.Free;
|
||
FOffset.Free;
|
||
FContourDraw.Free;
|
||
inherited;
|
||
end;
|
||
|
||
procedure TocvContoursOperation.DestroyProperties;
|
||
begin
|
||
FreeAndNil(FOperation);
|
||
end;
|
||
|
||
function TocvContoursOperation.GetProperties: TocvCustomImageOperation;
|
||
begin
|
||
if not Assigned(FOperation) then
|
||
FOperation := TocvNoneOperation.Create(nil);
|
||
Result := FOperation;
|
||
end;
|
||
|
||
function TocvContoursOperation.GetPropertiesClass: TocvImageOperationClass;
|
||
begin
|
||
Result := TocvImageOperationClass(Preprocessing.ClassType);
|
||
end;
|
||
|
||
function TocvContoursOperation.GetPropertiesClassName: string;
|
||
begin
|
||
Result := Preprocessing.ClassName;
|
||
end;
|
||
|
||
function TocvContoursOperation.LockTransform: Boolean;
|
||
begin
|
||
Result := CS.TryEnter;
|
||
end;
|
||
|
||
function TocvContoursOperation.QueryInterface(const IID: TGUID; out Obj): HResult;
|
||
begin
|
||
if GetInterface(IID, Obj) then
|
||
Result := 0
|
||
else
|
||
Result := E_NOINTERFACE;
|
||
end;
|
||
|
||
procedure TocvContoursOperation.RecreateProperties;
|
||
begin
|
||
DestroyProperties;
|
||
CreateProperties;
|
||
end;
|
||
|
||
procedure TocvContoursOperation.SetProperties(const Value: TocvCustomImageOperation);
|
||
begin
|
||
if (FOperation <> nil) and (Value <> nil) then
|
||
FOperation.Assign(Value);
|
||
end;
|
||
|
||
procedure TocvContoursOperation.SetPropertiesClass(Value: TocvImageOperationClass);
|
||
begin
|
||
if FOperationClass <> Value then
|
||
begin
|
||
FOperationClass := Value;
|
||
RecreateProperties;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvContoursOperation.SetPropertiesClassName(const Value: string);
|
||
begin
|
||
OperationClass := TocvImageOperationClass(GetRegisteredImageOperations.FindByClassName(Value));
|
||
end;
|
||
|
||
function TocvContoursOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
|
||
const
|
||
cLineType:array[TocvLineType] of Integer= (CV_FILLED,8,CV_AA);
|
||
|
||
Var
|
||
th_image: pIplImage;
|
||
contours: pCvSeq;
|
||
storage: pCvMemStorage;
|
||
contoursCont: Integer;
|
||
RGBColor: TColor;
|
||
er, eg, eb: Byte;
|
||
hr, hg, hb: Byte;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
Destanation := cvCloneImage(Source);
|
||
|
||
storage := cvCreateMemStorage(0);
|
||
contours := nil;
|
||
th_image := nil;
|
||
try
|
||
if not Preprocessing.Transform(Source, th_image) then
|
||
Exit;
|
||
|
||
contoursCont := cvFindContours(th_image, storage, @contours, SizeOf(TCvContour), Integer(RetrievalMode),
|
||
Integer(ApproximationMethod), cvPoint(Offset.X, Offset.Y));
|
||
|
||
if contoursCont > 0 then
|
||
begin
|
||
if ContourDraw.DrawContours then
|
||
begin
|
||
RGBColor := ColorToRGB(ContourDraw.ExternalColor);
|
||
er := GetRValue(RGBColor);
|
||
eg := GetGValue(RGBColor);
|
||
eb := GetBValue(RGBColor);
|
||
RGBColor := ColorToRGB(ContourDraw.HoleColor);
|
||
hr := GetRValue(RGBColor);
|
||
hg := GetGValue(RGBColor);
|
||
hb := GetBValue(RGBColor);
|
||
cvDrawContours( Destanation, contours, CV_RGB(er, eg, eb), CV_RGB(hr, hg, hb),
|
||
ContourDraw.MaxLevel, ContourDraw.Thickness, cLineType[ContourDraw.LineType], cvPoint(ContourDraw.Offset.X,
|
||
ContourDraw.Offset.Y));
|
||
end;
|
||
end;
|
||
Result := true;
|
||
finally
|
||
if Assigned(th_image) then
|
||
cvReleaseImage(th_image);
|
||
cvReleaseMemStorage(storage)
|
||
end;
|
||
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
procedure TocvContoursOperation.UnlockTransform;
|
||
begin
|
||
CS.Leave;
|
||
end;
|
||
|
||
function TocvContoursOperation._AddRef: Integer;
|
||
begin
|
||
Result := -1;
|
||
end;
|
||
|
||
function TocvContoursOperation._Release: Integer;
|
||
begin
|
||
Result := -1;
|
||
end;
|
||
|
||
{TocvRotateOperation}
|
||
|
||
procedure TocvRotateOperation.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TocvRotateOperation then
|
||
begin
|
||
FAngle := (Dest as TocvRotateOperation).FAngle;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TocvRotateOperation.Create(AOwner: TComponent);
|
||
begin
|
||
inherited;
|
||
FAngle := 90;
|
||
end;
|
||
|
||
procedure TocvRotateOperation.SetAngle(const Value: Integer);
|
||
begin
|
||
if LockTransform then
|
||
try
|
||
FAngle := Value;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
function TocvRotateOperation.Transform(const Source: pIplImage; var Destanation: pIplImage): Boolean;
|
||
Var
|
||
rot_mat: pCvMat;
|
||
scale: Double;
|
||
center: TcvPoint2D32f;
|
||
D: pIplImage;
|
||
begin
|
||
Result := false;
|
||
if LockTransform then
|
||
try
|
||
NotifyGetParams;
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
rot_mat := cvCreateMat(2, 3, CV_32FC1);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
center.x := Source^.width div 2;
|
||
center.y := Source^.height div 2;
|
||
scale := 1;
|
||
cv2DRotationMatrix(center, Angle, scale, rot_mat);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
D := nil;
|
||
D := cvCreateImage(cvGetSize(Source), Source^.depth, Source^.nChannels);
|
||
Destanation := cvCreateImage(cvGetSize(Source), Source^.depth, Source^.nChannels);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
cvWarpAffine(Source, D, rot_mat, CV_INTER_LINEAR or CV_WARP_FILL_OUTLIERS, cvScalarAll(0));
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
cvCopy(D, Destanation);
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
cvReleaseImage(D);
|
||
cvReleaseMat(rot_mat);
|
||
Result := true;
|
||
finally
|
||
UnlockTransform;
|
||
end;
|
||
end;
|
||
|
||
{TPersistentPoint}
|
||
|
||
procedure TocvPoint.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TocvPoint then
|
||
begin
|
||
FPoint := (Dest as TocvPoint).FPoint;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
{TocvCountourDraw}
|
||
|
||
procedure TocvContourDraw.AssignTo(Dest: TPersistent);
|
||
begin
|
||
if Dest is TocvContourDraw then
|
||
begin
|
||
FOffset.FPoint := (Dest as TocvContourDraw).FOffset.FPoint;
|
||
FDrawContours := (Dest as TocvContourDraw).FDrawContours;
|
||
FMaxLevel := (Dest as TocvContourDraw).FMaxLevel;
|
||
FHoleColor := (Dest as TocvContourDraw).FHoleColor;
|
||
FThickness := (Dest as TocvContourDraw).FThickness;
|
||
FLineType := (Dest as TocvContourDraw).FLineType;
|
||
FExternalColor := (Dest as TocvContourDraw).FExternalColor;
|
||
end
|
||
else
|
||
inherited;
|
||
end;
|
||
|
||
constructor TocvContourDraw.Create(AOwner: TPersistent);
|
||
begin
|
||
inherited Create;
|
||
FOwner := AOwner;
|
||
FOffset := TocvPoint.Create;
|
||
FDrawContours := false;
|
||
FMaxLevel := 2;
|
||
FHoleColor := clRed;
|
||
FThickness := 2;
|
||
FLineType := LT_AA;
|
||
FExternalColor := clGreen;
|
||
end;
|
||
|
||
destructor TocvContourDraw.Destroy;
|
||
begin
|
||
FOffset.Free;
|
||
inherited;
|
||
end;
|
||
|
||
function TocvContourDraw.GetOwner: TPersistent;
|
||
begin
|
||
Result := FOwner;
|
||
end;
|
||
|
||
initialization
|
||
|
||
GetRegisteredImageOperations.RegisterIOClass(TocvNoneOperation, 'None');
|
||
GetRegisteredImageOperations.RegisterIOClass(TocvGrayScaleOperation, 'GrayScale');
|
||
GetRegisteredImageOperations.RegisterIOClass(TovcCannyOperation, 'Canny');
|
||
GetRegisteredImageOperations.RegisterIOClass(TovcSmoothOperation, 'Smooth');
|
||
GetRegisteredImageOperations.RegisterIOClass(TovcErodeOperation, 'Erode');
|
||
GetRegisteredImageOperations.RegisterIOClass(TovcDilateOperation, 'Dilate');
|
||
GetRegisteredImageOperations.RegisterIOClass(TocvLaplaceOperation, 'Laplace');
|
||
GetRegisteredImageOperations.RegisterIOClass(TovcSobelOperation, 'Sobel');
|
||
GetRegisteredImageOperations.RegisterIOClass(TocvThresholdOperation, 'Threshold');
|
||
GetRegisteredImageOperations.RegisterIOClass(TocvAdaptiveThresholdOperation, 'AdaptiveThreshold');
|
||
GetRegisteredImageOperations.RegisterIOClass(TocvContoursOperation, 'Contours');
|
||
GetRegisteredImageOperations.RegisterIOClass(TocvRotateOperation, 'Rotate');
|
||
|
||
finalization
|
||
|
||
if Assigned(_RegisteredImageOperations) then
|
||
FreeAndNil(_RegisteredImageOperations);
|
||
|
||
end.
|