color.h

Go to the documentation of this file.

#ifndef COLOR_H
#define COLOR_H

#include <Magick++.h>

inline void operator*=(Magick::ColorRGB & color, double n) {
    color.red  (color.red()   * n);
    color.green(color.green() * n);
    color.blue (color.blue()  * n);
}

inline Magick::ColorRGB operator* (const Magick::ColorRGB & color, double n) {
    return Magick::ColorRGB(color.red() * n, color.green() * n, color.blue() * n);
}

inline void operator*=(Magick::ColorRGB & color, const Magick::ColorRGB & other) {
    color.red(color.red() * other.red());
    color.green(color.green() * other.green());
    color.blue(color.blue() * other.blue());
}
inline Magick::ColorRGB operator* (const Magick::ColorRGB & color, const Magick::ColorRGB & other) {
    return Magick::ColorRGB(
            color.red()   * other.red(),
            color.green() * other.green(),
            color.blue()  * other.blue()
            );
}

inline void operator+=(Magick::ColorRGB & color, const Magick::ColorRGB & other) {
    color.red  ( color.red()   + other.red()   );
    color.green( color.green() + other.green() );
    color.blue ( color.blue()  + other.blue()  );
}

inline Magick::ColorRGB operator+ (const Magick::ColorRGB & color, const Magick::ColorRGB & other) {
    return Magick::ColorRGB(
            color.red()   + other.red(),
            color.green() + other.green(),
            color.blue()  + other.blue()
            );
}

//{{{
// Pre-ImageMagick++ color implementation
#if 0
#include "raytrace_defs.h"

typedef unsigned char uchar;
class Color {
    private:
        double m_red;
        double m_green;
        double m_blue;

        inline double get_largest_color_component() const {
            if(m_red >= m_green && m_red >= m_blue) {
                return m_red;
            }
            else if(m_green >= m_red && m_green >= m_blue) {
                return m_green;
            }
            else if(m_blue >= m_red && m_blue >= m_green) {
                return m_blue;
            }
        }
    public:

        Color() : m_red(0.0), m_green(0.0), m_blue(0.0) {}

        Color(int rgb) : m_red(((unsigned char*)rgb)[0]/256.0), m_green(((unsigned char*)rgb)[1]/256.0), m_blue(((unsigned char*)rgb)[2]/256.0) {}

        Color(double _red, double _green, double _blue) : m_red(_red), m_green(_green), m_blue(_blue) {
            int a = 3;
        }

        Color(int _red, int _green, int _blue) : m_red(_red / 256.0), m_green(_green / 256.0), m_blue(_blue / 256.0) {
        }

        Color(const Color &other) : m_red(other.m_red), m_green(other.m_green), m_blue(other.m_blue) {
        }

        void operator=(const Color &other) {
            set_red ( other.m_red );
            set_green ( other.m_green );
            set_blue ( other.m_blue );
        }


        void operator*=(double n) {
            set_red(m_red * n);
            set_green(m_green * n);
            set_blue(m_blue * n);
        }
        Color operator* (double n) { return Color(m_red * n, m_green * n, m_blue * n); }

        Color operator-(const Color &other) { return Color( m_red - other.m_red, m_green - other.m_green, m_blue - other.m_blue); }
        bool operator==(const Color &other) {
            double FUDGE_FACTOR = 0.0001;
            return (m_red >= other.m_red - FUDGE_FACTOR && m_red <= other.m_red + FUDGE_FACTOR)
                && (m_green >= other.m_green - FUDGE_FACTOR && m_green <= other.m_green + FUDGE_FACTOR)
                && (m_blue >= other.m_blue - FUDGE_FACTOR && m_blue <= other.m_blue + FUDGE_FACTOR);
        } 

        void set_red (double new_red) { m_red = new_red; }
        void set_green (double new_green) { m_green = new_green; }
        void set_blue (double new_blue) { m_blue = new_blue; }

        inline uchar get_rgb_red () const {
            double max = get_largest_color_component();
            if(max > 1.0) {
                return (uchar)((m_red/max) * 255); 
            }
            return (uchar)(m_red * 255);
        }

        inline uchar get_rgb_green() const {
            double max = get_largest_color_component();
            if(max > 1.0) {
                return (uchar)((m_green/max) * 255); 
            }
            return (uchar)(m_green * 255);
        }
        
        inline uchar get_rgb_blue () const {
            double max = get_largest_color_component();
            if(max > 1.0) {
                return (uchar)((m_blue/max) * 255); 
            }
            return (uchar)(m_blue * 255);
        }


        inline double get_red () const { return m_red; }

        inline double get_green() const { return m_green; }
        
        inline double get_blue () const { return m_blue; }

};
#endif
//}}}

#endif

---