rixmap 0.1.0

data/src/rixmapcore.cxx

@@ -0,0 +1,3209 @@
+// -*- coding: utf-8 -*-
+/**
+ * Rixmapコア実装.
+ */
+#include "rixmapcore.hxx"
+
+//----------------------------------------------------------------------------//
+// オブジェクトプール実装
+//----------------------------------------------------------------------------//
+/**
+ * 画像形式オブジェクトプール
+ */
+class RixmapModePool {/*{{{*/
+private:        // 非公開クラスメンバ
+    static std::map<Rixmap::Mode, VALUE> _pool;
+
+public:         // 公開クラスメンバ
+    /**
+     * オブジェクトプールから取得します.
+     */
+    static inline VALUE Get(Rixmap::Mode mode) {
+        auto found = _pool.find(mode);
+        if (found != _pool.end()) {
+            return found->second;
+        } else {
+            volatile VALUE instance = rb_obj_alloc(cRixmapMode);
+            Rixmap::ModeData* data = rixmap_unwrap<Rixmap::ModeData>(instance);
+            data->setMode(mode);
+
+            rb_gc_register_mark_object(instance);
+            _pool[mode] = instance;
+
+            return instance;
+        }
+    }
+
+    /**
+     * オブジェクトプールからオブジェクトを削除します.
+     */
+    static inline void Remove(Rixmap::Mode mode) {
+        auto found = _pool.find(mode);
+        if (found != _pool.end()) {
+            _pool.erase(found);
+        }
+    }
+
+private:        // 非公開コンストラクタ
+    RixmapModePool() {}
+
+public:         // 仮想デストラクタ
+    virtual ~RixmapModePool() = 0;
+};/*}}}*/
+
+/**
+ * カラーオブジェクトプール
+ */
+class RixmapColorPool {/*{{{*/
+private:        // 非公開クラスメンバ
+    static std::map<uint32_t, VALUE> _pool;
+
+public:         // 公開クラスメンバ
+    /**
+     * オブジェクトプールから取得します.
+     */
+    static inline VALUE Get(const Rixmap::Color& color) {
+        uint32_t value = color.getValue();
+        auto found = _pool.find(value);
+        if (found != _pool.end()) {
+            return found->second;
+        } else {
+            volatile VALUE instance = rb_obj_alloc(cRixmapColor);
+            Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(instance);
+            *data = color;
+            rb_gc_register_mark_object(instance);
+            _pool[value] = instance;
+            return instance;
+        }
+    }
+
+    /**
+     * オブジェクトプールから削除します.
+     */
+    static inline void Remove(const Rixmap::Color& color) {
+        uint32_t value = color.getValue();
+        auto found = _pool.find(value);
+        if (found != _pool.end()) {
+            _pool.erase(found);
+        }
+    }
+
+private:        // 非公開コンストラクタ
+    RixmapColorPool() {}
+
+public:         // 仮想デストラクタ
+    virtual ~RixmapColorPool() = 0;
+};/*}}}*/
+
+// プール実体定義
+std::map<Rixmap::Mode, VALUE> RixmapModePool::_pool;
+std::map<uint32_t, VALUE>     RixmapColorPool::_pool;
+
+//----------------------------------------------------------------------------//
+// オブジェクト実体定義
+//----------------------------------------------------------------------------//
+VALUE mRixmap           = Qnil;
+VALUE cRixmapBinary     = Qnil;
+VALUE cRixmapMode       = Qnil;
+VALUE cRixmapColor      = Qnil;
+VALUE cRixmapPalette    = Qnil;
+VALUE cRixmapImage      = Qnil;
+VALUE cRixmapImageLine  = Qnil;
+
+//----------------------------------------------------------------------------//
+// ヘルパー関数
+//----------------------------------------------------------------------------//
+namespace RixmapHelper {/*{{{*/
+    /**
+     * 指定色数のパレットを作成します.
+     */
+    static VALUE CreatePalette(size_t size = 256) {
+        VALUE args[1] = {
+            ULONG2NUM(size)
+        };
+        return rb_class_new_instance(1, args, cRixmapPalette);
+    }
+
+    /**
+     * スキャンラインオブジェクトを作成します.
+     */
+    static VALUE CreateImageLine(VALUE image, int32_t lineno) {
+        VALUE args[2] = {
+            image,
+            LONG2NUM(lineno)
+        };
+        return rb_class_new_instance(2, args, cRixmapImageLine);
+    }
+
+    /**
+     * ピクセルを取得します.
+     */
+    static VALUE GetPixel(Rixmap::ImageData* image, int32_t xpos, int32_t ypos) {
+        // TODO imageがNULLの時対策
+
+        // 範囲チェック
+        if (image->isOutside(xpos, ypos)) {
+            // 範囲外はnil
+            return Qnil;
+        }
+
+        const Rixmap::ChannelArray& channels = image->getModeInfo().getChannels();
+        size_t nchannel = channels.size();
+
+        if (nchannel == 0) {
+            // ない場合はnil
+            return Qnil;
+        } else if (nchannel == 1) {
+            // 一つの場合は整数値で返す
+            Rixmap::Channel channel = channels.at(0);
+            uint8_t value = image->get(channel, xpos, ypos);
+            return INT2FIX(value);
+        } else {
+            // それ以外は配列で返す
+            VALUE pixel = rb_ary_new2(nchannel);
+            for (size_t i = 0; i < nchannel; i++) {
+                Rixmap::Channel channel = channels.at(i);
+                uint8_t value = image->get(channel, xpos, ypos);
+                rb_ary_store(pixel, i, INT2FIX(value));
+            }
+            return pixel;
+        }
+    }
+
+    /**
+     * ピクセルを更新します.
+     */
+    static void UpdatePixel(Rixmap::ImageData* image, int32_t xpos, int32_t ypos, VALUE pixel) {
+        // TODO imageがNULLの時対策
+        const Rixmap::ModeInfo& mode = image->getModeInfo();
+
+        // 範囲チェック
+        if (image->isInside(xpos, ypos)) {
+            if (RB_TYPE_P(pixel, T_ARRAY)) {
+                // 配列
+                const Rixmap::ChannelArray& channels = mode.getChannels();
+                for (size_t i = 0; i < channels.size(); i++) {
+                    Rixmap::Channel channel = channels.at(i);
+                    VALUE objItem = rb_ary_entry(pixel, i);
+                    if (!NIL_P(objItem)) {
+                        int value = ROUND2BYTE(NUM2INT(rb_Integer(objItem)));
+                        image->set(channel, xpos, ypos, static_cast<uint8_t>(value));
+                    }
+                }
+            } else if (RB_TYPE_P(pixel, T_FIXNUM) || RB_TYPE_P(pixel, T_FLOAT)) {
+            //} else if (RB_TYPE_P(pixel, T_FIXNUM) /* || RB_TYPE_P(pixel, T_BIGNUM) */) {
+                // 数値
+                int value = ROUND2BYTE(NUM2INT(rb_Integer(pixel)));
+                const Rixmap::ChannelArray& channels = mode.getChannels();
+                for (auto it = channels.begin(); it != channels.end(); it++) {
+                    image->set(*it, xpos, ypos, static_cast<uint8_t>(value));
+                }
+            } else if (RTEST(rb_obj_is_kind_of(pixel, cRixmapColor))) {
+                // カラーオブジェクト
+                Rixmap::ColorData* col = rixmap_unwrap<Rixmap::ColorData>(pixel);
+                switch (mode.getType()) {
+                case Rixmap::MODE_TYPE_INDEXED:
+                    {
+                        const Rixmap::PaletteData* pal = image->getPaletteData();
+                        size_t off = 0;
+                        if (pal == NULL) {
+                            off = 0;
+                        } else {
+                            off = pal->closest(col->getColor());
+                        }
+                        image->set(Rixmap::Channel::PALETTE, xpos, ypos, static_cast<uint8_t>(off));
+                    }
+                    break;
+
+                case Rixmap::MODE_TYPE_GRAYSCALE:
+                    image->set(Rixmap::Channel::LUMINANCE, xpos, ypos, col->getLuminance());
+                    break;
+
+                case Rixmap::MODE_TYPE_RGB:
+                    image->set(Rixmap::Channel::RED,   xpos, ypos, col->getRed());
+                    image->set(Rixmap::Channel::GREEN, xpos, ypos, col->getGreen());
+                    image->set(Rixmap::Channel::BLUE,  xpos, ypos, col->getBlue());
+                    break;
+
+                default:
+                    // DO NOTHING
+                    break;
+                }
+
+                if (mode.hasAlpha()) {
+                    image->set(Rixmap::Channel::ALPHA, xpos, ypos, col->getAlpha());
+                }
+            } else {
+                // 非対応(｀・ω・´)
+                rb_raise(rb_eArgError, "unexpected pixel data type: %s", rb_obj_classname(pixel));
+            }
+        } else {
+            // 範囲外は何もしないお
+            rb_warning("point (%d, %d) is outside of image", xpos, ypos);
+        }
+    }
+
+    /**
+     * スキャンラインから指定したチャンネルのバンドデータを取得します.
+     */
+    static VALUE GetBand(Rixmap::ImageLineData* line, Rixmap::Channel channel) {
+        if (line->isValid()) {
+            Rixmap::ImageData* parent = line->getImageData();
+            const Rixmap::ModeInfo& mode = parent->getModeInfo();
+            if (mode.has(channel)) {
+                int32_t  length = line->getLength();
+                int32_t  lineno = line->getLineNumber();
+                uint8_t* band   = parent->get(channel, lineno);
+                VALUE bytes = rb_ary_new2(length);
+                for (int32_t i = 0; i < length; i++) {
+                    rb_ary_store(bytes, i, INT2FIX(band[i]));
+                }
+                return bytes;
+            } else {
+                return Qnil;
+            }
+        } else {
+            return Qnil;
+        }
+    }
+
+    /**
+     * スキャンライン内の指定チャンネルデータを更新します.
+     */
+    static bool UpdateBand(Rixmap::ImageLineData* line, Rixmap::Channel channel, VALUE argBand) {
+        if (line->isValid()) {
+            Rixmap::ImageData* parent = line->getImageData();
+            const Rixmap::ModeInfo& mode = parent->getModeInfo();
+            int32_t lineLength = line->getLength();
+            int32_t lineno     = line->getLineNumber();
+            if (mode.has(channel)) {
+                // 型ごとにチェックして処理
+                if (RB_TYPE_P(argBand, T_ARRAY)) {
+                    // 配列の場合はいったん全要素を調べる
+                    long aryLength = RARRAY_LEN(argBand);
+                    int32_t length = (aryLength < lineLength) ? aryLength : lineLength;
+                    for (int32_t i = 0; i < length; i++) {
+                        VALUE item = rb_ary_entry(argBand, i);
+                        if (!RB_TYPE_P(item, T_FIXNUM)) {
+                            rb_raise(rb_eArgError, "unexpected band data type in line data: %s", rb_obj_classname(item));
+                        }
+                    }
+
+                    // OK
+                    for (int32_t i = 0; i < length; i++) {
+                        VALUE item = rb_ary_entry(argBand, i);
+                        int byte = FIX2INT(item);
+                        parent->set(channel, i, lineno, static_cast<uint8_t>(byte));
+                    }
+                } else {
+                    VALUE objBand = rb_String(argBand);
+                    long  nbyte = RSTRING_LEN(objBand);
+                    char* bytes = StringValuePtr(objBand);
+                    int32_t length = (nbyte < lineLength) ? nbyte : lineLength;
+                    for (int32_t i = 0; i < length; i++) {
+                        parent->set(channel, i, lineno, static_cast<uint8_t>(bytes[i]));
+                    }
+                }
+                return true;
+            } else {
+                rb_warning("channel %c is not supported of this line", static_cast<char>(channel));
+                return false;
+            }
+        } else {
+            rb_warning("line is not valid");
+            return false;
+        }
+    }
+}/*}}}*/
+
+//----------------------------------------------------------------------------//
+// ライブラリ実装
+//----------------------------------------------------------------------------//
+/* Rixmap::Binary {{{ */
+static void Binary_Free(Rixmap::BinaryData* data) {
+    rixmap_xdelete(data);
+}
+
+static VALUE Binary_Alloc(VALUE klass) {
+    Rixmap::BinaryData* data = rixmap_xnew<Rixmap::BinaryData>();
+    return Data_Wrap_Struct(klass, RIXMAP_DEFAULT_MARK, Binary_Free, data);
+}
+
+/**
+ * バイナリ配列オブジェクトを初期化します
+ *
+ * @overload initialize(size = 0, value = 0)
+ *   指定したサイズのバイナリ配列を作成します. 配列内はすべて `value` で初期化されます.
+ *
+ *   @param [Integer] size  バイナリ配列サイズ
+ *   @param [Integer] value 初期値
+ *   @return [void]
+ *
+ * @overload initialize(ary)
+ *   指定された配列を複製した、新しいバイナリ配列として初期化します.
+ *
+ *   @param [Array<Integer>,Rixmap::Binary] ary 元の配列
+ *   @return [void]
+ *
+ * @overload initialize(bytes)
+ *   指定されたバイナリ文字列を元に、バイナリ配列を初期化します.
+ *
+ *   @param [String] bytes 元にする文字列
+ *   @return [void]
+ */
+static VALUE Binary_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE arg0, arg1;
+    rb_scan_args(argc, argv, "02", &arg0, &arg1);
+
+    // 自分ポインタ
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    _this->clear();     // 何も入ってないと思うけど念のため
+
+    // 型別に初期化処理を分岐
+    if (!NIL_P(arg0)) {
+        // 最初の引数有
+        if (RB_TYPE_P(arg0, T_ARRAY) || rb_respond_to(arg0, rb_intern("to_ary"))) {
+            // 配列型
+            VALUE aryItems = rb_Array(arg0);
+            long nitem = RARRAY_LEN(aryItems);
+            for (long i = 0; i < nitem; i++) {
+                VALUE item = rb_Integer(rb_ary_entry(aryItems, i));
+                uint8_t value = static_cast<uint8_t>(NUM2INT(item));
+                _this->push_back(value);
+            }
+        } else if (RB_TYPE_P(arg0, T_STRING) || rb_respond_to(arg0, rb_intern("to_str"))) {
+            // 文字列型
+            VALUE strItems = rb_String(arg0);
+            long nitem = RSTRING_LEN(strItems);
+            const char* items = StringValuePtr(strItems);
+            _this->insert(_this->end(), &(items[0]), &(items[nitem]));
+        } else {
+            // サイズ指定っぽい
+            size_t size = NUM2ULONG(rb_Integer(arg0));
+
+            // リサイズ
+            _this->resize(size);
+
+            // 第二引数ある？
+            if (!NIL_P(arg1)) {
+                // 初期値
+                uint8_t value = static_cast<uint8_t>(NUM2INT(rb_Integer(arg1)));
+                for (auto it = _this->begin(); it != _this->end(); it++) {
+                    *it = value;
+                }
+            }
+        }
+    }
+
+    return self;
+}
+
+/**
+ * バイナリ配列の複製を初期化します.
+ *
+ * @param [Object] obj 複製元
+ * @return [void]
+ * @see Object#clone
+ * @see Object#dup
+ */
+static VALUE Binary_initializeCopy(VALUE self, VALUE argObject) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    Rixmap::BinaryData* _that = rixmap_unwrap<Rixmap::BinaryData>(argObject);
+
+    // 自分を消去して追加
+    _this->clear();
+    _this->insert(_this->end(), _that->begin(), _that->end());
+
+    return self;
+}
+
+/**
+ * バイナリ配列の内容を`times`回繰り返した新しいバイナリ配列を返します.
+ *
+ * @param [Integer] times 繰り返す回数
+ * @return [Rixmap::Binary] 繰り返されたバイナリ配列
+ * @see Array#*
+ */
+static VALUE Binary_operatorMul(VALUE self, VALUE argTimes) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    long times = NUM2LONG(rb_Integer(argTimes));
+
+    if (times < 0) {
+        rb_raise(rb_eArgError, "negative repeat times is not supported: %ld", times);
+    }
+
+    // 新しいバイナリ配列を確保
+    VALUE objResult = rb_class_new_instance(0, NULL, cRixmapBinary);
+    Rixmap::BinaryData* _result = rixmap_unwrap<Rixmap::BinaryData>(objResult);
+
+    // 指定回数だけ複製
+    for (long i = 0; i < times; i++) {
+        _result->insert(_result->end(), _this->begin(), _this->end());
+    }
+
+    // 戻る
+    return objResult;
+}
+
+/**
+ * バイナリ配列の末尾に別の配列を連結した新しいバイナリ配列を返します.
+ *
+ * @param [Array,String,Rixmap::Binary] other 連結する配列
+ * @return [Rixmap::Binary] 連結後の新しいバイナリ配列
+ * @raise TypeError `other` が配列ではなかった場合
+ * @see Array#+
+ */
+static VALUE Binary_operatorAdd(VALUE self, VALUE argOther) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+
+    // 返却用オブジェクトを確保
+    VALUE objResult = rb_class_new_instance(0, NULL, cRixmapBinary);
+    Rixmap::BinaryData* _result = rixmap_unwrap<Rixmap::BinaryData>(objResult);
+
+    // 型を判定
+    if (RTEST(rb_obj_is_kind_of(argOther, cRixmapBinary))) {
+        Rixmap::BinaryData* _other = rixmap_unwrap<Rixmap::BinaryData>(argOther);
+        _result->insert(_result->end(), _this->begin(), _this->end());
+        _result->insert(_result->end(), _other->begin(), _other->end());
+    } else if (RB_TYPE_P(argOther, T_ARRAY) || rb_respond_to(argOther, rb_intern("to_ary"))) {
+        VALUE aryItems = rb_Array(argOther);
+        long nitem = RARRAY_LEN(aryItems);
+        std::vector<uint8_t> items;
+        for (long i = 0; i < nitem; i++) {
+            int item = NUM2INT(rb_ary_entry(aryItems, i));
+            items.push_back(static_cast<uint8_t>(item));
+        }
+        _result->insert(_result->end(), _this->begin(), _this->end());
+        _result->insert(_result->end(), items.begin(), items.end());
+    } else if (RB_TYPE_P(argOther, T_STRING) || rb_respond_to(argOther, rb_intern("to_str"))) {
+        VALUE strItems = rb_String(argOther);
+        long nitem = RSTRING_LEN(strItems);
+        const char* items = StringValuePtr(strItems);
+
+        _result->insert(_result->end(), _this->begin(), _this->end());
+        _result->insert(_result->end(), &(items[0]), &(items[nitem]));
+    } else {
+        rb_raise(rb_eTypeError, "unexpected object type: %s", rb_obj_classname(argOther));
+    }
+
+    return objResult;
+}
+
+/**
+ * バイナリ配列の末尾に整数値を追加します.
+ *
+ * @param [Integer] value 追加する整数値
+ * @return [Rixmap::Binary] selfを返します.
+ * @raise TypeError `value` が整数値でない場合
+ * @see Array#<<
+ */
+static VALUE Binary_operatorLShift(VALUE self, VALUE argValue) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    VALUE objValue = rb_Integer(argValue);
+    uint8_t value = static_cast<uint8_t>(NUM2INT(objValue));
+    _this->push_back(value);
+    return self;
+}
+
+/**
+ * バイナリ配列とほかの配列を比較します.
+ *
+ * @param [Object] other 比較する配列
+ * @return [Integer] 比較結果を数値で返します.
+ *                   - 負数の場合 ==> `self`が`other`より小さい
+ *                   - `0`の場合  ==> `self`と`other`が等しい
+ *                   - 正数の場合 ==> `self`が`other`より大きい
+ *                   - `nil`の場合 == > `other`が配列でない
+ * @see Array#<=>
+ */
+static VALUE Binary_operatorCompare(VALUE self, VALUE argOther) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+
+    // 型を判定
+    if (RTEST(rb_obj_is_kind_of(argOther, cRixmapBinary))) {
+        Rixmap::BinaryData* _other = rixmap_unwrap<Rixmap::BinaryData>(argOther);
+        size_t thisSize = _this->size();
+        size_t otherSize = _other->size();
+        size_t i = 0, j = 0;
+        for (; i < thisSize && j < otherSize; i++, j++) {
+            uint8_t lvalue = _this->at(i);
+            uint8_t rvalue = _other->at(i);
+            if (!(lvalue == rvalue)) {
+                return INT2FIX(static_cast<int>(lvalue) - static_cast<int>(rvalue));
+            }
+        }
+        if (i == thisSize && j == otherSize) {
+            return INT2FIX(0);
+        } else {
+            if (thisSize > otherSize) {
+                return INT2FIX(1);
+            } else {
+                return INT2FIX(-1);
+            }
+        }
+    } else if (RB_TYPE_P(argOther, T_ARRAY) || rb_respond_to(argOther, rb_intern("to_ary"))) {
+        VALUE aryItems = rb_Array(argOther);
+        size_t thisSize = _this->size();
+        size_t otherSize = RARRAY_LEN(aryItems);
+        size_t i = 0, j = 0;
+        for (; i < thisSize && j < otherSize; i++, j++) {
+            uint8_t lvalue = _this->at(i);
+            uint8_t rvalue = static_cast<uint8_t>(NUM2INT(rb_Integer(rb_ary_entry(aryItems, j))));
+            if (!(lvalue == rvalue)) {
+                return INT2FIX(static_cast<int>(lvalue) - static_cast<int>(rvalue));
+            }
+        }
+        if (i == thisSize && j == otherSize) {
+            return INT2FIX(0);
+        } else {
+            if (thisSize > otherSize) {
+                return INT2FIX(1);
+            } else {
+                return INT2FIX(-1);
+            }
+        }
+    } else if (RB_TYPE_P(argOther, T_STRING) || rb_respond_to(argOther, rb_intern("to_str"))) {
+        VALUE strItems = rb_String(argOther);
+        size_t thisSize = _this->size();
+        size_t otherSize = RSTRING_LEN(strItems);
+        const char* items = StringValuePtr(strItems);
+
+        size_t i = 0, j = 0;
+        for (; i < thisSize && j < otherSize; i++, j++) {
+            uint8_t lvalue = _this->at(i);
+            uint8_t rvalue = static_cast<uint8_t>(items[j]);
+            if (!(lvalue == rvalue)) {
+                return INT2FIX(static_cast<int>(lvalue) - static_cast<int>(rvalue));
+            }
+        }
+        if (i == thisSize && j == otherSize) {
+            return INT2FIX(0);
+        } else {
+            if (thisSize > otherSize) {
+                return INT2FIX(1);
+            } else {
+                return INT2FIX(-1);
+            }
+        }
+    } else {
+        return Qnil;
+    }
+}
+
+/**
+ * バイナリ配列とほかのオブジェクトとを比較し、同じバイナリ配列か銅貨を返します.
+ *
+ * @param [Rixmap::Binary] other 比較対象のバイナリ配列
+ */
+static VALUE Binary_operatorEquals(VALUE self, VALUE argOther) {
+    if (!RTEST(rb_obj_is_kind_of(argOther, cRixmapBinary))) {
+        return Qfalse;
+    }
+
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    Rixmap::BinaryData* _that = rixmap_unwrap<Rixmap::BinaryData>(argOther);
+
+    if (*_this == *_that) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * @overload [](offset)
+ *   指定オフセットのバイトデータを取得します.
+ *
+ *   オフセットが負数の場合は末尾からの逆向き指定と解釈します.
+ *   オフセットが範囲外の場合は`nil`を返します.
+ *
+ *   @param [Integer] offset 取得オフセット
+ *   @return [Integer,nil] バイトデータ
+ *
+ * @overload [](offset, length)
+ *   `offset`から最大で`length`個の要素を持った部分バイナリ配列を取得します.
+ *
+ *   オフセットが負数の場合は末尾からの逆向き指定と解釈します.
+ *   戻り値については以下のルールになっています.
+ *
+ *   - `length`が負数の場合は`nil`
+ *   - `offset`が範囲外の場合は`nil`
+ *   - ただし、`offset`が #length と同じだった場合は空配列
+ *
+ *   @param [Integer] offset 取得開始位置
+ *   @param [Integer] length 取得する最大要素数
+ *   @return [Rixmap::Binary,nil] 指定範囲のデータを含む部分配列
+ *
+ * @overload [](range)
+ *   指定された範囲オブジェクトの範囲内の要素からなる部分バイナリ配列を返します.
+ *
+ *   戻り値は以下のようになります.
+ *
+ *   - Range#first が配列の範囲外の場合は`nil`
+ *   - Range#first が Raneg#end より後ろの場合は空の配列
+ *
+ *   @param [Range] range 取得する範囲
+ *   @return [Rixmap::Binary] 指定範囲のバイナリ配列
+ *
+ * @see Array#[]
+ */
+static VALUE Binary_offsetGet(int argc, VALUE* argv, VALUE self) {
+    // 引数
+    VALUE argOffset, argLength;
+    rb_scan_args(argc, argv, "11", &argOffset, &argLength);
+
+    // 自分
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+
+    // 長さを long として取得しておく
+    // FIXME 危険('A`)
+    long dataLength = static_cast<long>(_this->size());
+
+    // 型別に処理
+    if (RTEST(rb_obj_is_kind_of(argOffset, rb_cRange))) {
+        // 範囲オブジェクトなので、まず先頭と末尾を取得する
+        VALUE objFirst, objLast;
+        int excludeLast = 0;
+        rb_range_values(argOffset, &objFirst, &objLast, &excludeLast);
+
+        // 整数値へ
+        long first = NUM2LONG(objFirst);
+        long last  = NUM2LONG(objLast);
+
+        // 負数の場合は、後ろからのオフセットへ変換
+        if (first < 0) {
+            first += dataLength;
+        }
+        if (last < 0) {
+            last += dataLength;
+        }
+
+        // 終端を含まない場合は縮める
+        if (excludeLast) {
+            last--;
+        }
+
+        // 範囲チェック
+        if (first < 0 || first > dataLength) {
+            // 先頭が範囲外
+            return Qnil;
+        } else {
+            VALUE objResult = rb_class_new_instance(0, NULL, cRixmapBinary);
+            Rixmap::BinaryData* _result = rixmap_unwrap<Rixmap::BinaryData>(objResult);
+            for (long i = first; i < last && i < dataLength; i++) {
+                _result->push_back(_this->at(i));
+            }
+            return objResult;
+        }
+    } else {
+        // 整数値 (にする)
+        VALUE numOffset = rb_Integer(argOffset);
+        long offset = NUM2LONG(numOffset);
+
+        // 負数の場合は後ろからのオフセットとしてずらす
+        if (offset < 0) {
+            offset += dataLength;
+        }
+
+        // 範囲外かどうか (1)
+        if (offset < 0) {
+            return Qnil;
+        }
+
+        if (NIL_P(argLength)) {
+            // オフセットのみ
+            if (offset < dataLength) {  // 範囲外チェック (2.1)
+                return INT2FIX(_this->at(offset));
+            } else {
+                return Qnil;
+            }
+        } else {
+            // 長さある
+
+            // 範囲外チェック (2.2)
+            if (offset > dataLength) {
+                // NOTE Arrayと挙動合わせたらこんなことになった
+                return Qnil;
+            }
+
+            VALUE numLength = rb_Integer(argLength);
+            long length = NUM2LONG(numLength);
+
+            // 戻り値用
+            VALUE objResult = rb_class_new_instance(0, NULL, cRixmapBinary);
+            Rixmap::BinaryData* _result = rixmap_unwrap<Rixmap::BinaryData>(objResult);
+
+            // 追加
+            for (long i = 0, j = offset; i < length && j < dataLength; i++, j++) {
+                _result->push_back(_this->at(j));
+            }
+
+            return objResult;
+        }
+    }
+}
+
+/**
+ * @overload []=(offset, value)
+ *   指定位置のバイトデータを `value` に設定します.
+ *
+ *   `offset` が #length より後ろだった場合は配列自体を拡張します.
+ *
+ *   @param [Integer] offset 設定位置
+ *   @param [Integer] value  設定するバイトデータ
+ *   @return [void]
+ *
+ * @overload []=(offset, length, values)
+ *   `offset`から`length`個の要素を`values`で置き換えます.
+ *
+ *   `values`は配列または配列に変換できる値であり、それ以外は要素数が1の配列として扱われます.
+ *   また、`length`が0の場合は`offset`の前に`values`を挿入します.
+ *
+ *   @param [Integer] offset 開始オフセット
+ *   @param [Integer] length 置き換える長さ
+ *   @param [Array,Rixmap::Binary] values 置き換える値
+ *   @return [void]
+ *
+ * @overload []=(range, values)
+ *   指定範囲を`values`で置き換えます.
+ *
+ *   @param [Range] range 置き換える範囲
+ *   @param [Array,Rixmap::Binary] values 置き換える値
+ *   @return [void]
+ *
+ * @see Array#[]=
+ */
+static VALUE Binary_offsetSet(int argc, VALUE* argv, VALUE self) {
+    // 引数取得
+    VALUE arg0, arg1, arg2; // arg1 or arg2 が設定する値
+    rb_scan_args(argc, argv, "21", &arg0, &arg1, &arg2);
+
+    // 自分情報
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    long dataLength = static_cast<long>(_this->size());
+
+    // 更新情報
+    long start = -1;
+    long count = -1;
+    VALUE objValues = Qnil;
+
+    // 型チェック (Rangeかそれ以外か)
+    if (RTEST(rb_obj_is_kind_of(arg0, rb_cRange))) {
+        // Range (arg1が値)
+        objValues = arg1;
+
+        // 範囲オブジェクトを展開
+        VALUE objFirst = Qnil, objLast = Qnil;
+        int excludeLast = 0;
+        rb_range_values(arg0, &objFirst, &objLast, &excludeLast);
+
+        // Ruby Obj -> C Type
+        long first = NUM2LONG(objFirst);
+        long last  = NUM2LONG(objLast);
+        if (first < 0) {
+            first += dataLength;
+
+            // 範囲外チェック
+            if (first < 0) {
+                // NOTE Arrayと挙動合わせた
+                VALUE strRange = rb_inspect(arg0);
+                rb_raise(rb_eRangeError, "%s is out of range", StringValueCStr(strRange));
+            }
+        }
+        if (last < 0) {
+            last += dataLength;
+        }
+        if (excludeLast) {
+            last--;
+        }
+
+        // 範囲
+        start = first;
+        count = (last - start) + 1;
+    } else {
+        // それ以外
+        VALUE objOffset = rb_Integer(arg0);
+        long offset = NUM2LONG(objOffset);
+        if (offset < 0) {
+            // 範囲外チェック
+            // NOTE Arrayと挙動合わせた
+            if ((offset + dataLength) < 0) {
+                rb_raise(rb_eIndexError, "index %ld too small for array; minimum: -%ld", offset, dataLength);
+            }
+            offset += dataLength;
+        }
+        start = offset;
+
+        // 第2引数と第3引数の関係を処理
+        if (NIL_P(arg2)) {
+            // 第3引数なし => arg1がvalue
+            objValues = arg1;
+            count     = 1;      // 長さ1
+        } else {
+            // 第3引数あり => arg2がvalue
+            objValues = arg2;
+            count     = NUM2LONG(rb_Integer(arg1));
+        }
+    }
+
+    // 値チェック
+    if (NIL_P(objValues)) {
+        rb_raise(rb_eArgError, "unexpected value type: %s", rb_obj_classname(objValues));
+    }
+
+    /* 以下変更処理 */
+    // 値をC配列へ
+    std::deque<uint8_t> input;
+    if (RTEST(rb_obj_is_kind_of(objValues, cRixmapBinary))) {
+        // Rixmap::Binary
+        Rixmap::BinaryData* values = rixmap_unwrap<Rixmap::BinaryData>(objValues);
+        input.insert(input.end(), values->begin(), values->end());
+    } else if (RB_TYPE_P(objValues, T_ARRAY) || rb_respond_to(objValues, rb_intern("to_ary"))) {
+        // Ruby配列
+        VALUE aryValues = rb_Array(objValues);
+        long aryLength = RARRAY_LEN(aryValues);
+        for (long i = 0; i < aryLength; i++) {
+            VALUE aryItem = rb_Integer(rb_ary_entry(aryValues, i));
+            input.push_back(static_cast<uint8_t>(NUM2INT(aryItem)));
+        }
+    } else if (RB_TYPE_P(objValues, T_STRING) || rb_respond_to(objValues, rb_intern("to_str"))) {
+        // Ruby文字列
+        VALUE strValues = rb_String(objValues);
+        long strLength = RSTRING_LEN(strValues);
+        const char* strData = StringValuePtr(strValues);
+        input.insert(input.end(), &(strData[0]), &(strData[strLength]));
+    } else {
+        // その他. 数値変換を試す
+        int value = NUM2INT(rb_Integer(objValues));
+        input.push_back(static_cast<uint8_t>(value));
+    }
+
+    // 始点分だけ伸ばす
+    if (start >= dataLength) {
+        // 伸ばす
+        _this->resize(start + 1);
+        dataLength = static_cast<long>(_this->size());
+    }
+
+    // 変更長から挿入位置を分けるよー
+    // NOTE Arrayに合わせた
+    if (count <= 0) {
+        // 前に挿入
+        auto iter = _this->begin() + start;
+        _this->insert(iter, input.begin(), input.end());
+    } else {
+        // 挿入位置を基準に前と後ろの分割点を探す
+        auto firstEndIter    = _this->begin() + start;  // 一応startに関しては↑で伸ばしてあるので平気
+        auto secondStartIter = _this->begin();
+
+        if ((start + count) < dataLength) {
+            // 終端まで収まってる
+            secondStartIter = _this->begin() + (start + count);
+        } else {
+            // 収まってない
+            secondStartIter = _this->end();
+        }
+
+        // バッファへ入れて入れ替える
+        std::deque<uint8_t> buffer;
+        buffer.insert(buffer.end(), _this->begin(), firstEndIter);
+        buffer.insert(buffer.end(), input.begin(), input.end());
+        buffer.insert(buffer.end(), secondStartIter, _this->end());
+        _this->swap(buffer);
+    }
+
+    // 戻る
+    return objValues;
+}
+
+/**
+ * バイナリ配列の長さを取得します.
+ *
+ * @return [Integer] 配列長.
+ */
+static VALUE Binary_getLength(VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    return ULONG2NUM(_this->size());
+}
+
+/**
+ * バイナリ配列をRuby配列へ変換します.
+ *
+ * @return [Array<Integer>] バイナリデータが格納された整数値配列
+ */
+static VALUE Binary_toArray(VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    VALUE ary = rb_ary_new2(_this->size());
+
+    // Rubyオブジェクトへ変換しつつ格納
+    for (size_t i = 0; i < _this->size(); i++) {
+        rb_ary_store(ary, i, INT2FIX(_this->at(i)));
+    }
+
+    return ary;
+}
+
+/**
+ * バイナリ配列をバイト文字列へ変換します.
+ *
+ * @return [String] バイナリ配列のデータによる文字列
+ */
+static VALUE Binary_toString(VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    std::string str;
+    str.insert(str.end(), _this->begin(), _this->end());
+    return rb_enc_str_new(str.data(), str.size(), rb_ascii8bit_encoding());
+}
+
+/**
+ * バイナリ配列を配列形式の文字列として返します.
+ *
+ * @return [String] 配列形式文字列
+ * @see Array#to_s
+ */
+static VALUE Binary_toTextString(VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    std::ostringstream buffer;
+
+    buffer << "[";
+    for (auto it = _this->begin(); it != _this->end(); it++) {
+        if (it != _this->begin()) {
+            buffer << ", ";
+        }
+        buffer << static_cast<unsigned int>(*it);
+    }
+    buffer << "]";
+    std::string text = buffer.str();
+
+    return rb_enc_str_new(text.data(), text.size(), rb_ascii8bit_encoding());
+}
+
+/**
+ * バイナリ配列オブジェクトの、オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] オブジェクト文字列表現
+ */
+static VALUE Binary_inspect(VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    VALUE text = rb_funcall(self, rb_intern("to_s"), 0);
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            "#<%s:%p size=%d, data=%s>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            _this->size(), StringValueCStr(text));
+}
+
+/**
+ * 指定位置のバイトデータを取得します.
+ *
+ * これは #[offset] と同じです.
+ *
+ * @param [Integer] offset 配列位置
+ * @return [Integer,nil] バイトデータ
+ * @see Rixmap::Binary#[]
+ */
+static VALUE Binary_at(VALUE self, VALUE argOffset) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    long size   = static_cast<long>(_this->size());
+    long offset = NUM2LONG(rb_Integer(argOffset));
+    if (offset < 0) {
+        offset += size;
+    }
+    if (0 <= offset && offset < size) {
+        return INT2FIX(_this->at(offset));
+    } else {
+        return Qnil;
+    }
+}
+
+/**
+ * 末尾に値を追加します.
+ *
+ * @overload push(*items)
+ *   @param [*Integer] *items 追加する値
+ *   @return [Rixmap::Binary] selfを返します
+ *
+ * @see Array#push
+ */
+static VALUE Binary_push(int argc, VALUE* argv, VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    for (int i = 0; i < argc; i++) {
+        VALUE arg = argv[i];
+        long value = NUM2LONG(rb_Integer(arg));
+        _this->push_back(static_cast<uint8_t>(value));
+    }
+    return self;
+}
+
+/**
+ * @overload pop()
+ *   末尾から要素を取り除き、取り除かれた要素を返します.
+ *
+ *   @return [Integer,nil] 取り除かれたバイトデータ.
+ *                         配列が空だった場合は`nil`.
+ *
+ * @overload pop(num)
+ *   末尾から指定された数だけ要素を取り除き、取り除かれた要素を配列で返します.
+ *
+ *   @param [Integer] num 取り除く要素数
+ *   @return [Rixmap::Binary] 取り除かれたバイトデータの配列.
+ *                            空配列だった場合は空配列が返されます.
+ *
+ * @see Array#pop
+ */
+static VALUE Binary_pop(int argc, VALUE* argv, VALUE self) {
+    // 引数
+    VALUE argCount = Qnil;
+    rb_scan_args(argc, argv, "01", &argCount);
+
+    // 自分
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+
+    // 引数の有無で挙動を変える
+    if (NIL_P(argCount)) {
+        if (_this->empty()) {
+            return Qnil;
+        } else {
+            uint8_t value = _this->back();
+            _this->pop_back();
+            return INT2FIX(value);
+        }
+    } else {
+        long num = NUM2LONG(rb_Integer(argCount));
+        VALUE objResult = rb_class_new_instance(0, NULL, cRixmapBinary);
+        Rixmap::BinaryData* result = rixmap_unwrap<Rixmap::BinaryData>(objResult);
+        for (long i = 0; i < num && !_this->empty(); i++) {
+            result->push_front(_this->back());
+            _this->pop_back();
+        }
+        return objResult;
+    }
+}
+
+/**
+ * @overload shift()
+ *   先頭の要素を取り除き、取り除かれたバイトデータを返します.
+ *
+ *   @return [Integer,nil] 取り除かれたバイトデータ.
+ *                         `self`が空配列だった場合は`nil`.
+ *
+ * @overload shift(num)
+ *   先頭の要素を指定された数だけ取り除き、取り除かれたバイトデータを配列で返します.
+ *
+ *   @param [Integer] num 取り除く要素数
+ *   @return [Rixmap::Binary] 取り除かれたバイトデータの配列.
+ *                            `self`が空配列だった場合は空配列になります.
+ *
+ * @see Array#shift
+ */
+static VALUE Binary_shift(int argc, VALUE* argv, VALUE self) {
+    // 引数
+    VALUE argCount = Qnil;
+    rb_scan_args(argc, argv, "01", &argCount);
+
+    // 自分
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+
+    // 引数の有無で挙動を変える
+    if (NIL_P(argCount)) {
+        if (_this->empty()) {
+            return Qnil;
+        } else {
+            uint8_t value = _this->front();
+            _this->pop_front();
+            return INT2FIX(value);
+        }
+    } else {
+        long num = NUM2LONG(rb_Integer(argCount));
+        VALUE objResult = rb_class_new_instance(0, NULL, cRixmapBinary);
+        Rixmap::BinaryData* result = rixmap_unwrap<Rixmap::BinaryData>(objResult);
+        for (long i = 0; i < num && !_this->empty(); i++) {
+            result->push_back(_this->front());
+            _this->pop_front();
+        }
+        return objResult;
+    }
+}
+
+/**
+ * @overload unshift(*items)
+ *   先頭に指定された要素をすべて追加します.
+ *
+ *   @param [*Integer] *items 追加するバイトデータ
+ *   @return [Rixmap::Binary] selfを返します
+ *
+ * @see Array#unshift
+ */
+static VALUE Binary_unshift(int argc, VALUE* argv, VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    std::deque<uint8_t> buffer;
+    for (int i = 0; i < argc; i++) {
+        VALUE item = argv[i];
+        buffer.push_back(static_cast<uint8_t>(NUM2INT(rb_Integer(item))));
+    }
+    _this->insert(_this->begin(), buffer.begin(), buffer.end());
+    return self;
+}
+
+/**
+ * @overload each()
+ *   全てのバイトデータを走査するEnumeratorを返します.
+ *   @return [Enumerator] バイトデータを走査するイテレータ
+ *
+ * @overload each()
+ *   全てのバイトデータを順に引数としてブロックを呼び出します.
+ *   @yield [byte] バイトデータを引数としてブロックを呼び出します.
+ *   @yieldparam [Integer] byte バイトデータ
+ *   @return [void]
+ *
+ * @see Array#each
+ */
+static VALUE Binary_each(VALUE self) {
+    if (rb_block_given_p()) {
+        Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+        for (auto it = _this->begin(); it != _this->end(); it++) {
+            VALUE item = INT2FIX(*it);
+            rb_yield_values(1, item);
+        }
+        return self;
+    } else {
+        // TODO サイズ計算関数の追加
+        return rb_enumeratorize(self, ID2SYM(rb_frame_this_func()), 0, NULL);
+    }
+}
+
+/**
+ * バイナリ配列を破壊的に逆順に並べなおします.
+ *
+ * @return [Rixmap::Binary] self
+ * @see Array#reverse!
+ */
+static VALUE Binary_reverse(VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    std::reverse(_this->begin(), _this->end());
+    return self;
+}
+
+/**
+ * 逆順に並べられたバイナリ配列の複製を返します.
+ *
+ * @return [Rixmap::Binary] 逆順に並べられたバイナリ配列
+ * @see Array#reverse
+ */
+static VALUE Binary_copyReverse(VALUE self) {
+    Rixmap::BinaryData* _this = rixmap_unwrap<Rixmap::BinaryData>(self);
+    VALUE objResult = rb_class_new_instance(0, NULL, cRixmapBinary);
+    Rixmap::BinaryData* result = rixmap_unwrap<Rixmap::BinaryData>(objResult);
+    result->insert(result->begin(), _this->rbegin(), _this->rend());
+    return objResult;
+}
+/* }}} */
+/* Rixmap::Mode {{{ */
+static void Mode_Free(Rixmap::ModeData* data) {
+    // オブジェクトプールから削除
+    RixmapModePool::Remove(data->getMode());
+
+    // メモリを解放
+    rixmap_xdelete(data);
+}
+
+static VALUE Mode_Alloc(VALUE klass) {
+    Rixmap::ModeData* data = rixmap_xnew<Rixmap::ModeData>();
+    return Data_Wrap_Struct(klass, RIXMAP_DEFAULT_MARK, Mode_Free, data);
+}
+
+/**
+ * 画像形式名を文字列として取得します.
+ *
+ * @return [String] 画像形式名
+ */
+static VALUE Mode_getName(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    const std::string& name = _this->getName();
+    return rb_str_new_cstr(name.c_str());
+}
+
+/**
+ * ピクセルあたりのビット数を返します.
+ *
+ * @return [Integer]
+ */
+static VALUE Mode_getDepth(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    return INT2FIX(_this->getDepth());
+}
+
+/**
+ * RGBカラー形式かどうかを返します.
+ *
+ * @return [Boolean] RGBカラー形式ならtrue
+ */
+static VALUE Mode_isRGBType(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    if (_this->isRGBType()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * グレースケール形式かどうかを返します.
+ *
+ * @return [Boolean] グレースケール形式ならtrue
+ */
+static VALUE Mode_isGrayScaleType(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    if (_this->isGrayScaleType()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * インデックスカラー形式かどうかを返します.
+ *
+ * @return [Boolean] インデックスカラー形式ならtrue
+ */
+static VALUE Mode_isIndexedType(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    if (_this->isIndexedType()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * 透明度をサポートしているかを返します.
+ *
+ * @return [Boolean] 透明度をサポートしているならtrue
+ */
+static VALUE Mode_hasAlpha(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    if (_this->hasAlpha()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * 画像形式値を整数値に変換します.
+ *
+ * @return [Integer] 画像形式値.
+ */
+static VALUE Mode_toInteger(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    return ULONG2NUM(_this->getValue());
+}
+
+/**
+ * オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] 文字列表現
+ */
+static VALUE Mode_inspect(VALUE self) {
+    Rixmap::ModeData* _this = rixmap_unwrap<Rixmap::ModeData>(self);
+    const std::string& name = _this->getName();
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            "#<%s:%p name=%s, depth=%d>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            name.c_str(), _this->getDepth());
+}
+/* }}} */
+/* Rixmap::Color {{{ */
+static void Color_Free(Rixmap::ColorData* data) {
+    RixmapColorPool::Remove(data->getColor());
+    rixmap_xdelete(data);
+}
+
+static VALUE Color_Alloc(VALUE klass) {
+    Rixmap::ColorData* data = rixmap_xnew<Rixmap::ColorData>();
+    return Data_Wrap_Struct(klass, RIXMAP_DEFAULT_MARK, Color_Free, data);
+}
+
+/**
+ * カラーオブジェクトを取得します.
+ * 作成されたインスタンスはGCで回収されるまでキャッシュされるため、
+ * 既存インスタンスがあればそれを返します.
+ *
+ * @overload new(html)
+ *   @param [String] html HTMLによる色表現. この場合は透明度を指定できません.
+ *
+ * @overload new(luminance, alpha=255)
+ *   @param [Integer] luminance 輝度値 (グレースケール値)
+ *                              この場合は #red, #green, #blue それぞれに同じ値が設定されます.
+ *   @param [Integer] alpha 透明度
+ *
+ * @overload new(red, green, blue, alpha=255)
+ *   @param [Integer] red   赤要素値
+ *   @param [Integer] green 緑要素値
+ *   @param [Integer] blue  青要素値
+ *   @param [Integer] alpha 透明度
+ *
+ * @return [Rixmap::Color] カラーオブジェクト
+ */
+static VALUE Color_New(int argc, VALUE* argv, VALUE self) {
+    // 引数解析
+    VALUE arg0, arg1, arg2, arg3;
+    rb_scan_args(argc, argv, "13", &arg0, &arg1, &arg2, &arg3);
+
+    // 引数解析
+    uint8_t red = 0, green = 0, blue = 0, alpha = 255;
+    switch (argc) {
+    case 1:     // HTML形式 or 輝度値のみ
+        if (RB_TYPE_P(arg0, T_STRING)) {
+            // HTML形式として解析する
+            {
+                long  codeSize = RSTRING_LEN(arg0);
+                char* codeData = StringValueCStr(arg0);
+
+                if (codeData[0] == '#') {
+                    long codeLength = codeSize -1;
+                    long codeValue = 0;
+                    switch (codeLength) {
+                    case 3:     // 3桁 (RGB各1桁表現)
+                        codeValue = std::strtol(&(codeData[1]), NULL, 16);      // 16進数として解析
+                        red   = (codeValue & 0x00000F00) >> 8;
+                        green = (codeValue & 0x000000F0) >> 4;
+                        blue  = (codeValue & 0x0000000F);
+                        red   += (red   << 4);
+                        green += (green << 4);
+                        blue  += (blue  << 4);
+                        break;
+
+                    case 6:     // 6桁 (RGB各2桁表現
+                        codeValue = std::strtol(&(codeData[1]), NULL, 16);
+                        red   = (codeValue & 0x00FF0000) >> 16;
+                        green = (codeValue & 0x0000FF00) >> 8;
+                        blue  = (codeValue & 0x000000FF);
+                        break;
+
+                    default:
+                        // HTMLカラーコードとしてはおかしい
+                        rb_raise(rb_eArgError, "unexpected HTML Color: %s", codeData);
+                        break;
+                    }
+                } else {
+                    // 先頭が '#' で始まっていてほしい
+                    rb_raise(rb_eArgError, "unexpected HTML Color: %s", codeData);
+                }
+            }
+        } else {
+            // 輝度値をRGBに設定
+            {
+                uint8_t luminance = ROUND2BYTE(NUM2INT(rb_Integer(arg0)));
+                red   = luminance;
+                green = luminance;
+                blue  = luminance;
+            }
+        }
+        break;
+    case 2:     // 輝度値 + 透明度
+        {
+            uint8_t luminance = ROUND2BYTE(NUM2INT(rb_Integer(arg0)));
+            red   = luminance;
+            green = luminance;
+            blue  = luminance;
+            alpha = ROUND2BYTE(NUM2INT(rb_Integer(arg1)));
+        }
+        break;
+    case 3:     // RGB値
+        red   = ROUND2BYTE(NUM2INT(rb_Integer(arg0)));
+        green = ROUND2BYTE(NUM2INT(rb_Integer(arg1)));
+        blue  = ROUND2BYTE(NUM2INT(rb_Integer(arg2)));
+        break;
+    case 4:     // RGB + 透明度
+        red   = ROUND2BYTE(NUM2INT(rb_Integer(arg0)));
+        green = ROUND2BYTE(NUM2INT(rb_Integer(arg1)));
+        blue  = ROUND2BYTE(NUM2INT(rb_Integer(arg2)));
+        alpha = ROUND2BYTE(NUM2INT(rb_Integer(arg3)));
+        break;
+    default:
+        // ココには来ないとは思う
+        rb_raise(rb_eArgError, "wrong number of arguments (%d for 1..4)", argc);
+        break;
+    }
+
+    Rixmap::Color color(red, green, blue, alpha);
+    return RixmapColorPool::Get(color);
+}
+
+/**
+ * 赤要素値を取得します.
+ *
+ * @return [Integer] 赤要素値
+ */
+static VALUE Color_getRed(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    return INT2FIX(data->getRed());
+}
+
+/**
+ * 緑要素値を取得します.
+ *
+ * @return [Integer] 緑要素値
+ */
+static VALUE Color_getGreen(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    return INT2FIX(data->getGreen());
+}
+
+/**
+ * 青要素値を取得します.
+ *
+ * @return [Integer] 青要素値
+ */
+static VALUE Color_getBlue(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    return INT2FIX(data->getBlue());
+}
+
+/**
+ * 透明度を取得します.
+ *
+ * @return [Integer] 透明度
+ */
+static VALUE Color_getAlpha(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    return INT2FIX(data->getAlpha());
+}
+
+/**
+ * 輝度値を取得します.
+ *
+ * `(#red + #green + #blue) / 3` と同じです.
+ *
+ * @return [Integer] 輝度値
+ */
+static VALUE Color_getLuminance(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    return INT2FIX(data->getLuminance());
+}
+
+/**
+ * オブジェクトと比較し、同じカラーかどうかを返します.
+ *
+ * @param [Object] obj 比較対象のオブジェクト
+ * @return [Boolean] 同じカラーを表現しているならtrue
+ */
+static VALUE Color_operatorEquals(VALUE self, VALUE argObject) {
+    if (RTEST(rb_obj_is_kind_of(argObject, cRixmapColor))) {
+        Rixmap::ColorData* _this = rixmap_unwrap<Rixmap::ColorData>(self);
+        Rixmap::ColorData* _that = rixmap_unwrap<Rixmap::ColorData>(argObject);
+
+        if (*_this == *_that) {
+            return Qtrue;
+        } else {
+            return Qfalse;
+        }
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * 配列とみなし、指定ししたオフセットに対応する要素のバイトデータを取得します.
+ *
+ * 配列としての並びは {#to_a} を参照してください.
+ *
+ * @param [Integer] offset 取得オフセット
+ * @return [Integer,nil] 対応するバイトデータ. 範囲外の場合はnil.
+ * @see #to_a
+ */
+static VALUE Color_offsetGet(VALUE self, VALUE argOffset) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    size_t offset = NUM2ULONG(rb_Integer(argOffset));
+    if (/* 0 <= offset && */ offset < 4) {
+        return INT2FIX((*data)[offset]);
+    } else {
+        return Qnil;
+    }
+}
+
+/**
+ * 整数値に変換したカラー情報を返します.
+ *
+ * @return [Integer] カラーの整数値表現
+ */
+static VALUE Color_toInteger(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    return ULONG2NUM(data->getValue());
+}
+
+/**
+ * 各要素値を持った配列を返します.
+ *
+ * 配列の中身は `[R, G, B, A]` の並びになります.
+ *
+ * @return [Array<Integer>] 要素配列
+ * @example
+ *   color = Rixmap::Color.new(10, 20, 30, 255)
+ *   color.to_a     #=> [10, 20, 30, 255]
+ * @see #[]
+ */
+static VALUE Color_toArray(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    VALUE elems = rb_ary_new();
+    rb_ary_store(elems, 0, INT2FIX(data->getRed()));
+    rb_ary_store(elems, 1, INT2FIX(data->getGreen()));
+    rb_ary_store(elems, 2, INT2FIX(data->getBlue()));
+    rb_ary_store(elems, 3, INT2FIX(data->getAlpha()));
+    return elems;
+}
+
+/**
+ * オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] オブジェクト文字列表現
+ */
+static VALUE Color_inspect(VALUE self) {
+    Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(self);
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            "#<%s:%p red=%d, green=%d, blue=%d, alpha=%d>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            data->getRed(), data->getGreen(), data->getBlue(), data->getAlpha());
+}
+/* }}} */
+/* Rixmap::Palette {{{ */
+static void Palette_Free(Rixmap::PaletteData* data) {
+    rixmap_xdelete(data);
+}
+
+static VALUE Palette_Alloc(VALUE klass) {
+    Rixmap::PaletteData* data = rixmap_xnew<Rixmap::PaletteData>(0);
+    return Data_Wrap_Struct(klass, RIXMAP_DEFAULT_MARK, Palette_Free, data);
+}
+
+/**
+ * パレットを新しく作成します.
+ *
+ * @overload initialize(size=256)
+ *   指定したサイズのパレットを作成します.
+ *   @param [Integer] size パレットサイズ.
+ *   @return [void]
+ */
+static VALUE Palette_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE argSize;
+    rb_scan_args(argc, argv, "01", &argSize);
+
+    long size = 256;
+    if (!NIL_P(argSize)) {
+        size = NUM2LONG(rb_Integer(argSize));
+    }
+    if (size <= 0) {
+        rb_raise(rb_eArgError, "palette size must be positive: %ld", size);
+    }
+
+    // パレットを拡張
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+    _this->resize(size);
+
+    return self;
+}
+
+/**
+ * 複製されたオブジェクトを初期化します.
+ *
+ * @param [Object] 複製元オブジェクト
+ * @return [void]
+ */
+static VALUE Palette_initializeCopy(VALUE self, VALUE argObject) {
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+    Rixmap::PaletteData* _that = rixmap_unwrap<Rixmap::PaletteData>(argObject);
+
+    _this->setDefaultColor(_that->getDefaultColor());
+    _this->setColors(_that->getColors());
+
+    return self;
+}
+
+/**
+ * パレットサイズを取得します.
+ *
+ * @return [Integer] パレットサイズ
+ */
+static VALUE Palette_getSize(VALUE self) {
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+    return ULONG2NUM(_this->getSize());
+}
+
+/**
+ * パレットからカラーオブジェクトを取得します.
+ *
+ * @param [Integer] offset 取得オフセット. 負数の場合は末尾から数えます.
+ * @return [Rixmap::Color,nil] オフセットの位置のカラーオブジェクト.
+ *                             オフセットが範囲外の場合nilになります.
+ */
+static VALUE Palette_offsetGet(VALUE self, VALUE argOffset) {
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+    long length = static_cast<long>(_this->getSize());  // FIXME unsigned -> signedなのであぶねぇ
+    long offset = NUM2LONG(rb_Integer(argOffset));
+    long pos = offset;
+
+    if (pos < 0) {
+        // 末尾からのオフセットとして取得
+        pos += length;
+    }
+
+    // 範囲チェック
+    if (0 <= pos && pos < length) {
+        return RixmapColorPool::Get(_this->get(pos));
+    } else {
+        rb_warning("offset %ld is out of range", offset);
+        return Qnil;
+    }
+}
+
+/**
+ * パレットのカラーオブジェクトを設定します.
+ *
+ * @param [Integer] offset 設定するオフセット. 負数の場合は末尾から数えます.
+ * @param [String,Array,Rixmap::Color] color 設定するカラーオブジェクト
+ * @return [void]
+ * @see Color.new
+ */
+static VALUE Palette_offsetSet(VALUE self, VALUE argOffset, VALUE argColor) {
+    Rixmap::Color color(0, 0, 0, 255);
+
+    // カラーオブジェクトを解析
+    if (RB_TYPE_P(argColor, T_STRING)) {
+        // Color.newを使ってオブジェクトを構築
+        VALUE objColor = rb_funcall(cRixmapColor, rb_intern("new"), 1, argColor);
+        Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(objColor);
+        color = data->getColor();
+    } else if (RTEST(rb_obj_is_kind_of(argColor, cRixmapColor))) {
+        // Rixmap::Colorそのもの
+        Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(argColor);
+        color = data->getColor();
+    } else {
+        // 配列から
+        VALUE aryColor = rb_Array(argColor);
+        long   arylen = RARRAY_LEN(aryColor);
+        VALUE* aryptr = RARRAY_PTR(aryColor);
+        VALUE objColor = rb_funcall2(cRixmapColor, rb_intern("new"), arylen, aryptr);
+        Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(objColor);
+        color = data->getColor();
+    }
+
+    // 内部データポインタ
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+
+    // 対象オフセット
+    long length = static_cast<long>(_this->getSize());  // FIXME unsigned から signed 変換
+    long offset = NUM2LONG(rb_Integer(argOffset));
+    long pos = offset;
+    if (pos < 0) {
+        pos += length;
+    }
+
+    // 範囲チェック
+    if (0 <= pos && pos < length) {
+        _this->set(pos, color);
+    } else {
+        rb_warning("offset %ld is out of range", offset);
+    }
+    return argColor;
+}
+
+/**
+ * オブジェクトと比較して、同じパレットデータかどうかを調べます.
+ *
+ * @param [Object] obj 比較対象のオブジェクト
+ * @return [Boolean] 同じパレットデータならtrue
+ */
+static VALUE Palette_operatorEquals(VALUE self, VALUE argObject) {
+    if (RTEST(rb_obj_is_kind_of(argObject, cRixmapPalette))) {
+        Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+        Rixmap::PaletteData* _that = rixmap_unwrap<Rixmap::PaletteData>(argObject);
+        if (*_this == *_that) {
+            return Qtrue;
+        } else {
+            return Qfalse;
+        }
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * パレットをバイト列へと変換します.
+ *
+ * @overload to_s(layout='RGBA')
+ *   パレットをバイト列に変換します.
+ *   レイアウトが指定されている場合は、色ごとに各要素をレイアウトに沿うように配置します.
+ *   @param [String,Symbol,Array] layout バイト列の並び順. 使用可能な文字は 'R', 'G', 'B', 'A', 'L' です.
+ *                                       レイアウトに含まれないチャンネルはバイト列に含まれなくなるため、
+ *                                       単色バイト列も作成できます.
+ * @example
+ *   palette = Rixmap::Palette.new(256)
+ *   palette.to_s
+ *          #=> 1024バイト (RGBA×256) のバイト列データ
+ *   palette.to_s('RGB')
+ *          #=> 768バイト (RGB×256) データ
+ *   palette.to_s(:R)
+ *          #=> 赤要素のみの256バイトデータ
+ */
+static VALUE Palette_toString(int argc, VALUE* argv, VALUE self) {
+    // 引数解析
+    VALUE argLayout = Qnil;
+    rb_scan_args(argc, argv, "01", &argLayout);
+
+    // 対象チャンネルリスト
+    Rixmap::ChannelArray channels;
+    if (!NIL_P(argLayout)) {
+        if (RB_TYPE_P(argLayout, T_ARRAY)) {
+            long arylen = RARRAY_LEN(argLayout);
+            for (long i = 0; i < arylen; i++) {
+                VALUE item = rb_String(rb_ary_entry(argLayout, i));
+                item = rb_funcall(item, rb_intern("upcase"), 0);
+                long  len = RSTRING_LEN(item);
+                char* ptr = StringValuePtr(item);
+                if (len > 0) {
+                    // 先頭文字のみ見る
+                    channels.push_back(static_cast<Rixmap::Channel>(ptr[0]));
+                }
+            }
+        } else {
+            VALUE objLayout = rb_funcall(rb_String(argLayout), rb_intern("upcase"), 0);
+            long  len = RSTRING_LEN(objLayout);
+            char* ptr = StringValuePtr(objLayout);
+            for (long i = 0; i < len; i++) {
+                channels.push_back(static_cast<Rixmap::Channel>(ptr[i]));
+            }
+        }
+    }
+    if (channels.empty()) {
+        channels.push_back(Rixmap::Channel::RED);
+        channels.push_back(Rixmap::Channel::GREEN);
+        channels.push_back(Rixmap::Channel::BLUE);
+        channels.push_back(Rixmap::Channel::ALPHA);
+    }
+
+    // バイト列へ
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+    Rixmap::CharBuffer bytes;
+    const Rixmap::ColorArray& colors = _this->getColors();
+    for (auto colit = colors.begin(); colit != colors.end(); colit++) {
+        const Rixmap::Color& color = *colit;
+        for (auto chit = channels.begin(); chit != channels.end(); chit++) {
+            Rixmap::Channel ch = *chit;
+            switch (ch) {
+            case Rixmap::Channel::RED:
+            case Rixmap::Channel::GREEN:
+            case Rixmap::Channel::BLUE:
+            case Rixmap::Channel::ALPHA:
+            case Rixmap::Channel::LUMINANCE:
+                bytes.push_back(color[*chit]);
+                break;
+            default:
+                // DO NOTHING
+                // TODO 存在しないチャンネルだった場合にスキップするか0x00で埋めるかのフラグを作るべきだろか
+                break;
+            }
+        }
+    }
+
+    return rb_enc_str_new(bytes.data(), bytes.size(), rb_ascii8bit_encoding());
+}
+
+/**
+ * パレットをカラーオブジェクト配列に変換します.
+ *
+ * @return [Array<Rixmap::Color>] カラー配列
+ */
+static VALUE Palette_toArray(VALUE self) {
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+    size_t size = _this->getSize();
+    VALUE ary = rb_ary_new2(size);
+    for (size_t i = 0; i < size; i++) {
+        rb_ary_store(ary, i, RixmapColorPool::Get(_this->at(i)));
+    }
+    return ary;
+}
+
+/**
+ * パレットの各色を順番に走査するイテレータを返すか、各色を順にブロックに渡して走査します.
+ *
+ * ブロックが渡された場合はカラーオブジェクト引数にブロックを呼び出します.
+ * ブロックが渡されていない場合はイテレータを返します.
+ *
+ * @overload each()
+ *   @return [Enumerator] イテレータ
+ *
+ * @overload each()
+ *   @yield [color] パレット内の各カラーオブジェクトを引数としてブロックを呼び出します
+ *   @yieldparam color [Rixmap::Color] カラーオブジェクト
+ *   @return [void]
+ */
+static VALUE Palette_each(VALUE self) {
+    if (rb_block_given_p()) {   // ブロック有
+        Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+        const Rixmap::ColorArray& colors = _this->getColors();
+        for (auto it = colors.begin(); it != colors.end(); it++) {
+            VALUE color = RixmapColorPool::Get(*it);
+            rb_yield_values(1, color);
+        }
+        return self;
+    } else {                    // ブロック無
+        // TODO サイズ計算関数の追加
+        //      その時は rb_enumeratorize_with_sizeを使おう
+        //      (RETURN_SIZED_ENUMERATORでもいいかも)
+        return rb_enumeratorize(self, ID2SYM(rb_frame_this_func()), 0, NULL);
+    }
+}
+
+/**
+ * オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] 文字列表現
+ */
+static VALUE Palette_inspect(VALUE self) {
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+
+    // カラーリスト構築
+    //std::ostringstream text;
+    //text << "[";
+    //const Rixmap::ColorArray& colors = _this->getColors();
+    //for (auto it = colors.begin(); it != colors.end(); it++) {
+    //    const Rixmap::Color& color = *it;
+    //    if (it != colors.begin()) {
+    //        text << ", ";
+    //    }
+    //    text << "["
+    //         << static_cast<int>(color.getRed()) << ", "
+    //         << static_cast<int>(color.getGreen()) << ", "
+    //         << static_cast<int>(color.getBlue()) << ", "
+    //         << static_cast<int>(color.getAlpha()) << "]";
+    //}
+    //text << "]";
+
+    // 文字列構築
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            /* "#<%s:%p size=%d, colors=%s>", */
+            "#<%s:%p size=%d>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            _this->getSize()
+            /*, text.str().c_str()*/
+        );
+}
+/* }}} */
+/* Rixmap::Palette::VGA {{{ */
+static VALUE VGAPalette_initialize(VALUE self) {
+    // 16色パレットとして初期化
+    {
+        VALUE args[1];
+        args[0] = INT2FIX(16);
+        rb_call_super(1, args);
+    }
+
+    // 色を設定
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+    _this->set(0 , Rixmap::Color(255, 255, 255));         // White
+    _this->set(1 , Rixmap::Color(192, 192, 192));         // Silver
+    _this->set(2 , Rixmap::Color(128, 128, 192));         // Gray
+    _this->set(3 , Rixmap::Color(  0,   0,   0));         // Black
+    _this->set(4 , Rixmap::Color(255,   0,   0));         // Red
+    _this->set(5 , Rixmap::Color(128,   0,   0));         // Maroon
+    _this->set(6 , Rixmap::Color(255, 255,   0));         // Yellow
+    _this->set(7 , Rixmap::Color(128, 128,   0));         // Olive
+    _this->set(8 , Rixmap::Color(  0, 255,   0));         // Green
+    _this->set(9 , Rixmap::Color(  0, 128,   0));         // Lime
+    _this->set(10, Rixmap::Color(  0, 255, 255));         // Aqua
+    _this->set(11, Rixmap::Color(  0, 128, 128));         // Teal
+    _this->set(12, Rixmap::Color(  0,   0, 255));         // Blue
+    _this->set(13, Rixmap::Color(  0,   0, 128));         // Navy
+    _this->set(14, Rixmap::Color(255,   0, 255));         // Fucshia
+    _this->set(15, Rixmap::Color(128,   0, 128));         // Purple
+
+    // 凍結
+    OBJ_FREEZE(self);
+
+    return self;
+}
+/* }}} */
+/* Rixmap::Palette::WebSafe {{{ */
+static VALUE WebSafePalette_initialize(VALUE self) {
+    // 色要素
+    static uint8_t _levels[6] = {0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF};
+
+    // 216色パレット
+    {
+        VALUE args[1];
+        args[0] = INT2FIX(216);
+        rb_call_super(1, args);
+    }
+
+    // 色を設定
+    Rixmap::PaletteData* _this = rixmap_unwrap<Rixmap::PaletteData>(self);
+
+    int num = 0;
+    for (int ri = 0; ri < 6; ri++) {
+        for (int gi = 0; gi < 6; gi++) {
+            for (int bi = 0; bi < 6; bi++) {
+                _this->set(num++, Rixmap::Color(_levels[ri], _levels[gi], _levels[bi]));
+            }
+        }
+    }
+
+    // 凍結
+    OBJ_FREEZE(self);
+
+    return self;
+}
+/* }}} */
+/* Rixmap::Image {{{ */
+static void Image_Mark(Rixmap::ImageData* data) {
+    data->gcmark();
+}
+
+static void Image_Free(Rixmap::ImageData* data) {
+    rixmap_xdelete(data);
+}
+
+static VALUE Image_Alloc(VALUE klass) {
+    Rixmap::ImageData* data = rixmap_xnew<Rixmap::ImageData>();
+    return Data_Wrap_Struct(klass, Image_Mark, Image_Free, data);
+}
+
+/**
+ * 新規画像を作成します.
+ *
+ * @overload initialize(mode, width, height, options={})
+ *   形式とサイズを指定して画像を作成します.
+ *   @param [Rixmap::Mode] mode 画像形式
+ *   @param [Integer] width 横幅 (ピクセル数)
+ *   @param [Integer] height 高さ (ピクセル数)
+ *   @param [Hash] options オプションパラメータ
+ *   @option options [Rixmap::Palette] :palette パレットデータ
+ *   @return [void]
+ */
+static VALUE Image_initialize(int argc, VALUE* argv, VALUE self) {
+    // 引数解析
+    VALUE argMode, argWidth, argHeight, argOptions;
+    rb_scan_args(argc, argv, "31", &argMode, &argWidth, &argHeight, &argOptions);
+
+    // オブジェクト -> 画像形式定数
+    Rixmap::Mode mode = Rixmap::Mode::NONE;
+    if (!RTEST(rb_obj_is_kind_of(argMode, cRixmapMode))) {
+        VALUE strMode = rb_funcall(rb_String(argMode), rb_intern("upcase"), 0);
+        std::string name(StringValueCStr(strMode));
+        mode = Rixmap::ModeInfo::GetModeByName(name);
+    } else {
+        Rixmap::ModeData* mdata = rixmap_unwrap<Rixmap::ModeData>(argMode);
+        mode = mdata->getMode();
+    }
+
+    // 画像サイズ
+    long width  = NUM2LONG(argWidth);
+    long height = NUM2LONG(argHeight);
+
+    // データポインタを取得
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    try {
+        _this->init(mode, width, height);
+    } catch (const std::exception& e) {
+        rb_raise(rb_eArgError, e.what());
+    } catch (...) {
+        rb_raise(rb_eRuntimeError, "unknown error occurred");
+    }
+
+    // オプションパラメータからパレットを拾う
+    VALUE optPalette = Qnil;
+    if (RB_TYPE_P(argOptions, T_HASH)) {
+        optPalette = rb_hash_lookup(argOptions, ID2SYM(rb_intern("palette")));
+        // TODO 型チェック
+    }
+
+    // パレットの処置
+    if (_this->getModeInfo().isIndexedType() && NIL_P(optPalette)) {
+        // インデックスカラー形式でかつ、パレットが指定されてない場合は作る
+        optPalette = RixmapHelper::CreatePalette(256);
+    }
+
+    // パレットの設定
+    _this->setPalette(optPalette);
+
+    // 戻る
+    return self;
+}
+
+/**
+ * 画像形式を取得します.
+ *
+ * @return [Rixmap::Mode] 画像形式
+ */
+static VALUE Image_getMode(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    return RixmapModePool::Get(_this->getMode());
+}
+
+/**
+ * 画像の横幅を取得します.
+ *
+ * @return [Integer] 横幅
+ */
+static VALUE Image_getWidth(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    return LONG2NUM(_this->getWidth());
+}
+
+/**
+ * 画像の高さを取得します.
+ *
+ * @return [Integer] 高さ
+ */
+static VALUE Image_getHeight(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    return LONG2NUM(_this->getHeight());
+}
+
+/**
+ * 設定されているパレットを取得します.
+ *
+ * @return [Rixmap::Palette,nil] パレット
+ */
+static VALUE Image_getPalette(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    return _this->getPalette();
+}
+
+/**
+ * パレットを設定します.
+ *
+ * @param [Rixmap::Palette] パレットデータ
+ * @return [void]
+ */
+static VALUE Image_setPalette(VALUE self, VALUE argPalette) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    if (RTEST(rb_obj_is_kind_of(argPalette, cRixmapPalette))) {
+        _this->setPalette(argPalette);
+    } else {
+        rb_raise(rb_eArgError, "palette expected %s, but %s", rb_class2name(cRixmapPalette), rb_obj_classname(argPalette));
+    }
+    return argPalette;
+}
+
+/**
+ * 画像サイズを配列で返します.
+ *
+ * @return [Array<Integer>] (横幅, 高さ) で返される二要素の配列
+ */
+static VALUE Image_getSize(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    VALUE objSize = rb_ary_new2(2);
+    rb_ary_store(objSize, 0, LONG2NUM(_this->getWidth()));
+    rb_ary_store(objSize, 1, LONG2NUM(_this->getHeight()));
+    OBJ_FREEZE(objSize);
+    return objSize;
+}
+
+/**
+ * 画像の寸法を配列で返します.
+ *
+ * 寸法には
+ *
+ * - 横幅
+ * - 高さ
+ * - チャンネル数
+ *
+ * が含まれます.
+ *
+ * @return [Array<Integer>] 寸法を格納した配列
+ * @see #size
+ */
+static VALUE Image_getDimension(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    VALUE objDim = rb_ary_new2(3);
+    rb_ary_store(objDim, 0, LONG2NUM(_this->getWidth()));
+    rb_ary_store(objDim, 1, LONG2NUM(_this->getHeight()));
+    rb_ary_store(objDim, 2, INT2FIX(_this->getModeInfo().getChannels().size()));
+    OBJ_FREEZE(objDim);
+    return objDim;
+}
+
+/**
+ * この画像がインデックスカラー形式かどうかを返します.
+ *
+ * @return [Boolean] インデックスカラー形式ならtrue
+ * @see Rixmap::Mode#indexed?
+ */
+static VALUE Image_isIndexedImage(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    if (_this->getModeInfo().isIndexedType()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * この画像がグレースケール形式かどうかを返します.
+ *
+ * @return [Boolean] グレースケール形式ならtrue
+ * @see Rixmap::Mode#grayscale?
+ */
+static VALUE Image_isGrayScaleImage(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    if (_this->getModeInfo().isGrayScaleType()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * この画像がRGBカラー形式かどうかを返します.
+ *
+ * @return [Boolean] RGBカラー形式ならtrue
+ * @see Rixmap::Mode#rgb?
+ */
+static VALUE Image_isRGBImage(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    if (_this->getModeInfo().isRGBType()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * この画像が透明度を持っているかを返します.
+ *
+ * @return [Boolean] 透明度をサポートしている場合はtrue
+ * @see Rixmap::Mode#has_alpha?
+ */
+static VALUE Image_hasAlphaChannel(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    if (_this->getModeInfo().hasAlpha()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * 指定したスキャンラインまたはピクセルデータを取得します.
+ *
+ * @overload [](lineno)
+ *   指定行番号に対応するスキャンラインオブジェクトを返します.
+ *   @param [Integer] lineno 行番号
+ *   @return [Rixmap::Image::Line] スキャンライン
+ *
+ * @overload [](x, y)
+ *   指定座標のピクセルデータを取得します.
+ *
+ *   ピクセルデータは画像形式ごとに以下の形式で返されます.
+ *
+ *   ###### RGB, RGBA, GRAYALPHA形式の場合
+ *   戻り値は各要素値を含んだ配列になります.
+ *
+ *   ###### GRAYSCALE, INDEXED形式の場合
+ *   戻り値は輝度値またはパレットインデックスである整数値になります.
+ *
+ *   @param [Integer] x X軸座標
+ *   @param [Integer] y Y軸座標
+ *   @return [Integer,Array<Integer>,nil] ピクセルデータ. 範囲外の場合は`nil`
+ *
+ * @example 基本形
+ *   img = Rixmap::Image.new('RGB', 32, 32)
+ *   img[0, 0] = [10, 20, 30]
+ *   img[0]     #=> ImageLineインスタンス
+ *   img[0, 0]  #=> [10, 20, 30]
+ *
+ * @example パレットの場合
+ *   img = Rixmap::Image.new('INDEXED', 32, 32)
+ *   img[0, 0] = [240]
+ *   img[0, 0]  #=> 240
+ */
+static VALUE Image_offsetGet(int argc, VALUE* argv, VALUE self) {
+    // 引数を解析
+    VALUE arg0 = Qnil, arg1 = Qnil;
+    rb_scan_args(argc, argv, "11", &arg0, &arg1);
+
+    if (NIL_P(arg1)) {
+        // [line] 形式
+        // TODO [nil, nil] とかどうするよ
+        long lineno = NUM2LONG(rb_Integer(arg0));
+        return RixmapHelper::CreateImageLine(self, lineno);
+    } else {
+        // [x, y] 形式ですよねー
+        // TODO [nil, 0] とかどうするよ
+        long xpos = NUM2LONG(rb_Integer(arg0));
+        long ypos = NUM2LONG(rb_Integer(arg1));
+        Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+
+        return RixmapHelper::GetPixel(_this, xpos, ypos);
+    }
+}
+
+/**
+ * スキャンラインまたはピクセルを更新します.
+ *
+ * @overload []=(lineno, data)
+ *   スキャンラインをまとめて更新します.
+ *
+ *   更新する内容はピクセルデータを含む配列または文字列です.
+ *   文字列の場合はバイト列データとして扱われ、画像の持つチャンネル毎に
+ *   ピクセルとして扱われます.
+ *   ピクセルデータの扱いについては {#[]=} の二要素版を参照してください.
+ *
+ *   @param [Integer] lineno 対象行番号
+ *   @param [String,Array] data 更新データ
+ *   @return [void]
+ *
+ * @overload []=(x, y, data)
+ *   ピクセルデータを更新します.
+ *
+ *   ピクセルデータは以下の形式で設定できます.
+ *
+ *   ###### Integer
+ *   整数値の場合、画像の持つチャンネル数すべてに複製されます.
+ *   そのため、透明度を持つ場合などは配列で指定したほうが安全です.
+ *
+ *   ###### Array
+ *   配列の場合は各要素を `to_i` によって整数値に変換した後、チャンネル順に設定していきます.
+ *   そのため、チャンネル数に足りていない場合は更新されない要素があることに注意してください.
+ *   また、`nil` になっている要素は無視されます.
+ *
+ *   ###### {Rixmap::Color}
+ *   カラーオブジェクトの場合、以下の処理を行います.
+ *
+ *   - RGB形式の場合は {Rixmap::Color#red}, {Rixmap::Color#green}, {Rixmap::Color#blue} を設定します.
+ *   - GRAYSCALE形式の場合は {Rixmap::Color#luminance} で得られた値を使用します.
+ *   - INDEXED形式の場合は {Rixmap::Palette#closest} を使用して、最も近い色のインデックスを設定します.
+ *   - 透明度を持つ画像の場合は、{Rixmap::Color#alpha} を透明度に設定します.
+ *
+ *   @param [Integer] x X軸座標
+ *   @param [Integer] y Y軸座標
+ *   @param [Integer,Array,Rixmap::Color] data ピクセルデータ
+ *   @return [void]
+ *
+ * @example 使用例 (RGB形式)
+ *   img = Rixmap::Image.new('RGB', 32, 32)
+ *   img[0, 0] = [16, 32,480]   # 基本はこんな感じ
+ *   img[1, 0] = 24             # 全要素に設定
+ *   img[1, 0] = [24, 24, 24]   # 上と同じことをやっている
+ *   img[2, 0] = [24, 26]       # 青要素を更新しない
+ *   img[3, 0] = [nil, nil, 0]  # 青要素のみ更新
+ *
+ * @example 使用例 (インデックスカラー)
+ *   img = Rixmap::Image.new('INDEXED', 32, 32)
+ *   img[0, 0] = 10             # 基本
+ *   img[1, 0] = [3]            # 配列の場合は、先頭のみ使用
+ *   img[2, 0] = [3, 4, 5]      # 後ろは無視されます
+ *   img[3, 0] = [nil, nil, 7]  # 更新されません
+ *   img[4, 0] = Rixmap::Color.new(10, 20, 30)
+ *                              # 最も近い色を {#palette} から探します
+ *
+ * @example 透明度がある場合
+ *   img = Rixmap::Image.new('RGBA', 32, 32)
+ *   img[0, 0] = 10         # 透明度は更新せず
+ *   img[1, 0] = [5, 5, 5]  # 同じく更新せず
+ *   img[2, 0] = [nil, nil, nil, 128]
+ *                          # 透明度のみ更新
+ * @example スキャンライン単位で更新する場合
+ *   img = Rixmap::Image.new('RGB', 32, 32)
+ *   img[0] = [[0, 1, 2], [3, 4, 5]]
+ *              # img[0, 0] = [0, 1, 2], img[0, 1] = [3, 4, 5] と同じ
+ *              # 先頭から埋めていくので、不足している場合は更新されない要素が発生します.
+ *   img[1] = [0, 1, 2, 3, 4, 5]
+ *              # img[0, 0] = 0, img[0, 1] = 1, ... と同じ扱いです
+ *              # 先頭から3要素ずつとるとかいう気の利いたことはしません('A`)
+ *   img[2] = "\x00\x01\x02\x03\x04\x05"
+ *              # img[0, 0] = [0, 1, 2], img[0, 1] = [3, 4, 5] と同じ扱い
+ *              # なんでこっちは気の利いたことすんだよって感じですな('A`)
+ *
+ *   # FIXME この辺の動作の定義
+ */
+static VALUE Image_offsetSet(int argc, VALUE* argv, VALUE self) {
+    // 引数解析
+    VALUE arg0 = Qnil, arg1 = Qnil, arg2 = Qnil;
+    rb_scan_args(argc, argv, "21", &arg0, &arg1, &arg2);
+
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    const Rixmap::ModeInfo& mode = _this->getModeInfo();
+    VALUE argLineNumber = Qnil, argX = Qnil, argY = Qnil;
+    VALUE argData = Qnil;
+    if (NIL_P(arg2)) {
+        // [lineno] = data 形式
+        argLineNumber = arg0;
+        argData       = arg1;
+
+        int32_t lineno = NUM2LONG(argLineNumber);
+
+        // 範囲チェック
+        if (_this->isInside(0, lineno)) {
+            // 引数チェック
+            if (RTEST(rb_obj_is_kind_of(argData, cRixmapBinary))) {
+                Rixmap::BinaryData* data = rixmap_unwrap<Rixmap::BinaryData>(argData);
+                int32_t dataLength = static_cast<int32_t>(data->size());
+
+                int32_t width = _this->getWidth();
+                const Rixmap::ChannelArray& channels = mode.getChannels();
+                int nchannel = channels.size();
+
+                int32_t maxLength = width * nchannel;   // FIXME 場合によってはオーバーフロー
+                int32_t length = (dataLength < maxLength) ? dataLength : maxLength;
+
+                for (int32_t i = 0; i < length; i++) {
+                    int32_t w = (i / nchannel);
+                    int32_t c = (i % nchannel);
+                    Rixmap::Channel channel = channels.at(c);
+                    _this->set(channel, w, lineno, data->at(i));
+                }
+            } else if (RB_TYPE_P(argData, T_ARRAY)) {
+                // 配列なので、いったん全要素をチェックする
+                long nitem = RARRAY_LEN(argData);
+                int32_t width = _this->getWidth();
+                int32_t length = (width < nitem) ? width : nitem;
+                for (int32_t i = 0; i < length; i++) {
+                    VALUE item = rb_ary_entry(argData, i);
+                    if (RB_TYPE_P(item, T_FIXNUM) || RB_TYPE_P(item, T_ARRAY) || RTEST(rb_obj_is_kind_of(item, cRixmapColor))) {
+                    } else {
+                        rb_raise(rb_eArgError, "unexpected pixel data type in line data: %s", rb_obj_classname(item));
+                    }
+                }
+
+                // 要素を更新
+                for (int32_t i = 0; i < length; i++) {
+                    VALUE item = rb_ary_entry(argData, i);
+                    RixmapHelper::UpdatePixel(_this, i, lineno, item);
+                }
+            } else if (RB_TYPE_P(argData, T_STRING)) {
+                // TODO rb_String使って強制的に文字列化する
+                // 文字列
+                long  nbyte = RSTRING_LEN(argData);
+                const char* bytes = RSTRING_PTR(argData);
+                int32_t width = _this->getWidth();
+                const Rixmap::ChannelArray& channels = mode.getChannels();
+                int nchannel = channels.size();
+
+                int32_t maxlength = width * nchannel;   // FIXME 場合によってはオーバーフローするよなぁこれ
+                int32_t length = (nbyte < maxlength) ? nbyte : maxlength;
+
+                for (int32_t i = 0; i < length; i++) {
+                    int32_t w = (i / nchannel);
+                    int32_t c = (i % nchannel);
+                    Rixmap::Channel channel = channels.at(c);
+                    _this->set(channel, w, lineno, bytes[i]);
+                }
+            } else {
+                // 非対応(´・ω・`)
+                rb_raise(rb_eArgError, "unexpected line data type: %s", rb_obj_classname(argData));
+            }
+        } else {
+            // 範囲外
+            rb_warning("line %d is outside of image", lineno);
+        }
+    } else {
+        // [x, y] = data 形式
+        argX    = arg0;
+        argY    = arg1;
+        argData = arg2;
+
+        // ネイティブ値へ
+        int32_t xpos = NUM2LONG(rb_Integer(argX));
+        int32_t ypos = NUM2LONG(rb_Integer(argY));
+
+        RixmapHelper::UpdatePixel(_this, xpos, ypos, argData);
+    }
+
+    // 戻る
+    return argData;
+}
+
+/**
+ * オブジェクトと比較して、同じ画像かどうかを返します.
+ *
+ * @param [Object] obj 比較対象のオブジェクト
+ * @return [Boolean] 同じ画像ならtrue
+ */
+static VALUE Image_operatorEquals(VALUE self, VALUE argObject) {
+    if (self == argObject) {
+        // 自分自身はtrue
+        return Qtrue;
+    }
+
+    if (RTEST(rb_obj_is_kind_of(argObject, cRixmapImage))) {
+        Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+        Rixmap::ImageData* _that = rixmap_unwrap<Rixmap::ImageData>(argObject);
+
+        if (*_this == *_that) {
+            return Qtrue;
+        } else {
+            return Qfalse;
+        }
+    } else {
+        // クラスが違う場合はfalse
+        return Qfalse;
+    }
+}
+
+/**
+ * スキャンライン走査するイテレータを返します.
+ * ブロックが渡されている場合は各スキャンラインを引数としてブロックを呼び出します.
+ *
+ * @overload each_line()
+ *   @return [Enumerator] イテレータ
+ *
+ * @overload each_line()
+ *   @yield [line] スキャンラインを引数としてブロックを呼び出します
+ *   @yieldparam line [Rixmap::Image::Line] スキャンラインオブジェクト
+ *   @return [void]
+ */
+static VALUE Image_eachLine(VALUE self) {
+    if (rb_block_given_p()) {       // ブロック有
+        Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+        for (int32_t h = 0; h < _this->getHeight(); h++) {
+            VALUE line = RixmapHelper::CreateImageLine(self, h);
+            rb_yield_values(1, line);
+        }
+        return self;
+    } else {                        // ブロック無
+        // TODO サイズ計算関数の追加
+        //      その時は rb_enumeratorize_with_sizeを使おう
+        //      (RETURN_SIZED_ENUMERATORでもいいかも)
+        return rb_enumeratorize(self, ID2SYM(rb_frame_this_func()), 0, NULL);
+    }
+}
+
+/**
+ * ピクセルを走査するイテレータを返します.
+ * ブロックが渡されている場合は各ピクセルを引数としてブロックを呼び出します.
+ *
+ * ピクセルの走査は左上から右下へ、スキャンラインを左から右へ向かって行います.
+ *
+ * @overload each_pixel()
+ *   @return [Enumerator] イテレータ
+ *
+ * @overload each_pixel()
+ *   @yield [pixel] ピクセルデータを引数としてブロックを呼び出します
+ *   @yieldparam pixel [Array<Integer>,Integer] ピクセルデータ
+ *   @return [void]
+ */
+static VALUE Image_eachPixel(VALUE self) {
+    if (rb_block_given_p()) {       // ブロック有
+        Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+        for (int32_t h = 0; h < _this->getHeight(); h++) {
+            for (int32_t w = 0; w < _this->getWidth(); w++) {
+                VALUE pixel = RixmapHelper::GetPixel(_this, w, h);
+                rb_yield_values(1, pixel);
+            }
+        }
+        return self;
+    } else {                        // ブロック無
+        // TODO サイズ計算関数の追加
+        //      その時は rb_enumeratorize_with_sizeを使おう
+        //      (RETURN_SIZED_ENUMERATORでもいいかも)
+        return rb_enumeratorize(self, ID2SYM(rb_frame_this_func()), 0, NULL);
+    }
+}
+
+/**
+ * この画像の全てのスキャンラインを含む配列を返します.
+ *
+ * @return [Array<Rixmap::Image::Line>] スキャンライン配列
+ * @see #each_line
+ */
+static VALUE Image_getLines(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    VALUE aryLines = rb_ary_new2(_this->getHeight());
+
+    for (int32_t h = 0; h < _this->getHeight(); h++) {
+        VALUE line = RixmapHelper::CreateImageLine(self, h);
+        rb_ary_store(aryLines, h, line);
+    }
+
+    return aryLines;
+}
+
+/**
+ * この画像のすべてのピクセルデータを含む配列を返します.
+ *
+ * ピクセルデータはスキャンラインごとに入れ子の配列になります.
+ *
+ * @return [Array<Array>] 全ピクセルデータ
+ * @see #each_pixel
+ * @see Rixmap::Image::Line
+ */
+static VALUE Image_getPixels(VALUE self) {
+    // TODO NArrayがある場合はそっちを使いたいねぇ
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    VALUE aryPixels = rb_ary_new2(_this->getHeight());
+
+    for (int32_t h = 0; h < _this->getHeight(); h++) {
+        VALUE aryLine = rb_ary_new2(_this->getWidth());
+        for (int32_t w = 0; w < _this->getWidth(); w++) {
+            VALUE pixel = RixmapHelper::GetPixel(_this, w, h);
+            rb_ary_store(aryLine, w, pixel);
+        }
+        rb_ary_store(aryPixels, h, aryLine);
+    }
+
+    return aryPixels;
+}
+
+/**
+ * オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] 文字列表現
+ */
+static VALUE Image_inspect(VALUE self) {
+    Rixmap::ImageData* _this = rixmap_unwrap<Rixmap::ImageData>(self);
+    volatile VALUE objPalette = _this->getPalette();
+    volatile VALUE paletteText = rb_inspect(objPalette);
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            "#<%s:%p mode=%s, size=(%d, %d), palette=%s>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            _this->getModeInfo().getName().c_str(),
+            _this->getWidth(),
+            _this->getHeight(),
+            StringValueCStr(paletteText));
+}
+/* }}} */
+/* Rixmap::Image::Line {{{ */
+static void ImageLine_Mark(Rixmap::ImageLineData* data) {
+    data->gcmark();
+}
+
+static void ImageLine_Free(Rixmap::ImageLineData* data) {
+    rixmap_xdelete(data);
+}
+
+static VALUE ImageLine_Alloc(VALUE klass) {
+    Rixmap::ImageLineData* data = rixmap_xnew<Rixmap::ImageLineData>(Qnil, 0);
+    return Data_Wrap_Struct(klass, ImageLine_Mark, ImageLine_Free, data);
+}
+
+/**
+ * スキャンラインオブジェクトを初期化します.
+ *
+ * @param [Rixmap::Image] image 参照先画像
+ * @param [Integer] lineno 参照先行番号
+ * @return [void]
+ */
+static VALUE ImageLine_initialize(VALUE self, VALUE argImage, VALUE argLineNumber) {
+    // 引数のチェック
+    if (!RTEST(rb_obj_is_kind_of(argImage, cRixmapImage))) {
+        rb_raise(rb_eArgError, "parent image expected %s, but %s", rb_class2name(argImage), rb_obj_classname(argImage));
+    }
+    int32_t lineno = NUM2LONG(rb_Integer(argLineNumber));
+
+    // データを初期化
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    _this->setImage(argImage);
+    _this->setLineNumber(lineno);
+
+    return self;
+}
+
+/**
+ * 参照先の親画像を返します.
+ *
+ * @return [Rixmap::Image] 参照先画像
+ */
+static VALUE ImageLine_getImage(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return _this->getImage();
+}
+
+/**
+ * 参照先の行番号を返します.
+ *
+ * @return [Integer] 行番号
+ */
+static VALUE ImageLine_getLineNumber(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return LONG2NUM(_this->getLineNumber());
+}
+
+/**
+ * このスキャンラインが有効な画像と行番号への参照になっているかを返します.
+ *
+ * @return [Boolean] 有効なスキャンラインオブジェクトならtrue
+ */
+static VALUE ImageLine_isValid(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    if (_this->isValid()) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+/**
+ * スキャンライン内のピクセルデータの、赤要素のみのバイトデータを配列で取得します.
+ * 赤要素チャンネルを持たない場合や、スキャンラインが無効な場合はnilを返します.
+ *
+ * @return [Array<Integer>] 赤要素のみのバイトデータ.
+ */
+static VALUE ImageLine_getRedBand(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return RixmapHelper::GetBand(_this, Rixmap::Channel::RED);
+}
+
+/**
+ * スキャンライン内のピクセルデータの、赤要素のみを更新します.
+ *
+ * @param [String,Array] band 更新データ
+ * @return [void]
+ */
+static VALUE ImageLine_setRedBand(VALUE self, VALUE argBand) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    RixmapHelper::UpdateBand(_this, Rixmap::Channel::RED, argBand);
+    return argBand;
+}
+
+/**
+ * スキャンライン内のピクセルデータの、緑要素のみのバイトデータを配列で取得します.
+ * 緑要素チャンネルを持たない場合や、スキャンラインが無効な場合はnilを返します.
+ *
+ * @return [Array<Integer>] 緑要素のみのバイトデータ.
+ */
+static VALUE ImageLine_getGreenBand(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return RixmapHelper::GetBand(_this, Rixmap::Channel::GREEN);
+}
+
+/**
+ * スキャンライン内のピクセルデータの、緑要素のみを更新します.
+ *
+ * @param [String,Array] band 更新データ
+ * @return [void]
+ */
+static VALUE ImageLine_setGreenBand(VALUE self, VALUE argBand) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    RixmapHelper::UpdateBand(_this, Rixmap::Channel::GREEN, argBand);
+    return argBand;
+}
+
+/**
+ * スキャンライン内のピクセルデータの、青要素のみのバイトデータを配列で取得します.
+ * 青要素チャンネルを持たない場合や、スキャンラインが無効な場合はnilを返します.
+ *
+ * @return [Array<Integer>] 青要素のみのバイトデータ.
+ */
+static VALUE ImageLine_getBlueBand(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return RixmapHelper::GetBand(_this, Rixmap::Channel::BLUE);
+}
+
+/**
+ * スキャンライン内のピクセルデータの、青要素のみを更新します.
+ *
+ * @param [String,Array] band 更新データ
+ * @return [void]
+ */
+static VALUE ImageLine_setBlueBand(VALUE self, VALUE argBand) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    RixmapHelper::UpdateBand(_this, Rixmap::Channel::BLUE, argBand);
+    return argBand;
+}
+
+/**
+ * スキャンライン内のピクセルデータの、透明度のみのバイトデータを配列で取得します.
+ * 透明度チャンネルを持たない場合や、スキャンラインが無効な場合はnilを返します.
+ *
+ * @return [Array<Integer>] 透明度のみのバイトデータ.
+ */
+static VALUE ImageLine_getAlphaBand(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return RixmapHelper::GetBand(_this, Rixmap::Channel::ALPHA);
+}
+
+/**
+ * スキャンライン内のピクセルデータの、透明度のみを更新します.
+ *
+ * @param [String,Array] band 更新データ
+ * @return [void]
+ */
+static VALUE ImageLine_setAlphaBand(VALUE self, VALUE argBand) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    RixmapHelper::UpdateBand(_this, Rixmap::Channel::ALPHA, argBand);
+    return argBand;
+}
+
+/**
+ * スキャンライン内のピクセルデータの、輝度値のみのバイトデータを配列で取得します.
+ * 輝度値チャンネルを持たない場合や、スキャンラインが無効な場合はnilを返します.
+ *
+ * @return [Array<Integer>] 輝度値のみのバイトデータ.
+ */
+static VALUE ImageLine_getLuminanceBand(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return RixmapHelper::GetBand(_this, Rixmap::Channel::LUMINANCE);
+}
+
+/**
+ * スキャンライン内のピクセルデータの、輝度値のみを更新します.
+ *
+ * @param [String,Array] band 更新データ
+ * @return [void]
+ */
+static VALUE ImageLine_setLuminanceBand(VALUE self, VALUE argBand) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    RixmapHelper::UpdateBand(_this, Rixmap::Channel::LUMINANCE, argBand);
+    return argBand;
+}
+
+/**
+ * スキャンライン内のピクセルデータの、パレットインデックスのみのバイトデータを配列で取得します.
+ * パレットインデックスチャンネルを持たない場合や、スキャンラインが無効な場合はnilを返します.
+ *
+ * @return [Array<Integer>] パレットインデックスのみのバイトデータ.
+ */
+static VALUE ImageLine_getPaletteBand(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    return RixmapHelper::GetBand(_this, Rixmap::Channel::PALETTE);
+}
+
+/**
+ * スキャンライン内のピクセルデータの、パレットインデックスのみを更新します.
+ *
+ * @param [String,Array] band 更新データ
+ * @return [void]
+ */
+static VALUE ImageLine_setPaletteBand(VALUE self, VALUE argBand) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    RixmapHelper::UpdateBand(_this, Rixmap::Channel::PALETTE, argBand);
+    return argBand;
+}
+
+/**
+ * スキャンライン内の指定位置のピクセルデータを取得します.
+ *
+ * ピクセルデータの形式は {Rixmap::Image#[]} を参照してください.
+ *
+ * @param [Integer] offset 取得オフセット
+ * @return [Integer,Array,nil] ピクセルデータ
+ * @see Rixmap::Image#[]
+ */
+static VALUE ImageLine_offsetGet(VALUE self, VALUE argOffset) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    long offset = NUM2LONG(rb_Integer(argOffset));
+
+    return RixmapHelper::GetPixel(_this->getImageData(), offset, _this->getLineNumber());
+}
+
+/**
+ * スキャンライン内の指定位置のピクセルデータを更新します.
+ *
+ * ピクセルデータの形式は {Rixmap::Image#[]=} を参照してください.
+ *
+ * @param [Integer] offset 更新オフセット
+ * @param [Integer,Array,Rixmap::Color] color 更新データ
+ * @return [void]
+ * @see Rixmap::Image#[]=
+ */
+static VALUE ImageLine_offsetSet(VALUE self, VALUE argOffset, VALUE argColor) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    long offset = NUM2LONG(rb_Integer(argOffset));
+
+    RixmapHelper::UpdatePixel(_this->getImageData(), offset, _this->getLineNumber(), argColor);
+
+    return argColor;
+}
+
+/**
+ * スキャンライン内のピクセルデータを配列で返します.
+ *
+ * @return [Array,nil] ピクセルデータの配列. スキャンライン自体が無効な場合はnilになります.
+ * @example
+ *   rgb = Rixmap::Image.new('RGB', 32, 32)
+ *   rgb[0].to_a        #=> [[0, 0, 0], [0, 0, 0], ...]
+ *
+ *   idx = Rixmap::Image.new('INDEXED', 32, 32)
+ *   idx[0].to_a        #=> [0, 0, 0, ...]
+ */
+static VALUE ImageLine_toArray(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    if (_this->isValid()) {
+        Rixmap::ImageData* _parent = _this->getImageData();
+        int32_t length = _this->getLength();
+        int32_t lineno = _this->getLineNumber();
+        VALUE pixels = rb_ary_new2(length);
+        for (int32_t i = 0; i < length; i++) {
+            VALUE pixel = RixmapHelper::GetPixel(_parent, i, lineno);
+            rb_ary_store(pixels, i, pixel);
+        }
+        return pixels;
+    } else {
+        return Qnil;
+    }
+}
+
+/**
+ * スキャンラインのピクセルデータを格納した文字列データ (バイト列データ) を返します.
+ *
+ * @overload to_s(layout=nil)
+ *   ピクセルデータをバイト列として取得します.
+ *   レイアウトが指定されている場合は、対応するチャンネル毎に並べなおします.
+ *   レイアウトが指定されていない場合はバイト列をすべて格納していきます.
+ *   その時、RGB(A)形式は`R-G-B(-A)`の順に並び、GRAYALPHA形式も同様に透明度が後ろになります.
+ *   @param [String,Symbol,Array] layout 各ピクセルの並び順. 使用可能なものは 'R', 'G', 'B', 'A', 'L', 'P' です.
+ *                                       指定されたチャンネルを持たない画像の場合は、その部分は欠落します.
+ *   @see Palette#to_s
+ * @example
+ *   rgb = Rixmap::Image.new('RGB', 32, 32)
+ *   rgb[0].to_s        #=> 96バイト
+ *   rgb[1].to_s('L')   #=> 0バイト (チャンネルを含まないため)
+ *   rgb[2].to_s('R')   #=> 32バイト (赤要素のみ)
+ */
+static VALUE ImageLine_toString(int argc, VALUE* argv, VALUE self) {
+    // 引数解析
+    VALUE argLayout = Qnil;
+    rb_scan_args(argc, argv, "01", &argLayout);
+
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    Rixmap::CharBuffer bytes;
+
+    // 有効かどうかを判定
+    if (_this->isValid()) {
+        Rixmap::ImageData* _parent = _this->getImageData();
+        int32_t length = _this->getLength();
+        int32_t lineno = _this->getLineNumber();
+        const Rixmap::ModeInfo& mode = _parent->getModeInfo();
+        const Rixmap::ChannelArray& channels = mode.getChannels();
+
+        // 対象チャンネルを保存
+        std::vector<Rixmap::Channel> layout;
+        if (NIL_P(argLayout)) {
+            // 無指定の場合はチャンネルデータをすべて有効化
+            for (auto it = channels.begin(); it != channels.end(); it++) {
+                layout.push_back(*it);
+            }
+        } else {
+            // 指定されている場合は解析する
+            // TODO パレットのほうと共通化
+            if (RB_TYPE_P(argLayout, T_ARRAY)) {
+                long arylen = RARRAY_LEN(argLayout);
+                for (long i = 0; i < arylen; i++) {
+                    VALUE item = rb_String(rb_ary_entry(argLayout, i));
+                    item = rb_funcall(item, rb_intern("upcase"), 0);
+                    long  slen = RSTRING_LEN(item);
+                    char* sptr = StringValuePtr(item);
+                    if (slen > 0) {
+                        // 先頭文字を入れる
+                        Rixmap::Channel ch = static_cast<Rixmap::Channel>(sptr[0]);
+                        if (mode.has(ch)) {
+                            // 対応している場合のみ
+                            layout.push_back(ch);
+                        }
+                    }
+                }
+            } else {
+                // 文字列にして各バイトで入れ込む
+                VALUE objLayout = rb_funcall(rb_String(argLayout), rb_intern("upcase"), 0);
+                long  slen = RSTRING_LEN(objLayout);
+                char* sptr = StringValuePtr(objLayout);
+                for (long i = 0; i < slen; i++) {
+                    Rixmap::Channel ch = static_cast<Rixmap::Channel>(sptr[i]);
+                    if (mode.has(ch)) {
+                        layout.push_back(ch);
+                    }
+                }
+            }
+        }
+
+        // 各チャンネル毎にバイトとして追加
+        for (int32_t i = 0; i < length; i++) {
+            for (auto it = layout.begin(); it != layout.end(); it++) {
+                Rixmap::Channel ch = *it;
+                bytes.push_back(_parent->get(ch, i, lineno));
+            }
+        }
+    }
+
+    // 文字列化
+    return rb_enc_str_new(bytes.data(), bytes.size(), rb_ascii8bit_encoding());
+}
+
+/**
+ * スキャンライン内の各ピクセルを走査するイテレータを返します.
+ * ブロックが渡されている場合はイテレータを返す代わりに、各ピクセルデータを引数として
+ * ブロックを呼び出します.
+ *
+ * @overload each()
+ *   ブロックが渡されていない場合はピクセル走査用イテレータを返します.
+ *   @return [Enumerator] ピクセル走査用イテレータ
+ *
+ * @overload each()
+ *   ブロックが渡されている場合は各ピクセルデータを引数として、渡されたブロックを呼び出します.
+ *   戻り値はこのスキャンラインオブジェクトになります.
+ *   @yield [pixel] ピクセルを引数として呼び出します.
+ *   @yieldparam pixel [Integer,Array] ピクセルデータ
+ *   @return [Rixmap::ImageLine] self自身を返します.
+ */
+static VALUE ImageLine_each(VALUE self) {
+    if (rb_block_given_p()) {       // ブロック有り
+        Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+        if (_this->isValid()) {
+            Rixmap::ImageData* _parent = _this->getImageData();
+            int32_t length = _this->getLength();
+            int32_t lineno = _this->getLineNumber();
+            for (int32_t i = 0; i < length; i++) {
+                VALUE pixel = RixmapHelper::GetPixel(_parent, i, lineno);
+                rb_yield_values(1, pixel);
+            }
+        }
+        return self;
+    } else {                        // ブロック無し
+        // TODO サイズ計算関数の追加
+        //      その時は rb_enumeratorize_with_sizeを使おう
+        //      (RETURN_SIZED_ENUMERATORでもいいかも)
+        return rb_enumeratorize(self, ID2SYM(rb_frame_this_func()), 0, NULL);
+    }
+}
+
+/**
+ * オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] 文字列表現
+ */
+static VALUE ImageLine_inspect(VALUE self) {
+    Rixmap::ImageLineData* _this = rixmap_unwrap<Rixmap::ImageLineData>(self);
+    VALUE imageText = rb_inspect(_this->getImage());
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            "#<%s:%p image=%s, lineno=%d>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            StringValueCStr(imageText), _this->getLineNumber());
+}
+/* }}} */
+
+//----------------------------------------------------------------------------//
+// 内部API実装
+//----------------------------------------------------------------------------//
+/**
+ * ライブラリ初期化処理
+ */
+void RixmapCore_Init() {
+    /**
+     * Document-module: Rixmap
+     *
+     * Rixmapライブラリモジュール.
+     */
+    mRixmap = rb_define_module("Rixmap");
+
+    /**
+     * Document-class: Rixmap::Binary
+     *
+     * バイナリ配列クラス.
+     * RubyのArrayと違い、0～255の範囲でしか値を扱えなくしてあります.
+     * この範囲を超える場合はオーバーフローします.
+     *
+     * 上の特徴のため、たとえば {Binary#[]} で得られる値は常に Fixnum になります.
+     */
+    cRixmapBinary = rb_define_class_under(mRixmap, "Binary", rb_cObject);
+    rb_define_alloc_func(cRixmapBinary, Binary_Alloc);
+    rb_define_private_method(cRixmapBinary, "initialize",      RUBY_METHOD_FUNC(Binary_initialize), -1);
+    rb_define_private_method(cRixmapBinary, "initialize_copy", RUBY_METHOD_FUNC(Binary_initializeCopy), 1);
+    rb_define_method(cRixmapBinary, "*",        RUBY_METHOD_FUNC(Binary_operatorMul), 1);
+    rb_define_method(cRixmapBinary, "+",        RUBY_METHOD_FUNC(Binary_operatorAdd), 1);
+    rb_define_method(cRixmapBinary, "<<",       RUBY_METHOD_FUNC(Binary_operatorLShift), 1);
+    rb_define_method(cRixmapBinary, "<=>",      RUBY_METHOD_FUNC(Binary_operatorCompare), 1);
+    rb_define_method(cRixmapBinary, "==",       RUBY_METHOD_FUNC(Binary_operatorEquals), 1);
+    rb_define_method(cRixmapBinary, "[]",       RUBY_METHOD_FUNC(Binary_offsetGet), -1);
+    rb_define_method(cRixmapBinary, "[]=",      RUBY_METHOD_FUNC(Binary_offsetSet), -1);
+    rb_define_method(cRixmapBinary, "at",       RUBY_METHOD_FUNC(Binary_at), 1);
+    rb_define_method(cRixmapBinary, "inspect",  RUBY_METHOD_FUNC(Binary_inspect), 0);
+    rb_define_method(cRixmapBinary, "length",   RUBY_METHOD_FUNC(Binary_getLength), 0);
+    rb_define_method(cRixmapBinary, "push",     RUBY_METHOD_FUNC(Binary_push), -1);
+    rb_define_method(cRixmapBinary, "pop",      RUBY_METHOD_FUNC(Binary_pop), -1);
+    rb_define_method(cRixmapBinary, "shift",    RUBY_METHOD_FUNC(Binary_shift), -1);
+    rb_define_method(cRixmapBinary, "unshift",  RUBY_METHOD_FUNC(Binary_unshift), -1);
+    rb_define_method(cRixmapBinary, "each",     RUBY_METHOD_FUNC(Binary_each), 0);
+    rb_define_method(cRixmapBinary, "reverse",  RUBY_METHOD_FUNC(Binary_copyReverse), 0);
+    rb_define_method(cRixmapBinary, "reverse!", RUBY_METHOD_FUNC(Binary_reverse), 0);
+    rb_define_method(cRixmapBinary, "to_ary",   RUBY_METHOD_FUNC(Binary_toArray), 0);
+    rb_define_method(cRixmapBinary, "to_str",   RUBY_METHOD_FUNC(Binary_toString), 0);
+    rb_define_method(cRixmapBinary, "to_s",     RUBY_METHOD_FUNC(Binary_toTextString), 0);
+    rb_define_method(cRixmapBinary, "to_a",     RUBY_METHOD_FUNC(Binary_toArray), 0);
+    rb_alias(cRixmapBinary, rb_intern("size"), rb_intern("length"));
+    rb_alias(cRixmapBinary, rb_intern("slice"), rb_intern("[]"));
+    rb_include_module(cRixmapBinary, rb_mEnumerable);
+
+    /**
+     * Document-class: Rixmap::Mode
+     *
+     * 画像形式情報クラス.
+     */
+    cRixmapMode = rb_define_class_under(mRixmap, "Mode", rb_cData);
+    rb_undef(CLASS_OF(cRixmapMode), rb_intern("new"));      // インスタンス化させない方針
+    rb_define_alloc_func(cRixmapMode, Mode_Alloc);
+    rb_define_method(cRixmapMode, "name",       RUBY_METHOD_FUNC(Mode_getName), 0);
+    rb_define_method(cRixmapMode, "depth",      RUBY_METHOD_FUNC(Mode_getDepth), 0);
+    rb_define_method(cRixmapMode, "rgb?",       RUBY_METHOD_FUNC(Mode_isRGBType), 0);
+    rb_define_method(cRixmapMode, "grayscale?", RUBY_METHOD_FUNC(Mode_isGrayScaleType), 0);
+    rb_define_method(cRixmapMode, "indexed?",   RUBY_METHOD_FUNC(Mode_isIndexedType), 0);
+    rb_define_method(cRixmapMode, "has_alpha?", RUBY_METHOD_FUNC(Mode_hasAlpha), 0);
+    rb_define_method(cRixmapMode, "to_i",       RUBY_METHOD_FUNC(Mode_toInteger), 0);
+    rb_define_method(cRixmapMode, "inspect",    RUBY_METHOD_FUNC(Mode_inspect), 0);
+    rb_alias(cRixmapMode, rb_intern("to_s"), rb_intern("name"));
+
+    // 画像形式定数を設置
+    /** インデックスカラー形式定数 */
+    rb_define_const(mRixmap, "INDEXED",   RixmapModePool::Get(Rixmap::Mode::INDEXED));
+
+    /** グレースケール形式定数 */
+    rb_define_const(mRixmap, "GRAYSCALE", RixmapModePool::Get(Rixmap::Mode::GRAYSCALE));
+
+    /** 透明度付グレースケール形式定数 */
+    rb_define_const(mRixmap, "GRAYALPHA", RixmapModePool::Get(Rixmap::Mode::GRAYALPHA));
+
+    /** RGBカラー形式定数 */
+    rb_define_const(mRixmap, "RGB",       RixmapModePool::Get(Rixmap::Mode::RGB));
+
+    /** 透明度付RGBカラー形式定数 */
+    rb_define_const(mRixmap, "RGBA",      RixmapModePool::Get(Rixmap::Mode::RGBA));
+
+    /**
+     * Document-class: Rixmap::Color
+     *
+     * RGBカラー情報クラス.
+     *
+     * @example
+     *     c0 = Rixmap::Color.new(16, 32, 48)        # RGBカラー
+     *     c1 = Rixmap::Color.new(16, 32, 48, 96)    # RGBAカラー
+     *     g0 = Rixmap::Color.new(128)               # グレースケール
+     *     g1 = Rixmap::Color.new(128, 128)          # グレースケール (αチャンネル付)
+     *     h0 = RIxmap::Color.new("#00BBCC")         # HTML色表現
+     */
+    cRixmapColor = rb_define_class_under(mRixmap, "Color", rb_cData);
+    rb_undef(CLASS_OF(cRixmapColor), rb_intern("new"));
+    rb_define_alloc_func(cRixmapColor, Color_Alloc);
+    rb_define_singleton_method(cRixmapColor, "new", RUBY_METHOD_FUNC(Color_New), -1);
+    rb_define_method(cRixmapColor, "red",       RUBY_METHOD_FUNC(Color_getRed), 0);
+    rb_define_method(cRixmapColor, "green",     RUBY_METHOD_FUNC(Color_getGreen), 0);
+    rb_define_method(cRixmapColor, "blue",      RUBY_METHOD_FUNC(Color_getBlue), 0);
+    rb_define_method(cRixmapColor, "alpha",     RUBY_METHOD_FUNC(Color_getAlpha), 0);
+    rb_define_method(cRixmapColor, "luminance", RUBY_METHOD_FUNC(Color_getLuminance), 0);
+    rb_define_method(cRixmapColor, "==",        RUBY_METHOD_FUNC(Color_operatorEquals), 1);
+    rb_define_method(cRixmapColor, "[]",        RUBY_METHOD_FUNC(Color_offsetGet), 1);
+    rb_define_method(cRixmapColor, "to_i",      RUBY_METHOD_FUNC(Color_toInteger), 0);
+    rb_define_method(cRixmapColor, "to_a",      RUBY_METHOD_FUNC(Color_toArray), 0);
+    rb_define_method(cRixmapColor, "inspect",   RUBY_METHOD_FUNC(Color_inspect), 0);
+    rb_undef(CLASS_OF(cRixmapColor), rb_intern("clone"));
+    rb_undef(CLASS_OF(cRixmapColor), rb_intern("dup"));
+
+    /**
+     * Document-class: Rixmap::Palette
+     *
+     * パレット情報クラス.
+     *
+     * @todo 文字列からレイアウトに沿って更新するメソッド (#to_s の逆) の実装
+     */
+    cRixmapPalette = rb_define_class_under(mRixmap, "Palette", rb_cObject);
+    rb_define_alloc_func(cRixmapPalette, Palette_Alloc);
+    rb_define_private_method(cRixmapPalette, "initialize",      RUBY_METHOD_FUNC(Palette_initialize), -1);
+    rb_define_private_method(cRixmapPalette, "initialize_copy", RUBY_METHOD_FUNC(Palette_initializeCopy), 1);
+    rb_define_method(cRixmapPalette, "size",     RUBY_METHOD_FUNC(Palette_getSize), 0);
+    rb_define_method(cRixmapPalette, "[]",       RUBY_METHOD_FUNC(Palette_offsetGet), 1);
+    rb_define_method(cRixmapPalette, "[]=",      RUBY_METHOD_FUNC(Palette_offsetSet), 2);
+    rb_define_method(cRixmapPalette, "==",       RUBY_METHOD_FUNC(Palette_operatorEquals), 1);
+    rb_define_method(cRixmapPalette, "to_s",     RUBY_METHOD_FUNC(Palette_toString), -1);       // バイト列への変換
+    rb_define_method(cRixmapPalette, "to_a",     RUBY_METHOD_FUNC(Palette_toArray), 0);         // カラー配列への変換 (self.each.to_aでもいいかも)
+    rb_define_method(cRixmapPalette, "each",     RUBY_METHOD_FUNC(Palette_each), 0);
+    rb_define_method(cRixmapPalette, "inspect",  RUBY_METHOD_FUNC(Palette_inspect), 0);
+    rb_include_module(cRixmapPalette, rb_mEnumerable);
+
+    /**
+     * Document-class: Rixmap::Palette::VGA
+     *
+     * 16色 VGAパレットクラス.
+     */
+    VALUE cRixmapVGAPalette = rb_define_class_under(cRixmapPalette, "VGA", cRixmapPalette);
+    rb_define_private_method(cRixmapVGAPalette, "initialize", RUBY_METHOD_FUNC(VGAPalette_initialize), 0);
+
+    /**
+     * Document-class: Rixmap::Palette::WebSafe
+     *
+     * 216色 ウェブセーフカラーパレットクラス.
+     */
+    VALUE cRixmapWebSafePalette = rb_define_class_under(cRixmapPalette, "WebSafe", cRixmapPalette);
+    rb_define_private_method(cRixmapWebSafePalette, "initialize", RUBY_METHOD_FUNC(WebSafePalette_initialize), 0);
+
+    /**
+     * Document-class: Rixmap::Image
+     *
+     * 画像クラス.
+     */
+    cRixmapImage = rb_define_class_under(mRixmap, "Image", rb_cObject);
+    rb_define_alloc_func(cRixmapImage, Image_Alloc);
+    rb_define_private_method(cRixmapImage, "initialize", RUBY_METHOD_FUNC(Image_initialize), -1);
+    rb_define_method(cRixmapImage, "mode",       RUBY_METHOD_FUNC(Image_getMode), 0);
+    rb_define_method(cRixmapImage, "width",      RUBY_METHOD_FUNC(Image_getWidth), 0);
+    rb_define_method(cRixmapImage, "height",     RUBY_METHOD_FUNC(Image_getHeight), 0);
+    rb_define_method(cRixmapImage, "palette",    RUBY_METHOD_FUNC(Image_getPalette), 0);
+    rb_define_method(cRixmapImage, "palette=",   RUBY_METHOD_FUNC(Image_setPalette), 1);
+    rb_define_method(cRixmapImage, "size",       RUBY_METHOD_FUNC(Image_getSize), 0);
+    rb_define_method(cRixmapImage, "dimension",  RUBY_METHOD_FUNC(Image_getDimension), 0);
+    rb_define_method(cRixmapImage, "indexed?",   RUBY_METHOD_FUNC(Image_isIndexedImage), 0);
+    rb_define_method(cRixmapImage, "grayscale?", RUBY_METHOD_FUNC(Image_isGrayScaleImage), 0);
+    rb_define_method(cRixmapImage, "rgb?",       RUBY_METHOD_FUNC(Image_isRGBImage), 0);
+    rb_define_method(cRixmapImage, "has_alpha?", RUBY_METHOD_FUNC(Image_hasAlphaChannel), 0);
+    rb_define_method(cRixmapImage, "[]",         RUBY_METHOD_FUNC(Image_offsetGet), -1);
+    rb_define_method(cRixmapImage, "[]=",        RUBY_METHOD_FUNC(Image_offsetSet), -1);
+    rb_define_method(cRixmapImage, "==",         RUBY_METHOD_FUNC(Image_operatorEquals), 1);
+    rb_define_method(cRixmapImage, "each_line",  RUBY_METHOD_FUNC(Image_eachLine), 0);
+    rb_define_method(cRixmapImage, "each_pixel", RUBY_METHOD_FUNC(Image_eachPixel), 0);
+    rb_define_method(cRixmapImage, "lines",      RUBY_METHOD_FUNC(Image_getLines), 0);
+    rb_define_method(cRixmapImage, "pixels",     RUBY_METHOD_FUNC(Image_getPixels), 0);
+    rb_define_method(cRixmapImage, "inspect",    RUBY_METHOD_FUNC(Image_inspect), 0);
+    rb_alias(cRixmapImage, rb_intern("dim"), rb_intern("dimension"));
+
+    /**
+     * Document-class: Rixmap::Image::Line
+     *
+     * スキャンラインクラス.
+     *
+     * @todo 文字列からレイアウトに沿って更新するメソッド (#to_s の逆) の実装
+     */
+    cRixmapImageLine = rb_define_class_under(cRixmapImage, "Line", rb_cObject);
+    rb_define_alloc_func(cRixmapImageLine, ImageLine_Alloc);
+    rb_define_private_method(cRixmapImageLine, "initialize", RUBY_METHOD_FUNC(ImageLine_initialize), 2);
+    rb_define_method(cRixmapImageLine, "image",      RUBY_METHOD_FUNC(ImageLine_getImage), 0);
+    rb_define_method(cRixmapImageLine, "lineno",     RUBY_METHOD_FUNC(ImageLine_getLineNumber), 0);
+    rb_define_method(cRixmapImageLine, "valid?",     RUBY_METHOD_FUNC(ImageLine_isValid), 0);
+    rb_define_method(cRixmapImageLine, "red",        RUBY_METHOD_FUNC(ImageLine_getRedBand), 0);
+    rb_define_method(cRixmapImageLine, "red=",       RUBY_METHOD_FUNC(ImageLine_setRedBand), 1);
+    rb_define_method(cRixmapImageLine, "green",      RUBY_METHOD_FUNC(ImageLine_getGreenBand), 0);
+    rb_define_method(cRixmapImageLine, "green=",     RUBY_METHOD_FUNC(ImageLine_setGreenBand), 1);
+    rb_define_method(cRixmapImageLine, "blue",       RUBY_METHOD_FUNC(ImageLine_getBlueBand), 0);
+    rb_define_method(cRixmapImageLine, "blue=",      RUBY_METHOD_FUNC(ImageLine_setBlueBand), 1);
+    rb_define_method(cRixmapImageLine, "alpha",      RUBY_METHOD_FUNC(ImageLine_getAlphaBand), 0);
+    rb_define_method(cRixmapImageLine, "alpha=",     RUBY_METHOD_FUNC(ImageLine_setAlphaBand), 1);
+    rb_define_method(cRixmapImageLine, "luminance",  RUBY_METHOD_FUNC(ImageLine_getLuminanceBand), 0);
+    rb_define_method(cRixmapImageLine, "luminance=", RUBY_METHOD_FUNC(ImageLine_setLuminanceBand), 1);
+    rb_define_method(cRixmapImageLine, "palette",    RUBY_METHOD_FUNC(ImageLine_getPaletteBand), 0);
+    rb_define_method(cRixmapImageLine, "palette=",   RUBY_METHOD_FUNC(ImageLine_setPaletteBand), 1);
+    rb_define_method(cRixmapImageLine, "[]",         RUBY_METHOD_FUNC(ImageLine_offsetGet), 1);
+    rb_define_method(cRixmapImageLine, "[]=",        RUBY_METHOD_FUNC(ImageLine_offsetSet), 2);
+    rb_define_method(cRixmapImageLine, "to_a",       RUBY_METHOD_FUNC(ImageLine_toArray), 0);
+    rb_define_method(cRixmapImageLine, "to_s",       RUBY_METHOD_FUNC(ImageLine_toString), -1);
+    rb_define_method(cRixmapImageLine, "each",       RUBY_METHOD_FUNC(ImageLine_each), 0);
+    rb_define_method(cRixmapImageLine, "inspect",    RUBY_METHOD_FUNC(ImageLine_inspect), 0);
+    rb_alias(cRixmapImageLine, rb_intern("to_ary"), rb_intern("to_a"));
+    rb_include_module(cRixmapImageLine, rb_mEnumerable);
+
+    // グローバル変数としてマーク
+    rb_global_variable(&mRixmap);
+    rb_global_variable(&cRixmapBinary);
+    rb_global_variable(&cRixmapMode);
+    rb_global_variable(&cRixmapColor);
+    rb_global_variable(&cRixmapPalette);
+    rb_global_variable(&cRixmapImage);
+    rb_global_variable(&cRixmapImageLine);
+}
+
+
+//============================================================================//
+// $Id: rixmapcore.cxx,v 5b9a0968eca5 2014/04/20 13:37:36 chikuchikugonzalez $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: