Clases

bicotiImageImplementation
bicotiImageImplementation2D
bicotiImageImplementation2DSimple
bicotiImageImplementation2DArray
bicotiImageImplementation2DSparse
bicotiImageImplementation2DByLayers
bicotiImageImplementation3D
bicotiImageImplementation3DArray
bicotiImageImplementation3DLinear
 

     Templates Clases

PixelType

class bicotiImageImplementation < class PixelType >

virtual ~bicotiImageImplementation ( )

double GetScale ( )
PixelType GetDefaultPixel ( )
PixelCases PixelCase ( )

virtual PixelType GetPixel ( bicotiCoordinate< INTEGER >& ) = 0
virtual voidSetPixel ( bicotiCoordinate< INTEGER >&, const PixelType & ) = 0

virtual void Resize ( bicotiImageDescriptor * ) = 0

virtual bicotiImageDescriptor * CreateImageDescriptor ( ) = 0

virtual bicotiImageImplementation< PixelType > * CreateImageImplementation ( ) = 0
virtual bicotiImageImplementation< PixelType > * CreateImageImplementation ( bicotiImageDescriptor * ) = 0

virtual bicotiImageIterator< PixelType > * CreateIterator ( ) = 0
virtual bicotiImageFrameIterator< PixelType > * CreateFrameIterator
                                                                                        ( int , bicotiImageExtrapolationStrategy<PixelType > * ) = 0
 

        Destrutor. A pesar de ser virtual, las clases bases necesitan tener definidos destructores virtuales,
( que no hacen nada) , para que se llame al constructor de los correspondientes hijos, cuando se hace algo del tipo :

    bicotiImageImplementation< int > * ptr_ima;   // declaro un puntero a la clase base
    ptr_ima = new bicotiImageImplementation2DArray< int >( ... );  // creo un objeto concreto
                                            .
                                            .
   delete ptr_ima;       // llamo al destructor de la clase concreta

Este tipo de procedimiento es muy usual en nuestra biblioteca ya que permite el polimorfismo, muy útil en
los lengujes orientado a objetos.

    Permite leer la escala, es decir la dimensión de los pixeles de la imagen.
    Cuando creamos una imagen podemos pasarle el valor de la escala, si no lo hacemos se toma 1 por
    defecto.No hay forma de modificar la escala luego de creada la imagen.

       bicotiImageImplementation2DArray< int >   image( 0 , 10 ,10 );  // no especifico la escala

    En este caso :

        double scale;
        scale = image.GetScale( );

    Devuelve un 1 en scale
    Pero si creo a la imagen como :

       bicotiImageImplementation2DArray< int >   image( 0 , 10 ,10, 1.53 );  // tomo escala = 1.53

    Ahora la función devolvería scale = 1.53  ( la unidades son relevantes para el usuario )

    Cuando creamos una imagen hay que pasar como primer parámetro del constructor al pixel por defecto.
Es el pixel con el que se llena toda la imagen al crearse. Por ejemplo :

       bicotiImageImplementation2DArray< int >   image( 0 , 5 , 5 );

Crea una imagen 5 x 5 de ceros

       bicotiImageImplementation2DArray< int >   image( 2 , 5 , 5 );

Crea una imagen 5 x 5 llena de 2

La función GetDefaultPixel( ) retorna el valor del pixel por defecto.

    Retorna un enumerado ( PixelCases ) que indica el tipo de pixel que rellena a la imagen.
    Puede tomar uno de tres valores :
                     single - tipo básico ( int , char , float , etc )
                     vectorial - tipo estructurado, definido por el usuaruio ( RGB, HSV por ej )
                     unknouwn - desconocido
     Este valor solo puede ser seteado en el constructor y es conveniente hacerlo.

    Por ejemplo si creo :

        bicotiImageImplementation2DArray<char> image( 0, 4, 5 );

    El pixel es char, por lo tanto es simple , pero como no le paso el PixelCase toma unknown por defecto.
    Por lo tanto debo hacer :

        bicotiImageImplementation2DArray<char> image( 0, 4, 5 , 1.5 , single );

    Si el pixel es vectorial :

        bicotiImageImplementation2DArray< bicotiRGB<char> > image( 0, 4, 5 , 1.5 , vectorial );

    Retorna el valor del pixel situado en la coordenada indicada coord.
    Por ejemplo , si tengo la imagen 2D de la figura 2.1.2

