blocks|key|3142357|text|你说你的图像可能不完全一样，但又说你不想要“模糊”算法。我不确定这些是不是兼容的。不过，总的来说，我认为您应该看看image+registration算法。有一个名为ITK的开源C%2B%2B包，它可能会提供一些提示。此外，ImageJ是一个流行的开源Java包。如果你到处看看，这两个都至少有一些注册功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3142358|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Image_registration|1|http://itk.org/|2|http://rsbweb.nih.gov/ij/^0|1L|I|0|2B|3|1|30|6|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

You said your image may not be exactly the same, but then say you don't want "fuzzy" algorithms. I'm not sure those are compatible. In general, though, I think you want to look at <a href="http://en.wikipedia.org/wiki/Image_registration" rel="noreferrer">image registration</a> algorithms. There's an open source C++ package called <a href="http://itk.org/" rel="noreferrer">ITK</a> that might provide some hints. Also <a href="http://rsbweb.nih.gov/ij/" rel="noreferrer">ImageJ</a> is a popular open source Java package. Both of these have at least some registration capabilities available if you poke around.

blocks|key|3142381|text|下面是你想要使用的代码框架：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3142382|//+look+for+all+(x,y)+positions+where+target+appears+in+desktop
List<Loc>+findMatches(Image+desktop,+Image+target,+float+threshold)+{
++List<Loc>+locs;
++for+(int+y=0;+y<desktop.height()-target.height();+y%2B%2B)+{
++++++for+(int+x=0;+x<desktop.width()-target.width();+x%2B%2B)+{
++++++++++if+(imageDistance(desktop,+x,+y,+target)+<+threshold)+{
++++++++++++++locs.append(Loc(x,y));
++++++++++}
++++++}
+++}
+++return+locs;
}

//+computes+the+root+mean+squared+error+between+a+rectangular+window+in+
//+bigImg+and+target.
float+imageDistance(Image+bigImg,+int+bx,+int+by,+Image+target)+{
++++float+dist+=+0.0;
++++for+(int+y=0;+y<target.height();+y%2B%2B)+{
++++++++for+(int+x=0;+x<target.width();+x%2B%2B)+{
++++++++++++//+assume+RGB+images...
++++++++++++for+(int+colorChannel=0;+colorChannel<3;+colorChannel%2B%2B)+{
++++++++++++++++dist+%2B=+Math.pow(target.getPixel(x,y)+-+bigImg.getPixel(bx%2Bx,by%2By),+2);
++++++++++++}
+++++++++}
++++}
++++return+Math.sqrt(dist)+/+target.width()+/+target.height();
}|code-block|syntax|javascript|3142383|您可以考虑其他图像距离(请参阅a+similar+question)。对于您的应用程序，RMS错误可能是一个很好的选择。|offset|length|3142384|可能有各种Java库可以有效地为您计算此距离。|3142385|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/189943/how-can-i-quantify-difference-between-two-images#190061^0|0|0|F|I|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@$I|X|J|Y|1|Z]]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Here's the skeleton of code you'd want to use:

<pre><code>// look for all (x,y) positions where target appears in desktop
List&lt;Loc&gt; findMatches(Image desktop, Image target, float threshold) {
 List&lt;Loc&gt; locs;
 for (int y=0; y&lt;desktop.height()-target.height(); y++) {
 for (int x=0; x&lt;desktop.width()-target.width(); x++) {
 if (imageDistance(desktop, x, y, target) &lt; threshold) {
 locs.append(Loc(x,y));
 }
 }
 }
 return locs;
}

// computes the root mean squared error between a rectangular window in 
// bigImg and target.
float imageDistance(Image bigImg, int bx, int by, Image target) {
 float dist = 0.0;
 for (int y=0; y&lt;target.height(); y++) {
 for (int x=0; x&lt;target.width(); x++) {
 // assume RGB images...
 for (int colorChannel=0; colorChannel&lt;3; colorChannel++) {
 dist += Math.pow(target.getPixel(x,y) - bigImg.getPixel(bx+x,by+y), 2);
 }
 }
 }
 return Math.sqrt(dist) / target.width() / target.height();
}
</code></pre>

You could consider other image distances (see <a href="https://stackoverflow.com/questions/189943/how-can-i-quantify-difference-between-two-images#190061">a similar question</a>). For your application, the RMS error is probably a good choice.

There are probably various Java libraries that compute this distance for you efficiently.

blocks|key|357374|text|看看我写的论文：http://werner.yellowcouch.org/Papers/subimg/index.html。它非常详细，似乎是唯一一篇讨论如何将傅里叶变换应用于子图像查找问题的文章。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|357375|简而言之，如果你想使用傅立叶变换，你可以应用下面的公式:当图像A在dx上移动时，图像A和图像B之间的相关性在下面的矩阵中给出:+C=ifft(fft(A)+x共轭(fft(B)。所以，图像C中的位置具有最高的值，具有最高的相关性，该位置反映了dx，dy。|357376|此结果适用于相对较大的子图像。对于较小的图像，需要做更多的工作，如本文所述。然而，这样的傅立叶变换是相当快的。它产生大约3*sx_sy_log_2(sx*sy)%2B3*sx*sy操作。|357377|entityMap|0|LINK|mutability|MUTABLE|url|http://werner.yellowcouch.org/Papers/subimg/index.html^0|8|1I|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

Have a look at the paper I wrote: <a href="http://werner.yellowcouch.org/Papers/subimg/index.html" rel="noreferrer">http://werner.yellowcouch.org/Papers/subimg/index.html</a>. It's highly detailed and appears to be the only article discussing how to apply fourier transformation to the problem of subimage finding.

In short, if you want to use the fourier transform one could apply the following formula: the correlation between image A and image B when image A is shifted over dx,dy is given in the following matrix: C=ifft(fft(A) x conjugate(fft(B)). So, the position in image C that has the highest value, has the highest correlation and that position reflects dx,dy. 

This result works well for subimages that are relatively large. For smaller images, some more work is necessary as explained in the article. Nevertheless, such fourier transforms are quite fast. It results in around 3*sxsylog_2(sx*sy)+3*sx*sy operations.

blocks|key|3355348|text|你不需要像“神经网络”中那样的模糊，因为(据我所知)你没有旋转，倾斜或类似的东西。如果操作系统显示差异是唯一的修改，那么差异应该是最小的。因此，WernerVanBelle的论文很好，但并不是真的必要，MrFooz先生的代码可以工作--但效率非常低(O(width+*+height+*+patter_width+*+pattern_height)!)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3355349|我能想到的最好的算法是用于字符串搜索的Boyer-Moore算法，经过修改后可以进行二维搜索。http://en.wikipedia.org/wiki/Boyer%25E2%2580%2593Moore_string_search_algorithm|3355350|您必须为每种颜色存储一对置换dx和dy，而不是存储一个置换。当检查一个像素时，你只在x方向x+=+x+%2B+dx上移动，并且只存储最小的dy's+DY+=+min(DY,+dy)，以便在测试完一整行之后设置新的y值(即x+>+width)。|3355351|由于可能颜色的数量，为所有可能的颜色创建一个表可能是被禁止的，所以要么使用映射来存储规则(如果颜色不在映射中，则默认使用模式尺寸)，或者分别为每种颜色创建表并设置dx+=+max(dx(red),+dx(green),+dx(blue))+-这只是一个近似值，但消除了映射的开销。|3355352|在坏字符规则的预处理中，您可以通过将规则从所有颜色传播到它们的“相邻”颜色(无论您希望如何定义相邻颜色)来说明颜色的微小偏差。|3355353|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Boyer%25E2%2580%2593Moore_string_search_algorithm^0|3H|1D|0|1B|20|0|0|E|2|H|2|19|A|20|G|30|9|0|29|12|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|H|3|I|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1G|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]]]

Your don't need fuzzy as in "neural network" because (as I understand) you don't have rotation, tilts or similar. If OS display differences are the only modifications the difference should be minimal.
So WernerVanBelle's paper is nice but not really necessary and MrFooz's code works - but is terribly innefficient (<code>O(width * height * patter_width * pattern_height)</code>!).

The best algorithm I can think of is the Boyer-Moore algorithm for string searching, modified to allow 2 dimensional searches.
<a href="http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm" rel="nofollow">http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm</a>

Instead of one displacement you will have to store a pair of displacements <code>dx</code> and <code>dy</code> for each color. When checking a pixel you move only in the x direction <code>x = x + dx</code> and store only the minimum of the dy's <code>DY = min(DY, dy)</code> to set the new y value after a whole line has been tested (ie <code>x &gt; width</code>).

Creating a table for all possible colors probably is prohibitve due to the imense number of possible colors, so either use a map to store the rules (and default to the pattern dimensions if a color is not inside the map) or create tables for each color seperately and set <code>dx = max(dx(red), dx(green), dx(blue))</code> - which is only an approximation but removes the overhead of a map.

In the preprocessing of the bad-character rule, you can account for small deviations of colors by spreading rules from all colors to their "neighbouring" colors (however you wish to define neighbouring).

blocks|key|360127|text|我考虑了Werner+Van+Belle的解决方案(因为所有其他方法都非常慢-根本不可行)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360128|FFT子图像正确定位的自适应滤波器:基于|360129|的子图像定位需要图像归一化正常工作|blockquote|360130|360131|360132|我在需要解决方案的地方用C#编写了代码，但得到的结果非常不准确。与Van+Belle的声明相反，它真的不能很好地工作吗?还是我做错了什么？我使用https://github.com/tszalay/FFTWSharp作为FFTW的C#包装器。|offset|length|360133|这是我的翻译代码：(在http://werner.yellowcouch.org/Papers/subimg/index.html的C%2B%2B原版)|360134|using+System.Diagnostics;
using+System;
using+System.Runtime.InteropServices;
using+System.Drawing;
using+System.Drawing.Imaging;
using+System.IO;

using+FFTWSharp;

using+unsigned1+=+System.Byte;
using+signed2+=+System.Int16;
using+signed8+=+System.Int64;

public+class+Subimage
{
++++/**
+++++*+This+program+finds+a+subimage+in+a+larger+image.+It+expects+two+arguments.
+++++*+The+first+is+the+image+in+which+it+must+look.+The+secon+dimage+is+the
+++++*+image+that+is+to+be+found.+The+program+relies+on+a+number+of+different
+++++*+steps+to+perform+the+calculation.
+++++*
+++++*+It+will+first+normalize+the+input+images+in+order+to+improve+the
+++++*+crosscorrelation+matching.+Once+the+best+crosscorrelation+is+found
+++++*+a+sad-matchers+is+applied+in+a+grid+over+the+larger+image.
+++++*
+++++*+The+following+two+article+explains+the+details:
+++++*
+++++*+++Werner+Van+Belle;+An+Adaptive+Filter+for+the+Correct+Localization
+++++*+++of+Subimages:+FFT+based+Subimage+Localization+Requires+Image
+++++*+++Normalization+to+work+properly;+11+pages;+October+2007.
+++++*+++http://werner.yellowcouch.org/Papers/subimg/
+++++*
+++++*+++Werner+Van+Belle;+Correlation+between+the+inproduct+and+the+sum
+++++*+++of+absolute+differences+is+-0.8485+for+uniform+sampled+signals+on
+++++*+++[-1:1];+November+2006
+++++*/
++++unsafe+public+static+Point+FindSubimage_fftw(string[]+args)
++++{
++++++++if+(args+==+null+%7C%7C+args.Length+!=+2)
++++++++{
++++++++++++Console.Write("Usage:+subimg\n"+%2B+"\n"+%2B+"++subimg+is+an+image+matcher.+It+requires+two+arguments.+The+first\n"+%2B+"++image+should+be+the+larger+of+the+two.+The+program+will+search\n"+%2B+"++for+the+best+position+to+superimpose+the+needle+image+over+the\n"+%2B+"++haystack+image.+The+output+of+the+the+program+are+the+X+and+Y\n"+%2B+"++coordinates.\n\n"+%2B+"++http://werner.yellowouch.org/Papers/subimg/\n");
++++++++++++return+new+Point();
++++++++}

++++++++/**
+++++++++*+The+larger+image+will+be+called+A.+The+smaller+image+will+be+called+B.
+++++++++*
+++++++++*+The+code+below+relies+heavily+upon+fftw.+The+indices+necessary+for+the
+++++++++*+fast+r2c+and+c2r+transforms+are+at+best+confusing.+Especially+regarding
+++++++++*+the+number+of+rows+and+colums+(watch+our+for+Asx+vs+Asx2+!).
+++++++++*
+++++++++*+After+obtaining+all+the+crosscorrelations+we+will+scan+through+the+image
+++++++++*+to+find+the+best+sad+match.+As+such+we+make+a+backup+of+the+original+data
+++++++++*+in+advance
+++++++++*
+++++++++*/
++++++++int+Asx+=+0,+Asy+=+0;
++++++++signed2[]+A+=+read_image(args[0],+ref+Asx,+ref+Asy);
++++++++int+Asx2+=+Asx+/+2+%2B+1;

++++++++int+Bsx+=+0,+Bsy+=+0;
++++++++signed2[]+B+=+read_image(args[1],+ref+Bsx,+ref+Bsy);

++++++++unsigned1[]+Asad+=+new+unsigned1[Asx+*+Asy];
++++++++unsigned1[]+Bsad+=+new+unsigned1[Bsx+*+Bsy];

++++++++for+(int+i+=+0;+i+<+Bsx+*+Bsy;+i%2B%2B)
++++++++{
++++++++++++Bsad[i]+=+(unsigned1)B[i];
++++++++++++Asad[i]+=+(unsigned1)A[i];
++++++++}
++++++++for+(int+i+=+Bsx+*+Bsy;+i+<+Asx+*+Asy;+i%2B%2B)
++++++++++++Asad[i]+=+(unsigned1)A[i];

++++++++/**
+++++++++*+Normalization+and+windowing+of+the+images.
+++++++++*
+++++++++*+The+window+size+(wx,wy)+is+half+the+size+of+the+smaller+subimage.+This
+++++++++*+is+useful+to+have+as+much+good+information+from+the+subimg.
+++++++++*/
++++++++int+wx+=+Bsx+/+2;
++++++++int+wy+=+Bsy+/+2;
++++++++normalize(ref+B,+Bsx,+Bsy,+wx,+wy);
++++++++normalize(ref+A,+Asx,+Asy,+wx,+wy);

++++++++/**
+++++++++*+Preparation+of+the+fourier+transforms.
+++++++++*+Aa+is+the+amplitude+of+image+A.+Af+is+the+frequence+of+image+A
+++++++++*+Similar+for+B.+crosscors+will+hold+the+crosscorrelations.
+++++++++*/
++++++++IntPtr+Aa+=+fftw.malloc(sizeof(double)+*+Asx+*+Asy);
++++++++IntPtr+Af+=+fftw.malloc(sizeof(double)+*+2+*+Asx2+*+Asy);
++++++++IntPtr+Ba+=+fftw.malloc(sizeof(double)+*+Asx+*+Asy);
++++++++IntPtr+Bf+=+fftw.malloc(sizeof(double)+*+2+*+Asx2+*+Asy);

++++++++/**
+++++++++*+The+forward+transform+of+A+goes+from+Aa+to+Af
+++++++++*+The+forward+tansform+of+B+goes+from+Ba+to+Bf
+++++++++*+In+Bf+we+will+also+calculate+the+inproduct+of+Af+and+Bf
+++++++++*+The+backward+transform+then+goes+from+Bf+to+Aa+again.+That
+++++++++*+variable+is+aliased+as+crosscors;
+++++++++*/
++++++++//#original:+fftw_plan_dft_r2c_2d
++++++++//IntPtr+forwardA+=+fftwf.dft(2,+new+int[]+{+Asy,+Asx+},+Aa,+Af,+fftw_direction.Forward,+fftw_flags.Estimate);//equal+results
++++++++IntPtr+forwardA+=+fftwf.dft_r2c_2d(Asy,+Asx,+Aa,+Af,+fftw_flags.Estimate);
++++++++//#original:+fftw_plan_dft_r2c_2d
++++++++//IntPtr+forwardB+=+fftwf.dft(2,+new+int[]+{+Asy,+Asx+},+Ba,+Bf,+fftw_direction.Forward,+fftw_flags.Estimate);//equal+results
++++++++IntPtr+forwardB+=+fftwf.dft_r2c_2d(Asy,+Asx,+Ba,+Bf,+fftw_flags.Estimate);
++++++++double*+crosscorrs+=+(double*)Aa;
++++++++//#original:+fftw_plan_dft_c2r_2d
++++++++//IntPtr+backward+=+fftwf.dft(2,+new+int[]+{+Asy,+Asx+},+Bf,+Aa,+fftw_direction.Backward,+fftw_flags.Estimate);//equal+results
++++++++IntPtr+backward+=+fftwf.dft_c2r_2d(Asy,+Asx,+Bf,+Aa,+fftw_flags.Estimate);

++++++++/**
+++++++++*+The+two+forward+transforms+of+A+and+B.+Before+we+do+so+we+copy+the+normalized
+++++++++*+data+into+the+double+array.+For+B+we+also+pad+the+data+with+0
+++++++++*/
++++++++for+(int+row+=+0;+row+<+Asy;+row%2B%2B)
++++++++++++for+(int+col+=+0;+col+<+Asx;+col%2B%2B)
++++++++++++++++((double*)Aa)[col+%2B+Asx+*+row]+=+A[col+%2B+Asx+*+row];
++++++++fftw.execute(forwardA);

++++++++for+(int+j+=+0;+j+<+Asx+*+Asy;+j%2B%2B)
++++++++++++((double*)Ba)[j]+=+0;
++++++++for+(int+row+=+0;+row+<+Bsy;+row%2B%2B)
++++++++++++for+(int+col+=+0;+col+<+Bsx;+col%2B%2B)
++++++++++++++++((double*)Ba)[col+%2B+Asx+*+row]+=+B[col+%2B+Bsx+*+row];
++++++++fftw.execute(forwardB);

++++++++/**
+++++++++*+The+inproduct+of+the+two+frequency+domains+and+calculation
+++++++++*+of+the+crosscorrelations
+++++++++*/
++++++++double+norm+=+Asx+*+Asy;
++++++++for+(int+j+=+0;+j+<+Asx2+*+Asy;+j%2B%2B)
++++++++{
++++++++++++double+a+=+((double*)Af)[j+*+2];//#Af[j][0];
++++++++++++double+b+=+((double*)Af)[j+*+2+%2B+1];//#Af[j][1];
++++++++++++double+c+=+((double*)Bf)[j+*+2];//#Bf[j][0];
++++++++++++double+d+=+((double*)Bf)[j+*+2+%2B+1];//#-Bf[j][1];
++++++++++++double+e+=+a+*+c+-+b+*+d;
++++++++++++double+f+=+a+*+d+%2B+b+*+c;
++++++++++++((double*)Bf)[j+*+2]+=+(double)(e+/+norm);//#Bf[j][0]+=+(fftw_real)(e+/+norm);
++++++++++++((double*)Bf)[j+*+2+%2B+1]+=+(double)(f+/+norm);//Bf[j][1]+=+(fftw_real)(f+/+norm);
++++++++}
++++++++fftw.execute(backward);

++++++++/**
+++++++++*+We+now+have+a+correlation+map.+We+can+spent+one+more+pass
+++++++++*+over+the+entire+image+to+actually+find+the+best+matching+images
+++++++++*+as+defined+by+the+SAD.
+++++++++*+We+calculate+this+by+gridding+the+entire+image+according+to+the
+++++++++*+size+of+the+subimage.+In+each+cel+we+want+to+know+what+the+best
+++++++++*+match+is.
+++++++++*/
++++++++int+sa+=+1+%2B+Asx+/+Bsx;
++++++++int+sb+=+1+%2B+Asy+/+Bsy;
++++++++int+sadx+=+0;
++++++++int+sady+=+0;
++++++++signed8+minsad+=+Bsx+*+Bsy+*+256L;
++++++++for+(int+a+=+0;+a+<+sa;+a%2B%2B)
++++++++{
++++++++++++int+xl+=+a+*+Bsx;
++++++++++++int+xr+=+xl+%2B+Bsx;
++++++++++++if+(xr+>+Asx)+continue;
++++++++++++for+(int+b+=+0;+b+<+sb;+b%2B%2B)
++++++++++++{
++++++++++++++++int+yl+=+b+*+Bsy;
++++++++++++++++int+yr+=+yl+%2B+Bsy;
++++++++++++++++if+(yr+>+Asy)+continue;

++++++++++++++++//+find+the+maximum+correlation+in+this+cell
++++++++++++++++int+cormxat+=+xl+%2B+yl+*+Asx;
++++++++++++++++double+cormx+=+crosscorrs[cormxat];
++++++++++++++++for+(int+x+=+xl;+x+<+xr;+x%2B%2B)
++++++++++++++++++++for+(int+y+=+yl;+y+<+yr;+y%2B%2B)
++++++++++++++++++++{
++++++++++++++++++++++++int+j+=+x+%2B+y+*+Asx;
++++++++++++++++++++++++if+(crosscorrs[j]+>+cormx)
++++++++++++++++++++++++++++cormx+=+crosscorrs[cormxat+=+j];
++++++++++++++++++++}
++++++++++++++++int+corx+=+cormxat+%25+Asx;
++++++++++++++++int+cory+=+cormxat+/+Asx;

++++++++++++++++//+We+dont+want+subimages+that+fall+of+the+larger+image
++++++++++++++++if+(corx+%2B+Bsx+>+Asx)+continue;
++++++++++++++++if+(cory+%2B+Bsy+>+Asy)+continue;

++++++++++++++++signed8+sad+=+0;
++++++++++++++++for+(int+x+=+0;+sad+<+minsad+&&+x+<+Bsx;+x%2B%2B)
++++++++++++++++++++for+(int+y+=+0;+y+<+Bsy;+y%2B%2B)
++++++++++++++++++++{
++++++++++++++++++++++++int+j+=+(x+%2B+corx)+%2B+(y+%2B+cory)+*+Asx;
++++++++++++++++++++++++int+i+=+x+%2B+y+*+Bsx;
++++++++++++++++++++++++sad+%2B=+Math.Abs((int)Bsad[i]+-+(int)Asad[j]);
++++++++++++++++++++}

++++++++++++++++if+(sad+<+minsad)
++++++++++++++++{
++++++++++++++++++++minsad+=+sad;
++++++++++++++++++++sadx+=+corx;
++++++++++++++++++++sady+=+cory;
++++++++++++++++++++//+printf("*+");
++++++++++++++++}
++++++++++++++++//+printf("Grid+(%25d,%25d)+(%25d,%25d)+Sip=%25g+Sad=%25lld\n",a,b,corx,cory,cormx,sad);
++++++++++++}
++++++++}
++++++++//Console.Write("{0:D}\t{1:D}\n",+sadx,+sady);
++++++++/**
+++++++++*+Aa,+Ba,+Af+and+Bf+were+allocated+in+this+function
+++++++++*+crosscorrs+was+an+alias+for+Aa+and+does+not+require+deletion.
+++++++++*/
++++++++fftw.free(Aa);
++++++++fftw.free(Ba);
++++++++fftw.free(Af);
++++++++fftw.free(Bf);
++++++++return+new+Point(sadx,+sady);
++++}

++++private+static+void+normalize(ref+signed2[]+img,+int+sx,+int+sy,+int+wx,+int+wy)
++++{
++++++++/**
+++++++++*+Calculate+the+mean+background.+We+will+subtract+this
+++++++++*+from+img+to+make+sure+that+it+has+a+mean+of+zero
+++++++++*+over+a+window+size+of+wx+x+wy.+Afterwards+we+calculate
+++++++++*+the+square+of+the+difference,+which+will+then+be+used
+++++++++*+to+normalize+the+local+variance+of+img.
+++++++++*/
++++++++signed2[]+mean+=+boxaverage(img,+sx,+sy,+wx,+wy);
++++++++signed2[]+sqr+=+new+signed2[sx+*+sy];
++++++++for+(int+j+=+0;+j+<+sx+*+sy;+j%2B%2B)
++++++++{
++++++++++++img[j]+-=+mean[j];
++++++++++++signed2+v+=+img[j];
++++++++++++sqr[j]+=+(signed2)(v+*+v);
++++++++}
++++++++signed2[]+var+=+boxaverage(sqr,+sx,+sy,+wx,+wy);
++++++++/**
+++++++++*+The+normalization+process.+Currenlty+still
+++++++++*+calculated+as+doubles.+Could+probably+be+fixed
+++++++++*+to+integers+too.+The+only+problem+is+the+sqrt
+++++++++*/
++++++++for+(int+j+=+0;+j+<+sx+*+sy;+j%2B%2B)
++++++++{
++++++++++++double+v+=+Math.Sqrt(Math.Abs((double)var[j]));//#double+v+=+sqrt(fabs(var[j]));+<-+ambigous
++++++++++++Debug.Assert(!double.IsInfinity(v)+&&+v+>=+0);
++++++++++++if+(v+<+0.0001)+v+=+0.0001;
++++++++++++img[j]+=+(signed2)(img[j]+*+(32+/+v));
++++++++++++if+(img[j]+>+127)+img[j]+=+127;
++++++++++++if+(img[j]+<+-127)+img[j]+=+-127;
++++++++}
++++++++/**
+++++++++*+As+a+last+step+in+the+normalization+we
+++++++++*+window+the+sub+image+around+the+borders
+++++++++*+to+become+0
+++++++++*/
++++++++window(ref+img,+sx,+sy,+wx,+wy);
++++}

++++private+static+signed2[]+boxaverage(signed2[]+input,+int+sx,+int+sy,+int+wx,+int+wy)
++++{
++++++++signed2[]+horizontalmean+=+new+signed2[sx+*+sy];

++++++++Debug.Assert(horizontalmean+!=+null);
++++++++int+wx2+=+wx+/+2;
++++++++int+wy2+=+wy+/+2;
++++++++int+from+=+(sy+-+1)+*+sx;
++++++++int+to+=+(sy+-+1)+*+sx;
++++++++int+initcount+=+wx+-+wx2;
++++++++if+(sx+<+initcount)+initcount+=+sx;
++++++++int+xli+=+-wx2;
++++++++int+xri+=+wx+-+wx2;
++++++++for+(;+from+>=+0;+from+-=+sx,+to+-=+sx)
++++++++{
++++++++++++signed8+sum+=+0;
++++++++++++int+count+=+initcount;
++++++++++++for+(int+c+=+0;+c+<+count;+c%2B%2B)
++++++++++++++++sum+%2B=+(signed8)input[c+%2B+from];
++++++++++++horizontalmean[to]+=+(signed2)(sum+/+count);
++++++++++++int+xl+=+xli,+x+=+1,+xr+=+xri;
++++++++++++/**
+++++++++++++*+The+area+where+the+window+is+slightly+outside+the
+++++++++++++*+left+boundary.+Beware:+the+right+bnoundary+could+be
+++++++++++++*+outside+on+the+other+side+already
+++++++++++++*/
++++++++++++for+(;+x+<+sx;+x%2B%2B,+xl%2B%2B,+xr%2B%2B)
++++++++++++{
++++++++++++++++if+(xl+>=+0)+break;
++++++++++++++++if+(xr+<+sx)
++++++++++++++++{
++++++++++++++++++++sum+%2B=+(signed8)input[xr+%2B+from];
++++++++++++++++++++count%2B%2B;
++++++++++++++++}
++++++++++++++++horizontalmean[x+%2B+to]+=+(signed2)(sum+/+count);
++++++++++++}
++++++++++++/**
+++++++++++++*+both+bounds+of+the+sliding+window
+++++++++++++*+are+fully+inside+the+images
+++++++++++++*/
++++++++++++for+(;+xr+<+sx;+x%2B%2B,+xl%2B%2B,+xr%2B%2B)
++++++++++++{
++++++++++++++++sum+-=+(signed8)input[xl+%2B+from];
++++++++++++++++sum+%2B=+(signed8)input[xr+%2B+from];
++++++++++++++++horizontalmean[x+%2B+to]+=+(signed2)(sum+/+count);
++++++++++++}
++++++++++++/**
+++++++++++++*+the+right+bound+is+falling+of+the+page
+++++++++++++*/
++++++++++++for+(;+x+<+sx;+x%2B%2B,+xl%2B%2B)
++++++++++++{
++++++++++++++++sum+-=+(signed8)input[xl+%2B+from];
++++++++++++++++count--;
++++++++++++++++horizontalmean[x+%2B+to]+=+(signed2)(sum+/+count);
++++++++++++}
++++++++}

++++++++/**
+++++++++*+The+same+process+as+aboe+but+for+the+vertical+dimension+now
+++++++++*/
++++++++int+ssy+=+(sy+-+1)+*+sx+%2B+1;
++++++++from+=+sx+-+1;
++++++++signed2[]+verticalmean+=+new+signed2[sx+*+sy];
++++++++Debug.Assert(verticalmean+!=+null);
++++++++to+=+sx+-+1;
++++++++initcount+=+wy+-+wy2;
++++++++if+(sy+<+initcount)+initcount+=+sy;
++++++++int+initstopat+=+initcount+*+sx;
++++++++int+yli+=+-wy2+*+sx;
++++++++int+yri+=+(wy+-+wy2)+*+sx;
++++++++for+(;+from+>=+0;+from--,+to--)
++++++++{
++++++++++++signed8+sum+=+0;
++++++++++++int+count+=+initcount;
++++++++++++for+(int+d+=+0;+d+<+initstopat;+d+%2B=+sx)
++++++++++++++++sum+%2B=+(signed8)horizontalmean[d+%2B+from];
++++++++++++verticalmean[to]+=+(signed2)(sum+/+count);
++++++++++++int+yl+=+yli,+y+=+1,+yr+=+yri;
++++++++++++for+(;+y+<+ssy;+y+%2B=+sx,+yl+%2B=+sx,+yr+%2B=+sx)
++++++++++++{
++++++++++++++++if+(yl+>=+0)+break;
++++++++++++++++if+(yr+<+ssy)
++++++++++++++++{
++++++++++++++++++++sum+%2B=+(signed8)horizontalmean[yr+%2B+from];
++++++++++++++++++++count%2B%2B;
++++++++++++++++}
++++++++++++++++verticalmean[y+%2B+to]+=+(signed2)(sum+/+count);
++++++++++++}
++++++++++++for+(;+yr+<+ssy;+y+%2B=+sx,+yl+%2B=+sx,+yr+%2B=+sx)
++++++++++++{
++++++++++++++++sum+-=+(signed8)horizontalmean[yl+%2B+from];
++++++++++++++++sum+%2B=+(signed8)horizontalmean[yr+%2B+from];
++++++++++++++++verticalmean[y+%2B+to]+=+(signed2)(sum+/+count);
++++++++++++}
++++++++++++for+(;+y+<+ssy;+y+%2B=+sx,+yl+%2B=+sx)
++++++++++++{
++++++++++++++++sum+-=+(signed8)horizontalmean[yl+%2B+from];
++++++++++++++++count--;
++++++++++++++++verticalmean[y+%2B+to]+=+(signed2)(sum+/+count);
++++++++++++}
++++++++}
++++++++return+verticalmean;
++++}

++++private+static+void+window(ref+signed2[]+img,+int+sx,+int+sy,+int+wx,+int+wy)
++++{
++++++++int+wx2+=+wx+/+2;
++++++++int+sxsy+=+sx+*+sy;
++++++++int+sx1+=+sx+-+1;
++++++++for+(int+x+=+0;+x+<+wx2;+x%2B%2B)
++++++++++++for+(int+y+=+0;+y+<+sxsy;+y+%2B=+sx)
++++++++++++{
++++++++++++++++img[x+%2B+y]+=+(signed2)(img[x+%2B+y]+*+x+/+wx2);
++++++++++++++++img[sx1+-+x+%2B+y]+=+(signed2)(img[sx1+-+x+%2B+y]+*+x+/+wx2);
++++++++++++}

++++++++int+wy2+=+wy+/+2;
++++++++int+syb+=+(sy+-+1)+*+sx;
++++++++int+syt+=+0;
++++++++for+(int+y+=+0;+y+<+wy2;+y%2B%2B)
++++++++{
++++++++++++for+(int+x+=+0;+x+<+sx;+x%2B%2B)
++++++++++++{
++++++++++++++++/**
+++++++++++++++++*+here+we+need+to+recalculate+the+stuff+(*y/wy2)
+++++++++++++++++*+to+preserve+the+discrete+nature+of+integers.
+++++++++++++++++*/
++++++++++++++++img[x+%2B+syt]+=+(signed2)(img[x+%2B+syt]+*+y+/+wy2);
++++++++++++++++img[x+%2B+syb]+=+(signed2)(img[x+%2B+syb]+*+y+/+wy2);
++++++++++++}
++++++++++++/**
+++++++++++++*+The+next+row+for+the+top+rows
+++++++++++++*+The+previous+row+for+the+bottom+rows
+++++++++++++*/
++++++++++++syt+%2B=+sx;
++++++++++++syb+-=+sx;
++++++++}
++++}

++++private+static+signed2[]+read_image(string+filename,+ref+int+sx,+ref+int+sy)
++++{
++++++++Bitmap+image+=+new+Bitmap(filename);
++++++++sx+=+image.Width;
++++++++sy+=+image.Height;
++++++++signed2[]+GreyImage+=+new+signed2[sx+*+sy];
++++++++BitmapData+bitmapData1+=+image.LockBits(new+Rectangle(0,+0,+image.Width,+image.Height),+ImageLockMode.ReadOnly,+PixelFormat.Format32bppArgb);
++++++++unsafe
++++++++{
++++++++++++byte*+imagePointer+=+(byte*)bitmapData1.Scan0;

++++++++++++for+(int+y+=+0;+y+<+bitmapData1.Height;+y%2B%2B)
++++++++++++{
++++++++++++++++for+(int+x+=+0;+x+<+bitmapData1.Width;+x%2B%2B)
++++++++++++++++{
++++++++++++++++++++GreyImage[x+%2B+y+*+sx]+=+(signed2)((imagePointer[0]+%2B+imagePointer[1]+%2B+imagePointer[2])+/+3.0);
++++++++++++++++++++//4+bytes+per+pixel
++++++++++++++++++++imagePointer+%2B=+4;
++++++++++++++++}//end+for+x
++++++++++++++++//4+bytes+per+pixel
++++++++++++++++imagePointer+%2B=+bitmapData1.Stride+-+(bitmapData1.Width+*+4);
++++++++++++}//end+for+y
++++++++}//end+unsafe
++++++++image.UnlockBits(bitmapData1);
++++++++return+GreyImage;
++++}
}|code-block|syntax|javascript|360135|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/tszalay/FFTWSharp|1|http://werner.yellowcouch.org/Papers/subimg/index.html^0|0|0|0|0|0|20|10|0|0|B|1I|1|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|14|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|18|8|@]|9|@$K|19|L|1A|1|1B]]|A|$]]|$1|M|3|N|5|6|7|1C|8|@]|9|@$K|1D|L|1E|1|1F]]|A|$]]|$1|O|3|P|5|Q|7|1G|8|@]|9|@]|A|$R|S]]|$1|T|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]|11|$5|W|X|Y|A|$Z|12]]]]

I considered the solution of Werner Van Belle (since all other approaches are incredible slow - not practicable at all): 

<blockquote>
 An Adaptive Filter for the Correct Localization of Subimages: FFT
 based Subimage Localization Requires Image Normalization to work
 properly
</blockquote>

I wrote the code in C# where I need my solution, but I am getting highly inaccurate results. Does it really not work well, in contrary to Van Belle's statement, or did I do something wrong? I used <a href="https://github.com/tszalay/FFTWSharp" rel="nofollow">https://github.com/tszalay/FFTWSharp</a> as a C# wrapper for FFTW.

Here is my translated code: (original in C++ at <a href="http://werner.yellowcouch.org/Papers/subimg/index.html" rel="nofollow">http://werner.yellowcouch.org/Papers/subimg/index.html</a>)

<pre><code>using System.Diagnostics;
using System;
using System.Runtime.InteropServices;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

using FFTWSharp;

using unsigned1 = System.Byte;
using signed2 = System.Int16;
using signed8 = System.Int64;

public class Subimage
{
 /**
 * This program finds a subimage in a larger image. It expects two arguments.
 * The first is the image in which it must look. The secon dimage is the
 * image that is to be found. The program relies on a number of different
 * steps to perform the calculation.
 *
 * It will first normalize the input images in order to improve the
 * crosscorrelation matching. Once the best crosscorrelation is found
 * a sad-matchers is applied in a grid over the larger image.
 *
 * The following two article explains the details:
 *
 * Werner Van Belle; An Adaptive Filter for the Correct Localization
 * of Subimages: FFT based Subimage Localization Requires Image
 * Normalization to work properly; 11 pages; October 2007.
 * http://werner.yellowcouch.org/Papers/subimg/
 *
 * Werner Van Belle; Correlation between the inproduct and the sum
 * of absolute differences is -0.8485 for uniform sampled signals on
 * [-1:1]; November 2006
 */
 unsafe public static Point FindSubimage_fftw(string[] args)
 {
 if (args == null || args.Length != 2)
 {
 Console.Write("Usage: subimg\n" + "\n" + " subimg is an image matcher. It requires two arguments. The first\n" + " image should be the larger of the two. The program will search\n" + " for the best position to superimpose the needle image over the\n" + " haystack image. The output of the the program are the X and Y\n" + " coordinates.\n\n" + " http://werner.yellowouch.org/Papers/subimg/\n");
 return new Point();
 }

 /**
 * The larger image will be called A. The smaller image will be called B.
 *
 * The code below relies heavily upon fftw. The indices necessary for the
 * fast r2c and c2r transforms are at best confusing. Especially regarding
 * the number of rows and colums (watch our for Asx vs Asx2 !).
 *
 * After obtaining all the crosscorrelations we will scan through the image
 * to find the best sad match. As such we make a backup of the original data
 * in advance
 *
 */
 int Asx = 0, Asy = 0;
 signed2[] A = read_image(args[0], ref Asx, ref Asy);
 int Asx2 = Asx / 2 + 1;

 int Bsx = 0, Bsy = 0;
 signed2[] B = read_image(args[1], ref Bsx, ref Bsy);

 unsigned1[] Asad = new unsigned1[Asx * Asy];
 unsigned1[] Bsad = new unsigned1[Bsx * Bsy];

 for (int i = 0; i &lt; Bsx * Bsy; i++)
 {
 Bsad[i] = (unsigned1)B[i];
 Asad[i] = (unsigned1)A[i];
 }
 for (int i = Bsx * Bsy; i &lt; Asx * Asy; i++)
 Asad[i] = (unsigned1)A[i];

 /**
 * Normalization and windowing of the images.
 *
 * The window size (wx,wy) is half the size of the smaller subimage. This
 * is useful to have as much good information from the subimg.
 */
 int wx = Bsx / 2;
 int wy = Bsy / 2;
 normalize(ref B, Bsx, Bsy, wx, wy);
 normalize(ref A, Asx, Asy, wx, wy);

 /**
 * Preparation of the fourier transforms.
 * Aa is the amplitude of image A. Af is the frequence of image A
 * Similar for B. crosscors will hold the crosscorrelations.
 */
 IntPtr Aa = fftw.malloc(sizeof(double) * Asx * Asy);
 IntPtr Af = fftw.malloc(sizeof(double) * 2 * Asx2 * Asy);
 IntPtr Ba = fftw.malloc(sizeof(double) * Asx * Asy);
 IntPtr Bf = fftw.malloc(sizeof(double) * 2 * Asx2 * Asy);

 /**
 * The forward transform of A goes from Aa to Af
 * The forward tansform of B goes from Ba to Bf
 * In Bf we will also calculate the inproduct of Af and Bf
 * The backward transform then goes from Bf to Aa again. That
 * variable is aliased as crosscors;
 */
 //#original: fftw_plan_dft_r2c_2d
 //IntPtr forwardA = fftwf.dft(2, new int[] { Asy, Asx }, Aa, Af, fftw_direction.Forward, fftw_flags.Estimate);//equal results
 IntPtr forwardA = fftwf.dft_r2c_2d(Asy, Asx, Aa, Af, fftw_flags.Estimate);
 //#original: fftw_plan_dft_r2c_2d
 //IntPtr forwardB = fftwf.dft(2, new int[] { Asy, Asx }, Ba, Bf, fftw_direction.Forward, fftw_flags.Estimate);//equal results
 IntPtr forwardB = fftwf.dft_r2c_2d(Asy, Asx, Ba, Bf, fftw_flags.Estimate);
 double* crosscorrs = (double*)Aa;
 //#original: fftw_plan_dft_c2r_2d
 //IntPtr backward = fftwf.dft(2, new int[] { Asy, Asx }, Bf, Aa, fftw_direction.Backward, fftw_flags.Estimate);//equal results
 IntPtr backward = fftwf.dft_c2r_2d(Asy, Asx, Bf, Aa, fftw_flags.Estimate);

 /**
 * The two forward transforms of A and B. Before we do so we copy the normalized
 * data into the double array. For B we also pad the data with 0
 */
 for (int row = 0; row &lt; Asy; row++)
 for (int col = 0; col &lt; Asx; col++)
 ((double*)Aa)[col + Asx * row] = A[col + Asx * row];
 fftw.execute(forwardA);

 for (int j = 0; j &lt; Asx * Asy; j++)
 ((double*)Ba)[j] = 0;
 for (int row = 0; row &lt; Bsy; row++)
 for (int col = 0; col &lt; Bsx; col++)
 ((double*)Ba)[col + Asx * row] = B[col + Bsx * row];
 fftw.execute(forwardB);

 /**
 * The inproduct of the two frequency domains and calculation
 * of the crosscorrelations
 */
 double norm = Asx * Asy;
 for (int j = 0; j &lt; Asx2 * Asy; j++)
 {
 double a = ((double*)Af)[j * 2];//#Af[j][0];
 double b = ((double*)Af)[j * 2 + 1];//#Af[j][1];
 double c = ((double*)Bf)[j * 2];//#Bf[j][0];
 double d = ((double*)Bf)[j * 2 + 1];//#-Bf[j][1];
 double e = a * c - b * d;
 double f = a * d + b * c;
 ((double*)Bf)[j * 2] = (double)(e / norm);//#Bf[j][0] = (fftw_real)(e / norm);
 ((double*)Bf)[j * 2 + 1] = (double)(f / norm);//Bf[j][1] = (fftw_real)(f / norm);
 }
 fftw.execute(backward);

 /**
 * We now have a correlation map. We can spent one more pass
 * over the entire image to actually find the best matching images
 * as defined by the SAD.
 * We calculate this by gridding the entire image according to the
 * size of the subimage. In each cel we want to know what the best
 * match is.
 */
 int sa = 1 + Asx / Bsx;
 int sb = 1 + Asy / Bsy;
 int sadx = 0;
 int sady = 0;
 signed8 minsad = Bsx * Bsy * 256L;
 for (int a = 0; a &lt; sa; a++)
 {
 int xl = a * Bsx;
 int xr = xl + Bsx;
 if (xr &gt; Asx) continue;
 for (int b = 0; b &lt; sb; b++)
 {
 int yl = b * Bsy;
 int yr = yl + Bsy;
 if (yr &gt; Asy) continue;

 // find the maximum correlation in this cell
 int cormxat = xl + yl * Asx;
 double cormx = crosscorrs[cormxat];
 for (int x = xl; x &lt; xr; x++)
 for (int y = yl; y &lt; yr; y++)
 {
 int j = x + y * Asx;
 if (crosscorrs[j] &gt; cormx)
 cormx = crosscorrs[cormxat = j];
 }
 int corx = cormxat % Asx;
 int cory = cormxat / Asx;

 // We dont want subimages that fall of the larger image
 if (corx + Bsx &gt; Asx) continue;
 if (cory + Bsy &gt; Asy) continue;

 signed8 sad = 0;
 for (int x = 0; sad &lt; minsad &amp;&amp; x &lt; Bsx; x++)
 for (int y = 0; y &lt; Bsy; y++)
 {
 int j = (x + corx) + (y + cory) * Asx;
 int i = x + y * Bsx;
 sad += Math.Abs((int)Bsad[i] - (int)Asad[j]);
 }

 if (sad &lt; minsad)
 {
 minsad = sad;
 sadx = corx;
 sady = cory;
 // printf("* ");
 }
 // printf("Grid (%d,%d) (%d,%d) Sip=%g Sad=%lld\n",a,b,corx,cory,cormx,sad);
 }
 }
 //Console.Write("{0:D}\t{1:D}\n", sadx, sady);
 /**
 * Aa, Ba, Af and Bf were allocated in this function
 * crosscorrs was an alias for Aa and does not require deletion.
 */
 fftw.free(Aa);
 fftw.free(Ba);
 fftw.free(Af);
 fftw.free(Bf);
 return new Point(sadx, sady);
 }

 private static void normalize(ref signed2[] img, int sx, int sy, int wx, int wy)
 {
 /**
 * Calculate the mean background. We will subtract this
 * from img to make sure that it has a mean of zero
 * over a window size of wx x wy. Afterwards we calculate
 * the square of the difference, which will then be used
 * to normalize the local variance of img.
 */
 signed2[] mean = boxaverage(img, sx, sy, wx, wy);
 signed2[] sqr = new signed2[sx * sy];
 for (int j = 0; j &lt; sx * sy; j++)
 {
 img[j] -= mean[j];
 signed2 v = img[j];
 sqr[j] = (signed2)(v * v);
 }
 signed2[] var = boxaverage(sqr, sx, sy, wx, wy);
 /**
 * The normalization process. Currenlty still
 * calculated as doubles. Could probably be fixed
 * to integers too. The only problem is the sqrt
 */
 for (int j = 0; j &lt; sx * sy; j++)
 {
 double v = Math.Sqrt(Math.Abs((double)var[j]));//#double v = sqrt(fabs(var[j])); &lt;- ambigous
 Debug.Assert(!double.IsInfinity(v) &amp;&amp; v &gt;= 0);
 if (v &lt; 0.0001) v = 0.0001;
 img[j] = (signed2)(img[j] * (32 / v));
 if (img[j] &gt; 127) img[j] = 127;
 if (img[j] &lt; -127) img[j] = -127;
 }
 /**
 * As a last step in the normalization we
 * window the sub image around the borders
 * to become 0
 */
 window(ref img, sx, sy, wx, wy);
 }

 private static signed2[] boxaverage(signed2[] input, int sx, int sy, int wx, int wy)
 {
 signed2[] horizontalmean = new signed2[sx * sy];

 Debug.Assert(horizontalmean != null);
 int wx2 = wx / 2;
 int wy2 = wy / 2;
 int from = (sy - 1) * sx;
 int to = (sy - 1) * sx;
 int initcount = wx - wx2;
 if (sx &lt; initcount) initcount = sx;
 int xli = -wx2;
 int xri = wx - wx2;
 for (; from &gt;= 0; from -= sx, to -= sx)
 {
 signed8 sum = 0;
 int count = initcount;
 for (int c = 0; c &lt; count; c++)
 sum += (signed8)input[c + from];
 horizontalmean[to] = (signed2)(sum / count);
 int xl = xli, x = 1, xr = xri;
 /**
 * The area where the window is slightly outside the
 * left boundary. Beware: the right bnoundary could be
 * outside on the other side already
 */
 for (; x &lt; sx; x++, xl++, xr++)
 {
 if (xl &gt;= 0) break;
 if (xr &lt; sx)
 {
 sum += (signed8)input[xr + from];
 count++;
 }
 horizontalmean[x + to] = (signed2)(sum / count);
 }
 /**
 * both bounds of the sliding window
 * are fully inside the images
 */
 for (; xr &lt; sx; x++, xl++, xr++)
 {
 sum -= (signed8)input[xl + from];
 sum += (signed8)input[xr + from];
 horizontalmean[x + to] = (signed2)(sum / count);
 }
 /**
 * the right bound is falling of the page
 */
 for (; x &lt; sx; x++, xl++)
 {
 sum -= (signed8)input[xl + from];
 count--;
 horizontalmean[x + to] = (signed2)(sum / count);
 }
 }

 /**
 * The same process as aboe but for the vertical dimension now
 */
 int ssy = (sy - 1) * sx + 1;
 from = sx - 1;
 signed2[] verticalmean = new signed2[sx * sy];
 Debug.Assert(verticalmean != null);
 to = sx - 1;
 initcount = wy - wy2;
 if (sy &lt; initcount) initcount = sy;
 int initstopat = initcount * sx;
 int yli = -wy2 * sx;
 int yri = (wy - wy2) * sx;
 for (; from &gt;= 0; from--, to--)
 {
 signed8 sum = 0;
 int count = initcount;
 for (int d = 0; d &lt; initstopat; d += sx)
 sum += (signed8)horizontalmean[d + from];
 verticalmean[to] = (signed2)(sum / count);
 int yl = yli, y = 1, yr = yri;
 for (; y &lt; ssy; y += sx, yl += sx, yr += sx)
 {
 if (yl &gt;= 0) break;
 if (yr &lt; ssy)
 {
 sum += (signed8)horizontalmean[yr + from];
 count++;
 }
 verticalmean[y + to] = (signed2)(sum / count);
 }
 for (; yr &lt; ssy; y += sx, yl += sx, yr += sx)
 {
 sum -= (signed8)horizontalmean[yl + from];
 sum += (signed8)horizontalmean[yr + from];
 verticalmean[y + to] = (signed2)(sum / count);
 }
 for (; y &lt; ssy; y += sx, yl += sx)
 {
 sum -= (signed8)horizontalmean[yl + from];
 count--;
 verticalmean[y + to] = (signed2)(sum / count);
 }
 }
 return verticalmean;
 }

 private static void window(ref signed2[] img, int sx, int sy, int wx, int wy)
 {
 int wx2 = wx / 2;
 int sxsy = sx * sy;
 int sx1 = sx - 1;
 for (int x = 0; x &lt; wx2; x++)
 for (int y = 0; y &lt; sxsy; y += sx)
 {
 img[x + y] = (signed2)(img[x + y] * x / wx2);
 img[sx1 - x + y] = (signed2)(img[sx1 - x + y] * x / wx2);
 }

 int wy2 = wy / 2;
 int syb = (sy - 1) * sx;
 int syt = 0;
 for (int y = 0; y &lt; wy2; y++)
 {
 for (int x = 0; x &lt; sx; x++)
 {
 /**
 * here we need to recalculate the stuff (*y/wy2)
 * to preserve the discrete nature of integers.
 */
 img[x + syt] = (signed2)(img[x + syt] * y / wy2);
 img[x + syb] = (signed2)(img[x + syb] * y / wy2);
 }
 /**
 * The next row for the top rows
 * The previous row for the bottom rows
 */
 syt += sx;
 syb -= sx;
 }
 }

 private static signed2[] read_image(string filename, ref int sx, ref int sy)
 {
 Bitmap image = new Bitmap(filename);
 sx = image.Width;
 sy = image.Height;
 signed2[] GreyImage = new signed2[sx * sy];
 BitmapData bitmapData1 = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
 unsafe
 {
 byte* imagePointer = (byte*)bitmapData1.Scan0;

 for (int y = 0; y &lt; bitmapData1.Height; y++)
 {
 for (int x = 0; x &lt; bitmapData1.Width; x++)
 {
 GreyImage[x + y * sx] = (signed2)((imagePointer[0] + imagePointer[1] + imagePointer[2]) / 3.0);
 //4 bytes per pixel
 imagePointer += 4;
 }//end for x
 //4 bytes per pixel
 imagePointer += bitmapData1.Stride - (bitmapData1.Width * 4);
 }//end for y
 }//end unsafe
 image.UnlockBits(bitmapData1);
 return GreyImage;
 }
}
</code></pre>

blocks|key|360164|text|您可以使用此目标区域的独特视觉元素来确定其位置。这些独特的视觉元素就像一个“签名”。例如:独特的图标、图像和符号。如果角落中有独特的元素，则此方法独立于窗口分辨率工作。对于固定大小的窗口，只需一个元素就足以找到所有窗口坐标。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|360165|下面我将用一个使用Marvin+Framework的简单示例来说明这一想法。|offset|length|360166|唯一元素：|style|BOLD|360167|​|360168|📷|atomic|360169|360170|360171|程序输出：|360172|360173|360174|360175|原图：|360176|window.png|360177|源码：|360178|import+static+marvin.MarvinPluginCollection.*;

public+class+FindSubimageWindow+{
++++public+FindSubimageWindow(){
++++++++MarvinImage+window+=+MarvinImageIO.loadImage("./res/window.png");
++++++++MarvinImage+eclipse+=+MarvinImageIO.loadImage("./res/eclipse_icon.png");
++++++++MarvinImage+progress+=+MarvinImageIO.loadImage("./res/progress_icon.png");

++++++++MarvinSegment+seg1,+seg2;
++++++++seg1+=+findSubimage(eclipse,+window,+0,+0);
++++++++drawRect(window,+seg1.x1,+seg1.y1,+seg1.x2-seg1.x1,+seg1.y2-seg1.y1);

++++++++seg2+=+findSubimage(progress,+window,+0,+0);
++++++++drawRect(window,+seg2.x1,+seg2.y1,+seg2.x2-seg2.x1,+seg2.y2-seg2.y1);

++++++++drawRect(window,+seg1.x1-10,+seg1.y1-10,+(seg2.x2-seg1.x1)%2B25,+(seg2.y2-seg1.y1)%2B20);

++++++++MarvinImageIO.saveImage(window,+"./res/window_out.png");
++++}
++++private+void+drawRect(MarvinImage+image,+int+x,+int+y,+int+width,+int+height){
++++++++x-=4;+y-=4;+width%2B=8;+height%2B=8;
++++++++image.drawRect(x,+y,+width,+height,+Color.red);
++++++++image.drawRect(x%2B1,+y%2B1,+width-2,+height-2,+Color.red);
++++++++image.drawRect(x%2B2,+y%2B2,+width-4,+height-4,+Color.red);
++++}
++++public+static+void+main(String[]+args)+{
++++++++new+FindSubimageWindow();
++++}+++
}|code-block|syntax|javascript|360179|entityMap|0|LINK|mutability|MUTABLE|url|http://marvinproject.sourceforge.net/|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/624347dbfdf94a141acd28ef50e96d8c.png|imageAlt|2|https://ask.qcloudimg.com/http-save/yehe-900000/bb7353e521dd8cb41e91b45671b034f7.png|3|https://ask.qcloudimg.com/http-save/yehe-900000/e176acf97cfc8bd2753ce0d508a5c12a.png|4|http://marvinproject.sourceforge.net/other/window.png^0|0|9|G|0|0|0|5|0|0|0|1|1|0|0|1|2|0|0|0|5|0|0|0|1|3|0|0|0|3|0|0|A|4|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1R|8|@]|9|@$D|1S|E|1T|1|1U]]|A|$]]|$1|F|3|G|5|6|7|1V|8|@$D|1W|E|1X|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1Z|8|@]|9|@$D|20|E|21|1|22]]|A|$]]|$1|O|3|M|5|N|7|23|8|@]|9|@$D|24|E|25|1|26]]|A|$]]|$1|P|3|K|5|6|7|27|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|28|8|@$D|29|E|2A|H|I]]|9|@]|A|$]]|$1|S|3|K|5|6|7|2B|8|@]|9|@]|A|$]]|$1|T|3|M|5|N|7|2C|8|@]|9|@$D|2D|E|2E|1|2F]]|A|$]]|$1|U|3|K|5|6|7|2G|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2H|8|@$D|2I|E|2J|H|I]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|2K|8|@]|9|@$D|2L|E|2M|1|2N]]|A|$]]|$1|Z|3|10|5|6|7|2O|8|@$D|2P|E|2Q|H|I]]|9|@]|A|$]]|$1|11|3|12|5|13|7|2R|8|@]|9|@]|A|$14|15]]|$1|16|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]]|17|$18|$5|19|1A|1B|A|$1C|1D]]|1E|$5|1F|1A|1G|A|$1H|1I|1J|-4]]|1K|$5|1F|1A|1G|A|$1H|1L|1J|-4]]|1M|$5|1F|1A|1G|A|$1H|1N|1J|-4]]|1O|$5|19|1A|1B|A|$1C|1P]]]]

You could use unique visual elements of this target area to determine its position. These unique visual elements are like a "signature". Examples: unique icons, images and symbols. This approach works independently of the window resolution if you have unique elements in the corners. For fixed sized windows, just one element is sufficient to find all window coordinates. 

Below I illustrate the idea with a simple example using <a href="http://marvinproject.sourceforge.net" rel="nofollow noreferrer">Marvin Framework</a>.

Unique elements: 

<a href="https://i.stack.imgur.com/YvUr7.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/YvUr7.png" alt="enter image description here"></a> 
<a href="https://i.stack.imgur.com/Vd4XK.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Vd4XK.png" alt="enter image description here"></a>

Program output:

<a href="https://i.stack.imgur.com/FlTQR.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/FlTQR.png" alt="enter image description here"></a>

Original Image: 
<a href="http://marvinproject.sourceforge.net/other/window.png" rel="nofollow noreferrer">window.png</a>

Source code:

<pre><code>import static marvin.MarvinPluginCollection.*;

public class FindSubimageWindow {
 public FindSubimageWindow(){
 MarvinImage window = MarvinImageIO.loadImage("./res/window.png");
 MarvinImage eclipse = MarvinImageIO.loadImage("./res/eclipse_icon.png");
 MarvinImage progress = MarvinImageIO.loadImage("./res/progress_icon.png");

 MarvinSegment seg1, seg2;
 seg1 = findSubimage(eclipse, window, 0, 0);
 drawRect(window, seg1.x1, seg1.y1, seg1.x2-seg1.x1, seg1.y2-seg1.y1);

 seg2 = findSubimage(progress, window, 0, 0);
 drawRect(window, seg2.x1, seg2.y1, seg2.x2-seg2.x1, seg2.y2-seg2.y1);

 drawRect(window, seg1.x1-10, seg1.y1-10, (seg2.x2-seg1.x1)+25, (seg2.y2-seg1.y1)+20);

 MarvinImageIO.saveImage(window, "./res/window_out.png");
 }
 private void drawRect(MarvinImage image, int x, int y, int width, int height){
 x-=4; y-=4; width+=8; height+=8;
 image.drawRect(x, y, width, height, Color.red);
 image.drawRect(x+1, y+1, width-2, height-2, Color.red);
 image.drawRect(x+2, y+2, width-4, height-4, Color.red);
 }
 public static void main(String[] args) {
 new FindSubimageWindow();
 } 
}
</code></pre>

Does anyone know of an algorithm (or search terms / descriptions) to locate a known image within a larger image?

e.g.

I have an image of a single desktop window containing various buttons and areas (target). I also have code to capture a screen shot of the current desktop. I would like an algorithm that will help me find the target image within the larger desktop image (what exact x and y coordinates the window is located at). The target image may be located anywhere in the larger image and may not be 100% exactly the same (very similar but not exact possibly b/c of OS display differences)

Does anyone know of such an algorithm or class of algorithms?

I have found various image segmentation and computer vision algorithms but they seem geared to "fuzzy" classification of regions and not locating a specific image within another.

** My goal is to create a framework that, given some seed target images, can find "look" at the desktop, find the target area and "watch" it for changes. **

Find known sub image in larger image

计算机视觉

图像分割

Java

有没有人知道一种算法(或搜索词/描述)可以在较大的图像中定位已知图像？例如：我有一个包含各种按钮和区域(目标)的单一桌面窗口的图像。我还有代码来捕获当前桌面的屏幕截图。我想要一个算法，可以帮助我在较大的桌面图像中找到目标图像(窗口所在的确切x和y坐标)。目标映像可能位于较大映像中的任何位置，并且可能不是100%完全相同...

问在较大的图像中查找已知子图像
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在较大的图像中查找已知子图像EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在较大的图像中查找已知子图像
EN