vetFrameHSV.h

#ifndef __VETLIB_VETFRAMEHSV_H__
 #define __VETLIB_VETFRAMEHSV_H__

 #include "vetFrame.h"



 #include "PixelHSV.h"
/*
 struct PixelHSV {
         unsigned short int hue;        //16bit |
         unsigned char sat;                     //8bit  |> 32bit
         unsigned char vat;                     //8bit  |
 }
*/


 #include "vetFrameRGB96.h"
 #include "vetFrameGrey.h"


class vetFrameHSV : public virtual vetFrame
{
        public:

                PixelHSV *data;


        public:

                enum ChannelHSV { HUE, SAT, VAL };



        public:


                vetFrameHSV();

                vetFrameHSV(unsigned int width, unsigned int height);


                vetFrameHSV(vetFrameHSV& img);

                vetFrameHSV(vetFrameRGB96& img);

                vetFrameHSV(vetFrameGrey& img);


                ~vetFrameHSV();


                VETRESULT setWidth(unsigned int newWidth);
                VETRESULT setHeight(unsigned int newHeight);

                void* dump_buffer() { return static_cast<void*>(data); };

                VETRESULT reAllocCanvas(unsigned int w, unsigned int h);


                unsigned int getBpp() { return sizeof(PixelHSV) * 8; };
                VETRESULT setBlack();
                VETRESULT setWhite();

                VETRESULT extractBrightness(unsigned char* buffer, unsigned int* size = NULL );

                VETRESULT setPixel(unsigned int x, unsigned int y, PixelHSV p);

                VETRESULT setHSV(unsigned int x, unsigned int y, unsigned short int hue, unsigned char sat, unsigned char val);

                VETRESULT setChannel(unsigned int x, unsigned int y, ChannelHSV ch, unsigned int value);

                VETRESULT getPixel(unsigned int x, unsigned int y, PixelHSV& p);

                unsigned int getChannel(unsigned int x, unsigned int y, ChannelHSV ch);

                vetFrameHSV& clearWith(PixelHSV& bg);

                vetFrameHSV& clearChannel(ChannelHSV ch, unsigned int value = 0);

                vetFrameHSV& copy(vetFrameHSV& img);


                /* Operators overloading */

                vetFrameHSV& operator = (vetFrameHSV& img) { return this->copy(img); };


                vetFrameHSV& operator += (vetFrameHSV& img) ;


                vetFrameHSV& operator -= (vetFrameHSV& img) ;

                vetFrameHSV& operator /= (vetFrameHSV& img) ;

                vetFrameHSV& operator *= (vetFrameHSV& img) ;



                vetFrameHSV& operator >> (vetFrameRGB24& img);

                vetFrameHSV& operator >> (vetFrameHSV& img);

                vetFrameHSV& operator >> (vetFrameRGB96& img);

                vetFrameHSV& operator >> (vetFrameGrey& img);



                void operator << (const vetFrameRGB24& img);

                void operator << (const vetFrameHSV& img);

                void operator << (const vetFrameRGB96& img);

                void operator << (const vetFrameGrey& img);




        static void convPixel_RGB32toHSV (const PixelRGB96&, PixelHSV&);
        static void convPixel_HSVtoRGB32 (const PixelHSV&, PixelRGB96&);

        static void convPixel_RGB24toHSV (const PixelRGB24&, PixelHSV&);
        static void convPixel_HSVtoRGB24 (const PixelHSV&, PixelRGB24&);

        static void convPixel_GREYtoHSV (const PixelGrey&, PixelHSV&);
        static void convPixel_HSVtoGREY (const PixelHSV&, PixelGrey&);


                VETFRAME_PROFILE getProfile() { return vetFrame::VETFRAME_CUSTOM; };
                VETFRAME_CHANNEL_TYPE getChannelType() { return vetFrame::VETFRAME_CT_PACKED; };

                int getFOURCC() { return 0;};


 };


#endif  // __VETLIB_VETFRAMEHSV_H__

---