Clases

bicotiHistogramEqualizator

     Templates Clases

CoordType
ColorType
PixelType

class bicotiHistogramEqualizator < class CoordType, class ColorType,
                                                                            class PixelType = ColorType >

bicotiHistogramEqualizator(  bicotiPropertyHistogramExtended< CoordType, ColorType, PixelType > *,
                                                                                     const vector< bicotiPixelOperatorUnary< ColorType > * >& )
void operator( ) ( )

    Constructor, los parámetros que le paso son :
           -- Un puntero a una PropertyHistogram, que es la que se equaliza.
           -- Un vector de punteros a PixelOperatorUnary , cada uno de ellos se aplicará a cada uno de los
               Dexels de la propiedad.

    Es decir si por ejemplo la PropertyHistogram tiene 3 DexelHistogram, el vector debe contener 3 punteros a operadores, cada uno asociado a un dexel. Si las cantidades no coinciden, el constructor tirará una exepción.

Por ejemplo ,si quiero equalizar un histograma de una imagen 2D de enteros, la propiedad tendrá un solo Dexel, en este caso el vector debe tener un solo operador.

        CoordType = bicotiCoordinate2D< INTEGER >
        ColorType = int
        PixelType = int

Primero creo el operador, por ejemplo para equalización uniforme.

        typedef bicotiCoordinate2D< REAL > CooT;
        typedef int ColT;
        typedef int PixT;

        bicotiPixelOperatorUnary< ColT > * ptr_op;
        ptr_op = new  bicotiPixelOperatorUnaryUniform< ColT >;

Ahora creo el vector, con un solo operador :

        vector< bicotiPixelOperatorUnary< ColT > * > vect(1);
        vect[0] = ptr_op;

Ahora puedo crear el equalizador, suponiendo que tengo un puntero a la propiedad :

        bicotiHistogramEqualizator< CooT , ColT >  equ( ptr_prop_hist , vect )

En este caso no es necesario especificar el tercer template, se toma por defecto.
 

Pero si quiero uniformizar el histograma de una imagen 2D a colores ( RGB de enteros por ejemplo ), la Property tendrá tres Dexels, uno para cada color.
En este caso :
        CoordType = bicotiCoordinate2D< INTEGER >
        ColorType = int
        PixelType = bicotiRGB< int >

Primero creo el operador :

        typedef bicotiCoordinate2D< REAL > CooT;
        typedef int ColT;
        typedef bicotiRGB< int > PixT;

        bicotiPixelOperatorUnary< ColT > * ptr_op;
        ptr_op = new  bicotiPixelOperatorUnaryUniform< ColT >;

Ahora creo el vector, con 3 operadores, los mismos en este caso :

        vector< bicotiPixelOperatorUnary< ColT > * > vect(3);
        vect[0] = ptr_op;
        vect[1] = ptr_op;
        vect[2] = ptr_op;

Podría haber tomado arbitrariamente un operador distinto para cada campo.
Ahora puedo crear el equalizador :

        bicotiHistogramEqualizator< CooT , ColT , PixT  >  equ( ptr_prop_hist , vect )
 

    Esta función hace correr la equalización.
    Se recorre cada uno de los Dexels, se le aplica el operador correspondiente a cada nodo de la lista ( donde hay un valor de atributo determinado ) por lo que el DexelHistogram quedará con valores nuevos. Luego se actualiza la implementación para que se reflejen los cambios.

Cuando se equaliza el histograma, los cambios se reflejan automáticamente en la imagen.