1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

        public void DebugMethod(Bitmap uNeedleImage) {

            var NeedleBuf = BufferFromImage(uNeedleImage); //Erstellen des ByteBuffers

            var ImgCopy = new Bitmap(uNeedleImage); //Klonen des Bildes
            var NeedleBuf2 = BufferFromImage(ImgCopy); 
            //Eigentlich sollten die beiden Buffer "NeedleBuf" und NeedleBuf2 gleich sein. Die haben aber nicht mal die gleiche Länge... 

        }

        private byte[] BufferFromImage(Image img) {
            ImageConverter converter = new ImageConverter();
            return (byte[])converter.ConvertTo(img, typeof(byte[]));
        }					

1:
2:
3:
4:
5:
6:
7:
8:

        private Bitmap Copy(Bitmap srcBitmap, Rectangle section) {

            Bitmap bmp = new Bitmap(section.Width, section.Height, Graphics.FromImage(NeedleImage));
            Graphics g = Graphics.FromImage(bmp);
            g.DrawImage(srcBitmap, 0, 0, section, GraphicsUnit.Pixel);
            g.Dispose();
            return bmp;
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

byte[] bytes;

var bmp = new Bitmap(@"d:\foo.bmp");
var bmpData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, bmp.PixelFormat);
try
{
  bytes = new Byte[bmpData.Stride * bmp.Height];
  Marshal.Copy(bmpData.Scan0, bytes, 0, bytes.Length);
}
finally
{
  bmp.UnlockBits(bmpData);
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

        private byte[] HashFromImage(Bitmap bmp) {
            int i = -1;
            byte[] ImagePixelBuffer = new byte[bmp.Size.Height * bmp.Size.Width * 3];

            Color Pix;
            for(int row = 0; row < bmp.Size.Height; row++)
                for(int col = 0; col < bmp.Size.Width; col++) {
                    Pix = bmp.GetPixel(col, row);
                    ImagePixelBuffer[++i] = Pix.R;
                    ImagePixelBuffer[++i] = Pix.G;
                    ImagePixelBuffer[++i] = Pix.B;
                    // evtl. Alpha Kanal auch noch beachten...
                }
            return HashFromBuffer(ImagePixelBuffer);
        }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

        public Point? Next() {
            if(mDone)
                return null;
            Interlocked.Increment(ref mCurrent_X); // mCurrent.X++;

            if(mCurrent_X > mMaxMovement.Width) {
                lock(Locker) {
                    mCurrent_X = 0;
                }
                Interlocked.Increment(ref mCurrent_Y); //mCurrent.Y++;
                if(mCurrent_Y > mMaxMovement.Height) {
                    lock(Locker) {
                        mDone = true;
                    }
                    return null;
                }
            }
            return new Point(mCurrent_X, mCurrent_Y);
        }