vetFilterGeometric.h

#ifndef __VETLIB_VETFILTERGEOMETRIC_H__
 #define __VETLIB_VETFILTERGEOMETRIC_H__

 #include "../vetDefs.h"
 #include "../vetFilter.h"

 #include "../vetFrameYUV420.h"
 #include "../vetFrameRGB24.h"
 #include "../vetFrameT.h"



class vetFilterGeometricParameters : public vetFilterParameters
{
        public:

                enum RUNMODE{ DO_NOTHING, ROTATE90, ROTATE180, ROTATE270, ROTATE, FLIP_VERTICAL, FLIP_HORIZONTAL, RESIZE, RESIZECANVAS };

        protected:

                RUNMODE runMode;

                float par_Rotation;
                unsigned int par_ResizeWidth;
                unsigned int par_ResizeHeight;
                bool par_forzeSize;

                friend class vetFilterGeometric;

        public:

                vetFilterGeometricParameters(RUNMODE mode = vetFilterGeometricParameters::DO_NOTHING);
                ~vetFilterGeometricParameters() {}

                void reset();

                void setRunMode(RUNMODE mode) { runMode = mode; };
                RUNMODE getRunMode() { return runMode; };

                void setRotationDegree(float degree) { par_Rotation = degree; };
                void setResizeDimension(unsigned int width, unsigned int height) { par_ResizeWidth = width; par_ResizeHeight = height; };

                float getRotationDegree() { return par_Rotation; };
                unsigned int getResizeDimensionWidth() { return par_ResizeWidth; };
                unsigned int getResizeDimensionHeight() { return par_ResizeHeight; };

                void forceOutputSize(bool value = true) { par_forzeSize = value; };
                bool isForceOutputSizeEnabled() { return par_forzeSize; };


                VETRESULT saveToStreamXML(FILE *fp);
                VETRESULT loadFromStreamXML(FILE *fp);

};



