« 2010年6月 | トップページ | 2010年8月 »

2010年7月

2010.07.29

プログラムの落書き
processing

Processing_raku_2




思い通りの計算結果にならない。。。
だからちょっと落書き。。。


package faceCatch;

import processing.core.PApplet;

public class RagiTest extends PApplet{

        float deg, dd, d;

        int co1 = 0;
        int co2 = 50;
        int co3 = 150;

        int sz1 = 10;
        int sz2 = 10;
        int sz3 = 10;

        float cenX = 200, cenY = 200;

        boolean jude1, jude2, jude3;

        public void setup(){
                size(400, 400);
                background(40);
        }

        public void draw(){

                //background(40);

                d += 1.f;
                dd += 6.0f;
                deg += 4.0f;

                float r = radians(d);
                float rr = radians(dd);
                float rad = radians(deg);

                float x, y, xx, yy, xxx, yyy;

                x = cos(rad) * 50 + cenX;
                y = sin(rad) * 10 + cenY;

                xx = cos(rr) * 20 + x;
                yy = sin(rr) * 100 + y;

                xxx = cos(r) * 120 + xx;
                yyy = sin(r) * 40 + yy;

                smooth();


                //colorの変化値
                if(co1 > 255){
                        co1 = 0;
                }
                if(co2 > 255){
                        co2 = 0;
                }
                if(co3 > 255){
                        co3 = 0;
                }
                co1 ++;
                co2 ++;
                co3 ++;


                //sizeの値変化
                if(sz1 > 100){
                        jude1 = false;
                }
                if(sz1 < 5){
                        jude1 = true;
                }
                if(jude1){
                        sz1 += 5;
                } else {
                        sz1 -= 5;
                }

                if(sz2 > 120){
                        jude2 = false;
                }
                if(sz2 < 5){
                        jude2 = true;
                }
                if(jude2){
                        sz2 += 5;
                } else {
                        sz2 -= 5;
                }

                if(sz3 > 150){
                        jude3 = false;
                }
                if(sz3 < 5){
                        jude3 = true;
                }
                if(jude3){
                        sz3 += 5;
                } else {
                        sz3 -= 5;
                }


                //System.out.println("sz1 " + sz1 + " sz2 " + sz2 + " sz3 " + sz3);

                stroke(co2, co3, co1, 10);

                line(x, y, xx, yy);
                line(xx, yy, xxx, yyy);
                line(xxx, yyy, xx, yy);

                stroke(co1, co2, co3, 30);

                noFill();

                ellipse(x, y, sz1, sz1);
                ellipse(xx, yy, sz2, sz2);
                ellipse(xxx, yyy, sz3, sz3);


        }
}



アート・オブ・アジャイル デベロップメント アート・オブ・アジャイル デベロップメント
組織を成功に導くエクストリームプログラミング


価格 : ¥3,780 (税込み)

アジャイル開発は人のなせる技。アジャイル開発を極めるためには、その時々で無数の可能性を評価して最善の方策を選択することを学ぶ必要があります。本書は、あなたがアジャイル開発の「道」を極める手助けとなります。

| | コメント (0) | トラックバック (0)

2010.07.25

今日の畑
カボチャの性質から学ぶトマトの自立栽培

カボチャの性質から学ぶトマトの自立栽培

今年初めて挑戦したカボチャ、一つの種から現在で30個ほどの実がなっています。
今のところ追肥をしたことはなく、はじめの堆肥のみでこの生育様です。

カボチャは、元株から蔓をのばし、節から葉、子蔓、花、根、と一通りの部品を出します。多分推測すると株から7〜8節目以降に雌花を付けるようプログラムされているはずです。(子蔓は5〜6節目ぐらい?)
イチゴとよく似た性質の植物で、蔓はイチゴで言うランナーでしょうか、こうしたシステムを導入している植物は、元株が老衰しても関係なく、伸びた蔓の節から根を張り水分と栄養を補給している。他の植物の生育を邪魔するぐらい旺盛な生命力で人間の手間を必要としません。

勢いがなかなか収まらないカボチャに関心していてトマトについて一つの考えが浮かびました。
昨年、トマトの栽培方法を知らず、ただ支柱に括り付けていて伸び放題のわき芽が折れ、そこから病気に感染した失敗から、トマトは自立できない植物なのだ。と、決めつけていましたが、実際は人間が本来のトマトの性質とは違う方法で栽培しているのではないか、、、

トマトは垂れ下がったわき芽から沢山の根を出します。
その多くは地面に届くことはないのですが、めげずに出します。これはカボチャの節から出る根と同じように機能するのではないか。


わき芽が伸びる、→ 倒れる、 → わき芽から根が出る → わき芽からわき芽が伸びる、 → 倒れる、 → わき芽から根が出る、 ループ。

java風に書くなら、
while( 秋になるまで ){

	わき芽を伸ばす
	//自然に倒れる
	根が出る

	if( 節数 > 3 ){

		花を付ける
	}

	日付カウント
}



このようなサイクルが本来トマトの正しい生育方法で、こういった中心から円状に広がる成長により、種をより遠くに運ぶ事を達成しているのではないだろうか。

つうことで、来期はトマトの自立栽培に挑戦してみよう!


_dsc0001

_dsc0002

_dsc0004

_dsc0007

_dsc0009

_dsc0010

_dsc0012

_dsc0014

_dsc0017

_dsc0020




永田農法 トマトの本 永田農法 トマトの本

価格 : ¥1,680 (税込み)

永田農法が初めて語る“露地栽培トマト”のおいしさの秘密と作り方。そのすべてを大公開!『ミシュランガイド東京2008』に掲載され、世界からも注目を浴びる日本料理の名店『分とく山』の総料理長・野崎洋光氏と、南青山でこだわりの野菜料理が大評判のイタリアンレストラン『クチーナトキオネーゼコジマ』の名シェフ・小嶋正明氏による、永田農法のトマト料理大饗宴!!も収録。

| | コメント (0) | トラックバック (0)

2010.07.23

エッジ検出
processing java

Edge



まだ薄い理解でプログラムを組んだせいか、エッジ検出ではなく、コントラストを強めるフィルターになってしまった。目的とは違うけれど、今後のためにメモ。
後で分かりやすいように配列に代入。


package faceCatch;

import processing.core.PApplet;
import processing.video.*;

import java.awt.Color;

public class Edge extends PApplet{


        //////////////////////////////////////////////////////////////////////////////////////////

        private static final long serialVersionUID = 1L;

        //閾値
        float iThresh = 100.0f;

        //カメラオブジェクトの変数
        Capture camera;

        //ピクセルの位置を格納する変数
        int pos;

        //カラー定数
        final int WHITE = 0xffffffff;
        final int BLACK = 0xff000000;
        final int RED = 0xffff0000;

        //ラプシアンフィルタ
        final int[] RapFilter = new int[] {-1, -1, -1, -1, 8, -1, -1, -1, -1};

        //9近傍のカラー値を格納する配列
        float[] colorArray = new float[9];

        //フィルタ後のセル
        float cellColor;

        //変動値
        float XXX = 0.36f;


        //////////////////////////////////////////////////////////////////////////////////////////



        public void setup(){

                size(320, 240);

                colorMode(HSB, 256);

                //Captureオブジェクトの準備
                camera = new Capture(this, 320, 240, 30);


        } //end of setup()




        public void draw(){


                //カメラ画像のピクセルをロード
                camera.loadPixels();

                //カメラ画像の表示
                image(camera, 0, 0);

                //グレースケールにする
                filter(GRAY);

                //画面のピクセルのロード
                loadPixels();

                //エッジ検出フィルタリング処理へ

                //1ピクセル内側を調べる
                for(int i = 1; i < height - 1; i++){
                        for(int j = 1; j < width - 1; j++){

                                //ピクセルの位置
                                pos = (i * width) + j;

                                //System.out.println(pixels[pos]);
                                //System.out.println("red " + red(pixels[pos]));
                                //16進数に変換し3回足すそして、整数化

                                //9近傍の値を配列に代入、ここの値を255のgにする別にどれでも同じだけれど
                                colorArray[0] = green(pixels[pos - width - 1]);
                                colorArray[1] = green(pixels[pos - width]);
                                colorArray[2] = green(pixels[pos - width + 1]);
                                colorArray[3] = green(pixels[pos - 1]);
                                colorArray[4] = green(pixels[pos]);
                                colorArray[5] = green(pixels[pos + 1]);
                                colorArray[6] = green(pixels[pos + width - 1]);
                                colorArray[7] = green(pixels[pos + width]);
                                colorArray[8] = green(pixels[pos + width + 1]);

                                cellColor =
                                RapFilter[0] * colorArray[0] + RapFilter[1] * colorArray[1] +
                                RapFilter[2] * colorArray[2] + RapFilter[3] * colorArray[3] +
                                RapFilter[4] * colorArray[4] + RapFilter[5] * colorArray[5] +
                                RapFilter[6] * colorArray[6] + RapFilter[7] * colorArray[7] + RapFilter[8] * colorArray[8];

                                cellColor = XXX * cellColor;

                                if(cellColor != 0){
                                        if(cellColor < 0){
                                                cellColor = -cellColor;
                                        }
                                        if(cellColor > 255){
                                                cellColor = 255;
                                        }
                                        cellColor = cellColor / 255;
                                        //System.out.println("cellColor " + cellColor);
                                        Color c = new Color(cellColor, cellColor, cellColor, 1);
                                        pixels[pos] = c.getRGB();
                                        //pixels[pos] = gray(cellColor);
                                }
                        }
                }

                //ピクセルのアップデート
                updatePixels();

        } //end of draw()

        //キャプチャ映像のイベントハンドラ
        public void captureEvent(Capture camera){
                camera.read();
        } //end of captureEvant

}



ディジタル画像処理 ディジタル画像処理

価格 : ¥3,780 (税込み)


| | コメント (0) | トラックバック (0)

2010.07.22

オブジェクト認識003 ラベル処理
processing java



これこれ、想定していたとおりにやっとなった。


package faceCatch;

import processing.core.PApplet;
import processing.video.*;

public class Label_new002 extends PApplet{

        ///////////////////////////////////////////

        private static final long serialVersionUID = 1L;

        //閾値
        float iThresh = 100.0f;

        //カメラオブジェクトの変数
        Capture camera;

        //ピクセルの位置を格納する変数
        int pos;

        //ピクセルの値を格納する変数
        int pixColor;

        //明度値を格納する変数
        float b;

        //カラー定数
        final int WHITE = 0xffffffff;
        final int BLACK = 0xff000000;
        final int RED = 0xffff0000;

        //ラベルの色
        int labelColor;

        //4近傍変数
        int top, bottom, left, right, leftTop, rightTop, leftBottom, rightBottom;

        int endCell = (320 * 240) - 1;

        //labelIDごとに変化する色の値
        int idColor = 0xff223366;

        //近傍値検査のカウンター
        int cellCun;

        ///////////////////////////////////////////

        //コンストラクタ
        public Label_new002(){

        }

        public void setup(){

                size(320, 240);
                colorMode(HSB, 256);

                //Captureオブジェクトの準備
                camera = new Capture(this, 320, 240, 30);

        } //end of setup()


        public void draw(){
                //ラベルのID
                int labelID = 1;
                //map宣言初期化
                int labelMap[] = new int[width * height];
                //カラーの初期化
                idColor = 0xff334455;

                //カメラ画像のピクセルをロード
                camera.loadPixels();
                //画面のピクセルのロード
                loadPixels();

                //ピクセルの検査白黒化
                for(int i = 0; i < height; i++){
                        for(int j = 0; j < width; j++){

                                //ピクセルの位置
                                pos = (i * width) + j;
                                //ピクセルの値を取得する(RGB)
                                pixColor = camera.pixels[pos];

                                //明度の抽出
                                b = brightness(pixColor);

                                //明度が設定した閾値より上か下か
                                if(b <= iThresh){

                                        pixels[pos] = BLACK;

                                } else {

                                        pixels[pos] = WHITE;

                                }

                        }
                } //end of for() 2値化完了



                //ラベリング処理開始
                for(int i = 0; i < height; i++){
                        for(int j = 0; j < width; j++){

                                //ピクセルの位置
                                int posss = (i * width) + j;

                                //ピクセルが白かを調べる
                                if(pixels[posss] == WHITE){

                                        //ピクセルが白だったらIDを付加して色をつける
                                        setLabel(posss, labelID, labelMap);

                                        //処理が終了したらIDを加算
                                        labelID++;

                                        //カラーの加算
                                        idColor += 0xff112233;


                                } //end of if
                        }
                } //end of for()

                //ピクセルのアップデート
                updatePixels();


        } //end of draw()



        ////////////////////////////////////////////////////////////////////////////////////////////////////////////



        private void setLabel(int myPosition, int labelID, int labelMap[]){

                //自分の印を付ける
                labelMap[myPosition] = labelID;
                pixels[myPosition] = RED;

                do{
                        //近傍値のカウント
                        cellCun = 0;

                        for(int i = 0; i < height; i++){
                                for(int j = 0; j < width; j++){

                                        //ピクセルの位置
                                        pos = (i * width) + j;

                                        //myPositionを見つける
                                        if(labelMap[pos] == labelID){

                                                //近傍値検査

                                                //上ピクセルの検査
                                                if(pos > width - 1){//一行目より大きいとき
                                                        top = pos - width;
                                                        if(pixels[top] == WHITE){
                                                                labelMap[top] = labelID;
                                                                pixels[top] = idColor;

                                                                //カウントアップ
                                                                cellCun++;
                                                        }
                                                }

                                                //下ピクセルの検査
                                                if(pos < width * (height -1)){
                                                        bottom = pos + width;
                                                        if(pixels[bottom] == WHITE){
                                                                labelMap[bottom] = labelID;
                                                                pixels[bottom] = idColor;

                                                                //カウントアップ
                                                                cellCun++;
                                                        }

                                                }

                                                //右ピクセルの検査
                                                if(pos != (width * (i + 1)) - 1){
                                                        right = pos + 1;
                                                        if(pixels[right] == WHITE){
                                                                labelMap[right] = labelID;
                                                                pixels[right] = idColor;

                                                                //カウントアップ
                                                                cellCun++;
                                                        }
                                                }

                                                //左ピクセルの検査
                                                if(pos != width * i){
                                                        left = pos - 1;
                                                        if(pixels[left] == WHITE){
                                                                labelMap[left] = labelID;
                                                                pixels[left] = idColor;

                                                                //カウントアップ
                                                                cellCun++;
                                                        }
                                                }
                                        }
                                }
                        }

                } while(cellCun != 0);
        }


        //キャプチャ映像のイベントハンドラ
        public void captureEvent(Capture camera){
                camera.read();
        } //end of captureEvant


}



3次元画像処理入門 3次元画像処理入門

価格 : ¥2,835 (税込み)

入門的な3次元画像処理の書籍としては国内初。3次元画像処理を学部・院レベルで講義する際に最適な教科書。

| | コメント (0) | トラックバック (0)

2010.07.21

オブジェクト認識002
processing java



おかしな事になった。


画像解析テキスト―NIH Image,Scion Image,ImageJ実践講座 画像解析テキスト
実践講座


価格 : ¥5,775 (税込み)

細胞数のカウント、電気泳動のバンドの懐石、骨のX線画像の解析など、医学・生物学のさまざまな画像解析が自由自在。新たな画像解析ソフト「ImageJ」に対応し、ますます実践的になった改訂第3版。

| | コメント (0) | トラックバック (0)

ムービーシーケンス002






Kind of Blue Kind of Blue

価格 : ¥1,379 (税込み)

50年代末、それまでジャズの中心的なスタイルだったハードバップが、先鋭な発想をもったミュージシャンには飽き足らないものと映るようになっていた。そこでマイルス・ディヴィスは、煮詰まった音楽の一新を計るべく、ジャズの演奏原理に「モード」と呼ばれる新しい音楽理念を導入した。そのときに作ったのがこのアルバムである。

| | コメント (0) | トラックバック (0)

2010.07.20

オブジェクト認識
processing java

2値化に成功したので2値化からオブジェクト認識に挑戦。
処理の進め方に自分自身納得が行かないというか、どこか違うように思えてならない。
余計なことしてるきがする。どっか間違ってるな〜。やろうとしていることと違う。うーん。OpenCVつかっちゃおうかな、、、

Label2



package faceCatch;

import processing.core.PApplet;
import processing.video.*;

public class Label extends PApplet{

        ///////////////////////////////////////////

        private static final long serialVersionUID = 1L;

        //閾値
        float iThresh = 100.0f;

        //カメラオブジェクトの変数
        Capture camera;

        //平均値
        int pixAverage;

        //ループ変数
        int i, j;

        //ピクセルの位置を格納する変数
        int pos;

        //明度値を格納する変数
        float b;

        //カラー
        final int WHITE = 0xffffffff;
        final int BLACK = 0xff000000;
        final int RED   = 0xffff0000;

        //ラベルのID
        int labelID;

        //ラベル識別MAP
        int labelMap[];

        //ラベルの色
        int labelColor;

        //4近傍変数
        int top, bottom, left, right;

        int celMax = (320 * 240) - 1;

        ///////////////////////////////////////////

        //コンストラクタ
        public Label(){

        }

        public void setup(){

                size(320, 240);
                colorMode(HSB, 256);

                //Captureオブジェクトの準備
                camera = new Capture(this, 320, 240, 30);

                //ラベルmapの準備
                labelMap = new int[width * height];



        } //end of setup()


        public void draw(){

                //カメラ画像のピクセルをロード
                camera.loadPixels();
                //画面のピクセルのロード
                loadPixels();

                //ピクセルの検査2値化
                for(i = 0; i < height; i++){
                        for(j = 0; j < width; j++){

                                //ピクセルの位置
                                pos = (i * width) + j;

                                //明度の抽出
                                b = brightness(camera.pixels[pos]);

                                //明度が設定した閾値より上か下か
                                if(b <= iThresh){

                                        pixels[pos] = BLACK;

                                } else {

                                        pixels[pos] = WHITE;

                                }

                        }
                } //end of for() 2値化完了

                //ラベリング処理開始全てのピクセルから白いピクセルを調べる
                for(i = 0; i < height; i++){
                        for(j = 0; j < width; j++){

                                //ピクセルの位置
                                pos = (i * width) + j;

                                //ピクセルが白とき
                                if(pixels[pos] == WHITE){

                                        //自分の周りに白いピクセルがあるか探すメソッドの実行
                                        setLabel(pos, labelID);
                                        labelID++;
                                } //end of if
                        }
                } //end of for()

                //ピクセルのアップデート
                updatePixels();
        } //end of draw()


        //ラベリングと4近傍の検査
        private void setLabel(int position, int mylabelID){

                //自分の位置pixels[position]が白であると確定している時ここにいる
                labelMap[position] = mylabelID;
                pixels[position] = RED;

                //自分の回りに白いピクセルが無くなるまで調べ続ける
                for(i = 0; i < height; i++){
                        for(j = 0; j < width; j++){
                                //ピクセルの位置
                                int poss = (i * width) + j;

                                if(labelMap[position] == mylabelID){
                                        //近傍値
                                        //一つ上の検査
                                        if(poss > width){
                                                top = poss - width;
                                                if(pixels[top] == WHITE){
                                                        labelMap[top] = mylabelID;
                                                        //色を塗る
                                                        pixels[top] = RED;
                                                }
                                        }

                                        //一つ下の検査
                                        if(poss < width * (height - 1)){
                                                bottom = poss + width;
                                                if(pixels[bottom] == WHITE){
                                                        labelMap[bottom] = mylabelID;
                                                        //色を塗る
                                                        pixels[bottom] = RED;
                                                }
                                        }

                                        //一つ左の検査
                                        if(poss % width != 0 && poss != 0){
                                                left = poss - 1;
                                                if(pixels[left] == WHITE){
                                                        labelMap[left] = mylabelID;
                                                        //色を塗る
                                                        pixels[left] = RED;
                                                }
                                        }

                                        //一つ右の検査
                                        if(poss != (width - 1) * i && poss != celMax){
                                                right = poss + 1;
                                                if(pixels[right] == WHITE){
                                                        labelMap[right] = mylabelID;
                                                        //色を塗る
                                                        pixels[right] = RED;
                                                }
                                        }
                                } //end of if()
                        }
                } //end of for()


        } //end of setLabel()


        //キャプチャ映像のイベントハンドラ
        public void captureEvent(Capture camera){
                camera.read();
        } //end of captureEvant


}



OpenCV OpenCV
コンピュータビジョンライブラリを使った画像処理・認識


価格 : ¥4,830 (税込み)

コンピュータが「目」を持ち、情報に基づいて意思決定することが可能なアプリケーションをどう開発するかについて、OpenCVの開発者であるGary Bradski氏が詳しく解説します。
本書を読めば、研究者や開発者も電子ホビーストもOpenCVが提供するフレームワークの使い方を身につけてすぐに活用できます。

| | コメント (0) | トラックバック (0)

2010.07.18

I.S まんが日本昔ばなし 「片ひたのわらじ」



昔話で一番思い出深い作品。ずっとこれが見たかった。
餅が美味そうで美味そうで、


決定版 まんが日本昔ばなし101 決定版 まんが日本昔ばなし101

価格 : ¥2,940 (税込み)

おなじみ「まんが日本昔ばなし」の決定版!
「桃太郎」から「十二支の由来」まで。なつかしい話、めずらしい話……かつてTVで一大ブームを作った「まんが日本昔ばなし」の中から傑作101話を厳選しました。

| | コメント (0) | トラックバック (0)

ムービーシーケンス



javaやprocessingになれるとmaxのコーディングが分からなくなる。


超ブルーノート入門 超ブルーノート入門
―ジャズの究極・1500番台のすすめ


価格 : ¥735 (税込み)

ブルーノートにはジャズの全てがある。特に1500番台の98枚には、ジャズが最も熱かった時代の息吹があり、今も燦然と輝いている。好評の「超」シリーズの語り口で、その魅力を詳しく解説する。

| | コメント (0) | トラックバック (0)

2010.07.17

今日の畑
畑の虫たち

先週植え替えたネギが少しやせてしまいました。雨が降ったとはいえ、根を失ったので体内の水分が使われたのでしょう。でも、新しい葉が出てきたので少し安心。通気性が良く日光が良くあたる新しい畝で元気に生長してほしいな。

梅雨明して猛暑になり、サツマイモとカボチャが勢いをましています。
今日数えたらカボチャは25個実っていました。まだまだ蔓が伸びて花を咲かせていますので、もっと増えるかもしれません。一株で肥料あげなくてもこれだけできれば申し分ないですね。

日頃、畑に来ると多くの虫を見つけるので今日は意識して写真に収めてみました。
動きが素早いものもいるので実際はもっと多くの虫であふれています。内容は補食昆虫に害虫にと実に様々です。
とても珍しい発見としては、今回、蟻もどきを見つけました。6月初めには、空豆に取り付いた蜘蛛の蟻もどきを見つけたことはありますが、今回はどうやらカメムシの仲間のようです。注意深く観察すると、口がストローのような管になっており、蟻の足付きと若干の違いが見受けられ、それに伴い歩き方も、カメムシに似たぎこちなさです。
蜘蛛が蟻に擬態するのは、蜘蛛を食すためだと思いますが、カメムシ(多分)が蟻に擬態化するのは蟻に食べられないためでしょうか?僕は、蟻が見た目で仲間を判断しているとは思えないので、ほかの虫から身を守るためかとも考えましたが、それほど蟻って強い存在なのでしょうか?

_0015573_2

_0015567

_0015569

_0015582

_0015589

_0015572

_0015592

_0015593

_0015585

_0015586

_0015591

_0015596

_0015600




我が家でミニ野菜をつくる1 ミニトマト 我が家でミニ野菜をつくる1 ミニトマト

価格 : ¥1,500 (税込み)

世界初!書店で買える野菜栽培キット登場
野菜栽培キット付きMOOKです。
皆さんの家庭で明日から園芸が楽しめます!!

| | コメント (0) | トラックバック (0)

2010.07.16

2値化(白黒)フィルタ RGB値平均検出版
processing java

RGB値平均検出版

速度、特にかわらないな。

Threshold_rgb



package faceCatch;

//import processing

import processing.core.PApplet;
import processing.video.*;

public class Threshold_rgb extends PApplet{

        ////////////////////////////////////////////////////////////////////////////

        //閾値
        float iThresh = 100.0f;

        private static final long serialVersionUID = 1L;

        //カメラオブジェクトの変数
        Capture camera;

        //平均値
        float pixAverage;

        //ループ変数
        int i, j;

        //ピクセルの位置を格納する変数
        int pos;

        //ピクセルの値を格納する変数
        int pixColor;

        //RGBを格納する変数
        float r, g, b;

        ////////////////////////////////////////////////////////////////////////////

        //コンストラクタ
        public Threshold_rgb(){

        }

        public void setup(){

                size(320, 240);
                colorMode(RGB, 256);

                //Captureオブジェクトの準備
                camera = new Capture(this, 320, 240, 30);


        } //end of setup()

        public void draw(){

                //画面のピクセルのロード
                loadPixels();
                //カメラ画像のピクセルをロード
                camera.loadPixels();

                //ピクセルの検査
                for(i = 0; i < height; i++){
                        for(j = 0; j < width; j++){

                                //ピクセルの位置
                                pos = (i * width) + j;
                                //ピクセルの値を取得する(RGB)
                                pixColor = camera.pixels[pos];

                                //RGBの値を抽出
                                r = red(pixColor);
                                g = green(pixColor);
                                b = blue(pixColor);

                                //RGBの値の平均をとる
                                pixAverage = (r + g + b) / 3;

                                //明度が設定した閾値より上か下か
                                if(pixAverage <= iThresh){

                                        pixels[pos] = -16777216;

                                } else {

                                        pixels[pos] = -1;

                                }

                        }
                } //end of for()

                //ピクセルのアップデート
                updatePixels();

        } //end of draw()

        //キャプチャ映像のイベントハンドラ
        public void captureEvent(Capture camera){
                camera.read();
        } //end of captureEvant

}



語りかける中学数学 語りかける中学数学

価格 : ¥2,940 (税込み)

「覚えるべきこと」と、「理解すべきこと」の違いに気づく。豊富な「誤答例」で間違いの理由がわかる。声が聞こえる徹底解説。数学の基本はすべて中学数学にある。
恥ずかしくてなかなか聞けない基礎の基礎、ほんとに分かりやすく解説してます。

| | コメント (0) | トラックバック (0)

2値化(白黒)フィルタ
processing java

先日グレースケール表示に成功したので、今度は2値化、すなわち白黒表示のフィルタを作ってみた。
やっていること自体そんなにかわりませんが、この白黒化でオブジェクト認識ができそうな気がします。

Threshold



package faceCatch;

//import processing

import processing.core.PApplet;
import processing.video.*;

public class Threshold extends PApplet{

        ////////////////////////////////////////////////////////////////////////////

        //閾値
        float iThresh = 100.0f;

        private static final long serialVersionUID = 1L;

        //カメラオブジェクトの変数
        Capture camera;

        //平均値
        int pixAverage;

        //ループ変数
        int i, j;

        //ピクセルの位置を格納する変数
        int pos;

        //ピクセルの値を格納する変数
        int pixColor;

        //明度値を格納する変数
        float b;

        ////////////////////////////////////////////////////////////////////////////

        //コンストラクタ
        public Threshold(){

        }

        public void setup(){

                size(320, 240);
                colorMode(HSB, 256);

                //Captureオブジェクトの準備
                camera = new Capture(this, 320, 240, 30);


        } //end of setup()

        public void draw(){

                //画面のピクセルのロード
                loadPixels();
                //カメラ画像のピクセルをロード
                camera.loadPixels();

                //ピクセルの検査
                for(i = 0; i < height; i++){
                        for(j = 0; j < width; j++){

                                //ピクセルの位置
                                pos = (i * width) + j;
                                //ピクセルの値を取得する(RGB)
                                pixColor = camera.pixels[pos];

                                //明度の抽出
                                b = brightness(pixColor);

                                //明度が設定した閾値より上か下か
                                if(b <= iThresh){

                                        pixels[pos] = -16777216;

                                } else {

                                        pixels[pos] = -1;

                                }

                        }
                } //end of for()

                //ピクセルのアップデート
                updatePixels();

        } //end of draw()

        //キャプチャ映像のイベントハンドラ
        public void captureEvent(Capture camera){
                camera.read();
        } //end of captureEvant

}



「わかる」とはどういうことか―認識の脳科学「わかる」とはどういうことか―認識の脳科学 (ちくま新書)
価格 : ¥777 (税込み)

われわれは、どんなときに「あ、わかった」「わけがわからない」「腑に落ちた!」などと感じるのだろうか。また「わかった」途端に快感が生じたりする。そのとき、脳ではなにが起こっているのか―脳の高次機能障害の臨床医である著者が、自身の経験(心像・知識・記憶)を総動員して、ヒトの認識のメカニズムを、きわめて平明に解き明かす刺激的な試み。

| | コメント (0) | トラックバック (0)

2010.07.15

I.S Damu / The Making of Another Introduction from HOW IT SHOULD SOUND



Damu The Fudgemunk
粒子の粗い音。MPC2000だったらなんでもこんな音になるのだろうか?それとも、この人だからだろうか?

| | コメント (0) | トラックバック (0)

グレースケール映像フィルタ
processing java

顔認識プログラムの副産物としてキャプチした映像をグレースケール表示にするプログラムを作った。
配列を一次元にしている訳ではなく、色相、彩度を0に変更しているだけなので処理が早くなる訳でもなし、ちょっと意味なし。


Bandw_2




package faceCatch;

//import processing
import java.awt.Color;

import processing.core.PApplet;
import processing.video.*;


public class BandW extends PApplet{

        ////////////////////////////////////////////////////////////////////////////

        private static final long serialVersionUID = 1L;

        //カメラオブジェクトの変数
        Capture camera;


        ////////////////////////////////////////////////////////////////////////////


        //コンストラクタ
        public BandW(){
        }

        public void setup(){

                size(320, 240);
                colorMode(HSB, 256);

                //Captureオブジェクトの準備
                camera = new Capture(this, 320, 240, 30);

        } //end of setup()

        public void draw(){

                //画面のピクセルのロード
                loadPixels();
                //カメラ画像のピクセルをロード
                camera.loadPixels();

                //値の検査
                for(int i = 0; i < height; i ++){
                        for(int j = 0; j < width; j++){
                                int pos = (i * width) + j;
                                //ピクセルの値を取得する(RGB)
                                int pixColor = camera.pixels[pos];


                                //16進数に変換
                                StringBuffer sb = new StringBuffer(Integer.toHexString(pixColor));

                                //16進数に変換した値が8桁だったら
                                if(String.valueOf(sb).length() == 8){
                                        //先頭のffを取り去る
                                        sb.delete(0, 2);

                                        //RGBをHSBに変換
                                        float pixcelHSB[] = Color.RGBtoHSB(rgb(sb.toString(), 1), rgb(sb.toString(), 2), rgb(sb.toString(), 3), null);

                                        pixels[pos] = Color.HSBtoRGB(0, 0, pixcelHSB[2]);

                                }
                        }
                }

                updatePixels();

                //カメラ画像の表示
                //image(camera, 0, 0);

        } //end of draw()

        //キャプチャ映像のイベントハンドラ
        public void captureEvent(Capture camera){
                camera.read();
        } //end of captureEvant

        //RGBを分解するメソッド
        public static int rgb(String rgb, int num){
                int rgbNum = 0;
                StringBuffer s = new StringBuffer(rgb);

                switch(num){
                        case 1:
                        //赤の処理
                        s.delete(2, 6);
                        break;
                        case 2:
                        //緑の処理
                        s.delete(0, 2);
                        s.delete(2, 4);
                        break;
                        case 3:
                        //青の処理
                        s.delete(0, 4);
                        break;
                }

                //16進数を10進数に変換する
                rgbNum = Integer.decode("0x" + s.toString()).intValue();
                return rgbNum;
        }
}



ちなみに、processingには便利で簡単なグレースケールのメソッドが用意されています。
filter(GRAY);と一行追加してやるだけで、OKです。


わかりやすいパターン認識わかりやすいパターン認識
価格 : ¥2,940 (税込み)

本格的なマルチメディア時代を迎えるにあたり、種々のメディアの効率的処理のための基本技術であるパターン認識を、初学者が独学で学べるようにわかりやすく解説したテキスト。

| | コメント (0) | トラックバック (0)

2010.07.14

顔認識プログラム 3

先日制作したコードをwebカムのリアルタイム動画でまわしてみました。
内容はほぼ同じなので特にメモはなし、
この処理で大まかな顔のある位置を特定し、その後に詳細な顔の特定をしようと想定していたのですが、割と負荷が強く、そして、使用する環境に大きな影響を受けることが分かりました。
そういった結果から、HSBの値を元に顔を認識するのはよろしくない。んな気がします。


package faceCatch;

//import processing
import processing.core.PApplet;
import processing.video.*;


public class CameraTest extends PApplet{

        ////////////////////////////////////////////////////////////////////////

        private static final long serialVersionUID = 1L;

        //肌色定数上位下位
        //色相
        private static final int HueHig = 30;
        private static final int HueRow = 5;
        //彩度
        private static final int SatHig = 255;
        private static final int SatRow = 180;
        //明度
        private static final int BriHig = 200;
        private static final int BriRow = 150;

        //対象のピクセルがあるエリアの四隅の座標を代入する配列
        static int rect[][] = new int [4][2];

        //HSBそれぞれのT、D、L、RのXYを代入する変数
        static int rectH[][] = new int[4][2];
        static int rectS[][] = new int[4][2];
        static int rectB[][] = new int[4][2];

        //HSB判定用変数
        static boolean judgH = true;
        static boolean judgS = true;
        static boolean judgB = true;

        //カメラオブジェクトの変数
        Capture camera;

        ////////////////////////////////////////////////////////////////////////

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        //調査用forループ内の変数

        static int pos;
        static int color;
        static float h;
        static float s;
        static float b;
        static int x, y;
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        //コンストラクタ
        public CameraTest(){
        }

        public void setup(){
                size(320, 240);
                colorMode(HSB, 256);
                noStroke();
                //Captureオブジェクトの準備
                camera = new Capture(this, 320, 240, 12);
        }

        public void draw(){
                background(0);
                //カメラ画像のピクセルをロード
                camera.loadPixels();

                //カメラ画像の表示
                image(camera, 0, 0);

                //上からのHSB調査
                for(y = 0; y < height; y += 10){
                        for(x = 0; x < width; x += 10){

                                //ピクセルの位置
                                pos = (y * width) + x;
                                //その場所の色(RGB)
                                color = camera.pixels[pos];

                                //HSBの検出
                                h = hue(color); //色合いを抽出
                                s = saturation(color); //彩度を抽出
                                b = brightness(color); //光度を抽出

                                //色相判定がまだ見つかっていなければ
                                if(judgH){
                                        //色相を判定する
                                        if(judgmentHSB(h, 1)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[0][0] = x;
                                                rectH[0][1] = y;

                                                //判定の結果が見つかった
                                                judgH = false;
                                                //System.out.println("色相判定on");
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgS){
                                        //彩度を判定する
                                        if(judgmentHSB(s, 2)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[0][0] = x;
                                                rectS[0][1] = y;

                                                //判定の結果が見つかったら
                                                judgS = false;
                                                //System.out.println("彩度判定on");
                                        }
                                }

                                //明度判定がまだ見つかっていなければ
                                if(judgB){
                                        //彩度を判定する
                                        if(judgmentHSB(b, 3)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[0][0] = x;
                                                rectB[0][1] = y;

                                                //判定の結果が見つかったら
                                                judgB = false;
                                                //System.out.println("明度判定on");
                                        }
                                }
                        }
                } //end of T if()

                //判定の初期化
                judgH = true;
                judgS = true;
                judgB = true;

                //下からのHSB調査
                for(y = height - 1; y > 0; y--){
                        for(x = width - 1; x > 0; x--){
                                //ピクセルの位置
                                pos = (y * width) + x;
                                //その場所の色(RGB)
                                color = camera.pixels[pos];

                                //HSBの検出
                                h = hue(color); //色合いを抽出
                                s = saturation(color); //彩度を抽出
                                b = brightness(color); //光度を抽出

                                //色相判定がまだ見つかっていなければ
                                if(judgH){
                                        //色相を判定する
                                        if(judgmentHSB(h, 1)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[1][0] = x;
                                                rectH[1][1] = y;

                                                //判定の結果が見つかった
                                                judgH = false;
                                                //System.out.println("色相判定on");
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgS){
                                        //彩度を判定する
                                        if(judgmentHSB(s, 2)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[1][0] = x;
                                                rectS[1][1] = y;

                                                //判定の結果が見つかったら
                                                judgS = false;
                                                //System.out.println("彩度判定on");
                                        }
                                }

                                //明度判定がまだ見つかっていなければ
                                if(judgB){
                                        //彩度を判定する
                                        if(judgmentHSB(b, 3)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[1][0] = x;
                                                rectB[1][1] = y;

                                                //判定の結果が見つかったら
                                                judgB = false;
                                                //System.out.println("明度判定on");
                                        }
                                }
                        }
                } //end of D if()

                //判定の初期化
                judgH = true;
                judgS = true;
                judgB = true;

                //左からのHSB判定
                for(x = 0; x < width; x++){
                        for(y = 0; y < height; y++){
                                //ピクセルの位置
                                pos = (y * width) + x;
                                //その場所の色(RGB)
                                color = camera.pixels[pos];

                                //HSBの検出
                                h = hue(color); //色合いを抽出
                                s = saturation(color); //彩度を抽出
                                b = brightness(color); //光度を抽出

                                //色相判定がまだ見つかっていなければ
                                if(judgH){
                                        //色相を判定する
                                        if(judgmentHSB(h, 1)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[2][0] = x;
                                                rectH[2][1] = y;

                                                //判定の結果が見つかった
                                                judgH = false;
                                                //System.out.println("色相判定on");
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgS){
                                        //彩度を判定する
                                        if(judgmentHSB(s, 2)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[2][0] = x;
                                                rectS[2][1] = y;

                                                //判定の結果が見つかったら
                                                judgS = false;
                                                //System.out.println("彩度判定on");
                                        }
                                }

                                //明度判定がまだ見つかっていなければ
                                if(judgB){
                                        //彩度を判定する
                                        if(judgmentHSB(b, 3)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[2][0] = x;
                                                rectB[2][1] = y;

                                                //判定の結果が見つかったら
                                                judgB = false;
                                                //System.out.println("明度判定on");
                                        }
                                }
                        }
                } //end of L if()

                //判定の初期化
                judgH = true;
                judgS = true;
                judgB = true;

                //右からのHSB判定
                for(x = width - 1; x > 0; x--){
                        for(y = height - 1; y > 0; y--){
                                //ピクセルの位置
                                pos = (y * width) + x;
                                //その場所の色(RGB)
                                color = camera.pixels[pos];

                                //HSBの検出
                                h = hue(color); //色合いを抽出
                                s = saturation(color); //彩度を抽出
                                b = brightness(color); //光度を抽出

                                //色相判定がまだ見つかっていなければ
                                if(judgH){
                                        //色相を判定する
                                        if(judgmentHSB(h, 1)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[3][0] = x;
                                                rectH[3][1] = y;

                                                //判定の結果が見つかった
                                                judgH = false;
                                                //System.out.println("色相判定on");
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgS){
                                        //彩度を判定する
                                        if(judgmentHSB(s, 2)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[3][0] = x;
                                                rectS[3][1] = y;

                                                //判定の結果が見つかったら
                                                judgS = false;
                                                //System.out.println("彩度判定on");
                                        }
                                }

                                //明度判定がまだ見つかっていなければ
                                if(judgB){
                                        //彩度を判定する
                                        if(judgmentHSB(b, 3)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[3][0] = x;
                                                rectB[3][1] = y;

                                                //判定の結果が見つかったら
                                                judgB = false;
                                                //System.out.println("明度判定on");
                                        }
                                }
                        }
                } //end of R if()

                //判定の初期化
                judgH = true;
                judgS = true;
                judgB = true;

                //四角
                //noFill();

                /*
                stroke(204, 102, 255);
                quad(rectH[2][0], rectH[0][1], rectH[3][0], rectH[0][1], rectH[3][0], rectH[1][1], rectH[2][0], rectH[1][1]);

                stroke(150, 102, 255);
                quad(rectS[2][0], rectS[0][1], rectS[3][0], rectS[0][1], rectS[3][0], rectS[1][1], rectS[2][0], rectS[1][1]);

                stroke(50, 102, 255);
                quad(rectB[2][0], rectB[0][1], rectB[3][0], rectB[0][1], rectB[3][0], rectB[1][1], rectB[2][0], rectB[1][1]);
                */

                //HSBそれぞれのエリアから平均を求める
                int x1 = (rectH[2][0] + rectS[2][0] + rectB[2][0]) / 3;
                int y1 = (rectH[0][1] + rectS[0][1] + rectB[0][1]) / 3;
                int x2 = (rectH[3][0] + rectS[3][0] + rectB[3][0]) / 3;
                int y2 = (rectH[1][1] + rectS[1][1] + rectB[1][1]) / 3;

                stroke(10, 200, 150);
                quad(x1, y1, x2, y1, x2, y2, x1, y2);

        } //end of draw()

        //キャプチャ映像のイベントハンドラ
        public void captureEvent(Capture camera){
                camera.read();
        }

        //HSBを判定するメソッド
        private final boolean judgmentHSB(float hsb, int num){
                boolean judg = false;

                switch(num){
                        case 1: //H、色相判定
                        //色相判定領内だったらtrueを返す
                        if(hsb > HueRow && hsb < HueHig){

                                judg = true;

                        }
                        break;
                        case 2: //S、彩度判定
                        //彩度判定領内だったらtrueを返す
                        if(hsb > SatRow && hsb < SatHig){

                                judg = true;

                        }
                        break;
                        case 3: //B、明度判定
                        //明るさが判定領内だったらtrueを返す
                        if(hsb > BriRow && hsb < BriHig){

                                judg = true;

                        }
                        break;
                }
                return judg;
        }
}

Facecatch




環境によって精度がばらばら、


マンガでわかる統計学マンガでわかる統計学
価格 : ¥2,100 (税込み)

本書は統計の基礎から独立性の検定まで、マンガで理解!
統計の基礎である平均、分散、標準偏差や正規分布、検定などを押さえたうえで、アンケート分析に必要な手法の独立性の検定ができることを目標としている。統計の基礎を、学びたい方に最適の一冊。

| | コメント (0) | トラックバック (0)

2010.07.11

顔認識プログラム 2

前回の記事では肌色検出にて人間の顔を認識しようと考えていました。でも、はなっから肌色検出だけで顔認識ができると思っていなかったので、ある意味予想通りの結果を得ることができました。
それで、得られた結果から発展させるとして考えたのが、HSBの、「色相」、「彩度」、「明度」それぞれを別々に検査し、結果を平均してみるということです。
ここでは、厳密に顔認識する処理を後回しにすることで、“顔らしき場所”を特定することを目指しました。
細かな判断処理を重ね、やがて顔であると認識できるように段階を踏むプログラムを想定しています。

そして、今回のプログラムが下のものです。前述のとおり、色相、彩度、明度で判断をし、平均をとっています。円のポインタが顔のエリアに入っていれば今回はある程度合格点です。
また、ゴミとか、間違ったことしてますが、まぁ、気にしない。^^


package faceCatch;


//import processing
import processing.core.PApplet;
import processing.core.PImage;

import java.awt.Color;



public class FaceCatch extends PApplet{

        //これの意味は分からない
        private static final long serialVersionUID = 1L;

        //コンストラクタ
        public FaceCatch(){
        }

        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        //イメージの読み込みオブジェクト
        PImage mapImage;

        //イメージの縦横ピクセル
        int pixcelHieght, pixcelWidth;
        //イメージのピクセル値 HSB
        int celColorH, celColorS, celColorHB;
        //イメージのピクセル一つ分のRGB値
        int pixcelRGB;

        //肌色定数上位下位
        //色相
        final int HueHig = 30;
        final int HueRow = 5;
        //彩度
        final int SatHig = 255;
        final int SatRow = 150;
        //明るさ
        final int BriHig = 255;
        final int BriRow = 200;

        //肌色特定閾値
        final int THRASHOLD = Integer.decode("0x220000").intValue();

        //対象ピクセルのカラー値整数変換
        int colorInt = Integer.valueOf("FF7B2C", 16);

        //対象のピクセルがあるエリアの四隅の座標を代入する配列
        int rect[][] = new int [4][2];

        //HSBそれぞれのT、D、L、RのXYを代入する変数
        int rectH[][] = new int[4][2];
        int rectS[][] = new int[4][2];
        int rectB[][] = new int[4][2];


        //HSB判定用変数
        boolean judgHtoT = true, judgHtoD = true, judgHtoL = true, judgHtoR = true;
        boolean judgStoT = true, judgStoD = true, judgStoL = true, judgStoR = true;
        boolean judgBtoT = true, judgBtoD = true, judgBtoL = true, judgBtoR = true;


        //////////////////////////////////////////////////////////////////////////////////////////////////////////////////


        public void setup(){

                //画面サイズ
                size(200, 200, JAVA2D);

                //colorモード、レンジを255に設定
                colorMode(HSB, 255);

                //イメージの読み込み放射状
                mapImage = loadImage("画像のある場所");

                //ピクセルの縦数
                pixcelHieght = mapImage.height;
                //ピクセルの横数
                pixcelWidth = mapImage.width;

                //背景画像指定
                image(mapImage, 0, 0);


                //イメージの中から肌色を探し出し、その中心を求める処理

                /*
                * 具体的内容
                *
                * イメージの中で対象のピクセルを4点
                * 最上端、最下端、最左端、最右端、で求める。
                * 求められた点の座標から四隅、(上左、上右、下左、下右)を求め、その中心を求める
                */


                escT:
                //最上端を求める処理(上から右へ順次調べていく)
                for(int i = 0; i < pixcelHieght; i++){
                        for(int j = 0; j < pixcelWidth; j++){

                                //イメージからピクセルのRGBを取得
                                pixcelRGB = mapImage.get(j, i);

                                //16進数に変換して先頭のffを取り去る
                                StringBuffer sb = new StringBuffer(Integer.toHexString(pixcelRGB));
                                sb.delete(0, 2);

                                //RGBをHSBに変換
                                float pixcelHSB[] = Color.RGBtoHSB(rgb(sb.toString(), 1), rgb(sb.toString(), 2), rgb(sb.toString(), 3), null);

                                //RGB、HSB変換の戻り値floatをレンジ255の整数にマッピング

                                //色相を255にマップ
                                int hsbH = (int) (255 * pixcelHSB[0]);
                                //彩度を255にマップ
                                int hsbS = (int) (255 * pixcelHSB[1]);
                                //明るさを255にマップ
                                int hsbB = (int) (255 * pixcelHSB[2]);


                                //HSBそれぞれを別々の処理に分ける。


                                //色相判定がまだ見つかっていなければ
                                if(judgHtoT){
                                        //色相を判定する
                                        if(judgmentH(hsbH)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[0][0] = j;
                                                rectH[0][1] = i;

                                                //判定の結果が見つかった
                                                judgHtoT = false;
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgStoT){
                                        //彩度を判定する
                                        if(judgmentS(hsbS)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[0][0] = j;
                                                rectS[0][1] = i;

                                                //判定の結果が見つかったら
                                                judgStoT = false;
                                        }
                                }

                                //明るさ判定がまだ見つかっていなければ
                                if(judgBtoT){
                                        //彩度を判定する
                                        if(judgmentB(hsbB)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[0][0] = j;
                                                rectB[0][1] = i;

                                                //判定の結果が見つかったら
                                                judgBtoT = false;
                                        }
                                }

                                //全ての判定が出揃ったらループを抜ける
                                if(!judgHtoT & !judgStoT && !judgBtoT){

                                        break escT;

                                }
                        }
                } //end of for(TOP)

                ///////////////////////////////////////////////////////////////////////////////////////////

                escD:
                //最下端を求める処理(下から左に順に調べていく)
                for(int i = pixcelHieght - 1; i > 0; i--){
                        for(int j = pixcelWidth - 1; j > 0; j--){

                                //イメージからピクセルのRGBを取得
                                pixcelRGB = mapImage.get(j, i);

                                //16進数に変換して先頭のffを取り去る
                                StringBuffer sb = new StringBuffer(Integer.toHexString(pixcelRGB));
                                sb.delete(0, 2);

                                //RGBをHSBに変換
                                float pixcelHSB[] = Color.RGBtoHSB(rgb(sb.toString(), 1), rgb(sb.toString(), 2), rgb(sb.toString(), 3), null);

                                //RGB、HSB変換の戻り値floatをレンジ255の整数にマッピング

                                //色相を255にマップ
                                int hsbH = (int) (255 * pixcelHSB[0]);
                                //彩度を255にマップ
                                int hsbS = (int) (255 * pixcelHSB[1]);
                                //明るさを255にマップ
                                int hsbB = (int) (255 * pixcelHSB[2]);


                                //HSBそれぞれを別々の処理に分ける。


                                //色相判定がまだ見つかっていなければ
                                if(judgHtoD){
                                        //色相を判定する
                                        if(judgmentH(hsbH)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[1][0] = j;
                                                rectH[1][1] = i;

                                                //判定の結果が見つかった
                                                judgHtoD = false;
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgStoD){
                                        //彩度を判定する
                                        if(judgmentS(hsbS)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[1][0] = j;
                                                rectS[1][1] = i;

                                                //判定の結果が見つかったら
                                                judgStoD = false;
                                        }
                                }

                                //明るさ判定がまだ見つかっていなければ
                                if(judgBtoD){
                                        //彩度を判定する
                                        if(judgmentB(hsbB)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[1][0] = j;
                                                rectB[1][1] = i;

                                                //判定の結果が見つかったら
                                                judgBtoD = false;
                                        }
                                }

                                //全ての判定が出揃ったらループを抜ける
                                if(!judgHtoD & !judgStoD && !judgBtoD){

                                        break escD;

                                }
                        }
                } //end of for(Down)

                ///////////////////////////////////////////////////////////////////////////////////////////

                escL:
                //最左端を求める処理(左から下へと順に調べていく)
                for(int j = 0; j < pixcelWidth; j++){
                        for(int i = 0; i < pixcelHieght; i++){

                                //イメージからピクセルのRGBを取得
                                pixcelRGB = mapImage.get(j, i);

                                //16進数に変換して先頭のffを取り去る
                                StringBuffer sb = new StringBuffer(Integer.toHexString(pixcelRGB));
                                sb.delete(0, 2);

                                //RGBをHSBに変換
                                float pixcelHSB[] = Color.RGBtoHSB(rgb(sb.toString(), 1), rgb(sb.toString(), 2), rgb(sb.toString(), 3), null);

                                //RGB、HSB変換の戻り値floatをレンジ255の整数にマッピング

                                //色相を255にマップ
                                int hsbH = (int) (255 * pixcelHSB[0]);
                                //彩度を255にマップ
                                int hsbS = (int) (255 * pixcelHSB[1]);
                                //明るさを255にマップ
                                int hsbB = (int) (255 * pixcelHSB[2]);


                                //HSBそれぞれを別々の処理に分ける。


                                //色相判定がまだ見つかっていなければ
                                if(judgHtoL){
                                        //色相を判定する
                                        if(judgmentH(hsbH)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[2][0] = j;
                                                rectH[2][1] = i;

                                                //判定の結果が見つかった
                                                judgHtoL = false;
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgStoL){
                                        //彩度を判定する
                                        if(judgmentS(hsbS)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[2][0] = j;
                                                rectS[2][1] = i;

                                                //判定の結果が見つかったら
                                                judgStoL = false;
                                        }
                                }

                                //明るさ判定がまだ見つかっていなければ
                                if(judgBtoL){
                                        //彩度を判定する
                                        if(judgmentB(hsbB)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[2][0] = j;
                                                rectB[2][1] = i;

                                                //判定の結果が見つかったら
                                                judgBtoL = false;
                                        }
                                }

                                //全ての判定が出揃ったらループを抜ける
                                if(!judgHtoL & !judgStoL && !judgBtoL){

                                        break escL;

                                }
                        }
                } //end of for(Left)

                ///////////////////////////////////////////////////////////////////////////////////////////

                escR:
                //最右端を求める処理(左から下へと順に調べていく)
                for(int j = pixcelWidth - 1; j > 0; j--){
                        for(int i = pixcelHieght - 1; i > 0; i--){

                                //イメージからピクセルのRGBを取得
                                pixcelRGB = mapImage.get(j, i);

                                //16進数に変換して先頭のffを取り去る
                                StringBuffer sb = new StringBuffer(Integer.toHexString(pixcelRGB));
                                sb.delete(0, 2);

                                //RGBをHSBに変換
                                float pixcelHSB[] = Color.RGBtoHSB(rgb(sb.toString(), 1), rgb(sb.toString(), 2), rgb(sb.toString(), 3), null);

                                //RGB、HSB変換の戻り値floatをレンジ255の整数にマッピング

                                //色相を255にマップ
                                int hsbH = (int) (255 * pixcelHSB[0]);
                                //彩度を255にマップ
                                int hsbS = (int) (255 * pixcelHSB[1]);
                                //明るさを255にマップ
                                int hsbB = (int) (255 * pixcelHSB[2]);


                                //HSBそれぞれを別々の処理に分ける。


                                //色相判定がまだ見つかっていなければ
                                if(judgHtoR){
                                        //色相を判定する
                                        if(judgmentH(hsbH)){

                                                //判定がtrueであれば、Hの配列にXY座標を代入
                                                rectH[3][0] = j;
                                                rectH[3][1] = i;

                                                //判定の結果が見つかった
                                                judgHtoR = false;
                                        }
                                }

                                //彩度判定がまだ見つかっていなければ
                                if(judgStoR){
                                        //彩度を判定する
                                        if(judgmentS(hsbS)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectS[3][0] = j;
                                                rectS[3][1] = i;

                                                //判定の結果が見つかったら
                                                judgStoR = false;
                                        }
                                }

                                //明るさ判定がまだ見つかっていなければ
                                if(judgBtoR){
                                        //彩度を判定する
                                        if(judgmentB(hsbB)){

                                                //判定がtrueであれば、Sの配列にXY座標を代入
                                                rectB[3][0] = j;
                                                rectB[3][1] = i;

                                                //判定の結果が見つかったら
                                                judgBtoR = false;
                                        }
                                }

                                //全ての判定が出揃ったらループを抜ける
                                if(!judgHtoR & !judgStoR && !judgBtoR){

                                        break escR;

                                }
                        }
                } //end of for(Right)

                ///////////////////////////////////////////////////////////////////////////////////////////


                //四角
                noFill();

                stroke(204, 102, 255);
                quad(rectH[2][0], rectH[0][1], rectH[3][0], rectH[0][1], rectH[3][0], rectH[1][1], rectH[2][0], rectH[1][1]);

                stroke(150, 102, 255);
                quad(rectS[2][0], rectS[0][1], rectS[3][0], rectS[0][1], rectS[3][0], rectS[1][1], rectS[2][0], rectS[1][1]);

                stroke(50, 102, 255);
                quad(rectB[2][0], rectB[0][1], rectB[3][0], rectB[0][1], rectB[3][0], rectB[1][1], rectB[2][0], rectB[1][1]);


                //HSBそれぞれのエリアから平均を求める

                int x1 = (rectH[2][0] + rectS[2][0] + rectB[2][0]) / 3;
                int y1 = (rectH[0][1] + rectS[0][1] + rectB[0][1]) / 3;
                int x2 = (rectH[3][0] + rectS[3][0] + rectB[3][0]) / 3;
                int y2 = (rectH[1][1] + rectS[1][1] + rectB[1][1]) / 3;

                stroke(10, 200, 150);
                quad(x1, y1, x2, y1, x2, y2, x1, y2);



                //中心を求める
                int x = (x2 - x1) / 2 + x1;
                int y = (y2 - y1) / 2 + y1;

                stroke(5, 200, 255);
                ellipse(x, y, 30, 30);


                /*
                * 中心から特定のエリアのピクセル値を平均化し、その値の&#38334;値&#20869;に&#23646;するピクセルを中心から探し出し、ラベリング。一つのオブジェクトとして登&#37682;
                * 以後、そのオブジェクトをテンプレ&#12540;トとし、顔認&#35388;を行う
                *
                */



        } //end of setup

        public void draw(){


        }

        //色相を判断するメソッド
        public boolean judgmentH(int h){

                boolean judg = false;

                //色相判定領内だったらtrueを返す
                if(h > HueRow && h < HueHig){

                        judg = true;

                }
                return judg;
        }

        //彩度を判定するメソッド
        public boolean judgmentS(int s){

                boolean judg = false;

                //彩度判定領内だったらtrueを返す
                if(s > SatRow && s < SatHig){

                        judg = true;

                }
                return judg;
        }

        //明るさを判定するメソッド
        public boolean judgmentB(int b){

                boolean judg = false;

                //明るさが判定領内だったらtrueを返す
                if(b > BriRow && b < BriHig){

                        judg = true;

                }
                return judg;
        }

        //RGBを分解するメソッド
        public int rgb(String rgb, int num){
                int rgbNum = 0;
                StringBuffer s = new StringBuffer(rgb);

                switch(num){
                        case 1:
                        //赤の処理
                        s.delete(2, 6);
                        break;
                        case 2:
                        //緑の処理
                        s.delete(0, 2);
                        s.delete(2, 4);
                        break;
                        case 3:
                        //青の処理
                        s.delete(0, 4);
                        break;
                }

                //16進数を10進数に変換する
                rgbNum = Integer.decode("0x" + s.toString()).intValue();
                return rgbNum;
        }
}

Fc001_3

Fc002_3

Fc003_3




前回のプログラムでは反応しなかった画像にもプログラムを動作させることだ出来ました。
どうやら考え方は間違った方向に行ってなさそうですね。


完全独習 統計学入門完全独習 統計学入門
価格 : ¥1,890 (税込み)

「これ以上何かを削ったら、統計学にならない」という、最小限の道具立て(ツール)と簡単さで書かれた「超入門書」!! 確率の知識はほとんど使わない。微分積分もシグマも全く使わない。使う数学は、中学の数学(ルートと1次不等式)までだから、高校数学がわからなくても(忘れてしまっていても)大丈夫。毎講に穴埋め式の簡単な練習問題がついているので、独習に最適

| | コメント (0) | トラックバック (0)

顔認識プログラム

ちょっと腰が重いのだけれど、顔認識プログラムが作りたくて、一から少しずつ作っています。
やってくうちにC++に便利なAPIがあるという噂を知り、それをJavaから使おうかと思いましたが、ちょっと我慢しています。ロジックを自分で考える努力は後々に繋がりそうだもの。
ということで、現段階での考え方をコードと共にメモしておこうと思います。


はじめに作ったプログラムがこれです。

processingとゴミが混ざっていますが気にしない。うん。
内容は肌色検出です。正直肌色検出で顔認識するのは無理だと思っています。なぜかというと環境光の違いでとたんに検出できなくなるから。コードの最後で実験結果を貼付けたいと思います。
苦労した点はprocessingのcolor指定ですね、colorがただのintだというのがよく分からず、ずいぶん時間を費やしました。(今でもよく分かっていない)
本当に最初の頃はcolorModeをRGBでやってたので、検出がうまくいかず、HSBにして、赤系を指定してやれば!と思うが前述のcolor値で、数字がどの色を示しているのか分からなかった。この問題は10進数を16進数に変換して、先頭の"ff"(アルファ)を取り去ることで解決することができました。


package test;


//import processing
//import processing.core.*;
import processing.core.PApplet;
import processing.core.PImage;
import java.awt.Color;



public class FaceCatch extends PApplet{

        private static final long serialVersionUID = 1L;

        //コンストラクタ
        public FaceCatch(){

        }

        //イメージの読み込み
        PImage mapImage;

        //イメージのピクセルの個数
        int pixcelOll;
        //イメージの縦横ピクセル
        int pixcelHieght, pixcelWidth;
        //イメージのピクセル値 RGB
        int celColorR, celColorG, celColorB;
        //イメージのピクセル値 HSB
        int celColorH, celColorS, celColorHB;

        //肌色定数上位下位
        final String SKINOVER = "FFE1D5";
        final String SKINUNDER = "DE9D7F";

        //肌色特定閾値
        final int THRASHOLD = Integer.decode("0x220000").intValue();


        public void setup(){

                //画面サイズ
                size(200, 200, JAVA2D);

                //colorモード
                colorMode(HSB, 255);

                //イメージの読み込み
                mapImage = loadImage("画像のある場所");

                //ピクセルの縦数
                pixcelHieght = mapImage.height;
                //ピクセルの横数
                pixcelWidth = mapImage.width;

                //肌色定数を10進数のRGBごとに分解
                int skinColor[] = {

                        rgb(SKINOVER, 1),
                        rgb(SKINOVER, 2),
                        rgb(SKINOVER, 3),
                        rgb(SKINUNDER, 1),
                        rgb(SKINUNDER, 2),
                        rgb(SKINUNDER, 3),

                };

                //イメージの中に肌色が無いか調べる
                for(int i = 0; i < pixcelHieght; i++){
                        for(int j = 0; j < pixcelWidth; j++){


                                //ここで画像から取得されるピクセルの値はgetメソッドにより必ずRGBとなってしまう。これをHSBに変換してやる必要がある。



                                //取得されるRGBの調査

                                //イメージからピクセルのRGBを取得
                                int pixcelRGB = mapImage.get(j, i);


                                //System.out.println("取得したRGBの値を10進数の整数で表示_" + pixcelRGB);

                                //頭の2桁を取る
                                StringBuffer s = new StringBuffer(Integer.toString(pixcelRGB));
                                //-のみを取り去る
                                s.delete(0, 1);
                                //System.out.println("10進数_" + s);
                                //System.out.println("16進数に変換_" + Integer.toHexString(Integer.parseInt(s.toString())));

                                StringBuffer ss = new StringBuffer(Integer.toHexString(pixcelRGB));
                                ss.delete(0, 2);
                                //System.out.println("16進数_" + ss);


                                //RGBをHSBに変換
                                float pixcelHSB[] = Color.RGBtoHSB(rgb(ss.toString(), 1), rgb(ss.toString(), 2), rgb(ss.toString(), 3), null);

                                //テスト表示
                                //System.out.println("色相Hは、" + pixcelHSB[0]);
                                //System.out.println("彩度Sは、" + pixcelHSB[1]);
                                //System.out.println("明るさBは、" + pixcelHSB[2]);

                                //RGB、HSB変換の戻り値floatをレンジ255の整数にマッピング

                                //色相を255にマップ
                                int hsbH = (int) (255 * pixcelHSB[0]);
                                //彩度を255にマップ
                                int hsbS = (int) (255 * pixcelHSB[1]);
                                //明るさを255にマップ
                                int hsbB = (int) (255 * pixcelHSB[2]);

                                //System.out.println("H_" + hsbH + " S_" + hsbS + " B_" + hsbB);



                                if(hsbH > 5 && hsbH < 30 && hsbS > 50 && hsbB > 170 && hsbB < 250){
                                        //System.out.println("該当のデータが見つかりました");
                                        mapImage.set(j, i, 255);
                                }




                                /*
                                //取得した値を16進数に変換し、先頭の2文字FFを削除する
                                StringBuffer s = new StringBuffer(Integer.toHexString(mapImage.get(j, i)));
                                //頭のアルファを取る
                                s.delete(0, 2);

                                //H、色相に分離
                                celColorH = rgb(s.toString(), 1);
                                System.out.println("色相値は、" + celColorH);
                                //肌色判定HSB版色相だけを判断材料に使う
                                if(celColorH > 25 && celColorH < 76){
                                System.out.println("該&#24403;のデ&#12540;タが見つかりました");
                                mapImage.set(j, i, 255);

                        }*/




                                /*
                                //入手したピクセルをRGBに3分割する

                                //R、赤に分離
                                celColorR = rgb(s.toString(), 1);
                                //G、緑に分解
                                celColorG = rgb(s.toString(), 2);
                                //B、青に分解
                                celColorB = rgb(s.toString(), 3);
                                //肌色判定RGB版
                                if(celColorR < skinColor[0] && celColorR > skinColor[3] && celColorG < skinColor[1] && celColorG > skinColor[4] && celColorB < skinColor[2] && celColorB > skinColor[4]){
                                mapImage.set(j, i, 255);
                                //rect(j, i, 5, 5);
                        }*/
                        }
                }
        }

        public void draw(){

                //背景画像指定
                image(mapImage, 0, 0);


                //HSB表示のテスト
                //fill(25, 96, 237);
                //rect(width / 2 - 10, height / 2 - 10, 20, 20);

        }

        //RGBを分解するメソッド
        public int rgb(String rgb, int num){
                int rgbNum = 0;
                StringBuffer s = new StringBuffer(rgb);

                switch(num){
                        case 1:
                        //赤の処理
                        s.delete(2, 6);
                        break;
                        case 2:
                        //緑の処理
                        s.delete(0, 2);
                        s.delete(2, 4);
                        break;
                        case 3:
                        //青の処理
                        s.delete(0, 4);
                        break;
                }

                //16進数を10進数に変換する
                rgbNum = Integer.decode("0x" + s.toString()).intValue();
                return rgbNum;
        }






        //HSBを分解するメソッド
        public int hsb(String hsb, int num){
                int hsbNum = 0;
                StringBuffer s = new StringBuffer(hsb);

                switch(num){
                        case 1:
                        //色相の処理
                        break;
                        case 2:
                        //彩度の処理
                        break;
                        case 3:
                        //明るさの処理
                        break;
                }

                return hsbNum;
        }

}



《実験結果》

Fc001_2

Fc002_2

Fc003_2


ご覧の通り、全体的に暗くなったりすると前もって指定した肌色の定数に引っかからない。
これじゃだめだね。


統計的パターン認識入門統計的パターン認識入門
価格 : ¥2,940 (税込み)

本書は、統計的パターン認識の識別系と特徴抽出系の理論とその基本的考え方を丁寧に解説した入門書である。また、より実用的な観点から具体的な図表や計算機演習を用意して理解が深まるように工夫したテキストでもある。

| | コメント (0) | トラックバック (0)

2010.07.10

今日の畑
ジャガイモ掘りとネギの植え替え

先週は週末にキャンプに行ったので畑はお休みでした。そのせいか葉がのび放題で荒れてしまいましたので、朝早くから風通し、日当りを考慮してヒマワリ、コスモス、カボチャの葉などを取り除きました。

狭い畑なのに多数の野菜を育てるから非常に苦労しますね。

その後、ジャガイモを掘ったのですが、ずっと雨続きだったので土が重くて参りました。
本屋さんで見かける家庭菜園の本は、さわやかでオシャレだけど実際は汗に泥にまみれることがあります。長靴はお気に入りのエーグルを使っていますが、上着などは絶対ホームセンターとかの500円ぐらいのシャツです。この時期はもう水をかぶったようになりますから、

初めてジャガイモを栽培したのでノウハウがないのですが、出来は上々のような気がします。大きさも重さもあり、数もそこそこありましたし、気になっていた虫食いも被害がなく安心しました。要因は冬場の土作りであると考えています。その証拠にジャガイモの根の下に白い菌糸が長く深く伸びていました。詳しくはわかりませんが、何らかの共生関係が出来上がっているように思えます。

ジャガイモを掘り出した後はその畝にネギを植え替えました。サツマイモの横に植えてあったので、サツマイモが生長するにしたがって、日当りが悪くなったからです。
この暑い季節に根を痛めるのはリスキーな気がするのですが下仁田ねぎは7月に植え替えをするということで、思い切って植え替えました。

ミニカボチャの栗坊ですがつるや、葉はミニじゃないんですね、==;
肥料のやってないのに家の畑を浸食しています。
つるをのばし根を張って、日光をすべて奪ってしまうので地際の野菜、花、が腐ってしまいました。恐るべし能力。
サカタのたねのパンフレットには実が5、6個なると書いてあったけど10個以上あります。生育旺盛だなぁ;

_0015549

_0015550

_0015551

_0015547

_0015548

_0015552

_0015553

_0015554

_0015555

_0015556

_0015557

_0015558

_0015559

_0015560

_0015561




アンティーク調ブリキ缶アンティーク調ブリキ缶 ハンドルティン3点セット
価格 : ¥1,522 (税込み)

味わい深いアンティーク風のブリキポットは植物を一層引き立てます。 ハイセンスなガーデンデザインには、お洒落な小物が絶対に必要ですよね! 室内のインテリアとして、小物入れとして使用してもおしゃれです!

| | コメント (0) | トラックバック (0)

« 2010年6月 | トップページ | 2010年8月 »