rixmap 0.1.1 → 0.2.0

data/src/rixmap/quantizer.hxx

@@ -0,0 +1,385 @@
+// -*- coding: utf-8 -*-
+/**
+ * 減色処理実装
+ */
+#pragma once
+#include "common.hxx"
+#include "mode.hxx"
+#include "palette.hxx"
+#include "image.hxx"
+
+namespace Rixmap {
+
+    /**
+     * 減色処理ベースクラス.
+     */
+    class Quantizer {
+    public:
+        virtual ~Quantizer() {}
+
+    public:
+        /**
+         * 減色を実行します.
+         *
+         * @param [ImageData&] input  ベース画像
+         * @param [ImageData&] output 減色後画像データの格納先
+         */
+        virtual void quantize(const ImageData& input, ImageData& output) = 0;
+
+    protected:
+        /**
+         * 入力画像と出力画像が処理できるかを調べます.
+         */
+        virtual bool validate(const ImageData& input, const ImageData& output) {
+            return true;
+        }
+    };
+
+    /**
+     * メディアンカットによる減色処理実装
+     */
+    class MedianCutQuantizer : public Quantizer {
+    private:        // 内部クラス
+        class ColorRange {
+        public:
+            uint8_t maximum;
+            uint8_t minimum;
+
+        public:
+            inline long getLength() {
+                return static_cast<long>(this->maximum) - static_cast<long>(this->minimum);
+            }
+
+            inline long getMedian() {
+                return lround(this->getLength() / 2.0) + this->minimum;
+            }
+        };
+
+        /**
+         * ピクセルデータクラスタ
+         */
+        class PixelCluster {/*{{{*/
+        private:
+            ColorArray _colors;     // クラスタ内色データ
+            ColorRange _rrange;     // 赤要素範囲
+            ColorRange _grange;     // 緑要素範囲
+            ColorRange _brange;     // 青要素範囲
+            size_t _index;          // パレットインデックス
+
+        public:
+            PixelCluster() {
+                this->_rrange.minimum = UINT8_MAX;
+                this->_rrange.maximum = 0;
+                this->_grange.minimum = UINT8_MAX;
+                this->_grange.maximum = 0;
+                this->_brange.minimum = UINT8_MAX;
+                this->_brange.maximum = 0;
+            }
+
+        public:     // プロパティメンバ関数
+            inline size_t getIndex() const { return this->_index; }
+            inline void setIndex(size_t index) { this->_index = index; }
+
+            /**
+             * 指定した色がクラスタに含まれているかを調べます.
+             */
+            inline bool contains(const Color& color) {
+                return ((this->_rrange.minimum <= color.getRed() && color.getRed() <= this->_rrange.maximum)
+                        && (this->_grange.minimum <= color.getGreen() && color.getGreen() <= this->_grange.maximum)
+                        && (this->_brange.minimum <= color.getBlue() && color.getBlue() <= this->_brange.maximum));
+            }
+
+            /**
+             * クラスタ内要素数を返します.
+             */
+            inline size_t getSize() {
+                return this->_colors.size();
+            }
+
+            /**
+             * 3次元空間としての体積を計算して返します.
+             */
+            inline long getVolume() {
+                return this->_rrange.getLength() * this->_grange.getLength() * this->_brange.getLength();
+            }
+
+            /**
+             * 密度を計算して返します.
+             */
+            inline double getDensity() {
+                if (this->_colors.size() > 0) {
+                    return this->getVolume() / static_cast<double>(this->_colors.size());
+                } else {
+                    return 0.0;
+                }
+            }
+
+            /**
+             * クラスタへ色を追加します.
+             */
+            inline void add(const Color& color) {
+                if (color.getRed() < this->_rrange.minimum) {
+                    this->_rrange.minimum = color.getRed();
+                }
+                if (color.getRed() > this->_rrange.maximum) {
+                    this->_rrange.maximum = color.getRed();
+                }
+                if (color.getGreen() < this->_grange.minimum) {
+                    this->_grange.minimum = color.getGreen();
+                }
+                if (color.getGreen() > this->_grange.maximum) {
+                    this->_grange.maximum = color.getGreen();
+                }
+                if (color.getBlue() < this->_brange.minimum) {
+                    this->_brange.minimum = color.getBlue();
+                }
+                if (color.getBlue() > this->_brange.maximum) {
+                    this->_brange.maximum = color.getBlue();
+                }
+                this->_colors.push_back(color);
+            }
+
+            /**
+             * 中央色を取得します.
+             */
+            inline Color getMedianColor() {
+                if (this->_colors.size() > 0) {
+                    return Color(ROUND2BYTE(this->_rrange.getMedian()), ROUND2BYTE(this->_grange.getMedian()), ROUND2BYTE(this->_brange.getMedian()));
+                } else {
+                    return Color(0, 0, 0);
+                }
+            }
+
+            /**
+             * 中央値でクラスタを分割します.
+             */
+            bool divide(PixelCluster& left, PixelCluster& right) {
+                if (this->_colors.size() <= 1) {
+                    // 分割不能
+                    return false;
+                }
+
+                long rlen = this->_rrange.getLength();
+                long glen = this->_grange.getLength();
+                long blen = this->_brange.getLength();
+
+                // 最長辺で分割
+                if (rlen >= glen && rlen >= blen) {
+                    // 赤で分割
+                    double rmed = this->_rrange.getMedian();
+                    for (auto it = this->_colors.begin(); it != this->_colors.end(); it++) {
+                        Color& color = *it;
+                        if (color.getRed() < rmed) {
+                            left.add(color);
+                        } else {
+                            right.add(color);
+                        }
+                    }
+                } else if (glen >= blen) {
+                    // 緑で分割
+                    double gmed = this->_grange.getMedian();
+                    for (auto it = this->_colors.begin(); it != this->_colors.end(); it++) {
+                        Color& color = *it;
+                        if (color.getGreen() < gmed) {
+                            left.add(color);
+                        } else {
+                            right.add(color);
+                        }
+                    }
+                } else {
+                    // 青で分割
+                    double bmed = this->_brange.getMedian();
+                    for (auto it = this->_colors.begin(); it != this->_colors.end(); it++) {
+                        Color& color = *it;
+                        if (color.getBlue() < bmed) {
+                            left.add(color);
+                        } else {
+                            right.add(color);
+                        }
+                    }
+                }
+
+                // 分割できたか
+                if (left.getSize() > 0 && right.getSize() > 0) {
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+        };/*}}}*/
+
+        // クラスタリスト
+        typedef std::vector<PixelCluster*> PixelClusterList;
+
+    protected:      // 非公開メンバ
+        size_t _count;      // 目標色数
+
+    public:         // コンストラクタ
+        /**
+         * @param [size_t] count 目標色数
+         */
+        MedianCutQuantizer(size_t count = 256) : _count(count) {};
+
+    public:
+        void quantize(const ImageData& input, ImageData& output) override {
+            // バリデーション
+            if (!this->validate(input, output)) {
+                rb_raise(rb_eRuntimeError, "unexpeced input or output image");
+            }
+
+            PixelClusterList clusters;
+            this->prepare(input, clusters);
+            this->reduce(input, output, clusters);
+
+            // 後始末
+            for (auto it = clusters.begin(); it != clusters.end(); it++) {
+                PixelCluster* cluster = *it;
+                delete cluster;
+                *it = NULL;
+            }
+            clusters.clear();
+        }
+
+    protected:
+        bool validate(const ImageData& input, const ImageData& output) override {
+            if (output.getMode() != Mode::INDEXED) {
+                rb_raise(rb_eArgError, "unexpected output image mode: %s", ModeInfo::GetModeName(input.getMode()).c_str());
+            }
+            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 true;
+        }
+
+        /**
+         * パレット準備処理
+         */
+        void prepare(const ImageData& input, PixelClusterList& clusters) {
+            // 画像情報
+            int32_t width  = input.getWidth();
+            int32_t height = input.getHeight();
+            //const ModeInfo& mode = input.getModeInfo();
+
+            // 先頭クラスタ
+            PixelCluster* root = new PixelCluster();
+            {
+                // 全色を入れる
+                for (int32_t h = 0; h < height; h++) {
+                    for (int32_t w = 0; w < width; w++) {
+                        Color pixel = input.fetch(w, h);
+                        root->add(pixel);
+                    }
+                }
+            }
+            clusters.push_back(root);
+
+            // 目標色数まで分割
+            while (clusters.size() < this->_count) {
+                PixelCluster* left  = new PixelCluster();
+                PixelCluster* right = new PixelCluster();
+
+                // 最後尾を取り出す
+                PixelCluster* last = clusters.back();
+                clusters.pop_back();
+
+                // 分割する
+                if (last->divide(*left, *right)) {
+                    // 分割成功
+                    delete last; // 分割済みは消す
+                    clusters.push_back(left);
+                    clusters.push_back(right);
+
+                    // 要素順にソート
+                    std::sort(clusters.begin(), clusters.end(), [](PixelCluster* left, PixelCluster* right) -> bool {
+                            long lv = left->getVolume();
+                            long rv = right->getVolume();
+                            //size_t lsz = left->getSize();
+                            //size_t rsz = right->getSize();
+                            double ld = left->getDensity();
+                            double rd = right->getDensity();
+
+                            if (lv == rv) {
+                                return (ld < rd);
+                            } else {
+                                return (lv < rv);
+                            }
+                        });
+                } else {
+                    // 分割失敗
+                    clusters.push_back(last);   // 戻して
+                    delete left;        // 分割用を消す
+                    delete right;
+                    break;      // ループ終了
+                }
+            }
+        }
+
+        /**
+         * 減色済みパレットと適合させる
+         */
+        void reduce(const ImageData& input, ImageData& output, PixelClusterList& clusters) {
+            // クラスタリストからパレットを作成
+            PaletteData* palette = output.getPaletteData();
+            palette->resize(this->_count);
+            {
+                size_t offset = 0;
+                for (auto it = clusters.begin(); it != clusters.end(); it++) {
+                    PixelCluster* cluster = *it;
+                    Color color = cluster->getMedianColor();
+                    palette->set(offset, color);
+                    cluster->setIndex(offset++);
+                }
+
+                // 不足分を黒にする
+                // FIXME 変更できるようにするべきか
+                Color blk(0, 0, 0);
+                for (size_t off = offset; off < this->_count; off++) {
+                    palette->set(offset, blk);
+                }
+            }
+
+            // 減色を実行
+            int32_t width  = output.getWidth();
+            int32_t height = output.getHeight();
+            //const ModeInfo& mode = input.getModeInfo();
+            for (int32_t h = 0; h < height; h++) {
+                for (int32_t w = 0; w < width; w++) {
+                    Color pixel = input.fetch(w, h);
+
+                    // クラスタから探索
+                    auto found = clusters.end();
+                    for (auto it = clusters.begin(); it != clusters.end(); it++) {
+                        PixelCluster* cluster = *it;
+                        if (cluster->contains(pixel)) {
+                            // 含んでいる
+                            found = it;
+                            break;
+                        } else {
+                            // 含んでいない
+                            // FIXME 誤差拡散処理を入れるとどのクラスタにもマッチしないのが出るはず
+                        }
+                    }
+
+                    // パレットインデックス化
+                    size_t index = 0;
+                    if (found == clusters.end()) {
+                        // FIXME 誤差拡散とかするとどのクラスタにもない色になる可能性がある
+                        // とおもうんだけどなぁ(´・ω・`)
+                        index = palette->closest(pixel);
+                    } else {
+                        // クラスタにある
+                        PixelCluster* cluster = *found;
+                        index = cluster->getIndex();
+                    }
+
+                    output.set(Channel::PALETTE, w, h, index);
+                }
+            }
+        }
+    };
+}
+
+
+//============================================================================//
+// $Id: quantizer.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
+// vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker:

data/src/rixmap.hxx

@@ -12,8 +12,11 @@
 #include "rixmap/color.hxx"
 #include "rixmap/palette.hxx"
 #include "rixmap/image.hxx"
+#include "rixmap/quantizer.hxx"
+#include "rixmap/converter.hxx"
+#include "rixmap/deformer.hxx"
 
 
 //============================================================================//
-// $Id: rixmap.hxx,v add33526d522 2014/04/19 16:27:29 chikuchikugonzalez $
+// $Id: rixmap.hxx,v 753dbf70cab3 2014/05/16 16:13:38 chikuchikugonzalez $
 // vim: set sts=4 ts=4 sw=4 expandtab foldmethod=marker: