bicotiRGB (  constColorType = 0, constColorType = 0, const ColorType = 0  )
~bicotiRGB ( )
bicotiRGB (  const  bicotiRGB<ColorType,PrecisionType> &  )

ColorType&  operator( ) (  int  )
unsigned GetColorsNumber ( )

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

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

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

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

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

ColorType& Red( )
ColorType& Green( )
ColorType& Blue( )

operator bicotiRGB< PrecisionType, ColorType >( )

        Es el constructor de la clase, se pasa como parámetros los valores de los campos red, green y blue,
        en ese orden. En caso de no pasar parámetros, se toma por defecto cero en todos los campos.
        Es importante recordar que el tipo de los campos es un template de la clase.
        Por ejemplo, la linea de código :

               bicotiRGB < unsigned char > my_pixel;

        Crea una pixel RGB de char sin signo. Para más detalles ver Ejemplos.

        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, en nuestro caso, el campo blue.

                    my_pixel ( 0 ) = 4

         Pone 4 en la primer componente de my_pixel, en nuestro caso, el campo red pasa a ser igual a 4.

         Es importante destacar que los índices van de 0 a colors_number - 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.
            Para pixels bicotiRGB retorna 3. Esto de gran utilidad para
            algoritmos que trabajan con pixels vectoriales, sin importar la cantidad de "colores".

            El operador de asignación , simplemente crea una copia, sin construir un nuevo objeto.
            Es decir que puedo hacer algo como :

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

                        pixel_b = pixel_a;

             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 );
                        bicotiPixelVectorialStatic<int,3> pixel_b;

                        pixel_b = pixel_a;

            Operador de comparación . Devuelve true cuando los valores en los campos de los pixels 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 facilmente 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 :

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

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

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

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

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

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

            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.

             Sobrecarga del operador +=, ejemplo:

                                      bicotiRGB<unsigned char> pixel_a( 1, 2, 3);
                               bicotiRGB<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= ).

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

               Sobrecarga del operador *=, ejemplo:

                                      bicotiRGB<unsigned char> pixel_a( 1, 2, 3);
                               bicotiRGB<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= ).

            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.

              Función de acceso al campo red del pixel, es bidireccional, puedo leer y cargar un valor en este
             campo. Ejemplo :

                                                   bicotiRGB<unsigned char> pixel_c( 1, 2, 3);
                                          unsigned char red;
                                          red = pixel_c.Red();

          Obtengo red = 1.
                                          red = 25;
                                          pixel_c.Red( ) = red;

          Obtengo pixel_c = ( 25, 2, 3).

         Recordar que se puede acceder mediante la interfaz standar de pixels vectorial.

                              bicotiRGB<unsigned char> pixel_c( 1, 2, 3);
                                red = 25;
                                pixel_c( 0 ) = red;

         Obtengo pixel_c = ( 25, 2, 3).

               Similar a Red, solo que trabaja sobre el campo Green.

              Similar a Red, solo que trabaja sobre el campo Blue.

              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 bicotiRGB<unsigned char> ( notar
            que con el default template, el PrecisionType = unsigned char).

                                    bicotiRGB<unsigned char> pixel_1( 120, 25 , 231);
                                     bicotiRGB<unsigned char> pixel_2( 20, 200, 213);
                                     bicotiRGB<unsigned char> pixel_3( 145, 12, 198);

                                    bicotiRGB<unsigned char> suma( 0, 0, 0);

             Uno se veria 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 terminos de espacio de memoria, se usa el casting.

                                    bicotiRGB<unsigned char, float> pixel_1( 120, 25 , 231);
                                     bicotiRGB<unsigned char, float> pixel_2( 20, 200, 213);
                                     bicotiRGB<unsigned char, float> pixel_3( 145, 12, 198);

                                      bicotiRGB<float, unsigned char> suma( 0, 0, 0);
                                      bicotiRGB< unsigned char, float> promedio;

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

                                      suma /=3;
                                               promedio = (bicotiRGB<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