void  operator = (  const Pixel &  )
bool  operator == (  const Pixel &  )

  Pixel operator + (  double  )
  Pixel operator - (  double  )
  Pixel operator * (  double  )
  Pixel operator / (  double  )

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

  Pixel operator + ( const Pixel & )
  Pixel operator - ( const Pixel & )
  Pixel operator * ( const Pixel & )
  Pixel operator / ( const Pixel& )

void operator += ( const Pixel & )
void operator -= ( const Pixel & )
void operator *= ( const Pixel & )
void operator /= ( const Pixel & )

    Por particularidades de algunos algoritmos, tuvimos que hacer la distinción entre tres tipos de pixels,
    single, vectorial y unknow. En pixels singles, encontramos los tipos nativos del lenguaje; en vectorial
    se ubican los pixels RGB, VectorialStatic y VectorialDynamic; unknow se utiliza cuando no se
    especifica el pixel.

    En  los pixels vectorial, para independizarse de la cantidad de "campos", se agregan dos operadores de
    acceso standard.

Campo&  operator ( ) (  int  )
unsigned GetColorsNumber ( )

    Con GetColorsNumbers, se conoce la cantidad de campos M del pixel y con el operator( ), se accede
    a los campos de 0 . . . M-1.

    A modo de resumen los pixels poseen por lo menos dos argumentos de tipo, es decir las clases tiene al
menos un doble template, un argumento en el tipo de "dato" que se guarda en el array antes mencionado y otro en un tipo que solamente interviene en algoritmos de precisión númerica.
Se deja al usuario la responsabilidad de usar el tipo de precisión adecuado, se utiliza default template  en caso de que no se especifique este segundo tipo implicitamente, por defecto ambos tipo son iguales.
Para una discusión mas detallada sobre los argumentos template ir a Criterios de Diseño.
 

Para mayor claridad, haremos un ejemplo concreto:

                                                        bicotiRGB< unsigned char, float > pixel_a;
                                                        unsigned dim;
                                                        dim = pixel_a.GetColorsNumbers(); Retorna dim = 3
                                                        unsigned char  red, green, blue;
                                                        red = pixel_a(0);
                                                        green = pixel_a(1);
                                                        blue = pixel_a(2);

Existe otro operador mas a sobrecargar, es el siguiente,

operator PixelPrecision( )

Realiza el casting adecuado al tipo de precisión, por ejemplo.

                                            bicotiRGB< unsigned char, float > pixel_uchar;
                                            bicotiRGB< float, unsigned char > pixel_float;
                                            pixel_float = ( bicotiRGB< float, unsigned char> ) pixel_uchar;

En este caso PixelPrecision es float. El primer argumento es sobre el cual se trabaja, el segundo se utiliza solamente para cuando se desea calculos con precisión.
          
Observacion Importantes :

• Estos operadores, estan solamente pensados para hacer operaciones entre mismos tipos de pixels, esto quiere, por ejemplo, que el operator+ entre pixel A y B, solo funciona si pertenecen a la misma clase. Recordamos que tratandose con templates, dos pixels pertenecen a la misma clase cuando tambien sus argumentos templates coinciden. Para fijar ideas:

                                                              bicotiRGB< unsigned char, float > pixel_uchar_1;
                                                  bicotiRGB< unsigned char, float > pixel_uchar_2;
Esto si se puede hacer :                    pixel_uchar_1 = pixel_uchar_1 + pixel_uchar_2;

                                                   bicotiRGB< float, unsigned char > pixel_float;
Error esto NO se puede hacer :       pixel_uchar_1 = pixel_uchar_1 + pixel_float;

                                                   bicotiPixelVectorialStatic<unsigned char, 3, float> pixel_vector;
Error esto NO se puede hacer :      pixel_vector = pixel_vector + pixel_uchar_1;

• 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. Observar que para pixels igual a tipos nativos del lenguaje no podemos controlar la división por cero, para definir una política,  y con al objetivo de pensar en algorimos genéricos no hubiese sido correcto que fuera "a veces si, a veces no".
 
• La operaciones no chequean los overflow o underflow, por ejemplo:

        Se obtiene pixel_uchar_1 = ( 5, 38, 45);
        Esto es porque la suma con unsigned char, es suma en módulo 256.

Para una discusión mas detallada sobre PrecisionType ir a Criterios de Diseño.