vetFilterGeometric.cpp

Go to the documentation of this file.

#include "vetFilterGeometric.h"
#include <math.h>


vetFilterGeometric::vetFilterGeometric(vetFilterGeometricParameters* initParams) : vetFilter()
 {
        INFO("vetFilterGeometric::vetFilterGeometric(..* initParams) : vetFilter() [CONTRUCTOR]")
        myParams = NULL;
        setParameters(initParams);

        setName("Geometric Editing Filter");
        setDescription("Resize, Crop, Rotation, Flip");
        setVersion(1.0);
 }

vetFilterGeometric::~vetFilterGeometric()
 {
        INFO("vetFilterGeometric::~vetFilterGeometric() [DESTRUCTOR]")

        printf("vetFilterGeometric::~vetFilterGeometric() [DESTRUCTOR]");


        if (myParams != NULL)
                delete myParams;
        myParams = NULL;
 }

VETRESULT vetFilterGeometric::reset()
 {
        INFO("VETRESULT vetFilterGeometric::reset() [SET DEFAULT PARAMETERS]")

        releaseBuffers();

        if (myParams != NULL)
         {
                myParams->reset();
                allocateBuffer(myParams->currentBuffer);
         }
        else
                setParameters(NULL);

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::setParameters (vetFilterGeometricParameters* initParams)
 {
        if (initParams != NULL && myParams == initParams)
                return VETRET_PARAM_ERR;

        if ( initParams == NULL )
         {
                if ( myParams != NULL )
                        reset();
                else
                        myParams = new vetFilterGeometricParameters();
         }
        else
         {
                if ( myParams != NULL )
                        delete myParams;

                myParams = initParams;
         }

        allocateBuffer(myParams->currentBuffer);

        return VETRET_OK;
 }


VETRESULT vetFilterGeometric::importFrom(vetFrameYUV420& img)
 {
        DEBUGMSG("VETRESULT vetFilterGeometric::importFrom(vetFrameYUV420& img) [reading data]", myParams->runMode)

        switch ( myParams->runMode )
         {
         case vetFilterGeometricParameters::DO_NOTHING:
                        if ( !isBufferYUV() )
                         {
                                useBufferYUV(img.width, img.height);
                                *bufferYUV = img;
                                return VETRET_OK_DEPRECATED;
                         }
                        else
                         {
                                *bufferYUV = img;
                                return VETRET_OK;
                         }

         case vetFilterGeometricParameters::ROTATE90:
                        return rotate90(img);

         case vetFilterGeometricParameters::ROTATE180:
                        return rotate180(img);

         case vetFilterGeometricParameters::ROTATE270:
                        return rotate270(img);

         case vetFilterGeometricParameters::ROTATE:
                        return rotate( img, myParams->par_Rotation );

         case vetFilterGeometricParameters::FLIP_VERTICAL:
                        return flipVertical(img);

         case vetFilterGeometricParameters::FLIP_HORIZONTAL:
                        return flipHorizontal(img);

         case vetFilterGeometricParameters::RESIZE:
                        return resize( img, myParams->par_ResizeWidth, myParams->par_ResizeHeight );

         case vetFilterGeometricParameters::RESIZECANVAS:
                        return resizeCanvas( img, myParams->par_ResizeWidth, myParams->par_ResizeHeight );

         default:
                  return VETRET_PARAM_ERR;
         }
 }

VETRESULT vetFilterGeometric::importFrom(vetFrameRGB24& img)
 {
        DEBUGMSG("VETRESULT vetFilterGeometric::importFrom(vetFrameRGB24& img) [reading data]", myParams->runMode)

        switch ( myParams->runMode )
         {
         case vetFilterGeometricParameters::DO_NOTHING:
                        if ( !isBufferRGB() )
                         {
                                useBufferRGB(img.width, img.height);
                                *bufferRGB = img;
                                return VETRET_OK_DEPRECATED;
                         }
                        else
                         {
                                *bufferRGB = img;

                                return VETRET_OK;
                         }

         case vetFilterGeometricParameters::ROTATE90:
                        return rotate90(img);

         case vetFilterGeometricParameters::ROTATE180:
                        return rotate180(img);

         case vetFilterGeometricParameters::ROTATE270:
                        return rotate270(img);

         case vetFilterGeometricParameters::ROTATE:
                        return rotate( img, myParams->par_Rotation );

         case vetFilterGeometricParameters::FLIP_VERTICAL:
                        return flipVertical(img);

         case vetFilterGeometricParameters::FLIP_HORIZONTAL:
                        return flipHorizontal(img);

         case vetFilterGeometricParameters::RESIZE:
                        return resize( img, myParams->par_ResizeWidth, myParams->par_ResizeHeight );

         case vetFilterGeometricParameters::RESIZECANVAS:
                        return resizeCanvas( img, myParams->par_ResizeWidth, myParams->par_ResizeHeight );

         default:
                  return VETRET_PARAM_ERR;
         }

 }

VETRESULT vetFilterGeometric::importFrom(vetFrameT<unsigned char>& img)
 {
        DEBUGMSG("VETRESULT vetFilterGeometric::importFrom(vetFrameT& img) [reading data]", myParams->runMode)

        switch ( myParams->runMode )
         {
         case vetFilterGeometricParameters::DO_NOTHING:
                        if ( !isBufferTuC() )
                         {
                                useBufferTuC(img.width, img.height, img.profile);
                                *bufferTuC = img;
                                return VETRET_OK_DEPRECATED;
                         }
                        else
                         {
                                *bufferTuC = img;
                                return VETRET_OK;
                         }

         case vetFilterGeometricParameters::ROTATE90:
                        return rotate90(img);

         case vetFilterGeometricParameters::ROTATE180:
                        return rotate180(img);

         case vetFilterGeometricParameters::ROTATE270:
                        return rotate270(img);

         case vetFilterGeometricParameters::ROTATE:
                        return rotate( img, myParams->par_Rotation );

         case vetFilterGeometricParameters::FLIP_VERTICAL:
                        return flipVertical(img);

         case vetFilterGeometricParameters::FLIP_HORIZONTAL:
                        return flipHorizontal(img);

         case vetFilterGeometricParameters::RESIZE:
                        return resize( img, myParams->par_ResizeWidth, myParams->par_ResizeHeight );

         case vetFilterGeometricParameters::RESIZECANVAS:
                        return resizeCanvas( img, myParams->par_ResizeWidth, myParams->par_ResizeHeight );

         default:
                  return VETRET_PARAM_ERR;
         }

 }






// Video Size and Trasformation Functions


VETRESULT vetFilterGeometric::resize(vetFrameYUV420& img, unsigned int dimX , unsigned int dimY)
 {
        useBufferYUV(dimX, dimY);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::resize(vetFrameRGB24& img, unsigned int dimX , unsigned int dimY)
 {
        useBufferRGB(dimX, dimY);

        float rx=(float)bufferRGB->width/(float)dimX;
        float ry=(float)bufferRGB->height/(float)dimY;
//BUG
        for ( unsigned int y=0; y < dimY; y++ ) // single pixel copy routine
          for ( unsigned int x=0; x < dimX; x++ )
                bufferRGB->data[y*bufferRGB->width+x] = img.data[(int)( ((float)x*rx) + ((float)y*ry * (float)img.width)   )]; //(float)x*rx + ((float)y*ry * (float)img.width) )

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::resize(vetFrameT<unsigned char>& img, unsigned int dimX , unsigned int dimY)
 {
        useBufferTuC(dimX, dimY, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::resizeCanvas(vetFrameYUV420& img, unsigned int dimX, unsigned int dimY)
 {
        useBufferYUV(dimX, dimY);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::resizeCanvas(vetFrameRGB24& img, unsigned int dimX, unsigned int dimY)
 {
        useBufferRGB(dimX, dimY);

        for ( unsigned int y=0; y < img.height; y++ ) // single pixel copy routine
          for ( unsigned int x=0; x < img.width; x++ )
                bufferRGB->data[y*bufferRGB->width+x] = img.data[ y * img.width + x ];

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::resizeCanvas(vetFrameT<unsigned char>& img, unsigned int dimX, unsigned int dimY)
 {
        useBufferTuC(dimX, dimY, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::resizeCanvas(vetFrameYUV420& img, unsigned int dimX, unsigned int dimY, unsigned char& valY, unsigned char& valU, unsigned char& valV)
 {
        useBufferYUV(dimX, dimY);

        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetFilterGeometric::resizeCanvas(vetFrameRGB24& img, unsigned int dimX, unsigned int dimY, PixelRGB24 background)
 {
        useBufferRGB(dimX, dimY);

        PixelRGB24 bgRGB24((unsigned char)background[0], (unsigned char)background[1], (unsigned char)background[2] );

        for ( unsigned int i=0; i < dimX * dimY; i++ )
                bufferRGB->data[i] = bgRGB24;

        for ( unsigned int y=0; y < img.height; y++ ) // single pixel copy routine
          for ( unsigned int x=0; x < img.width; x++ )
                bufferRGB->data[y*bufferRGB->width+x] = img.data[ y * img.width + x ];

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::resizeCanvas(vetFrameT<unsigned char>& img, unsigned int dimX, unsigned int dimY, unsigned char& val1, unsigned char& val2, unsigned char& val3)
 {
        useBufferTuC(dimX, dimY, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetFilterGeometric::rotate90(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate90(vetFrameYUV420& img)")

        useBufferYUV(img.height, img.width);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::rotate90(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate90(vetFrameRGB24& img)")

        useBufferRGB(img.height, img.width);

        for ( unsigned int y=0; y < bufferRGB->height; y++ ) // single pixel copy routine
          for ( unsigned int x=0; x < bufferRGB->width; x++ )
                bufferRGB->data[(bufferRGB->width-1-x)*bufferRGB->height+y] = img.data[x*img.width + y];

                /*       y,w_rect-1-x
0,0 > width-1, 0
1,0 > width-1, 1

i,0 > width-1, i

x,y > width-1-y, x



  int w_rect=i.get_dimx();
  int h_rect=i.get_dimy();
  imt=new image(h_rect,w_rect,i.get_bpp(),1);
  for (y=0;y<h_rect;y++)
    for (x=0;x<w_rect;x++)
      imt->put_GL(h_rect-1-y,x,i.get_GL(x,y));


        //data[0] -> rgb [newwidth-1];
        //data[1] -> rgb [2*newwidth-1];
        //data[i] > rgb[width*i-1]
        for ( unsigned int i=0; i< width * height; i++ )


                rgb[i] = img.data[   width * height-1  +i   ];


        {
                rgb [width*height-1] = img.data[width-1];
        }
  */
        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::rotate90(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate90(vetFrameT<unsigned char>& img)")

        useBufferTuC(img.height, img.width, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetFilterGeometric::rotate180(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate180(vetFrameYUV420& img)")

        useBufferYUV(img.height, img.width);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::rotate180(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate180(vetFrameRGB24& img)")

        useBufferRGB(img.width, img.height);

        for (unsigned int i=0; i < bufferRGB->width*bufferRGB->height; i++)      // reverse array
                bufferRGB->data[i] = img.data[img.width*img.height-1-i];

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::rotate180(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate180(vetFrameT<unsigned char>& img)")

        useBufferTuC(img.height, img.width, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::rotate270(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate270(vetFrameYUV420& img)")

        useBufferYUV(img.height, img.width);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::rotate270(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate270(vetFrameCach24e& img)")

        useBufferRGB(img.height, img.width);

        for ( unsigned int y=0; y < bufferRGB->height; y++ ) // single pixel copy routine
          for ( unsigned int x=0; x < bufferRGB->width; x++ )
                bufferRGB->data[(bufferRGB->height-1-y)*bufferRGB->width+x] = img.data[x*img.width + y];

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::rotate270(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterGeometric::rotate270(vetFrameT<unsigned char>& img)")

        useBufferTuC(img.height, img.width, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::rotate(vetFrameYUV420& img, float alpha)
 {
        unsigned int ex,ey;
        float ox,oy;
        float dx=(float) img.width;
        float dy=(float) img.height;
        float x1,x2,x3,x4,y1,y2,y3,y4;
        float xmin,xmax,ymin,ymax;
        //conversione alpha da gradi in radianti
        alpha*=(float)3.141592654/180;
        //calcolo la posizione degli angoli dell'immagine una volta ruotata
        x1=0.;
        x2=dx*cos(alpha);
        x3=dx*cos(alpha)-dy*sin(alpha);
        x4=-dy*sin(alpha);
        y1=0.;
        y2=dx*sin(alpha);
        y3=dy*cos(alpha)+dx*sin(alpha);
        y4=dy*cos(alpha);
        //ricerco quindi gli estremi per calcolare il rettangolo che conterrà la mia immagine ruotata
        xmin=x1;
        if (x2<xmin) xmin=x2;
        if (x3<xmin) xmin=x3;
        if (x4<xmin) xmin=x4;
        xmax=x1;
        if (x2>xmax) xmax=x2;
        if (x3>xmax) xmax=x3;
        if (x4>xmax) xmax=x4;
        ymin=y1;
        if (y2<ymin) ymin=y2;
        if (y3<ymin) ymin=y3;
        if (y4<ymin) ymin=y4;
        ymax=y1;
        if (y2>ymax) ymax=y2;
        if (y3>ymax) ymax=y3;
        if (y4>ymax) ymax=y4;
        //calcolo la dimensione della nuova immagine
        ex=(int)(xmax-xmin)+1;
        ey=(int)(ymax-ymin)+1;
        //calcolo il vettore di spostamento che dovrò applicare all'immagine originale ruotata
        //per farla stare nella nuova
        ox=xmin-x1;
        oy=ymin-y1;
        //istanzio l'immagine

        useBufferYUV(ex, ey);


        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::rotate(vetFrameRGB24& img, float alpha)
 {
        unsigned int ex,ey;
        float ox,oy;
        float dx=(float) img.width;
        float dy=(float) img.height;
        float x1,x2,x3,x4,y1,y2,y3,y4;
        float xmin,xmax,ymin,ymax;
        //conversione alpha da gradi in radianti
        alpha*=(float)3.141592654/180;
        //calcolo la posizione degli angoli dell'immagine una volta ruotata
        x1=0.;
        x2=dx*cos(alpha);
        x3=dx*cos(alpha)-dy*sin(alpha);
        x4=-dy*sin(alpha);
        y1=0.;
        y2=dx*sin(alpha);
        y3=dy*cos(alpha)+dx*sin(alpha);
        y4=dy*cos(alpha);
        //ricerco quindi gli estremi per calcolare il rettangolo che conterrà la mia immagine ruotata
        xmin=x1;
        if (x2<xmin) xmin=x2;
        if (x3<xmin) xmin=x3;
        if (x4<xmin) xmin=x4;
        xmax=x1;
        if (x2>xmax) xmax=x2;
        if (x3>xmax) xmax=x3;
        if (x4>xmax) xmax=x4;
        ymin=y1;
        if (y2<ymin) ymin=y2;
        if (y3<ymin) ymin=y3;
        if (y4<ymin) ymin=y4;
        ymax=y1;
        if (y2>ymax) ymax=y2;
        if (y3>ymax) ymax=y3;
        if (y4>ymax) ymax=y4;
        //calcolo la dimensione della nuova immagine
        ex=(int)(xmax-xmin)+1;
        ey=(int)(ymax-ymin)+1;
        //calcolo il vettore di spostamento che dovrò applicare all'immagine originale ruotata
        //per farla stare nella nuova
        ox=xmin-x1;
        oy=ymin-y1;
        //istanzio l'immagine

        useBufferRGB(ex, ey);

        //precalcolo il seno e coseno
        float cc=cos(-alpha);
        float ss=sin(-alpha);

        for ( unsigned int y=0; y < ey; y++ ) // single pixel copy routine
          for ( unsigned int x=0; x < ex; x++ )
                        bufferRGB->data[y*bufferRGB->width+x] = img.data[(int)( (( (float)(y+oy)*cc+(float)(x+ox)*ss) * img.width) + ((float)(x+ox)*cc-(float)(y+oy)*ss) )];

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::rotate(vetFrameT<unsigned char>& img, float alpha)
 {
        unsigned int ex,ey;
        float ox,oy;
        float dx=(float) img.width;
        float dy=(float) img.height;
        float x1,x2,x3,x4,y1,y2,y3,y4;
        float xmin,xmax,ymin,ymax;
        //conversione alpha da gradi in radianti
        alpha*=(float)3.141592654/180;
        //calcolo la posizione degli angoli dell'immagine una volta ruotata
        x1=0.;
        x2=dx*cos(alpha);
        x3=dx*cos(alpha)-dy*sin(alpha);
        x4=-dy*sin(alpha);
        y1=0.;
        y2=dx*sin(alpha);
        y3=dy*cos(alpha)+dx*sin(alpha);
        y4=dy*cos(alpha);
        //ricerco quindi gli estremi per calcolare il rettangolo che conterrà la mia immagine ruotata
        xmin=x1;
        if (x2<xmin) xmin=x2;
        if (x3<xmin) xmin=x3;
        if (x4<xmin) xmin=x4;
        xmax=x1;
        if (x2>xmax) xmax=x2;
        if (x3>xmax) xmax=x3;
        if (x4>xmax) xmax=x4;
        ymin=y1;
        if (y2<ymin) ymin=y2;
        if (y3<ymin) ymin=y3;
        if (y4<ymin) ymin=y4;
        ymax=y1;
        if (y2>ymax) ymax=y2;
        if (y3>ymax) ymax=y3;
        if (y4>ymax) ymax=y4;
        //calcolo la dimensione della nuova immagine
        ex=(int)(xmax-xmin)+1;
        ey=(int)(ymax-ymin)+1;
        //calcolo il vettore di spostamento che dovrò applicare all'immagine originale ruotata
        //per farla stare nella nuova
        ox=xmin-x1;
        oy=ymin-y1;
        //istanzio l'immagine

        useBufferTuC(ex, ey, img.profile);


        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetFilterGeometric::flipHorizontal(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterGeometric::flipHorizontal(vetFrameYUV420& img)")

        useBufferYUV(img.width, img.height);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::flipHorizontal(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterGeometric::flipHorizontal(vetFrameRGB24& img)")

        useBufferRGB(img.width, img.height);

        for ( unsigned int y=0; y < bufferRGB->height; y++ ) // single pixel copy routine
         for ( unsigned int x=0; x < bufferRGB->width; x++ )
                bufferRGB->data[x+y*bufferRGB->width] = img.data[y*img.width + (img.width-1)-x];

        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::flipHorizontal(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterGeometric::flipHorizontal(vetFrameT<unsigned char>& img)")

        useBufferTuC(img.width, img.height, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetFilterGeometric::flipVertical(vetFrameYUV420& img)
 {
        INFO("VETRESULT vetFilterGeometric::flipVertical(vetFrameYUV420& img)")

        useBufferYUV(img.width, img.height);

        return VETRET_NOT_IMPLEMENTED;
 }

VETRESULT vetFilterGeometric::flipVertical(vetFrameRGB24& img)
 {
        INFO("VETRESULT vetFilterGeometric::flipVertical(vetFrameRGB24& img)")

        useBufferRGB(img.width, img.height);

        for ( unsigned int i=0; i < bufferRGB->height; i++ ) // optimized, copy each row
                memcpy( &bufferRGB->data[i*bufferRGB->width], &img.data[(bufferRGB->height-i-1)*bufferRGB->width], bufferRGB->width * sizeof(PixelRGB24) );


        return VETRET_OK;
 }

VETRESULT vetFilterGeometric::flipVertical(vetFrameT<unsigned char>& img)
 {
        INFO("VETRESULT vetFilterGeometric::flipVertical(vetFrameT<unsigned char>& img)")

        useBufferTuC(img.width, img.height, img.profile);

        return VETRET_NOT_IMPLEMENTED;
 }
















vetFilterGeometricParameters::vetFilterGeometricParameters(RUNMODE mode) : vetFilterParameters()
 {
        runMode = mode;
 }

void vetFilterGeometricParameters::reset()
 {
        runMode = vetFilterGeometricParameters::DO_NOTHING;
        par_Rotation = 0;
        par_ResizeWidth = 0;
        par_ResizeHeight = 0;
        par_forzeSize = false;
        currentBuffer = vetFilterParameters::NONE;
 }

int vetFilterGeometricParameters::saveToStreamXML(FILE *fp)
 {

        if ( fp == NULL )
                return VETRET_PARAM_ERR;

        if( fprintf(fp, "<vetFilterGeometricParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <runmode value=\"%i\" />\n", (int)runMode) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <rotation value=\"%f\" />\n", par_Rotation) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <resize width=\"%u\" height=\"%u\" />\n", par_ResizeWidth, par_ResizeHeight) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <forzeSize value=\"%u\" />\n", (int)par_forzeSize) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <internalBufferType value=\"%u\" />\n", (int)currentBuffer) == EOF)
                return VETRET_INTERNAL_ERR;

        if( fprintf(fp, "</vetFilterGeometricParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        return VETRET_OK;
 }


int vetFilterGeometricParameters::loadFromStreamXML(FILE *fp)
 {
        if ( fscanf(fp, "<vetFilterGeometricParameters>\n") == EOF )
                throw "error in XML file, unable to import data.";

        int runTmp = 0;
        if ( fscanf(fp, "  <runmode value=\"%i\" />\n", &runTmp) == EOF )
                throw "error in XML file, unable to import data.";
        else
                runMode = (RUNMODE)runTmp;

        if ( fscanf(fp, "  <rotation value=\"%f\" />\n", &par_Rotation) == EOF )
                throw "error in XML file, unable to import data.";

        if ( fscanf(fp, "  <resize width=\"%u\" height=\"%u\" />\n", &par_ResizeWidth, &par_ResizeHeight) == EOF )
                throw "error in XML file, unable to import data.";

        int boolTmp = 0;
        if ( fscanf(fp, "  <forzeSize value=\"%u\" />\n", &boolTmp) == EOF )
                throw "error in XML file, unable to import data.";

        if (boolTmp == 0)
                par_forzeSize = false;
        else
                par_forzeSize = true;

        int cB = (int)currentBuffer;
        if ( fscanf(fp, "  <internalBufferType value=\"%u\" />\n", &cB) == EOF )
                throw "error in XML file, unable to import data.";
        currentBuffer = (BUFFER_TYPE)cB;

        return VETRET_OK;
 }

---