rixmap 0.1.1 → 0.2.0

data/src/rixmap/image.hxx

@@ -9,10 +9,110 @@
 #include "palette.hxx"
 
 namespace Rixmap {
+
+    // ピクセルデータ用コンテナ
+    typedef std::map<Channel, uint8_t**> Pixels;
+
+    // 反転方向定数
+    enum class FlipDirection : int {
+        HORIZONTAL = 0x01,
+        VERTICAL   = 0x02,
+        DIAGONAL   = 0x03
+    };
+
     /**
      * Ruby用画像情報クラスデータ
      */
     class ImageData {
+    private:        // 非公開クラスメンバ関数
+        /**
+         * ピクセルデータを指定された情報に従って解放します.
+         *
+         * @param [Pixels&] pixels ピクセルデータ.
+         * @param [int32_t] width 画像の横幅
+         * @param [int32_t] height 画像の高さ
+         */
+        static void DeallocatePixels(Pixels& pixels, int32_t width, int32_t height) {
+            for (auto it = pixels.begin(); it != pixels.end(); it++) {
+                uint8_t** plane = it->second;
+                if (plane != NULL) {
+                    for (int32_t h = 0; h < height; h++) {
+                        if (plane[h] != NULL) {
+                            delete[] plane[h];
+                        }
+                    }
+                    delete[] plane;
+                    it->second = NULL;
+                }
+            }
+            pixels.clear();
+        }
+
+        /**
+         * ピクセルデータリストを指定チャンネル分だけ確保します.
+         *
+         * 注意点として、pixelsは未初期化 (確保したて) を想定しています.
+         * 中身が二重ポインタのせいで正確に解放できないためです.
+         *
+         * @param [Pixels&] pixels データ格納先.
+         * @param [ChannelArray&] channels 確保するチャンネルリスト
+         * @param [int32_t] width 画像の横幅
+         * @param [int32_t] height 画像の高さ
+         * @param [bool] cleared 初期化するかのフラグ (default=true)
+         */
+        static void AllocatePixels(Pixels& pixels, const ChannelArray& channels, int32_t width, int32_t height, bool cleared = true) {
+            // メモリ不足時に投げる例外オブジェクト
+            static std::bad_alloc excNoMemory;
+
+            // 確保処理
+            try {
+                for (auto it = channels.begin(); it != channels.end(); it++) {
+                    Channel channel = *it;
+
+                    // NULLポインタで初期化
+                    // TODO ところでこれ、nullptrのほうがいいんですかね
+                    pixels[channel] = NULL;
+
+                    // ピクセルデータを確保
+                    uint8_t** plane = new uint8_t*[height];
+                    if (plane == NULL) {
+                        // 確保できてない
+                        throw excNoMemory;
+                    }
+
+                    // 確保できたらpixelsに入れる
+                    pixels[channel] = plane;
+
+                    // 中身を確保
+                    for (int32_t h = 0; h < height; h++) {
+                        uint8_t* line = new uint8_t[width];
+                        if (line == NULL) {
+                            // 無理でした
+                            throw excNoMemory;
+                        }
+                        plane[h] = line;
+
+                        // 初期化する
+                        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);
+                            }
+                        }
+                    }
+                }
+            } catch (const std::bad_alloc& e) {
+                // メモリねぇぞ(#ﾟДﾟ)
+
+                // 今まで確保した分を解放
+                ImageData::DeallocatePixels(pixels, width, height);
+
+                // raise NoMemoryError
+                rb_memerror();
+            }
+        }
+
     private:        // 非公開メンバ
         ModeInfo _mode;     // 画像形式
         int32_t  _width;    // 横幅
@@ -20,7 +120,7 @@ namespace Rixmap {
         bool     _ready;    // 準備完了しているか
 
         // ピクセルデータ系
-        std::map<Channel, uint8_t**> _data;
+        Pixels _data;
         VALUE _palette;
 
     public:         // コンストラクタ
@@ -36,25 +136,42 @@ namespace Rixmap {
             this->init(mode, width, height);
         }
 
+        /**
+         * コピーコンストラクタ
+         */
+        ImageData(const ImageData& image) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil) {
+            this->init(image.getMode(), image._width, image._height);
+            this->_palette = image._palette;
+
+            // ピクセルの複製
+            const ChannelArray& channels = image._mode.getChannels();
+            for (auto it = channels.begin(); it != channels.end(); it++) {
+                Channel channel = *it;
+                uint8_t** dstPlane = this->_data.at(channel);
+                uint8_t** srcPlane = image._data.at(channel);
+                for (int32_t h = 0; h < image._height; h++) {
+                    for (int32_t w = 0; w < image._width; w++) {
+                        dstPlane[h][w] = srcPlane[h][w];
+                    }
+                }
+            }
+        }
+
+        /**
+         * ベース画像ののサイズを変更した新しい画像を作成する、部分コピーコンストラクタ.
+         * ピクセルデータは複製されません.
+         */
+        ImageData(const ImageData& image, int32_t width, int32_t height) : _mode(Mode::NONE), _width(0), _height(0), _ready(false), _palette(Qnil) {
+            this->init(image.getMode(), width, height);
+            this->_palette = image._palette;
+        }
+
         /**
          * デストラクタ
          */
         ~ImageData() {
-            // TODO ピクセルデータの解放処理
             if (this->_ready) {
-                for (auto it = this->_data.begin(); it != this->_data.end(); it++) {
-                    uint8_t** plane = it->second;
-                    if (plane != NULL) {
-                        for (int32_t h = 0; h < this->_height; h++) {
-                            if (plane[h] != NULL) {
-                                ruby_xfree(plane[h]);
-                            }
-                        }
-                        ruby_xfree(plane);
-                        it->second = NULL;
-                    }
-                }
-                this->_data.clear();
+                ImageData::DeallocatePixels(this->_data, this->_width, this->_height);
             }
         }
 
@@ -67,8 +184,8 @@ namespace Rixmap {
         /**
          * 画像形式情報を取得します.
          */
-        //inline ModeInfo& getModeInfo() { return this->_mode; }
         inline const ModeInfo& getModeInfo() const { return this->_mode; }
+        inline ModeInfo& getModeInfo() { return this->_mode; }
 
         /**
          * 横幅を取得します.
@@ -94,7 +211,7 @@ namespace Rixmap {
          * パレットオブジェクトの内部データポインタを返します.
          * パレットがnilの場合はNULLが返されます.
          */
-        inline const PaletteData* getPaletteData() const {
+        inline PaletteData* getPaletteData() const {
             if (NIL_P(this->_palette)) {
                 return NULL;
             } else {
@@ -130,10 +247,10 @@ namespace Rixmap {
          * 指定チャンネルデータを格納するデータポインタから取得します.
          * 対象チャンネルを持っていない場合はNULLになります.
          */
-        inline uint8_t** get(Channel channel) {
+        inline uint8_t** get(Channel channel) const {
             auto found = this->_data.find(channel);
             if (found != this->_data.end()) {
-                return this->_data[channel];
+                return this->_data.at(channel);
             } else {
                 return NULL;
             }
@@ -143,7 +260,7 @@ namespace Rixmap {
          * 指定チャンネルの指定行番号に対応するバイト列へのポインタから取得します.
          * 行番号が範囲外の場合か、非対応のチャンネルの場合はNULLになります.
          */
-        inline uint8_t* get(Channel channel, int32_t lineno) {
+        inline uint8_t* get(Channel channel, int32_t lineno) const {
             if (0 <= lineno && lineno < this->_height) {
                 uint8_t** plane = this->get(channel);
                 if (plane != NULL) {
@@ -159,7 +276,7 @@ namespace Rixmap {
          * Notice: 範囲外だったりチャンネル持ってないときは0になるので、
          *         実はバイトデータが0の時と判別できないんですよコレ
          */
-        inline uint8_t get(Channel channel, int32_t x, int32_t y) {
+        inline uint8_t get(Channel channel, int32_t x, int32_t y) const {
             if (0 <= x && x < this->_width && 0 <= y && y < this->_height) {
                 uint8_t** plane = this->get(channel);
                 if (plane != NULL) {
@@ -183,6 +300,51 @@ namespace Rixmap {
             return false;
         }
 
+        /**
+         * 指定した座標の色データを取得します.
+         */
+        inline Color fetch(int32_t x, int32_t y, bool strict = false) const {
+            if (0 <= x && x < this->_width && 0 <= y && y < this->_height) {
+                switch (this->_mode.getMode()) {
+                case Mode::INDEXED:
+                    {
+                        uint8_t off = this->get(Channel::PALETTE, x, y);
+                        return this->getPaletteData()->get(off);
+                    }
+                    break;
+
+                case Mode::GRAYSCALE:
+                case Mode::GRAYALPHA:
+                    {
+                        uint8_t l = this->get(Channel::LUMINANCE, x, y);
+                        return Color(l, l, l);
+                    }
+                    break;
+
+                case Mode::RGB:
+                case Mode::RGBA:
+                    {
+                        uint8_t r = this->get(Channel::RED,   x, y);
+                        uint8_t g = this->get(Channel::GREEN, x, y);
+                        uint8_t b = this->get(Channel::BLUE,  x, y);
+                        return Color(r, g, b);
+                    }
+                    break;
+
+                default:
+                    throw std::invalid_argument("unexpected image mode");
+                }
+            } else {
+                if (strict) {
+                    std::ostringstream err;
+                    err << "point [" << x << ", " << y << "] is out of image";
+                    throw std::out_of_range(err.str());
+                } else {
+                    return Color(0, 0, 0);
+                }
+            }
+        }
+
         /**
          * 画像データを初期化します.
          */
@@ -203,25 +365,11 @@ namespace Rixmap {
             // 解析用にモードを設置
             ModeInfo info(mode);
             const ChannelArray& channels = info.getChannels();
-            for (auto it = channels.begin(); it != channels.end(); it++) {
-                Channel channel = *it;
-                this->_data[channel] = NULL;
-
-                // 領域を確保
-                uint8_t** plane = ALLOC_N(uint8_t*, height);
-                std::memset(plane, 0, sizeof(uint8_t*) * height);
-                for (int32_t h = 0; h < height; h++) {
-                    plane[h] = ALLOC_N(uint8_t, width);
-                    if (channel == Channel::ALPHA) {
-                        std::memset(&(plane[h][0]), 255, sizeof(uint8_t) * width);
-                    } else {
-                        std::memset(&(plane[h][0]), 0, sizeof(uint8_t) * width);
-                    }
-                }
 
-                this->_data[channel] = plane;
-            }
+            // ピクセルデータを確保
+            ImageData::AllocatePixels(this->_data, channels, width, height, true);
 
+            // その他プロパティを初期化
             this->_mode   = info;
             this->_width  = width;
             this->_height = height;
@@ -236,6 +384,62 @@ 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;
+        }
+
+        /**
+         * 画像の反転処理を行います.
+         */
+        void flip(FlipDirection direction) {
+            const ChannelArray& channels = this->_mode.getChannels();
+
+            // まずは横方向に反転
+            switch (direction) {
+            case FlipDirection::HORIZONTAL:
+            case FlipDirection::DIAGONAL:
+                for (auto it = channels.begin(); it != channels.end(); it++) {
+                    uint8_t** plane = this->get(*it);
+                    if (plane == NULL) {
+                        continue;
+                    }
+                    for (int32_t h = 0; h < this->_height; h++) {
+                        std::reverse(&(plane[h][0]), &(plane[h][this->_width]));
+                    }
+                }
+                break;
+
+            default:
+                // DO NOTHING
+                // (警告抑制)
+                break;
+            }
+
+            // 次に縦方向に反転
+            switch (direction) {
+            case FlipDirection::VERTICAL:
+            case FlipDirection::DIAGONAL:
+                for (auto it = channels.begin(); it != channels.end(); it++) {
+                    uint8_t** plane = this->get(*it);
+                    if (plane == NULL) {
+                        continue;
+                    }
+                    std::reverse(&(plane[0]), &(plane[this->_height]));
+                }
+                break;
+
+            default:
+                // DO NOTHING
+                // (警告抑制)
+                break;
+            }
+        }
+
     public:         // 演算子オーバーロード
         bool operator==(const ImageData& data) const {
             if (this->_ready && data._ready && (this->_mode == data._mode) && (this->_width == data._width) && (this->_height == data._height)) {
@@ -267,6 +471,47 @@ namespace Rixmap {
             }
         }
         bool operator!=(const ImageData& data) const { return !(*this == data); }
+
+        /**
+         * 代入演算子実装
+         */
+        ImageData& operator=(const ImageData& base) {
+            // チャンネルリスト
+            const ChannelArray& channels = base._mode.getChannels();
+
+            // ピクセルデータは新しく確保 (破壊防止)
+            std::map<Channel, uint8_t**> pixels;
+            ImageData::AllocatePixels(pixels, channels, base._width, base._height, false);
+
+            // ピクセルデータを複製
+            for (auto it = channels.begin(); it != channels.end(); it++) {
+                Channel channel = *it;
+                uint8_t** dstPlane = pixels.at(channel);
+                uint8_t** srcPlane = base._data.at(channel);
+                for (int32_t h = 0; h < base._height; h++) {
+                    std::memcpy(&(dstPlane[h][0]), &(srcPlane[h][0]), sizeof(uint8_t) * base._width);
+                }
+            }
+
+            // ピクセルを移動
+            // TODO swapとか使ってるけど危ないなら複製する方向にしよう
+            ImageData::DeallocatePixels(this->_data, this->_width, this->_height);
+            this->_data.swap(pixels);
+
+            // 基本情報を複製
+            this->_mode   = base._mode;
+            this->_width  = base._width;
+            this->_height = base._height;
+
+            // パレットは参照
+            this->_palette = base._palette;
+
+            // 準備完了
+            this->_ready = true;
+
+            // 戻る
+            return *this;
+        }
     };
 
     /**
@@ -367,5 +612,5 @@ namespace Rixmap {
 
 
 //============================================================================//
-// $Id: image.hxx,v c10e98a1e0fa 2014/04/20 08:17:37 chikuchikugonzalez $
+// $Id: image.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmap/interpolator.hxx

@@ -0,0 +1,226 @@
+// -*- coding: utf-8 -*-
+/**
+ * 変形処理用画素補間処理実装
+ */
+#pragma once
+#include <array>
+#include "common.hxx"
+#include "image.hxx"
+
+namespace Rixmap {
+    /**
+     * 補間処理方法.
+     */
+    enum class Interpolation : int {
+        NONE     = 0x00,
+        //NEAREST  = 0x01,        // 最近傍 (Nearest-Neighbor)
+        //BILINEAR = 0x02,        // バイリニア (双一次)
+        BICUBIC  = 0x03,        // バイキュービック (双三次)
+    };
+
+    /**
+     * 画素補間処理ベースクラス.
+     * 補間処理自体はピクセルベースで実行されます.
+     */
+    class Interpolator {
+    protected:
+        ImageData* _base;           // 元画像
+        ModeInfo*  _mode;           // 元画像形式
+
+        // 補間処理キャッシュ
+        std::map<Channel, uint8_t> _pixel;
+
+    public:
+        Interpolator(ImageData* base) : _base(base), _mode(&(_base->getModeInfo())) {
+            this->reset();
+        }
+
+        virtual ~Interpolator() {}
+
+    public:     // 補間処理用メソッド
+        /**
+         * 変換後に必要になる画像形式
+         */
+        virtual Mode getPreferredMode() { return this->_mode->getMode(); }
+
+        /**
+         * 補間処理を実行します.
+         */
+        virtual void calculate(double x, double y) = 0;
+
+        /**
+         * 計算済みピクセルデータを取得します.
+         */
+        virtual uint8_t get(Channel channel) { return this->_pixel.at(channel); }
+
+    protected:      // 非公開メンバ
+        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;
+                }
+            }
+        }
+    };
+
+    /**
+     * なにもしない補間処理実装
+     */
+    class NOPInterpolator : public Interpolator {
+    public:
+        NOPInterpolator(ImageData* base) : Interpolator(base) {}
+
+    public:
+        virtual void calculate(double x, double y) override {
+            this->reset();
+            int32_t dx = static_cast<int32_t>(x);
+            int32_t dy = static_cast<int32_t>(y);
+            if (this->_base->isInside(dx, dy)) {
+                const ChannelArray& channels = this->_mode->getChannels();
+                for (auto it = channels.begin(); it != channels.end(); it++) {
+                    Channel channel = *it;
+                    this->_pixel[channel] = this->_base->get(channel, dx, dy);
+                }
+            }
+        }
+    };
+
+    /**
+     * バイキュービック法による補間処理実装
+     */
+    class BicubicInterpolator : public Interpolator {
+    protected:
+        double _factor;         // sinc関数パラメータ
+        ModeInfo _preferredMode;    // 推奨画像形式
+
+    public:
+        BicubicInterpolator(ImageData* base, double factor = -1) : Interpolator(base), _factor(factor) {
+            switch (this->_mode->getMode()) {
+            case Mode::RGB:
+            case Mode::RGBA:
+                this->_preferredMode = ModeInfo(this->_mode->getMode());
+                break;
+
+            default:
+                this->_preferredMode = ModeInfo(Mode::RGB);
+            }
+        }
+
+    protected:      // 非公開メンバ関数
+        /**
+         * sinc関数 (http://ja.wikipedia.org/wiki/Sinc%E9%96%A2%E6%95%B0) の近似式
+         */
+        static inline double sinc(double t, double f = -1) {
+            using namespace std;    // powがmingw x86_64版rubyだとstd名前空間付きで使えないため
+            double t0 = abs(t);
+            if (t0 > 2) {
+                return 0.0;
+            } else if (t0 <= 1.0) {
+                double n0 = (f + 2) * pow(t0, 3.0);
+                double n1 = (f + 3) * pow(t0, 2.0);
+                return n0 - n1 + 1;
+            } else {
+                double n0 = f * pow(t0, 3.0);
+                double n1 = (5 * f) * pow(t0, 2.0);
+                double n2 = (8 * f) * t0;
+                double n3 = 4 * f;
+                return n0 - n1 + n2 - n3;
+            }
+        }
+
+    public:
+        virtual Mode getPreferredMode() override {
+            return this->_preferredMode.getMode();
+        }
+
+        virtual void calculate(double x, double y) override {
+            static int32_t sx[4];       // 周辺座標点 (16点)
+            static int32_t sy[4];
+            static double dx[4];        // 周辺座標の比率
+            static double dy[4];
+            static double hx[4];        // sinc関数キャッシュ
+            static double hy[4];
+            static std::map<Channel, std::array<std::array<uint8_t, 4>, 4>> pixels;
+
+            // ピクセルデータを初期化
+            this->reset();
+
+            // 周辺座標設定
+            sx[1] = lround(std::floor(x));  // [x]
+            sx[0] = sx[1] - 1;              // [x] - 1
+            sx[2] = sx[1] + 1;              // [x] + 1
+            sx[3] = sx[1] + 2;              // [x] + 2
+            sy[1] = lround(std::floor(y));  // [y]
+            sy[0] = sy[1] - 1;              // [y] - 1
+            sy[2] = sy[1] + 1;              // [y] + 1
+            sy[3] = sy[1] + 2;              // [y] + 2
+
+            // 距離を計算
+            dx[0] = 1 + x - sx[1];
+            dx[1] =     x - sx[1];
+            dx[2] = sx[1] + 1 - x;
+            dx[3] = sx[1] + 2 - x;
+            dy[0] = 1 + y - sy[1];
+            dy[1] =     y - sy[1];
+            dy[2] = sy[1] + 1 - y;
+            dy[3] = sy[1] + 2 - y;
+
+            // sinc関数による重み計算
+            for (int i = 0; i < 4; i++) {
+                hx[i] = BicubicInterpolator::sinc(dx[i], this->_factor);
+                hy[i] = BicubicInterpolator::sinc(dy[i], this->_factor);
+            }
+
+            // 周辺ピクセルデータ
+            for (int32_t h = 0; h < 4; h++) {
+                for (int32_t w = 0; w < 4; w++) {
+                    Color col = this->_base->fetch(sx[w], sy[h]);
+                    pixels[Channel::RED  ][h][w] = col.getRed();
+                    pixels[Channel::GREEN][h][w] = col.getGreen();
+                    pixels[Channel::BLUE ][h][w] = col.getBlue();
+                    pixels[Channel::ALPHA][h][w] = col.getAlpha();
+                }
+            }
+
+            // 画素値を計算
+            double matrix[4];
+            const ChannelArray& channels = this->_preferredMode.getChannels();
+            for (auto it = channels.begin(); it != channels.end(); it++) {
+                Channel channel = *it;
+                for (int m = 0; m < 4; m++) {
+                    matrix[m] = 0.0;
+                    for (int h = 0; h < 4; h++) {
+                        matrix[m] += hy[h] * pixels[channel][h][m];
+                    }
+                }
+                double v = 0.0;
+                for (int w = 0; w < 4; w++) {
+                    v += matrix[w] * hx[w];
+                }
+                this->_pixel[channel] = ROUND2BYTE(lround(v));
+            }
+        }
+
+    protected:      // 非公開メンバ
+        virtual void reset() {
+            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;
+                }
+            }
+        }
+    };
+}
+
+
+//============================================================================//
+// $Id: interpolator.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmap/palette.hxx

@@ -113,7 +113,19 @@ namespace Rixmap {
                 throw std::out_of_range(msg.str());
             }
         }
-        inline const Color& get(size_t offset) const { return this->get(offset); }
+
+        /**
+         * const用実装.
+         */
+        inline const Color& get(size_t offset) const {
+            if (/* 0 <= offset && */ offset <= this->_colors.size()) {
+                return this->_colors[offset];
+            } else {
+                std::ostringstream msg;
+                msg << "offsetis out of range: " << offset << " for 0.." << this->_colors.size();
+                throw std::out_of_range(msg.str());
+            }
+        }
 
         /**
          * 指定したオフセットのカラーデータを変更します.
@@ -216,5 +228,5 @@ namespace Rixmap {
 
 
 //============================================================================//
-// $Id: palette.hxx,v 5b9a0968eca5 2014/04/20 13:37:36 chikuchikugonzalez $
+// $Id: palette.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: