« 顔認識プログラム 2 | トップページ | グレースケール映像フィルタ
processing java »

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 (税込み)

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

|

« 顔認識プログラム 2 | トップページ | グレースケール映像フィルタ
processing java »

processing」カテゴリの記事

コメント

コメントを書く



(ウェブ上には掲載しません)




トラックバック

この記事のトラックバックURL:
http://app.cocolog-nifty.com/t/trackback/198455/48877164

この記事へのトラックバック一覧です: 顔認識プログラム 3:

« 顔認識プログラム 2 | トップページ | グレースケール映像フィルタ
processing java »