rixmap 0.1.1 → 0.2.0

data/src/rixmapcore.hxx

@@ -20,8 +20,15 @@ extern VALUE cRixmapImageLine;
 // コアAPI関数プロトタイプ
 //----------------------------------------------------------------------------//
 extern void RixmapCore_Init();
+extern VALUE RixmapPalette_NewInstance(size_t size = 256);
+extern VALUE RixmapPalette_NewRedScaleInstance();
+extern VALUE RixmapPalette_NewGreenScaleInstance();
+extern VALUE RixmapPalette_NewBlueScaleInstance();
+extern VALUE RixmapPalette_NewGrayScaleInstance();
+extern VALUE RixmapImage_NewInstance(Rixmap::Mode mode, int32_t width, int32_t height, VALUE options = Qnil);
+extern VALUE RixmapImageLine_NewInstance(VALUE image, int32_t lineno);
 
 
 //============================================================================//
-// $Id: rixmapcore.hxx,v add33526d522 2014/04/19 16:27:29 chikuchikugonzalez $
+// $Id: rixmapcore.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmapdeformation.cxx

@@ -0,0 +1,687 @@
+// -*- coding: utf-8 -*-
+/**
+ * Rixmap変形処理実装
+ */
+#include "rixmapdeformation.hxx"
+
+//----------------------------------------------------------------------------//
+// グローバル変数実体
+//----------------------------------------------------------------------------//
+VALUE mRixmapDeformer       = Qnil;
+VALUE cRixmapBaseDeformer   = Qnil;
+VALUE cRixmapAffineDeformer = Qnil;
+VALUE cRixmapAffineMatrix   = Qnil;
+
+//VALUE cRixmapAffinePoint       = Qnil;
+//VALUE cRixmapAffineCenter      = Qnil;
+//VALUE cRixmapAffineScale       = Qnil;
+//VALUE cRixmapAffineTranslation = Qnil;
+
+//----------------------------------------------------------------------------//
+// 変換系クラス実装
+//----------------------------------------------------------------------------//
+/* Rixmap::Deformer::BaseDeformer {{{ */
+static void BaseDeformer_Free(Rixmap::DeformerData* data) {
+    rixmap_xdelete(data);
+}
+
+static VALUE BaseDeformer_Alloc(VALUE klass) {
+    Rixmap::DeformerData* data = rixmap_xnew<Rixmap::DeformerData>();
+    return Data_Wrap_Struct(klass, RIXMAP_DEFAULT_MARK, BaseDeformer_Free, data);
+}
+
+/**
+ * @overload initialize(ipo = nil)
+ *   変形処理ベースを初期化します.
+ *
+ *   @param [Symbol,String,Integer,nil] ipo 補間処理方法 (Default: nil)
+ *   @return [void]
+ */
+static VALUE BaseDeformer_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE argIPO = Qnil;
+    rb_scan_args(argc, argv, "01", &argIPO);
+    rb_funcall(self, rb_intern("interpolator="), 1, argIPO);
+    return self;
+}
+
+/**
+ * 画素補間処理方法を返します.
+ *
+ * @return [Integer] 画素補間処理方法.
+ */
+static VALUE BaseDeformer_getInterpolator(VALUE self) {
+    Rixmap::DeformerData* _this = rixmap_unwrap<Rixmap::DeformerData>(self);
+    switch (_this->getInterpolation()) {
+    case Rixmap::Interpolation::BICUBIC:
+        return INT2FIX(static_cast<int>(_this->getInterpolation()));
+
+    default:
+        return Qnil;
+    }
+}
+
+/**
+ * 画素補間処理方法を設定します.
+ *
+ * @param [Symbol,String,Integer,nil] ipo 画素補間処理方法.
+ * @return [void]
+ */
+static VALUE BaseDeformer_setInterpolator(VALUE self, VALUE argIPO) {
+    Rixmap::DeformerData* _this = rixmap_unwrap<Rixmap::DeformerData>(self);
+    if (NIL_P(argIPO)) {
+        _this->setInterpolation(Rixmap::Interpolation::NONE);
+    } else if (RB_TYPE_P(argIPO, T_FIXNUM)) {
+        Rixmap::Interpolation ipo = static_cast<Rixmap::Interpolation>(FIX2INT(argIPO));
+        switch (ipo) {
+        case Rixmap::Interpolation::BICUBIC:
+            _this->setInterpolation(ipo);
+            break;
+
+        default:
+            _this->setInterpolation(Rixmap::Interpolation::NONE);
+            break;
+        }
+    } else {
+        VALUE strIPO = rb_str_new_cstr("IPO_");
+        strIPO = rb_str_concat(strIPO, rb_funcall(rb_String(argIPO), rb_intern("upcase"), 0));
+        if (rb_const_defined(mRixmapDeformer, rb_intern_str(strIPO))) {
+            VALUE objIPO = rb_const_get(mRixmapDeformer, rb_intern_str(strIPO));
+            _this->setInterpolation(static_cast<Rixmap::Interpolation>(NUM2INT(rb_Integer(objIPO))));
+        } else {
+            _this->setInterpolation(Rixmap::Interpolation::NONE);
+        }
+    }
+    return argIPO;
+}
+
+/**
+ * @overload deform(image, *args)
+ *   変形処理を実行します.
+ *   @param [Rixmap::Image] image 変形する画像
+ *   @return [Rixmap::Image] 変形された画像
+ */
+static VALUE BaseDeformer_deform(int argc, VALUE* argv, VALUE self) {
+    rb_raise(rb_eNotImpError, "%s#%s is not implemented", rb_obj_classname(self), rb_id2name(rb_frame_this_func()));
+}
+
+/**
+ * オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] 文字列表現
+ */
+static VALUE BaseDeformer_inspect(VALUE self) {
+    Rixmap::DeformerData* _this = rixmap_unwrap<Rixmap::DeformerData>(self);
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            "#<%s:%p ipo=%d>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            static_cast<int>(_this->getInterpolation()));
+}
+/* }}} */
+/* Rixmap::Deformer::AffineDeformer {{{ */
+static void AffineDeformer_Free(Rixmap::AffineDeformerData* data) {
+    rixmap_xdelete(data);
+}
+
+static VALUE AffineDeformer_Alloc(VALUE klass) {
+    Rixmap::AffineDeformerData* data = rixmap_xnew<Rixmap::AffineDeformerData>();
+    return Data_Wrap_Struct(klass, RIXMAP_DEFAULT_MARK, AffineDeformer_Free, data);
+}
+
+/**
+ *
+ * @overload initialize(matrix=nil, ipo=nil)
+ *   アフィン変換による変形処理実装オブジェクトを初期化します.
+ *   @param [Rixmap::Deformer::AffineMatrix] matrix アフィン変換パラメータ
+ *   @param [Symbol,String,Integer,nil] ipo 補間処理方法
+ *   @return [void]
+ *   @see {BaseDeformer#initialize}
+ */
+static VALUE AffineDeformer_initialize(int argc, VALUE* argv, VALUE self) {
+    VALUE argMatrix = Qnil, argIPO = Qnil;
+    rb_scan_args(argc, argv, "02", &argMatrix, &argIPO);
+
+    // 自分を初期化
+    if (NIL_P(argMatrix)) {
+        rb_iv_set(self, "@matrix", rb_class_new_instance(0, NULL, cRixmapAffineMatrix));
+    } else {
+        rb_iv_set(self, "@matrix", argMatrix);
+    }
+
+    // 親を初期化
+    {
+        VALUE sargs[1] = {argIPO};
+        rb_call_super(1, sargs);
+    }
+
+    return self;
+}
+
+/**
+ * @overload deform(image, fit=false)
+ *   アフィン変換による変形処理を実行します.
+ *
+ *   @param [Rixmap::Image] image 対象画像
+ *   @param [Boolean] fit trueの場合は変形後の画像サイズに合うように画像自体を拡大します.
+ *   @return [Rixmap::Image] 変形後画像
+ */
+static VALUE AffineDeformer_deform(int argc, VALUE* argv, VALUE self) {
+    // パラメータ処理
+    VALUE argImage = Qnil, argFit = Qnil;
+    rb_scan_args(argc, argv, "11", &argImage, &argFit);
+
+    // 自分ポインタ
+    Rixmap::AffineDeformerData* _this = rixmap_unwrap<Rixmap::AffineDeformerData>(self);
+
+    // 対象画像
+    Rixmap::ImageData* srcImage = rixmap_unwrap<Rixmap::ImageData>(argImage);
+
+    // 補間処理方法
+    Rixmap::Interpolator* ipo = NULL;
+    switch (_this->getInterpolation()) {
+    case Rixmap::Interpolation::BICUBIC:
+        ipo = new Rixmap::BicubicInterpolator(srcImage);
+        break;
+
+    default:
+        ipo = new Rixmap::NOPInterpolator(srcImage);
+        break;
+    }
+
+    // 画像サイズ調整フラグをC++型に展開
+    bool fit = false;
+    if (RTEST(argFit)) {
+        fit = true;
+    }
+
+    try {
+        // アフィン変換パラメータ
+        VALUE matrixObject = rb_iv_get(self, "@matrix");
+        Rixmap::AffineMatrix* matrix = rixmap_unwrap<Rixmap::AffineMatrix>(matrixObject);
+
+        // 画像サイズ調整
+        int32_t newWidth   = srcImage->getWidth();
+        int32_t newHeight  = srcImage->getHeight();
+        int32_t newXOffset = 0;
+        int32_t newYOffset = 0;
+
+        if (fit) {  // サイズ調整有
+            matrix->matrixize();
+
+            // 座標点を取得
+            Rixmap::Point srcPoints[4] = {
+                {0.0, 0.0},
+                {0.0, static_cast<double>(srcImage->getHeight())},
+                {static_cast<double>(srcImage->getWidth()), 0.0},
+                {static_cast<double>(srcImage->getWidth()), static_cast<double>(srcImage->getHeight())}
+            };
+            Rixmap::Point dstPoint;
+
+            int32_t left   = INT32_MAX;
+            int32_t right  = INT32_MIN;
+            int32_t top    = INT32_MAX;
+            int32_t bottom = INT32_MIN;
+            for (int i = 0; i < 4; i++) {
+                matrix->deform(srcPoints[i], dstPoint);
+                if (dstPoint.x < left) {
+                    left = lround(std::floor(dstPoint.x));
+                }
+                if (dstPoint.x > right) {
+                    right = lround(std::ceil(dstPoint.x));
+                }
+                if (dstPoint.y < top) {
+                    top = lround(std::floor(dstPoint.y));
+                }
+                if (dstPoint.y > bottom) {
+                    bottom = lround(std::ceil(dstPoint.y));
+                }
+            }
+
+            // サイズへ
+            newWidth   = (right - left);
+            newHeight  = (bottom - top);
+            newXOffset = left;
+            newYOffset = top;
+        } else {    // サイズ調整なし
+            // DO NOTHING
+        }
+
+        // 保存先画像を作成
+        VALUE dstImageObject = RixmapImage_NewInstance(ipo->getPreferredMode(), newWidth, newHeight, srcImage->getMetadata());
+        Rixmap::ImageData* dstImage = rixmap_unwrap<Rixmap::ImageData>(dstImageObject);
+
+        // 移動先チャンネルリスト
+        const Rixmap::ChannelArray& channels = dstImage->getModeInfo().getChannels();
+
+        // 変換処理
+        matrix->matrixize();
+        Rixmap::Point src;      // 変形前 (元画像) 座標格納先
+        Rixmap::Point dst;      // 変形後 (返却用画像) 座標格納先
+        for (int32_t dstY = 0; dstY < dstImage->getHeight(); dstY++) {
+            for (int32_t dstX = 0; dstX < dstImage->getWidth(); dstX++) {
+                // 変換前座標を取得
+                dst.x = static_cast<double>(dstX + newXOffset);
+                dst.y = static_cast<double>(dstY + newYOffset);
+                matrix->inverse(dst, src);
+
+                // 補間処理
+                ipo->calculate(src.x, src.y);
+
+                // ピクセルデータを取り込む
+                for (auto it = channels.begin(); it != channels.end(); it++) {
+                    uint8_t byte = ipo->get(*it);
+                    dstImage->set(*it, dstX, dstY, byte);
+                }
+            }
+        }
+
+        return dstImageObject;
+    } catch (const std::exception& e) {
+        if (ipo != NULL) {
+            delete ipo;
+        }
+        rb_raise(rb_eRuntimeError, e.what());
+    }
+}
+/* }}} */
+/* Rixmap::Deformer::AffineMatrix {{{ */
+static void AffineMatrix_Free(Rixmap::AffineMatrixData* data) {
+    rixmap_xdelete(data);
+}
+
+static VALUE AffineMatrix_Alloc(VALUE klass) {
+    Rixmap::AffineMatrixData* data = rixmap_xnew<Rixmap::AffineMatrixData>();
+    return Data_Wrap_Struct(klass, RIXMAP_DEFAULT_MARK, AffineMatrix_Free, data);
+}
+
+/**
+ * アフィン変換パラメータを初期化します.
+ *
+ * @param [Hash] params 初期化パラメータ
+ * @option params [Array<Integer>] :center 変換中心点 (Default: [0, 0]. つまりは左上)
+ * @option params [Array<Integer>] :scale  拡大率 (Default: [1.0, 1.0])
+ * @option params [Array<Integer>] :translation 平行移動量 (Default: [0.0, 0.0])
+ * @option params [Float] :angle 回転角度
+ * @option params [Symbol] :skew 剪断変形方向. `:horizontal`, `:vertical`, `:both` のいずれか.
+ * @return [void]
+ */
+static VALUE AffineMatrix_initialize(int argc, VALUE* argv, VALUE self) {
+    // 引数解析
+    VALUE argParams = Qnil;
+    rb_scan_args(argc, argv, "01", &argParams);
+
+    VALUE objParams = Qnil;
+    if (!NIL_P(argParams)) {
+#if HAVE_RB_HASH
+        objParams = rb_Hash(argParams);
+#else
+        objParams = rb_hash_new();
+#endif
+    } else {
+        objParams = rb_hash_new();
+    }
+
+    VALUE keys = rb_funcall(objParams, rb_intern("keys"), 0);
+    long nkey = RARRAY_LEN(keys);
+    for (long i = 0; i < nkey; i++) {
+        VALUE key = rb_ary_entry(keys, i);
+        VALUE val = rb_hash_lookup(objParams, key);
+
+        // インスタンスメソッドを呼び出し
+        rb_funcall(self, rb_intern_str(rb_String(key)), 1, val);
+    }
+
+    return self;
+}
+
+/**
+ * アフィン変換パラメータの複製を初期化します.
+ *
+ * @param [Object] object 複製元オブジェクト
+ * @return [void]
+ */
+static VALUE AffineMatrix_initializeCopy(VALUE self, VALUE argObject) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    Rixmap::AffineMatrixData* _that = rixmap_unwrap<Rixmap::AffineMatrixData>(argObject);
+
+    *_this = *_that;
+
+    return self;
+}
+
+/**
+ * 変換中心点を取得します.
+ *
+ * @return [Array<Float>] 中心点
+ */
+static VALUE AffineMatrix_getCenter(VALUE self) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    VALUE items = rb_ary_new();
+    rb_ary_store(items, 0, DBL2NUM(_this->getCenter().x));
+    rb_ary_store(items, 1, DBL2NUM(_this->getCenter().y));
+    return items;
+}
+
+/**
+ * 変換中心点を設定します.
+ *
+ * @param [Array<Float>] point 中心点
+ * @return [void]
+ */
+static VALUE AffineMatrix_setCenter(VALUE self, VALUE argPoint) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    VALUE items = rb_Array(argPoint);
+    double x = NUM2DBL(rb_Float(rb_ary_entry(items, 0)));
+    double y = NUM2DBL(rb_Float(rb_ary_entry(items, 1)));
+    _this->setCenter(x, y);
+    return argPoint;
+}
+
+/**
+ * 拡大率を取得します.
+ *
+ * @return [Array<Float>] 拡大率
+ */
+static VALUE AffineMatrix_getScale(VALUE self) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    VALUE items = rb_ary_new();
+    rb_ary_store(items, 0, DBL2NUM(_this->getScale().x));
+    rb_ary_store(items, 1, DBL2NUM(_this->getScale().y));
+    return items;
+}
+
+/**
+ * 拡大率を設定します.
+ *
+ * @param [Array<Float>] scale 拡大率
+ */
+static VALUE AffineMatrix_setScale(VALUE self, VALUE argScale) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    VALUE items = rb_Array(argScale);
+    _this->setScale(NUM2DBL(rb_Float(rb_ary_entry(items, 0))), NUM2DBL(rb_Float(rb_ary_entry(items, 1))));
+    return argScale;
+}
+
+/**
+ * 平行移動量を取得します.
+ *
+ * @return [Array<Float>] 平行移動量
+ */
+static VALUE AffineMatrix_getTranslation(VALUE self) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    VALUE items = rb_ary_new();
+    rb_ary_store(items, 0, DBL2NUM(_this->getTranslation().x));
+    rb_ary_store(items, 1, DBL2NUM(_this->getTranslation().y));
+    return items;
+}
+
+/**
+ * 平行移動量を設定します.
+ *
+ * @param [Array<Float>] trans 平行移動量
+ * @return [void]
+ */
+static VALUE AffineMatrix_setTranslation(VALUE self, VALUE argTrans) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    VALUE items = rb_Array(argTrans);
+    _this->setTranslation(NUM2DBL(rb_Float(rb_ary_entry(items, 0))), NUM2DBL(rb_Float(rb_ary_entry(items, 1))));
+    return argTrans;
+}
+
+/**
+ * 回転角度をラジアンで取得します.
+ *
+ * @return [Float] 回転角度
+ */
+static VALUE AffineMatrix_getAngle(VALUE self) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    return DBL2NUM(_this->getAngle());
+}
+
+/**
+ * 回転角度を設定します.
+ *
+ * @param [Float] angle 回転角度 (ラジアン)
+ * @return [void]
+ */
+static VALUE AffineMatrix_setAngle(VALUE self, VALUE argAngle) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    _this->setAngle(NUM2DBL(rb_Float(argAngle)));
+    return argAngle;
+}
+
+/**
+ * 剪断変形方向を取得します.
+ *
+ * @return [Integer] 剪断変形方向定数値
+ */
+static VALUE AffineMatrix_getSkew(VALUE self) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    switch (_this->getSkew()) {
+    case Rixmap::SkewDeformation::HORIZONTAL:
+    case Rixmap::SkewDeformation::VERTICAL:
+    case Rixmap::SkewDeformation::BOTH:
+        return INT2FIX(static_cast<int>(_this->getSkew()));
+
+    default:
+        return Qnil;
+    }
+}
+
+/**
+ * 剪断変形方向を設定します.
+ *
+ * @param [Symbol,String,Integer,nil] skew 剪断変形方向
+ * @return [void]
+ */
+static VALUE AffineMatrix_setSkew(VALUE self, VALUE argSkew) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    if (NIL_P(argSkew)) {
+        _this->setSkew(Rixmap::SkewDeformation::NONE);
+    } else if (RB_TYPE_P(argSkew, T_FIXNUM)) {
+        Rixmap::SkewDeformation skew = static_cast<Rixmap::SkewDeformation>(FIX2INT(argSkew));
+        switch (skew) {
+        case Rixmap::SkewDeformation::HORIZONTAL:
+        case Rixmap::SkewDeformation::VERTICAL:
+        case Rixmap::SkewDeformation::BOTH:
+            _this->setSkew(skew);
+            break;
+
+        default:
+            _this->setSkew(Rixmap::SkewDeformation::NONE);
+            break;
+        }
+    } else {
+        VALUE strSkew = rb_sprintf("SKEW_");
+        strSkew = rb_str_concat(strSkew, rb_funcall(rb_String(argSkew), rb_intern("upcase"), 0, NULL));
+        if (rb_const_defined(mRixmapDeformer, rb_intern_str(strSkew))) {
+            VALUE objSkew = rb_const_get(mRixmapDeformer, rb_intern_str(strSkew));
+            _this->setSkew(static_cast<Rixmap::SkewDeformation>(NUM2INT(rb_Integer(objSkew))));
+        } else {
+            _this->setSkew(Rixmap::SkewDeformation::NONE);
+        }
+    }
+
+    return argSkew;
+}
+
+/**
+ * オブジェクトとしての文字列表現を返します.
+ *
+ * @return [String] 文字列表現
+ */
+static VALUE AffineMatrix_inspect(VALUE self) {
+    Rixmap::AffineMatrixData* _this = rixmap_unwrap<Rixmap::AffineMatrixData>(self);
+    return rb_enc_sprintf(
+            rb_usascii_encoding(),
+            "#<%s:%p scale=[%f, %f], trans=[%f, %f], center=[%f, %f], angle=%f, skew=%d>",
+            rb_obj_classname(self), reinterpret_cast<void*>(self),
+            _this->getScale().x, _this->getScale().y,
+            _this->getTranslation().x, _this->getTranslation().y,
+            _this->getCenter().x, _this->getCenter().y,
+            _this->getAngle(),
+            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実装
+//----------------------------------------------------------------------------//
+/**
+ * 変形処理モジュール定義
+ */
+void RixmapDeformation_Init() {
+    /**
+     * Document-module: Rixmap::Deformer
+     *
+     * 変形処理実装モジュール.
+     */
+    mRixmapDeformer = rb_define_module_under(mRixmap, "Deformer");
+
+    /** バイキュービック補間処理定数 */
+    rb_define_const(mRixmapDeformer, "IPO_BICUBIC",     INT2FIX(static_cast<int>(Rixmap::Interpolation::BICUBIC)));
+
+    /** 横方向剪断変形定数 */
+    rb_define_const(mRixmapDeformer, "SKEW_HORIZONTAL", INT2FIX(static_cast<int>(Rixmap::SkewDeformation::HORIZONTAL)));
+
+    /** 縦方向剪断変形定数 */
+    rb_define_const(mRixmapDeformer, "SKEW_VERTICAL",   INT2FIX(static_cast<int>(Rixmap::SkewDeformation::VERTICAL)));
+
+    /** 両方向剪断変形定数 */
+    rb_define_const(mRixmapDeformer, "SKEW_BOTH",       INT2FIX(static_cast<int>(Rixmap::SkewDeformation::BOTH)));
+
+    /**
+     * Document-class: Rixmap::Deformer::BaseDeformer
+     *
+     * 画像変形処理のベースクラス.
+     */
+    cRixmapBaseDeformer = rb_define_class_under(mRixmapDeformer, "BaseDeformer", rb_cObject);
+    rb_define_alloc_func(cRixmapBaseDeformer, BaseDeformer_Alloc);
+    rb_define_private_method(cRixmapBaseDeformer, "initialize", RUBY_METHOD_FUNC(BaseDeformer_initialize), -1);
+    rb_define_method(cRixmapBaseDeformer, "interpolator",  RUBY_METHOD_FUNC(BaseDeformer_getInterpolator), 0);
+    rb_define_method(cRixmapBaseDeformer, "interpolator=", RUBY_METHOD_FUNC(BaseDeformer_setInterpolator), 1);
+    rb_define_method(cRixmapBaseDeformer, "deform",        RUBY_METHOD_FUNC(BaseDeformer_deform), -1);
+    rb_define_method(cRixmapBaseDeformer, "inspect",       RUBY_METHOD_FUNC(BaseDeformer_inspect), 0);
+    rb_alias(cRixmapBaseDeformer, rb_intern("ipo"), rb_intern("interpolator"));
+    rb_alias(cRixmapBaseDeformer, rb_intern("ipo="), rb_intern("interpolator="));
+
+    /**
+     * Document-class: Rixmap::Deformer::AffineDeformer
+     *
+     * アフィン変換による変形処理実装.
+     */
+    cRixmapAffineDeformer = rb_define_class_under(mRixmapDeformer, "AffineDeformer", cRixmapBaseDeformer);
+    rb_define_alloc_func(cRixmapAffineDeformer, AffineDeformer_Alloc);
+    rb_define_private_method(cRixmapAffineDeformer, "initialize", RUBY_METHOD_FUNC(AffineDeformer_initialize), -1);
+    rb_define_method(cRixmapAffineDeformer, "deform", RUBY_METHOD_FUNC(AffineDeformer_deform), -1);
+    rb_define_attr(cRixmapAffineDeformer, "matrix", 1, 1);
+
+    /**
+     * Document-class: Rixmap::Deformer::AffineMatrix
+     *
+     * アフィン変換用パラメータクラス.
+     */
+    cRixmapAffineMatrix = rb_define_class_under(mRixmapDeformer, "AffineMatrix", rb_cObject);
+    rb_define_alloc_func(cRixmapAffineMatrix, AffineMatrix_Alloc);
+    rb_define_private_method(cRixmapAffineMatrix, "initialize",      RUBY_METHOD_FUNC(AffineMatrix_initialize), -1);
+    rb_define_private_method(cRixmapAffineMatrix, "initialize_copy", RUBY_METHOD_FUNC(AffineMatrix_initializeCopy), 1);
+    rb_define_method(cRixmapAffineMatrix, "center",       RUBY_METHOD_FUNC(AffineMatrix_getCenter), 0);
+    rb_define_method(cRixmapAffineMatrix, "center=",      RUBY_METHOD_FUNC(AffineMatrix_setCenter), 1);
+    rb_define_method(cRixmapAffineMatrix, "scale",        RUBY_METHOD_FUNC(AffineMatrix_getScale), 0);
+    rb_define_method(cRixmapAffineMatrix, "scale=",       RUBY_METHOD_FUNC(AffineMatrix_setScale), 1);
+    rb_define_method(cRixmapAffineMatrix, "translation",  RUBY_METHOD_FUNC(AffineMatrix_getTranslation), 0);
+    rb_define_method(cRixmapAffineMatrix, "translation=", RUBY_METHOD_FUNC(AffineMatrix_setTranslation), 1);
+    rb_define_method(cRixmapAffineMatrix, "angle",        RUBY_METHOD_FUNC(AffineMatrix_getAngle), 0);
+    rb_define_method(cRixmapAffineMatrix, "angle=",       RUBY_METHOD_FUNC(AffineMatrix_setAngle), 1);
+    rb_define_method(cRixmapAffineMatrix, "skew",         RUBY_METHOD_FUNC(AffineMatrix_getSkew), 0);
+    rb_define_method(cRixmapAffineMatrix, "skew=",        RUBY_METHOD_FUNC(AffineMatrix_setSkew), 1);
+    rb_define_method(cRixmapAffineMatrix, "inspect",      RUBY_METHOD_FUNC(AffineMatrix_inspect), 0);
+    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 $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: