rixmap 0.2.1 → 0.3.0

data/src/rixmap/color.hxx

@@ -51,9 +51,17 @@ namespace Rixmap {
 
     public:         // プロパティメンバ関数
         inline uint8_t getRed() const { return this->_red; }
+        inline void setRed(uint8_t value) { this->_red = value; }
+
         inline uint8_t getGreen() const { return this->_green; }
+        inline void setGreen(uint8_t value) { this->_green = value; }
+
         inline uint8_t getBlue() const { return this->_blue; }
+        inline void setBlue(uint8_t value) { this->_blue = value; }
+
         inline uint8_t getAlpha() const { return this->_alpha; }
+        inline void setAlpha(uint8_t value) { this->_alpha = value; }
+
         inline uint32_t getValue() const { return this->_value; }
 
     public:         // メンバ関数
@@ -64,6 +72,12 @@ namespace Rixmap {
             return ROUND2BYTE(lround((r + g + b) / 3.0));
         }
 
+        inline void setLuminance(uint8_t value) {
+            this->_red   = value;
+            this->_green = value;
+            this->_blue  = value;
+        }
+
         /**
          * 指定した色との距離を計算します.
          * 現在の実装では透明度を無視しています.
@@ -77,19 +91,10 @@ namespace Rixmap {
             return sqrt((dr + dg + db));
         }
 
-    public:         // 演算子オーバーロード
         /**
-         * 代入演算子定義
+         * 配列のようにインデックスアクセス
          */
-        inline Color& operator=(const Color& c) {
-            this->_value = c._value;
-            return *this;
-        }
-
-        /**
-         * 配列アクセス
-         */
-        inline uint8_t operator[](size_t offset) const {
+        inline uint8_t get(size_t offset) const {
             switch (offset) {
             case 0: return this->_red;
             case 1: return this->_green;
@@ -101,9 +106,9 @@ namespace Rixmap {
         }
 
         /**
-         * 配列アクセス with Channel
+         * チャンネルアクセス
          */
-        inline uint8_t operator[](Channel channel) const {
+        inline uint8_t get(Channel channel) const {
             switch (channel) {
             case Channel::RED:       return this->_red;
             case Channel::GREEN:     return this->_green;
@@ -114,6 +119,71 @@ namespace Rixmap {
             }
         }
 
+        /**
+         * 配列のようにインデックスで更新
+         */
+        inline void set(size_t offset, uint8_t value) {
+            switch (offset) {
+            case 0:
+                this->_red   = value;
+                break;
+            case 1:
+                this->_green = value;
+                break;
+            case 2:
+                this->_blue  = value;
+                break;
+            case 3:
+                this->_alpha = value;
+                break;
+            default:
+                // 何もできねぇ
+                break;
+            }
+        }
+
+        /**
+         * チャンネルで更新
+         */
+        inline void set(Channel channel, uint8_t value) {
+            switch (channel) {
+            case Channel::RED:
+                this->_red = value;
+                break;
+            case Channel::GREEN:
+                this->_green = value;
+                break;
+            case Channel::BLUE:
+                this->_blue = value;
+                break;
+            case Channel::ALPHA:
+                this->_alpha = value;
+                break;
+            default:
+                // 何もできねぇ
+                break;
+            }
+        }
+
+    public:         // 演算子オーバーロード
+        /**
+         * 代入演算子定義
+         */
+        inline Color& operator=(const Color& c) {
+            this->_value = c._value;
+            return *this;
+        }
+
+        /**
+         * 配列アクセス
+         */
+        inline uint8_t operator[](size_t offset) const { return this->get(offset); }
+
+        /**
+         * 配列アクセス with Channel
+         */
+        inline uint8_t operator[](Channel channel) const { return this->get(channel); }
+
         /**
          * 等値比較演算子
          */
@@ -218,5 +288,5 @@ namespace Rixmap {
 
 
 //============================================================================//
-// $Id: color.hxx,v 66c8edefa6c0 2014/04/20 14:22:54 chikuchikugonzalez $
+// $Id: color.hxx,v 7ded24c516db 2014/05/18 08:28:38 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmap/image.hxx

@@ -20,6 +20,102 @@ namespace Rixmap {
         DIAGONAL   = 0x03
     };
 
+    /**
+     * 画像背景色データ.
+     */
+    class BackgroundColor {
+    private:        // 非公開メンバ
+        std::map<Channel, uint8_t> _data;
+        bool _disabled;
+
+    public:         // コンストラクタ
+        BackgroundColor() : _disabled(true) {
+            this->clear();
+        }
+
+        BackgroundColor(uint8_t l, uint8_t a = 255) : _disabled(true) {
+            this->clear();
+            this->_data[Channel::LUMINANCE] = l;
+            this->_data[Channel::ALPHA    ] = a;
+        }
+
+        BackgroundColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) : _disabled(true) {
+            this->clear();
+            this->_data[Channel::RED  ] = r;
+            this->_data[Channel::GREEN] = g;
+            this->_data[Channel::BLUE ] = b;
+            this->_data[Channel::ALPHA] = a;
+        }
+
+        BackgroundColor(const BackgroundColor& bg) {
+            this->clear();
+            this->_data     = bg._data;
+            this->_disabled = bg._disabled;
+        }
+
+    public:         // 公開メンバ関数
+        inline uint8_t getRed()       { return this->_data.at(Channel::RED); }
+        inline uint8_t getRed() const { return this->_data.at(Channel::RED); }
+        inline void setRed(uint8_t value) { this->_data[Channel::RED] = value; }
+
+        inline uint8_t getGreen()       { return this->_data.at(Channel::GREEN); }
+        inline uint8_t getGreen() const { return this->_data.at(Channel::GREEN); }
+        inline void setGreen(uint8_t value) { this->_data[Channel::GREEN] = value; }
+
+        inline uint8_t getBlue()       { return this->_data.at(Channel::BLUE); }
+        inline uint8_t getBlue() const { return this->_data.at(Channel::BLUE); }
+        inline void setBlue(uint8_t value) { this->_data[Channel::BLUE] = value; }
+
+        inline uint8_t getAlpha()       { return this->_data.at(Channel::ALPHA); }
+        inline uint8_t getAlpha() const { return this->_data.at(Channel::ALPHA); }
+        inline void setAlpha(uint8_t value) { this->_data[Channel::ALPHA] = value; }
+
+        inline uint8_t getLuminance()       { return this->_data.at(Channel::LUMINANCE); }
+        inline uint8_t getLuminance() const { return this->_data.at(Channel::LUMINANCE); }
+        inline void setLuminance(uint8_t value) { this->_data[Channel::LUMINANCE] = value; }
+
+        inline uint8_t getPalette()       { return this->_data.at(Channel::PALETTE); }
+        inline uint8_t getPalette() const { return this->_data.at(Channel::PALETTE); }
+        inline void setPalette(uint8_t value) { this->_data[Channel::PALETTE] = value; }
+
+        inline bool isEnabled()  const { return !(this->_disabled); }
+        inline bool isDisabled() const { return this->_disabled; }
+        inline void enable()  { this->_disabled = false; }
+        inline void disable() { this->_disabled = true; }
+
+    public:         // 演算子オーバーロード
+        inline const uint8_t& operator[](Channel channel) const { return this->_data.at(channel); }
+        inline       uint8_t& operator[](Channel channel)       { return this->_data.at(channel); }
+
+        inline bool operator==(const BackgroundColor& bg) const {
+            return (   (this->_data.at(Channel::RED) == bg._data.at(Channel::RED))
+                    && (this->_data.at(Channel::GREEN) == bg._data.at(Channel::GREEN))
+                    && (this->_data.at(Channel::BLUE) == bg._data.at(Channel::BLUE))
+                    && (this->_data.at(Channel::ALPHA) == bg._data.at(Channel::ALPHA))
+                    && (this->_data.at(Channel::LUMINANCE) == bg._data.at(Channel::LUMINANCE))
+                    && (this->_data.at(Channel::PALETTE) == bg._data.at(Channel::PALETTE))
+                    && (this->_disabled == bg._disabled)
+                   );
+        }
+        inline bool operator!=(const BackgroundColor& bg) const { return !((*this) == bg); }
+
+        inline BackgroundColor& operator=(const BackgroundColor& base) {
+            this->_data     = base._data;
+            this->_disabled = base._disabled;
+            return *this;
+        }
+
+    private:        // 非公開メンバ関数
+        inline void clear() {
+            this->_data[Channel::PALETTE  ] = 0;
+            this->_data[Channel::LUMINANCE] = 0;
+            this->_data[Channel::RED  ]     = 0;
+            this->_data[Channel::GREEN]     = 0;
+            this->_data[Channel::BLUE ]     = 0;
+            this->_data[Channel::ALPHA]     = 255;
+        }
+    };
+
     /**
      * Ruby用画像情報クラスデータ
      */
@@ -59,16 +155,24 @@ namespace Rixmap {
          * @param [int32_t] width 画像の横幅
          * @param [int32_t] height 画像の高さ
          * @param [bool] cleared 初期化するかのフラグ (default=true)
+         * @param [BackgroundColor*] bg 背景色
          */
-        static void AllocatePixels(Pixels& pixels, const ChannelArray& channels, int32_t width, int32_t height, bool cleared = true) {
+        static void AllocatePixels(Pixels& pixels, const ChannelArray& channels, int32_t width, int32_t height, bool cleared = true, const BackgroundColor* bg = NULL) {
             // メモリ不足時に投げる例外オブジェクト
             static std::bad_alloc excNoMemory;
+            static BackgroundColor defaultBG;
+
+            // 背景色へのポインタ
+            const BackgroundColor* bgColor = ((bg != NULL) && bg->isEnabled()) ? bg : &defaultBG;
 
             // 確保処理
             try {
                 for (auto it = channels.begin(); it != channels.end(); it++) {
                     Channel channel = *it;
 
+                    // 背景色
+                    uint8_t bgByte = (*bgColor)[channel];
+
                     // NULLポインタで初期化
                     // TODO ところでこれ、nullptrのほうがいいんですかね
                     pixels[channel] = NULL;
@@ -93,12 +197,14 @@ namespace Rixmap {
                         plane[h] = line;
 
                         // 初期化する
+                        // TODO 初期カラーを設定できるようにする
                         if (cleared) {
-                            if (channel == Channel::ALPHA) {
-                                std::memset(&(line[0]), 255, sizeof(uint8_t) * width);
-                            } else {
-                                std::memset(&(line[0]),   0, sizeof(uint8_t) * width);
-                            }
+                            std::memset(&(line[0]), bgByte, sizeof(uint8_t) * width);
+                            //if (channel == Channel::ALPHA) {
+                            //    std::memset(&(line[0]), 255, sizeof(uint8_t) * width);
+                            //} else {
+                            //    std::memset(&(line[0]),   0, sizeof(uint8_t) * width);
+                            //}
                         }
                     }
                 }
@@ -123,25 +229,35 @@ namespace Rixmap {
         Pixels _data;
         VALUE _palette;
 
+        // 補助データ
+        //VALUE _background;      // 背景色
+        //VALUE _transparent;     // 透過設定
+
+        // 構造体スタイル
+        BackgroundColor _background;
+        BackgroundColor _transparent;
+
     public:         // コンストラクタ
         /**
          * デフォルトコンストラクタ
          */
-        ImageData() : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil) {}
+        ImageData() : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil), _background(), _transparent() {}
 
         /**
          * 一応初期データつき
          */
-        ImageData(Mode mode, int32_t width, int32_t height) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil) {
+        ImageData(Mode mode, int32_t width, int32_t height) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil), _background(), _transparent() {
             this->init(mode, width, height);
         }
 
         /**
          * コピーコンストラクタ
          */
-        ImageData(const ImageData& image) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil) {
+        ImageData(const ImageData& image) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil), _background(), _transparent() {
+            this->_palette     = image._palette;
+            this->_background  = image._background;
+            this->_transparent = image._transparent;
             this->init(image.getMode(), image._width, image._height);
-            this->_palette = image._palette;
 
             // ピクセルの複製
             const ChannelArray& channels = image._mode.getChannels();
@@ -161,9 +277,11 @@ namespace Rixmap {
          * ベース画像ののサイズを変更した新しい画像を作成する、部分コピーコンストラクタ.
          * ピクセルデータは複製されません.
          */
-        ImageData(const ImageData& image, int32_t width, int32_t height) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil) {
+        ImageData(const ImageData& image, int32_t width, int32_t height) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil), _background(), _transparent() {
+            this->_palette     = image._palette;
+            this->_background  = image._background;
+            this->_transparent = image._transparent;
             this->init(image.getMode(), width, height);
-            this->_palette = image._palette;
         }
 
         /**
@@ -185,7 +303,7 @@ namespace Rixmap {
          * 画像形式情報を取得します.
          */
         inline const ModeInfo& getModeInfo() const { return this->_mode; }
-        inline ModeInfo& getModeInfo() { return this->_mode; }
+        inline       ModeInfo& getModeInfo()       { return this->_mode; }
 
         /**
          * 横幅を取得します.
@@ -228,6 +346,14 @@ namespace Rixmap {
             this->_palette = obj;
         }
 
+        inline const BackgroundColor& getBackground() const { return this->_background; }
+        inline       BackgroundColor& getBackground()       { return this->_background; }
+        inline void setBackground(const BackgroundColor& bg) { this->_background = bg; }
+
+        inline const BackgroundColor& getTransparent() const { return this->_transparent; }
+        inline       BackgroundColor& getTransparent()       { return this->_transparent; }
+        inline void setTransparent(const BackgroundColor& bg) { this->_transparent = bg; }
+
     public:         // 公開メンバ関数
         /**
          * 指定座標が画像範囲内かどうかを返します.
@@ -340,7 +466,27 @@ namespace Rixmap {
                     err << "point [" << x << ", " << y << "] is out of image";
                     throw std::out_of_range(err.str());
                 } else {
-                    return Color(0, 0, 0);
+                    if (this->_background.isEnabled()) {
+                        switch (this->_mode.getMode()) {
+                        case Mode::INDEXED:
+                            return this->getPaletteData()->get(this->_background.getPalette());
+                            break;
+
+                        case Mode::GRAYSCALE:
+                        case Mode::GRAYALPHA:
+                            {
+                                uint8_t l = this->_background.getLuminance();
+                                return Color(l, l, l);
+                            }
+                            break;
+
+                        default:
+                            return Color(this->_background.getRed(), this->_background.getGreen(), this->_background.getBlue());
+                            break;
+                        }
+                    } else {
+                        return Color(0, 0, 0);
+                    }
                 }
             }
         }
@@ -367,7 +513,7 @@ namespace Rixmap {
             const ChannelArray& channels = info.getChannels();
 
             // ピクセルデータを確保
-            ImageData::AllocatePixels(this->_data, channels, width, height, true);
+            ImageData::AllocatePixels(this->_data, channels, width, height, true, &(this->_background));
 
             // その他プロパティを初期化
             this->_mode   = info;
@@ -384,14 +530,14 @@ namespace Rixmap {
             rb_gc_mark_maybe(this->_palette);
         }
 
-        /**
-         * 必須ではないオブジェクトのハッシュを返します.
-         */
-        inline VALUE getMetadata() const {
-            VALUE metadata = rb_hash_new();
-            rb_hash_aset(metadata, ID2SYM(rb_intern("palette")), this->_palette);
-            return metadata;
-        }
+        ///**
+        // * 必須ではないオブジェクトのハッシュを返します.
+        // */
+        //inline VALUE getMetadata() const {
+        //    VALUE metadata = rb_hash_new();
+        //    rb_hash_aset(metadata, ID2SYM(rb_intern("palette")), this->_palette);
+        //    return metadata;
+        //}
 
         /**
          * 画像の反転処理を行います.
@@ -440,6 +586,30 @@ namespace Rixmap {
             }
         }
 
+        /**
+         * 背景色で画像を塗りつぶします.
+         */
+        void clear() {
+            // TODO AllocatePixelsと共通化したいよねぇ
+            static BackgroundColor _default;
+
+            // 背景色
+            BackgroundColor* bg = (this->_background.isEnabled()) ? &(this->_background) : &_default;
+
+            // チャンネル毎に処理
+            const ChannelArray& channels = this->_mode.getChannels();
+            for (auto it = channels.begin(); it != channels.end(); it++) {
+                Channel channel = *it;
+                uint8_t byte = (*bg)[channel];
+                uint8_t** plane = this->get(channel);
+
+                for (int32_t h = 0; h < this->_height; h++) {
+                    uint8_t* line = plane[h];
+                    std::memset(&(line[0]), byte, sizeof(uint8_t) * this->_width);
+                }
+            }
+        }
+
     public:         // 演算子オーバーロード
         bool operator==(const ImageData& data) const {
             if (this->_ready && data._ready && (this->_mode == data._mode) && (this->_width == data._width) && (this->_height == data._height)) {
@@ -448,6 +618,12 @@ namespace Rixmap {
                         return false;
                     }
                 }
+                if (this->_background != data._background) {
+                    return false;
+                }
+                if (this->_transparent != data._transparent) {
+                    return false;
+                }
 
                 // ピクセルを比較
                 const ChannelArray& channels = this->_mode.getChannels();
@@ -481,7 +657,7 @@ namespace Rixmap {
 
             // ピクセルデータは新しく確保 (破壊防止)
             std::map<Channel, uint8_t**> pixels;
-            ImageData::AllocatePixels(pixels, channels, base._width, base._height, false);
+            ImageData::AllocatePixels(pixels, channels, base._width, base._height, false, NULL);
 
             // ピクセルデータを複製
             for (auto it = channels.begin(); it != channels.end(); it++) {
@@ -506,6 +682,10 @@ namespace Rixmap {
             // パレットは参照
             this->_palette = base._palette;
 
+            // 背景色とかを複製
+            this->_background  = base._background;
+            this->_transparent = base._transparent;
+
             // 準備完了
             this->_ready = true;
 
@@ -612,5 +792,5 @@ namespace Rixmap {
 
 
 //============================================================================//
-// $Id: image.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// $Id: image.hxx,v 5590f3c64493 2014/05/31 14:59:34 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmap/interpolator.hxx

@@ -26,12 +26,13 @@ namespace Rixmap {
     protected:
         ImageData* _base;           // 元画像
         ModeInfo*  _mode;           // 元画像形式
+        BackgroundColor* _bg;       // 元画像背景色
 
         // 補間処理キャッシュ
         std::map<Channel, uint8_t> _pixel;
 
     public:
-        Interpolator(ImageData* base) : _base(base), _mode(&(_base->getModeInfo())) {
+        Interpolator(ImageData* base) : _base(base), _mode(&(_base->getModeInfo())), _bg(&(base->getBackground())) {
             this->reset();
         }
 
@@ -54,15 +55,29 @@ namespace Rixmap {
         virtual uint8_t get(Channel channel) { return this->_pixel.at(channel); }
 
     protected:      // 非公開メンバ
+        inline uint8_t getBG(Channel channel) {
+            if (this->_bg != NULL && this->_bg->isEnabled()) {
+                return (*(this->_bg))[channel];
+            } else {
+                if (channel == Channel::ALPHA) {
+                    return 255;
+                } else {
+                    return 0;
+                }
+            }
+        }
+
         virtual void reset() {
             const ChannelArray& channels = this->_mode->getChannels();
             for (auto it = channels.begin(); it != channels.end(); it++) {
                 Channel channel = *it;
-                if (channel == Channel::ALPHA) {
-                    this->_pixel[channel] = 255;
-                } else {
-                    this->_pixel[channel] = 0;
-                }
+                //uint8_t byte = (*(this->_bg))[channel]; // TODO NULLになっちゃってた場合の対処
+                uint8_t byte = this->getBG(channel);
+                //uint8_t byte = 0;
+                //if (channel == Channel::ALPHA) {
+                //    byte = 255;
+                //}
+                this->_pixel[channel] = byte;
             }
         }
     };
@@ -210,11 +225,13 @@ namespace Rixmap {
             const ChannelArray& channels = this->_preferredMode.getChannels();
             for (auto it = channels.begin(); it != channels.end(); it++) {
                 Channel channel = *it;
-                if (channel == Channel::ALPHA) {
-                    this->_pixel[channel] = 255;
-                } else {
-                    this->_pixel[channel] = 0;
-                }
+                //uint8_t byte = (*(this->_bg))[channel]; // TODO NULLになっちゃってた場合の対処
+                uint8_t byte = this->getBG(channel);
+                //uint8_t byte = 0;
+                //if (channel == Channel::ALPHA) {
+                //    byte = 255;
+                //}
+                this->_pixel[channel] = byte;
             }
         }
     };
@@ -222,5 +239,5 @@ namespace Rixmap {
 
 
 //============================================================================//
-// $Id: interpolator.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// $Id: interpolator.hxx,v f55202a19a4a 2014/05/31 13:04:07 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: