unit filter;
(* ***** BEGIN LICENSE BLOCK *****
 * Copyright (C) 2004 Durand Emmanuel
 * Copyright (C) 2004 Burgel Eric
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Contact :
 *   filters@edurand.com
 *   filters@burgel.com
 *
 * ***** END LICENSE BLOCK ***** *)

{
 edurand (filters@edurand.com)
 eburgel (filters@burgel.com)
}

interface
uses
  Classes, Windows, SysUtils, image, fparameters;

const
  _version = '1.8 (2006_0?) beta';

type

  //
  TFilter = class(TObject)
  protected
    Parameters : TList;
    OutputParameters : TList;
    RegionOfInterest : TRect ; // right/bottom is outside, by convention of filters ROI
  public
    constructor Create; virtual;
    destructor Destroy; override;

    // Input Parameters ...
    function addParameterBoolean( const aName,aDescription : String ; const default:Boolean) : TParameterBoolean; virtual ;
    function addParameterInteger( const aName,aDescription : String; const min,max,default:Int64) : TParameterInteger; virtual;
    function addParameterSingle( const aName,aDescription : String; const min,max,default:Single) : TParameterSingle; virtual;
    function addParameterString( const aName,aDescription : String; const default:String) : TParameterString; virtual;
    function addParameterImage( const aName,aDescription : String) : TParameterImage; virtual;
    function addParameterImages( const aName,aDescription : String) : TParameterImages; virtual;
    function addParameterPointer( const aName,aDescription : String) : TParameterPointer; virtual;

    procedure setParameterBoolean( const aName: String;  const aValue: Boolean); virtual ;
    procedure setParameterInteger( const aName: String; const aValue:Int64 ); virtual;
    procedure setParameterSingle( const aName: String; const aValue:Single ); virtual;
    procedure setParameterString( const aName: String; const aValue:String ); virtual;
    procedure setParameterImage( const aName: String; const aImage: PBitmap32); virtual;
    procedure setParameterImages( const aName: String; const aImages: ArrayOfPBitmap32); virtual;
    procedure setParameterPointer( const aName: String; const aPointer: Pointer); virtual;

    function getParameterBoolean( const aName: String) : TParameterBoolean; virtual;
    function getParameterInteger( const aName: String) : TParameterInteger; virtual;
    function getParameterSingle( const aName: String) : TParameterSingle; virtual;
    function getParameterString( const aName: String) : TParameterString; virtual;
    function getParameterImage( const aName: String) : TParameterImage; virtual;
    function getParameterImages( const aName: String) : TParameterImages; virtual;
    function getParameterPointer( const aName: String) : TParameterPointer; virtual;

    // Output Parameters ...
    function addOutputParameterImage( const aName,aDescription : String) : TParameterImage; virtual;
    function addOutputParameterImages( const aName,aDescription : String) : TParameterImages; virtual;
    function addOutputParameterArrayIntegers( const aName,aDescription : String) : TParameterArrayIntegers; virtual;
    function addOutputParameterArraySingles( const aName,aDescription : String) : TParameterArraySingles; virtual;
    function addOutputParameterInteger( const aName,aDescription : String) : TParameterInteger; virtual;
    function addOutputParameterSingle( const aName,aDescription : String) : TParameterSingle; virtual;
    function addOutputParameterArrayPointers( const aName,aDescription : String) : TParameterArrayPointers; virtual;

    procedure setOutputParameterImage( const aName: String; const aImage: PBitmap32); virtual;
    procedure setOutputParameterImages( const aName: String; const aImages: ArrayOfPBitmap32); virtual;
    procedure setOutputParameterArrayIntegers( const aName: String; const aIntegers: array of Integer); virtual;
    procedure setOutputParameterArraySingles( const aName: String; const aSingles: array of Single); virtual;
    procedure setOutputParameterInteger( const aName: String; const aInteger: Integer); virtual;
    procedure setOutputParameterSingle( const aName: String; const aSingle: Single); virtual;
    procedure setOutputParameterArrayPointers( const aName: String; const aPointers: array of Pointer); virtual;

    function getOutputParameterImage( const aName: String) : TParameterImage; virtual;
    function getOutputParameterImages( const aName: String) : TParameterImages; virtual;
    function getOutputParameterArrayIntegers( const aName: String) : TParameterArrayIntegers; virtual;
    function getOutputParameterArraySingles( const aName: String) : TParameterArraySingles; virtual;
    function getOutputParameterInteger( const aName: String) : TParameterInteger; virtual;
    function getOutputParameterSingle( const aName: String) : TParameterSingle; virtual;
    function getOutputParameterArrayPointers( const aName: String) : TParameterArrayPointers; virtual;

    // parameters info
    function getParametersCount() :  Integer;
    function getParameterName( const aIndex : Integer ) : String;
    function getParameterHelp( const aIndex : Integer ) : String;
    function getParameterIndex( const aName:String) : Integer; virtual;
    // output info
    function getOutputsCount() :  Integer;
    function getOutputName( const aIndex : Integer ) : String;
    function getOutputParameterIndex( const aName:String) : Integer; virtual;

    function _getParameterIndex( const aParametersList:TList; const aName:String) : Integer; virtual;

    // Region of interest
    procedure setRegionOfInterest( const r:TRect) ; overload;
    procedure setRegionOfInterest( const x, y, x2, y2 : Integer) ; overload;
    procedure unsetRegionOfInterest() ;
    function getRegionOfInterest( const bitmap : PBitmap32) : TRect;
    function scanline( const bitmap: PBitmap32; const y:Cardinal): PColor32Array;
    function scanWidth ( const bitmap : PBitmap32) : Cardinal ;
    function scanHeight( const bitmap : PBitmap32) : Cardinal ;

    // Filter method
    procedure Run; overload; virtual; abstract;
    procedure Run(command:String); overload; virtual;
  end;

