Figura 2.3.1

     Clases

bicotiProperty
bicotiPropertyStatistical
bicotiPropertyHistogram
bicotiPropertyHistogramUsual
bicotiPropertyHistogramExtended

     Templates Clases

PixelType

class bicotiPropertyStatistical < class CoordType, class ColorType,
                                         class PixelType = ColorType , class PrecisionType >

bicotiPropertyStatistical ( bicotiImageImplementation< PixelType > * ,
                               const vector< bicotiPixelAttributeSelector< ColorType, PixelType > * >& color_sel_list )
~bicotiPropertyStatistical ( )

void UpdateImageImplementation ( )
  ColorType& MaximumValue( unsigned = 0 )
  ColorType& MinimumValue( unsigned = 0 )
  PixelType MeanValue( )
 

    Constructor al que paso como parámetro :
        ptr_ima -- puntero a la imagen a la que se refiere la propiedad.
        color_sel_list -- vector ( de la STL ) con punteros a selectores de atributos.

La propiedad tiene un lista de DexelStatistical cada uno de los cuales se construye con uno de los atributos del vector, por lo tanto tendrá tantos Dexels asociados como selectores de atributo le pase en el vector.

Figura 2.3.2

Por ejemplo si queremos crear una propiedad estadística para una imagen 2D RGB de entereos.
Los templates son:
                    CoordType = bicotiCoordinate2D< INTEGER >
                    ColorType = int
                    PixelType = bicotiRGB< int >
                     PrecisionType = bicotiRGB< double >

El último template es la precisión con la que se hacen las cuentas para clacular por ejemplo el valor medio.
Si tomo un RGB de enteros me daría cualquier cosa.

Primero definimos unos tipos , "para escribir menos".

typedef  bicotiCoordinate2D<INTEGER> CooT ; // coordenada
typedef  int  ColT;                                                // atributo
typedef  bicotiRGB< int > PixT;                       // pixel
typedef  bicotiRGB< double > PreT;                 // precision

Creamos un selector de atributos para cada campo:

    bicotiPixelAttributeSelector< ColT, PixT > * ptr_att_sel_red;
    ptr_att_sel_red = new bicotiPixelAttributeSelectorColorRed< ColT, PixT >;

    bicotiPixelAttributeSelector< ColT, PixT > * ptr_att_sel_green;
    ptr_att_sel_green = new bicotiPixelAttributeSelectorColorGreen< ColT, PixT >;

    bicotiPixelAttributeSelector< ColT , PixT > * ptr_att_sel_blue;
    ptr_att_sel_blue = new bicotiPixelAttributeSelectorColorBlue< ColT, PixT >;

Los Pongo en un vector :

    vector <bicotiPixelAttributeSelector< ColT, PixT > * >  vect( 3 );
    vect[0]=ptr_att_sel_red; // el rojo tiene índice 0
    vect[1]=ptr_att_sel_green; // el verde tiene índice 1
    vect[2]=ptr_att_sel_blue; // el azul tiene índice 2

Ahora puedo crear la propiedad

    bicotiPropertyStatistical< CooT, ColT, PixT, PreT >  prop( ptr_ima, vect );
 

        Destructor.

    Esta función sirve para actualizar a la imagen una vez que se han hecho cambios en las propiedades.
Los cambios en las propiedades NO se reflejan automáticamente en la imagen

    Devuelve el mámimo valor del atributo asociado al dexel de índice index.

Por ejemplo si tengo un atributo para cada color :

       vect = [ ptr_att_sel_red ,  ptr_att_sel_green , ptr_att_sel_blue ]

Puedo obtener el máximo de cada campo .

        max_red = prop.MaximumValue( 0 );
        max_green = prop.MaximumValue( 1 );
        max_blue = prop.MaximumValue( 2 );

Ver Maximum Value en bicotiDexelStatistical.

    Devuelve el mínimo valor del atributo asociado al dexel de índice index.

Por ejemplo si tengo un atributo para cada color :

       vect = [ ptr_att_sel_red ,  ptr_att_sel_green , ptr_att_sel_blue ]

Puedo obtener el mínimo de cada campo .

        min_red = prop.MinimumValue( 0 );
        min_green = prop.MinimumValue( 1 );
        min_blue = prop.MinimumValue( 2 );

Ver Minimum Value en bicotiDexelStatistical.

    Devuelve el valor medio del pixel de la imagen.
Si el pixel es básico, da el valor medio, pero si es vectorial, como el RGB, da un RGB con el valor medio de cada campo.