---

Bmp.h

Go to the documentation of this file.

//  ======================================================================== //
//                                                                           //
//    File      : Bmp.h                                                      //
//    Purpose   :                                                            //
//    Time-stamp: <Thu Nov/14/2002 09:34 MET Coder@ReallySoft.de>            //
//                                                                           //
//    (C) February 2002 by Ralf Westram                                      //
//                                                                           //
//    Permission to use, copy, modify, distribute and sell this software     //
//    and its documentation for any purpose is hereby granted without fee,   //
//    provided that the above copyright notice appear in all copies and      //
//    that both that copyright notice and this permission notice appear      //
//    in supporting documentation.                                           //
//                                                                           //
//    Ralf Westram makes no representations about the suitability of this    //
//    software for any purpose.  It is provided "as is" without express or   //
//    implied warranty.                                                      //
//                                                                           //
//  ======================================================================== //

#ifndef BMP_H
#define BMP_H

#ifndef STRING
#include <string>
#endif

#ifndef BOOST_UTIL_H
#include <boost_util.h>
#endif

namespace rs {

    typedef unsigned int   UINT32;
    typedef unsigned short UINT16;

    const long max_distance = 255L*255L;

    class Pixel {
    private:
        unsigned char *pix;     // pointer to pixel

        static unsigned char transparent_red, transparent_green, transparent_blue; // the transparent color
        static bool          use_transparent_color;

    public:
        Pixel() : pix(0) {}
        Pixel(unsigned char *pixPtr) : pix(pixPtr) {}
        virtual ~Pixel() {}

        unsigned char *getPixPointer() { return pix; }
        const unsigned char *getPixPointer() const { return pix; }

        int color(int rgb) const { assert(rgb >= 0 && rgb <= 2); return pix[rgb]; }

        void set_color(int rgb, unsigned char value) { assert(rgb >= 0 && rgb <= 2); pix[rgb] = value; }

        bool hasTransparentColor() const {
            return use_transparent_color &&
                color(0) == transparent_red &&
                color(1) == transparent_green &&
                color(2) == transparent_blue;
        }

        static void defineTransparentColor(unsigned char red, unsigned char green, unsigned char blue);

        static void useTransparentColor(bool enabled) {
            use_transparent_color = enabled;
        }

        void countMisMatches(const Pixel& other, long& matchCounter, long& mismatchCounter, int max_dist) {
            if (!hasTransparentColor() && !other.hasTransparentColor())  {
                long rdist = labs(color(0)-other.color(0));
                long gdist = labs(color(1)-other.color(1));
                long bdist = labs(color(2)-other.color(2));

                if (rdist>max_dist || gdist>max_dist || bdist>max_dist) {
                    ++mismatchCounter;
                }
                else {
                    ++matchCounter;
                }
            }
        }

        long distance(const Pixel& other) const {
            if (hasTransparentColor() || other.hasTransparentColor()) return 0;

            long rdist = color(0)-other.color(0);
            long gdist = color(1)-other.color(1);
            long bdist = color(2)-other.color(2);

            return rdist*rdist + gdist*gdist + bdist*bdist;
        }

        Pixel& operator++() {
            pix += 3;
            return *this;
        }

        bool operator == (const Pixel& other) const {
            return
                color(0) == other.color(0) &&
                color(1) == other.color(1) &&
                color(2) == other.color(2);
        }

        bool operator != (const Pixel& other) const { return !(*this == other); }
    };




    class Bmp {
    private:
        std::string loaded_from_file;

        UINT32 xsize;
        UINT32 ysize;

        unsigned char *data;
        size_t         offset_per_line;

        static void throw_wrong_pix_pos();

        unsigned char *pixelPointer(UINT32 xpos, UINT32 ypos) {
            if (xpos >= xsize || ypos >= ysize) throw_wrong_pix_pos();
            return data + ypos*offset_per_line + xpos*3;
        }

        void getPositions(const Pixel& pixel, UINT32& xpos_result, UINT32& ypos_result) const {
            long distance = pixel.getPixPointer()-data;
            long ypos     = distance/long(offset_per_line);
            long xpos     = (distance - ypos*offset_per_line)/3;

            xpos_result = xpos;
            ypos_result = ypos;

            if (xpos_result >= xsize || ypos_result >= ysize) throw_wrong_pix_pos();
        }

    public:
        Bmp(const std::string& filename);
        Bmp(size_t xsize_, size_t ysize_);

        Bmp(const Bmp& other);
        Bmp& operator=(const Bmp& other);

        virtual ~Bmp() { delete data; }

        UINT32 Xsize() const { return xsize; }

        UINT32 Ysize() const { return ysize; }

        Pixel getPixel(UINT32 xpos, UINT32 ypos)  { return Pixel(pixelPointer(xpos, ypos)); }

        const Pixel getPixel(UINT32 xpos, UINT32 ypos) const { return Pixel(const_cast<Bmp*>(this)->pixelPointer(xpos, ypos)); }

        void setPixel(UINT32 xpos, UINT32 ypos, unsigned char red, unsigned char green, unsigned char blue) {
            unsigned char *d = const_cast<unsigned char *>(pixelPointer(xpos, ypos));

            d[0] = red;
            d[1] = green;
            d[2] = blue;
        }

        void saveAs(const std::string& filename) const;

        const std::string& originalFilename() const { return loaded_from_file; }

        void left(Pixel& curr, size_t dist = 1) {
            UINT32 xpos, ypos;
            getPositions(curr, xpos, ypos);
            curr = getPixel(xpos-dist, ypos);
        }

        void right(Pixel& curr, size_t dist = 1) {
            UINT32 xpos, ypos;
            getPositions(curr, xpos, ypos);
            curr = getPixel(xpos+dist, ypos);
        }

        void up(Pixel& curr, size_t dist = 1) {
            UINT32 xpos, ypos;
            getPositions(curr, xpos, ypos);
            curr = getPixel(xpos, ypos-dist);
        }

        void down(Pixel& curr, size_t dist = 1) {
            UINT32 xpos, ypos;
            getPositions(curr, xpos, ypos);
            curr = getPixel(xpos, ypos+dist);
        }
    };

    // create a new BMP with half width and height
    Bmp *halfBmp(const Bmp& bmp);



}; // end of namespace rs

#else
#error Bmp.h included twice
#endif // BMP_H

---

Contact me in case of errors or questions. This documentation is powered by .

(C) 2000-2002