/**
		 * @Override
		 */
		protected override void onLabelFound(NyARRleLabelFragmentInfo iRefLabel)
		{
			//widthとheightの計算
			int w=iRefLabel.clip_r-iRefLabel.clip_l;
			int h=iRefLabel.clip_b-iRefLabel.clip_t;
			//1*1(1bitPixelの5*5)以下の場合は、検出不能
			//未実装部分:2*2(1bitPixelの8*8)以下の場合は、解像度1で再検出
			//未実装部分:3*3,4*4(1bitPixelの12*12,16*16)以下の場合は、解像度2で再検出
			if(w<10 || h<10){
				//今のところは再検出機構なし。
				return;
			}
			LowResolutionLabelingSamplerOut.Item item=current_output.prePush();
			if(item==null){
				return;
			}
			int pix=this._pix;
			item.entry_pos.x=iRefLabel.entry_x;
			item.entry_pos.y=iRefLabel.clip_t;
			item.base_area.x=iRefLabel.clip_l*pix;
			item.base_area.y=iRefLabel.clip_t*pix;
			item.base_area.w=w*pix;
			item.base_area.h=h*pix;
			item.base_area_center.x=item.base_area.x+item.base_area.w/2;
			item.base_area_center.y=item.base_area.y+item.base_area.h/2;
			item.base_area_sq_diagonal=(w*w+h*h)*(pix*pix);
			item.lebeling_th=this.current_th;
		}
        /**
         * @override
         */
        public override void detectMarker(NyARBinRaster i_raster)
        {
            NyARRleLabelFragmentInfoPtrStack flagment = this._labeling.label_stack;
            NyARLabelOverlapChecker <NyARRleLabelFragmentInfo> overlap = this._overlap_checker;

            // ラベル数が0ならここまで
            flagment.clear();
            this._labeling.labeling(i_raster);
            int label_num = flagment.getLength();

            if (label_num < 1)
            {
                return;
            }
            //ラベルをソートしておく
            flagment.sortByArea();
            //ラベルリストを取得
            NyARRleLabelFragmentInfo[] labels = flagment.getArray();

            NyARIntCoordinates coord = this._coord;

            int[] mkvertex = this.__detectMarker_mkvertex;


            //重なりチェッカの最大数を設定
            overlap.setMaxLabels(label_num);

            for (int i = 0; i < label_num; i++)
            {
                NyARRleLabelFragmentInfo label_pt = labels[i];
                int label_area = label_pt.area;

                // 既に検出された矩形との重なりを確認
                if (!overlap.check(label_pt))
                {
                    // 重なっているようだ。
                    continue;
                }

                //輪郭を取得
                if (!this._cpickup.getContour(i_raster, label_pt.entry_x, label_pt.clip_t, coord))
                {
                    continue;
                }
                //輪郭線をチェックして、矩形かどうかを判定。矩形ならばmkvertexに取得
                if (!this._coord2vertex.getVertexIndexes(coord, label_area, mkvertex))
                {
                    // 頂点の取得が出来なかった
                    continue;
                }
                //矩形を発見したことをコールバック関数で通知
                this.onSquareDetect(coord, mkvertex);

                // 検出済の矩形の属したラベルを重なりチェックに追加する。
                overlap.push(label_pt);
            }
            return;
        }
 protected override void onLabelFound(NyARRleLabelFragmentInfo i_label)
 {
     // クリップ領域が画面の枠に接していれば除外
     if (i_label.clip_l == 0 || i_label.clip_r == this._right)
     {
         return;
     }
     if (i_label.clip_t == 0 || i_label.clip_b == this._bottom)
     {
         return;
     }
     this.label_stack.push(i_label);
 }
 protected override void onLabelFound(NyARRleLabelFragmentInfo i_label)
 {
     // クリップ領域が画面の枠に接していれば除外
     if (i_label.clip_l == 0 || i_label.clip_r == this._right)
     {
         return;
     }
     if (i_label.clip_t == 0 || i_label.clip_b == this._bottom)
     {
         return;
     }
     this.label_stack.push(i_label);
 }
예제 #5
0
        private bool addFragment(RleElement i_rel_img, int i_nof, int i_row_index, RleInfoStack o_stack)
        {
            int l   = i_rel_img.l;
            int len = i_rel_img.r - l;

            i_rel_img.fid = i_nof;// REL毎の固有ID
            NyARRleLabelFragmentInfo v = o_stack.prePush();

            if (v == null)
            {
                return(false);
            }
            v.entry_x = l;
            v.area    = len;
            v.clip_l  = l;
            v.clip_r  = i_rel_img.r - 1;
            v.clip_t  = i_row_index;
            v.clip_b  = i_row_index;
            v.pos_x   = (len * (2 * l + (len - 1))) / 2;
            v.pos_y   = i_row_index * len;

            return(true);
        }
        /**
         * この関数は、ラスタから矩形を検出して、自己コールバック関数{@link #onSquareDetect}で通知します。
         * @param i_raster
         * 検出元のラスタ画像
         * 入力できるラスタの画素形式は、{@link NyARLabeling_Rle#labeling(INyARRaster, int)}と同じです。
         * @param i_area
         * 検出する範囲。検出元のラスタの内側である必要があります。
         * @param i_th
         * ラベルと判定する敷居値
         * @
         */
        public void detectMarker(INyARGrayscaleRaster i_raster, NyARIntRect i_area, int i_th, NyARSquareContourDetector.CbHandler i_cb)
        {
            Debug.Assert(i_area.w * i_area.h > 0);

            NyARRleLabelFragmentInfoPtrStack flagment = this._labeling.label_stack;
            NyARLabelOverlapChecker <NyARRleLabelFragmentInfo> overlap = this._overlap_checker;

            //ラベルの生成エラーならここまで
            if (!this._labeling.labeling(i_raster, i_area, i_th))
            {
                return;
            }
            // ラベル数が0ならここまで
            int label_num = flagment.getLength();

            if (label_num < 1)
            {
                return;
            }

            //ラベルリストを取得
            NyARRleLabelFragmentInfo[] labels = flagment.getArray();

            NyARIntCoordinates coord = this._coord;

            int[] mkvertex = this.__detectMarker_mkvertex;


            //重なりチェッカの最大数を設定
            overlap.setMaxLabels(label_num);

            for (int i = 0; i < label_num; i++)
            {
                NyARRleLabelFragmentInfo label_pt = labels[i];
                // 既に検出された矩形との重なりを確認
                if (!overlap.check(label_pt))
                {
                    // 重なっているようだ。
                    continue;
                }

                //輪郭を取得
                if (!this._cpickup.getContour(i_raster, i_area, i_th, label_pt.entry_x, label_pt.clip_t, coord))
                {
                    continue;
                }
                int label_area = label_pt.area;
                //輪郭線をチェックして、矩形かどうかを判定。矩形ならばmkvertexに取得
                if (!this._coord2vertex.getVertexIndexes(coord, label_area, mkvertex))
                {
                    // 頂点の取得が出来なかった
                    continue;
                }
                //矩形を発見したことをコールバック関数で通知
                i_cb.detectMarkerCallback(coord, mkvertex);

                // 検出済の矩形の属したラベルを重なりチェックに追加する。
                overlap.push(label_pt);
            }
            return;
        }
예제 #7
0
 /**
  * ハンドラ関数です。継承先クラスでオーバライドしてください。
  * i_labelのインスタンスは、次のラべリング実行まで保証されていますが、将来にわたり保証されないかもしれません。(恐らく保証されますが)
  * コールバック関数から参照を使用する場合は、互換性を確認するために、念のため、assertで_af_label_array_safe_referenceフラグをチェックしてください。
  * @param i_label
  */
 protected abstract void onLabelFound(NyARRleLabelFragmentInfo i_ref_label);
예제 #8
0
        private void imple_labeling(INyARRaster i_raster, int i_th, int i_left, int i_top, int i_width, int i_height)
        {
            //ラスタのサイズを確認
            Debug.Assert(i_raster.getSize().isEqualSize(this._raster_size));

            RleElement[] rle_prev    = this._rle1;
            RleElement[] rle_current = this._rle2;
            // リセット処理
            RleInfoStack rlestack = this._rlestack;

            rlestack.clear();

            //
            int len_prev    = 0;
            int len_current = 0;
            int bottom      = i_top + i_height;
            int row_stride  = this._raster_size.w;

            int[] in_buf = (int[])i_raster.getBuffer();

            int id_max        = 0;
            int label_count   = 0;
            int rle_top_index = i_left + row_stride * i_top;

            // 初段登録

            len_prev = toRel(in_buf, rle_top_index, i_width, rle_prev, i_th);
            for (int i = 0; i < len_prev; i++)
            {
                // フラグメントID=フラグメント初期値、POS=Y値、RELインデクス=行
                if (addFragment(rle_prev[i], id_max, i_top, rlestack))
                {
                    id_max++;
                    // nofの最大値チェック
                    label_count++;
                }
            }
            NyARRleLabelFragmentInfo[] f_array = rlestack.getArray();
            // 次段結合
            for (int y = i_top + 1; y < bottom; y++)
            {
                // カレント行の読込
                rle_top_index += row_stride;
                len_current    = toRel(in_buf, rle_top_index, i_width, rle_current, i_th);
                int index_prev = 0;

                for (int i = 0; i < len_current; i++)
                {
                    // index_prev,len_prevの位置を調整する
                    int id = -1;
                    // チェックすべきprevがあれば確認
                    while (index_prev < len_prev)
                    {
                        if (rle_current[i].l - rle_prev[index_prev].r > 0)                      // 0なら8方位ラベリング
                        // prevがcurの左方にある→次のフラグメントを探索
                        {
                            index_prev++;
                            continue;
                        }
                        else if (rle_prev[index_prev].l - rle_current[i].r > 0)                        // 0なら8方位ラベリングになる
                        // prevがcur右方にある→独立フラグメント
                        {
                            if (addFragment(rle_current[i], id_max, y, rlestack))
                            {
                                id_max++;
                                label_count++;
                            }
                            // 次のindexをしらべる
                            goto SCAN_CUR;
                        }
                        id = rle_prev[index_prev].fid;                  //ルートフラグメントid
                        NyARRleLabelFragmentInfo id_ptr = f_array[id];
                        //結合対象(初回)->prevのIDをコピーして、ルートフラグメントの情報を更新
                        rle_current[i].fid = id;                    //フラグメントIDを保存
                        //
                        int l   = rle_current[i].l;
                        int r   = rle_current[i].r;
                        int len = r - l;
                        //結合先フラグメントの情報を更新する。
                        id_ptr.area += len;
                        //tとentry_xは、結合先のを使うので更新しない。
                        id_ptr.clip_l = l < id_ptr.clip_l?l:id_ptr.clip_l;
                        id_ptr.clip_r = r > id_ptr.clip_r?r - 1:id_ptr.clip_r;
                        id_ptr.clip_b = y;
                        id_ptr.pos_x += (len * (2 * l + (len - 1))) / 2;
                        id_ptr.pos_y += y * len;
                        //多重結合の確認(2個目以降)
                        index_prev++;
                        while (index_prev < len_prev)
                        {
                            if (rle_current[i].l - rle_prev[index_prev].r > 0)                          // 0なら8方位ラベリング
                            // prevがcurの左方にある→prevはcurに連結していない。
                            {
                                goto SCAN_PREV;
                            }
                            else if (rle_prev[index_prev].l - rle_current[i].r > 0)                            // 0なら8方位ラベリングになる
                            // prevがcurの右方にある→prevはcurに連結していない。
                            {
                                index_prev--;
                                goto SCAN_CUR;
                            }
                            // prevとcurは連結している→ルートフラグメントの統合

                            //結合するルートフラグメントを取得
                            int prev_id = rle_prev[index_prev].fid;
                            NyARRleLabelFragmentInfo prev_ptr = f_array[prev_id];
                            if (id != prev_id)
                            {
                                label_count--;
                                //prevとcurrentのフラグメントidを書き換える。
                                for (int i2 = index_prev; i2 < len_prev; i2++)
                                {
                                    //prevは現在のidから最後まで
                                    if (rle_prev[i2].fid == prev_id)
                                    {
                                        rle_prev[i2].fid = id;
                                    }
                                }
                                for (int i2 = 0; i2 < i; i2++)
                                {
                                    //currentは0から現在-1まで
                                    if (rle_current[i2].fid == prev_id)
                                    {
                                        rle_current[i2].fid = id;
                                    }
                                }

                                //現在のルートフラグメントに情報を集約
                                id_ptr.area  += prev_ptr.area;
                                id_ptr.pos_x += prev_ptr.pos_x;
                                id_ptr.pos_y += prev_ptr.pos_y;
                                //tとentry_xの決定
                                if (id_ptr.clip_t > prev_ptr.clip_t)
                                {
                                    // 現在の方が下にある。
                                    id_ptr.clip_t  = prev_ptr.clip_t;
                                    id_ptr.entry_x = prev_ptr.entry_x;
                                }
                                else if (id_ptr.clip_t < prev_ptr.clip_t)
                                {
                                    // 現在の方が上にある。prevにフィードバック
                                }
                                else
                                {
                                    // 水平方向で小さい方がエントリポイント。
                                    if (id_ptr.entry_x > prev_ptr.entry_x)
                                    {
                                        id_ptr.entry_x = prev_ptr.entry_x;
                                    }
                                    else
                                    {
                                    }
                                }
                                //lの決定
                                if (id_ptr.clip_l > prev_ptr.clip_l)
                                {
                                    id_ptr.clip_l = prev_ptr.clip_l;
                                }
                                else
                                {
                                }
                                //rの決定
                                if (id_ptr.clip_r < prev_ptr.clip_r)
                                {
                                    id_ptr.clip_r = prev_ptr.clip_r;
                                }
                                else
                                {
                                }
                                //bの決定

                                //結合済のルートフラグメントを無効化する。
                                prev_ptr.area = 0;
                            }


                            index_prev++;
                        }
                        index_prev--;
                        break;
                        SCAN_PREV :;
                    }
                    // curにidが割り当てられたかを確認
                    // 右端独立フラグメントを追加
                    if (id < 0)
                    {
                        if (addFragment(rle_current[i], id_max, y, rlestack))
                        {
                            id_max++;
                            label_count++;
                        }
                    }
                    SCAN_CUR :;
                }
                // prevとrelの交換
                RleElement[] tmp = rle_prev;
                rle_prev    = rle_current;
                len_prev    = len_current;
                rle_current = tmp;
            }
            //対象のラベルだけを追記
            int max = this._max_area;
            int min = this._min_area;

            for (int i = id_max - 1; i >= 0; i--)
            {
                NyARRleLabelFragmentInfo src_info = f_array[i];
                int area = src_info.area;
                if (area < min || area > max)        //対象外のエリア0のもminではじく
                {
                    continue;
                }
                //値を相対位置に補正
                src_info.clip_l  += i_left;
                src_info.clip_r  += i_left;
                src_info.entry_x += i_left;
                src_info.pos_x   /= area;
                src_info.pos_y   /= area;
                //コールバック関数コール
                this.onLabelFound(src_info);
            }
        }