rixmap 0.1.1 → 0.2.0

data/src/rixmap/helper.hxx

@@ -0,0 +1,347 @@
+// -*- coding: utf-8 -*-
+/**
+ * Rixmap実装時のヘルパー関数定義.
+ * 一応グローバルに使えるようなものを定義しておきます.
+ *
+ * ※ API系列とはまた別
+ */
+#pragma once
+#include "common.hxx"
+#include "color.hxx"
+#include "palette.hxx"
+#include "image.hxx"
+#include "converter.hxx"
+#include "interpolator.hxx"
+
+namespace Rixmap {
+
+    /**
+     * ヘルパー関数名前空間
+     */
+    namespace Helper {
+        /**
+         * パレットデータを更新します.
+         *
+         * @param [Rixmap::PaletteData*] palette
+         * @param [long] offset
+         * @param [VALUE] object
+         * @return [bool] 更新できた場合はtrue. 更新できなかった場合はfalse
+         */
+        static bool 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;
+            }
+        }
+
+        /**
+         * ピクセルを取得します.
+         */
+        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;
+            }
+        }
+
+        /**
+         * 画像形式変換処理クラスオブジェクトを取得します.
+         */
+        static Rixmap::Converter* 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 */
+}   /* Rixmap */
+
+
+//============================================================================//
+// $Id: helper.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: