1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:

//==========================================================================*
// Vergleich eines Musterbildes (Modell) mit einem größeren Bild(ausschnitt)
//
// Bild in dem gesucht wird:
// Bits      := Zeiger auf Beginn des Bildes (Grauwerte oder RGB-Werte wie Bitmap)
// DIBWidth  := Breite des Bildes in Pixeln
// DIBHeight := Höhe des Bildes in Pixeln
//
// Ausschnitt in dem gesucht wird:
// DX        := Suchebreite (Von OLeft-DX bis OLeft+DX suchen) in Pixeln
// DY        := Suchehöhe   (Von OTop-DY bis OTop+DY suchen) in Pixeln
// Step      := Schrittweite in Pixeln
//
// oBitBuffer: Modell (Grauwerte oder RGB-Werte analog einer Bitmap)
//
// Aus der Klasse bzw globale Variablen:
// Eingabe:
// oLeft: Startpunkt von links (Angenommene linke obere Ecke)
// oTop: Startpunkt von oben
// oPSize: bei RGB = 3 bei GrayScale = 1
// oWidth: Breite des Modells
// oHeight: Höhe des Modells

// Ausgabe:
// oBestMatchLeft: Position mit der besten Übereinstimmung links
// oBestMatchTop: Position mit der besten Übereinstimmung oben
//--------------------------------------------------------------------------*
function ScaledConvolution
  (Bits: PByte; DIBWidth, DIBHeight, DX, DY, Step: Integer;
   MaxR: Double): Double;
var
  I, J, N, Left, Top: Integer;
  L, T: Integer;
  Pixel: PByte;
  SumI, SumI2, SumIM: Double;
  R: Double;
  MinX, MinY, MaxX, MaxY: Integer;
  Muster: Byte;
begin
  N := oPSize * oWidth * oHeight;                // Anzahl der Pixel im Mod.

  R := 0;                                        // Pessimistische Prognose
  Result := R;
  MinX := oLeft - DX;                            // Linken Suchrand bestimm.
  MaxX := oLeft + DX;                            // Rechten Suchrand bestimm.
  MinY := oTop - DY;                             // Oberen Suchrand bestimm.
  MaxY := oTop + DY;                             // Unteren Suchrand bestimm.
  if MinX < 0 then                               // Grenzwerte überwachen
    MinX := 0;                                   // um Zugriffsfehler
  if MinY < 0 then                               // auf Pixel außerhalb
    MinY := 0;                                   // des Bildes
  if MaxX > DibWidth - oWidth then               // zu verhindern
    MaxX := DibWidth - oWidth;
  if MaxY > DibHeight - oHeight then
    MaxY := DibHeight - oHeight;

  T := MinY;                                     // Aktueller Hochwert
  while T <= MaxY do                             // Solange er über dem
  begin                                          // unteren Rand liegt
    L := MinX;                                   // Aktuellen Linkswert set.
    while L <= MaxX do                           // Solange er links vom
    begin                                        // rechten Rand liegt
      SumI := 0.0;                               // Summen neu initialisieren
      SumI2 := 0.0;
      SumIM := 0.0;

      Pixel := Bits;                             // Beginn des Bildes
      Inc(Pixel,                                 // Beginn des Modells
        oPSize*(L+                               //   Spaltenoffset
       (DIBHeight-T-oHeight)*DIBWidth));         //   Zeilenoffset

      for I := 0 to oHeight - 1 do               // Für alle Zeilen des
      begin                                      // Modells
        for J := 0 to oPSize*oWidth - 1 do       // Für alle Spalten des
        begin                                    // Modells
          Muster := oBitBuffer[oPSize*I*oWidth+J];
          if Muster > 0 then                     // Wenn kein Dont Care Pixel
          begin                                  // im Modell vorliegt
            SumI := SumI + Pixel^;               // Summe der Bildpixelwerte
            SumI2 := SumI2 + Pixel^ * Pixel^;    // Summe der Quadrate dazu
            SumIM := SumIM +
              Pixel^ * Muster;                   // Summe der Produkte
          end;
          Inc(Pixel);                            // Nächsten Pixel
        end;
        R := (SumIM - (SumI * oSumM) / N);       // Teilergebnis
        Inc(Pixel,oPSize*(DIBWidth-oWidth));     // Nächste Zeile
      end;

      try
        R := R*R /((SumI2 - SumI * SumI / N)     // Quadrat der Korrelation
          * oSumMFaktor);
      except
        R := 0.0;
      end;

      if R > Result then                         // Wenn Wert besser als
      begin                                      // bisher ist
        Result := R;                             // Ergebnis merken
        oBestMatchLeft := L;                     // Position merken
        oBestMatchTop := T;
      end;
      Inc(L,Step);                               // Schritt nach rechts
    end;
    Inc(T,Step);                                 // Schritt nach unten
    if Result > MaxR then
      break;
  end;
end;
//==========================================================================*