PixelMath: Donde esta el fallo

[ManoloL]

Hola a todos:
Estoy intentando ejercitarme con PixelMath.
Pretendía mediante una formula sustituir un tramo de una columna, por la media de los píxeles de ambos lados de dicha columna.
Ya se que hay un script escrito por Oriol al respecto, si bien por ahora trata una columna, o fila, completamente y no permite limitarlo a un tramo.
Como primer paso queria introducir en una imagen un tramo de columna saturado, para posteriormente eliminarlo.
Para ello he definido estos símbolos:

columna
iniciofila
finfila
x
y

después he introducido estas sentencias:

columna=5;
iniciofila=20;
finfila=100;
x=XPos();
y=YPos();
iif((x=columna)&&((y>iniciofila)&&(y<finfila)),1,$target)

Esperaba que el resultado fuera que la columna 5 tuviera los pixeles saturados entre las filas 21 y 99.
Pero mi sorpresa es que el resultado es una franja saturada que incluye todas las columnas entre las filas 21 y 99.

¿Alguien me puede indicar donde esta el fallo?




Saludos.

[Silvercup]

Hola:

Prueba a poner iff((x==columna)...

Saludos. Silvercup

[ManoloL]

Hola:

Prueba a poner iff((x==columna)...

Saludos. Silvercup

Hello Silvercup

That is the questión!

Thank you

Dos días dando vueltas al asunto. Por cierto que cuando estuve leyendo el tutorial del PixelMath me llamo la atención lo del doble=.
Pero luego me he olvidado de utilizarlo.
Mi siguiente paso será hacer desaparecer la traza vertical que he creado.

Saludos

[ManoloL]

Hola de nuevo:
Ya he terminado el PixelMath que repara un tramo de columna.
Los símbolos definidos son los mismos citados y las sentencias:

columna=5;
iniciofila=20;
finfila=100;
x=XPos();
y=YPos();
iif((x==columna)&&(y>iniciofila)&&(y<finfila),(Pixel($target,columna-1,y)+Pixel($target,columna+1,y))/2,$target)

Lo he probado quitando la traza marcada con la utilidad anterior

Hay que ajustar para un caso normal:

columna= numero correspondiente a la columna defectuosa
iniciofila= numero de la fila de la columna donde está el último píxel bueno
finfila= numero de la fila de la columna donde está el primer píxel bueno después del tramo defectuoso

y parece que funciona para una cámara monocroma, para una de color no resulta adecuado pues sustituye el valor de un color por los adjuntos que son de otros colores y no tienen normalmente continuidad entre si.


Saludos

[Carlos Milovic]

Manolo, muy buen trabajo

Quizás sería buena idea crear una "galería" con íconos útiles de procesamiento, sobretodo instancias de PixelMath. ¿Qué opinas, Juan?



PD: Yo tengo un módulo escrito hace tiempo que hace algo similar, pero usando una imagen "máscara" como referencia para hacer los reemplazos. En inglés a esta idea se le llama corrección por "Deffect Map". Saliendo de los trabajos actuales que tengo, pondré ese módulo como primera prioridad para retomar, actualizar, y mandárselo a Juan

[Silvercup]

Hola Carlos:

Muy buena idea esa de la galería de códigos. Yo estoy ahora con un script para sustituir un preview en la imagen principal por otro preview procesado.

Saludos. Silvercup.
 

[Juan Conejero]

Carlos, excelente idea. Tengo que actualizar el tutorial sobre PixelMath para incluir todas las funciones y características nuevas (hay bastantes).

Silver, ánimo con ese script. Por supuesto, sabes que cuentas con mi ayuda en lo que puedas necesitar.

[Juan Conejero]

[English text at the bottom]

Hola Manolo

columna=5;
iniciofila=20;
finfila=100;
x=XPos();
y=YPos();
iif((x==columna)&&(y>iniciofila)&&(y<finfila),(Pixel($target,columna-1,y)+Pixel($target,columna+1,y))/2,$target)

Buen ejemplo de PixelMath. Puedes optimizar mucho esta expresión si en vez de asignar valores constantes a las variables columna, iniciofila y finfila, las defines como constantes en PixelMath. Para hacer esto, escribe lo siguiente en el campo Symbols:

Code: [Select]

x, y, columna=5, iniciofila=20, finfila=100
y entonces tu expresión queda así:

Code: [Select]

x=XPos();
y=YPos();
iif( x == columna && y > iniciofila && y < finfila, (Pixel( $T, columna-1, y ) + Pixel( $T, columna+1, y ))/2, $T )
En vez de $target se puede usar ahora $T, que es mucho más breve y simplifica las expresiones.

La mayoría de los paréntesis que estabas definiendo eran innecesarios, y hacían la expresión menos legible. En las expresiones lógicas y condicionales, ten en cuenta lo siguiente:

- La precedencia (orden de evaluación) de los operadores lógicos es la siguiente: ! ("no", negación), && ("y", intersección), || ("o", unión). En cuanto a precedencia, estos operadores son equivalentes a - (cambio de signo), * (multiplicación), + (suma), respectivamente.

- Los operadores relacionales (==, !=, <, <=, >, >=) tienen todos la misma precedencia, y ésta es siempre mayor que la de los operadores lógicos (se evalúan antes).

Por ejemplo, estas dos expresiones son equivalentes:

Code: [Select]

(a < b) || (b < c)
a < b || b < c
y éstas también:

Code: [Select]

(a && b) || (c && d)
a && b || c && d
sin embargo, éstas son diferentes:

Code: [Select]

a && b || c && d
a && (b || c) && d
Bienvenido a PixelMath. Siempre resulta sorprendente comprobar el tipo de cosas increíbles que se pueden hacer con esta herramienta. La mayoría de usuarios todavía no es consciente de lo enormemente potente que es. Y lo será más, porque aún no he terminado con ella, ni mucho menos


==============================================


Hi Manolo

columna=5;
iniciofila=20;
finfila=100;
x=XPos();
y=YPos();
iif((x==columna)&&(y>iniciofila)&&(y<finfila),(Pixel($target,columna-1,y)+Pixel($target,columna+1,y))/2,$target)

Good PixelMath example. You can optimize this expression a lot if instead of assigning constant values to the columna, iniciofila and finfila variables, you define them as constants in PixelMath. To do that, write the following in the Symbols field:

Code: [Select]

x, y, columna=5, iniciofila=20, finfila=100
then your expression reduces to:

Code: [Select]

x=XPos();
y=YPos();
iif( x == columna && y > iniciofila && y < finfila, (Pixel( $T, columna-1, y ) + Pixel( $T, columna+1, y ))/2, $T )
Instead of $target you can use now $T, which is much more readable and simplifies expressions.

Most of the parentheses you had defined are unnecessary, and they were making your expression less readable. For logical and conditional expressions, note the following:

- Precedence (evaluation order) of logical operators is: ! ("not", logical negation), && ("and", intersection), || ("or", union). Regarding precedence, these operators are equivalent to - (sign change), * (multiplication), + (addition), respectively.

- Relational operators (==, !=, <, <=, >, >=) have all of them the same precedence, which is always higher than the precedence of logical operators.

For example, these two expressions are equivalent:

Code: [Select]

(a < b) || (b < c)
a < b || b < c
and these, too:

Code: [Select]

(a && b) || (c && d)
a && b || c && d
But these are different:

Code: [Select]

a && b || c && d
a && (b || c) && d
Welcome to PixelMath. It is always amazing all the incredible things that can be done with this tool. Most users still don't realize how powerful it is. And it will be more powerful, since I haven't finished its development, by no means

[ManoloL]

Hola Manolo

columna=5;
iniciofila=20;
finfila=100;
x=XPos();
y=YPos();
iif((x==columna)&&(y>iniciofila)&&(y<finfila),(Pixel($target,columna-1,y)+Pixel($target,columna+1,y))/2,$target)

Buen ejemplo de PixelMath. Puedes optimizar mucho esta expresión si en vez de asignar valores constantes a las variables columna, iniciofila y finfila, las defines como constantes en PixelMath. Para hacer esto, escribe lo siguiente en el campo Symbols:

Code: [Select]

x, y, columna=5, iniciofila=20, finfila=100
y entonces tu expresión queda así:

Code: [Select]

x=XPos();
y=YPos();
iif( x == columna && y > iniciofila && y < finfila, (Pixel( $T, columna-1, y ) + Pixel( $T, columna+1, y ))/2, $T )
En vez de $target se puede usar ahora $T, que es mucho más breve y simplifica las expresiones.

La mayoría de los paréntesis que estabas definiendo eran innecesarios, y hacían la expresión menos legible. En las expresiones lógicas y condicionales, ten en cuenta lo siguiente:

- La precedencia (orden de evaluación) de los operadores lógicos es la siguiente: ! ("no", negación), && ("y", intersección), || ("o", unión). En cuanto a precedencia, estos operadores son equivalentes a - (cambio de signo), * (multiplicación), + (suma), respectivamente.

- Los operadores relacionales (==, !=, <, <=, >, >=) tienen todos la misma precedencia, y ésta es siempre mayor que la de los operadores lógicos (se evalúan antes).

Por ejemplo, estas dos expresiones son equivalentes:

Code: [Select]

(a < b) || (b < c)
a < b || b < c
y éstas también:

Code: [Select]

(a && b) || (c && d)
a && b || c && d
sin embargo, éstas son diferentes:

Code: [Select]

a && b || c && d
a && (b || c) && d
Bienvenido a PixelMath. Siempre resulta sorprendente comprobar el tipo de cosas increíbles que se pueden hacer con esta herramienta. La mayoría de usuarios todavía no es consciente de lo enormemente potente que es. Y lo será más, porque aún no he terminado con ella, ni mucho menos

Hola a todos:

Juan:
Muchas gracias por tus indicaciones.
Desconocía que al definir el símbolo se le podía asignar su valor.
Ya había realizado alguna excursión por PixelMath
http://fotografiaastronomica.com/files/posted_images/user_41_talkoverdepx.jpg
después de haber releído con detenimiento el tutorial y quedo a la espera de su actualización.

Saludos.