rixmap 0.2.1 → 0.3.0

data/src/rixmapdeformation.cxx

@@ -3,6 +3,7 @@
  * Rixmap変形処理実装
  */
 #include "rixmapdeformation.hxx"
+#include "rixmaphelper.hxx"
 
 //----------------------------------------------------------------------------//
 // グローバル変数実体
@@ -12,11 +13,6 @@ VALUE cRixmapBaseDeformer   = Qnil;
 VALUE cRixmapAffineDeformer = Qnil;
 VALUE cRixmapAffineMatrix   = Qnil;
 
-//VALUE cRixmapAffinePoint       = Qnil;
-//VALUE cRixmapAffineCenter      = Qnil;
-//VALUE cRixmapAffineScale       = Qnil;
-//VALUE cRixmapAffineTranslation = Qnil;
-
 //----------------------------------------------------------------------------//
 // 変換系クラス実装
 //----------------------------------------------------------------------------//
@@ -247,7 +243,8 @@ static VALUE AffineDeformer_deform(int argc, VALUE* argv, VALUE self) {
         }
 
         // 保存先画像を作成
-        VALUE dstImageObject = RixmapImage_NewInstance(ipo->getPreferredMode(), newWidth, newHeight, srcImage->getMetadata());
+        VALUE srcMetadata    = Rixmap::Helper::GetImageMetadata(*srcImage);
+        VALUE dstImageObject = RixmapImage_NewInstance(ipo->getPreferredMode(), newWidth, newHeight, srcMetadata);
         Rixmap::ImageData* dstImage = rixmap_unwrap<Rixmap::ImageData>(dstImageObject);
 
         // 移動先チャンネルリスト
@@ -523,44 +520,6 @@ static VALUE AffineMatrix_inspect(VALUE self) {
             static_cast<int>(_this->getSkew()));
 }
 /* }}} */
-///* Rixmap::Deformer::AffineMatrix::Point {{{ */
-///**
-// * @overload initialize(x=0.0, y=0.0)
-// *   座標オブジェクトを初期化します.
-// *   @param [Float] x X軸方向データ
-// *   @param [Float] y Y軸方向データ
-// *   @return [void]
-// */
-//static VALUE AffinePoint_initialize(int argc, VALUE* argv, VALUE self) {
-//    VALUE argX = Qnil, argY = Qnil;
-//    rb_scan_args(argc, argv, "02", &argX, &argY);
-//
-//    if (NIL_P(argX)) {
-//        rb_iv_set(self, "@x", DBL2NUM(0.0));
-//    } else {
-//        rb_iv_set(self, "@x", rb_Float(argX));
-//    }
-//    if (NIL_P(argY)) {
-//        rb_iv_set(self, "@y", DBL2NUM(0.0));
-//    } else {
-//        rb_iv_set(self, "@y", DBL2NUM(argY));
-//    }
-//
-//    return self;
-//}
-//
-///**
-// * 座標オブジェクトの複製を初期化します.
-// *
-// * @param [Object] object 複製元
-// * @return [void]
-// */
-//static VALUE AffinePoint_initializeCopy(VALUE self, VALUE argObject) {
-//    rb_iv_set(self, "@x", rb_iv_get(argObject, "@x"));
-//    rb_iv_set(self, "@y", rb_iv_get(argObject, "@y"));
-//    return self;
-//}
-///* }}} */
 
 //----------------------------------------------------------------------------//
 // 内部API実装
@@ -637,51 +596,14 @@ void RixmapDeformation_Init() {
     rb_alias(cRixmapAffineMatrix, rb_intern("trans"), rb_intern("translation"));
     rb_alias(cRixmapAffineMatrix, rb_intern("trans="), rb_intern("translation="));
 
-//    /**
-//     * Document-class: Rixmap::Deformer::AffineMatrix::Point
-//     *
-//     * アフィン変換用座標構造体.
-//     * FIXME 外出しするかも
-//     */
-//    cRixmapAffinePoint = rb_define_class_under(cRixmapAffineMatrix, "Point", rb_cObject);
-//    rb_define_private_method(cRixmapAffinePoint, "initialize", RUBY_METHOD_FUNC(AffinePoint_initialize), -1);
-//    rb_define_private_method(cRixmapAffinePoint, "initialize_copy", RUBY_METHOD_FUNC(AffinePoint_initializeCopy), 1);
-//    rb_define_attr(cRixmapAffinePoint, "x", 1, 1);
-//    rb_define_attr(cRixmapAffinePoint, "y", 1, 1);
-//
-//    /**
-//     * Document-class: Rixmap::Deformer::AffineMatrix::Center
-//     *
-//     * アフィン変換用中央座標構造体.
-//     */
-//    cRixmapAffineCenter = rb_define_class_under(cRixmapAffineMatrix, "Center", cRixmapAffinePoint);
-//
-//    /**
-//     * Document-class: Rixmap::Deformer::AffineMatrix::Scale
-//     *
-//     * アフィン変換用拡大率構造体.
-//     */
-//    cRixmapAffineScale = rb_define_class_under(cRixmapAffineMatrix, "Scale", cRixmapAffinePoint);
-//
-//    /**
-//     * Document-class: Rixmap::Deformer::AffineMatrix::Translation
-//     *
-//     * アフィン変換用平行移動量構造体.
-//     */
-//    cRixmapAffineTranslation = rb_define_class_under(cRixmapAffineMatrix, "Translation", cRixmapAffinePoint);
-
     // GCから保護しておく
     rb_global_variable(&mRixmapDeformer);
     rb_global_variable(&cRixmapBaseDeformer);
     rb_global_variable(&cRixmapAffineDeformer);
     rb_global_variable(&cRixmapAffineMatrix);
-//    rb_global_variable(&cRixmapAffinePoint);
-//    rb_global_variable(&cRixmapAffineCenter);
-//    rb_global_variable(&cRixmapAffineScale);
-//    rb_global_variable(&cRixmapAffineTranslation);
 }
 
 
 //============================================================================//
-// $Id: rixmapdeformation.cxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// $Id: rixmapdeformation.cxx,v 6e4defc69a98 2014/05/23 17:15:06 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmaphelper.cxx

@@ -0,0 +1,501 @@
+// -*- coding: utf-8 -*-
+/**
+ * Rixmap実装用ヘルパー関数実装.
+ */
+#include "rixmaphelper.hxx"
+
+/* Rixmap::Helper::UpdatePalette {{{ */
+bool Rixmap::Helper::UpdatePalette(Rixmap::PaletteData* palette, long offset, VALUE object) {
+    Rixmap::Color color(0, 0, 0, 255);
+
+    // カラーオブジェクトを解析
+    if (RB_TYPE_P(object, T_STRING)) {
+        // Color.newを使ってオブジェクトを構築
+        VALUE objColor = rb_funcall(cRixmapColor, rb_intern("new"), 1, object);
+        Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(objColor);
+        color = data->getColor();
+    } else if (RTEST(rb_obj_is_kind_of(object, cRixmapColor))) {
+        // Rixmap::Colorそのもの
+        Rixmap::ColorData* data = rixmap_unwrap<Rixmap::ColorData>(object);
+        color = data->getColor();
+    } else {
+        // 配列から
+        VALUE aryColor = rb_Array(object);
+        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();
+    }
+
+    // 範囲チェック && 更新
+    // FIXME unsignedからsignedへの変換になってる
+    //long length = static_cast<long>(palette->getSize());
+    try {
+        palette->set(offset, color);
+        return true;
+    } catch (const std::out_of_range& e) {
+        // ( ´ﾟдﾟ｀)ｴｰ
+        rb_warning(e.what());
+        return false;
+    }
+}
+/* }}} */
+/* Rixmap::Helper::LayoutChannels {{{ */
+bool Rixmap::Helper::LayoutChannels(VALUE layout, Rixmap::ChannelArray& channels) {
+    if (NIL_P(layout)) {
+        return false;
+    }
+
+    Rixmap::ChannelArray dst;
+    if (RB_TYPE_P(layout, T_ARRAY)) {
+        // 配列の場合は各要素を文字列にして、その先頭を使う
+        long length = RARRAY_LEN(layout);
+        for (long i = 0; i < length; i++) {
+            VALUE item = rb_funcall(rb_String(rb_ary_entry(layout, i)), rb_intern("upcase"), 0);
+            long  slen = RSTRING_LEN(item);
+            char* sptr = StringValuePtr(item);
+            if (slen > 0) {
+                // 先頭をチャンネルに
+                Rixmap::Channel channel = static_cast<Rixmap::Channel>(sptr[0]);
+                dst.push_back(channel);
+            }
+        }
+    } else {
+        // 配列以外は文字列として扱い、各文字を使う
+        VALUE str = rb_funcall(rb_String(layout), rb_intern("upcase"), 0);
+        long  slen = RSTRING_LEN(str);
+        char* sptr = StringValuePtr(str);
+        for (long i = 0; i < slen; i++) {
+            Rixmap::Channel channel = static_cast<Rixmap::Channel>(sptr[i]);
+            dst.push_back(channel);
+        }
+    }
+
+    // チャンネルリストが空の場合は失敗とみなす
+    if (dst.empty()) {
+        return false;
+    }
+
+    // 入れ替える
+    channels.insert(channels.end(), dst.begin(), dst.end());
+    return true;
+}
+/* }}} */
+/* Rixmap::Helper::GetPixel {{{ */
+VALUE Rixmap::Helper::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;
+    }
+}
+/* }}} */
+/* Rixmap::Helper::UpdatePixel {{{ */
+void Rixmap::Helper::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);
+    }
+}
+/* }}} */
+/* Rixmap::Helper::GetBand {{{ */
+VALUE Rixmap::Helper::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;
+    }
+}
+/* }}} */
+/* Rixmap::Helper::UpdateBand {{{ */
+bool Rixmap::Helper::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::Helper::GetImageConverter {{{ */
+Rixmap::Converter* Rixmap::Helper::GetImageConverter(const Rixmap::Mode input, const Rixmap::Mode output) {
+    // コンバータオブジェクト
+    // FIXME これ大丈夫かしら
+    static Rixmap::RGB2GrayScaleConverter   rgb2gray;
+    static Rixmap::RGB2IndexConverter       rgb2index;
+    static Rixmap::GrayScale2RGBConverter   gray2rgb;
+    static Rixmap::GrayScale2IndexConverter gray2index;
+    static Rixmap::Index2RGBConverter       index2rgb;
+    static Rixmap::Index2GrayScaleConverter index2gray;
+
+    // チャンネル増減
+    static Rixmap::RGB2RGBConverter         rgb2rgb;
+    static Rixmap::GrayScale2RGBConverter   gray2gray;
+    static Rixmap::Index2IndexConverter     index2index;
+
+    // 判別処理
+    switch (input) {
+    case Rixmap::Mode::INDEXED:
+        switch (output) {
+        case Rixmap::Mode::INDEXED:
+            return &index2index;
+
+        case Rixmap::Mode::RGB:
+        case Rixmap::Mode::RGBA:
+            return &index2rgb;
+
+        case Rixmap::Mode::GRAYSCALE:
+        case Rixmap::Mode::GRAYALPHA:
+            return &index2gray;
+
+        default:
+            // 何もできない
+            // (警告抑制)
+            break;
+        }
+        break;
+
+    case Rixmap::Mode::RGB:
+    case Rixmap::Mode::RGBA:
+        switch (output) {
+        case Rixmap::Mode::RGB:
+        case Rixmap::Mode::RGBA:
+            return &rgb2rgb;
+
+        case Rixmap::Mode::GRAYSCALE:
+        case Rixmap::Mode::GRAYALPHA:
+            return &rgb2gray;
+
+        case Rixmap::Mode::INDEXED:
+            return &rgb2index;
+
+        default:
+            // 何もできない
+            // (警告抑制)
+            break;
+        }
+        break;
+
+    case Rixmap::Mode::GRAYSCALE:
+    case Rixmap::Mode::GRAYALPHA:
+        switch (output) {
+        case Rixmap::Mode::GRAYSCALE:
+        case Rixmap::Mode::GRAYALPHA:
+            return &gray2gray;
+
+        case Rixmap::Mode::RGB:
+        case Rixmap::Mode::RGBA:
+            return &gray2rgb;
+
+        case Rixmap::Mode::INDEXED:
+            return &gray2index;
+
+        default:
+            // 何もできない
+            // (警告抑制)
+            break;
+        }
+        break;
+
+    default:
+        // 何もできない
+        // (警告抑制)
+        break;
+    }
+
+    // 見つからない
+    std::ostringstream err;
+    err << "image converter between "
+        << Rixmap::ModeInfo::GetModeName(input) << " and "
+        << Rixmap::ModeInfo::GetModeName(output) << " is not implemented.";
+    throw std::invalid_argument(err.str());
+}
+/* }}} */
+/* Rixmap::Helper::GetBackgroundValue {{{ */
+VALUE Rixmap::Helper::GetBackgroundValue(const Rixmap::ImageData& image, const Rixmap::BackgroundColor& bg) {
+    const Rixmap::ModeInfo& mode = image.getModeInfo();
+    if (bg.isDisabled()) {
+        // 無効な場合はnil
+        return Qnil;
+    }
+
+    if (mode.isIndexedType()) {
+        // パレット番号
+        return INT2FIX(bg.getPalette());
+    } else if (mode.isGrayScaleType()) {
+        // 輝度値
+        return INT2FIX(bg.getLuminance());
+    } else if (mode.isRGBType()) {
+        // Color Poolから拾う
+        Rixmap::Color color(bg.getRed(), bg.getGreen(), bg.getBlue());
+        return RixmapColorPool::Get(color);
+    } else {
+        return Qnil;
+    }
+}
+/* }}} */
+/* Rixmap::Helper::GetBackgroundAsColor {{{ */
+VALUE Rixmap::Helper::GetBackgroundAsColor(const Rixmap::ImageData& image, const Rixmap::BackgroundColor& bg) {
+    Rixmap::Color color;
+    const Rixmap::ModeInfo& mode = image.getModeInfo();
+    if (bg.isDisabled()) {
+        // 無効な場合はnil
+        return Qnil;
+    }
+
+    if (mode.isIndexedType()) {
+        color = image.getPaletteData()->get(bg.getPalette());
+    } else if (mode.isGrayScaleType()) {
+        color.setLuminance(bg.getLuminance());
+    } else if (mode.isRGBType()) {
+        color.setRed(bg.getRed());
+        color.setGreen(bg.getGreen());
+        color.setBlue(bg.getBlue());
+    } else {
+        return Qnil;
+    }
+
+    return RixmapColorPool::Get(color);
+}
+/* }}} */
+/* Rixmap::Helper::SetBackgroundValue {{{ */
+bool Rixmap::Helper::SetBackgroundValue(const Rixmap::ImageData& image, Rixmap::BackgroundColor& bg, VALUE value) {
+    const Rixmap::ModeInfo& mode = image.getModeInfo();
+    if (RTEST(value)) {
+        if (RB_TYPE_P(value, T_TRUE)) {
+            bg.enable();
+            return true;
+        } else if (RB_TYPE_P(value, T_FIXNUM)) {
+            uint8_t v = static_cast<uint8_t>(FIX2INT(value));
+            if (mode.isIndexedType()) {
+                bg.setPalette(v);
+                const Rixmap::PaletteData* palette = image.getPaletteData();
+                if (palette != NULL) {
+                    const Rixmap::Color& color = palette->get(v);
+                    bg.setRed(color.getRed());
+                    bg.setGreen(color.getGreen());
+                    bg.setBlue(color.getBlue());
+                }
+            } else if (mode.isGrayScaleType()) {
+                bg.setLuminance(v);
+                bg.setRed(v);
+                bg.setGreen(v);
+                bg.setBlue(v);
+            } else {
+                // RGBの場合はエラーになる
+                rb_raise(rb_eArgError, "'%s' is unexpected value type for %s image.", rb_obj_classname(value), Rixmap::ModeInfo::GetModeName(mode.getMode()).c_str());
+                return false;
+            }
+            bg.enable();
+            return true;
+        } else if (RB_TYPE_P(value, T_ARRAY) || RTEST(rb_obj_is_kind_of(value, cRixmapColor))) {
+            Rixmap::ColorData* color = NULL;
+
+            // 色要素の取得
+            if (RB_TYPE_P(value, T_ARRAY)) {
+                // 配列の場合、それを引数にColorを作る
+                VALUE ary = rb_Array(value);
+                long arySize = RARRAY_LEN(ary);
+                VALUE* aryPtr = RARRAY_PTR(ary);
+                VALUE objColor = rb_funcall2(cRixmapColor, rb_intern("new"), arySize, aryPtr);
+                color = rixmap_unwrap<Rixmap::ColorData>(objColor);
+            } else {
+                color = rixmap_unwrap<Rixmap::ColorData>(value);
+            }
+
+            if (mode.isIndexedType()) {
+                // 最も近い色を探す
+                uint8_t offset = static_cast<uint8_t>(image.getPaletteData()->closest(color->getColor()));
+                bg.setPalette(offset);
+
+                // RGB値も保存
+                bg.setRed(color->getRed());
+                bg.setGreen(color->getGreen());
+                bg.setBlue(color->getBlue());
+            } else if (mode.isGrayScaleType()) {
+                // 輝度値を入れる
+                bg.setLuminance(color->getLuminance());
+
+                // RGB値も保存
+                bg.setRed(color->getRed());
+                bg.setGreen(color->getGreen());
+                bg.setBlue(color->getBlue());
+            } else if (mode.isRGBType()) {
+                // パレットはなし (0)
+                bg.setPalette(0);
+
+                // 輝度値は計算する
+                bg.setLuminance(color->getLuminance());
+
+                // RGBの各要素を使う
+                bg.setRed(color->getRed());
+                bg.setGreen(color->getGreen());
+                bg.setBlue(color->getBlue());
+            } else {
+                rb_raise(rb_eArgError, "'%s' is unexpected value type for %s image.", rb_obj_classname(value), Rixmap::ModeInfo::GetModeName(mode.getMode()).c_str());
+                return false;
+            }
+            bg.enable();
+            return true;
+        }
+
+        // ここに来た場合はエラーにする
+        rb_raise(rb_eArgError, "'%s' is unexpected value type for %s image.", rb_obj_classname(value), Rixmap::ModeInfo::GetModeName(mode.getMode()).c_str());
+        return false;
+    } else {
+        bg.disable();
+        return false;
+    }
+}
+/* }}} */
+/* Rixmap::Helper::GetImageMetadata {{{ */
+VALUE Rixmap::Helper::GetImageMetadata(const Rixmap::ImageData& image) {
+    VALUE metadata = rb_hash_new();
+    rb_hash_aset(metadata, ID2SYM(rb_intern("palette")), image.getPalette());
+    rb_hash_aset(metadata, ID2SYM(rb_intern("background")), GetBackgroundAsColor(image, image.getBackground()));
+    rb_hash_aset(metadata, ID2SYM(rb_intern("transparent")), GetBackgroundAsColor(image, image.getTransparent()));
+    return metadata;
+}
+/* }}} */
+
+
+//============================================================================//
+// $Id: rixmaphelper.cxx,v 5590f3c64493 2014/05/31 14:59:34 chikuchikugonzalez $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: