trunk/src/jp/nyatla/nyartoolkit/core/analyzer/raster/NyARRasterAnalyzer_Histogram.java

   1 package jp.nyatla.nyartoolkit.core.analyzer.raster;\r
   2 \r
   3 import jp.nyatla.nyartoolkit.NyARException;\r
   4 import jp.nyatla.nyartoolkit.core.raster.*;\r
   5 import jp.nyatla.nyartoolkit.core.types.NyARHistogram;\r
   6 import jp.nyatla.nyartoolkit.core.types.NyARIntSize;\r
   7 /**\r
   8  * 画像のヒストグラムを計算します。\r
   9  * RGBの場合、(R+G+B)/3のヒストグラムを計算します。\r
  10  * \r
  11  * \r
  12  */\r
  13 public class NyARRasterAnalyzer_Histogram\r
  14 {\r
  15         protected ICreateHistogramImpl _histImpl;\r
  16         /**\r
  17          * ヒストグラム解析の縦方向スキップ数。継承クラスはこのライン数づつ\r
  18          * スキップしながらヒストグラム計算を行うこと。\r
  19          */\r
  20         protected int _vertical_skip;\r
  21         \r
  22         \r
  23         public NyARRasterAnalyzer_Histogram(int i_raster_format,int i_vertical_interval) throws NyARException\r
  24         {\r
  25                 if(!initInstance(i_raster_format,i_vertical_interval)){\r
  26                         throw new NyARException();\r
  27                 }\r
  28         }\r
  29         protected boolean initInstance(int i_raster_format,int i_vertical_interval)\r
  30         {\r
  31                 switch (i_raster_format) {\r
  32                 case INyARRaster.BUFFERFORMAT_BYTE1D_B8G8R8_24:\r
  33                 case INyARRaster.BUFFERFORMAT_BYTE1D_R8G8B8_24:\r
  34                         this._histImpl = new NyARRasterThresholdAnalyzer_Histogram_BYTE1D_RGB_24();\r
  35                         break;\r
  36                 case INyARRaster.BUFFERFORMAT_INT1D_GRAY_8:\r
  37                         this._histImpl = new NyARRasterThresholdAnalyzer_Histogram_INT1D_GRAY_8();\r
  38                         break;\r
  39                 case INyARRaster.BUFFERFORMAT_BYTE1D_B8G8R8X8_32:\r
  40                         this._histImpl = new NyARRasterThresholdAnalyzer_Histogram_BYTE1D_B8G8R8X8_32();\r
  41                         break;\r
  42                 case INyARRaster.BUFFERFORMAT_BYTE1D_X8R8G8B8_32:\r
  43                         this._histImpl = new NyARRasterThresholdAnalyzer_Histogram_BYTE1D_X8R8G8B8_32();\r
  44                         break;\r
  45                 case INyARRaster.BUFFERFORMAT_WORD1D_R5G6B5_16LE:\r
  46                         this._histImpl = new NyARRasterThresholdAnalyzer_Histogram_WORD1D_R5G6B5_16LE();\r
  47                         break;\r
  48                 case INyARRaster.BUFFERFORMAT_INT1D_X8R8G8B8_32:\r
  49                         this._histImpl = new NyARRasterThresholdAnalyzer_Histogram_INT1D_X8R8G8B8_32();\r
  50                         break;\r
  51                 default:\r
  52                         return false;\r
  53                 }\r
  54                 //初期化\r
  55                 this._vertical_skip=i_vertical_interval;\r
  56                 return true;\r
  57         }       \r
  58         \r
  59         \r
  60         public void setVerticalInterval(int i_step)\r
  61         {\r
  62                 this._vertical_skip=i_step;\r
  63                 return;\r
  64         }\r
  65 \r
  66         /**\r
  67          * o_histogramにヒストグラムを出力します。\r
  68          * @param i_input\r
  69          * @param o_histogram\r
  70          * @return\r
  71          * @throws NyARException\r
  72          */\r
  73         public int analyzeRaster(INyARRaster i_input,NyARHistogram o_histogram) throws NyARException\r
  74         {\r
  75                 \r
  76                 final NyARIntSize size=i_input.getSize();\r
  77                 //最大画像サイズの制限\r
  78                 assert size.w*size.h<0x40000000;\r
  79                 assert o_histogram.length==256;//現在は固定\r
  80 \r
  81                 int[] h=o_histogram.data;\r
  82                 //ヒストグラム初期化\r
  83                 for (int i = o_histogram.length-1; i >=0; i--){\r
  84                         h[i] = 0;\r
  85                 }\r
  86                 o_histogram.total_of_data=size.w*size.h/this._vertical_skip;\r
  87                 return this._histImpl.createHistogram(i_input, size,h,this._vertical_skip);             \r
  88         }\r
  89         \r
  90         interface ICreateHistogramImpl\r
  91         {\r
  92                 public int createHistogram(INyARRaster i_reader,NyARIntSize i_size, int[] o_histogram,int i_skip);\r
  93         }\r
  94 \r
  95         class NyARRasterThresholdAnalyzer_Histogram_INT1D_GRAY_8 implements ICreateHistogramImpl\r
  96         {\r
  97                 public int createHistogram(INyARRaster i_reader,NyARIntSize i_size, int[] o_histogram,int i_skip)\r
  98                 {\r
  99                         assert (i_reader.isEqualBufferType(INyARRaster.BUFFERFORMAT_INT1D_GRAY_8));\r
 100                         final int[] input=(int[]) i_reader.getBuffer();\r
 101                         for (int y = i_size.h-1; y >=0 ; y-=i_skip){\r
 102                                 int pt=y*i_size.w;\r
 103                                 for (int x = i_size.w-1; x >=0; x--) {\r
 104                                         o_histogram[input[pt]]++;\r
 105                                         pt++;\r
 106                                 }\r
 107                         }\r
 108                         return i_size.w*i_size.h;\r
 109                 }       \r
 110         }\r
 111         class NyARRasterThresholdAnalyzer_Histogram_INT1D_X8R8G8B8_32 implements ICreateHistogramImpl\r
 112         {\r
 113                 public int createHistogram(INyARRaster i_reader,NyARIntSize i_size, int[] o_histogram,int i_skip)\r
 114                 {\r
 115                         assert (i_reader.isEqualBufferType(INyARRaster.BUFFERFORMAT_INT1D_X8R8G8B8_32));\r
 116                         final int[] input=(int[]) i_reader.getBuffer();\r
 117                         for (int y = i_size.h-1; y >=0 ; y-=i_skip){\r
 118                                 int pt=y*i_size.w;\r
 119                                 for (int x = i_size.w-1; x >=0; x--) {\r
 120                                         int p=input[pt];\r
 121                                         o_histogram[((p& 0xff)+(p& 0xff)+(p& 0xff))/3]++;\r
 122                                         pt++;\r
 123                                 }\r
 124                         }\r
 125                         return i_size.w*i_size.h;\r
 126                 }       \r
 127         }\r
 128 \r
 129         \r
 130         class NyARRasterThresholdAnalyzer_Histogram_BYTE1D_RGB_24 implements ICreateHistogramImpl\r
 131         {\r
 132                 public int createHistogram(INyARRaster i_reader,NyARIntSize i_size, int[] o_histogram,int i_skip)\r
 133                 {\r
 134                         assert (\r
 135                                         i_reader.isEqualBufferType(INyARRaster.BUFFERFORMAT_BYTE1D_B8G8R8_24)||\r
 136                                         i_reader.isEqualBufferType(INyARRaster.BUFFERFORMAT_BYTE1D_R8G8B8_24));\r
 137                         final byte[] input=(byte[]) i_reader.getBuffer();\r
 138                         final int pix_count=i_size.w;\r
 139                         final int pix_mod_part=pix_count-(pix_count%8);\r
 140                         for (int y = i_size.h-1; y >=0 ; y-=i_skip) {\r
 141                                 int pt=y*i_size.w*3;\r
 142                                 int x,v;\r
 143                                 for (x = pix_count-1; x >=pix_mod_part; x--) {\r
 144                                         v=((input[pt+0]& 0xff)+(input[pt+1]& 0xff)+(input[pt+2]& 0xff))/3;\r
 145                                         o_histogram[v]++;\r
 146                                         pt+=3;\r
 147                                 }\r
 148                                 //タイリング\r
 149                                 for (;x>=0;x-=8){\r
 150                                         v=((input[pt+ 0]& 0xff)+(input[pt+ 1]& 0xff)+(input[pt+ 2]& 0xff))/3;\r
 151                                         o_histogram[v]++;\r
 152                                         v=((input[pt+ 3]& 0xff)+(input[pt+ 4]& 0xff)+(input[pt+ 5]& 0xff))/3;\r
 153                                         o_histogram[v]++;\r
 154                                         v=((input[pt+ 6]& 0xff)+(input[pt+ 7]& 0xff)+(input[pt+ 8]& 0xff))/3;\r
 155                                         o_histogram[v]++;\r
 156                                         v=((input[pt+ 9]& 0xff)+(input[pt+10]& 0xff)+(input[pt+11]& 0xff))/3;\r
 157                                         o_histogram[v]++;\r
 158                                         v=((input[pt+12]& 0xff)+(input[pt+13]& 0xff)+(input[pt+14]& 0xff))/3;\r
 159                                         o_histogram[v]++;\r
 160                                         v=((input[pt+15]& 0xff)+(input[pt+16]& 0xff)+(input[pt+17]& 0xff))/3;\r
 161                                         o_histogram[v]++;\r
 162                                         v=((input[pt+18]& 0xff)+(input[pt+19]& 0xff)+(input[pt+20]& 0xff))/3;\r
 163                                         o_histogram[v]++;\r
 164                                         v=((input[pt+21]& 0xff)+(input[pt+22]& 0xff)+(input[pt+23]& 0xff))/3;\r
 165                                         o_histogram[v]++;\r
 166                                         pt+=3*8;\r
 167                                 }\r
 168                         }\r
 169                         return i_size.w*i_size.h;\r
 170                 }\r
 171         }\r
 172 \r
 173         class NyARRasterThresholdAnalyzer_Histogram_BYTE1D_B8G8R8X8_32 implements ICreateHistogramImpl\r
 174         {\r
 175                 public int createHistogram(INyARRaster i_reader,NyARIntSize i_size, int[] o_histogram,int i_skip)\r
 176                 {\r
 177                 assert(i_reader.isEqualBufferType(INyARRaster.BUFFERFORMAT_BYTE1D_B8G8R8X8_32));\r
 178                 byte[] input = (byte[])i_reader.getBuffer();\r
 179                 int pix_count = i_size.w;\r
 180                 int pix_mod_part = pix_count - (pix_count % 8);\r
 181                 for (int y = i_size.h - 1; y >= 0; y -= i_skip)\r
 182                 {\r
 183                     int pt = y * i_size.w * 4;\r
 184                     int x, v;\r
 185                     for (x = pix_count - 1; x >= pix_mod_part; x--)\r
 186                     {\r
 187                         v = ((input[pt + 0] & 0xff) + (input[pt + 1] & 0xff) + (input[pt + 2] & 0xff)) / 3;\r
 188                         o_histogram[v]++;\r
 189                         pt += 4;\r
 190                     }\r
 191                     //タイリング\r
 192                     for (; x >= 0; x -= 8)\r
 193                     {\r
 194                         v = ((input[pt + 0] & 0xff) + (input[pt + 1] & 0xff) + (input[pt + 2] & 0xff)) / 3;\r
 195                         o_histogram[v]++;\r
 196                         v = ((input[pt + 4] & 0xff) + (input[pt + 5] & 0xff) + (input[pt + 6] & 0xff)) / 3;\r
 197                         o_histogram[v]++;\r
 198                         v = ((input[pt + 8] & 0xff) + (input[pt + 9] & 0xff) + (input[pt + 10] & 0xff)) / 3;\r
 199                         o_histogram[v]++;\r
 200                         v = ((input[pt + 12] & 0xff) + (input[pt + 13] & 0xff) + (input[pt + 14] & 0xff)) / 3;\r
 201                         o_histogram[v]++;\r
 202                         v = ((input[pt + 16] & 0xff) + (input[pt + 17] & 0xff) + (input[pt + 18] & 0xff)) / 3;\r
 203                         o_histogram[v]++;\r
 204                         v = ((input[pt + 20] & 0xff) + (input[pt + 21] & 0xff) + (input[pt + 22] & 0xff)) / 3;\r
 205                         o_histogram[v]++;\r
 206                         v = ((input[pt + 24] & 0xff) + (input[pt + 25] & 0xff) + (input[pt + 26] & 0xff)) / 3;\r
 207                         o_histogram[v]++;\r
 208                         v = ((input[pt + 28] & 0xff) + (input[pt + 29] & 0xff) + (input[pt + 30] & 0xff)) / 3;\r
 209                         o_histogram[v]++;\r
 210                         pt += 4 * 8;\r
 211                     }\r
 212                 }\r
 213                 return i_size.w*i_size.h;\r
 214             }\r
 215         }\r
 216 \r
 217         class NyARRasterThresholdAnalyzer_Histogram_BYTE1D_X8R8G8B8_32 implements ICreateHistogramImpl\r
 218         {\r
 219                 public int createHistogram(INyARRaster i_reader,NyARIntSize i_size, int[] o_histogram,int i_skip)\r
 220                 {\r
 221                 assert(i_reader.isEqualBufferType(INyARRaster.BUFFERFORMAT_BYTE1D_X8R8G8B8_32));\r
 222                 byte[] input = (byte[])i_reader.getBuffer();\r
 223                 int pix_count = i_size.w;\r
 224                 int pix_mod_part = pix_count - (pix_count % 8);\r
 225                 for (int y = i_size.h - 1; y >= 0; y -=i_skip)\r
 226                 {\r
 227                     int pt = y * i_size.w * 4;\r
 228                     int x, v;\r
 229                     for (x = pix_count - 1; x >= pix_mod_part; x--)\r
 230                     {\r
 231                         v = ((input[pt + 1] & 0xff) + (input[pt + 2] & 0xff) + (input[pt + 3] & 0xff)) / 3;\r
 232                         o_histogram[v]++;\r
 233                         pt += 4;\r
 234                     }\r
 235                     //タイリング\r
 236                     for (; x >= 0; x -= 8)\r
 237                     {\r
 238                         v = ((input[pt + 1] & 0xff) + (input[pt + 2] & 0xff) + (input[pt + 3] & 0xff)) / 3;\r
 239                         o_histogram[v]++;\r
 240                         v = ((input[pt + 5] & 0xff) + (input[pt + 6] & 0xff) + (input[pt + 7] & 0xff)) / 3;\r
 241                         o_histogram[v]++;\r
 242                         v = ((input[pt + 9] & 0xff) + (input[pt + 10] & 0xff) + (input[pt + 11] & 0xff)) / 3;\r
 243                         o_histogram[v]++;\r
 244                         v = ((input[pt + 13] & 0xff) + (input[pt + 14] & 0xff) + (input[pt + 15] & 0xff)) / 3;\r
 245                         o_histogram[v]++;\r
 246                         v = ((input[pt + 17] & 0xff) + (input[pt + 18] & 0xff) + (input[pt + 19] & 0xff)) / 3;\r
 247                         o_histogram[v]++;\r
 248                         v = ((input[pt + 21] & 0xff) + (input[pt + 22] & 0xff) + (input[pt + 23] & 0xff)) / 3;\r
 249                         o_histogram[v]++;\r
 250                         v = ((input[pt + 25] & 0xff) + (input[pt + 26] & 0xff) + (input[pt + 27] & 0xff)) / 3;\r
 251                         o_histogram[v]++;\r
 252                         v = ((input[pt + 29] & 0xff) + (input[pt + 30] & 0xff) + (input[pt + 31] & 0xff)) / 3;\r
 253                         o_histogram[v]++;\r
 254                         pt += 4 * 8;\r
 255                     }\r
 256                 }\r
 257                 return i_size.w*i_size.h;\r
 258             }\r
 259         }\r
 260 \r
 261         class NyARRasterThresholdAnalyzer_Histogram_WORD1D_R5G6B5_16LE implements ICreateHistogramImpl\r
 262         {\r
 263                 public int createHistogram(INyARRaster i_reader,NyARIntSize i_size, int[] o_histogram,int i_skip)\r
 264                 {\r
 265                 assert(i_reader.isEqualBufferType(INyARRaster.BUFFERFORMAT_WORD1D_R5G6B5_16LE));\r
 266                 short[] input = (short[])i_reader.getBuffer();\r
 267                 int pix_count = i_size.w;\r
 268                 int pix_mod_part = pix_count - (pix_count % 8);\r
 269                 for (int y = i_size.h - 1; y >= 0; y -= i_skip)\r
 270                 {\r
 271                     int pt = y * i_size.w;\r
 272                     int x, v;\r
 273                     for (x = pix_count - 1; x >= pix_mod_part; x--)\r
 274                     {\r
 275                         v =(int)input[pt];\r
 276                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 277                         o_histogram[v]++;\r
 278                         pt++;\r
 279                     }\r
 280                     //タイリング\r
 281                     for (; x >= 0; x -= 8)\r
 282                     {\r
 283                         v =(int)input[pt];pt++;\r
 284                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 285                         o_histogram[v]++;\r
 286                         v =(int)input[pt];pt++;\r
 287                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 288                         o_histogram[v]++;\r
 289                         v =(int)input[pt];pt++;\r
 290                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 291                         o_histogram[v]++;\r
 292                         v =(int)input[pt];pt++;\r
 293                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 294                         o_histogram[v]++;\r
 295                         v =(int)input[pt];pt++;\r
 296                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 297                         o_histogram[v]++;\r
 298                         v =(int)input[pt];pt++;\r
 299                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 300                         o_histogram[v]++;\r
 301                         v =(int)input[pt];pt++;\r
 302                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 303                         o_histogram[v]++;\r
 304                         v =(int)input[pt];pt++;\r
 305                         v = (((v & 0xf800) >> 8) + ((v & 0x07e0) >> 3) + ((v & 0x001f) << 3))/3;\r
 306                         o_histogram[v]++;\r
 307                     }\r
 308                 }\r
 309                 return i_size.w*i_size.h;\r
 310             }\r
 311         }\r
 312 \r
 313 \r
 314 }