Pixel Complex

bicotiComplex

bicotiRGB

bicotiPixelVectorialStatic

bicotiPixelVectorialDynamic

bicotiPixelComplex

class bicotiPixelComplex< class PixelType,
class PixelPrecisionType = PixelType>

Observaciones Generales sobre bicotiPixelComplex :

        El argumento del template PixelType, en ves del habitual "ColorType" de pixel vectorial, se debe a
        que el complejo que se construye en base a pixels ya existentes. Por ejemplo se puede hacer un
        bicotiPixelComplex< char >, o un bicotiPixelComplex< bicotiRGB< int > >, o un
        bicotiPixelComplex< bicotiPixelVectorialDynamic< float> >, etc.
        De la misma forma el PixelPrecisionType, se utiliza para hacer cuentas con precisión, solo que
        ahora cuando tengamos: PixelType = char, usar PixelPrecisionType = float, por ejemplo;
        PixelType = bicotiRGB< int >, usar PixelPrecisionType = bicotiRGB< double >, por ejemplo;
        PixelType = bicotiPixelVectorialDynamic< float >, podria dejar el default template; etc.
        Se sugiere por simplicidad, comenzar por estudiar los otros pixels primero.

Public Methods

bicotiPixelComplex ( PixelType, PixelType )
bicotiPixelComplex ( )
~bicotiPixelComplex ( )
bicotiPixelComplex ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

void operator = ( const bicotiPixelComplex <PixelType,PixelPrecisionType> & )
bool operator == ( const bicotiPixelComplex<PixelType,PixelPrecisionType>& )

bicotiPixelComplex<PixelType,PixelPrecisionType>operator + ( double )
bicotiPixelComplex<PixelType,PixelPrecisionType>operator - ( double )
bicotiPixelComplex<PixelType,PixelPrecisionType>operator * ( double )
bicotiPixelComplex<PixelType,PixelPrecisonType>operator / ( double )

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

bicotiPixelComplex<PixelType,PixelPrecisionType>operator + ( const PixelType & )
bicotiPixelComplex<PixelType,PixelPrecisionType>operator - ( const PixelType &   )
bicotiPixelComplex<PixelType,PixelPrecisionType>operator * ( const PixelType &   )
bicotiPixelComplex<PixelType,PixelPrecisionType>operator / ( const PixelType &   )

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

bicotiPixelComplex<PixelType,PixelPrecisionType>
                                                           operator + ( const bicotiPixelComplex<PixelTypePixelPrecisionType> & )
bicotiPixelComplex<PixelType,PixelPrecisionType>
                                                           operator - ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )
bicotiPixelComplex<PixelType,PixelPrecisionType>
                                                            operator * ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )
bicotiPixelComplex<PixelType,PixelPrecisionType>
                                                            operator / ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

void operator += ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )
void operator -= ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )
void operator *= ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )
void operator /= ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

PixelType& Real ( )
PixelType& Imaginary ( )

bicotiPixelComplex<PixelType,PixelPrecisionType> Conjugate ( )

PixelType Module ( )
PixelType Argument ( )

operator bicotiPixelComplex< PixelPrecisionType, PixelType >( )

void One ( )

bicotiPixelComplex (PixelType, PixelType)

Es el constructor de la clase, se pasa como parámetros los valores de parte real y parte imaginaria,
en ese orden.

              bicotiRGB<unsigned char> pixel_real( 2, 2, 2);
              bicotiRGB<unsigned char> pixel_imaginary( 5, 5, 5);
           bicotiPixelComplex < bicotiRGB<unsigned char> > my_pixel( pixel_real,pixel_imaginary);

Creo un bicotiPixelComplex =

bicotiPixelComplex ()

Constructor por defecto de la clase.

~bicotiPixelComplex ( )

Es el destructor de la clase.

bicotiPixelComplex ( const bicotiPixelComplex<PixelType> & )

Constructor de copia.

void operator = ( const bicotiPixelComplex <PixelType> & )

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

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

pixel_b = pixel_a;

El pixel pixel_b resulta una copia exacta de pixel_a.

pixel_a = 3 + 3 j
pixel_b = 1 + 1 j

bool operator == ( const bicotiPixelComplex <PixelType> & )

Operador de comparación . Devuelve true cuando los pixels poseen la misma parte real, y la
misma parte imaginaria.

bicotiPixelComplex<PixelType,PixelPrecisionType>operator + ( double )

            Este operador le suma un doble a la parte real y a la parte imaginaria.
            Por ejemplo si fuera pixel_a = 1 + 2 j
            y hago :

pixel_b = pixel_a + 3;

Obtengo pixel_b = 4 + 5 j

bicotiPixelComplex<PixelType,PixelPrecisionType>operator - ( double )

Este operador le resta un doble a la parte real y al parte imaginaria, y devuelve un nuevo
pixel. Similar al operator +.

bicotiPixelComplex<PixelType,PixelPrecisionType>operator * ( double )

            Este operador multiplica por un doble a la parte real y a la parte imaginaria, y devuelve un nuevo
            pixel. Por ejemplo si fuera pixel_a = 1 + 0 j
            y hago :

pixel_b = pixel_a * 2;

Obtengo pixel_b = 2 + 0 j

bicotiPixelComplex<PixelType,PixelPrecisionType>operator / ( double )

            Este operador divide por un doble a la parte real y a la parte imaginaria, 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.

void operator += ( double )

            Este operador le suma un doble a la parte real y a la parte imaginaria, y devuelve los resultados
            en el mismo pixel.
            Por ejemplo si fuera pixel = 1 - 1 j
            y hago :

pixel += 2;

Obtengo pixel = 3 + 1 j

void operator -= ( double )

Este operador le resta un doble a la parte real y a la parte imaginaria, y devuelve los resultados
en el mismo pixel. Similar al operator +=.

void operator *= ( double )

            Este operador multiplica por un doble a la parte real y a la parte imaginaria, y devuelve los
            resultados en el mismo pixel.
            Por ejemplo si fuera pixel = 2 - 1 j
            y hago :

pixel *= -1;

Obtengo pixel = -2 + 1 j

            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" ( el complejo 0 + 0 j )
            Puedo hacer:

pixel *= 0;

void operator /= ( double )

Este operador divide por un doble a la parte real y a la parte imaginaria, y devuelve los
resultados en el mismo pixel. Similar al operator /=.

bicotiPixelComplex<PixelType,PixelPrecisionType>operator + ( const PixelType & )

bicotiPixelComplex<PixelType,PixelPrecisionType>operator - ( const PixelType & )

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

bicotiPixelComplex<PixelType,PixelPrecisionType>operator * ( const PixelType & )

bicotiPixelComplex<PixelType,PixelPrecisionType>operator / ( const PixelType & )

            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.

void operator += ( const PixelType & )

void operator -= ( const PixelType & )

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

void operator *= ( const PixelType & )

void operator /= ( const PixelType & )

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

bicotiPixelComplex<PixelType,PixelPrecisionType>
operator +( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

Suma de complejos.

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

Se obtiene en pixel_a = 3 + 4 j

bicotiPixelComplex<PixelType,PixelPrecisionType>
operator - ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

Este operador realiza la resta de complejos, entre pixels bicotiPixelComplex, similar al
operator+.

bicotiPixelComplex<PixelType,PixelPrecisionType>
operator *( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

Este operador realiza el producto de complejos. Por ejemplo:

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

Se obtiene en pixel_a = -2 + 6 j;

bicotiPixelComplex<PixelType,PixelPrecisionType>
operator / ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

Este operador realiza la división de complejos. Por ejemplo:

                              bicotiPixelComplex< float > pixel_a( 1, 2);
                                bicotiPixelComplex< float > pixel_b( 2, 2);
                                pixel_a = pixel_a / pixel_b;

Se obtiene en pixelito = .75 + .25 j;

            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.

void operator += ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

Sobrecarga del operador +=, ejemplo:

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

pixel_a = pixel_a + pixel_b;

ó puedo hacer

pixel_a += pixel_b;

Se obtiene en pixelito = 3 + 4 j;

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= ).

void operator -= ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

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

void operator *= ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

Sobrecarga del operador *=, producto de complejos, ejemplo:

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

pixel_a = pixel_a * pixel_b;

ó puedo hacer

pixel_a *= pixel_b;

Se obtiene en pixel_b = -2 + 6 j;

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= ).

void operator /= ( const bicotiPixelComplex<PixelType,PixelPrecisionType> & )

Sobrecarga del operador /=, división de complejos, ejemplo:

bicotiPixelComplex< float > pixel_a( 1, 2);
bicotiPixelComplex< float > pixel_b( 2, 2);

pixel_a = pixel_a / pixel_b;

ó puedo hacer

pixel_a /= pixel_b;

Se obtiene en pixel_a = .75 + .25 j

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= ).

PixelType& Real ( )

Función de acceso bidireccional a la parte real del complejo, o sea puedo leer la parte real o
setearla.

PixelType& Imaginary ( )

Igual que la función Real, pero para acceder a la parte imaginaria de complejo.

bicotiPixelComplex<PixelType,PixelPrecisionType> Conjugate ( )

Retorna el pixel conjugado, del pixel con el cual se invoca.

PixelType Module ( )

Retorna el módulo del pixel en cuestion, observar que si el pixel es vectorial, lo que se retorna es
el módulo de cada uno de sus campos.

PixelType Argument ( )

Retorna la fase del complejo en cuestion, observar que si es un pixel vectorial, lo que se retorna
es la fase de cada uno de sus campos.

operator bicotiPixelComplex< PixelPrecisionType,PixelType>( )

Esta función realiza el casting adecuado a un tipo de precisión deseado por el usuario,
recomendamos por simplicidad, estudiar los otros pixels primero para entender el concepto.

void One ( )

Pone el pixel 1 en ambos campos del complejo.

Por ejemplo si tengo :

bicotiPixelComplex< float > pixel_a( 1, 2);
pixel_a.Ones();

Obtengo a = 1 + j

Si tengo :

bicotiPixelComplex< bicotiRGB< float > > pixel_b( 1, 2);
pixel_b.Ones();

Obtengo a = ( 1, 1 , 1 ) + j ( 1 , 1 , 1)