class bicotiPixelVectorialDynamic< class ColorType,
                                                               class PrecisionType = ColorType >

bicotiPixelVectorialDynamic ( int  = 0  )
~bicotiPixelVectorialDynamic ( )
bicotiPixelVectorialDynamic (  const  bicotiPixelVectorialDynamic<ColorType,PrecisionType> &  )

ColorType&  operator( ) (  int  )
unsigned GetColorsNumbers ( )

void  operator = (  const bicotiPixelVectorialDynamic <ColorType,PrecisionType> &  )
bool  operator == (  const bicotiPixelVectorialDynamic<ColorType,PrecisionType> &  )

bicotiPixelVectorialDynamic<ColorType,PrecisionType>operator + (  double  )
bicotiPixelVectorialDynamic<ColorType,PrecisionType>operator - (  double  )
bicotiPixelVectorialDynamic<ColorType,PrecisionType>operator * (  double  )
bicotiPixelVectorialDynamic<ColorType,PrecisonType>operator / (  double  )

void operator += (  double  )
void operator -= (  double  )
void operator *= (  double  )
void operator /= (  double  )

bicotiPixelVectorialDynamic<ColorType,PrecisionType>
                                    operator + ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )
bicotiPixelVectorialDynamic<ColorType,PrecisionType>
                                    operator - ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )
bicotiPixelVectorialDynamic<ColorType,PrecisionType>
                                    operator * ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )
bicotiPixelVectorialDynamic<ColorType,PrecisionType>
                                    operator / ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )

void operator += ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )
void operator -= ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )
void operator *= ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )
void operator /= ( const bicotiPixelVectorialDynamic<ColorType,PrecisionType> & )

operator bicotiPixelVectorialDynamic< PrecisionType, ColorType >( )

        Es el constructor de la clase, se pasa como parámetro, la cantidad de "colores" del pixel a construir,
        por defecto, se crea un pixel con cantidad de colores igual a cero.

        Es el destructor de la clase.

        Constructor de copia.

         Este operador es la intefaz standard para acceder a las campos de los pixels.
         Todas los pixels vectorial deben tener este operador definido.
         Es bidireccional, por lo que podemos a través de el , leer o setear la componente de índice
         indicado por la variable index.
         Por ejemplo :

                    componete = my_pixel ( 2 )

         Me devuelve la tercer componente del pixel.

                    my_pixel ( 0 ) = 4

         Pone 4 en la primer componente de my_pixel.
         Es importante destacar que los índices van de 0 a colors_numbers - 1.
         La operación controla que el índice este dentro de rango si se han habilitado los chequeos, ver
         "Macros de Chequeo" para más información.

            Esta función devuelve la cantidad de "colores" del pixel. También
            es parte de la interfáz standard por lo tanto todos los pixels vectorial deben definirla.

            El operador de asignación , simplemente crea una copia, sin construir un nuevo objeto. Hay que
            tener cuidado con este operador, si se tiene un pixel bicotiPixelVectorialDynamic, con
            colors_number = 3 y se lo iguala a otro pixel bicotiPixelVectorialDynamic, con
            colors_number = 0; se redimensiona y se copia. Para clarificar, veamos el siguiente ejemplo.
 

                        bicotiPixelVectorDynamic<int> pixel_a( 3);
                            pixel_a( 0 ) = 4;
                        pixel_a( 1 ) = 5;
                        pixel_a( 2 ) = 6;

                        bicotiPixelVectorDynamic<int> pixel_b( 1);
                       pixel_b( 0 ) = 35;

    Hasta aqui:

                            pixel_a = ( 4, 5, 6)
                       pixel_a.GetColorsNumber( ) = 3
                       pixel_b = ( 35 )
                       pixel_b.GetColorsNumber( ) = 1

                       pixel_b = pixel_a;

   Obtengo ahora:

                            pixel_a = ( 4, 5, 6)
                       pixel_a.GetColorsNumber( ) = 3
                       pixel_b = ( 4, 5, 6 )
                       pixel_b.GetColorsNumber( ) = 3
 

             El pixel pixel_b resulta una copia exacta de pixel_a.

             Es importante aclarar que este operador solo funciona entre pixels del mismo tipo.
            NO PUEDO HACER :

                        bicotiRGB<int> pixel_a( 3,3,3 );
                        bicotiPixelVectorialDynamic<int> pixel_b;

                        pixel_b = pixel_a;

            Operador de comparación . Devuelve true cuando ambos pixel poseen la misma cantidad de
            "colores", y los valores en los campos, son iguales uno a uno.

            Este operador le suma un doble a cada uno de los campos y devuelve un nuevopixel.
            Por ejemplo si fuera  pixel_a = ( 1,  3 , -2 )
            y hago :

                        pixel_b = pixel_a + 3;

            Obtengo  pixel_b = ( 4 , 6 , 1 )

            Este operador le resta un doble a cada uno de los campos y devuelve un nuevo pixel. Similar al
            operator +.

            Este operador multiplica por un doble a cada uno de los campos y devuelve un nuevo pixel.
            Por ejemplo si fuera  pixel_a = ( 1,  0 , -1 )
            y hago :

                        pixel_b = pixel_a * 2;

            Obtengo  pixel_b = ( 2 , 0 , -2 )

            Este operador divide por un doble a cada uno de los campos y devuelve un nuevo pixel.
            Similar al operator *.
           NO se controla de división por 0 ( cero ). Las consecuencias de hacerlo dependerán de lo que
            haga el sistema operativos para los tipos básicos. Es aconsejable que el usuario contemple
            externamente esta posibilidad.

            Este operador le suma un doble a cada uno de los campos y devuelve los resultados
            en el mismo pixel.
            Por ejemplo si fuera  pixel = ( 1,  -1, 1 )
            y hago :

                        pixel += 2;

            Obtengo  pixel = ( 3 , 1, 3 )

            Este operador le resta un doble a cada uno de los campos y devuelve los resultados
            en el mismo pixel. Similar al operator +=.

            Este operador multiplica por un doble a cada uno de los campos y devuelve los resultados
            en el mismo pixel.
            Por ejemplo si fuera  pixel = ( 2,  -1,  0 )
            y hago :

                        pixel *= -1;

            Obtengo  pixel = ( -2 , 1 , 0 )

            Este tipo de operadores tiene una utilidad interesante para setearle fácilmente valores a todas
            las componentes.
            Por ejemplo si quiero obtener el pixel "0" ( ceros en todos los campos )
            Puedo hacer:

                       pixel *= 0;

            Independientemente de la cantidad de "colores" y del contenido previo de pixel.
            Si quiero poner unos en todos los campos puedo hacer:

                       pixel *= 0;
                       pixel += 1;

      Este operador divide por un doble a cada uno de los campos y devuelve los resultados
     en el mismo pixel. Similar al operator *=.

            Suma campo a campo de pixels. Por ejemplo :

                               bicotiPixelVectorialDynamic<unsigned char> pixel_a( 1, 2, 3);
                                bicotiPixelVectorialDynamic<unsigned char> pixel_b( 2, 2, 2);
                                pixelito = pixel_a + pixel_b;

            Se obtiene en pixel_a = ( 3, 4, 5);

              Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
            caso de no ser asi se produce una excepción, que probablemente aborte el programa.

           Este operador realiza la resta campo a campo entre pixels bicotiRGB, similar al operator+.

           Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
           caso de no ser asi se produce una excepción, que probablemente aborte el programa.

            Este operador realiza el producto campo a campo entre pixels bicotiPixelVectorialDynamic.
            Por ejemplo:

                               bicotiPixelVectorialDynamic<unsigned char> pixel_a( 1, 2, 3);
                                bicotiPixelVectorialDynamic<unsigned char> pixel_b( 2, 2, 2);
                                pixel_a = pixel_a * pixel_b;

            Se obtiene en pixel_a = ( 2, 4, 6);

              Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
            caso de no ser asi se produce una excepción, que probablemente aborte el programa.

            Este operador realiza la división campo a campo entre pixels bicotiRGB, similar al operator*.
           NO se controla de división por 0 ( cero ). Las consecuencias de hacerlo dependerán de lo que
            haga el sistema operativos para los tipos básicos. Es aconsejable que el usuario contemple
            externamente esta posibilidad.

              Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
            caso de no ser asi se produce una excepción, que probablemente aborte el programa.

             Sobrecarga del operador +=, ejemplo:

                                       bicotiPixelVectorialDynamic<unsigned char> pixel_a( 1, 2, 3);
                                bicotiPixelVectorialDynamic<unsigned char> pixel_b( 2, 2, 2);

                                pixel_a = pixel_a + pixel_b;

                                             ó puedo hacer

                               pixel_a += pixel_b;

            Se obtiene en pixel_a = ( 3, 4, 5);

            Este operador normalmente ayuda en claridad en el código y el loops importantes para hacer una
            suma, se llama a una función ( operator+= ) y no a dos ( operator+ y operator= ).

            Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
            caso de no ser asi se produce una excepción, que probablemente aborte el programa.

            Similar a el operator +=, solo que en ves de sumar se realiza la resta.

              Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
            caso de no ser asi se produce una excepción, que probablemente aborte el programa.

            Sobrecarga del operador *=, ejemplo:

                                       bicotiPixelVectorialDynamic<unsigned char> pixel_a( 1, 2, 3);
                                bicotiPixelVectorialDynamic<unsigned char> pixel_b( 2, 2, 2);

                                pixel_a = pixel_a * pixel_b;

                                             ó puedo hacer

                               pixel_a *= pixel_b;

            Se obtiene en pixel_a = ( 2, 4, 6);

            Este operador normalmente ayuda en claridad en el código y el loops importantes para hacer una
            suma, se llama a una función ( operator*= ) y no a dos ( operator* y operator= ).

              Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
            caso de no ser asi se produce una excepción, que probablemente aborte el programa.

            Similar a el operator +=, solo que en ves de sumar se realiza la división.
            NO se controla de división por 0 ( cero ). Las consecuencias de hacerlo dependerán de lo que
            haga el sistema operativos para los tipos básicos. Es aconsejable que el usuario contemple
            externamente esta posibilidad.

              Es importante darse cuenta que ambos pixels deben tener la misma cantidad de "colores", en
            caso de no ser asi se produce una excepción, que probablemente aborte el programa.

            Operador de casting a un tipo de mejor precision. Creemos que se entendera mejor su utilidad
            con un ejemplo:

            Supongamos que queremos hacer un promedio de 3 pixels
            bicotiPixelVectorialDynamic<unsigned char> ( notar que con el default template, el
            PrecisionType = unsigned char) y que los tres pixels poseen tres "colores".

                                     bicotiPixelVectorialDynamic<unsigned char> pixel_1( 3 );
                                              pixel_1( 0 ) = 120;
                                     pixel_1( 1 ) = 25;
                                     pixel_1( 2 ) = 231;

                                     bicotiPixelVectorialDynamic<unsigned char> pixel_2( 3 );
                                             pixel_2( 0 ) = 20;
                                     pixel_2( 1 ) = 200;
                                     pixel_2( 2 ) = 213;

                                     bicotiPixelVectorialDynamic<unsigned char> pixel_3( 3 );
                                              pixel_3( 0 ) = 145;
                                     pixel_3( 1 ) = 12;
                                     pixel_3( 1 ) = 198;

                                    bicotiPixelVectorialDynamic<unsigned char> suma( 3 );
                                             suma *=  0;

             Uno se vería tentado a hacer:

                                    suma += pixel_1;
                                    suma += pixel_2;
                                    suma += pixel_3;

                                    suma /=3;

            Para su asombro obtendría que suma = ( 9, 79, 43).
            El problema esta en que las operaciones cn unsigned char son en módulo 256.
            Para hacer el promedio, sin estos problemas y sin que tener que siempre usar tipos mas costosos
            en términos de espacio de memoria, se usa el casting.

                                    bicotiPixelVectorialDynamic<unsigned char,float> pixel_1( 3 );
                                              pixel_1( 0 ) = 120;
                                     pixel_1( 1 ) = 25;
                                     pixel_1( 2 ) = 231;

                                     bicotiPixelVectorialDynamic<unsigned char,float> pixel_2( 3 );
                                             pixel_2( 0 ) = 20;
                                     pixel_2( 1 ) = 200;
                                     pixel_2( 2 ) = 213;

                                     bicotiPixelVectorialDynamic<unsigned char,float> pixel_3( 3 );
                                              pixel_3( 0 ) = 145;
                                     pixel_3( 1 ) = 12;
                                     pixel_3( 2 ) = 198;

                                    bicotiPixelVectorialDynamic<float,unsigned char> suma( 3 );
                                             suma *=  0;

                                   bicotiPixelVectorialDynamic< unsigned char, float> promedio( 3 );

                                     suma += (bicotiPixelVectorialDynamic<float, unsigned char>)pixel_1;
                                      suma += (bicotiPixelVectorialDynamic<float, unsigned char>)pixel_2;
                                      suma += (bicotiPixelVectorialDynamic<float, unsigned char>)pixel_3;

                                      suma /=3;
                                               promedio = (bicotiPixelVectorialDynamic<unsigned char, float>)suma;

               Obtenemos promedio = ( 95, 79, 214).

             Los castings se pueden evitar en este caso ya que los Compiladores habitualmente, si no
             encuentran un "macheo" exacto de argumetos para una función, promueven mediante el
             casting y  llaman a la función. Por claridad aqui los hicimos aparecer
             implícitamente, aunque existe otra razón para haberlo hecho. Esta es, que para tipos nativos del
             lenguaje, los castings automáticos a tipos "mas amplios" estan bien definidos, pero a tipos "mas
             chicos" produce perdida de información y un Warning del Compilador. Si se pretende entender
             bien este problema dirigirse a :

• Neighbours Filters
• ImagePixelInterpolator