Algoritmo de recorrido de imagenes.

[Mick]

Supongo que el calculo que usas consiste en recorrer solamente una vez los pixeles de la imagen, es un algoritmo simple de modo que no hay forma de conseguir otro algoritmo que vaya mas rapido, ya que es imposible calcular el histograma sin acceder como minimo una vez a todos y cada uno de los pixeles.
Tampoco indicas cuanto tarda en ejecutarse para poder saber si realmente es demasiado tiempo, como referencia te puedo decir que el calculo que haces programado en Delphi para una imagen de 10 megabytes tarda menos de 2 decimas de segundo en un PIV a 2.4 Ghz (sin contar el tiempo de carga de la imagen en memoria desde el disco duro).
Si solo recorres una vez cada pixel, la lentitud podria venir o de que no hay suficiente memoria libre para cargar la imagen completa en memoria, o que utilices una forma muy lenta de acceder a los pixeles de la imagen, o que quizas el codigo hecho en C# no lo hayas compilado a codigo nativo.
Si no muestras ningun codigo fuente dificilmente se podra descubrir el problema.

En cuanto a la congestion del procesador , en general el procesador mientras esta ejecutando algo sea lo que sea siempre esta al 100%, si solo usase la mitad de ciclos libres (al 50% por ejemplo) el calculo tardaria el doble de tiempo, no teniendo otros threads que ejecutar, seria bastante tonto que el procesador desperdiciase su poder de calculo haciendo los calculos a mitad de su velocidad.

Saludos

[bustio]

Hola:
Ante todo, debo agradecerte el tomarte el trabajo de responder a mi pregunta. Te dire que estoy trabajando en un Celeron P4 a 1.7GHz de velocidad, con 248 Mb de RAM y para una imagen de 28 Mb, con 4000 y tantos por 7000 y tantos pixeles se demora bastante... por encima de los 10 minutos, cosa que es indeseable. Estoy comparando mi histograma con el que trae implementado el Paint Shop Pro 9 y para la misma imagen solo se demora unos pocos segundos. Evidentemente, ellos hacen algun tipo de analiisis no solo mas rapido qeu el que yo hago, sino muchisimo mas eficiente. En pocas palabras, lo que hago es algo como esto:

creo una variable tipo Bitmap y luego le asigno la imagen leida desde el fichero que deseo analizar.
Luego, cuento los pixeles por filas y columnas y luego con un ciclo voy visitando pixel a pixel, y en ese momento y para el pixel(x,y) obtengo sus respectivos valores en la escala RGB y los almaceno en los arrays de los que ya te hable en mi pregunta. Pienso que la demora esta en el recorrido de la imagen, por que lo que resta es leer estos arrays y con LineTo... graficar los valores.
No se de que otra manera pudiera optimizar esto. En realidad, no me interesa tanto que el procesador este al 100% como que el calculo del histograma sea rapido. Pienso que se puede sacrificar un poco la congestion del micro con el fin de que este analisis sea rapido.

De cualquier manera, si crees ser capaz de ayudarme con el codigo, pues perfectamente te lo puedo enviar(si es que esto no viola las reglas del foro)para ver de qye manera se puede llegar a la solucion mas optima.
Te agradezco otra vez por tomarte el trabajo de responderme..

GRACIAS!!!

[<Sergio>]

Empezado por bustio

creo una variable tipo Bitmap y luego le asigno la imagen leida desde el fichero que deseo analizar.
Luego, cuento los pixeles por filas y columnas y luego con un ciclo voy visitando pixel a pixel, y en ese momento y para el pixel(x,y) obtengo sus respectivos valores en la escala RGB

¿No estarás accediendo a la imagen con el pixels[], verdad?

P.D.

Si lo estás haciendo es mejor que utilices el scanline (muchísimo más rápido por varios motivos...), te devuelve una referencia a memoria al inicio de la linea "y".

Define un tipo de dato de acuerdo al tipo de formato de pixel, ej: arreglo de bytes para 24 bits: en bytes: 3*ancho de la imagen.

TLinea=array[0..64535] of byte;//el 64535 solo para el control de rangos del compilador, puede ser 0..0 si no controla rangos.
PLinea=^Tlinea;

Defines una variable del tipo PLinea y le asignas el valor que devuelve
bitmap.scanline(y) suponiendo que tienes un objeto bitmap:Tbitmap

Mucho cuidado de pasarse del ancho total en bytes de cada linea de tu imagen.

Otra forma es usar directamente la referencia a memoria, guardarla en un entero de 4 bytes mientero=integer(bitmap.scanline(y)), hacer un ciclo while e incrementar la posición de memoria a revisar y cuando sea necesario aclararle al compilador que quieres usar tu entero como referencia a memoria: mivalor:=byte(pointer(mientero)^), esto genera código más eficiente.

El pixels[x,y] está pensado para acceder a cualquier pixel de la imagen al azar: realiza control de rangos, llama al scanline por cada pixel y además que realiza conversión de color al formato utilizado por Tcolor. Llamar al scanline para cada pixel es bastante pesado comparado a llamarlo sólo para cada línea.

[bustio]

Pues si Sergio, muchisimas gracias por responder a mi pregunta. En realidad si estoy usando Pixel[]..... fijate bien en mi pregunta original, que dije que estaba programando en C#. Puse esta pregunta en este foro de Delphi por que tambien programo bastante en Delphi y creo que este es uno de los mejores foros que existen,.... ademas, lo que andaba buscando es un algoritmo para optimizar mi tratamiento a las imagenes.
Aunque no he probado todavia, supongo que en C# tambien exista un ScanLines... y siendo asi pondre a prueba tu sugerencia, todo esta en que exista esa funcion o propiedad.
De todas maneras te agradezco mucho haberte tomado el trabajo de leerte mi pregunta y responder.

Saludos..

Lazaro Bustio Martinez.