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