PortablePixmap.hpp

Go to the documentation of this file.

#ifndef LOPER_PORTABLEPIXMAP
#define LOPER_PORTABLEPIXMAP

#include "standard.hpp"
#include <vector>
#include <algorithm>
#include "PortablePicture.hpp"
#include "PortableBitmap.hpp"

#ifndef UBYTE
#define UBYTE unsigned char
#endif



class PortablePixel
{
public:

    PortablePixel() {}
    PortablePixel (UBYTE r, UBYTE g, UBYTE b)
    {
        this->red = r;
        this->green = g;
        this->blue = b;
    }

    UBYTE & operator[](int index) { return (&red)[index]; }

    void operator*=(float f)
    {
        red   = (UBYTE)(f * red);
        green = (UBYTE)(f * green);
        blue  = (UBYTE)(f * blue);
    }

    PortablePixel operator* (float f)
    {
        PortablePixel result = *this;
        result *= f;
        return result;
    }


    void operator+=(const PortablePixel &p)
    {
        red   += p.red;
        green += p.green;
        blue  += p.blue;
    }

    PortablePixel operator+ (const PortablePixel &p)
    {
        PortablePixel result = *this;
        result += p;

        return result;
    }

    UBYTE red, green, blue; 
};




class PortablePixmap : public PortablePicture< PortablePixel >
{
public:

    PortablePixmap ();
    PortablePixmap (int width, int height) { resize (width, height); }

/*
 * File operations
 */
    void loadFromFile (const char *filename);
    void loadFromFileRescaled (const char *filename);
    void saveAsPpm (const char *filename);
    PortablePixmap(const char *filename) { loadFromFile(filename); }

/*
 * Mutators
 */

    void setToBlack() { pixels.assign(pixels.size(), PortablePixel(0,0,0)); } 
/*
 * Image processing
 */
    PortablePixmap getDilatedImage() const;
    PortablePixmap getInvertedImage();
    PortableBitmap getThresholdedImage (int thresh) const;
    PortableBitmap getAdaptivelyThresholdedImage();
    PortablePixmap getSubImage (int left, int top, int width, int height) const;
    PortablePixmap getBoxBlurredImage(int filterWidth, int filterHeight);

    void getFramedImage(PortablePixmap & imgOut) const;

    void getRescaledImage(PortablePixmap &imgOut) const;

    PortablePixmap getEdgeDetectedImage();
    PortablePixel getModeBrightness();
    PortablePixel getInterpolated (float row, float col) const;
};

#endif // LOPER_PORTABLEPIXMAP

---