class vetFilterGeometric :      public vetFilter
 {

 protected:

                vetFilterGeometricParameters* myParams;



 public:

                vetFilterGeometric(vetFilterGeometricParameters* initParams = NULL );

                ~vetFilterGeometric();

                float getFrameRate()  const { return 0; };
        //      virtual int setFrameRate(float );



                VETRESULT setParameters(vetFilterGeometricParameters* initParams);

                vetFilterGeometricParameters& getParameters() { return *myParams; };



                VETRESULT setFilterParameters (vetFilterParameters* initParams)
                 {
                        if (initParams == NULL)
                                return setParameters(NULL);
                        else
                                return setParameters(static_cast<vetFilterGeometricParameters*>(initParams));
                 };



                vetFilterParameters* getFilterParameters ()
                 {
                        if (myParams == NULL)
                                return NULL;
                        else
                                return static_cast<vetFilterParameters*>(myParams);
                 };


                VETRESULT reset();



                VETRESULT resize(vetFrameYUV420& img, unsigned int dimX , unsigned int dimY);
                VETRESULT resize(vetFrameRGB24& img, unsigned int dimX , unsigned int dimY);
                VETRESULT resize(vetFrameT<unsigned char>& img, unsigned int dimX , unsigned int dimY);


                VETRESULT resizeCanvas(vetFrameYUV420& img, unsigned int newdimX, unsigned int newdimY);
                VETRESULT resizeCanvas(vetFrameRGB24& img, unsigned int newdimX, unsigned int newdimY);
                VETRESULT resizeCanvas(vetFrameT<unsigned char>& img, unsigned int newdimX, unsigned int newdimY);

                VETRESULT resizeCanvas(vetFrameYUV420& img, unsigned int newdimX , unsigned int newdimY, unsigned char& valY, unsigned char& valU, unsigned char& valV);
                VETRESULT resizeCanvas(vetFrameRGB24& img, unsigned int newdimX , unsigned int newdimY, PixelRGB24 defaultColor);
                VETRESULT resizeCanvas(vetFrameT<unsigned char>& img, unsigned int newdimX , unsigned int newdimY, unsigned char& val1, unsigned char& val2, unsigned char& val3);


                VETRESULT rotate90(vetFrameYUV420& img);
                VETRESULT rotate90(vetFrameRGB24& img);
                VETRESULT rotate90(vetFrameT<unsigned char>& img);


                VETRESULT rotate180(vetFrameYUV420& img);
                VETRESULT rotate180(vetFrameRGB24& img);
                VETRESULT rotate180(vetFrameT<unsigned char>& img);


                VETRESULT rotate270(vetFrameYUV420& img);
                VETRESULT rotate270(vetFrameRGB24& img);
                VETRESULT rotate270(vetFrameT<unsigned char>& img);


                VETRESULT rotate(vetFrameYUV420& img, float alpha);
                VETRESULT rotate(vetFrameRGB24& img, float alpha);
                VETRESULT rotate(vetFrameT<unsigned char>& img, float alpha);


                VETRESULT flipHorizontal(vetFrameYUV420& img);
                VETRESULT flipHorizontal(vetFrameRGB24& img);
                VETRESULT flipHorizontal(vetFrameT<unsigned char>& img);


                VETRESULT flipVertical(vetFrameYUV420& img);
                VETRESULT flipVertical(vetFrameRGB24& img);
                VETRESULT flipVertical(vetFrameT<unsigned char>& img);



                VETRESULT importFrom(vetFrameYUV420& img);

                VETRESULT importFrom(vetFrameRGB24& img);

                VETRESULT importFrom(vetFrameT<unsigned char>& img);






























                template <class T>
                static VETRESULT rotate90(vetFrameT<T> *src, vetFrameT<T> *dst, bool clockDir)
                {
                        int xd,yd,x,y;

                        if (dir)
                                xd = 0;
                        else
                                xd = dst.width - 1;

                        for(y = 0 ; y < src.height ; y++)
                         {
                                if (dir)
                                        yd = dst.height - 1;
                                else
                                        yd = 0;

                                for(x = 0 ; x < src.width ; x++)
                                 {
                                        dst.data[yd * dst.width + xd] = src.data[y * src.width + x];

                                        if (dir)
                                                yd--;
                                        else
                                                yd++;
                                 }

                                if (dir)
                                        xd++;
                                else
                                        xd--;
                         }

                        return VETRET_OK;
                }


                template <class T>
                static VETRESULT rotate180(vetFrameT<T> *src, vetFrameT<T> *dst)
                {
                        for (unsigned int i=0; i < src.width*src.height; i++)      // reverse array
                                dst.data[i] = src.data[src.width*src.height-1-i];

                        return VETRET_OK;

                /*  int xd,yd,x,y;

                  yd = dst.height - 1;

                  for(y = 0 ; y < src.height ; y++)
                  {
                        xd = dst.width - 1;

                        for(x = 0 ; x < src.width ; x++)
                        {
                          dst.data[yd * dst.width + xd] = src.data[y * src.width + x];
                          xd--;
                        }

                        yd--;
                  }
                */
                }

                template <class T>
                static VETRESULT mirror(vetFrameT<T> *src, vetFrameT<T> *dst)
                {
                        unsigned int width = src.width;

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

                        return VETRET_OK;
                /*  int xd,x,y;
                  (void)dst.height;

                  for(y = 0 ; y < src.height ; y++)
                  {
                        xd = dst.width - 1;

                        for(x = 0 ; x < src.width ; x++)
                        {
                          dst.data[y * dst.width + xd] = src.data[y * src.width + x];
                          xd--;
                        }
                  }
                */
                }

                template <class T>
                static VETRESULT flip(vetFrameT<T> *src, vetFrameT<T> *dst)
                {
                        int yd,y;

                        yd = dst.height - 1;

                        for(y = 0 ; y < src.height ; y++)
                         {
                                memcpy(dst.data+yd*dst.width,src.data+y*src.width,src.width * sizeof(T));
                                yd--;
                         }
                        return VETRET_OK;
                }





};


#endif //__VETLIB_VETFILTERGEOMETRIC_H__

---