1. 最近在补 3D 知识，上周花很大的精力试着手动逐像素渲染 3D 图形，挺好玩的：

老大的要求是高光贴图和法线贴图也是要的，我也做出来了，只不过几个小时之前突然意识到一个非常重要的坐标转换没有做，所以那个法线贴图的结果其实很不靠谱，代码先不放了，省得丢人，等把法线贴图做对了再说吧。

这是阉割版的程序 —— 如果你有兴趣围观的话：rending.7z

哦对了，这里用到的数学运算俺也都自己实现了一遍，等有时间了会整理一下的，毕竟这个其实挺好玩。

2. 觉得 mataball 这东西挺有意思，结果就整出了个奇丑的：

任何试图画出有两个眼睛一个嘴巴的面部的尝试都会得到一个青蛙

程序和代码在这儿：metaball.7z

圈圈们默认是会动的，如果你只是想画青蛙，把 render 函数的第二个参数设为 0 就好了。

BTW Fast inverse square root 真是威武，有多威武你自己试试就知道了。

好久没看 CSDN，今天一看就把我吓了一跳：

首页推荐了某个号称专家而且脑袋上还盖着“专家”两字的生物写的名字很吓人以至于让我忍不住点进去看了的文章《Boost库对unicode字符集的支持方式探究》，文章说，他发现了原来 boost 和 STL 一样给 unicode 函数/类加了个 w 前缀。

囧。

用 TDM-GCC 4.5 编译了 OpenCV 2.1 和 boost 1.44 

下载了用(某不知道来源的) MinGW GCC 4.4 编译的 Qt 4.6

问题在于，这两个版本的 MinGW 显然不兼容！

今天需要用到这三个库时，链接就总是悲剧 —— 用 TDM-GCC 编译工程，则找不到 _Unwind_Resume 函数（链接 libgcc_s.a 还是找不到、同时还会伴随出现 n 个重复定义）；用 Qt 目录下那个 MinGW 编译工程的话，则有无数个找不到实现的 boost 库函数。

现在我在想是要重新编译一下 OpenCV 以及 Boost 呢，还是重新编译一下 Qt 呢。

update:
花了近四个小时把 Qt 自己编译了一遍，其间顺便(终于)看了《银翼杀手》，问题果然解决，真累。
话说银翼杀手确实是部不可多得的好片，情节引人入胜同时又发人深省，只是我还不敢说看懂了，什么时候还得再看几遍。
另外，从编译的流程来看 Qt 的确是世界上最容易编译的东西之一了，configure，make，done —— 只是，它好大啊。 

在今天以前我一直以为 MinGW 只认得 libXXX.a ，不认得 XXX.lib

丫的，害我做过多少无用功啊！

对打马赛克有特别性趣的童鞋们，你们可以先试着玩一下了：

=> 二进制文件及源代码打包下载 [2.4 MB]

其中彩色马赛克拼接的效果目前还很不靠谱，请谨慎使用。

用法：

• 首先把一大堆图像转换成某个统一大小的缩略图 ( 如果你自己没有什么好的办法能做到这一点，可以考虑一下我为你量身定做的 resize.exe，在压缩包里 ) 
• 然后关机，膜拜一下春哥
• 开机，你会发现拼接图像已经生成好了

好吧，我是开玩笑的。

实际上，mosaic 的用法如下：

mosaic <源文件> -o <输出图像> <选项们>

选项有：

• -p <缩略图库目录> （支持多个目录，至少得要有一个非空的目录）
• -S <缩略图大小> （单位为像素，默认48）
• -s <用于比较的缩略图大小> （将会把缩略图再缩率成这个模样，然后用于比较，单位像素，默认12）
• -z <放大倍数> （实数，默认为 1）
• -c （启用彩色，默认灰白）
• -t <n> （从前n个图像中随机选一个用于填充，默认13）
• -x （完成后在系统关联程序中打开）
• -d （完成后显示一下）

一个简单的例子是： mosaic -p pool in.jpg -o out.jpg

主要的源代码如下：

其中那个 sizedpqueue.hpp 中是一个名曰 sizedpq 的俺实现的比较丑陋的用于保存前 n 小元素用的数据结构类，由于丑陋，就不贴了，反正那个压缩包里有……

// vi:foldmethod=marker
// Author: if ( www.if-yu.info)
// Version: 0.0.3.100613
// Date: June 13rd, 2010
// Copyright (C): if
// License: BSD

/*
 change log:

 * Version 0.0.3:
     can see color

 * Version 0.0.2:
     got an command-line interface

 * Version 0.0.1:
     born

 */

// misc {{{
#include <exception>
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <cmath>

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

#include <boost/filesystem.hpp>
#include <boost/program_options.hpp>

#include <opencv/cv.h>
#include <opencv/cv.hpp>
#include <opencv/cxcore.h>
#include <opencv/cxcore.hpp>
#include <opencv/highgui.h>

#include "sizedpqueue.hpp"

using namespace std;
namespace fs = boost::filesystem;
namespace po = boost::program_options;

int g_thumb_size = 12;
int g_image_size = 48;
int g_top_n   = 13;
bool g_color = false;

typedef struct Image {
    cv::Mat thumb;
    cv::Mat orig;
} Image;

typedef struct Record {
    double d;
    int    idx;
} Record;
class RecordCmp {
public:
    bool operator()(Record const& a, Record const& b)const{
        return a.d<b.d;
    }
};
// }}}

// mean idea:
// calculate a `distance' between two images, which shows their similarity {{{
double dist(cv::Mat const& m1, cv::Mat const& m2) {
    assert(m1.type() == m2.type() && m1.size() == m2.size());

    if(CV_MAT_TYPE(m1.type())==CV_8UC1) {
        typedef unsigned char uchar;
        int i,I=m1.rows,j,J=m1.cols,t;
        double d=0;
        for(i=0;i<I;++i)
            for(j=0;j<J;++j) {
                t=int(m1.at<uchar>(i,j))-int(m2.at<uchar>(i,j));
                t*=t;
                d+=/*fabs*/(t);
            }
        return d;
    } else if(CV_MAT_TYPE(m1.type())==CV_8UC3) {
        double dM=0.0, t, d[3]={0.};
        cv::Scalar mean1 = cv::mean(m1);
        cv::Scalar mean2 = cv::mean(m2);
        for(int c=0;c<3;++c) {
            t=mean1.val[c]-mean2.val[c];
            t*=t;
            dM+=t;
        }

        for(int i=0, I=m1.rows; i<I; ++i) {
            for(int j=0, J=m1.cols; j<J; ++j) {
                typedef cv::Vec<uchar,3> BGR_color;
                BGR_color c1=m1.at<BGR_color>(i,j);
                BGR_color c2=m2.at<BGR_color>(i,j);

                for(int c=0;c<3;++c) {
                    t = c1[c]-c2[c];
                    d[c] += t*t;
                }
            }
        }

#if 0
        // compare their histogram
        int hist1[3][64]={{0}}, hist2[3][64]={{0}};
        for(int i=0,I=m1.rows; i<I; ++i) {
            for(int j=0,J=m1.cols; j<J; ++j) {
                typedef cv::Vec<uchar,3> BGR_color;
                BGR_color c1 = m1.at<BGR_color>(i, j);
                BGR_color c2 = m2.at<BGR_color>(i, j);
                for(int c=0;c<3;++c) {
                    ++hist1[c][c1[c]/4];
                    ++hist2[c][c2[c]/4];
                }
            }
        }
        // algorithms:
        // 全不靠谱……
        // correlation
        {
            double a=0.,b=0.,up[3]={0.},down[3]={0.},s1[3]={0.},s2[3]={0.};
            double avg1[3]={0}, avg2[3]={0};
            for(int c=0;c<3;++c) {
                for(int i=0;i<64;++i) {
                    avg1[c] += hist1[c][i]/64.;
                    avg2[c] += hist2[c][i]/64.;
                }
            }
            for(int c=0;c<3;++c){
                for(int i=0;i<64;++i) {
                    a=hist1[c][i]-avg1[c];
                    b=hist2[c][i]-avg2[c];
                    up[c] += a*b;
                    s1[c] += a*a;
                    s2[c] += b*b;
                }
            }
            for(int c=0;c<3;++c){
                down[c] = sqrt(s1[c]*s2[c]);
                d[c] = up[c]/down[c];
            }
        }
        /*
        // so-called chi-square, sucks
        for(int i=0;i<64;++i){
            for(int c=0;c<3;++c) {
                t=(hist1[c][i]-hist2[c][i]);
                t*=t;
                d[c] += t/(hist1[c][i]+hist2[c][i]);
            }
        }
        */
#endif
        t = 0;
        for(int i=0;i<3;++i){
            t+=d[i]*d[i];
        }
        return 0.7*dM + 0.3*t;
    } else {
        // only support CV_8UC1 and CV_8UC3 so far
        assert(CV_MAT_TYPE(m1.type()) == CV_8UC1 || CV_MAT_TYPE(m1.type()) == CV_8UC3); // false;
    }
    return 0;
}
// }}}

// core features: {{{
void addToPool(std::vector<Image>& pool, string const& dir) {
    cv::Size expect(g_image_size, g_image_size);
    cout<<"----- reading "<<(g_color?"color":"gray")<<" images from \""<<dir<<"\" -----"<<endl;
    for(fs::directory_iterator i(dir),I;i!=I;++i){
        Image img;
        img.orig = cv::imread(i->path().string(), g_color?1:0);
        if(img.orig.size()!=expect) {
            cout<<"X";
            continue;
        }
        cv::resize(img.orig, img.thumb, cv::Size(g_thumb_size, g_thumb_size));
        // cv::blur(img.thumb, img.thumb, cv::Size(2,2));
        pool.push_back(img);
        cout<<'+';
    }
    cout<<"\n [done]"<<endl;
}

int chooseRandomFromPool(vector<Image> const& pool, cv::Mat const& source) {
    int a=0,c=pool.size();
    sizedpq<Record,RecordCmp> top(g_top_n);
    cv::Mat thumb;
    cv::resize(source, thumb, cv::Size(g_thumb_size, g_thumb_size));
    for(a=0;a<c;++a) {
        Record r;
        r.d=dist(pool[a].thumb, thumb);
        r.idx=a;
        top.insert(r);
    }
    return top[rand()%g_top_n].idx;
}

void doRandomMosaic(vector<Image> const& pool, cv::Mat const& src, cv::Mat & dst){
    cv::Size size(src.size());
    size.width  /= g_thumb_size;
    size.height /= g_thumb_size;
    cv::Size dstSize( size.width*g_image_size, size.height*g_image_size);
    if(dst.size()!=dstSize) {
        dst = cv::Mat::zeros(dstSize, g_color?CV_8UC3:CV_8UC1);
    }
    cout<<"----- doing what you want me to -----"<<endl;
    if (dstSize.width>800||dstSize.height>600) {
        cout<<"image is too big, i do not want to display it."<<endl;
    }
    for(int i=0,I=size.height; i<I; ++i) {
        for(int j=0,J=size.width; j<J; ++j) {
            cv::Rect r1(j*g_thumb_size,i*g_thumb_size,g_thumb_size,g_thumb_size);
            cv::Rect r2(j*g_image_size,i*g_image_size,g_image_size,g_image_size);
            cv::Mat s(src, r1);
            cv::Mat d(dst, r2);
            int n = chooseRandomFromPool(pool, s);
            pool[n].orig.copyTo(d);
            cout<<'.';
            if(!(dstSize.width>800||dstSize.height>600)) {
                cv::imshow("dst", dst);
                cv::waitKey(10);
            }
        }
        double precence = double(i+1)/(size.height)*100.0;
        cout<<" [ "<<setw(6)<<setprecision(2)<<fixed<<precence<<"% ]\n";
    }
    cout<<"\n [done]"<<endl;
}
// }}}

// interface (if it can be called an interface) {{{
void errorOut(string const& msg) {
    cerr<<msg<<endl;
    exit(1);
}

cv::Size calcDisplaySize(cv::Size sz)
{
    int w = sz.width,
        h = sz.height;
    int w2 = w,
        h2 = h;
    if (w>=h) {
        if(w>700) {
            w2= 700;
            h2= h * w2 / w;
        }
    } else {
        if (h>700) {
            h2= 700;
            w2= w * h2 / h;
        }
    }
    return cv::Size(w2,h2);
}

void display(cv::Mat const& img)
{
    cv::Mat m;
    cv::Size s=calcDisplaySize(img.size());
    if(s!=img.size()) {
        cv::resize(img,m,s);
        cv::imshow("display", m);
    } else {
        cv::imshow("display", img);
    }
    cv::waitKey(0);
}

int main(int argc, char *argv[]) {
    srand(time(0));
    vector<Image> pool;
    vector<string> poolPathes;
    string inPath;
    string outPath;
    double zoom=1.0;

    // boost::program_options is cute!
    po::variables_map vm;
    po::options_description desc("options");
    try{
        desc.add_options()
            ("help,h", "show this message")
            ("color,c", "generate colored mosaic")
            ("zoom,z", po::value<double>(&zoom)->default_value(zoom), "zoom rate")
            ("pool,p", po::value<vector<string> >(&poolPathes), "image pool")
            ("image-size,S", po::value<int>(&g_image_size)->default_value(g_image_size),
                "size of small images")
            ("thumb-size,s", po::value<int>(&g_thumb_size)->default_value(g_thumb_size),
                "size of thumbnails to be used for compairing")
            ("input,i", po::value<string>(&inPath), "input image file")
            ("output,o", po::value<string>(&outPath), "output image file")
            ("top-n,t", po::value<int>(&g_top_n)->default_value(g_top_n), "choose a random piece from top-n like ones")
            ("display,d", "Display the result image")
            ("open,x", "View the result image using associated program in your system")
        ;
        po::positional_options_description p;
        p.add("input", -1);
        po::store(po::command_line_parser(argc,argv)
                     .options(desc).positional(p).run(),
                  vm);
        po::notify(vm);
    } catch(exception const& e) {
        errorOut(e.what());
    }
    if(vm.count("help")) {
        cout<<desc<<endl;
        return 0;
    }
    if(! vm.count("input")) {
        errorOut("No input file");
    }
    if(! vm.count("output")) {
        errorOut("No output file");
    }
    if( vm.count("color")) {
        g_color = true;
    }
    if(! vm.count("pool")) {
        errorOut("Where can i find pieces to make mosaic?");
    } else {
        for(vector<string>::const_iterator citr = poolPathes.begin();
            citr != poolPathes.end();
            ++citr )
        {
            if(!fs::exists(*citr)) {
                errorOut("What is \""+*citr+"\" ??");
            } else if( fs::is_directory(*citr)) {
                addToPool(pool, *citr);
            }
        }
        if(pool.empty()) {
            errorOut("What do you expect when u got no image in pool?");
        }
    }
    if( g_image_size<g_thumb_size ) {
        errorOut("You are doing something foolish, human.");
    }

    cv::Mat src;
    cv::Mat dst;
    try{
        if(g_color) {
            cout<<"Reading source image [colored] "<<endl;
            src = cv::imread(inPath, 1);
        } else {
            cout<<"Reading source image [b&w]"<<endl;
            src = cv::imread(inPath, 0);
        }
    } catch(...) {
        errorOut(string("Can\'t read your input file: \"")+inPath+"\"");
    }
    cv::Size s(src.size());
    if(s==cv::Size(0,0))
        errorOut(string("Can\'t read your input file: \"")+inPath+"\"");
    s.width = static_cast<int>(s.width/g_image_size*g_thumb_size*zoom);
    s.width -= s.width%g_thumb_size;
    s.height = static_cast<int>(s.height/g_image_size*g_thumb_size*zoom);
    s.height -= s.height%g_thumb_size;
    if(s!=src.size()) {
        cv::resize(src, dst, s);
        src=dst.clone();
    }
    doRandomMosaic(pool, src, dst);
    try{
        cv::imwrite(outPath,dst);
    } catch(...) {
        errorOut("Failed to save the image, please check your RP.");
    }

    if(vm.count("display")) {
        display(dst);
    }
    if(vm.count("open")) {
        system(outPath.c_str());
    }

    return 0;
}
// }}}