Buenas

1) El título de un tema debe describir el problema.
Porfavor, lee las normas del subforo de programación.

---

¿Donde está el código que demuestra tus progresos?, en este lugar no hacemos trabajos, ayudamos a resolver dudas específicas o aportamos orientación.

Hay varias librerías, algunas gratis y otras de pago, que ofrecen algoritmos profesionales de técnicas ImageSearch o PixelSearch, como por ejemplo AForge.Net
http://www.aforgenet.com/framework/downloads.html

Si quieres desarrollar tu propio algoritmo de forma tradicional no te lo recomiendo, por el simple hecho de que jamás podrás optimizarlo hasta tal punto, pero de todas formas puedes ver un ejemplo escrito en VB.Net en la class PixelUtil que desarrollé:
Librería de Snippets !! (Compartan aquí sus snippets)

Este ejemplo utilizando Aforge, es una función de uso genérico que busca una imagen en otra imagen, y devuelve un objeto con las coordenadas y otra información relevante:

VB.Net:

    ' Find Image
    ' ( By Elektro )
    '
    ' Usage Examples:
    '
    'Private Sub Test() Handles MyBase.Shown
    '
    '    ' A Desktop Screenshot, in 1920x1080 px. resolution.
    '    Dim desktopScreenshoot As New Bitmap("C:\Desktop.png")
    '
    '    ' A cutted piece of the screenshot, in 50x50 px. resolution.
    '    Dim partOfDesktopToFind As New Bitmap("C:\PartOfDesktop.png")
    '
    '    ' Find the part of the image in the desktop, with the specified similarity.
    '    For Each matching As AForge.Imaging.TemplateMatch In
    '
    '        FindImage(baseImage:=desktopScreenshoot, imageToFind:=partOfDesktopToFind, similarity:=80.5R) ' 80,5% similarity.
    '
    '        Dim sb As New System.Text.StringBuilder
    '
    '        sb.AppendFormat("Top-Left Corner Coordinates: {0}", matching.Rectangle.Location.ToString())
    '        sb.AppendLine()
    '        sb.AppendFormat("similarity Image Percentage: {0}%", (matching.similarity * 100.0F).ToString("00.00"))
    '
    '        MessageBox.Show(sb.ToString)
    '
    '    Next matching
    '
    'End Sub
    '
    ''' <summary>
    ''' Finds a part of an image inside other image and returns the top-left corner coordinates and it's similarity percent.
    ''' </summary>
    ''' <param name="baseImage">
    ''' Indicates the base image.
    ''' </param>
    ''' <param name="imageToFind">
    ''' Indicates the image to find in the base image.
    ''' </param>
    ''' <param name="similarity">
    ''' Indicates the similarity percentage to compare the images.
    ''' A value of '100' means identical image. 
    ''' Note: High percentage values with big images could take several minutes to finish.
    ''' </param>
    ''' <returns>AForge.Imaging.TemplateMatch().</returns>
    Private Function FindImage(ByVal baseImage As Bitmap,
                               ByVal imageToFind As Bitmap,
                               ByVal similarity As Double) As AForge.Imaging.TemplateMatch()
 
        Dim currentSimilarity As Single
 
        ' Translate the readable similarity percent value to Single value.
        Select Case similarity
 
            Case Is < 0.1R, Is > 100.0R ' Value is out of range.
                Throw New Exception(String.Format("similarity value of '{0}' is out of range, range is from '0.1' to '100.0'",
                                                  CStr(similarity)))
 
            Case Is = 100.0R ' Identical image comparission.
                currentSimilarity = 1.0F
 
            Case Else ' Image comparission with specific similarity.
                currentSimilarity = Convert.ToSingle(similarity) / 100.0F
 
        End Select
 
        ' Set the similarity threshold to find all matching images with specified similarity.
        Dim tm As New AForge.Imaging.ExhaustiveTemplateMatching(currentSimilarity)
 
        ' Return all the found matching images, 
        ' it contains the top-left corner coordinates of each one 
        ' and matchings are sortered by it's similarity percent.
        Return tm.ProcessImage(baseImage, imageToFind)
 
    End Function
 

C#:
EDITO: El Snippet está traducido incorrectamente.

// Find Image
// ( By Elektro )
 
/// <summary>
/// Finds a part of an image inside other image and returns the top-left corner coordinates and it's similarity percent.
/// </summary>
/// <param name="baseImage">
/// Indicates the base image.
/// </param>
/// <param name="imageToFind">
/// Indicates the image to find in the base image.
/// </param>
/// <param name="similarity">
/// Indicates the similarity percentage to compare the images.
/// A value of '100' means identical image. 
/// Note: High percentage values with big images could take several minutes to finish.
/// </param>
/// <returns>AForge.Imaging.TemplateMatch().</returns>
private AForge.Imaging.TemplateMatch[] FindImage(Bitmap baseImage, Bitmap imageToFind, double similarity)
{
 
	float currentSimilarity = 0;
 
	// Translate the readable similarity percent value to Single value.
	switch (similarity) {
 
		case 100.0: // Identical image comparission.
			currentSimilarity = 1f;
			break;
 
		default: // Image comparission with specific similarity.
			currentSimilarity = Convert.ToSingle(similarity) / 100f;
			break;
	}
 
	// Set the similarity threshold to find all matching images with specified similarity.
	AForge.Imaging.ExhaustiveTemplateMatching tm = new AForge.Imaging.ExhaustiveTemplateMatching(currentSimilarity);
 
	// Return all the found matching images, 
	// it contains the top-left corner coordinates of each one 
	// and matchings are sortered by it's similarity percent.
	return tm.ProcessImage(baseImage, imageToFind);
 
}
 
//=======================================================
//Service provided by Telerik (www.telerik.com)
//=======================================================

Saludos.

No te preocupes, aquí nadie es mejor que nadie y todos vienen a aprender.

Hombre, por supuesto, solo debes obtener la imagen de la zona donde quieras buscar (puede ser una captura de la pantalla completa, claro), y si la imagen es demasiado grande redimensionar la imagen a unas dimensiones que te permitan realizar la búsqueda y comparación de imagen de una forma eficiente, rápida, pero sin aumentar el margen de falsos positivos, buscando esa relación (ej: 100x100 píxeles quizás, depende).

EDITO:
No me ha quedado claro que camino vas a tomar para llevarlo a cabo, pero bueno vuelvo a aconsejarte utilizar la librería de AForge.Net, aunque he visto algoritmos de pago mucho más rápidos que obtienen los mismos o mejores resultados, pero AForge es excelente para ser gratis.

Realizar un algoritmo de ese estilo es relativamente fácil, de forma básica, pero es un tema muy delicado ya que procesar/comparar una imagen, una imagen que sea grande, es una operación muy lenta (y si usas metodologías anticuadas lo es aun mucho más), si no optimizas tu propio algoritmo hasta el punto que puede llegar a optimizarlo un grupo de desarrolladores profesionales en el tema que están vendiendo un producto de ese estilo entonces te puede quedar un algoritmo muy lento o incompetente en otros sentidos, y yo no soy ningún gurú en la optimización de este tema, pero llegué a implementar funcionalidades GPU para aumentar la velocidad de procesamiento de imagen y aun así no me convenció mucho el resultado que obtuve, sigo prefiriendo la estabilidad de AForge.

Saludos

Hola ^^ sabrías qué falla aquí?

    Bitmap bmpScreenshot = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
                Graphics gfxScreenshot = Graphics.FromImage(bmpScreenshot);
                gfxScreenshot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
                System.Drawing.Bitmap sourceImage = new Bitmap (@"C:\Users\PC\Documents\Visual Studio 2012\Projects\NeoBux\NeoBux\obj\Debug\Ball.bmp");            
                System.Drawing.Bitmap template = new Bitmap(bmpScreenshot);
                ExhaustiveTemplateMatching tm = new ExhaustiveTemplateMatching(0.921f);
                TemplateMatch[] matchings = tm.ProcessImage(sourceImage, template);//fallo aquí

Yo una vez hice (copie en parte) un algoritmo ImageSearch bastante eficiente como para una imagen 1024 x 768.
El algoritmo se basa en ir pixel por pixel comparando el primer pixel de la imagen X (imagen a buscar) con los pixeles de la imagen B (imagen base).
Por primera vez yo lo había hecho con GetPixel (funcion de la libreria grafica de C#) pero era muy lento. Buscando en internet encontré que a través de punteros podes acceder directamente a la memoria donde se encuentran almacenados cada pixel, haciendo que la velocidad aumente considerablemente.

Acá te dejo un link con la información necesaria:
http://bobpowell.net/lockingbits.aspx

Nunca probé AForge pero el metodo que yo te digo lo podes comprobar acá:


Quizas te parezca algo lento pero eso se debe a que la imagen la obtiene de un WebBrowser, si la sacas de algún archivo estático y comparás, va a ser muy veloz.

Obviamente se podria optimizar mucho mas, haciendo por ejemplo, lo que dice Elektro, dividir en partes de 100x100.

Saludos