Implementación preliminar de auto-star-profile-transform.js

[David Serrano]

Bueno, según ha surgido en el foro de astrofotografia.es, aquí tenemos un primer borrador de este proceso. Faltan muchas cosas por hacer todavía, pero esto ya es perfectamente usable:

Code: [Select]

/*
    auto-star-profile-transform.js v0.1
    Iteratively stretch histogram with an appropriate luminance mask each time.
    Copyright (C) 2007  David Serrano

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, version 3 of the License.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// TODO: populate this TODO list xD. Go figure.

#include <pjsr/ColorSpace.jsh>
#include <pjsr/SampleType.jsh>
#include <pjsr/UndoFlag.jsh>

#feature-id AutoStarProfileTransform
#feature-info At the time of stretching the histogram of an image, \
   it's better to do it several times changing the mask used every \
   time - a long, boring task that is perfect for script automation. \
   This script does precisely that.
//#feature-icon auto-star-profile-transform.xpm

#define VERSION "0.1"

var iter = 9;     // iterations
var mt = 0.35;    // midtones

var aw = ImageWindow.activeWindow;

if (aw.isNull)
   throw Error ("No active image window.");

var v = ImageWindow.activeWindow.mainView;

var hist = new HistogramTransform;
hist.H = [
   // shadows, midtones, highlights, ext_shadows, ext_hilights
   [0, 0.5, 1, 0, 1], // R
   [0, 0.5, 1, 0, 1], // G
   [0, 0.5, 1, 0, 1], // B
   [0, mt,  1, 0, 1], // RGB
   [0, 0.5, 1, 0, 1]  // Alpha
];

// these are the image holding the luminance and the corresponding window for masking
var luma;
var luma_w = new ImageWindow (1, 1, 1, v.image.bitsPerSample, false, false, "ASPT_luma");

for (var i = 0; i < iter; i++) {
   // extract luma
   luma = new Image;
   v.image.extractLuminance (luma);

   // transfer image to window and apply the window as mask
   with (luma_w.mainView) {
      beginProcess (UndoFlag_NoSwapFile);
      // ### Note that after this transfer, luma is no longer a reference to a valid Image object
      image.transfer (luma);
      endProcess();
   }
   //luma_w.show();
   aw.maskVisible = false;
   aw.mask = luma_w;

   // stretch
   hist.executeOn (v);

   // clean up
   luma_w.removeMaskReferences();  // automatically removes mask from aw
   gc();
}

luma_w.close();
// no need to set luma to null, since .transfer removed the reference to the Image object
luma_w = null;
gc();

Hay que cargar una imagen o activar aquella sobre la que queremos trabajar, cargar este script, cambiar los variables "iter" y "mt" que hay arriba y darle caña. "iter" es el número de pasadas y "mt" es el valor de medios tonos que tendrá el histograma a usar.

Lo he probado sobre una imagen pequeña y no astronómica.

En aquel hilo de astrofotografia.es, Carlos Sonnenstein mencionó algunas características interesantes que esto podría tener, por ejemplo "calcular automáticamente la transferencia de medios tonos a aplicar en función de las propiedades estadísticas globales de la imagen" o poder aplicar un desenfoque a la máscara. Como yo en esto del proceso de imágenes estoy bastante verde, aceptaría cualquier explicación adicional acerca de todo esto. Por ejemplo, ¿cómo determinarían las estadísticas globales el valor de medios tonos a usar? ¿qué valores estadísticos usar?.

Jordi Gallego, ya que has mostrado un interés especial, quiero animarte en particular a que lo pruebes y me cuentes qué tal te ha ido .

[C. Sonnenstein]

Hola David:

El script funciona, pero hace todo lo contrario: quema las estrellas y protege el fondo del cielo ¿Has invertido los valores de la máscara?

Para refinar el proceso en primer lugar se debería calcular la luminancia de la imagen para que actúe como máscara sobre la imagen principal. Es importante que la máscara sea calculada normalizando los coeficientes de cada canal R, G y B:

Code: [Select]

var p = new RGBWorkingSpace;
with ( p )
{
   channels = // Y, x, y
   [   [1.000000, 0.648431, 0.330856],
   [1.000000, 0.321152, 0.597871],
   [1.000000, 0.155886, 0.066044]];
   gamma = 2.20;
   sRGBGamma = true;
   applyGlobalRGBWS = false;
}


Una vez realizado este paso se extrae la luminancia:

Code: [Select]

var p = new ChannelExtraction;
with ( p )
{
   colorSpace = CIELch;
   channels = // enabled, id
   [
   [true, ""],
   [false, ""],
   [false, ""]];
   sampleFormat = SameAsSource;
}


...y por último se invierten los valores de la luminancia para que actúe como máscara sobre la imagen principal, protegiendo las altas luces.

Luego la transferencia de medios tonos sería:

Code: [Select]

var p = new HistogramTransform;
with ( p )
{
   H = // c0, m, c1, r0, r1
   [
   [0.00000000, 0.50000000, 1.00000000, 0.00000000, 1.00000000],
   [0.00000000, 0.50000000, 1.00000000, 0.00000000, 1.00000000],
   [0.00000000, 0.50000000, 1.00000000, 0.00000000, 1.00000000],
   [0.00000000, 0.47500000, 1.00000000, 0.00000000, 1.00000000],
   [0.00000000, 0.50000000, 1.00000000, 0.00000000, 1.00000000]];
}

Aquí he puesto un valor de 0.475 en el canal RGB/K combinado, pero puede ser otro distinto. A partir de aquí, la máscara utilizada es inservible y hay que calcular de nuevo la luminancia invertida a partir del resultado de la primera iteración.

Carlos Sonnenstein mencionó algunas características interesantes que esto podría tener, por ejemplo "calcular automáticamente la transferencia de medios tonos a aplicar en función de las propiedades estadísticas globales de la imagen" o poder aplicar un desenfoque a la máscara

Aquí ya no sé como continuar. El problema que nos encontramos es que cada imagen RAW puede tener valores estadísticos distintos, por lo que decidir el número de iteraciones dependiendo de la función de transferencia de medios tonos solo puede hacerse a base de prueba y error hasta obtener el valor de brillo deseado. Lo ideal sería pues que  desde el script se pudiese ajustar el brillo final de la imagen en función de los valores estadísticos de la imagen.

Y sobre la posibilidad de desenfocar ligeramente la máscara, lo he estado pensando y quizás no sea necesario, salvo que se sepa muy bien lo que se pretende obtener con los perfiles de las estrellas.

Por cierto, el nombre del script quizás no sea el más adecuado podría ser MaskedStretchTransform o algo así

Salu2,

[Jordi Gallego]

Hola David, muchas gracias por el esfuerzo (me siento un poco culpable :oops: ).

Prometo probarlo en cuanto tenga un momento, con una imagen de NGC6888 que tengo entre manos :wink:

Muchos saludos
Jordi

[Carlos Milovic]

A ver si te puedo dar una mano con eso... Lo de usar las estadisticas globales para automatizar las transformaciones de histograma es relativamente sencillo, siempre y cuando se hacen algunas presunciones: 1) el cielo de fondo es el objeto dominante, o, 2)por lo menos, se puede identificar con la mediana de la imagen (tambien se podria entrar a calcular la moda del histograma...). Luego, la idea es que al final del proceso dicho valor este en cierto rango, ojala neutralizado (es decir, color gris neutro, o con un tono que el usuario pueda determinar). Mirate bien el proceso AutoHistogram que yo hice, pues alli precisamente hago eso. La unica diferencia esta en que yo utilizo una funcion gama en vez de una MTF para la transformacion de tonos medios. La razon es que con la funcion gama puedo predecir teoricamente de manera muy facil cual sera el nuevo valor de la mediana, para cualquier ajuste, y por lo tanto encontrar el ajuste necesario para que la mediana quede en el valor que yo quiero. Con la MTF es bastante mas complicado, pero, dado que estaras usando un esquema iterativo, puedes ir avanzando de a poco, e ir comprobando. Todo se basa en la idea de que el valor de la mediana es invariante ante funciones biyectivas (como la MTF y la gama).

Entonces, mi sugerencia es tomar un valor arbitrario para la MTF, y un valor definido para el usuario para la mediana final. Calculas el valor de la mediana. Si te pasas (valor mas alto), acercas la MTF mas a 0.5 (a la mitad de distancia que antes), y repites el calculo. Si esta por debajo del valor ideal, lo aplicas a la imagen (en caso contrario, sigue buscando hasta cierto criterio de convergencia, claro). Y sigues haciendo este procedimiento, recalculando medianas si es necesario (recuerda que estas enmascarando... osea la mediana no es invariante completamente, aunque te dara muy cercano... de hecho, podrias probar usando solamente el valor de la mediana inicial para los calculos en una primera version), hasta que se alcance el criterio de convergencia que te comentaba antes.

[Carlos Milovic]

Por cierto, para lo de desenfocar la mascara, simplemente podrias eliminar capas de wavelets... aunque creo que las convoluciones estan definidas de manera bastante amigable en el JS. De todas maneras, preocupate de esto despues, cuando todo el resto funcione ;)

[GABRI 9555]

hola,he intentado probarlo pero me da un mensaje de error : *** Error: C:/Users/gabri/Documents/NewScriptFile2.scp, line 34: Unrecognized command: var
, he intentado distintos valores en mt y nada me da el mismo mensaje de error.

[David Serrano]

El script funciona, pero hace todo lo contrario: quema las estrellas y protege el fondo del cielo ¿Has invertido los valores de la máscara?

:^D Mira que soy capullo... ya me parecía a mí que esa imagen de prueba no me acababa de convencer... moraleja: probar siempre con imágenes astronómicas. Menos mal que puse "preliminar" en el asunto!

Code: [Select]

new RGBWorkingSpace;
[...]
new ChannelExtraction;

Yo usé el método .extractLuminance que ya tienen los objetos Image. En principio quería hacerlo con un proceso externo pero para no comerme el tarro obteniendo el nuevo ID de la imagen resultante, decidí crear yo la imagen a mano con un ID predeterminado y almacenar en ella el resultado de .extractLuminance.

Tu explicación concuerda con lo que he implementado en el código, así que debe de estar bien, excepto por el detalle de invertir la máscara, por supuesto. Para eso, basta con añadir la línea:

Code: [Select]

  aw.maskInverted = true;

antes de la línea 73 (que en el script original es "aw.mask = luma_w;"). El resultado sería:

Code: [Select]

  //luma_w.show();
   aw.maskVisible = false;
   aw.maskInverted = true;
   aw.mask = luma_w;

decidir el número de iteraciones dependiendo de la función de transferencia de medios tonos solo puede hacerse a base de prueba y error hasta obtener el valor de brillo deseado

Discrepo. Si le pedimos al usuario el valor de medios tonos, y el brillo final deseado (por ejemplo, preguntándole por la mediana deseada), el script haría un bucle infinito máscara-histograma-mediana hasta que viera que la mediana se pasa de rosca, en ese momento se cortaría el bucle.

El problema viene si preguntamos al usuario el número de iteraciones y la mediana deseada. Esto me parece más amistoso puesto que el usuario sabrá más o menos lo que el proceso va a tardar pero la pega es que aquí sí que es difícil calcular el valor de medios tonos necesario para alcanzar ese valor "destino" de mediana con el número de iteraciones dado. Excepto que exista alguna fórmula mágica en plan de "un valor de transferencia de medios tonos de 0.45 siempre incrementará la mediana de la imagen en un 10%". Si hubiera algo así, que lo dudo, el cálculo del valor no debería ser muy complicado.

Por cierto, el nombre del script quizás no sea el más adecuado podría ser MaskedStretchTransform o algo así

La verdad es que me convence más que el actual . La siguiente versión tendrá el nombre nuevo pero será 0.2 de todas formas.

[David Serrano]

Hola David, muchas gracias por el esfuerzo (me siento un poco culpable :oops: ).

Culpable en absoluto! En tal caso orgulloso puesto que esto contribuye a PixInsight . Pero antes de probarlo echa un ojo al mensaje mío que acabo de poner, puesto que olvidé invertir la máscara y el programa arruina las imágenes .

Y ahora voy a digerir ese mensaje tan grandote de C. Milovic que acabo de ver...

[Carlos Milovic]

David, lo que puedes hacer es trabajar directamente sobre el valor de la mediana, una variable double ;), y calcular asi el numero de iteraciones requeridas. Tambien puedes ajustar ahi, de forma interna, los valores de las mtf. Recuerda el usar un parametro de convergencia, tanto para la mtf necesaria, como para la mediana obtenida.

[C. Sonnenstein]

Hola Gabri:

Para hacerlo funcionar (en estos momentos el script quema las luces y mantiene prácticamente los valores de fondo) has de cargar la imagen y luego ir a ScriptEditor (Ctrl+Alt+E). A continuación seleccionas File> New> Plain Text File (.txt), pegas todo el código del script y pulsas F9 (menú Execute> Compile & Run).

Salu2,

[GABRI 9555]

si , si es lo que hago , incluso he reinstalado PI pero nada , me da el mismo mensaje de error.

[Juan Conejero]

Hola

Disculpad que no pueda dedicar más tiempo a esto, lo cual me encantaría como os podéis suponer, porque es realmente interesante y divertido.

Ahora estoy enfrascado con el sistema de autenticación de módulos que va a llevar la nueva versión que publicaré mañana... es endemoniadamente complejo. Por cierto, la de mañana va a ser, salvo retoques mínimos y con el permiso de los bug busters, la versión final

Gabri: tienes que seleccionar "File > New > JavaScript Source File (.js)" en Script Editor. De esta forma el script tendrá la extensión .js y funcionará.

Al resto. Os pongo algo que quizá pueda ser de ayuda. Se trata de una rutina que localiza el valor del balance de medios tonos requerido para que un valor de píxel v0 cualquiera se transforme en otro v1. El algoritmo es básicamente una búsqueda binaria, con lo que las prestaciones son muy altas. Esta rutina forma parte del código interno de PCL. Aquí va la versión en C++ directamente tomada de un archivo fuente de PCL (hmmm, estoy contando algunos secretos aquí, de hecho ):

Code: [Select]

#define TINY   1.0e-40

double HistogramTransform::MidtonesTransferFunction( double m, double x )
{
   if ( x == m )
      return 0.5;

   double xa[ 4 ] = { 0, 0.0, m, 1.0 };
   double c[ 4 ] = { 0, 0.0, 0.5, 1.0 };
   double d[ 4 ] = { 0, 0.0+TINY, 0.5+TINY, 1.0+TINY };

   int ns;
   double y;

   if ( x < 0.25 )
   {
      if ( x == 0 )
         return 0;
      ns = 0;
      y = 0;
   }
   else if ( x <= 0.75 )
   {
      ns = 1;
      y = 0.5;
   }
   else
   {
      if ( x == 1 )
         return 1;
      ns = 2;
      y = 1;
   }

   for ( int m = 1; m < 3; ++m )
   {
      for ( int i = 1; i <= 3-m; ++i )
      {
         double ci1 = c[i+1], di = d[i];
         double t = (xa[i] - x)*di/(xa[i+m] - x);
         double dd = (ci1 - di)/(t - ci1);
         d[i] = ci1*dd;
         c[i] = t*dd;
      }

      y += ((ns << 1) < (3-m)) ? c[ns+1] : d[ns--];
   }

   return y;
}

double HistogramTransform::FindMidtonesBalance( double v0, double v1, double eps )
{
   eps = Max( 1.0e-15, eps );

   double m0, m1;

   if ( v1 < v0 )
   {
      m0 = 0;
      m1 = 0.5;
   }
   else
   {
      m0 = 0.5;
      m1 = 1;
   }

   for ( ;; )
   {
      double m = 0.5*(m0 + m1);
      double v = MidtonesTransferFunction( m, v1 );

      if ( Abs( v - v0 ) < eps )
         return m;

      if ( v < v0 )
         m1 = m;
      else
         m0 = m;
   }
}

y esto sería un traducción a JavaScript *** ojo *** la traduzco al vuelo; no la he probado:

Code: [Select]

#define TINY   1.0e-40

function MidtonesTransferFunction( m, x )
{
   if ( x == m )
      return 0.5;

   var xa = [ 0, 0.0, m, 1.0 ];
   var c = [ 0, 0.0, 0.5, 1.0 ];
   var d = [ 0, 0.0+TINY, 0.5+TINY, 1.0+TINY ];

   var ns, y;

   if ( x < 0.25 )
   {
      if ( x == 0 )
         return 0;
      ns = 0;
      y = 0;
   }
   else if ( x <= 0.75 )
   {
      ns = 1;
      y = 0.5;
   }
   else
   {
      if ( x == 1 )
         return 1;
      ns = 2;
      y = 1;
   }

   for ( var m = 1; m < 3; ++m )
   {
      for ( var i = 1; i <= 3-m; ++i )
      {
         var ci1 = c[i+1], di = d[i];
         var t = (xa[i] - x)*di/(xa[i+m] - x);
         var dd = (ci1 - di)/(t - ci1);
         d[i] = ci1*dd;
         c[i] = t*dd;
      }

      y += ((ns << 1) < (3-m)) ? c[ns+1] : d[ns--];
   }

   return y;
}

function FindMidtonesBalance( v0, v1, eps )
{
   eps = Math.max( 1.0e-15, eps );

   var m0, m1;

   if ( v1 < v0 )
   {
      m0 = 0;
      m1 = 0.5;
   }
   else
   {
      m0 = 0.5;
      m1 = 1;
   }

   for ( ;; )
   {
      var m = 0.5*(m0 + m1);
      var v = MidtonesTransferFunction( m, v1 );

      if ( Math.abs( v - v0 ) < eps )
         return m;

      if ( v < v0 )
         m1 = m;
      else
         m0 = m;
   }
}

Obviamente, tengo que añadir esta función MidtonesTransferFunction al runtime JS de PI. Lo haré en breve.

[C. Sonnenstein]

Al resto. Os pongo algo que quizá pueda ser de ayuda. Se trata de una rutina que localiza el valor del balance de medios tonos requerido para que un valor de píxel v0 cualquiera se transforme en otro v1. El algoritmo es básicamente una búsqueda binaria, con lo que las prestaciones son muy altas.

Interesante, muchas gracias

[David Serrano]

Vaya, se ha juntado aquí casi toda la élite del PTeam .

Entonces, mi sugerencia es tomar un valor arbitrario para la MTF, y un valor definido para el usuario para la mediana final. Calculas el valor de la mediana. Si te pasas (valor mas alto), acercas la MTF mas a 0.5 (a la mitad de distancia que antes), y repites el calculo. Si esta por debajo del valor ideal, lo aplicas a la imagen

Creo que es más o menos lo que pienso yo. Estoy definiendo el algoritmo más o menos en esta dirección:

 - Pedir al usuario número de iteraciones (N) y mediana objetivo.
 - Partir de un valor arbitrario de MTF, tal como dices.
 - Aplicar la MTF al valor de la mediana actual N veces.
 - Ver la mediana alcanzada y modificar la MTF consecuentemente, volviendo al paso anterior hasta que la diferencia sea despreciable.
 - Aplicar finalmente el histograma a la imagen N veces usando el valor de medios tonos "calculado".
 - Por último, aplicar a la imagen final (Edito: este paso está repetido, es el mismo que el anterior).

El problema de esto es, tal como anticipas, que el valor se ha averiguado sin máscaras. Así que ya voy pensando en otra cosa...

 - Pedir al usuario número de iteraciones (N) y mediana objetivo.
 - Crear una imagen nueva consistente en un recorte pequeño de la imagen original, tal que la mediana del recorte y la de la imagen original sean bastante parecidas. Dado que el usuario va a aplicar un histograma, podemos asumir que el fondo está neutralizado y por tanto probar un recorte en cualquier esquina.
 - Escoger un valor inicial de MTF arbitrario.
 - Con esta imagen, aplicar el procedimiento entero, con máscaras y todo, las N veces necesarias. Dado que la imagen no hay que mostrarla en pantalla (de la misma forma que el script actual no muestra las máscaras que se van generando), es transparente al usuario. Y como el recorte es pequeño, se hace en un pispás.
 - Evaluar la mediana, descartar la imagen pequeña y alterar la MTF en función del resultado obtenido. Volver a crear la imagen y repetir desde el paso anterior hasta que la diferencia de medianas sea despreciable.
 - Finalmente, aplicar a la imagen grande.

Lo que sí tengo claro es que el número de iteraciones vendrá definido por el usuario. Así el usuario no sólo controla el tiempo de ejecución (como ya dije en otro mensaje) sino también la calidad del resultado.

Ahora estoy enfrascado con el sistema de autenticación de módulos que va a llevar la nueva versión que publicaré mañana...

Jeje, ya hace al menos un par de versiones que parte de este código ya anda por ahí verdad? . Si te sirve de algo (que a estas alturas no creo), los del núcleo de Linux están metiendo PGP.

Con respecto a bugs, tengo uno de Statistics en el horno, me quiero asegurar bien. Creo que no lo pondré en la sección de bugs; total, siempre se puede mover después si resulta que tal.

Obviamente, tengo que añadir esta función MidtonesTransferFunction al runtime JS de PI. Lo haré en breve.

Y ya que está implementada como parte de la PCL, y obviamente funciona, ¿por qué no hacerla accesible mediante, por ejemplo, Math.mtf()? Ese fue el segundo sitio donde fui a buscarla, siendo el primero el objeto Image. Y como es cálculo puro, por muy búsqueda binaria que sea, siempre es mejor que se ejecute en código compilado, no? Y te ahorras la traducción a JS y el hacer un script de ejemplo que demuestre cómo se usa.

Y eso de publicar funcioncitas internas... de aquí a la GPL hay un paso!

[Carlos Milovic]

Creo que te sera mas facil asumir que la mediana es invariante con la mascara... es decir, que un pixel con dicho valor sigue siendo la mediana despues (aunque no sea exacto).

Entonces, lo que yo haria es (pseudo codigo):

Code: [Select]


float medianOrig = img.Median();
float medianTemp;
float medianFinal; // definido por el usuario

float convergencia = 1e-6;
int iters; //definida por el usuario

float mtf = 0.25; //primera aproximacion, arbitraria

do // esta es la busqueda binaria
{
  medianTemp = medianOrig;
  for (int i = 0; i < iters; i++)
  {
    float temp = MTF( medianTemp, mtf );
    medianTemp = temp*(1-medianTemp)+medianTemp*medianTemp;
  }

  if ( Abs(medianTemp-medianFinal) > convergencia )
  {
    if ( medianTemp > medianFinal )
       AgrandarMTFBinariamente( mtf );
    else
       AchicarMTFBinariamente( mtf );
  }
} while ( Abs(medianTemp-medianFinal) > convergencia )


Fijate que estoy emulando el accionar de la mascara, asumiendo que para la mediana, tiene el mismo valor que la mediana (no siempre es exacto, pero funcionara bien).
Este codigo te daria como resultado el valor de la mtf a utilizar.

Y eso... :)

Me pondre a terminar un codigo que tengo pendiente de enviar a Juan, y me pongo a hacer un mini tutorial para escribir "Hola Mundo", tal como yo lo entiendo :) Que conste que me considero bastante novato en la programacion, asi que puede que me equivoque en conceptos, asi que no te lo tomes como la verdad hasta que Juan lo corrija. Simplemente subire un rar con el codigo, comentado en espagnol adentro, por mientras.