lib/src.rpf/jp/nyatla/nyartoolkit/rpf/tracker/nyartk/NyARVectorReader_INT1D_GRAY_8.java

   1 /* \r
   2  * PROJECT: NyARToolkit(Extension)\r
   3  * --------------------------------------------------------------------------------\r
   4  * The NyARToolkit is Java edition ARToolKit class library.\r
   5  * Copyright (C)2008-2009 Ryo Iizuka\r
   6  *\r
   7  * This program is free software: you can redistribute it and/or modify\r
   8  * it under the terms of the GNU General Public License as published by\r
   9  * the Free Software Foundation, either version 3 of the License, or\r
  10  * (at your option) any later version.\r
  11  * \r
  12  * This program is distributed in the hope that it will be useful,\r
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  15  * GNU General Public License for more details.\r
  16  *\r
  17  * You should have received a copy of the GNU General Public License\r
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.\r
  19  * \r
  20  * For further information please contact.\r
  21  *      http://nyatla.jp/nyatoolkit/\r
  22  *      <airmail(at)ebony.plala.or.jp> or <nyatla(at)nyatla.jp>\r
  23  * \r
  24  */\r
  25 package jp.nyatla.nyartoolkit.rpf.tracker.nyartk;\r
  26 \r
  27 import jp.nyatla.nyartoolkit.core.param.NyARCameraDistortionFactor;\r
  28 import jp.nyatla.nyartoolkit.core.raster.NyARGrayscaleRaster;\r
  29 import jp.nyatla.nyartoolkit.core.squaredetect.NyARContourPickup;\r
  30 import jp.nyatla.nyartoolkit.core.types.*;\r
  31 \r
  32 \r
  33 /**\r
  34  * このクラスは、{@link NyARBufferType#INT1D_GRAY_8}の画素形式に対応した画素ベクトルリーダーです。\r
  35  */\r
  36 public class NyARVectorReader_INT1D_GRAY_8 extends NyARVectorReader_Base\r
  37 {\r
  38         /**\r
  39          * コンストラクタです。\r
  40          * 基本GS画像、ヒント画像のセットから、インスタンスを作ります。\r
  41          * @param i_ref_raster\r
  42          * 基本GS画像の参照値\r
  43          * @param i_ref_raster_distortion\r
  44          * 基本画像の歪み補正オブジェクトの参照値\r
  45          * @param i_ref_rob_raster\r
  46          * ヒント画像の参照値\r
  47          */\r
  48         public NyARVectorReader_INT1D_GRAY_8(NyARGrayscaleRaster i_ref_raster,NyARCameraDistortionFactor i_ref_raster_distortion,NyARGrayscaleRaster i_ref_rob_raster)\r
  49         {\r
  50                 super();\r
  51                 assert (i_ref_raster.getBufferType() == NyARBufferType.INT1D_GRAY_8);\r
  52                 assert (i_ref_rob_raster.getBufferType() == NyARBufferType.INT1D_GRAY_8);\r
  53                 this.initInstance(i_ref_raster, i_ref_raster_distortion, i_ref_rob_raster,new NyARContourPickup());\r
  54         }\r
  55 \r
  56 \r
  57 //      /**\r
  58 //       * 画素の4近傍の画素ベクトルを取得します。 取得可能な範囲は、Rasterの1ドット内側です。 0 ,-1, 0 0, 0, 0 0 , x,\r
  59 //       * 0　+ -1, y,+1 0 ,+1, 0 0, 0, 0\r
  60 //       * \r
  61 //       * @param i_raster\r
  62 //       * @param x\r
  63 //       * @param y\r
  64 //       * @param o_v\r
  65 //       */\r
  66 //      public void getPixelVector4(int x, int y, NyARIntPoint2d o_v)\r
  67 //      {\r
  68 //              assert ((x > 0) && (y > 0) && (x) < this._ref_base_raster.getWidth() && (y) < this._ref_base_raster.getHeight());\r
  69 //              int[] buf = (int[])(this._ref_base_raster.getBuffer());\r
  70 //              int w = this._ref_base_raster.getWidth();\r
  71 //              int idx = w * y + x;\r
  72 //              o_v.x = (buf[idx + 1] - buf[idx - 1]) >> 1;\r
  73 //              o_v.y = (buf[idx + w] - buf[idx - w]) >> 1;\r
  74 //              //歪み補正どうすんの\r
  75 //      }\r
  76 //\r
  77 //      /**\r
  78 //       * 画素の8近傍画素ベクトルを取得します。 取得可能な範囲は、Rasterの1ドット内側です。\r
  79 //       *  -1,-2,-1　　　　-1,　0,+1\r
  80 //       *   0, y,　0 +　　-2, x,+2\r
  81 //       *  +1,+2,+1 　　　　-1, 0,+1\r
  82 //       * \r
  83 //       * @param i_raster\r
  84 //       * @param x\r
  85 //       * @param y\r
  86 //       * @param o_v\r
  87 //       */\r
  88 //      public void getPixelVector8(int x, int y, NyARIntPoint2d o_v) {\r
  89 //              assert ((x > 0) && (y > 0) && (x) < this._ref_base_raster.getWidth() && (y) < this._ref_base_raster.getHeight());\r
  90 //              int[] buf = (int[])this._ref_base_raster.getBuffer();\r
  91 //              int sw = this._ref_base_raster.getWidth();\r
  92 //              int idx_0 = sw * y + x;\r
  93 //              int idx_p1 = idx_0 + sw;\r
  94 //              int idx_m1 = idx_0 - sw;\r
  95 //              int b = buf[idx_m1 - 1];\r
  96 //              int d = buf[idx_m1 + 1];\r
  97 //              int h = buf[idx_p1 - 1];\r
  98 //              int f = buf[idx_p1 + 1];\r
  99 //              o_v.x = ((buf[idx_0 + 1] - buf[idx_0 - 1]) >> 1)\r
 100 //                              + ((d - b + f - h) >> 2);\r
 101 //              o_v.y = ((buf[idx_p1] - buf[idx_m1]) >> 1) + ((f - d + h - b) >> 2);\r
 102 //              //歪み補正どうするの？\r
 103 //      }\r
 104 \r
 105         /**\r
 106          * この関数は、元画像の矩形領域を集計して、その領域内のエッジ中心と、エッジの方位ベクトルを返します。 画素の集計には、3x3のカーネルを使います。 矩形領域は、例えば取得元の画像が320*240の場合、(x>=0 && x<=320 x+w>=0 && x+w<=320),(y>=0 && y<=240 y+h>=0 && y+h<=240)です。 \r
 107          */\r
 108         public final int getAreaVector33(int ix, int iy, int iw, int ih,NyARVecLinear2d o_posvec)\r
 109         {\r
 110                 assert (ih >= 3 && iw >= 3);\r
 111                 assert ((ix >= 0) && (iy >= 0) && (ix + iw) <= this._ref_base_raster.getWidth() && (iy + ih) <= this._ref_base_raster.getHeight());\r
 112                 int[] buf =(int[])this._ref_base_raster.getBuffer();\r
 113                 int stride =this._ref_base_raster.getWidth();\r
 114                 // x=(Σ|Vx|*Xn)/n,y=(Σ|Vy|*Yn)/n\r
 115                 // x=(ΣVx)^2/(ΣVx+ΣVy)^2,y=(ΣVy)^2/(ΣVx+ΣVy)^2\r
 116                 int sum_x, sum_y, sum_wx, sum_wy, sum_vx, sum_vy;\r
 117                 sum_x = sum_y = sum_wx = sum_wy = sum_vx = sum_vy = 0;\r
 118                 int lw=iw - 3;\r
 119                 int vx, vy;\r
 120                 for (int i = ih - 3; i >= 0; i--) {\r
 121                         int idx_0 = stride * (i + 1 + iy) + (iw - 3 + 1 + ix);\r
 122                         for (int i2 = lw; i2 >= 0; i2--){\r
 123                                 // 1ビット分のベクトルを計算\r
 124                                 int idx_p1 = idx_0 + stride;\r
 125                                 int idx_m1 = idx_0 - stride;\r
 126                                 int b = buf[idx_m1 - 1];\r
 127                                 int d = buf[idx_m1 + 1];\r
 128                                 int h = buf[idx_p1 - 1];\r
 129                                 int f = buf[idx_p1 + 1];\r
 130                                 vx = ((buf[idx_0 + 1] - buf[idx_0 - 1]) >> 1)+ ((d - b + f - h) >> 2);\r
 131                                 vy = ((buf[idx_p1] - buf[idx_m1]) >> 1)+ ((f - d + h - b) >> 2);\r
 132                                 idx_0--;\r
 133 \r
 134                                 // 加重はvectorの絶対値\r
 135                                 int wx = vx * vx;\r
 136                                 int wy = vy * vy;\r
 137                                 sum_wx += wx; //加重値\r
 138                                 sum_wy += wy; //加重値\r
 139                                 sum_vx += wx * vx; //加重*ベクトルの積\r
 140                                 sum_vy += wy * vy; //加重*ベクトルの積\r
 141                                 sum_x += wx * (i2 + 1);//位置\r
 142                                 sum_y += wy * (i + 1); //\r
 143                         }\r
 144                 }\r
 145                 //x,dx,y,dyの計算\r
 146                 double xx,yy;\r
 147                 if (sum_wx == 0) {\r
 148                         xx = ix + (iw >> 1);\r
 149                         o_posvec.dx = 0;\r
 150                 } else {\r
 151                         xx = ix+(double) sum_x / sum_wx;\r
 152                         o_posvec.dx = (double) sum_vx / sum_wx;\r
 153                 }\r
 154                 if (sum_wy == 0) {\r
 155                         yy = iy + (ih >> 1);\r
 156                         o_posvec.dy = 0;\r
 157                 } else {\r
 158                         yy = iy+(double) sum_y / sum_wy;\r
 159                         o_posvec.dy = (double) sum_vy / sum_wy;\r
 160                 }\r
 161                 //必要なら歪みを解除\r
 162                 if(this._factor!=null){\r
 163                         this._factor.observ2Ideal(xx, yy, o_posvec);\r
 164                 }else{\r
 165                         o_posvec.x=xx;\r
 166                         o_posvec.y=yy;\r
 167                 }\r
 168                 //加重平均の分母を返却\r
 169                 return sum_wx+sum_wy;\r
 170         }\r
 171         /**\r
 172          * この関数は、元画像の矩形領域を集計して、その領域内のエッジ中心と、エッジの方位ベクトルを返します。 画素の集計には、2x2のカーネルを使います。 矩形領域は、例えば取得元の画像が320*240の場合、(x>=0 && x<=320 x+w>=0 && x+w<=320),(y>=0 && y<=240 y+h>=0 && y+h<=240)です。 \r
 173          */     \r
 174         public final int getAreaVector22(int ix, int iy, int iw, int ih,NyARVecLinear2d o_posvec)\r
 175         {\r
 176                 assert (ih >= 3 && iw >= 3);\r
 177                 assert ((ix >= 0) && (iy >= 0) && (ix + iw) <= this._ref_base_raster.getWidth() && (iy + ih) <= this._ref_base_raster.getHeight());\r
 178                 int[] buf =(int[])this._ref_base_raster.getBuffer();\r
 179                 int stride =this._ref_base_raster.getWidth();\r
 180                 int sum_x, sum_y, sum_wx, sum_wy, sum_vx, sum_vy;\r
 181                 sum_x = sum_y = sum_wx = sum_wy = sum_vx = sum_vy = 0;\r
 182                 int vx, vy;\r
 183                 int ll=iw-1;\r
 184                 for (int i = 0; i<ih-1; i++) {\r
 185                         int idx_0 = stride * (i+iy) + ix+1;\r
 186                         int a=buf[idx_0-1];\r
 187                         int b=buf[idx_0];\r
 188                         int c=buf[idx_0+stride-1];\r
 189                         int d=buf[idx_0+stride];\r
 190                         for (int i2 = 0; i2<ll; i2++){\r
 191                                 // 1ビット分のベクトルを計算\r
 192                                 vx=(b-a+d-c)>>2;\r
 193                                 vy=(c-a+d-b)>>2;\r
 194                                 idx_0++;\r
 195                                 a=b;\r
 196                                 c=d;\r
 197                                 b=buf[idx_0];\r
 198                                 d=buf[idx_0+stride];\r
 199 \r
 200                                 // 加重はvectorの絶対値\r
 201                                 int wx = vx * vx;\r
 202                                 sum_wx += wx; //加重値\r
 203                                 sum_vx += wx * vx; //加重*ベクトルの積\r
 204                                 sum_x += wx * i2;//位置\r
 205 \r
 206                                 int wy = vy * vy;\r
 207                                 sum_wy += wy; //加重値\r
 208                                 sum_vy += wy * vy; //加重*ベクトルの積\r
 209                                 sum_y += wy * i; //\r
 210                         }\r
 211                 }\r
 212                 //x,dx,y,dyの計算\r
 213                 double xx,yy;\r
 214                 if (sum_wx == 0) {\r
 215                         xx = ix + (iw >> 1);\r
 216                         o_posvec.dx = 0;\r
 217                 } else {\r
 218                         xx = ix+(double) sum_x / sum_wx;\r
 219                         o_posvec.dx = (double) sum_vx / sum_wx;\r
 220                 }\r
 221                 if (sum_wy == 0) {\r
 222                         yy = iy + (ih >> 1);\r
 223                         o_posvec.dy = 0;\r
 224                 } else {\r
 225                         yy = iy+(double) sum_y / sum_wy;\r
 226                         o_posvec.dy = (double) sum_vy / sum_wy;\r
 227                 }\r
 228                 //必要なら歪みを解除\r
 229                 if(this._factor!=null){\r
 230                         this._factor.observ2Ideal(xx, yy, o_posvec);\r
 231                 }else{\r
 232                         o_posvec.x=xx;\r
 233                         o_posvec.y=yy;\r
 234                 }\r
 235                 //加重平均の分母を返却\r
 236                 return sum_wx+sum_wy;\r
 237         }\r
 238 }