Figura 2.1.2

    Si Hago :

        bicotiCoordinate<int>  coord(2);    // Creo una coordenada 2D de valores enteros
        coord(0) = 1 ;
        coord(1) = 2 ;    //  Pongo coord = ( 1 , 2 )

        pix = imagen.GetPixel( coord );   // devuelve en pix el valor en la columna 1 fila 2

       Obtengo pix = 3.

     Esta función es virtual pura en esta clase, se implementa en las especializaciones.

    Escribe en la posición indicada por coord el valor de pix_val.
    Por ejemplo, si hago :

        bicotiCoordinate<int>  coord(2);    // Creo una coordenada 2D de valores enteros
        coord(0) = 2 ;
        coord(1) = 3 ;    //  Pongo coord = ( 2 , 3 )

        imagen.SetPixel( coord , 0 );   // pongo un cero en la columna 2 , fila 3

     Esta función es virtual pura en esta clase, se implementa en las especializaciones.

    Esta función permite modificar el tamaño de un imagen usando un descriptor.El descriptor es una clase
    que tiene información respecto a la dimensión, el tamaño y el tipo de pixel de la imagen, ver
    ImageDescriptor para más detalles.

    Por ejemplo si tengo una imagen 3 x 3 y quiero cambiarla a 4x5, puedo hacer :

    bicotiImageDescriptor * ptr_desc = new  bicotiImageDescriptor ;  // Creo al descriptor
    desc->Size(0)=4;
    desc->Size(1)=4;  // Le seteo los tamaños que quiero

    image.Resize ( ptr_desc );

    La ventaja de usar un descriptor para cambiar el tamaño es que no necesitamos saber nada sobre
    las dimensiones o el tipo de la imagen.

    Obs : Al usar esta función, toda la información de la imagen se pierde, es como crear una nueva con
    el mismo default_pixel , scale y pixel_case que tenía.

     Esta función es virtual pura en esta clase, se implementa en las especializaciones.

    Esta función crea y devuelve un puntero a un descriptor de la imagen. Nos sirve para obtener
    información sobre una imagen y hacer algoritmos independientes de la dimensión y tipo de
    implementación.
    Por ejemplo, si tenemos una imagen_a y una imagen_b ( ambas de igual dimensión )
    y hacemos :

    bicotiImageDescriptor * ptr_desc ;
    ptr_desc= imagen_a.CreateImageDescriptor ;  // Creo un descriptor de imagen_a

    image_b.Resize( ptr_desc ); // Cambio el tamaño de imagen_b

    delete ptr_desc; // Llamo al destructor del descriptor.

    Con este procedimiento puedo igualar el tamño de imagen_b al de imagen_a sin cambiar su tipo,
    y sin necesidad de preguntar por el tamaño de imagen_a.
 

    Crea y devuelve un punero a una implementación igual a la de la imagen.
    Esta función es útil cuando queremos crear una copia de una implementación que no sabemos.
    Por ejemplo si tenemos una imagen_a de enteros cuya dimensión tamaño y tipo no sabemos.
    Si hacemos:

        bicotiImageImplementation< int > * ptr_ima_b;
        ptr_ima_b = imagen_a.CreateImageImplementation();

    Tenemos en ptr_ima_b un puntero a una imagen identica a imagen_a, misma dimensión, tamaño y tipo.

    Obs: Es importante destacar que esto no es lo mismo que usar el constructor de copia, primero porque
    no hace una copia de la imagen, copia las características y no el contenido. Además para usar el
    constructor de copia necesitamos saber el tipo concreto de la imagen, cosa que aquí no es necesaria.

     Esta función es virtual pura en esta clase, se implementa en las especializaciones.

    Esta función sirve para crear una imagen del mismo tipo que la que tenemos , pero con el tamaño
   indicado por el descriptor.
   Por ejemplo, si imagen_a es 2DArray  10 x 10:

    bicotiImageImplementation2DArray<int> imagen_a ( 0 , 10 , 10 , 1 , single );

    y hago :

    bicotiImageDescriptor * ptr_desc ;
    ptr_desc= imagen_a.CreateImageDescriptor ;  // Creo un descriptor de imagen_a
    ptr_desc->Size(0)=3;
    ptr_desc->Size(0)=5;  // cambio el tamaño

    bicotiImageImplementation<int> * ptr_imagen_b;

    ptr_imagen_b = imagen_a.CreateImageImplementation( ptr_desc );

    La imagen_b será 2DArray 3 x 5, con default_pixel 0 , escala 1 y pixel_case single como imagen_a.

     Esta función es virtual pura en esta clase, se implementa en las especializaciones.

     Esta función es fundamental para los algoritmos que recorren las imágenes independientemente de
    la dimensión y el tipo.
    Al llamar a esta función, la imagen creará un iterador adecuado para su tipo y dimensión.
    Podemos hacer algo del tipo:

        bicotiImageIterator<int>* ptr_iterator;
        ptr_iterator = imagen.CreateIterator();

    En ptr_iterator tenemos un puntero al iterador adecuado. Podemos luego recorrer la imagen usando
    este puntero.

    Ver Iterators para más detalles.

     Esta función es virtual pura en esta clase, se implementa en las especializaciones.

     Es análogo al caso anterior pero devuelve un FrameIterator en lugar de un iterator, pero la idea es
    la misma.

    bicotiImageExtrapolationStrategy<int> * ptr_strat;
    ptr_strat = new bicotiImageExtrapolationStrategyEqual<int>; // Creo la estrategia de extrapolación

    bicotiImageFrameIterator<int>* ptr_frame_iterator;
    ptr_frame_iterator = imagen.CreateFrameIterator( 3 , ptr_strat );

     Aqui hay que pasarle el tamaño del frame y la estrategia de extrapolación para crear al iterador.
    Ver Frame Iterators para más detalles.

     Esta función es virtual pura en esta clase, se implementa en las especializaciones.