implementation

uses Math ;

constructor TFilter.Create;
begin
  inherited;
  Parameters := TList.Create;
  OutputParameters := TList.Create;
  unsetRegionOfInterest;
end;

destructor TFilter.Destroy;
var
  p : Integer;
  aParameter : TParameter;
begin
  try
    for p := 0 to (Parameters.Count - 1) do begin
      aParameter := Parameters.Items[p];
      aParameter.Free;
    end;
  finally
    Parameters.Free;
  end;
  try
    for p := 0 to (OutputParameters.Count - 1) do begin
      aParameter := OutputParameters.Items[p];
      aParameter.Free;
    end;
  finally
    OutputParameters.Free;
  end;
  inherited;
end;

procedure TFilter.Run(command:String);
begin
  if (command='') or (command='run') then begin
    Run;
  end;
end;

function TFilter.getParametersCount() : Integer;
begin
  Result := Parameters.Count;
end;

function TFilter.getParameterName( const aIndex : Integer ) : String;
var
  aParameter : TParameter;
begin
  aParameter := Parameters.Items[ aIndex ];
  Result := aParameter.Name;
end;

function TFilter.getParameterHelp( const aIndex : Integer ) : String;
var
  aParameter : TParameter;
begin
  aParameter := Parameters.Items[ aIndex ];
  Result := aParameter.Help;
end;

function TFilter.getParameterIndex( const aName:String) : Integer;
begin
  Result:=_getParameterIndex(Parameters,aName);
end;

function TFilter.getOutputsCount() : Integer;
begin
  Result := OutputParameters.Count;
end;

function TFilter.getOutputName( const aIndex : Integer ) : String;
var
  aOutputParameter : TParameter;
begin
  aOutputParameter := OutputParameters.Items[ aIndex ];
  Result := aOutputParameter.Name;
end;

function TFilter.getOutputParameterIndex( const aName:String) : Integer;
begin
  Result:=_getParameterIndex(OutputParameters,aName);
end;

function TFilter._getParameterIndex( const aParametersList:TList; const aName:String) : Integer;
var
  index, p : Integer;
  aParameter : TParameter;
begin
  index:=-1;  p:=0;
  while((p<aParametersList.Count) and (index=-1)) do begin
    aParameter := aParametersList.Items[p];
    if(aParameter.Name=aName) then begin
      index := p;
    end;
    Inc(p);
  end;
  if(index=-1) then begin
    raise EParameterNotFound.Create('Unable to found parameter ['+aName+']');
  end;
  Result:=index;
end;

// *************** Add^parameter functions ***************
function TFilter.addParameterBoolean(const aName,aDescription : String ;  const default:Boolean) : TParameterBoolean;
var
  parameter : TParameterBoolean;
begin
  parameter:=TParameterBoolean.Create(aName,aDescription,default);
  Parameters.Add(parameter);
  Result:=parameter;
end;


function TFilter.addParameterInteger( const aName,aDescription : String; const min,max,default:Int64) : TParameterInteger;
var
  parameter : TParameterInteger;
begin
  parameter:=TParameterInteger.Create(aName,aDescription,min,max,default);
  Parameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addParameterSingle( const aName,aDescription : String; const min,max,default:Single) : TParameterSingle;
var
  parameter : TParameterSingle;
begin
  parameter:=TParameterSingle.Create(aName,aDescription,min,max,default);
  Parameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addParameterString( const aName, aDescription, default: String): TParameterString;
var
  parameter : TParameterString;
begin
  parameter:=TParameterString.Create(aName,aDescription,default);
  Parameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addParameterImage( const aName,aDescription : String) : TParameterImage;
var
  parameter : TParameterImage;
begin
  parameter:=TParameterImage.Create(aName,aDescription);
  Parameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addParameterImages( const aName,aDescription : String) : TParameterImages;
var
  parameter : TParameterImages;
begin
  parameter:=TParameterImages.Create(aName,aDescription);
  Parameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addParameterPointer( const aName,aDescription : String) : TParameterPointer;
var
  parameter : TParameterPointer;
begin
  parameter:=TParameterPointer.Create(aName,aDescription);
  Parameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addOutputParameterImage( const aName,aDescription : String) : TParameterImage;
var
  parameter : TParameterImage;
begin
  parameter:=TParameterImage.Create(aName,aDescription);
  OutputParameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addOutputParameterImages( const aName,aDescription : String) : TParameterImages;
var
  parameter : TParameterImages;
begin
  parameter:=TParameterImages.Create(aName,aDescription);
  OutputParameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addOutputParameterArrayIntegers( const aName,aDescription : String) : TParameterArrayIntegers;
var
  parameter : TParameterArrayIntegers;
begin
  parameter:=TParameterArrayIntegers.Create(aName,aDescription);
  OutputParameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addOutputParameterArraySingles( const aName,aDescription : String) : TParameterArraySingles;
var
  parameter : TParameterArraySingles;
begin
  parameter:=TParameterArraySingles.Create(aName,aDescription);
  OutputParameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addOutputParameterInteger( const aName,aDescription : String) : TParameterInteger;
var
  parameter : TParameterInteger;
begin
  parameter:=TParameterInteger.Create(aName,aDescription,-MAXINT,MAXINT,0);
  OutputParameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addOutputParameterSingle( const aName,aDescription : String) : TParameterSingle;
var
  parameter : TParameterSingle;
begin
  parameter:=TParameterSingle.Create(aName,aDescription,-1.1754943508222875079687365372222E-38,3.4028236692093846346337460743177E+38,0);
  OutputParameters.Add(parameter);
  Result:=parameter;
end;

function TFilter.addOutputParameterArrayPointers( const aName,aDescription : String) : TParameterArrayPointers;
var
  parameter : TParameterArrayPointers;
begin
  parameter:=TParameterArrayPointers.Create(aName,aDescription);
  OutputParameters.Add(parameter);
  Result:=parameter;
end;

procedure TFilter.setParameterImage( const aName: String; const aImage: PBitmap32);
begin
  getParameterImage(aName).Image:=aImage;
end;

procedure TFilter.setParameterImages( const aName: String; const aImages: ArrayOfPBitmap32);
var
  parameter : TParameterImages;
begin
  parameter:=getParameterImages(aName);
  parameter.Images := aImages ;
end;

procedure TFilter.setParameterPointer( const aName: String; const aPointer: Pointer);
var
  parameter : TParameterPointer;
begin
  parameter:=getParameterPointer(aName);
  parameter.Value := aPointer ;
end;

procedure TFilter.setOutputParameterImage( const aName: String; const aImage: PBitmap32);
var
  parameter : TParameterImage;
begin
  parameter:=getOutputParameterImage(aName);
  parameter.Image:=aImage;
end;

procedure TFilter.setOutputParameterImages( const aName: String; const aImages: ArrayOfPBitmap32);
var
  parameter : TParameterImages;
begin
  parameter:=getOutputParameterImages(aName);
  parameter.Images:=aImages;
end;

procedure TFilter.setOutputParameterArrayIntegers( const aName: String; const aIntegers: array of Integer);
var
  i : Integer;
  parameter : TParameterArrayIntegers;
begin
  parameter:=getOutputParameterArrayIntegers(aName);
  SetLength(parameter.Integers,0);
  SetLength(parameter.Integers,Length(aIntegers));
  for i:=0 to Length(parameter.Integers) -1 do begin
    parameter.Integers[i]:=aIntegers[i];
  end;
end;

procedure TFilter.setOutputParameterArraySingles( const aName: String; const aSingles: array of Single);
var
  i : Integer;
  parameter : TParameterArraySingles;
begin
  parameter:=getOutputParameterArraySingles(aName);
  SetLength(parameter.Singles,0);
  SetLength(parameter.Singles,Length(aSingles));
  for i:=0 to Length(parameter.Singles) -1 do begin
    parameter.Singles[i]:=aSingles[i];
  end;
end;

procedure TFilter.setOutputParameterInteger( const aName: String; const aInteger: Integer);
var
  parameter : TParameterInteger;
begin
  parameter:=getOutputParameterInteger(aName);
  parameter.Value:=aInteger;
end;

procedure TFilter.setOutputParameterSingle( const aName: String; const aSingle: Single);
var
  parameter : TParameterSingle;
begin
  parameter:=getOutputParameterSingle(aName);
  parameter.Value:=aSingle;
end;

procedure TFilter.setOutputParameterArrayPointers( const aName: String; const aPointers: array of Pointer);
var
  i : Integer;
  parameter : TParameterArrayPointers;
begin
  parameter:=getOutputParameterArrayPointers(aName);
  SetLength(parameter.Pointers,0);
  SetLength(parameter.Pointers,Length(aPointers));
  for i:=0 to Length(parameter.Pointers) -1 do begin
    parameter.Pointers[i]:=aPointers[i];
  end;
end;

function TFilter.getParameterImage( const aName: String) : TParameterImage;
var
  index : Integer;
  parameter : TParameterImage;
begin
  index:=getParameterIndex(aName);
  parameter:=Parameters.Items[index];
  Result:=parameter;
end;

function TFilter.getParameterImages( const aName: String) : TParameterImages;
var
  index : Integer;
  parameter : TParameterImages;
begin
  index:=getParameterIndex(aName);
  parameter:=Parameters.Items[index];
  Result:=parameter;
end;

function TFilter.getParameterPointer( const aName: String) : TParameterPointer;
var
  index : Integer;
  parameter : TParameterPointer;
begin
  index:=getParameterIndex(aName);
  parameter:=Parameters.Items[index];
  Result:=parameter;
end;

function TFilter.getOutputParameterImage( const aName: String) : TParameterImage;
var
  index : Integer;
  parameter : TParameterImage;
begin
  index:=getOutputParameterIndex(aName);
  parameter:=OutputParameters.Items[index];
  Result:=parameter;
end;

function TFilter.getOutputParameterImages( const aName: String) : TParameterImages;
var
  index : Integer;
  parameter : TParameterImages;
begin
  index:=getOutputParameterIndex(aName);
  parameter:=OutputParameters.Items[index];
  Result:=parameter;
end;

function TFilter.getOutputParameterArrayIntegers( const aName: String) : TParameterArrayIntegers;
var
  index : Integer;
  parameter : TParameterArrayIntegers;
begin
  index:=getOutputParameterIndex(aName);
  parameter:=OutputParameters.Items[index];
  Result:=parameter;
end;

function TFilter.getOutputParameterArraySingles( const aName: String) : TParameterArraySingles;
var
  index : Integer;
  parameter : TParameterArraySingles;
begin
  index:=getOutputParameterIndex(aName);
  parameter:=OutputParameters.Items[index];
  Result:=parameter;
end;

function TFilter.getOutputParameterInteger( const aName: String) : TParameterInteger;
var
  index : Integer;
  parameter : TParameterInteger;
begin
  index:=getOutputParameterIndex(aName);
  parameter:=OutputParameters.Items[index];
  Result:=parameter;
end;

function TFilter.getOutputParameterSingle( const aName: String) : TParameterSingle;
var
  index : Integer;
  parameter : TParameterSingle;
begin
  index:=getOutputParameterIndex(aName);
  parameter:=OutputParameters.Items[index];
  Result:=parameter;
end;

function TFilter.getOutputParameterArrayPointers( const aName: String) : TParameterArrayPointers;
var
  index : Integer;
  parameter : TParameterArrayPointers;
begin
  index:=getOutputParameterIndex(aName);
  parameter:=OutputParameters.Items[index];
  Result:=parameter;
end;

procedure TFilter.setParameterBoolean( const aName: String;  const aValue: Boolean);
var
  parameter : TParameterBoolean;
begin
  parameter:=getParameterBoolean(aName);
  if parameter.DataType<>dtBoolean then raise EParameterInvalidDataType.Create('you use a bad setter for this parameter');
  parameter.Value:=aValue;
end;


procedure TFilter.setParameterInteger( const aName: String;  const aValue: Int64);
var
  parameter : TParameterInteger;
begin
  parameter:=getParameterInteger(aName);
  if parameter.DataType<>dtInteger then raise EParameterInvalidDataType.Create('you use a bad setter for this parameter');
  if((aValue>=parameter.Min) and (aValue<=parameter.Max)) then begin
    parameter.Value:=aValue;
  end else begin
    raise EParameterValueOutOfBound.Create('Unable to set value ['+IntToStr(aValue)+'] for parameter ['+aName+'] : Min=['+IntToStr(parameter.Min)+'], Max=['+IntToStr(parameter.Max)+']');
  end;
end;

procedure TFilter.setParameterSingle(const aName: String;  const aValue: Single);
var
  parameter : TParameterSingle;
begin
  parameter:=getParameterSingle(aName);
  if parameter.DataType<>dtSingle then raise EParameterInvalidDataType.Create('you use a bad setter for this parameter');
  if((aValue>=parameter.Min) and (aValue<=parameter.Max)) then begin
    parameter.Value:=aValue;
  end else begin
    raise EParameterValueOutOfBound.Create(Format('Unable to set value %f for parameter %s', [aValue, aName]));
  end;
end;

procedure TFilter.setParameterString( const aName: String;  const aValue: String);
var
  parameter : TParameterString;
begin
  parameter:=getParameterString(aName);
  if parameter.DataType<>dtString then raise EParameterInvalidDataType.Create('you use a bad setter for this parameter');
  parameter.Value:=aValue;
end;


//*********** Get Parameter functions *********************************

function TFilter.getParameterboolean( const aName: String) : TParameterBoolean;
var
  index : Integer;
  parameter : TParameterBoolean;
begin
  index:=getParameterIndex(aName);
  parameter:=Parameters.Items[index];
  Result:=parameter;
end;

function TFilter.getParameterInteger( const aName: String) : TParameterInteger;
var
  index : Integer;
  parameter : TParameterInteger;
begin
  index:=getParameterIndex(aName);
  parameter:=Parameters.Items[index];
  Result:=parameter;
end;

function TFilter.getParameterSingle(const aName: String) : TParameterSingle;
var
  index : Integer;
  parameter : TParameterSingle;
begin
  index:=getParameterIndex(aName);
  parameter:=Parameters.Items[index];
  Result:=parameter;
end;

function TFilter.getParameterString( const aName: String) : TParameterString;
var
  index : Integer;
  parameter : TParameterString;
begin
  index:=getParameterIndex(aName);
  parameter:=Parameters.Items[index];
  Result:=parameter;
end;

function TFilter.scanline( const bitmap: PBitmap32; const y:Cardinal): PColor32Array;
begin
  result := scanlineWithROI(bitmap, RegionOfInterest, y) ;
end;

Procedure TFilter.setRegionOfInterest( const x, y, x2, y2 : Integer) ;
var
  validROI : TRect;
Begin
  RegionOfInterest.Left   := x;
  RegionOfInterest.Top    := y;
  RegionOfInterest.Right  := x2;
  RegionOfInterest.Bottom := y2;
  //   Right
  if RegionOfInterest.Right<1 then
    validROI.Right:=1
  else
    validROI.Right:=RegionOfInterest.Right;
  //  Left
  if RegionOfInterest.Left<0 then
    validROI.Left:=0
  else if RegionOfInterest.Left>validROI.Right then
    validROI.Left:=validROI.Right-1
  else
    validROI.Left:=RegionOfInterest.Left;
  //   Bottom
  if RegionOfInterest.Bottom<1 then
    validROI.Bottom:=1
  else
    validROI.Bottom:=RegionOfInterest.Bottom;
  //  Top
  if RegionOfInterest.Top<0 then
    validROI.Top:=0
  else if RegionOfInterest.Top>validROI.Bottom then
    validROI.Top:=validROI.Bottom-1
  else
    validROI.Top:=RegionOfInterest.Top;

  RegionOfInterest:=validROI;
End ;

Procedure TFilter.setRegionOfInterest( const r:TRect) ;
Begin
  setRegionOfInterest(r.Left,r.Top,r.Right,r.Bottom);
End ;

Procedure TFilter.unsetRegionOfInterest() ;
Begin
  with RegionOfInterest do Begin
    Left := 0 ;
    Top := 0 ;
    Right := 0 ;
    Bottom := 0 ;
  end ;
End ;

function TFilter.getRegionOfInterest(const bitmap : PBitmap32) : TRect;
begin
  Result:=image.getValidROI(bitmap,RegionOfInterest);
end;

function TFilter.scanHeight( const bitmap : PBitmap32) : Cardinal ;
begin
  if RegionOfInterest.Bottom = 0 then Begin
    Result := bitmap.Height-RegionOfInterest.Top ;
  End else Begin
    Result := min(bitmap.Height, RegionOfInterest.Bottom)-RegionOfInterest.Top ;
  End ;
end;

function TFilter.scanWidth ( const bitmap : PBitmap32) : Cardinal ;
begin
  if RegionOfInterest.Right = 0 then Begin
    //Result := bitmap.Width-1 ;
    Result := bitmap.Width-RegionOfInterest.left ;
  End else Begin
    Result := min(bitmap.Width, RegionOfInterest.Right)-RegionOfInterest.Left ;
  End ;
end;

end.