rixmap 0.1.1 → 0.2.0

data/src/rixmap/converter.hxx

@@ -0,0 +1,348 @@
+// -*- coding: utf-8 -*-
+/**
+ * 画像形式変換処理実装
+ */
+#pragma once
+#include "common.hxx"
+#include "mode.hxx"
+#include "image.hxx"
+#include "quantizer.hxx"
+
+namespace Rixmap {
+    /**
+     * 画像形式変換ベースクラス.
+     */
+    class Converter {
+    public:
+        virtual ~Converter() {}
+
+    public:     // インターフェイスメソッド
+        virtual void convert(const ImageData& input, ImageData& output) = 0;
+
+    protected:  // ユーティリティメソッドとか
+        /**
+         * 画像の持っている画像形式が指定された形式のどれかにマッチするかをチェックします.
+         */
+        inline bool validateModes(const ImageData& image, int num, const Mode* modes) {
+            for (int i = 0; i < num; i++) {
+                if (image.getMode() == modes[i]) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /**
+         * 画像形式チェック (入力画像用).
+         * 失敗時はRuby例外を出します.
+         */
+        inline bool validateInput(const ImageData& image, int num, const Mode* modes) {
+            if (!this->validateModes(image, num, modes)) {
+                rb_raise(rb_eArgError, "unexpected input image mode: %s", ModeInfo::GetModeName(image.getMode()).c_str());
+                return false;
+            }
+            return true;
+        }
+
+        /**
+         * 画像形式チェック (出力画像用).
+         * 入力用との違いは、例外メッセージのテキストだけです.
+         */
+        inline bool validateOutput(const ImageData& image, int num, const Mode* modes) {
+            if (!this->validateModes(image, num, modes)) {
+                rb_raise(rb_eArgError, "unexpected output image mode: %s", ModeInfo::GetModeName(image.getMode()).c_str());
+                return false;
+            }
+            return true;
+        }
+
+        /**
+         * 入力画像と出力画像のサイズが同じかを調べます.
+         */
+        inline bool validateSize(const ImageData& input, const ImageData& output) {
+            if (!((input.getWidth() == output.getWidth()) && (input.getHeight() == output.getHeight()))) {
+                rb_raise(rb_eArgError, "input bounds does not matche to output bounds: input is [%d, %d], but output is [%d, %d]", input.getWidth(), input.getHeight(), output.getWidth(), output.getHeight());
+                return false;
+            }
+            return true;
+        }
+    };
+
+    /**
+     * RGB形式からグレースケールへの変換処理実装コンバータ
+     */
+    class RGB2GrayScaleConverter : public Converter {
+    public:     // 抽象メソッド実装
+        void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[2] = {Mode::RGB, Mode::RGBA};
+            static Mode dstModes[2] = {Mode::GRAYSCALE, Mode::GRAYALPHA};
+
+            // バリデーション
+            this->validateSize(input, output);
+            this->validateInput(input, 2, srcModes);
+            this->validateOutput(output, 2, dstModes);
+
+            // 変換処理本体
+            int32_t width  = input.getWidth();
+            int32_t height = input.getHeight();
+            bool useAlpha = (input.getModeInfo().hasAlpha() && output.getModeInfo().hasAlpha());
+
+            // ピクセル単位で処理
+            for (int32_t h = 0; h < height; h++) {
+                for (int32_t w = 0; w < width; w++) {
+                    uint8_t r = input.get(Channel::RED,   w, h);
+                    uint8_t g = input.get(Channel::GREEN, w, h);
+                    uint8_t b = input.get(Channel::BLUE,  w, h);
+                    Color c(r, g, b);
+                    output.set(Channel::LUMINANCE, w, h, c.getLuminance());
+
+                    if (useAlpha) {
+                        output.set(Channel::ALPHA, w, h, input.get(Channel::ALPHA, w, h));
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     * RGBカラー形式からインデックスカラー形式への変換処理実装.
+     */
+    class RGB2IndexConverter : public Converter {
+    public:
+        void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[2] = {Mode::RGB, Mode::RGBA};
+            static Mode dstModes[2] = {Mode::INDEXED};
+
+            // バリデーション
+            this->validateSize(input, output);
+            this->validateInput(input, 2, srcModes);
+            this->validateOutput(output, 1, dstModes);
+
+            // FIXME メディアンカット以外を選択可能にしたい
+            // FIXME パレット色数を選択可能にしたい
+            MedianCutQuantizer quantizer(256);
+            quantizer.quantize(input, output);
+        }
+    };
+
+    /**
+     * グレースケールからRGB形式への変換処理実装
+     */
+    class GrayScale2RGBConverter : public Converter {
+    public:
+        void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[2] = {Mode::GRAYSCALE, Mode::GRAYALPHA};
+            static Mode dstModes[2] = {Mode::RGB, Mode::RGBA};
+
+            // バリデーション
+            this->validateSize(input, output);
+            this->validateInput(input, 2, srcModes);
+            this->validateOutput(output, 2, dstModes);
+
+            // 変換処理本体
+            int32_t width  = input.getWidth();
+            int32_t height = input.getHeight();
+            bool useAlpha = (input.getModeInfo().hasAlpha() && output.getModeInfo().hasAlpha());
+
+            // ピクセル単位で処理
+            for (int32_t h = 0; h < height; h++) {
+                for (int32_t w = 0; w < width; w++) {
+                    uint8_t l = input.get(Channel::LUMINANCE, w, h);
+                    output.set(Channel::RED,   w, h, l);
+                    output.set(Channel::GREEN, w, h, l);
+                    output.set(Channel::BLUE,  w, h, l);
+
+                    if (useAlpha) {
+                        output.set(Channel::ALPHA, w, h, input.get(Channel::ALPHA, w, h));
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     * グレースケール形式からインデックスカラー形式への変換処理実装
+     * 透明度は引き継げないことに注意.
+     */
+    class GrayScale2IndexConverter : public Converter {
+    public:
+        void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[2] = {Mode::GRAYSCALE, Mode::GRAYALPHA};
+            static Mode dstModes[1] = {Mode::INDEXED};
+
+            // バリデーション
+            this->validateSize(input, output);
+            this->validateInput(input, 2, srcModes);
+            this->validateOutput(output, 1, dstModes);
+
+            // グレースケールパレットを作成
+            // FIXME 256階調決め打ちやめたい
+            PaletteData* palette = output.getPaletteData();
+            if (palette == NULL) {
+                rb_raise(rb_eRuntimeError, "illegal state: indexed image without palette detected.");
+            }
+            palette->resize(256);
+            for (size_t i = 0; i < 256; i++) {
+                uint8_t l = static_cast<uint8_t>(i);
+                Color c(l, l, l);
+                palette->set(i, c);
+            }
+
+            // ピクセルを変更
+            int32_t width  = input.getWidth();
+            int32_t height = input.getHeight();
+            for (int32_t h = 0; h < height; h++) {
+                for (int32_t w = 0; w < width; w++) {
+                    uint8_t l = input.get(Channel::LUMINANCE, w, h);
+                    output.set(Channel::PALETTE, w, h, l);
+                }
+            }
+        }
+    };
+
+    /**
+     * インデックスカラー形式からRGBカラー形式への変換処理実装.
+     */
+    class Index2RGBConverter : public Converter {
+    public:
+        void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[1] = {Mode::INDEXED};
+            static Mode dstModes[2] = {Mode::RGB, Mode::RGBA};
+
+            // バリデーション
+            this->validateSize(input, output);
+            this->validateInput(input, 1, srcModes);
+            this->validateOutput(output, 2, dstModes);
+
+            // パレット
+            const PaletteData* palette = input.getPaletteData();
+            if (palette == NULL) {
+                rb_raise(rb_eRuntimeError, "illegal state: indexed image without palette detected.");
+            }
+
+            // 変換処理
+            int32_t width  = input.getWidth();
+            int32_t height = input.getHeight();
+            bool useAlpha = output.getModeInfo().hasAlpha();
+
+            for (int32_t h = 0; h < height; h++) {
+                for (int32_t w = 0; w < width; w++) {
+                    size_t off = input.get(Channel::PALETTE, w, h);
+                    const Color& col = palette->get(off);
+
+                    output.set(Channel::RED,   w, h, col.getRed());
+                    output.set(Channel::GREEN, w, h, col.getGreen());
+                    output.set(Channel::BLUE,  w, h, col.getBlue());
+                    if (useAlpha) {
+                        output.set(Channel::ALPHA, w, h, col.getAlpha());
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     * インデックスカラー形式からグレースケール形式への変換処理実装.
+     */
+    class Index2GrayScaleConverter : public Converter {
+    public:
+        void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[1] = {Mode::INDEXED};
+            static Mode dstModes[2] = {Mode::GRAYSCALE, Mode::GRAYALPHA};
+
+            // バリデーション
+            this->validateSize(input, output);
+            this->validateInput(input, 1, srcModes);
+            this->validateOutput(output, 2, dstModes);
+
+            // パレット
+            const PaletteData* palette = input.getPaletteData();
+            if (palette == NULL) {
+                rb_raise(rb_eRuntimeError, "illegal state: indexed image without palette detected.");
+            }
+
+            // 変換処理
+            int32_t width  = input.getWidth();
+            int32_t height = input.getHeight();
+            bool useAlpha = output.getModeInfo().hasAlpha();
+
+            for (int32_t h = 0; h < height; h++) {
+                for (int32_t w = 0; w < width; w++) {
+                    size_t off = input.get(Channel::PALETTE, w, h);
+                    const Color& col = palette->get(off);
+
+                    output.set(Channel::LUMINANCE, w, h, col.getLuminance());
+                    if (useAlpha) {
+                        output.set(Channel::ALPHA, w, h, col.getAlpha());
+                    }
+                }
+            }
+        }
+    };
+
+    class CopyConverter : public Converter {
+    public:
+        virtual ~CopyConverter() {}
+
+    public:
+        virtual void convert(const ImageData& input, ImageData& output) override {
+            this->validateSize(input, output);
+
+            // 変換処理
+            int32_t width  = input.getWidth();
+            int32_t height = input.getHeight();
+            const ModeInfo& outMode = output.getModeInfo();
+            //bool useAlpha = outMode.hasAlpha();
+            const ChannelArray& channels = input.getModeInfo().getChannels();
+            for (auto it = channels.begin(); it != channels.end(); it++) {
+                Channel channel = *it;
+                if (!outMode.has(channel)) {
+                    continue;
+                }
+                for (int32_t h = 0; h < height; h++) {
+                    for (int32_t w = 0; w < width; w++) {
+                        output.set(channel, w, h, input.get(channel, w, h));
+                    }
+                }
+            }
+        }
+    };
+
+    class RGB2RGBConverter : public CopyConverter {
+    public:
+        virtual void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[2] = {Mode::RGB, Mode::RGBA};
+            static Mode dstModes[2] = {Mode::RGB, Mode::RGBA};
+            this->validateInput(input, 2, srcModes);
+            this->validateOutput(output, 2, dstModes);
+            CopyConverter::convert(input, output);
+        }
+    };
+
+    class GrayScale2GrayScaleConverter : public CopyConverter {
+    public:
+        virtual void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[2] = {Mode::GRAYSCALE, Mode::GRAYALPHA};
+            static Mode dstModes[2] = {Mode::GRAYSCALE, Mode::GRAYALPHA};
+            this->validateInput(input, 2, srcModes);
+            this->validateOutput(output, 2, dstModes);
+            CopyConverter::convert(input, output);
+        }
+    };
+
+    class Index2IndexConverter : public CopyConverter {
+    public:
+        virtual void convert(const ImageData& input, ImageData& output) override {
+            static Mode srcModes[1] = {Mode::INDEXED};
+            static Mode dstModes[1] = {Mode::INDEXED};
+            this->validateInput(input, 1, srcModes);
+            this->validateOutput(output, 1, dstModes);
+            CopyConverter::convert(input, output);
+        }
+    };
+}
+
+
+//============================================================================//
+// $Id: converter.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmap/deformer.hxx

@@ -0,0 +1,325 @@
+// -*- coding: utf-8 -*-
+/**
+ * 画像変形処理
+ */
+#pragma once
+#include "common.hxx"
+#include "image.hxx"
+#include "interpolator.hxx"
+
+namespace Rixmap {
+
+    /**
+     * 座標っぽい構造体
+     */
+    struct Point {
+    public:
+        double x;
+        double y;
+    };
+
+    /**
+     * 剪断変形フラグ.
+     */
+    enum class SkewDeformation : int {
+        NONE       = 0x00,
+        HORIZONTAL = 0x01,
+        VERTICAL   = 0x02,
+        BOTH       = 0x03
+    };
+
+    /**
+     * アフィン変換パラメータ.
+     */
+    class AffineMatrix {
+    protected:      // 非公開メンバ
+        Point _center;          // 変換中心点
+        Point _scale;           // 拡大率
+        Point _translation;     // 平行移動量
+
+        double _angle;      // 回転角度 (ラジアン)
+
+        SkewDeformation _skew;      // 剪断変形方向
+
+        double _regularMatrix[3][3];        // 3x3 正変換用行列
+        double _inverseMatrix[3][3];        // 3x3 逆変換用行列
+
+    public:         // コンストラクタ
+        AffineMatrix() {
+            this->reset();
+        }
+
+        AffineMatrix(const AffineMatrix& matrix) {
+            *this = matrix;
+            this->reset();
+        }
+
+        virtual ~AffineMatrix() {}
+
+    private:        // 非公開クラスメンバ関数
+        /**
+         * 3x3行列同士の乗算を行います.
+         */
+        static inline void _3x3matrixMultiply(const double left[][3], const double right[][3], double dest[][3]) {
+            for (int row = 0; row < 3; row++) {
+                for (int column = 0; column < 3; column++) {
+                    dest[row][column] = 0.0;        // リセット
+                    for (int i = 0; i < 3; i++) {
+                        dest[row][column] += (left[row][i] * right[i][column]);
+                    }
+                }
+            }
+        }
+
+    public:         // 公開プロパティメンバ関数
+        inline const Point& getCenter() const { return this->_center; }
+        inline Point& getCenter() { return this->_center; }
+        inline void setCenter(const Point& point) { this->setCenter(point.x, point.y); }
+        inline void setCenter(double x, double y) {
+            this->_center.x = x;
+            this->_center.y = y;
+        }
+
+        inline const Point& getScale() const { return this->_scale; }
+        inline Point& getScale() { return this->_scale; }
+        inline void setScale(const Point& point) { this->setScale(point.x, point.y); }
+        inline void setScale(double x, double y) {
+            this->_scale.x = x;
+            this->_scale.y = y;
+        }
+
+        inline const Point& getTranslation() const { return this->_translation; }
+        inline Point& getTranslation() { return this->_translation; }
+        inline void setTranslation(const Point& point) { this->setTranslation(point.x, point.y); }
+        inline void setTranslation(double x, double y) {
+            this->_translation.x = x;
+            this->_translation.y = y;
+        }
+
+        inline double getAngle() const { return this->_angle; }
+        inline void setAngle(double angle) { this->_angle = angle; }
+
+        inline SkewDeformation getSkew() const { return this->_skew; }
+        inline void setSkew(SkewDeformation skew) { this->_skew = skew; }
+
+    public:         // 公開メンバ関数
+        /**
+         * 内部パラメータから変換用行列を初期化します.
+         */
+        virtual void matrixize() {
+            double scaleMatrix[3][3] = {
+                {0.0, 0.0, 0.0},
+                {0.0, 0.0, 0.0},
+                {0.0, 0.0, 1.0}
+            };
+            double transMatrix[3][3] = {
+                {0.0, 0.0, 0.0},
+                {0.0, 0.0, 0.0},
+                {0.0, 0.0, 1.0}
+            };
+            double angleMatrix[3][3] = {
+                {0.0, 0.0, 0.0},
+                {0.0, 0.0, 0.0},
+                {0.0, 0.0, 1.0}
+            };
+            this->matrixizeScale(scaleMatrix);
+            this->matrixizeTranslation(transMatrix);
+            this->matrixizeAngle(angleMatrix);
+
+            // 正変換行列
+            {
+                double matrix0[3][3];       // 一時計算
+                AffineMatrix::_3x3matrixMultiply(scaleMatrix, transMatrix, matrix0);
+                AffineMatrix::_3x3matrixMultiply(matrix0, angleMatrix, this->_regularMatrix);
+            }
+
+            // 逆変換用行列
+            {
+                double delta0 = this->_regularMatrix[0][0] * (this->_regularMatrix[1][1] * this->_regularMatrix[2][2] - this->_regularMatrix[2][1] * this->_regularMatrix[1][2]);
+                double delta1 = this->_regularMatrix[1][0] * (this->_regularMatrix[0][1] * this->_regularMatrix[2][2] - this->_regularMatrix[2][1] * this->_regularMatrix[0][2]);
+                double delta2 = this->_regularMatrix[2][0] * (this->_regularMatrix[0][1] * this->_regularMatrix[1][2] - this->_regularMatrix[1][1] * this->_regularMatrix[0][2]);
+                double delta  = delta0 - delta1 + delta2;
+
+                this->_inverseMatrix[0][0] = +(this->_regularMatrix[1][1] * this->_regularMatrix[2][2] - this->_regularMatrix[2][1] * this->_regularMatrix[1][2]) / delta;
+                this->_inverseMatrix[0][1] = -(this->_regularMatrix[0][1] * this->_regularMatrix[2][2] - this->_regularMatrix[2][1] * this->_regularMatrix[0][2]) / delta;
+                this->_inverseMatrix[0][2] = +(this->_regularMatrix[0][1] * this->_regularMatrix[1][2] - this->_regularMatrix[1][1] * this->_regularMatrix[0][2]) / delta;
+                this->_inverseMatrix[1][0] = -(this->_regularMatrix[1][0] * this->_regularMatrix[2][2] - this->_regularMatrix[2][0] * this->_regularMatrix[1][2]) / delta;
+                this->_inverseMatrix[1][1] = +(this->_regularMatrix[0][0] * this->_regularMatrix[2][2] - this->_regularMatrix[2][0] * this->_regularMatrix[0][2]) / delta;
+                this->_inverseMatrix[1][2] = -(this->_regularMatrix[0][0] * this->_regularMatrix[1][2] - this->_regularMatrix[1][0] * this->_regularMatrix[0][2]) / delta;
+                this->_inverseMatrix[2][0] = +(this->_regularMatrix[1][0] * this->_regularMatrix[2][1] - this->_regularMatrix[2][0] * this->_regularMatrix[1][1]) / delta;
+                this->_inverseMatrix[2][1] = -(this->_regularMatrix[0][0] * this->_regularMatrix[2][1] - this->_regularMatrix[2][0] * this->_regularMatrix[0][1]) / delta;
+                this->_inverseMatrix[2][2] = +(this->_regularMatrix[0][0] * this->_regularMatrix[1][1] - this->_regularMatrix[1][0] * this->_regularMatrix[0][1]) / delta;
+            }
+        }
+
+        /**
+         * 内部パラメータを初期化します.
+         */
+        virtual void reset() {
+            this->_center.x      = 0.0;
+            this->_center.y      = 0.0;
+            this->_scale.x       = 1.0;
+            this->_scale.y       = 1.0;
+            this->_translation.x = 0.0;
+            this->_translation.y = 0.0;
+            this->_angle         = 0.0;
+            this->_skew          = SkewDeformation::NONE;
+            this->matrixize();
+        }
+
+        /**
+         * パラメータに従いsrcからdstに変換を行います.
+         */
+        virtual void deform(const Point& src, Point& dst) {
+            this->apply(this->_regularMatrix, src, dst);
+        }
+
+        /**
+         * パラメータに従い逆変換を実行します.
+         */
+        virtual void inverse(const Point& src, Point& dst) {
+            this->apply(this->_inverseMatrix, src, dst);
+        }
+
+    public:         // 演算子オーバーロード
+        AffineMatrix& operator=(const AffineMatrix& base) {
+            this->_center.x      = base._center.x;
+            this->_center.y      = base._center.y;
+            this->_scale.x       = base._scale.x;
+            this->_scale.y       = base._scale.y;
+            this->_translation.x = base._translation.x;
+            this->_translation.y = base._translation.y;
+            this->_angle         = base._angle;
+            this->_skew          = base._skew;
+            return *this;
+        }
+
+    protected:
+        /**
+         * 変換処理の実体
+         */
+        virtual void apply(const double matrix[][3], const Point& src, Point& dst) {
+            // 中心補正をした基準値を計算
+            double sx = src.x - this->_center.x;
+            double sy = src.y - this->_center.y;
+
+            // 似非行列計算を実行
+            double dx = (matrix[0][0] * sx) + (matrix[0][1] * sy) + matrix[0][2];
+            double dy = (matrix[1][0] * sx) + (matrix[1][1] * sy) + matrix[1][2];
+
+            // 中止補正分を除外
+            dst.x = dx + this->_center.x;
+            dst.y = dy + this->_center.y;
+        }
+
+        /**
+         * 拡縮関係の行列を初期化
+         */
+        virtual void matrixizeScale(double matrix[][3]) {
+            matrix[0][0] = this->_scale.x;
+            matrix[0][1] = 0.0;
+            matrix[0][2] = 0.0;
+            matrix[1][0] = 0.0;
+            matrix[1][1] = this->_scale.y;
+            matrix[1][2] = 0.0;
+            matrix[2][0] = 0.0;
+            matrix[2][1] = 0.0;
+            matrix[2][2] = 1.0;
+        }
+
+        /**
+         * 平行移動関係の行列を初期化する.
+         */
+        virtual void matrixizeTranslation(double matrix[][3]) {
+            matrix[0][0] = 1.0;
+            matrix[0][1] = 0.0;
+            matrix[0][2] = this->_translation.x;
+            matrix[1][0] = 0.0;
+            matrix[1][1] = 1.0;
+            matrix[1][2] = this->_translation.y;
+            matrix[2][0] = 0.0;
+            matrix[2][1] = 0.0;
+            matrix[2][2] = 1.0;
+        }
+
+        /**
+         * 角度関係の行列を初期化します.
+         */
+        virtual void matrixizeAngle(double matrix[][3]) {
+            double cosTheta = std::cos(this->_angle);
+            double sinTheta = std::sin(this->_angle);
+            double tanTheta = std::tan(this->_angle);
+            matrix[0][0] = 0.0;
+            matrix[0][1] = 0.0;
+            matrix[0][2] = 0.0;
+            matrix[1][0] = 0.0;
+            matrix[1][1] = 0.0;
+            matrix[1][2] = 0.0;
+            matrix[2][0] = 0.0;
+            matrix[2][1] = 0.0;
+            matrix[2][2] = 1.0;
+
+            switch (this->_skew){
+            case SkewDeformation::BOTH:
+                matrix[0][0] = 1.0;
+                matrix[0][1] = tanTheta;
+                matrix[1][0] = tanTheta;
+                matrix[1][1] = 1.0;
+                break;
+
+            case SkewDeformation::HORIZONTAL:
+                matrix[0][0] = 1.0;
+                matrix[0][1] = tanTheta;
+                matrix[1][1] = 1.0;
+                break;
+
+            case SkewDeformation::VERTICAL:
+                matrix[0][0] = 1.0;
+                matrix[1][0] = tanTheta;
+                matrix[1][1] = 1.0;
+                break;
+
+            default:
+                matrix[0][0] = +(cosTheta);
+                matrix[0][1] = -(sinTheta);
+                matrix[1][0] = +(sinTheta);
+                matrix[1][1] = +(cosTheta);
+                break;
+            }
+        }
+    };
+
+    /**
+     * Ruby用アフィン変換パラメータクラスデータ.
+     */
+    class AffineMatrixData : public AffineMatrix {};
+
+    /**
+     * Ruby用変形処理クラスデータ.
+     */
+    class DeformerData {
+    private:
+        Interpolation _ipo;     // 補間処理方法
+
+    public:     // コンストラクタ
+        DeformerData(Interpolation ipo = Interpolation::NONE) : _ipo(ipo) {}
+        virtual ~DeformerData() {}
+
+    public:     // メンバ関数
+        inline Interpolation getInterpolation() const { return this->_ipo; }
+        inline void setInterpolation(Interpolation ipo) { this->_ipo = ipo; }
+    };
+
+    /**
+     * Ruby用アフィン変換処理クラスデータ.
+     */
+    class AffineDeformerData : public DeformerData {
+    public:
+        AffineDeformerData(Interpolation ipo = Interpolation::NONE) : DeformerData(ipo) {}
+    };
+}
+
+
+//============================================================================//
+// $Id: deformer.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: