会社近くの檜町公園やミッドタウンガーデンっていう所でサンドイッチとか食べてますｖ

今はミッドタウンでDESIGN TOUCHっていうイベントの期間中で、今日は熱気球が上がってました。
けっこう近くで見たんですが、ゴーっていう炎の音がすごいんですね。

あと、ガレリアB1Fではデザイン展が開かれていて、初期のApple Mouseとか展示してあって面白かったです。

11月からは忙しくなるので、今の内に元気を溜めておこう。

上記のシンプルな連立一次方程式を cv::Mat クラスの機能を使って解いてみます。

// 係数行列 A
float dataA[][3] = { {1.0, -2.0, 3.0}, {3.0, 1.0, -5.0}, {-2.0, 6.0, -9.0} };
// 行列 B
float dataB[] = {1.0, -4.0, -2.0};
Mat matA(3, 3, CV_32FC1, dataA);
Mat matB(3, 1, CV_32FC1, dataB);
Mat matX(3, 1, CV_32FC1);

// AX = B を解く. 両辺にAの逆行列を前掛けする
matX = matA.inv()*matB;

MatConstIterator_<float> iter = matX.begin<float>();
while(iter != matX.end<float>()) printf("%.1f\n", *iter++);

• 出力結果

1.0　// x
3.0　// y
2.0　// z

CvMatでは cvmInvert -> cvmMul と関数を順番に呼び出さないといけないところを、
cv::Matなら matX = matA.inv()*matB のように直感的に行列演算を行うことができます。
また、今回のような線形な問題であれば solve(matA, matB, matX) で解くこともできます。

基本的な行列演算

以下のような細かい操作もできます。

matA*5.0;　// 行列の各要素に5を掛ける (スケーリング)

matA.row(0) = matA.row(2)*2.0;　// 3行目をスケーリングして1行目に (添字に注意)

また、Matlabスタイルの行列初期化関数も用意されています。

Mat zero = Mat::zeros(3, 3, CV_32FC1);　// 零行列を生成
Mat eye = Mat::eye(3, 3, CV_32FC1);　// 単位行列を生成
Mat one = Mat::ones(3, 3, CV_32FC1);　// 全要素が 1 の行列を生成

これ以外にもまだまだたくさんの機能があります。
今まで面倒だった行列演算がかなり楽になるのでうれしいですね。

関連記事：
OpenCV 2.0 – cv::Mat
OpenCV 2.0 – cv::Ptr
OpenCV 2.0を試してみた

OpenCV C++ matrix class

前回、OpenCV 2.0 – cv::Ptr ではスマートポインタである cv::Ptr について調べました。
今回はOpenCV 2.0のC++インタフェースの中でも重要な役割を持つ cv::Mat クラスについて。
このクラスは従来の IplImage 及び CvMat に取って代わるものになっていますが、
かなり大きいクラスなので何回かに分けて調べていきたいと思います。

cv::Mat はマルチチャンネルとROI(Region Of Interest)をサポートしている二次元行列です。
オブジェクトの生成方法は複数ありますが、ここでは基本的な方法から紹介します。

using namespace cv;
using namespace std;

// create() メソッド　(5行5列，各要素が8ビット符号なし整数型 3チャンネル)
// タイプ指定：CV_<bit-depth>{U|S|F}C<number_of_channels>
Mat matA;
matA.create(5, 5, CV_8UC3);

// コンストラクタ　(3行3列，各要素が32ビット浮動小数点型 1チャンネル)
Mat matB(3, 3, CV_32FC1);

// コンストラクタの引数に cv::Size を指定
Mat matC(Size(640, 480), CV_8UC3);

// 二次元配列を使って初期化
double data[][3] = { {1,2,3}, {4,5,6}, {7,8,9} };
Mat matD(Size(3, 3), CV_64FC1, data);

// std::vector を使って初期化
// デフォルトでは浅いコピー、第二引数にtrueを指定すると深いコピーになる
// この場合、10行1列の行列が生成され、要素は全て0で初期化される
vector<double> v(10);
Mat matE(v);　// or Mat matE(v, true);

// cv::Scalar を使って初期化
Mat matF(5, 5, CV_32FC2, Scalar(1.0, 3.0));

// コピーコンストラクタ (浅いコピー, refcount++)
Mat copy(matA);

// clone() メソッド　(深いコピー)
Mat clone = matA.clone();

// ROIを設定 (cv::Rect で位置と大きさを指定)
Mat roi(matC, Rect(10, 10, 100, 100));

// IplImage から cv::Mat に変換
IplImage* src_img = cvLoadImage("lena.jpg", CV_LOAD_IMAGE_COLOR);
Mat img(src_img);

// CvMat から cv::Mat に変換
CvMat* cv_mat = cvCreateMat(3, 3, CV_32FC1);
Mat mat(cv_mat);

次はMatクラスの構造について。
gdbで上のコードのmatAを見てみると、

(gdb) p matA
$1 = {
  flags = 1124024336,
  rows = 5,
  cols = 5,
  step = 15,
  data = 0xb07ff0 "",
  refcount = 0xb0803c,
  datastart = 0xb07ff0 "",
  dataend = 0xb0803b ""
}

メンバは基本的にCvMatと同様のものを備えています。
flagsはMatクラスの各メソッドで内部的に利用されているものなので特に気にしなくて構いません。
また、サイズはIplImageと比べるとかなり小さく、sizeofしてみるとIplImageは112、Matは32となっています。

各要素のアドレスは以下のように計算します。

// M(i, j) の要素のアドレス

// elemSize() は1要素のバイト数を返す
M.data + M.step*i + j*M.elemSize()

// 要素の型が既知の場合は at(int y, int x) が利用可能
// 内部では、指定された型のポインタでキャストされた (data + step*y)[x] がreturnされている
&M.at<double>(i, j)

---------------------------------------
// 各行の先頭アドレスは ptr(int y) で取得可能　(内部では、return data + step*y)
// 型指定しない場合は uchar* が返される
M.ptr<double>(y)
M.ptr(y)

とりあえず今回はcv::Matクラスの構造を主に紹介しました。
次からは実際にこのクラスを利用していろいろな処理を行いたいと思います。

:: 追記
＊ IplImage, CvMat と cv::Mat の互換性について
とりあえず、ドキュメントに載っていたコードを使って確認を行いました。

/* IplImage -> cv::Mat -> CvMat の順で変換 */

IplImage* img = cvLoadImage("lena.jpg", CV_LOAD_IMAGE_COLOR);
Mat mtx(img);
CvMat oldmat = mtx;

// OpenCV Error: Assertion failed~ は発生しないことを確認
CV_Assert(oldmat.cols == img->width && oldmat.rows == img->height
  && oldmat.data.ptr == (uchar*)img->imageData && oldmat.step == img->widthStep);

関連記事：
OpenCV 2.0 – cv::Ptr
OpenCV 2.0を試してみた

A template class for smart reference-counting pointers

OpenCV 2.0では cv::Ptr という参照カウント方式のスマートポインタが用意されています。
これは Boost C++ Library の shared_ptr と同様のもので大変便利です。
参考：参照カウント – Wikipedia

一時的にcv::Ptrクラスのrefcountというメンバをprotectedからpublicに変更して挙動を見てみます。
(cxcore.hppの660行目付近にあります)

class Test {
public:
  Test() { std::cout<<"construct"<<std::endl; }
  ~Test() { std::cout<<"destruct"<<std::endl; }
};

int main(void) {
  using namespace std;
  cv::Ptr<Test> p1(new Test());  // 参照カウント 1
  cout<<"refcount: "<<*(p1.refcount)<<endl;
  {
    cv::Ptr<Test> p2;
    p2 = p1;  // 参照カウントが+1されて2になる
    cout<<"refcount: "<<*(p1.refcount)<<endl;
  }  // 参照カウントが-1されて1になる、まだオブジェクトは解放されない
  cout<<"refcount: "<<*(p1.refcount)<<endl;
  cout<<"main exit"<<endl;
  return 0;
}  // Testオブジェクトが解放される

--------------
/** 結果
 construct
 refcount: 1
 refcount: 2
 refcount: 1
 main exit
 destruct
**/

すばらしい。
また、IplImage に適用した場合はきちんとテンプレートの特殊化が施されているので安心です。

int main(void) {
  cv::Ptr<IplImage> img = cvLoadImage("test.jpg");

  if(img.empty()) {
    std::cerr<<"can't load image."<<std::endl;
    return -1;
  }

  namedWindow("image", CV_WINDOW_AUTOSIZE);
  imshow("image", Mat(img));
  waitKey();

  return 0;
}

--------------------------------------------------------------------
/* 参照カウント(refcount)が0になると Ptr::delete_obj() が呼ばれる
 CvMatやIplImageは以下のように特殊化されている */
template<> inline void Ptr<CvMat>::delete_obj()
{ cvReleaseMat(&obj); }   

template<> inline void Ptr<IplImage>::delete_obj()
{ cvReleaseImage(&obj); }

OpenCV 1.0ではメモリのアロケートに cvAlloc() という malloc() のラッパーが使われていましたが、
OpenCV 2.0ではその代わりに fastMalloc() という関数が用意され、cv::Ptr内でもコールされています。
少し中を覗いてみると、どうやらシステムコールの mmap() でアロケートしているようです。
(Windowsでは普通のmalloc()が呼ばれる模様)
詳しくはまだ読めていませんが、fastというくらいだからきっと速くなっているんでしょう。

メモリ管理を cv::Ptr に任せておくと開発が楽になるのは間違いなさそうです。

関連記事：
OpenCV 2.0を試してみた

IplImage や CvMat は 新しいC++インタフェースでは cv::Mat に取って代わります。
(1.1preで追加されたWImageクラスの立場は? 関連：cv::WImage – OpenCV 1.1)
また、メモリ管理が賢くなっているので、後始末は各クラスのデストラクタに任せておきましょう。
boostのshared_ptrと同様のスマートポインタ(cv::Ptr)も用意されていて、いろいろ便利になっているようです。

C++インタフェースを中心にこれから少しずつ調べていこうと思います。

// カメラから画像をキャプチャ

#include <cv.h>
#include <highgui.h>

int main(int argc, char **argv) {
  using namespace cv;
  VideoCapture cap(0);  // VideoCapture(int device)
  if(!cap.isOpened()) return -1;
  Mat edges;
  char code;
  namedWindow("OpenCV 2.0 Capture Test", CV_WINDOW_AUTOSIZE);
  for(;;) {
    Mat frame;
    cap >> frame;  // virtual VideoCapture&  operator >> (Mat& image)
    cvtColor(frame ,edges, CV_BGR2GRAY);
    GaussianBlur(edges, edges, Size(7, 7), 1.5, 1.5);
    Canny(edges, edges, 0, 30, 3);
    imshow("OpenCV 2.0 Capture Test", edges);
    code = waitKey(30);
    if(code == 'q') break;
    if(code == 's') imwrite("test.jpg", edges);
  }
  return 0;
}

以前、FlexでXML-RPCを利用していた時は、確かbase64にエンコードして返していたと思うので、
Thriftでも同様にバイナリデータはbase64にエンコードして返すようにします。
Thriftのソースを漁っていると TBase64Utils とかいうのを見つけたのですが、
どうせboost必須なフレームワークなのでboostを使ってエンコードしてみます。

インタフェースとして、
・サービス名を Test
・プロシージャ名を returnImage
・引数は画像ファイル名、戻り値はbase64エンコード文字列
を定義します。

#!/usr/bin/thrift

service Test {
  string returnImage(1: string name)
}

画像ファイルを読み込んで、base64にエンコードするだけの処理です。
boostでbase64にエンコードする方法は以下のサイトを参考にさせていただきました。
B Lifeで行こう: boostでbase64のエンコード

ここではハンドラの部分のみ、自動生成部分は省略します。

class TestHandler : virtual public TestIf {

 public:
  TestHandler() {
  }

  void returnImage(std::string& _return, const std::string& name) {
    std::ifstream ifs;
    std::ostringstream oss;
    std::string str;

    ifs.open(name.c_str(), std::ios::in | std::ios::binary);
    if(!ifs.is_open()) {
      _return = "";
    }else {
      oss<<ifs.rdbuf();
      str = oss.str();
      _return = encode_base64(str);
    }
  }

  std::string encode_base64(const std::string& src_data) {
    using namespace boost::archive::iterators;
    const int Base64_Column_Width = 76;
    typedef insert_linebreaks<base64_from_binary<transform_width<
      const char *, 6, 8> >, Base64_Column_Width> base64_encoder;

    // エンコードしたデータを格納
    std::stringstream ost_base64;
    // エンコード処理
    std::copy(
      base64_encoder(src_data.c_str()),
      base64_encoder(src_data.c_str() + src_data.length()),
      std::ostream_iterator<char>(ost_base64)
    );
    std::string base64 = ost_base64.str();
    // 末尾の長さ調整
    while(((base64.length() % (Base64_Column_Width + 1)) % 4) > 0) {
      base64 += "=";
    }
    return base64;
  }
};

次にクライアントを今回はPHPで書きます。
RPCで受け取ったbase64エンコード文字列をimgタグに埋め込んで画面に表示します。

<?php
$GLOBALS['THRIFT_ROOT'] = 'src';
$GEN_DIR = 'gen-php';

/** Include the Thrift base */
require_once $GLOBALS['THRIFT_ROOT'].'/Thrift.php';

/** Include the binary protocol */
require_once $GLOBALS['THRIFT_ROOT'].'/protocol/TBinaryProtocol.php';

/** Include the socket layer */
require_once $GLOBALS['THRIFT_ROOT'].'/transport/TSocketPool.php';

/** Include the socket layer */
require_once $GLOBALS['THRIFT_ROOT'].'/transport/TBufferedTransport.php';

/** Include the generated code */
require_once $GEN_DIR.'/test/Test.php';
require_once $GEN_DIR.'/test/test_types.php';

$transport = new TSocket('localhost', 9090);
$client = new TestClient(new TBinaryProtocol($transport));

try {
  $transport->open();
  $img = $client->returnImage("lenna.jpg");  /* $img に base64エンコード文字列が入る */
  $transport->close();
}catch(Exception $e) {
  echo $e->getMessage();
}
?>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="www.w3.org/1999/xhtml" lang="ja" xml:lang="ja">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta http-equiv="Content-Style-Type" content="text/css" />
<title>Embed Base64 Image Test</title>
</head>
<body>
<img src="data:image/jpg;base64,<?php echo $img ?>" />
</body>
</html>

こんな感じで一応上手く表示まで行うことができました。

サーバ側で画像処理を行った後、出力画像をクライアントに返す時などに使えます。
楽な方法なんですが、大きな画像データをやりとりするのには向いてないですね；；
もうちょっと良い方法を探してみます。

・関連記事
Thrift + OpenCV
Thrift::例外処理
Thriftインストール

Slab Allocatorの部分に興味を持ったので、それについてわかったことのメモ。
以下のサイトで事前知識を付けてからコードを読みました。
memcachedを知り尽くす：第2回　memcachedのメモリストレージを理解する

Slab Allocator : メモリの確保・管理を行うメカニズム

　・メモリアロケーションでオーバーヘッドの大きいmalloc()を極力呼ばない
　・一度アロケートしたメモリ領域を再利用してメモリフラグメンテーションを抑える

これらを実現するために以下のルールでメモリアロケーションを行っています。
　・memcachedの初期化時にmalloc()で大きな領域(slabと呼ばれる, デフォルトで1MB)を確保
　・あるslab classに属するslabは全て同一サイズのchunkで構成される
　・chunkサイズはslab classにより異なる
　・各slabはどのchunkが使われていないかを指すポインタを持っている
　・chunkは不要になったらfree()されるのではなく、再利用するためにchunkリストに戻される
　・もし利用可能なchunkがなくなった場合は、malloc()して新しいslabを作成する

Slab Allocatorの実装は slabs.h, slabs.c
　・ slabclass_t 構造体
chunkサイズやslabのリストを持っています。
これを見ると、chunkのことをコード上ではitemと呼んでいる模様。

typedef struct {
    unsigned int size;      /* sizes of items */
    unsigned int perslab;   /* how many items per slab */

    void **slots;           /* list of item ptrs */
    unsigned int sl_total;  /* size of previous array */
    unsigned int sl_curr;   /* first free slot */

    void *end_page_ptr;         /* pointer to next free item at end of page, or 0 */
    unsigned int end_page_free; /* number of items remaining at end of last alloced page */

    unsigned int slabs;     /* how many slabs were allocated for this class */

    void **slab_list;       /* array of slab pointers */
    unsigned int list_size; /* size of prev array */

    unsigned int killing;  /* index+1 of dying slab, or zero if none */
    size_t requested; /* The number of requested bytes */
} slabclass_t;

static slabclass_t slabclass[MAX_NUMBER_OF_SLAB_CLASSES];

　・Slab Allocatorは固定数のslabclass_t配列を持ち、chunkサイズでソートされている
　・slabclass_t配列のインデックス番号はclsidと呼ばれ、これはslab classを識別するためのidになっている

Slab Allocatorのメインインタフェース

unsigned int slabs_clsid(const size_t size);
void *slabs_alloc(size_t size, unsigned int id);
void slabs_free(void *ptr, size_t size, unsigned int id);

malloc()が実際にメモリ割り当てを行っているのに対して、
slab_alloc()はあらかじめ確保した領域から、最適なサイズのchunkを返しているだけです。
同様に、free()が実際にメモリ解放を行っているのに対して、
slab_free()はchunkをリスト(slabclass_tのslots)に戻しているだけです。

unsigned int clsid;
item *it;
clsid = slabs_clsid(item_size);  // item_sizeに応じてclsidを決める
it = slabs_alloc(item_size, clsid); // item_sizeとclsidをもとにchunkの割り当てを行う
slabs_free(it, item_size, clsid); // chunkをリストに戻す

このSlab Allocatorの仕組みは、Linuxカーネルでも使われているとのことです。
時間があれば続きを読んでいきたいと思います。

・参考
MemcachedSlabAllocator – memcached -

ここでは、画像の各チャンネルの平均値と標準偏差を求めてみます。
サーバ側でOpenCVの cvAvgSvd() を利用すればOK。

まず、最初にRPCのインタフェースをThrift IDLに書きます。
ここでは、平均と標準偏差を求める関数を2つ作ることにしました。
各チャンネルの値が欲しいので戻り値は list<double> に、
引数は画像ファイル名を指定したいので string にしておきます。

• cv.thrift (サービス名は CV)

service CV {
  list<double> calcAvg(1: string img)
  list<double> calcSdv(1: string img)
}

• thriftコマンドでコード生成

$ thrift --gen cpp --gen perl --gen php --gen rb cv.thrift

サーバ側の実装ではC++で普通にOpenCVを使って書けばOKです。
(今回の場合は gen-cpp/CV_server.skeleton.cpp というファイルを編集する)
メソッドの引数にだけ注意しておきます。
ここではコードを一部省略しますが、実際はドメインロジック以外自動生成されます。
ソケットを作って接続を待ったり、データ構造をシリアライズしたりといった面倒な部分は、
全てThriftが引き受けてくれるので安心です。

• サーバ側 CV_server.skeleton.cpp (C++)

#include "CV.h"
#include <protocol/TBinaryProtocol.h>
#include <server/TSimpleServer.h>
#include <transport/TServerSocket.h>
#include <transport/TBufferTransports.h>

#include <cv.h>
#include <highgui.h>
#include <iostream>

/*  中略  */

class CVHandler : virtual public CVIf {
  IplImage *srcImg;
  CvScalar mean;
  CvScalar std_dev;
 public:
  CVHandler() {
    srcImg = 0;
    mean = cvScalarAll(0);
    std_dev = cvScalarAll(0);
  }

  void calcAvg(std::vector<double> & _return, const std::string& img) {
    if((srcImg = cvLoadImage(img.c_str(), CV_LOAD_IMAGE_ANYDEPTH |  CV_LOAD_IMAGE_ANYCOLOR)) == 0) {
      std::cout<<"load error."<<std::endl;
      exit(0);
    }
    cvAvgSdv(srcImg , &mean, NULL);
    for(int i=0;i<3;++i) _return.push_back(mean.val[i]);
    cvReleaseImage(&srcImg);
  }

  void calcSdv(std::vector<double> & _return, const std::string& img) {
    /* 以下略 (calcAvgと同様に書けばよい)*/
　

• コンパイル

$ g++ -g CV.cpp CV_server.skeleton.cpp -o CV_server `pkg-config --cflags --libs opencv thrift`

次はクライアント側を実装します。
• クライアント側 cv.pl (Perl)

#!/usr/bin/perl

use strict;
use warnings;
use lib './gen-perl';

use Thrift;
use Thrift::BinaryProtocol;
use Thrift::Socket;

use CV;

my $transport = Thrift::Socket->new('localhost', 9090);
my $client = CVClient->new(Thrift::BinaryProtocol->new($transport));

eval {
  $transport->open();
  print "Calculate the Mean\n( Blue Green Red ) = ( ";
  printf "%f ", $_ for @{$client->calcAvg("lena.jpg")};　# 戻り値はリストリファレンス
  print ")\n\n";
  print "Calculate the Standard-Deviation\n( Blue Green Red ) = ( ";
  printf "%f ", $_ for @{$client->calcSdv("baboon.jpg")};
  print ")";
  $transport->close();
};

if($@) {
  warn $@->{message};
}

• サーバの起動およびクライアントの実行

$ mv ./gen-cpp/CV_server .
$ ./CV_server

$ chmod +x cv.pl
$ ./cv.pl
Calculate the Mean
( Blue Green Red ) = ( 105.398991 99.562698 179.730305 )

Calculate the Standard-Deviation
( Blue Green Red ) = ( 60.611124 47.493925 55.499225 )

上手くいきました。
次はPHPから。抽象化レイヤのおかげでPHPでも簡単に使えます。
• クライアント側 cv.php (PHP)

<?php
$GLOBALS['THRIFT_ROOT'] = 'src';
$GEN_DIR = 'gen-php';

/** Include the Thrift base */
require_once $GLOBALS['THRIFT_ROOT'].'/Thrift.php';

/** Include the binary protocol */
require_once $GLOBALS['THRIFT_ROOT'].'/protocol/TBinaryProtocol.php';

/** Include the socket layer */
require_once $GLOBALS['THRIFT_ROOT'].'/transport/TSocketPool.php';

/** Include the socket layer */
require_once $GLOBALS['THRIFT_ROOT'].'/transport/TBufferedTransport.php';

/** Include the generated code */
require_once $GEN_DIR.'/CV.php';
require_once $GEN_DIR.'/cv_types.php';

$transport = new TSocket('localhost', 9090);
$client = new CVClient(new TBinaryProtocol($transport));

try {
  $transport->open();
  print_r($client->calcAvg("lena.jpg"));　/* Perl版と同じように呼べる */
  print_r($client->calcSdv("baboon.jpg"));
  $transport->close();
}catch(Exception $e) {
  echo $e->getMessage();
}

?>

• 出力結果

Array
(
    [0] => 105.3989906311
    [1] => 99.562698364258
    [2] => 179.73030471802
)
Array
(
    [0] => 60.611123950567
    [1] => 47.493925313866
    [2] => 55.499224912776
)

詳細は省きますが、Rubyでもシンタックスを変えるだけで利用できます。

# Rubyでも簡単
client.calcAvg("lena.jpg")
client.calcSdv("baboon.jpg")

今回はThriftを使って各言語から簡単にOpenCVを利用できることを確認しました。

それはともかくOpenCV 2.0 のリリースが Sept. 31, 2009 って書いてありましたが、
また便利な機能が追加されてるんですかね。楽しみです。

macbookへのインストールについてはThriftインストールを参照。
hello, world 的な話はたくさん情報が公開されているのでそちらを参考するといいかと。
ここでは例外処理についてメモしておきます。

TException
ThriftはRPCフレームワークです。
このRPCにおいてなんらかの理由でサーバと通信ができなかった時などの異常系処理。
ThriftではTExceptionという例外オブジェクトを送出します。
PerlとPHPの例を載せますが、以下のように普通にハンドリングすればOKです。

• Perlの場合

my $transport = Thrift::Socket->new('localhost', 9090);
my $client = HelloClient->new(Thrift::BinaryProtocol->new($transport));

eval {
  $transport->open();
  printf "%s¥n", $client->hello("aru");
  $transport->close();
};
if($@) {
  print $@->{message};
}

• PHPの場合

$transport = new TSocket('localhost', 9090);
$client = new HelloClient(new TBinaryProtocol($transport));

try {
  $transport->open();
  echo $client->hello("aru");
  $transport->close();
}catch(Exception $e) {
  echo $e->getMessage();
}

普通ですね。
エラーメッセージは message というプロパティに入っています。

• エラーメッセージ例

TSocket: Could not connect to localhost:9090

RPCにおける異常系処理にも特に頭を悩ませることがないのはうれしいです。

今日は六本木ヒルズの森美術館とスカイアクアリウムに行ってきました。
美術館はフラッシュ無しなら撮影可だったんですが、なんとデジカメを忘れるという。。
まぁここに写真を貼るよりああいうのは実物をみないとあんまり意味ないですし。

一応ケータイで東京の街並みを撮りましたが、ひどい画質。。

あとは、マグカップとかエンピツを買ってきました。

職場から歩いて5,6分くらいなんですが、あまり行かないので今日はイイ気分転換になりました。

一応メモ。
今回はMacbookにインストールしました。
Thriftはboostが必須なので注意。公式サイトにはSo please download the bzip2 of boost and unpack〜〜とか書いてありますが、portでインストールしてしまいます。

$ sudo port install boost

インストールに失敗する場合は一度cleanしてみる。

$ sudo port clean --work boost

環境変数の設定も忘れずに(.bashrc, .zshrc …)。

export PATH=/opt/local/bin:/opt/local/sbin/:$PATH
export MANPATH=/opt/local/man:$MANPATH
export LIBRARY_PATH=/opt/local/lib:$LIBRARY_PATH
export LD_LIBRARY_PATH=/opt/local/lib:$LD_LIBRARY_PATH
export C_INCLUDE_PATH=/opt/local/include:$C_INCLUDE_PATH
export CPLUS_INCLUDE_PATH=/opt/local/include:$CPLUS_INCLUDE_PATH
export DYLD_FALLBACK_LIBRARY_PATH=/opt/local/lib
export BOOST_ROOT=/opt/local/include/boost:$BOOST_ROOT

あとはThrift本体をインストールするだけです。

$ wget -O thrift.tgz "http://gitweb.thrift-rpc.org/?p=thrift.git;a=snapshot;h=HEAD;sf=tgz"
$ tar -xzf thrift.tgz
$ cd thrift
$ ./bootstrap.sh
$ ./configure
$ make
$ sudo make install

ただ、僕の場合 ./configure で以下のようなエラーがでました。

./configure: line 21183: syntax error near unexpected token `MONO,'
./configure: line 21183: `  PKG_CHECK_MODULES(MONO, mono >= 1.2.6, have_mono=yes, have_mono=no)'

意味がわからなくて途方に暮れていたんですが、公式のFAQに解決策が書いてありました。。
FAQ – Thrift Wiki
If you’re on OS X: find pkg.m4, copy it to thrift/aclocal, and rerun bootstrap.sh.
とあるので、とりあえず /opt/local/share/aclocal に pkg.m4 があるか確認してからcopy。
(pkgconfigパッケージがインストールされている必要がある)

$ cp /opt/local/share/aclocal/pkg.m4 ./aclocal
$ ./bootstrap.sh
.... 略

make install まで上手くいきました。
公式にドキュメントがある場合はFAQも含めてよく読もう。

＜追記＞
各言語のライブラリのインストールも忘れないように。
ここでは、perl, ruby, pythonの各ライブラリをインストールしておきます。

$ cd lib/perl
$ perl Makefile.PL
$ sudo make install
$ cd ../rb
$ sudo ruby setup.rb
$ cd ../py
$ sudo python setup.py install

Apple Mini DisplayPort − DVI アダプタとDVI to HDMI変換ケーブルで併せて5000円くらいだったと思います。

TV側がフルハイビジョン(1920×1080)なので、２枚目のディスプレイとしては申し分ない大きさです。
ただ、こっちでコードとか書くのはツライのでTV側には主にブラウザとかを配置することになるかと。

作業用デスクとディスプレイは大きい方が良い。

// グレースケールのデータ
private function serializeData(data:Vector.<Number>, img:BitmapData):void {
  for(var y:int=0; y<h; y++) {
    for(var x:int=0; x<w; x++) {
      data[x + y*w] = img.getPixel(x, y) & 0xff;
    }
  }
}

こんな風に書いていました。
ナイトビジョンエフェクトのコードは最初はByteArrayで書いてて、その後でVectorに書き換えています。
get/setVector() vs get/setPixels()
で、コードの整理ついでに位相限定相関のコードもVector版で書き換えようとしたんですが、
位相限定相関法はフーリエ変換してからいろいろ計算する必要があります。
でも、getVector() の戻り値が Vector.<uint> なのでこのままでは使えません。
ということで、

// reはVector.<Number>, imgDataはBitmapData
re = Vector.<Number>(imgData.getVector(imgData.rect));

と書いて実際これで上手く動いたのですが、これって新しいVectorをさらにもう一つ生成してることになるの?
ちなみに速度的には前述の getPixel() での一次元化とほとんど変わりませんでした。
(計算量的にはこの部分がボトルネックになってるわけではないのですが；)
メリットはコードが少しだけ短くなることですかね。

参考：トップレベルの定数と関数 – ActionScript 3.0 言語およびコンポーネントリファレンス

・ソースコード
FFT演算用クラスはこれまで利用してきたものと同じものです → FFT.as

package {
  import __AS3__.vec.Vector;

  import flash.display.*;
  import flash.geom.Point;
  import flash.utils.getTimer;

  [SWF(width = "514", height = "300", backgroundColor = "#000000", frameRate = "12")]

  public class POC extends Sprite {
    [Embed(source = './assets/lennagray1.jpg')]
    private var EmbedImage:Class;

    [Embed(source = './assets/lennagray2.jpg')]
    private var EmbedImage2:Class;

    private var srcBmp:Bitmap;
    private var srcBmp2:Bitmap;
    private var imgData:BitmapData;
    private var imgData2:BitmapData;
    private var re:Vector.<Number>;
    private var im:Vector.<Number>;
    private var re2:Vector.<Number>;
    private var im2:Vector.<Number>;
    private var rePOC:Vector.<Number>;
    private var imPOC:Vector.<Number>;
    private var w:int = 0;
    private var h:int = 0;

    public function POC() {
      srcBmp = new EmbedImage() as Bitmap;
      imgData = srcBmp.bitmapData.clone();
      srcBmp2 = new EmbedImage2() as Bitmap;
      imgData2 = srcBmp2.bitmapData.clone();
      w = imgData.width;
      h = imgData.height;
      var ts:int = getTimer();
      // 画像データの直列化
      re = Vector.<Number>(imgData.getVector(imgData.rect));
      re2 = Vector.<Number>(imgData2.getVector(imgData2.rect));
      im = new Vector.<Number>(w*h, true);
      im2 = im.concat();
      rePOC = im.concat();
      imPOC = im.concat();

      // 位相限定相関
      phaseOnlyCorrelation(re, im, re2, im2, rePOC, imPOC);
      var te:int = getTimer();
      trace("time: " + (te - ts) + " ms");
      // ピーク値と座標の探索
      var peak:Number = 0.0, spectrum:Number = 0.0;
      var pos:Point = new Point();
      for(var y:int=0; y<h; y++) {
        for(var x:int=0; x<w; x++) {
          //spectrum = Math.sqrt(rePOC[x + y*w]*rePOC[x + y*w] + imPOC[x + y*w]*imPOC[x + y*w]);
          spectrum = rePOC[x + y*w] + Math.abs(imPOC[x + y*w]);
          if(spectrum > peak){
            peak = spectrum;
            pos.x = x;
            pos.y = y;
          }
        }
      }
      trace("peak: " + peak + ", position: " + pos);
      addChild(srcBmp);
      addChild(srcBmp2).x += w + 2;
    }
    // 位相限定相関
    private function phaseOnlyCorrelation(srcRe1:Vector.<Number>, srcIm1:Vector.<Number>, srcRe2:Vector.<Number>, srcIm2:Vector.<Number>, dstRe:Vector.<Number>, dstIm:Vector.<Number>):void {
      var fft:FFT = new FFT(w);
      var spectrum:Number = 0.0;
      // 2D-FFT
      fft.fft2d(srcRe1, srcIm1);
      fft.fft2d(srcRe2, srcIm2);
      for(var i:int=0; i<w*h; i++) {
        // 位相を算出 (振幅で正規化)
        spectrum = Math.sqrt(srcRe1[i]*srcRe1[i] + srcIm1[i]*srcIm1[i]);
        srcRe1[i] /= spectrum;
        srcIm1[i] /= spectrum;
        spectrum = Math.sqrt(srcRe2[i]*srcRe2[i] + srcIm2[i]*srcIm2[i]);
        srcRe2[i] /= spectrum;
        srcIm2[i] /= spectrum;
        // 相互相関
        dstRe[i] = srcRe1[i]*srcRe2[i];
        dstIm[i] = srcIm1[i]*(-srcIm2[i]);
      }
      // 2D-IFFT
      fft.fft2d(dstRe, dstIm, true);
    }
  }
}

・出力結果
time: 1542 ms
peak: 0.44900903245107504, position: (x=86, y=45)

The Quick Brown Fox～とは———————————————-

英語のパングラムの一つであり、タイプライターやコンピュータのキーボードの試験などによく用いられる。quick brown fox（クイック・ブラウン・フォックス）と略して呼称することが多い。パングラムとは、ラテン文字のアルファベット26字をすべて用い、かつ重複をなるべく少なくした短文のこと。

———-
最近は業務で簡単な動画配信周りの処理を書くことになり今はその対応をしています。
言語はperlなんですが、今まで遊び程度でしか書いたことがなかったので今がんばって勉強中。
今後はperl関連のことも書いていくかもしれません。(今はまだ[perl]タグは付けません)

テンプレートパラメータの宣言でclassとtypenameの違いはないが、typenameにはもう一つの意味があって、これを使わなければならない場所がある。例えば、STLコンテナを引数に取る関数テンプレートを作る時、

template <typename T>
void func(const T& container) {
  if(container.size() > 2) {
    T::const_iterator iter(container.begin());  // 型名とは解釈されないのでエラー
    ...

C++には、テンプレート内にあるネストされた依存名は、特に指示されていなければ型名とは解釈されないというルールがある。T::const_iteratorを型名と解釈させるためにはコンパイラに指示を与える必要があるが、ここで使うのがtypename。

template <typename T>
void func(const T& container) {
  if(container.size() > 2) {
    typename T::const_iterator iter(container.begin());  // 依存型名の頭にtypenameを付ける
    ...

typenameはネストされた依存名でのみ使う。

template <typename C>               // typenameを使う(classでもよい)
void f(const C& container,          // typenameは使えない
       typename C::iterator iter);  // typenameが必要

ただし、派生クラスを定義するときの基底クラスの指定と、初期化子リスト内での基底クラスの指定ではtypenameは使わないので注意。

template <typename T>
class Derived:public Base<T>::Nested {  // 基底クラスの指定ではtypenameを使えない
public:
  explicit Derived(int x)  // 初期化子リスト内での基底クラスの指定ではtypenameを使えない
  :Base<T>::Nested(x)
  {
    typename Base<T>::Nested temp;  // ネストされた依存名なのでここではtypenameが必要
    ...
  }
  ...
};

参考：Effective C++ 42項

これからゆっくりといじっていきましょうかね。
なんか便利なツールあったら教えてください^^

>> Demo

今回はFlexで簡単なデモを作りました(ソースコードは右クリックから)。
指定した日付まで過去にさかのぼってひたすら見出しを表示しつづけます。
カテゴリーとデータソートの種類を指定(掲載開始時間順 or PV指標順)する機能と、
見出しをクリックするとバックナンバーのページに飛ぶ機能が付いています。

勢いでガガッと作ったので中身は粗いですが、
1ユーザーとしてチームに良いフィードバックができたらいいなと思ってます。

6月10日発売のOpenCVの新しい書籍です。
NAISTの人達が書いたOpenCV プログラミングブックを既に持っていてこの本を買う意義としては、
強いて挙げるなら6章の「OpenGLとの連携」と7章の「物体検出の機械学習」の部分でしょうか。
ちなみに5章では「映像解析」を扱っていますが、ここで紹介されている処理を載せておきます。

・テンプレートマッチング
・オプティカルフロー
・離散フーリエ変換フィルタリング
・モーションテンプレート
・Haar-like特徴分類

理論説明はほとんどなくて関数紹介が主な内容です。
1,2年前ならHaar-likeの所の説明はとても有用だったんだと思いますが、今はWeb上でたくさん調べられます。
カメラキャリブレーション関係を扱っていないのもツライ。
あと、OpenCV プログラミングブックにはあった巻末の関数リファレンスがなかったのも残念です。
CD-ROMなんか付けなくていいから代わりにリファレンスを付けて欲しかった。

良い所はOpenCV プログラミングブックよりも載っているソースコードが見やすいところ。
大きめで読みやすいフォントが使われています。

大学院時代は機械学習方面にはあまり興味がなくて研究でも取り組んでいなかったんですが、
今はヒマがあったら勉強してみようかなと思っているところです。
なので7章はじっくり読んで実践して、ある程度理解したらTech Noteにもメモしておきます。