diff --git a/PACKAGES.md b/PACKAGES.md index efa211635..5b79ed1e5 100644 --- a/PACKAGES.md +++ b/PACKAGES.md @@ -67,4 +67,4 @@ Example: www.testversions.com "name" : "versionname" } ] -``` +``` \ No newline at end of file diff --git a/Source/Simba.lpi b/Source/Simba.lpi index e3478086b..1279b0195 100644 --- a/Source/Simba.lpi +++ b/Source/Simba.lpi @@ -267,7 +267,7 @@ - + @@ -704,6 +704,26 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/Source/generics/simba.generics_matrix.pas b/Source/generics/simba.generics_matrix.pas index bcdc57860..a23b55b45 100644 --- a/Source/generics/simba.generics_matrix.pas +++ b/Source/generics/simba.generics_matrix.pas @@ -182,24 +182,32 @@ implementation var X, Y, Width, Height: Integer; Value: _T; + HasValue: Boolean; begin MinValue := Default(_T); MaxValue := Default(_T); + HasValue := False; if specialize MatrixSize<_T>(Matrix, Width, Height) then begin Width -= 1; Height -= 1; - MinValue := Matrix[0,0]; - MaxValue := Matrix[0,0]; - for Y := 0 to Height do for X := 0 to Width do begin Value := Matrix[Y, X]; + if IsNumber(Value) then begin + if (not HasValue) then + begin + HasValue := True; + + MinValue := Value; + MaxValue := Value; + end; + if (Value > MaxValue) then MaxValue := Value; if (Value < MinValue) then MinValue := Value; end; diff --git a/Source/helpers/simba.helpers_matrix.pas b/Source/helpers/simba.helpers_matrix.pas index f566fca36..44e866593 100644 --- a/Source/helpers/simba.helpers_matrix.pas +++ b/Source/helpers/simba.helpers_matrix.pas @@ -7,6 +7,8 @@ {$i simba.inc} +{$MODESWITCH ARRAYOPERATORS OFF} + interface uses @@ -70,14 +72,6 @@ interface procedure MeanStdev(out MeanValue, Stdev: Double); end; - TComplexMatrixHelper = type helper for TComplexMatrix - function Width: Integer; - function Height: Integer; - function Area: Integer; - function Size(out AWidth, AHeight: Integer): Boolean; - procedure SetSize(const AWidth, AHeight: Integer); - end; - TByteMatrixHelper = type helper for TByteMatrix function Width: Integer; function Height: Integer; @@ -184,31 +178,6 @@ procedure TDoubleMatrixHelper.MeanStdev(out MeanValue, Stdev: Double); specialize MatrixMeanStdev(Self, MeanValue, Stdev); end; -function TComplexMatrixHelper.Width: Integer; -begin - Result := specialize MatrixWidth(Self); -end; - -function TComplexMatrixHelper.Height: Integer; -begin - Result := specialize MatrixHeight(Self); -end; - -function TComplexMatrixHelper.Area: Integer; -begin - Result := specialize MatrixArea(Self); -end; - -function TComplexMatrixHelper.Size(out AWidth, AHeight: Integer): Boolean; -begin - Result := specialize MatrixSize(Self, AWidth, AHeight); -end; - -procedure TComplexMatrixHelper.SetSize(const AWidth, AHeight: Integer); -begin - specialize MatrixSetSize(Self, AWidth, AHeight); -end; - function TIntegerMatrixHelper.Width: Integer; begin Result := specialize MatrixWidth(Self); diff --git a/Source/matchtemplate/simba.fftpack4.pas b/Source/matchtemplate/simba.fftpack4.pas index 64c660a76..c9ec25fec 100644 --- a/Source/matchtemplate/simba.fftpack4.pas +++ b/Source/matchtemplate/simba.fftpack4.pas @@ -21,24 +21,23 @@ interface uses - sysutils, - simba.fftpack4_core, simba.mufasatypes, - simba.helpers_matrix; + sysutils, math, + simba.math, simba.mufasatypes, simba.matchtemplate_matrix; type TFFTPACK = record - function OptimalDFTSize(target: Int32): Int32; + function OptimalDFTSize(const target: Integer): Integer; - function InitFFT(n: Int32): TComplexArray; - function FFT(a, wsave: TComplexArray; Inplace: Boolean=False): TComplexArray; - function IFFT(a, wsave: TComplexArray; Inplace: Boolean=False): TComplexArray; + function InitFFT(const n: Integer): TComplexArray; + function FFT(const a, wsave: TComplexArray; const Inplace: Boolean = False): TComplexArray; + function IFFT(const a, wsave: TComplexArray; const Inplace: Boolean = False): TComplexArray; - function InitRFFT(n: Int32): TSingleArray; - function RFFT(a, wsave: TSingleArray; Inplace: Boolean=False): TSingleArray; - function IRFFT(a, wsave: TSingleArray; Inplace: Boolean=False): TSingleArray; + function InitRFFT(const n: Integer): TSingleArray; + function RFFT(const a, wsave: TSingleArray; const Inplace: Boolean = False): TSingleArray; + function IRFFT(const a, wsave: TSingleArray; const Inplace: Boolean = False): TSingleArray; - function FFT2(m: TComplexMatrix): TComplexMatrix; - function IFFT2(m: TComplexMatrix): TComplexMatrix; + function FFT2(const m: TComplexMatrix): TComplexMatrix; + function IFFT2(const m: TComplexMatrix): TComplexMatrix; end; var @@ -47,8 +46,7 @@ TFFTPACK = record implementation uses - math, - simba.matchtemplate_matrix, simba.math; + simba.fftpack4_core; const __OptimalDFT: array[0..168] of Integer = ( @@ -74,7 +72,7 @@ implementation // -------------------------------------------------------------------------------- // Compute the optimal size for FFT -function TFFTPACK.OptimalDFTSize(target: Integer): Integer; +function TFFTPACK.OptimalDFTSize(const target: Integer): Integer; var n,match,quotient,p2,p5,p35: Integer; begin @@ -121,13 +119,13 @@ function TFFTPACK.OptimalDFTSize(target: Integer): Integer; // -------------------------------------------------------------------------------- // complex 2 complex FFT -function TFFTPACK.InitFFT(n: Integer): TComplexArray; +function TFFTPACK.InitFFT(const n: Integer): TComplexArray; begin SetLength(Result, CPLX_BUFFSZ); cffti(n, @Result[0]); end; -function TFFTPACK.FFT(a, wsave: TComplexArray; Inplace:Boolean=False): TComplexArray; +function TFFTPACK.FFT(const a, wsave: TComplexArray; const Inplace: Boolean): TComplexArray; var n: Integer; begin if Inplace then Result := a @@ -137,7 +135,7 @@ function TFFTPACK.FFT(a, wsave: TComplexArray; Inplace:Boolean=False): TComplexA cfftf(n, @Result[0], @wsave[0]); end; -function TFFTPACK.IFFT(a, wsave: TComplexArray; Inplace:Boolean=False): TComplexArray; +function TFFTPACK.IFFT(const a, wsave: TComplexArray; const Inplace: Boolean): TComplexArray; var n: Integer; f: Single; @@ -159,13 +157,13 @@ function TFFTPACK.IFFT(a, wsave: TComplexArray; Inplace:Boolean=False): TComplex // -------------------------------------------------------------------------------- // real 2 real FFT -function TFFTPACK.InitRFFT(n: Integer): TSingleArray; +function TFFTPACK.InitRFFT(const n: Integer): TSingleArray; begin SetLength(Result, REAL_BUFFSZ); rffti(n, @Result[0]); end; -function TFFTPACK.RFFT(a, wsave: TSingleArray; Inplace:Boolean=False): TSingleArray; +function TFFTPACK.RFFT(const a, wsave: TSingleArray; const Inplace: Boolean): TSingleArray; var n: Integer; begin if Inplace then Result := a @@ -175,7 +173,7 @@ function TFFTPACK.RFFT(a, wsave: TSingleArray; Inplace:Boolean=False): TSingleAr rfftf(n, @Result[0], @wsave[0]); end; -function TFFTPACK.IRFFT(a, wsave: TSingleArray; Inplace:Boolean=False): TSingleArray; +function TFFTPACK.IRFFT(const a, wsave: TSingleArray; const Inplace: Boolean): TSingleArray; var n: Integer; f: Single; @@ -193,52 +191,40 @@ function TFFTPACK.IRFFT(a, wsave: TSingleArray; Inplace:Boolean=False): TSingleA // -------------------------------------------------------------------------------- // 2d complex fft -function TFFTPACK.FFT2(m: TComplexMatrix): TComplexMatrix; +function TFFTPACK.FFT2(const m: TComplexMatrix): TComplexMatrix; var - W,H,Y: Integer; + Y: Integer; plan: TComplexArray; + rot: TComplexMatrix; begin - W := M.Width; - H := M.Height; - - plan := InitFFT(W); - for Y := 0 to H - 1 do + plan := InitFFT(m.Width); + for Y := 0 to m.Height - 1 do FFTPACK.FFT(m[Y], Plan, True); - m := Rot90(m); - - W := M.Width; - H := M.Height; - - plan := InitFFT(W); - for Y := 0 to H - 1 do - FFTPACK.FFT(m[Y], Plan, True); + rot := Rot90(m); + plan := InitFFT(rot.Width); + for Y := 0 to rot.Height - 1 do + FFTPACK.FFT(rot[Y], Plan, True); - Result := Rot90(m); + Result := Rot90(rot); end; -function TFFTPACK.IFFT2(m: TComplexMatrix): TComplexMatrix; +function TFFTPACK.IFFT2(const m: TComplexMatrix): TComplexMatrix; var - W,H,Y: Integer; + Y: Integer; plan: TComplexArray; + rot: TComplexMatrix; begin - W := M.Width; - H := M.Height; - - plan := InitFFT(W); - for Y := 0 to H - 1 do + plan := InitFFT(m.Width); + for Y := 0 to m.Height - 1 do FFTPACK.IFFT(m[Y], Plan, True); - m := Rot90(m); - - W := M.Width; - H := M.Height; - - plan := InitFFT(W); - for Y := 0 to H - 1 do - FFTPACK.IFFT(m[Y], Plan, True); + rot := Rot90(m); + plan := InitFFT(rot.Width); + for Y := 0 to rot.Height - 1 do + FFTPACK.IFFT(rot[Y], Plan, True); - Result := Rot90(m); + Result := Rot90(rot); end; end. diff --git a/Source/matchtemplate/simba.matchtemplate.pas b/Source/matchtemplate/simba.matchtemplate.pas index 64bffb5c9..c630a63ca 100644 --- a/Source/matchtemplate/simba.matchtemplate.pas +++ b/Source/matchtemplate/simba.matchtemplate.pas @@ -14,11 +14,7 @@ See the License for the specific language governing permissions and limitations under the License. - 2021: Olly brings mask template matching thanks to OpenCV: - https://github.com/opencv/opencv/blob/5b095dfcb669f87c2a767806a3dd9bd56e035a1c/modules/imgproc/src/templmatch.cpp#L837 - - - Currently only TM_CCOEFF and TM_CCOEFF_NORMED. - - Cache system if Image & Mask are static. + Mask template matching implemented from OpenCV's templmatch.cpp [==============================================================================} {$DEFINE SIMBA_O4} @@ -30,7 +26,7 @@ interface uses classes, sysutils, - simba.mufasatypes, simba.baseclass; + simba.mufasatypes, simba.baseclass, simba.bitmap; type PTMFormula = ^ETMFormula; @@ -43,496 +39,101 @@ interface TM_SQDIFF_NORMED ); - PMatchTemplateCache = ^TMatchTemplateCache; - TMatchTemplateCache = class(TSimbaBaseClass) + PMatchTemplateCacheBase = ^TMatchTemplateCacheBase; + TMatchTemplateCacheBase = class(TSimbaBaseClass) public - constructor Create(const Image, Templ: TIntegerMatrix); virtual; abstract; + Width: Integer; + Height: Integer; end; - TMatchTemplateCacheClass = class of TMatchTemplateCache; - TSimbaMatchTemplateClass = class of TSimbaMatchTemplate; - TSimbaMatchTemplate = class - protected - class procedure Validate(const ImageWidth, ImageHeight, TemplateWidth, TemplateHeight: Integer); - public - class function CacheClass: TMatchTemplateCacheClass; virtual; +function MatchTemplateCache(Image, Template: TIntegerMatrix; Formula: ETMFormula): TMatchTemplateCacheBase; overload; +function MatchTemplateCache(Image, Template: TMufasaBitmap; Formula: ETMFormula): TMatchTemplateCacheBase; overload; +function MatchTemplateMask(Cache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; overload; +function MatchTemplateMask(Cache: TMatchTemplateCacheBase; Template: TMufasaBitmap; Formula: ETMFormula): TSingleMatrix; overload; +function MatchTemplateMask(Image, Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; overload; - class function MatchTemplateMask(const Cache: TMatchTemplateCache; const Template: TIntegerMatrix; const Formula: ETMFormula): TSingleMatrix; virtual; overload; - class function MatchTemplateMask(const Image, Template: TIntegerMatrix; const Formula: ETMFormula): TSingleMatrix; virtual; overload; - - class function MatchTemplate(const Image, Template: TIntegerMatrix; const Formula: ETMFormula): TSingleMatrix; virtual; - end; - -var - SimbaMatchTemplate: TSimbaMatchTemplateClass; +function MatchTemplate(Image, Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; implementation uses - math, - simba.FFTPACK4, simba.helpers_matrix, - simba.matchtemplate_matrix, simba.matchtemplate_multithread; - -// ----------------------------------------------------------------------------- -// Helpers - -function DoFFT2(const Matrix: TSingleMatrix; const outW, outH: Integer): TComplexMatrix; -var - Spec: TComplexMatrix; - X, Y, W, H: Integer; -begin - Spec.SetSize(FFTPACK.OptimalDFTSize(OutW), FFTPACK.OptimalDFTSize(OutH)); - - W := Matrix.Width - 1; - H := Matrix.Height - 1; - for Y := 0 to H do - for X := 0 to W do - Spec[Y, X].Re := Matrix[Y, X]; - - Result := FFTPACK.FFT2(Spec); -end; - -function DoIFFT2(Spec: TComplexMatrix; const outW, outH: Integer): TSingleMatrix; -var - X, Y, W, H: Integer; -begin - Spec := FFTPACK.IFFT2(Spec); - - Result.SetSize(OutW, OutH); - - W := OutW - 1; - H := OutH - 1; - for Y := 0 to H do - for X := 0 to W do - Result[Y, X] := Spec[Y, X].Re; -end; - -// ----------------------------------------------------------------------------- -// a * conj(b) - -function MulSpectrumConj(const A, B: TComplexMatrix): TComplexMatrix; -var - X, Y, W, H: Integer; -begin - Result.SetSize(A.Width, A.Height); - - W := A.Width - 1; - H := A.Height - 1; - - for Y := 0 to H do - for X := 0 to W do - begin - Result[y,x].re := (a[y,x].re * b[y,x].re) - (a[y,x].im * -b[y,x].im); - Result[y,x].im := (a[y,x].re * -b[y,x].im) + (a[y,x].im * b[y,x].re); - end; -end; - -// ----------------------------------------------------------------------------- -// Cross correlate - -function CCORR(const Image, Templ: TSingleMatrix): TSingleMatrix; -var - Spec: TComplexMatrix; -begin - Spec := MulSpectrumConj(DoFFT2(Image, Image.Width, Image.Height), DoFFT2(Templ, Image.Width, Image.Height)); - - Result := DoIFFT2(Spec, Image.Width - Templ.Width + 1, Image.Height - Templ.Height + 1); -end; - -function CCORR(ImageWidth, ImageHeight: Integer; const Image: TComplexMatrix; const Templ: TSingleMatrix): TSingleMatrix; -var - Spec: TComplexMatrix; -begin - Spec := MulSpectrumConj(Image, DoFFT2(Templ, ImageWidth, ImageHeight)); - - Result := DoIFFT2(Spec, ImageWidth - Templ.Width + 1, ImageHeight - Templ.Height + 1); -end; + simba.helpers_matrix, + simba.matchtemplate_ccorr, simba.matchtemplate_sqdiff, simba.matchtemplate_ccoeff; -// ----------------------------------------------------------------------------- -// Cross correlation of R,G,B channels - -function CCORR_RGB(Image, Templ: TIntegerMatrix; out aR,aG,aB, tR,tG,tB: TSingleMatrix): TSingleMatrix; -var - x,y,W,H: Integer; - xR,xG,xB: TSingleMatrix; +procedure Validate(ImageWidth, ImageHeight, TemplateWidth, TemplateHeight: Integer); begin - SplitRGB(Image, aR,aG,aB); - SplitRGB(Templ, tR,tG,tB); - - xR := CCORR(aR,tR); - xG := CCORR(aG,tG); - xB := CCORR(aB,tB); - - Result := xR; - - W := Result.Width - 1; - H := Result.Height - 1; - - for Y := 0 to H do - for X := 0 to W do - Result[Y, X] := xR[Y, X] + xG[Y, X] + xB[Y, X]; -end; - -function CCORR_RGB(ImageWidth, ImageHeight: Integer; const ImageR, ImageG, ImageB: TComplexMatrix; Templ: TRGBMatrix): TRGBMatrix; -begin - Result.R := CCORR(ImageWidth, ImageHeight, ImageR, Templ.R); - Result.G := CCORR(ImageWidth, ImageHeight, ImageG, Templ.G); - Result.B := CCORR(ImageWidth, ImageHeight, ImageB, Templ.B); -end; - -// ---------------------------------------------------------------------------- -// [Normalized] cross correlation of R,G,B channels - -function CCORR_RGB(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; -var - x,y,w,h,tw,th,iw,ih: Integer; - invSize, numer, denom, tplSdv, tplMean, tplSigma, mR,mG,mB, sR,sG,sB, wndSum2: Double; - sum2r, sum2g, sum2b: TDoubleMatrix; - xcorr, aR,aG,aB, tR,tG,tB: TSingleMatrix; -begin - xcorr := CCORR_RGB(Image, Templ, aR,aG,aB, tR,tG,tB); - if not Normed then - Exit(xcorr); - - tw := Templ.Width; - th := Templ.Height; - - invSize := Double(1.0) / Double(tw * th); - - tR.MeanStdev(mR, sR); - tG.MeanStdev(mG, sG); - tB.MeanStdev(mB, sB); - - tplMean := Sqr(mR) + Sqr(mG) + Sqr(mB); - tplSdv := Sqr(sR) + Sqr(sG) + Sqr(sB); - - tplSigma := Sqrt(tplSdv + tplMean) / Sqrt(invSize); - - SumsPd(aR, sum2r); - SumsPd(aG, sum2g); - SumsPd(aB, sum2b); - - iw := sum2r.Width; - ih := sum2r.Height; - - Result.SetSize(iw-tw, ih-th); - - w := iw-tw-1; - h := ih-th-1; - for y := 0 to h do - for x := 0 to w do - begin - wndSum2 := sum2r[Y,X] - sum2r[Y,X+tw] - sum2r[Y+th,X] + sum2r[Y+th,X+tw]; - wndSum2 += sum2g[Y,X] - sum2g[Y,X+tw] - sum2g[Y+th,X] + sum2g[Y+th,X+tw]; - wndSum2 += sum2b[Y,X] - sum2b[Y,X+tw] - sum2b[Y+th,X] + sum2b[Y+th,X+tw]; - - numer := xcorr[Y, X]; - denom := tplSigma * Sqrt(wndSum2); - - if Abs(numer) < denom then - Result[Y, X] := numer / denom - else if abs(numer) < denom*1.25 then - if numer > 0 then Result[Y, X] := 1 else Result[Y, X] := -1; - end; + if (ImageWidth = 0) or (ImageHeight = 0) then + raise Exception.Create('MatchTemplate: Image is empty'); + if (TemplateWidth = 0) or (TemplateHeight = 0) then + raise Exception.Create('MatchTemplate: Template is empty'); + if (TemplateWidth > ImageWidth) or (TemplateHeight > ImageHeight) then + raise Exception.Create('MatchTemplate: Template must be smaller than image'); end; -// ----------------------------------------------------------------------------- -// [Normalized] Cross correlation (coefficient) of R,G,B channels - -function CCOEFF_RGB(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; -var - x,y,w,h,tw,th,iw,ih: Integer; - invSize, numer, denom, tplSdv, tplSigma, wndSum2, wndMean2: Double; - wndSumR, wndSumG, wndSumB: Double; - mR,sR, mG,sG, mB,sB: Double; - sumR, sumG, sumB, sum2r, sum2g, sum2b: TDoubleMatrix; - xcorr, aR,aG,aB, tR,tG,tB: TSingleMatrix; +function MatchTemplateCache(Image, Template: TIntegerMatrix; Formula: ETMFormula): TMatchTemplateCacheBase; begin - xcorr := CCORR_RGB(Image, Templ, aR,aG,aB, tR,tG,tB); - - tw := Templ.Width; - th := Templ.Height; - - invSize := Double(1.0) / Double(tw*th); - - if not Normed then - begin - mR := tR.Mean(); - mG := tG.Mean(); - mB := tB.Mean(); - tplSigma := 0; - end else - begin - tR.MeanStdev(mR, sR); - tG.MeanStdev(mG, sG); - tB.MeanStdev(mB, sB); - - tplSdv := Sqr(sR) + Sqr(sG) + Sqr(sB); - if tplSdv < 0.00001 then - begin - Result.SetSize(xcorr.Width, xcorr.Height); - Result.Fill(1); - Exit; - end; + Validate(Image.Width, Image.Height, Template.Width, Template.Height); - tplSigma := Sqrt(tplSdv) / Sqrt(invSize); + case Formula of + TM_CCOEFF, TM_CCOEFF_NORMED: + Result := MatchTemplateMask_CCOEFF_CreateCache_MT(Image, Template); + TM_CCORR, TM_CCORR_NORMED: + Result := MatchTemplateMask_CCORR_CreateCache_MT(Image, Template); + TM_SQDIFF, TM_SQDIFF_NORMED: + Result := MatchTemplateMask_SQDIFF_CreateCache_MT(Image, Template); end; - - sumR := SumsPd(aR, sum2r); - sumG := SumsPd(aG, sum2g); - sumB := SumsPd(aB, sum2b); - - iw := sum2r.Width; - ih := sum2r.Height; - - Result.SetSize(iw-tw, ih-th); - - w := iw-tw-1; - h := ih-th-1; - for y := 0 to h do - for x := 0 to w do - begin - wndSumR := sumR[Y, X] - sumR[Y,X+tw] - sumR[Y+th,X] + sumR[Y+th,X+tw]; - wndSumG := sumG[Y, X] - sumG[Y,X+tw] - sumG[Y+th,X] + sumG[Y+th,X+tw]; - wndSumB := sumB[Y, X] - sumB[Y,X+tw] - sumB[Y+th,X] + sumB[Y+th,X+tw]; - - numer := xcorr[Y, X] - ((wndSumR * mR) + (wndSumG * mG) + (wndSumB * mB)); - if Normed then - begin - wndSum2 := sum2r[Y, X] - sum2r[Y,X+tw] - sum2r[Y+th,X] + sum2r[Y+th,X+tw]; - wndSum2 += sum2g[Y, X] - sum2g[Y,X+tw] - sum2g[Y+th,X] + sum2g[Y+th,X+tw]; - wndSum2 += sum2b[Y, X] - sum2b[Y,X+tw] - sum2b[Y+th,X] + sum2b[Y+th,X+tw]; - - wndMean2 := Sqr(wndSumR) + Sqr(wndSumG) + Sqr(wndSumB); - wndMean2 := wndMean2 * invSize; - - denom := tplSigma * Sqrt(Max(0, wndSum2 - wndMean2)); - if abs(numer) < denom then - Result[Y, X] := numer / denom - else if abs(numer) < denom*1.25 then - if numer > 0 then Result[Y, X] := 1 else Result[Y, X] := -1; - end else - Result[Y, X] := numer; - end; end; -// ---------------------------------------------------------------------------- -// [Normalized] square difference of R,G,B channels - -function SQDIFF_RGB(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; -var - x,y,w,h,tw,th,iw,ih: Integer; - invSize, numer, denom, tplSigma, tplSum2, wndSum2: Double; - tplMean, tplSdv, mR,sR, mG,sG, mB,sB:Double; - sum2r, sum2g, sum2b: TDoubleMatrix; - xcorr, aR,aG,aB, tR,tG,tB: TSingleMatrix; -begin - xcorr := CCORR_RGB(Image, Templ, aR,aG,aB, tR,tG,tB); - - tw := Templ.Width; - th := Templ.Height; - - invSize := Double(1.0) / Double(tw*th); - - tR.MeanStdev(mR, sR); - tG.MeanStdev(mG, sG); - tB.MeanStdev(mB, sB); - - tplMean := Sqr(mR) + Sqr(mG) + Sqr(mB); - tplSdv := Sqr(sR) + Sqr(sG) + Sqr(sB); - - tplSigma := Sqrt(tplSdv + tplMean) / Sqrt(invSize); - tplSum2 := (tplSdv + tplMean) / invSize; - - SumsPd(aR, sum2r); - SumsPd(aG, sum2g); - SumsPd(aB, sum2b); - - iw := sum2r.Width; - ih := sum2r.Height; - - Result.SetSize(iw-tw, ih-th); - - w := iw-tw-1; - h := ih-th-1; - for y := 0 to h do - for x := 0 to w do - begin - wndSum2 := sum2r[Y, X] - sum2r[Y,X+tw] - sum2r[Y+th,X] + sum2r[Y+th,X+tw]; - wndSum2 += sum2g[Y, X] - sum2g[Y,X+tw] - sum2g[Y+th,X] + sum2g[Y+th,X+tw]; - wndSum2 += sum2b[Y, X] - sum2b[Y,X+tw] - sum2b[Y+th,X] + sum2b[Y+th,X+tw]; - - numer := Max(0, wndSum2 - Double(2.0) * xcorr[Y, X] + tplSum2); - if Normed then - begin - denom := tplSigma * Sqrt(wndSum2); - if abs(numer) < denom then - Result[Y, X] := numer / denom - else - Result[Y, X] := 1; - end else - Result[Y, X] := numer; - end; -end; - -type - TMatchTemplateCachedImage = class(TMatchTemplateCache) - protected - Width: Integer; - Height: Integer; - - ImageSpec: record - R, G, B: TComplexMatrix; - end; - ImageSpecSquared: record - R, G, B: TComplexMatrix; - end; - - MaskChannel: TRGBMatrix; - MaskSum: TDoubleArray; - MaskSumSquared: TDoubleArray; - - ImgNormCorr: TSingleMatrix; - ImgMaskCorr: TRGBMatrix; - public - constructor Create(const Image, Templ: TIntegerMatrix); override; - end; - -constructor TMatchTemplateCachedImage.Create(const Image, Templ: TIntegerMatrix); -var - R, G, B: TSingleMatrix; - X, Y: Integer; +function MatchTemplateCache(Image, Template: TMufasaBitmap; Formula: ETMFormula): TMatchTemplateCacheBase; begin - SplitRGB(Image, R, G, B); - - Width := Image.Width; - Height := Image.Height; - - ImageSpec.R := DoFFT2(R, Width, Height); - ImageSpec.G := DoFFT2(G, Width, Height); - ImageSpec.B := DoFFT2(B, Width, Height); - - ImageSpecSquared.R := DoFFT2(R*R, Width, Height); - ImageSpecSquared.G := DoFFT2(G*G, Width, Height); - ImageSpecSquared.B := DoFFT2(B*B, Width, Height); - - // Template to mask. Binary - MaskChannel.R.SetSize(Templ.Width, Templ.Height); - MaskChannel.G.SetSize(Templ.Width, Templ.Height); - MaskChannel.B.SetSize(Templ.Width, Templ.Height); - - SplitRGB(Templ, MaskChannel.R, MaskChannel.G, MaskChannel.B); - - for Y := 0 to Templ.Height - 1 do - for X := 0 to Templ.Width - 1 do - begin - if (Templ[Y, X] and $FFFFFF) <> 0 then // Mask out Alpha - begin - MaskChannel.R[Y, X] := 1; - MaskChannel.G[Y, X] := 1; - MaskChannel.B[Y, X] := 1; - end; - end; - - MaskSum := Sum(MaskChannel); - MaskSumSquared := Sum(MaskChannel * MaskChannel); - - ImgMaskCorr := CCORR_RGB(Width, Height, ImageSpec.R, ImageSpec.G, ImageSpec.B, MaskChannel); - ImgNormCorr := Sqrt( - CCORR_RGB(Width, Height, ImageSpecSquared.R, ImageSpecSquared.G, ImageSpecSquared.B, MaskChannel * MaskChannel) + - (ImgMaskCorr * [1 / MaskSum[0], 1 / MaskSum[1], 1 / MaskSum[2]]) * - (ImgMaskCorr * [MaskSumSquared[0] / MaskSum[0], MaskSumSquared[1] / MaskSum[1], MaskSumSquared[2] / MaskSum[2]] - CCORR_RGB(Width, Height, ImageSpec.R, ImageSpec.G, ImageSpec.B, MaskChannel * MaskChannel) * [2, 2, 2]) - ); + Result := MatchTemplateCache(Image.ToMatrixBGR(), Template.ToMatrixBGR(), Formula); end; -class function TSimbaMatchTemplate.MatchTemplateMask(const Cache: TMatchTemplateCache; const Template: TIntegerMatrix; const Formula: ETMFormula): TSingleMatrix; -var - TemplChannel, TemplxMask, Corr: TRGBMatrix; - MaskTemplSum, TemplxMaskSum: TDoubleArray; - X, Y, W, H: Integer; +function MatchTemplateMask(Cache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; begin - if (not (Cache is TMatchTemplateCachedImage)) then - raise Exception.Create('Invalid Cache'); - - with Cache as TMatchTemplateCachedImage do - begin - Validate(Width, Height, Template.Width, Template.Height); - - SplitRGB(Template, TemplChannel.R, TemplChannel.G, TemplChannel.B); - - case Formula of - TM_CCOEFF, TM_CCOEFF_NORMED: - begin - MaskTemplSum := Sum(MaskChannel * TemplChannel); - - TemplxMask := MaskChannel * (MaskChannel * (TemplChannel - [MaskTemplSum[0] / MaskSum[0], MaskTemplSum[1] / MaskSum[1], MaskTemplSum[2] / MaskSum[2]])); - TemplxMaskSum := Sum(TemplxMask); - - Corr := CCORR_RGB(Width, Height, ImageSpec.R, ImageSpec.G, ImageSpec.B, TemplxMask) - - ImgMaskCorr * [TemplxMaskSum[0] / MaskSum[0], TemplxMaskSum[1] / MaskSum[1], TemplxMaskSum[2] / MaskSum[2]]; - - Result := Corr.R; - - W := Result.Width - 1; - H := Result.Height - 1; - - for Y := 0 to H do - for X := 0 to W do - Result[Y, X] += Corr.G[Y, X] + Corr.B[Y, X]; + Validate(Cache.Width, Cache.Height, Template.Width, Template.Height); - if (Formula = TM_CCOEFF_NORMED) then - Result /= ImgNormCorr * Norm(TemplxMask); - end; - - else - raise Exception.Create('MatchTemplateMask: Formula not implemented'); - end; + case Formula of + TM_CCOEFF: Result := MatchTemplateMask_CCOEFF_Cache(Cache, Template, False); + TM_CCOEFF_NORMED: Result := MatchTemplateMask_CCOEFF_Cache(Cache, Template, True); + TM_SQDIFF: Result := MatchTemplateMask_SQDIFF_Cache(Cache, Template, False); + TM_SQDIFF_NORMED: Result := MatchTemplateMask_SQDIFF_Cache(Cache, Template, True); + TM_CCORR: Result := MatchTemplateMask_CCORR_Cache(Cache, Template, False); + TM_CCORR_NORMED: Result := MatchTemplateMask_CCORR_Cache(Cache, Template, True); end; end; -class function TSimbaMatchTemplate.MatchTemplateMask(const Image, Template: TIntegerMatrix; const Formula: ETMFormula): TSingleMatrix; -var - Cache: TMatchTemplateCache; +function MatchTemplateMask(Cache: TMatchTemplateCacheBase; Template: TMufasaBitmap; Formula: ETMFormula): TSingleMatrix; begin - Cache := CacheClass.Create(Image, Template); - - try - Result := MatchTemplateMask(Cache, Template, Formula); - finally - Cache.Free(); - end; + Result := MatchTemplateMask(Cache, Template.ToMatrixBGR(), Formula); end; -class function TSimbaMatchTemplate.MatchTemplate(const Image, Template: TIntegerMatrix; const Formula: ETMFormula): TSingleMatrix; +function MatchTemplateMask(Image, Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; begin Validate(Image.Width, Image.Height, Template.Width, Template.Height); case Formula of - TM_CCORR: Result := CCORR_RGB(Image, Template, False); - TM_CCORR_NORMED: Result := CCORR_RGB(Image, Template, True); - TM_CCOEFF: Result := CCOEFF_RGB(Image, Template, False); - TM_CCOEFF_NORMED: Result := CCOEFF_RGB(Image, Template, True); - TM_SQDIFF: Result := SQDIFF_RGB(Image, Template, False); - TM_SQDIFF_NORMED: Result := SQDIFF_RGB(Image, Template, True); + TM_CCOEFF: Result := MatchTemplateMask_CCOEFF_MT(Image, Template, False); + TM_CCOEFF_NORMED: Result := MatchTemplateMask_CCOEFF_MT(Image, Template, True); + TM_SQDIFF: Result := MatchTemplateMask_SQDIFF_MT(Image, Template, False); + TM_SQDIFF_NORMED: Result := MatchTemplateMask_SQDIFF_MT(Image, Template, True); + TM_CCORR: Result := MatchTemplateMask_CCORR_MT(Image, Template, False); + TM_CCORR_NORMED: Result := MatchTemplateMask_CCORR_MT(Image, Template, True); end; end; -class procedure TSimbaMatchTemplate.Validate(const ImageWidth, ImageHeight, TemplateWidth, TemplateHeight: Integer); +function MatchTemplate(Image, Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; begin - if (ImageWidth = 0) or (ImageHeight = 0) then - raise Exception.Create('MatchTemplate: Image is empty'); - if (TemplateWidth = 0) or (TemplateHeight = 0) then - raise Exception.Create('MatchTemplate: Template is empty'); - if (TemplateWidth > ImageWidth) or (TemplateHeight > ImageHeight) then - raise Exception.Create('MatchTemplate: Template must be smaller than image'); -end; + Validate(Image.Width, Image.Height, Template.Width, Template.Height); -class function TSimbaMatchTemplate.CacheClass: TMatchTemplateCacheClass; -begin - Result := TMatchTemplateCachedImage; + case Formula of + TM_CCOEFF: Result := MatchTemplate_CCOEFF_MT(Image, Template, False); + TM_CCOEFF_NORMED: Result := MatchTemplate_CCOEFF_MT(Image, Template, True); + TM_SQDIFF: Result := MatchTemplate_SQDIFF_MT(Image, Template, False); + TM_SQDIFF_NORMED: Result := MatchTemplate_SQDIFF_MT(Image, Template, True); + TM_CCORR: Result := MatchTemplate_CCORR_MT(Image, Template, False); + TM_CCORR_NORMED: Result := MatchTemplate_CCORR_MT(Image, Template, True); + end; end; -initialization - SimbaMatchTemplate := TSimbaMultithreadedMatchTemplate; - end. diff --git a/Source/matchtemplate/simba.matchtemplate_ccoeff.pas b/Source/matchtemplate/simba.matchtemplate_ccoeff.pas new file mode 100644 index 000000000..486700a82 --- /dev/null +++ b/Source/matchtemplate/simba.matchtemplate_ccoeff.pas @@ -0,0 +1,281 @@ +{ + Author: Raymond van Venetië and Merlijn Wajer + Project: Simba (https://github.com/MerlijnWajer/Simba) + License: GNU General Public License (https://www.gnu.org/licenses/gpl-3.0) +} +unit simba.matchtemplate_ccoeff; + +{$DEFINE SIMBA_O4} +{$i simba.inc} + +{$MODESWITCH ARRAYOPERATORS OFF} + +interface + +uses + classes, sysutils, math, + simba.mufasatypes, simba.helpers_matrix, + simba.matchtemplate, simba.matchtemplate_matrix, simba.matchtemplate_helpers; + +function MatchTemplate_CCOEFF(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplate_CCOEFF_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +function MatchTemplateMask_CCOEFF_CreateCache(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +function MatchTemplateMask_CCOEFF(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplateMask_CCOEFF_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +function MatchTemplateMask_CCOEFF_CreateCache_MT(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +function MatchTemplateMask_CCOEFF_Cache(ACache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +implementation + +uses + simba.threadpool; + +type + TMatchTemplateCache_CCOEFF = class(TMatchTemplateCacheBase) + public + Slices: array of record + ImgFFT: TRGBComplexMatrix; + MaskChannels: TRGBMatrix; + MaskSum, MaskSquaredSum: Single; + ImgChannels: TRGBMatrix; + ImgMaskCorr: TSingleMatrix; + ImgNormCorr: TSingleMatrix; + end; + + constructor Create(Image, Template: TIntegerMatrix; Multithread: Boolean); + end; + +constructor TMatchTemplateCache_CCOEFF.Create(Image, Template: TIntegerMatrix; Multithread: Boolean); +var + ImageChannels, ImageMaskCorr: TRGBMatrix; + ImageSlices: TImageSlices; + I: Integer; +begin + inherited Create(); + + if Multithread then + ImageSlices := SliceImage(Image, Template) + else + ImageSlices := [Image]; + + Width := Image.Width; + Height := Image.Height; + + SetLength(Slices, Length(ImageSlices)); + for I := 0 to High(ImageSlices) do + with Slices[I] do + begin + MaskChannels := MaskFromTemplate(Template); + MaskSum := Sum(MaskChannels.R); + MaskSquaredSum := Sum(MaskChannels.R * MaskChannels.R); + + ImageChannels := TRGBMatrix.Create(ImageSlices[I]); + ImageMaskCorr := CrossCorrRGB(ImageChannels, MaskChannels); + + ImgFFT := FFT2_RGB(ImageChannels); + + ImgChannels := ImageChannels; + ImgMaskCorr := ImageChannels.Merge(); + ImgNormCorr := Sqrt( + CrossCorrRGB(ImageChannels * ImageChannels, MaskChannels * MaskChannels) + + (ImageMaskCorr * (1 / MaskSum)) * + (ImageMaskCorr * (MaskSquaredSum / MaskSum) - CrossCorrRGB(ImageChannels, MaskChannels * MaskChannels) * 2) + ); + end; +end; + +function MatchTemplateMask_CCOEFF_CreateCache(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +begin + Result := TMatchTemplateCache_CCOEFF.Create(Image, Template, False); +end; + +function MatchTemplateMask_CCOEFF(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + MaskChannels, TemplChannels, ImageChannels: TRGBMatrix; + ImgNormCorr, ImgMaskCorr: TSingleMatrix; + MaskTemplSum, TemplxMaskSum: TDoubleArray; + TemplxMask: TRGBMatrix; + ImageMaskCorr: TRGBMatrix; + MaskSum, MaskSumSquared: Single; +begin + MaskChannels := MaskFromTemplate(Template); + MaskSum := Sum(MaskChannels.R); + MaskSumSquared := Sum(MaskChannels.R * MaskChannels.R); + + ImageChannels := TRGBMatrix.Create(Image); + ImageMaskCorr := CrossCorrRGB(ImageChannels, MaskChannels); + + ImgMaskCorr := ImageChannels.Merge(); + ImgNormCorr := Sqrt( + CrossCorrRGB(ImageChannels * ImageChannels, MaskChannels * MaskChannels) + + (ImageMaskCorr * (1 / MaskSum)) * + (ImageMaskCorr * (MaskSumSquared / MaskSum) - CrossCorrRGB(ImageChannels, MaskChannels * MaskChannels) * 2) + ); + + TemplChannels := TRGBMatrix.Create(Template); + + MaskTemplSum := Sum(MaskChannels * TemplChannels); + + TemplxMask := MaskChannels * (MaskChannels * (TemplChannels - [MaskTemplSum[0] / MaskSum, MaskTemplSum[1] / MaskSum, MaskTemplSum[2] / MaskSum])); + TemplxMaskSum := Sum(TemplxMask); + + Result := CrossCorrRGB(ImageChannels, TemplxMask).Merge() - (ImgMaskCorr * (TemplxMaskSum[0] / MaskSum) + (TemplxMaskSum[1] / MaskSum) + (TemplxMaskSum[2] / MaskSum)); + if Normed then + Result /= ImgNormCorr * Norm(TemplxMask); +end; + +function MatchTemplateMask_CCOEFF_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +begin + Result := Multithread(Image, Template, @MatchTemplateMask_CCOEFF, Normed); +end; + +function MatchTemplateMask_CCOEFF_CreateCache_MT(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +begin + Result := TMatchTemplateCache_CCOEFF.Create(Image, Template, True); +end; + +function MatchTemplateMask_CCOEFF_Cache(ACache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + Cache: TMatchTemplateCache_CCOEFF absolute ACache; + RowSize: Integer; + + procedure DoMatchTemplate(SliceIndex: Integer); + var + TemplChannel: TRGBMatrix; + MaskTemplSum, TemplxMaskSum: TDoubleArray; + TemplxMask: TRGBMatrix; + Mat: TSingleMatrix; + SliceOffset, Y: Integer; + begin + with Cache.Slices[SliceIndex] do + begin + TemplChannel := TRGBMatrix.Create(Template); + + MaskTemplSum := Sum(MaskChannels * TemplChannel); + + TemplxMask := MaskChannels * (MaskChannels * (TemplChannel - [MaskTemplSum[0] / MaskSum, MaskTemplSum[1] / MaskSum, MaskTemplSum[2] / MaskSum])); + TemplxMaskSum := Sum(TemplxMask); + Mat := CrossCorrRGB(ImgFFT, TemplxMask).Merge() - + (ImgMaskCorr * (TemplxMaskSum[0] / MaskSum) + (TemplxMaskSum[1] / MaskSum) + (TemplxMaskSum[2] / MaskSum)); + if Normed then + Mat /= ImgNormCorr * Norm(TemplxMask); + end; + + SliceOffset := (Cache.Height div Length(Cache.Slices)) * SliceIndex; + for Y := 0 to Mat.Height - 1 do + Move(Mat[Y, 0], Result[SliceOffset + Y, 0], RowSize); + end; + +var + Tasks: TSimbaThreadPoolTasks; + I: Integer; +begin + if (not (ACache is TMatchTemplateCache_CCOEFF)) then + raise Exception.Create('[MatchTemplateMask_CCOEFF]: Invalid cache'); + + Result.SetSize( + (Cache.Width - Template.Width) + 1, + (Cache.Height - Template.Height) + 1 + ); + RowSize := Result.Width * SizeOf(Single); + + if Length(Cache.Slices) > 1 then + begin + SetLength(Tasks, Length(Cache.Slices)); + for I := 0 to High(Tasks) do + Tasks[I] := TSimbaThreadPoolTask.Create(@DoMatchTemplate); + + SimbaThreadPool.RunParallel(Tasks); + end else + DoMatchTemplate(0); +end; + +function MatchTemplate_CCOEFF(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + x,y,w,h,tw,th,iw,ih: Integer; + invSize, numer, denom, tplSdv, tplSigma, wndSum2, wndMean2: Double; + wndSumR, wndSumG, wndSumB: Double; + mR,sR, mG,sG, mB,sB: Double; + sumR, sumG, sumB, sum2r, sum2g, sum2b: TDoubleMatrix; + ImageChannels, TemplChannels: TRGBMatrix; + Corr: TSingleMatrix; +begin + ImageChannels := TRGBMatrix.Create(Image); + TemplChannels := TRGBMatrix.Create(Template); + Corr := CrossCorrRGB(ImageChannels, TemplChannels).Merge(); + + tw := Template.Width; + th := Template.Height; + + invSize := Double(1.0) / Double(tw*th); + + if not Normed then + begin + mR := TemplChannels.R.Mean(); + mG := TemplChannels.G.Mean(); + mB := TemplChannels.B.Mean(); + tplSigma := 0; + end else + begin + TemplChannels.R.MeanStdev(mR, sR); + TemplChannels.G.MeanStdev(mG, sG); + TemplChannels.B.MeanStdev(mB, sB); + + tplSdv := Sqr(sR) + Sqr(sG) + Sqr(sB); + if tplSdv < 0.00001 then + begin + Result.SetSize(Corr.Width, Corr.Height); + Result.Fill(1); + Exit; + end; + + tplSigma := Sqrt(tplSdv) / Sqrt(invSize); + end; + + sumR := SumsPd(ImageChannels.R, sum2r); + sumG := SumsPd(ImageChannels.G, sum2g); + sumB := SumsPd(ImageChannels.B, sum2b); + + iw := sum2r.Width; + ih := sum2r.Height; + + Result.SetSize(iw-tw, ih-th); + + w := iw-tw-1; + h := ih-th-1; + for y := 0 to h do + for x := 0 to w do + begin + wndSumR := sumR[Y, X] - sumR[Y,X+tw] - sumR[Y+th,X] + sumR[Y+th,X+tw]; + wndSumG := sumG[Y, X] - sumG[Y,X+tw] - sumG[Y+th,X] + sumG[Y+th,X+tw]; + wndSumB := sumB[Y, X] - sumB[Y,X+tw] - sumB[Y+th,X] + sumB[Y+th,X+tw]; + + numer := Corr[Y, X] - ((wndSumR * mR) + (wndSumG * mG) + (wndSumB * mB)); + if Normed then + begin + wndSum2 := sum2r[Y, X] - sum2r[Y,X+tw] - sum2r[Y+th,X] + sum2r[Y+th,X+tw]; + wndSum2 += sum2g[Y, X] - sum2g[Y,X+tw] - sum2g[Y+th,X] + sum2g[Y+th,X+tw]; + wndSum2 += sum2b[Y, X] - sum2b[Y,X+tw] - sum2b[Y+th,X] + sum2b[Y+th,X+tw]; + + wndMean2 := Sqr(wndSumR) + Sqr(wndSumG) + Sqr(wndSumB); + wndMean2 := wndMean2 * invSize; + + denom := tplSigma * Sqrt(Max(0, wndSum2 - wndMean2)); + if abs(numer) < denom then + Result[Y, X] := numer / denom + else if abs(numer) < denom*1.25 then + if numer > 0 then Result[Y, X] := 1 else Result[Y, X] := -1; + end else + Result[Y, X] := numer; + end; +end; + +function MatchTemplate_CCOEFF_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +begin + Result := Multithread(Image, Template, @MatchTemplate_CCOEFF, Normed); +end; + +end. + diff --git a/Source/matchtemplate/simba.matchtemplate_ccorr.pas b/Source/matchtemplate/simba.matchtemplate_ccorr.pas new file mode 100644 index 000000000..71240885a --- /dev/null +++ b/Source/matchtemplate/simba.matchtemplate_ccorr.pas @@ -0,0 +1,245 @@ +{ + Author: Raymond van Venetië and Merlijn Wajer + Project: Simba (https://github.com/MerlijnWajer/Simba) + License: GNU General Public License (https://www.gnu.org/licenses/gpl-3.0) +} +unit simba.matchtemplate_ccorr; + +{$DEFINE SIMBA_O4} +{$i simba.inc} + +{$MODESWITCH ARRAYOPERATORS OFF} + +interface + +uses + classes, sysutils, + simba.mufasatypes, simba.helpers_matrix, simba.matchtemplate, + simba.matchtemplate_matrix, simba.matchtemplate_helpers; + +function MatchTemplateMask_CCORR_CreateCache(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +function MatchTemplateMask_CCORR_CreateCache_MT(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; + +function MatchTemplateMask_CCORR(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplateMask_CCORR_Cache(ACache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplateMask_CCORR_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +function MatchTemplate_CCORR(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplate_CCORR_MT(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +implementation + +uses + simba.threadpool; + +type + TMatchTemplateCache_CCORR = class(TMatchTemplateCacheBase) + public + Slices: array of record + ImageChannels, MaskChannels: TRGBMatrix; + Mask2: TRGBMatrix; + TempResult: TSingleMatrix; + end; + + constructor Create(Image, Template: TIntegerMatrix; Multithread: Boolean); + end; + +constructor TMatchTemplateCache_CCORR.Create(Image, Template: TIntegerMatrix; Multithread: Boolean); +var + Img2: TRGBMatrix; + ImageSlices: TImageSlices; + I: Integer; +begin + inherited Create(); + + if Multithread then + ImageSlices := SliceImage(Image, Template) + else + ImageSlices := [Image]; + + Width := Image.Width; + Height := Image.Height; + + SetLength(Slices, Length(ImageSlices)); + for I := 0 to High(ImageSlices) do + with Slices[I] do + begin + MaskChannels := MaskFromTemplate(Template); + ImageChannels := TRGBMatrix.Create(ImageSlices[I]); + Img2 := (ImageChannels * ImageChannels); + Mask2 := (MaskChannels * MaskChannels); + TempResult := CrossCorrRGB(Img2, Mask2).Merge(); + end; +end; + +function MatchTemplateMask_CCORR_CreateCache(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +begin + Result := TMatchTemplateCache_CCORR.Create(Image, Template, False); +end; + +function MatchTemplateMask_CCORR_CreateCache_MT(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +begin + Result := TMatchTemplateCache_CCORR.Create(Image, Template, True); +end; + +function MatchTemplateMask_CCORR(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + MaskChannels, TemplateChannels, ImageChannels: TRGBMatrix; + Img2, Mask2: TRGBMatrix; + Templ2Mask2Sum: Double; + TempResult: TSingleMatrix; + W, H, X, Y: Integer; +begin + MaskChannels := MaskFromTemplate(Template); + TemplateChannels := TRGBMatrix.Create(Template); + ImageChannels := TRGBMatrix.Create(Image); + + Result := CrossCorrRGB(ImageChannels, TemplateChannels * (MaskChannels * MaskChannels)).Merge(); + + if Normed then + begin + // img.mul(img); + Img2 := (ImageChannels * ImageChannels); + // mask.mul(mask); + Mask2 := (MaskChannels * MaskChannels); + // double templ2_mask2_sum = norm(templ.mul(mask), NORM_L2SQR); + Templ2Mask2Sum := SumOfSquares(TemplateChannels * MaskChannels); + + // crossCorr(img2, mask2, temp_result, Point(0, 0), 0, 0); + TempResult := CrossCorrRGB(Img2, Mask2).Merge(); + + // sqrt(templ2_mask2_sum * temp_result, temp_result); + W := Result.Width - 1; + H := Result.Height - 1; + for Y := 0 to H do + for X := 0 to W do + Result[Y, X] := Result[Y, X] / Sqrt(Templ2Mask2Sum * TempResult[Y, X]); + end; +end; + +function MatchTemplateMask_CCORR_Cache(ACache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + Cache: TMatchTemplateCache_CCORR absolute ACache; + RowSize: Integer; + + procedure DoMatchTemplate(SliceIndex: Integer); + var + Mat: TSingleMatrix; + SliceOffset, X, Y, W, H: Integer; + TemplChannels: TRGBMatrix; + Templ2Mask2Sum: Double; + begin + with Cache.Slices[SliceIndex] do + begin + TemplChannels := TRGBMatrix.Create(Template); + Mat := CrossCorrRGB(ImageChannels, TemplChannels * Mask2).Merge(); + + if Normed then + begin + Templ2Mask2Sum := SumOfSquares(TemplChannels * MaskChannels); + + W := Mat.Width - 1; + H := Mat.Height - 1; + for Y := 0 to H do + for X := 0 to W do + Mat[Y, X] := Mat[Y, X] / Sqrt(Templ2Mask2Sum * TempResult[Y, X]); + end; + end; + + SliceOffset := (Cache.Height div Length(Cache.Slices)) * SliceIndex; + for Y := 0 to Mat.Height - 1 do + Move(Mat[Y, 0], Result[SliceOffset + Y, 0], RowSize); + end; + +var + Tasks: TSimbaThreadPoolTasks; + I: Integer; +begin + if (not (ACache is TMatchTemplateCache_CCORR)) then + raise Exception.Create('[MatchTemplateMask_CCORR]: Invalid cache'); + + Result.SetSize( + (Cache.Width - Template.Width) + 1, + (Cache.Height - Template.Height) + 1 + ); + RowSize := Result.Width * SizeOf(Single); + + if Length(Cache.Slices) > 1 then + begin + SetLength(Tasks, Length(Cache.Slices)); + for I := 0 to High(Tasks) do + Tasks[I] := TSimbaThreadPoolTask.Create(@DoMatchTemplate); + + SimbaThreadPool.RunParallel(Tasks); + end else + DoMatchTemplate(0); +end; + +function MatchTemplateMask_CCORR_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +begin + Result := Multithread(Image, Template, @MatchTemplateMask_CCORR, Normed); +end; + +function MatchTemplate_CCORR(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + x,y,w,h,tw,th,iw,ih: Integer; + invSize, numer, denom, tplSdv, tplMean, tplSigma, mR,mG,mB, sR,sG,sB, wndSum2: Double; + sum2r, sum2g, sum2b: TDoubleMatrix; + Corr: TSingleMatrix; + ImageChannels, TemplChannels: TRGBMatrix; +begin + ImageChannels := TRGBMatrix.Create(Image); + TemplChannels := TRGBMatrix.Create(Templ); + Corr := CrossCorrRGB(ImageChannels, TemplChannels).Merge(); + if not Normed then + Exit(Corr); + + tw := Templ.Width; + th := Templ.Height; + + invSize := Double(1.0) / Double(tw * th); + + TemplChannels.R.MeanStdev(mR, sR); + TemplChannels.G.MeanStdev(mG, sG); + TemplChannels.B.MeanStdev(mB, sB); + + tplMean := Sqr(mR) + Sqr(mG) + Sqr(mB); + tplSdv := Sqr(sR) + Sqr(sG) + Sqr(sB); + + tplSigma := Sqrt(tplSdv + tplMean) / Sqrt(invSize); + + SumsPd(ImageChannels.R, sum2r); + SumsPd(ImageChannels.G, sum2g); + SumsPd(ImageChannels.B, sum2b); + + iw := sum2r.Width; + ih := sum2r.Height; + + Result.SetSize(iw-tw, ih-th); + + w := iw-tw-1; + h := ih-th-1; + for y := 0 to h do + for x := 0 to w do + begin + wndSum2 := sum2r[Y,X] - sum2r[Y,X+tw] - sum2r[Y+th,X] + sum2r[Y+th,X+tw]; + wndSum2 += sum2g[Y,X] - sum2g[Y,X+tw] - sum2g[Y+th,X] + sum2g[Y+th,X+tw]; + wndSum2 += sum2b[Y,X] - sum2b[Y,X+tw] - sum2b[Y+th,X] + sum2b[Y+th,X+tw]; + + numer := Corr[Y, X]; + denom := tplSigma * Sqrt(wndSum2); + + if Abs(numer) < denom then + Result[Y, X] := numer / denom + else if abs(numer) < denom*1.25 then + if numer > 0 then Result[Y, X] := 1 else Result[Y, X] := -1; + end; +end; + +function MatchTemplate_CCORR_MT(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +begin + Result := Multithread(Image, Templ, @MatchTemplate_CCORR, Normed); +end; + +end. + diff --git a/Source/matchtemplate/simba.matchtemplate_helpers.pas b/Source/matchtemplate/simba.matchtemplate_helpers.pas new file mode 100644 index 000000000..d117561af --- /dev/null +++ b/Source/matchtemplate/simba.matchtemplate_helpers.pas @@ -0,0 +1,264 @@ +{ + Author: Raymond van Venetië and Merlijn Wajer + Project: Simba (https://github.com/MerlijnWajer/Simba) + License: GNU General Public License (https://www.gnu.org/licenses/gpl-3.0) +} +unit simba.matchtemplate_helpers; + +{$DEFINE SIMBA_O4} +{$i simba.inc} + +{$MODESWITCH ARRAYOPERATORS OFF} + +interface + +uses + classes, sysutils, math, + simba.baseclass, simba.mufasatypes, simba.helpers_matrix, simba.matchtemplate_matrix; + +type + TImageSlices = array of TIntegerMatrix; + TMatchTemplate = function(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +function SliceImage(Image, Template: TIntegerMatrix): TImageSlices; + +function MaskFromTemplate(Templ: TIntegerMatrix): TRGBMatrix; +function Multithread(Image, Templ: TIntegerMatrix; MatchTemplate: TMatchTemplate; Normed: Boolean): TSingleMatrix; + +function FFT2_RGB(Mat: TRGBMatrix): TRGBComplexMatrix; + +function CrossCorr(Image, Templ: TSingleMatrix): TSingleMatrix; +function CrossCorrRGB(Image, Templ: TRGBMatrix): TRGBMatrix; overload; +function CrossCorrRGB(Mat: TRGBComplexMatrix; Templ: TRGBMatrix): TRGBMatrix; overload; + +implementation + +uses + simba.FFTPACK4, simba.threadpool; + +function FFT2_RGB(Mat: TRGBMatrix): TRGBComplexMatrix; +var + Spec: TComplexMatrix; + Width, Height: Integer; + + function GetSpec(Mat: TSingleMatrix): TComplexMatrix; + var + X, Y: Integer; + begin + for Y := 0 to Height do + for X := 0 to Width do + begin + Spec[Y, X].Im := 0; + Spec[Y, X].Re := Mat[Y, X]; + end; + + Result := Spec; + end; + +begin + Result.Width := Mat.Width; + Result.Height := Mat.Height; + + Spec.SetSize(FFTPACK.OptimalDFTSize(Result.Width), FFTPACK.OptimalDFTSize(Result.Height)); + + Width := Result.Width - 1; + Height := Result.Height - 1; + + Result.R := FFTPACK.FFT2(GetSpec(Mat.R)); + Result.G := FFTPACK.FFT2(GetSpec(Mat.G)); + Result.B := FFTPACK.FFT2(GetSpec(Mat.B)); +end; + +function DoFFT2(const Matrix: TSingleMatrix; const outW, outH: Integer): TComplexMatrix; +var + Spec: TComplexMatrix; + X, Y, W, H: Integer; +begin + Spec.SetSize(FFTPACK.OptimalDFTSize(OutW), FFTPACK.OptimalDFTSize(OutH)); + + W := Matrix.Width - 1; + H := Matrix.Height - 1; + for Y := 0 to H do + for X := 0 to W do + Spec[Y, X].Re := Matrix[Y, X]; + + Result := FFTPACK.FFT2(Spec); +end; + +function DoIFFT2(Spec: TComplexMatrix; const outW, outH: Integer): TSingleMatrix; +var + X, Y, W, H: Integer; +begin + Spec := FFTPACK.IFFT2(Spec); + + Result.SetSize(OutW, OutH); + + W := OutW - 1; + H := OutH - 1; + for Y := 0 to H do + for X := 0 to W do + Result[Y, X] := Spec[Y, X].Re; +end; + +// ----------------------------------------------------------------------------- +// a * conj(b) + +function MulSpectrumConj(const A, B: TComplexMatrix): TComplexMatrix; +var + X, Y, W, H: Integer; +begin + Result.SetSize(A.Width, A.Height); + + W := A.Width - 1; + H := A.Height - 1; + + for Y := 0 to H do + for X := 0 to W do + begin + Result[y,x].re := (a[y,x].re * b[y,x].re) - (a[y,x].im * -b[y,x].im); + Result[y,x].im := (a[y,x].re * -b[y,x].im) + (a[y,x].im * b[y,x].re); + end; +end; + +function MaskFromTemplate(Templ: TIntegerMatrix): TRGBMatrix; +var + X, Y, W, H: Integer; +begin + Result := Default(TRGBMatrix); + Result.R.SetSize(Templ.Width, Templ.Height); + Result.G := Result.R; // reference + Result.B := Result.R; // .. + + W := Templ.Width - 1; + H := Templ.Height - 1; + for Y := 0 to H do + for X := 0 to W do + if (Templ[Y, X] and $FFFFFF) <> 0 then // Mask out alpha + Result.R[Y, X] := 1; +end; + +function CrossCorr(Image, Templ: TSingleMatrix): TSingleMatrix; +var + Spec: TComplexMatrix; +begin + Spec := MulSpectrumConj( + DoFFT2(Image, Image.Width, Image.Height), + DoFFT2(Templ, Image.Width, Image.Height) + ); + + Result := DoIFFT2(Spec, Image.Width - Templ.Width + 1, Image.Height - Templ.Height + 1); +end; + +function CrossCorrRGB(Image, Templ: TRGBMatrix): TRGBMatrix; +begin + Result.R := CrossCorr(Image.R, Templ.R); + Result.G := CrossCorr(Image.G, Templ.G); + Result.B := CrossCorr(Image.B, Templ.B); +end; + +function CalculateSlices(ImageW, ImageH, TemplW, TemplH: Integer): Integer; +var + I: Integer; +begin + Result := 1; + + if (ImageW - TemplW > 200) and (ImageH - TemplH > 250) then // not worth + begin + for I := Min(TThread.ProcessorCount, 4) downto 2 do // more than 4 threads loses effectiveness very quickly + if ((ImageH div I) + TemplH) > 200 then + Exit(I); + end; + + // not possible to slice into at least 200 pixels +end; + +function SliceImage(Image, Template: TIntegerMatrix): TImageSlices; +var + I, Y, Offset, RowSize, Count: Integer; + Slice: TIntegerMatrix; +begin + SetLength(Result, CalculateSlices(Image.Width, Image.Height, Template.Width, Template.Height)); + if (Length(Result) = 1) then + Result[0] := Image + else + begin + RowSize := Image.Width * SizeOf(Integer); + Count := Length(Result); + + for I := 0 to High(Result) do + begin + Slice := nil; + if (I = Count - 1) then + Slice.SetSize(Image.Width, Image.Height div Count) + else + Slice.SetSize(Image.Width, (Image.Height div Count) + Template.Height); + + Offset := (Image.Height div Count) * I; + for Y := 0 to Slice.Height - 1 do + Move(Image[Y + Offset, 0], Slice[Y, 0], RowSize); + + Result[I] := Slice; + end; + end; +end; + +function Multithread(Image, Templ: TIntegerMatrix; MatchTemplate: TMatchTemplate; Normed: Boolean): TSingleMatrix; +var + ImageSlices: TImageSlices; + RowSize: Integer; + + procedure DoMatchTemplate(SliceIndex: Integer); + var + SliceOffset, Y: Integer; + Mat: TSingleMatrix; + begin + SliceOffset := (Image.Height div Length(ImageSlices)) * SliceIndex; + + Mat := MatchTemplate(ImageSlices[SliceIndex], Templ, Normed); + for Y := 0 to Mat.Height - 1 do + Move(Mat[Y, 0], Result[SliceOffset + Y, 0], RowSize); + end; + +var + Tasks: TSimbaThreadPoolTasks; + I: Integer; +begin + if CalculateSlices(Image.Width, Image.Height, Templ.Width, Templ.Height) > 1 then + begin + Result.SetSize( + (Image.Width - Templ.Width) + 1, + (Image.Height - Templ.Height) + 1 + ); + RowSize := Result.Width * SizeOf(Single); + ImageSlices := SliceImage(Image, Templ); + + SetLength(Tasks, Length(ImageSlices)); + for I := 0 to High(Tasks) do + Tasks[I] := TSimbaThreadPoolTask.Create(@DoMatchTemplate); + + SimbaThreadPool.RunParallel(Tasks); + end else + Result := MatchTemplate(Image, Templ, Normed); +end; + +function CrossCorrRGB(Mat: TRGBComplexMatrix; Templ: TRGBMatrix): TRGBMatrix; + + function CrossCorr(Channel: TComplexMatrix; Templ: TSingleMatrix): TSingleMatrix; + begin + Result := DoIFFT2( + MulSpectrumConj( + Channel, + DoFFT2(Templ, Mat.Width, Mat.Height) + ), + Mat.Width - Templ.Width + 1, Mat.Height - Templ.Height + 1 + ); + end; + +begin + Result.R := CrossCorr(Mat.R, Templ.R); + Result.G := CrossCorr(Mat.G, Templ.G); + Result.B := CrossCorr(Mat.B, Templ.B); +end; + +end. + diff --git a/Source/matchtemplate/simba.matchtemplate_matrix.pas b/Source/matchtemplate/simba.matchtemplate_matrix.pas index 00e29b1bb..8a32eb718 100644 --- a/Source/matchtemplate/simba.matchtemplate_matrix.pas +++ b/Source/matchtemplate/simba.matchtemplate_matrix.pas @@ -26,68 +26,63 @@ interface simba.mufasatypes, simba.helpers_matrix; type + TComplex = record + Re, Im: Single; + end; + TComplexArray = array of TComplex; + TComplexMatrix = array of TComplexArray; + TComplexMatrixHelper = type helper for TComplexMatrix + public + procedure SetSize(AWidth, AHeight: Integer); + function Width: Integer; + function Height: Integer; + end; + + TRGBComplexMatrix = record + Width: Integer; + Height: Integer; + + R, G, B: TComplexMatrix; + end; + TRGBMatrix = record R, G, B: TSingleMatrix; - function Width: Int32; - function Height: Int32; + function Merge: TSingleMatrix; + function Width: Integer; + function Height: Integer; + + class function Create(const Image: TIntegerMatrix): TRGBMatrix; static; end; + +operator *(const Left: Double; const Mat: TSingleMatrix): TSingleMatrix; operator *(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; -operator *(const Left: TRGBMatrix; const Right: TDoubleArray): TRGBMatrix; +operator *(const Left: TRGBMatrix; const Right: Single): TRGBMatrix; operator -(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; operator -(const Left: TRGBMatrix; const Right: TDoubleArray): TRGBMatrix; operator +(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; - operator +(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; -operator -(const Left: TSingleMatrix; const Right: Double): TSingleMatrix; +operator +(const Left: TSingleMatrix; const Right: Single): TSingleMatrix; +operator -(const Left: TSingleMatrix; const Right: Single): TSingleMatrix; operator -(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; -operator *(const Left: TSingleMatrix; const Right: Double): TSingleMatrix; +operator *(const Left: TSingleMatrix; const Right: Single): TSingleMatrix; operator *(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; -operator /(const Left: TSingleMatrix; const Right: Double): TSingleMatrix; operator /(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; -function Sum(const Matrix: TRGBMatrix): TDoubleArray; +function SumOfSquares(const Matrix: TRGBMatrix): Double; function Sqrt(const Matrix: TRGBMatrix): TSingleMatrix; overload; +function Sum(const Matrix: TSingleMatrix): Single; overload; +function Sum(const Matrix: TRGBMatrix): TDoubleArray; overload; function Norm(const Matrix: TRGBMatrix): Double; - -function Sum(const Matrix: TSingleMatrix): Double; -function Sqrt(const Matrix: TSingleMatrix): TSingleMatrix; overload; -function Norm(const Matrix: TSingleMatrix): Double; - function SumsPd(const Matrix: TSingleMatrix; out Square: TDoubleMatrix): TDoubleMatrix; function Rot90(const Matrix: TComplexMatrix): TComplexMatrix; -procedure SplitRGB(const Image: TIntegerMatrix; out R, G, B: TSingleMatrix); - implementation -procedure SplitRGB(const Image: TIntegerMatrix; out R, G, B: TSingleMatrix); -var - W,H,x,y: Int32; -begin - W := Image.Width; - H := Image.Height; - - SetLength(R, H, W); - SetLength(G, H, W); - SetLength(B, H, W); - - Dec(W); - Dec(H); - - for y:=0 to H do - for x:=0 to W do - begin - R[y,x] := Image[y,x]{shr 00}and $FF; - G[y,x] := Image[y,x] shr 08 and $FF; - B[y,x] := Image[y,x] shr 16 and $FF; - end; -end; - function SumsPd(const Matrix: TSingleMatrix; out Square: TDoubleMatrix): TDoubleMatrix; var - x,y,W,H: Int32; + x,y,W,H: Integer; sum,sqsum: Double; begin H := Length(Matrix); @@ -139,7 +134,7 @@ function Rot90(const Matrix: TComplexMatrix): TComplexMatrix; function Sum(const Matrix: TRGBMatrix): TDoubleArray; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; R, G, B: Double; begin R := 0; @@ -160,43 +155,51 @@ function Sum(const Matrix: TRGBMatrix): TDoubleArray; Result := [R, G, B]; end; -function Sqrt(const Matrix: TRGBMatrix): TSingleMatrix; +function SumOfSquares(const Matrix: TRGBMatrix): Double; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin - SetLength(Result, Matrix.Height, Matrix.Width); + Result := 0; W := Matrix.Width - 1; H := Matrix.Height - 1; for Y := 0 to H do for X := 0 to W do - Result[Y, X] := Sqrt(Matrix.R[Y, X] + Matrix.G[Y, X] + Matrix.B[Y, X]); + Result += Sqr(Matrix.R[Y, X]) + Sqr(Matrix.G[Y, X]) + Sqr(Matrix.B[Y, X]); end; -function Norm(const Matrix: TRGBMatrix): Double; +function Sqrt(const Matrix: TRGBMatrix): TSingleMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin - Result := 0; + SetLength(Result, Matrix.Height, Matrix.Width); W := Matrix.Width - 1; H := Matrix.Height - 1; for Y := 0 to H do for X := 0 to W do - begin - Result += Matrix.R[Y][X] * Matrix.R[Y][X]; - Result += Matrix.G[Y][X] * Matrix.G[Y][X]; - Result += Matrix.B[Y][X] * Matrix.B[Y][X]; - end; + Result[Y, X] := Sqrt(Matrix.R[Y, X] + Matrix.G[Y, X] + Matrix.B[Y, X]); +end; - Result := Sqrt(Result); +operator*(const Left: Double; const Mat: TSingleMatrix): TSingleMatrix; +var + X, Y, W, H: Integer; +begin + SetLength(Result, Mat.Height, Mat.Width); + + W := Mat.Width - 1; + H := Mat.Height - 1; + + for Y := 0 to H do + for X := 0 to W do + Result[Y, X] := Mat[Y, X] * Left; end; operator*(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin SetLength(Result.R, Left.Height, Left.Width); SetLength(Result.G, Left.Height, Left.Width); @@ -214,9 +217,9 @@ function Norm(const Matrix: TRGBMatrix): Double; end; end; -operator-(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; +operator*(const Left: TRGBMatrix; const Right: Single): TRGBMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin SetLength(Result.R, Left.Height, Left.Width); SetLength(Result.G, Left.Height, Left.Width); @@ -228,15 +231,15 @@ function Norm(const Matrix: TRGBMatrix): Double; for Y := 0 to H do for X := 0 to W do begin - Result.R[Y, X] := Left.R[Y, X] - Right.R[Y, X]; - Result.G[Y, X] := Left.G[Y, X] - Right.G[Y, X]; - Result.B[Y, X] := Left.B[Y, X] - Right.B[Y, X]; + Result.R[Y, X] := Left.R[Y, X] * Right; + Result.G[Y, X] := Left.G[Y, X] * Right; + Result.B[Y, X] := Left.B[Y, X] * Right; end; end; -operator+(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; +operator-(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin SetLength(Result.R, Left.Height, Left.Width); SetLength(Result.G, Left.Height, Left.Width); @@ -248,15 +251,15 @@ function Norm(const Matrix: TRGBMatrix): Double; for Y := 0 to H do for X := 0 to W do begin - Result.R[Y, X] := Left.R[Y, X] + Right.R[Y, X]; - Result.G[Y, X] := Left.G[Y, X] + Right.G[Y, X]; - Result.B[Y, X] := Left.B[Y, X] + Right.B[Y, X]; + Result.R[Y, X] := Left.R[Y, X] - Right.R[Y, X]; + Result.G[Y, X] := Left.G[Y, X] - Right.G[Y, X]; + Result.B[Y, X] := Left.B[Y, X] - Right.B[Y, X]; end; end; -operator*(const Left: TRGBMatrix; const Right: TDoubleArray): TRGBMatrix; +operator+(const Left: TRGBMatrix; const Right: TRGBMatrix): TRGBMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin SetLength(Result.R, Left.Height, Left.Width); SetLength(Result.G, Left.Height, Left.Width); @@ -268,15 +271,15 @@ function Norm(const Matrix: TRGBMatrix): Double; for Y := 0 to H do for X := 0 to W do begin - Result.R[Y, X] := Left.R[Y, X] * Right[0]; - Result.G[Y, X] := Left.G[Y, X] * Right[1]; - Result.B[Y, X] := Left.B[Y, X] * Right[2]; + Result.R[Y, X] := Left.R[Y, X] + Right.R[Y, X]; + Result.G[Y, X] := Left.G[Y, X] + Right.G[Y, X]; + Result.B[Y, X] := Left.B[Y, X] + Right.B[Y, X]; end; end; operator-(const Left: TRGBMatrix; const Right: TDoubleArray): TRGBMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin SetLength(Result.R, Left.Height, Left.Width); SetLength(Result.G, Left.Height, Left.Width); @@ -294,9 +297,9 @@ function Norm(const Matrix: TRGBMatrix): Double; end; end; -function Sum(const Matrix: TSingleMatrix): Double; +function Sum(const Matrix: TSingleMatrix): Single; var - W, H, X, Y: Int32; + W, H, X, Y: Integer; begin Result := 0; @@ -308,23 +311,9 @@ function Sum(const Matrix: TSingleMatrix): Double; Result += Matrix[Y, X]; end; -function Sqrt(const Matrix: TSingleMatrix): TSingleMatrix; -var - X, Y, W, H: Int32; -begin - SetLength(Result, Matrix.Height, Matrix.Width); - - W := Matrix.Width - 1; - H := Matrix.Height - 1; - - for Y := 0 to H do - for X := 0 to W do - Result[Y, X] := System.Sqrt(Matrix[Y, X]); -end; - -function Norm(const Matrix: TSingleMatrix): Double; +function Norm(const Matrix: TRGBMatrix): Double; var - W, H, X, Y: Int32; + X, Y, W, H: Integer; begin Result := 0; @@ -333,14 +322,14 @@ function Norm(const Matrix: TSingleMatrix): Double; for Y := 0 to H do for X := 0 to W do - Result += Matrix[Y][X] * Matrix[Y][X]; + Result += Sqr(Matrix.R[Y, X]) + Sqr(Matrix.G[Y, X]) + Sqr(Matrix.B[Y, X]); Result := Sqrt(Result); end; operator+(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin W := Left.Width - 1; H := Left.Height - 1; @@ -352,9 +341,9 @@ function Norm(const Matrix: TSingleMatrix): Double; Result[Y, X] := Left[Y, X] + Right[Y, X]; end; -operator*(const Left: TSingleMatrix; const Right: Double): TSingleMatrix; +operator*(const Left: TSingleMatrix; const Right: Single): TSingleMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin W := Left.Width - 1; H := Left.Height - 1; @@ -368,7 +357,7 @@ function Norm(const Matrix: TSingleMatrix): Double; operator*(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; var - W, H, X, Y: Int32; + W, H, X, Y: Integer; begin W := Left.Width - 1; H := Left.Height - 1; @@ -382,7 +371,7 @@ function Norm(const Matrix: TSingleMatrix): Double; operator-(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin W := Left.Width - 1; H := Left.Height - 1; @@ -394,9 +383,9 @@ function Norm(const Matrix: TSingleMatrix): Double; Result[Y, X] := Left[Y, X] - Right[Y, X]; end; -operator-(const Left: TSingleMatrix; const Right: Double): TSingleMatrix; +operator+(const Left: TSingleMatrix; const Right: Single): TSingleMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin W := Left.Width - 1; H := Left.Height - 1; @@ -405,12 +394,12 @@ function Norm(const Matrix: TSingleMatrix): Double; for Y := 0 to H do for X := 0 to W do - Result[Y, X] := Left[Y, X] - Right; + Result[Y, X] := Left[Y, X] + Right; end; -operator/(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; +operator-(const Left: TSingleMatrix; const Right: Single): TSingleMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin W := Left.Width - 1; H := Left.Height - 1; @@ -419,12 +408,12 @@ function Norm(const Matrix: TSingleMatrix): Double; for Y := 0 to H do for X := 0 to W do - Result[Y, X] := Left[Y, X] / Right[Y, X]; + Result[Y, X] := Left[Y, X] - Right; end; -operator/(const Left: TSingleMatrix; const Right: Double): TSingleMatrix; +operator/(const Left: TSingleMatrix; const Right: TSingleMatrix): TSingleMatrix; var - X, Y, W, H: Int32; + X, Y, W, H: Integer; begin W := Left.Width - 1; H := Left.Height - 1; @@ -433,10 +422,43 @@ function Norm(const Matrix: TSingleMatrix): Double; for Y := 0 to H do for X := 0 to W do - Result[Y, X] := Left[Y, X] / Right; + Result[Y, X] := Left[Y, X] / Right[Y, X]; end; -function TRGBMatrix.Width: Int32; +procedure TComplexMatrixHelper.SetSize(AWidth, AHeight: Integer); +begin + SetLength(Self, AHeight, AWidth); +end; + +function TComplexMatrixHelper.Width: Integer; +begin + if (Length(Self) > 0) then + Result := Length(Self[0]) + else + Result := 0; +end; + +function TComplexMatrixHelper.Height: Integer; +begin + Result := Length(Self); +end; + +function TRGBMatrix.Merge: TSingleMatrix; +var + X, Y, W, H: Integer; +begin + W := Self.Width; + H := Self.Height; + Result.SetSize(W, H); + Dec(W); + Dec(H); + + for Y := 0 to H do + for X := 0 to W do + Result[Y, X] := Self.R[Y, X] + Self.G[Y, X] + Self.B[Y, X]; +end; + +function TRGBMatrix.Width: Integer; begin if Length(Self.R) > 0 then Result := Length(Self.R[0]) @@ -444,9 +466,31 @@ function TRGBMatrix.Width: Int32; Result := 0; end; -function TRGBMatrix.Height: Int32; +function TRGBMatrix.Height: Integer; begin Result := Length(Self.R); end; +class function TRGBMatrix.Create(const Image: TIntegerMatrix): TRGBMatrix; +var + W, H, X, Y: Integer; +begin + W := Image.Width; + H := Image.Height; + + SetLength(Result.R, H, W); + SetLength(Result.G, H, W); + SetLength(Result.B, H, W); + + Dec(W); + Dec(H); + for Y := 0 to H do + for X := 0 to W do + begin + Result.R[Y, X] := Image[Y, X] and $FF; + Result.G[Y, X] := Image[Y, X] shr 08 and $FF; + Result.B[Y, X] := Image[Y, X] shr 16 and $FF; + end; +end; + end. diff --git a/Source/matchtemplate/simba.matchtemplate_sqdiff.pas b/Source/matchtemplate/simba.matchtemplate_sqdiff.pas new file mode 100644 index 000000000..e13fe904c --- /dev/null +++ b/Source/matchtemplate/simba.matchtemplate_sqdiff.pas @@ -0,0 +1,252 @@ +{ + Author: Raymond van Venetië and Merlijn Wajer + Project: Simba (https://github.com/MerlijnWajer/Simba) + License: GNU General Public License (https://www.gnu.org/licenses/gpl-3.0) +} +unit simba.matchtemplate_sqdiff; + +{$DEFINE SIMBA_O4} +{$i simba.inc} + +{$MODESWITCH ARRAYOPERATORS OFF} + +interface + +uses + classes, sysutils, math, + simba.mufasatypes, simba.helpers_matrix, + simba.matchtemplate, simba.matchtemplate_matrix, simba.matchtemplate_helpers; + +function MatchTemplateMask_SQDIFF_CreateCache(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +function MatchTemplateMask_SQDIFF_CreateCache_MT(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +function MatchTemplateMask_SQDIFF_Cache(ACache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplateMask_SQDIFF(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplateMask_SQDIFF_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +function MatchTemplate_SQDIFF(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +function MatchTemplate_SQDIFF_MT(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; + +implementation + +uses + simba.threadpool; + +type + TMatchTemplateCache_SQDIFF = class(TMatchTemplateCacheBase) + public + Slices: array of record + ImageChannels, MaskChannels: TRGBMatrix; + Mask2: TRGBMatrix; + TempResult: TSingleMatrix; + end; + + constructor Create(Image, Template: TIntegerMatrix; Multithread: Boolean); + end; + +constructor TMatchTemplateCache_SQDIFF.Create(Image, Template: TIntegerMatrix; Multithread: Boolean); +var + Img2: TRGBMatrix; + ImageSlices: TImageSlices; + I: Integer; +begin + inherited Create(); + + if Multithread then + ImageSlices := SliceImage(Image, Template) + else + ImageSlices := [Image]; + + Width := Image.Width; + Height := Image.Height; + + SetLength(Slices, Length(ImageSlices)); + for I := 0 to High(ImageSlices) do + with Slices[I] do + begin + MaskChannels := MaskFromTemplate(Template); + ImageChannels := TRGBMatrix.Create(ImageSlices[I]); + Img2 := (ImageChannels * ImageChannels); + Mask2 := (MaskChannels * MaskChannels); + TempResult := CrossCorrRGB(Img2, Mask2).Merge(); + end; +end; + +function MatchTemplateMask_SQDIFF_Cache(ACache: TMatchTemplateCacheBase; Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + Cache: TMatchTemplateCache_SQDIFF absolute ACache; + RowSize: Integer; + + procedure DoMatchTemplate(SliceIndex: Integer); + var + Mat: TSingleMatrix; + SliceOffset, X, Y, W, H: Integer; + TemplChannels, TemplMulMask2: TRGBMatrix; + Templ2Mask2Sum: Double; + begin + with Cache.Slices[SliceIndex] do + begin + TemplChannels := TRGBMatrix.Create(Template); + Templ2Mask2Sum := SumOfSquares(TemplChannels * MaskChannels); + TemplMulMask2 := TemplChannels * Mask2; + + Mat := CrossCorrRGB(ImageChannels, TemplMulMask2).Merge(); + Mat := -2 * Mat + TempResult + Templ2Mask2Sum; + + if Normed then + begin + W := Mat.Width - 1; + H := Mat.Height - 1; + for Y := 0 to H do + for X := 0 to W do + Mat[Y, X] := Mat[Y, X] / Sqrt(Templ2Mask2Sum * TempResult[Y, X]); + end; + end; + + SliceOffset := (Cache.Height div Length(Cache.Slices)) * SliceIndex; + for Y := 0 to Mat.Height - 1 do + Move(Mat[Y, 0], Result[SliceOffset + Y, 0], RowSize); + end; + +var + Tasks: TSimbaThreadPoolTasks; + I: Integer; +begin + if (not (ACache is TMatchTemplateCache_SQDIFF)) then + raise Exception.Create('[MatchTemplateMask_SQDIFF]: Invalid cache'); + + Result.SetSize( + (Cache.Width - Template.Width) + 1, + (Cache.Height - Template.Height) + 1 + ); + RowSize := Result.Width * SizeOf(Single); + + if Length(Cache.Slices) > 1 then + begin + SetLength(Tasks, Length(Cache.Slices)); + for I := 0 to High(Tasks) do + Tasks[I] := TSimbaThreadPoolTask.Create(@DoMatchTemplate); + + SimbaThreadPool.RunParallel(Tasks); + end else + DoMatchTemplate(0); +end; + +function MatchTemplateMask_SQDIFF(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + MaskChannels, TemplateChannels, ImageChannels: TRGBMatrix; + Img2, Mask2, TemplMulMask2: TRGBMatrix; + Templ2Mask2Sum: Double; + TempResult: TSingleMatrix; + W, H, X, Y: Integer; +begin + MaskChannels := MaskFromTemplate(Template); + TemplateChannels := TRGBMatrix.Create(Template); + ImageChannels := TRGBMatrix.Create(Image); + + // Mat img2 = img.mul(img); + Img2 := (ImageChannels * ImageChannels); + // mask.mul(mask); + Mask2 := (MaskChannels * MaskChannels); + // double templ2_mask2_sum = norm(templ.mul(mask), NORM_L2SQR); + Templ2Mask2Sum := SumOfSquares(TemplateChannels * MaskChannels); + // templ.mul(mask2) + TemplMulMask2 := TemplateChannels * Mask2; + + // crossCorr(img2, mask2, temp_result, Point(0,0), 0, 0); + TempResult := CrossCorrRGB(Img2, Mask2).Merge(); + + // crossCorr(img, templ.mul(mask2), result, Point(0,0), 0, 0); + Result := CrossCorrRGB(ImageChannels, templMulMask2).Merge(); + Result := -2 * Result + TempResult + Templ2Mask2Sum; + + if Normed then + begin + W := Result.Width - 1; + H := Result.Height - 1; + for Y := 0 to H do + for X := 0 to W do + Result[Y, X] := Result[Y, X] / Sqrt(Templ2Mask2Sum * TempResult[Y, X]); + end; +end; + +function MatchTemplateMask_SQDIFF_MT(Image, Template: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +begin + Result := Multithread(Image, Template, @MatchTemplateMask_SQDIFF, Normed); +end; + +function MatchTemplateMask_SQDIFF_CreateCache(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +begin + Result := TMatchTemplateCache_SQDIFF.Create(Image, Template, False); +end; + +function MatchTemplateMask_SQDIFF_CreateCache_MT(Image, Template: TIntegerMatrix): TMatchTemplateCacheBase; +begin + Result := TMatchTemplateCache_SQDIFF.Create(Image, Template, True); +end; + +function MatchTemplate_SQDIFF(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +var + x,y,w,h,tw,th,iw,ih: Integer; + invSize, numer, denom, tplSigma, tplSum2, wndSum2: Double; + tplMean, tplSdv, mR,sR, mG,sG, mB,sB:Double; + sum2r, sum2g, sum2b: TDoubleMatrix; + Corr: TSingleMatrix; + ImageChannels, TemplChannels: TRGBMatrix; +begin + ImageChannels := TRGBMatrix.Create(Image); + TemplChannels := TRGBMatrix.Create(Templ); + Corr := CrossCorrRGB(ImageChannels, TemplChannels).Merge(); + + tw := Templ.Width; + th := Templ.Height; + + invSize := Double(1.0) / Double(tw*th); + + TemplChannels.R.MeanStdev(mR, sR); + TemplChannels.G.MeanStdev(mG, sG); + TemplChannels.B.MeanStdev(mB, sB); + + tplMean := Sqr(mR) + Sqr(mG) + Sqr(mB); + tplSdv := Sqr(sR) + Sqr(sG) + Sqr(sB); + + tplSigma := Sqrt(tplSdv + tplMean) / Sqrt(invSize); + tplSum2 := (tplSdv + tplMean) / invSize; + + SumsPd(ImageChannels.R, sum2r); + SumsPd(ImageChannels.G, sum2g); + SumsPd(ImageChannels.B, sum2b); + + iw := sum2r.Width; + ih := sum2r.Height; + + Result.SetSize(iw-tw, ih-th); + + w := iw-tw-1; + h := ih-th-1; + for y := 0 to h do + for x := 0 to w do + begin + wndSum2 := sum2r[Y, X] - sum2r[Y,X+tw] - sum2r[Y+th,X] + sum2r[Y+th,X+tw]; + wndSum2 += sum2g[Y, X] - sum2g[Y,X+tw] - sum2g[Y+th,X] + sum2g[Y+th,X+tw]; + wndSum2 += sum2b[Y, X] - sum2b[Y,X+tw] - sum2b[Y+th,X] + sum2b[Y+th,X+tw]; + + numer := Max(0, wndSum2 - Double(2.0) * Corr[Y, X] + tplSum2); + if Normed then + begin + denom := tplSigma * Sqrt(wndSum2); + if abs(numer) < denom then + Result[Y, X] := numer / denom + else + Result[Y, X] := 1; + end else + Result[Y, X] := numer; + end; +end; + +function MatchTemplate_SQDIFF_MT(Image, Templ: TIntegerMatrix; Normed: Boolean): TSingleMatrix; +begin + Result := Multithread(Image, Templ, @MatchTemplate_SQDIFF, Normed); +end; + +end. + diff --git a/Source/script/imports/simba/simba.import_matchtemplate.pas b/Source/script/imports/simba/simba.import_matchtemplate.pas index 742927771..7ad42ea87 100644 --- a/Source/script/imports/simba/simba.import_matchtemplate.pas +++ b/Source/script/imports/simba/simba.import_matchtemplate.pas @@ -1,3 +1,8 @@ +{ + Author: Raymond van Venetië and Merlijn Wajer + Project: Simba (https://github.com/MerlijnWajer/Simba) + License: GNU General Public License (https://www.gnu.org/licenses/gpl-3.0) +} unit simba.import_matchtemplate; {$i simba.inc} @@ -12,22 +17,32 @@ implementation procedure _LapeMatchTemplateCache_Create(const Params: PParamArray; const Result: Pointer); {$IFDEF Lape_CDECL}cdecl;{$ENDIF} begin - PMatchTemplateCache(Result)^ := SimbaMatchTemplate.CacheClass.Create(PIntegerMatrix(Params^[0])^, PIntegerMatrix(Params^[1])^); + PMatchTemplateCacheBase(Result)^ := MatchTemplateCache(PIntegerMatrix(Params^[0])^, PIntegerMatrix(Params^[1])^, PTMFormula(Params^[2])^); +end; + +procedure _LapeMatchTemplateCache_CreateEx(const Params: PParamArray; const Result: Pointer); {$IFDEF Lape_CDECL}cdecl;{$ENDIF} +begin + PMatchTemplateCacheBase(Result)^ := MatchTemplateCache(PMufasaBitmap(Params^[0])^, PMufasaBitmap(Params^[1])^, PTMFormula(Params^[2])^); end; procedure _LapeMatchTemplateMaskCache(const Params: PParamArray; const Result: Pointer); {$IFDEF Lape_CDECL}cdecl;{$ENDIF} begin - PSingleMatrix(Result)^ := SimbaMatchTemplate.MatchTemplateMask(PMatchTemplateCache(Params^[0])^, PIntegerMatrix(Params^[1])^, PTMFormula(Params^[2])^); + PSingleMatrix(Result)^ := MatchTemplateMask(PMatchTemplateCacheBase(Params^[0])^, PIntegerMatrix(Params^[1])^, PTMFormula(Params^[2])^); +end; + +procedure _LapeMatchTemplateMaskCacheEx(const Params: PParamArray; const Result: Pointer); {$IFDEF Lape_CDECL}cdecl;{$ENDIF} +begin + PSingleMatrix(Result)^ := MatchTemplateMask(PMatchTemplateCacheBase(Params^[0])^, PMufasaBitmap(Params^[1])^, PTMFormula(Params^[2])^); end; procedure _LapeMatchTemplateMask(const Params: PParamArray; const Result: Pointer); {$IFDEF Lape_CDECL}cdecl;{$ENDIF} begin - PSingleMatrix(Result)^ := SimbaMatchTemplate.MatchTemplateMask(PIntegerMatrix(Params^[0])^, PIntegerMatrix(Params^[1])^, PTMFormula(Params^[2])^); + PSingleMatrix(Result)^ := MatchTemplateMask(PIntegerMatrix(Params^[0])^, PIntegerMatrix(Params^[1])^, PTMFormula(Params^[2])^); end; procedure _LapeMatchTemplate(const Params: PParamArray; const Result: Pointer); {$IFDEF Lape_CDECL}cdecl;{$ENDIF} begin - PSingleMatrix(Result)^ := SimbaMatchTemplate.MatchTemplate(PIntegerMatrix(Params^[0])^, PIntegerMatrix(Params^[1])^, PTMFormula(Params^[2])^); + PSingleMatrix(Result)^ := MatchTemplate(PIntegerMatrix(Params^[0])^, PIntegerMatrix(Params^[1])^, PTMFormula(Params^[2])^); end; procedure _LapeMufasaBitmap_MatchTemplate(const Params: PParamArray; const Result: Pointer); {$IFDEF Lape_CDECL}cdecl;{$ENDIF} @@ -47,12 +62,13 @@ procedure ImportMatchTemplate(Compiler: TSimbaScript_Compiler); pushSection('Match Template'); addClass('TMatchTemplateCache'); - addGlobalType('(TM_CCORR, TM_CCORR_NORMED, TM_CCOEFF, TM_CCOEFF_NORMED, TM_SQDIFF, TM_SQDIFF_NORMED)', 'ETMFormula'); - addGlobalFunc('function TMatchTemplateCache.Create(Image, Template: TIntegerMatrix): TMatchTemplateCache; static', @_LapeMatchTemplateCache_Create); + addGlobalFunc('function TMatchTemplateCache.Create(Image, Template: TIntegerMatrix; Formula: ETMFormula): TMatchTemplateCache; static; overload', @_LapeMatchTemplateCache_Create); + addGlobalFunc('function TMatchTemplateCache.Create(Image, Template: TMufasaBitmap; Formula: ETMFormula): TMatchTemplateCache; static; overload', @_LapeMatchTemplateCache_CreateEx); - addGlobalFunc('function MatchTemplateMask(Image: TMatchTemplateCache; Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; overload', @_LapeMatchTemplateMaskCache); + addGlobalFunc('function MatchTemplateMask(Cache: TMatchTemplateCache; Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; overload', @_LapeMatchTemplateMaskCache); + addGlobalFunc('function MatchTemplateMask(Cache: TMatchTemplateCache; Template: TMufasaBitmap; Formula: ETMFormula): TSingleMatrix; overload', @_LapeMatchTemplateMaskCacheEx); addGlobalFunc('function MatchTemplateMask(Image, Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix; overload', @_LapeMatchTemplateMask); addGlobalFunc('function MatchTemplate(Image, Template: TIntegerMatrix; Formula: ETMFormula): TSingleMatrix', @_LapeMatchTemplate); diff --git a/Source/simba.bitmap_helpers.pas b/Source/simba.bitmap_helpers.pas index 3fb156a3d..23922ae91 100644 --- a/Source/simba.bitmap_helpers.pas +++ b/Source/simba.bitmap_helpers.pas @@ -36,12 +36,12 @@ implementation function TMufasaBitmapHelpers.MatchTemplate(Template: TMufasaBitmap; Formula: ETMFormula): TSingleMatrix; begin - Result := SimbaMatchTemplate.MatchTemplate(Self.ToMatrixBGR(), Template.ToMatrixBGR(), Formula); + Result := simba.matchtemplate.MatchTemplate(Self.ToMatrixBGR(), Template.ToMatrixBGR(), Formula); end; function TMufasaBitmapHelpers.MatchTemplateMask(Template: TMufasaBitmap; Formula: ETMFormula): TSingleMatrix; begin - Result := SimbaMatchTemplate.MatchTemplateMask(Self.ToMatrixBGR(), Template.ToMatrixBGR(), Formula); + Result := simba.matchtemplate.MatchTemplateMask(Self.ToMatrixBGR(), Template.ToMatrixBGR(), Formula); end; function TMufasaBitmapHelpers.FindColors(out Points: TPointArray; Color: Integer): Boolean; diff --git a/Source/simba.finder.pas b/Source/simba.finder.pas index 104b7ca44..bee27791e 100644 --- a/Source/simba.finder.pas +++ b/Source/simba.finder.pas @@ -1429,7 +1429,7 @@ function TMFinder.FindTemplateEx(TemplImage: TMufasaBitmap; out TPA: TPointArray for y:=0 to TemplImage.Height-1 do Move(TemplImage.Data[y*TemplImage.Width], Templ[y,0], TemplImage.Width*SizeOf(TRGB32)); - xcorr := TSimbaMatchTemplate.MatchTemplate(Image, Templ, Formula); + xcorr := MatchTemplate(Image, Templ, Formula); if Formula in [TM_SQDIFF, TM_SQDIFF_NORMED] then begin diff --git a/Source/simba.math.pas b/Source/simba.math.pas index a8e376502..99ab14b10 100644 --- a/Source/simba.math.pas +++ b/Source/simba.math.pas @@ -64,7 +64,7 @@ function IsNumber(const n: Double): Boolean; function IsNumber(const n: Single): Boolean; begin - Result := (LongWord(n) and $7fffffff) < $7f800000; // Result := (not IsNan(b)) and (not IsInfinite(b)); + Result := (LongWord(n) and $7fffffff) < $7f800000; // Result := (not IsNan(n)) and (not IsInfinite(n)); end; function Modulo(const X, Y: Double): Double; diff --git a/Source/simba.mufasatypes.pas b/Source/simba.mufasatypes.pas index 7a95263e5..b462674fb 100644 --- a/Source/simba.mufasatypes.pas +++ b/Source/simba.mufasatypes.pas @@ -140,15 +140,6 @@ TRetData = record TInt64Array = array of Int64; PInt64Array = ^TInt64Array; - TComplex = packed record - Re, Im: Single; - end; - - TComplexArray = array of TComplex; - T2DComplexArray = array of TComplexArray; - - TComplexMatrix = T2DComplexArray; - EComparator = (__LT__, __GT__, __EQ__, __LE__, __GE__, __NE__); PComparator = ^EComparator; diff --git a/Source/simba.threadpool.pas b/Source/simba.threadpool.pas index 2242f441e..d1864583e 100644 --- a/Source/simba.threadpool.pas +++ b/Source/simba.threadpool.pas @@ -16,13 +16,18 @@ interface PParamArray = ^TParamArray; TParamArray = array[Word] of Pointer; + TSimbaThreadPoolNestedMethod = procedure(Index: Integer) is nested; TSimbaThreadPoolMethod = procedure(const Params: PParamArray; const Result: Pointer); TSimbaThreadPoolTask = record Method: TSimbaThreadPoolMethod; + NestedMethod: TSimbaThreadPoolNestedMethod; Params: TParamArray; Result: Pointer; - class function Create(AMethod: TSimbaThreadPoolMethod; AParams: array of Pointer; AResult: Pointer): TSimbaThreadPoolTask; static; + procedure Execute(Index: Integer); + + class function Create(AMethod: TSimbaThreadPoolNestedMethod): TSimbaThreadPoolTask; static; overload; + class function Create(AMethod: TSimbaThreadPoolMethod; AParams: array of Pointer; AResult: Pointer = nil): TSimbaThreadPoolTask; static; overload; end; TSimbaThreadPoolTasks = array of TSimbaThreadPoolTask; @@ -30,9 +35,8 @@ TSimbaThreadPool_Thread = class(TThread) protected FEvent: TSimpleEvent; FIdleEvent: TSimpleEvent; - FMethod: TSimbaThreadPoolMethod; - FParams: TParamArray; - FResult: Pointer; + FTask: TSimbaThreadPoolTask; + FTaskIndex: Integer; procedure Execute; override; @@ -42,7 +46,7 @@ TSimbaThreadPool_Thread = class(TThread) constructor Create; reintroduce; destructor Destroy; override; - procedure Run(Task: TSimbaThreadPoolTask); + procedure Run(Task: TSimbaThreadPoolTask; TaskIndex: Integer); procedure WaitForIdle; property Idle: Boolean read GetIdle write SetIdle; @@ -69,8 +73,24 @@ TSimbaThreadPool = class implementation +uses + LazLoggerBase; + +procedure TSimbaThreadPoolTask.Execute(Index: Integer); +begin + if Assigned(Method) then Method(@Params, Result); + if Assigned(NestedMethod) then NestedMethod(Index); +end; + +class function TSimbaThreadPoolTask.Create(AMethod: TSimbaThreadPoolNestedMethod): TSimbaThreadPoolTask; +begin + Result := Default(TSimbaThreadPoolTask); + Result.NestedMethod := AMethod; +end; + class function TSimbaThreadPoolTask.Create(AMethod: TSimbaThreadPoolMethod; AParams: array of Pointer; AResult: Pointer): TSimbaThreadPoolTask; begin + Result := Default(TSimbaThreadPoolTask); Result.Method := AMethod; Result.Params := AParams; Result.Result := AResult; @@ -84,18 +104,17 @@ procedure TSimbaThreadPool_Thread.Execute; if Terminated then Exit; - FMethod(@FParams, FResult); + FTask.Execute(FTaskIndex); FEvent.ResetEvent(); FIdleEvent.SetEvent(); end; end; -procedure TSimbaThreadPool_Thread.Run(Task: TSimbaThreadPoolTask); +procedure TSimbaThreadPool_Thread.Run(Task: TSimbaThreadPoolTask; TaskIndex: Integer); begin - FMethod := Task.Method; - FParams := Task.Params; - FResult := Task.Result; + FTask := Task; + FTaskIndex := TaskIndex; FEvent.SetEvent(); // begin execution end; @@ -123,7 +142,7 @@ procedure TSimbaThreadPool_Thread.SetIdle(Value: Boolean); constructor TSimbaThreadPool_Thread.Create; begin - inherited Create(True, 1024 * 512); // default = 4MiB, we set 512KiB + inherited Create(True, 512 * 512); // default = 4MiB, we set 256KiB FreeOnTerminate := False; @@ -211,16 +230,17 @@ procedure TSimbaThreadPool.RunParallel(Tasks: TSimbaThreadPoolTasks); begin if GetIdleThreads(Length(Tasks), Threads) then begin - for I := 0 to High(Tasks) do - Threads[I].Run(Tasks[I]); + // DebugLn('Running %d tasks', [Length(Tasks)]); + for I := 0 to High(Tasks) do + Threads[I].Run(Tasks[I], I); for I := 0 to High(Threads) do Threads[I].WaitForIdle(); end else begin // Not enough threads - no multithreading. for I := 0 to High(Tasks) do - Tasks[I].Method(@Tasks[I].Params, Tasks[I].Result); + Tasks[I].Execute(I); end; end; diff --git a/Tests/matchtemplate.simba b/Tests/matchtemplate.simba deleted file mode 100644 index 06b669f6e..000000000 --- a/Tests/matchtemplate.simba +++ /dev/null @@ -1,21 +0,0 @@ -{$assertions on} - -var - img, templ: TMufasaBitmap; - mat: TSingleMatrix; -begin - img := TMufasaBitmap.CreateFromString(240, 240, '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'); - templ := img.Copy(90,80,170,100); - - try - mat := MatchTemplate(img.ToMatrix(), templ.ToMatrix(), TM_CCOEFF_NORMED); - Assert(mat.ArgMax() = [90,80]); - - templ.Blur(7); - mat := MatchTemplate(img.ToMatrix(), templ.ToMatrix(), TM_CCOEFF_NORMED); - Assert(mat.ArgMax() = [90,80]); - finally - img.Free(); - templ.Free(); - end; -end. diff --git a/Tests/matchtemplatemask.simba b/Tests/matchtemplatemask.simba new file mode 100644 index 000000000..36f1caabb --- /dev/null +++ b/Tests/matchtemplatemask.simba @@ -0,0 +1,77 @@ +{$assertions on} + +var + img, templ: TMufasaBitmap; + +procedure test(formula: ETMFormula; minLoc, maxLoc: TPoint; minValue, maxValue: Single = 0); +var + mat: TSingleMatrix; +begin + try + mat := MatchTemplateMask(img.ToMatrix(), templ.ToMatrix(), formula); + Assert(mat.ArgMin() = minLoc); + Assert(mat.ArgMax() = maxLoc); + + if (minValue <> 0) and (maxValue <> 0) then + begin + Assert(Abs(mat[minLoc.Y, minLoc.X] - minValue) <= 0.05); + Assert(Abs(mat[maxLoc.Y, maxLoc.X] - maxValue) <= 0.05); + end; + except + WriteLn(Formula, ' :: ', mat.ArgMin(), ', ', mat.ArgMax(), ', ', Round(mat[mat.ArgMin().Y, mat.ArgMin().X], 1), ', ', Round(mat[mat.ArgMax().Y, mat.ArgMax().X], 1)); + raise; + end; +end; + +procedure testCache(formula: ETMFormula; minLoc, maxLoc: TPoint; minValue, maxValue: Single = 0); +var + mat: TSingleMatrix; + cache: TMatchTemplateCache; +begin + try + cache := TMatchTemplateCache.Create(img.toMatrix(), templ.ToMatrix(), formula); + mat := MatchTemplateMask(cache, templ.ToMatrix(), formula); + Assert(mat.ArgMin() = minLoc); + Assert(mat.ArgMax() = maxLoc); + + if (minValue <> 0) and (maxValue <> 0) then + begin + Assert(Abs(mat[minLoc.Y, minLoc.X] - minValue) <= 0.05); + Assert(Abs(mat[maxLoc.Y, maxLoc.X] - maxValue) <= 0.05); + end; + except + WriteLn(Formula, ' :: ', mat.ArgMin(), ', ', mat.ArgMax(), ', ', Round(mat[mat.ArgMin().Y, mat.ArgMin().X], 1), ', ', Round(mat[mat.ArgMax().Y, mat.ArgMax().X], 1)); + raise; + finally + cache.free(); + end; +end; + +begin + img := TMufasaBitmap.CreateFromString(226, 149, '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'); + templ := img.Copy(50, 50, 100, 100); + templ.DrawCircleInverted(templ.GetCenter(), 20, 0); + + try + test(TM_CCOEFF, [83, 1], [50, 50]); + test(TM_CCOEFF_NORMED, [24, 19], [50, 50], -0.2, 1); + + test(TM_CCORR, [80, 14], [53, 0]); + test(TM_CCORR_NORMED, [77, 1], [50, 50], 0.8, 1); + + test(TM_SQDIFF, [50, 50], [54, 0]); + test(TM_SQDIFF_NORMED, [50, 50], [59, 0], 0, 0.4); + + testCache(TM_CCOEFF, [83, 1], [50, 50]); + testCache(TM_CCOEFF_NORMED, [24, 19], [50, 50], -0.2, 1); + + testCache(TM_CCORR, [80, 14], [53, 0]); + testCache(TM_CCORR_NORMED, [77, 1], [50, 50], 0.8, 1); + + testCache(TM_SQDIFF, [50, 50], [54, 0]); + testCache(TM_SQDIFF_NORMED, [50, 50], [59, 0], 0, 0.4); + finally + img.free(); + templ.free(); + end; +end.