001 /* Copyright (C) 2004, 2005, 2006, Free Software Foundation 002 003 This file is part of GNU Classpath. 004 005 GNU Classpath is free software; you can redistribute it and/or modify 006 it under the terms of the GNU General Public License as published by 007 the Free Software Foundation; either version 2, or (at your option) 008 any later version. 009 010 GNU Classpath is distributed in the hope that it will be useful, but 011 WITHOUT ANY WARRANTY; without even the implied warranty of 012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013 General Public License for more details. 014 015 You should have received a copy of the GNU General Public License 016 along with GNU Classpath; see the file COPYING. If not, write to the 017 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 018 02110-1301 USA. 019 020 Linking this library statically or dynamically with other modules is 021 making a combined work based on this library. Thus, the terms and 022 conditions of the GNU General Public License cover the whole 023 combination. 024 025 As a special exception, the copyright holders of this library give you 026 permission to link this library with independent modules to produce an 027 executable, regardless of the license terms of these independent 028 modules, and to copy and distribute the resulting executable under 029 terms of your choice, provided that you also meet, for each linked 030 independent module, the terms and conditions of the license of that 031 module. An independent module is a module which is not derived from 032 or based on this library. If you modify this library, you may extend 033 this exception to your version of the library, but you are not 034 obligated to do so. If you do not wish to do so, delete this 035 exception statement from your version. */ 036 037 package java.awt.image; 038 039 import gnu.java.awt.Buffers; 040 041 /** 042 * A sample model that reads each sample value from a separate band in the 043 * {@link DataBuffer}. 044 * 045 * @author Jerry Quinn (jlquinn@optonline.net) 046 */ 047 public final class BandedSampleModel extends ComponentSampleModel 048 { 049 private int[] bitMasks; 050 private int[] bitOffsets; 051 private int[] sampleSize; 052 private int dataBitOffset; 053 private int elemBits; 054 private int numberOfBits; 055 private int numElems; 056 057 private static int[] createBankArray(int size) 058 { 059 int[] result = new int[size]; 060 for (int i = 0; i < size; i++) 061 result[i] = i; 062 return result; 063 } 064 065 /** 066 * Creates a new <code>BandedSampleModel</code>. 067 * 068 * @param dataType the data buffer type. 069 * @param w the width (in pixels). 070 * @param h the height (in pixels). 071 * @param numBands the number of bands. 072 */ 073 public BandedSampleModel(int dataType, int w, int h, int numBands) 074 { 075 this(dataType, w, h, w, createBankArray(numBands), new int[numBands]); 076 } 077 078 /** 079 * Creates a new <code>BandedSampleModel</code>. 080 * 081 * @param dataType the data buffer type. 082 * @param w the width (in pixels). 083 * @param h the height (in pixels). 084 * @param scanlineStride the number of data elements from a pixel in one 085 * row to the corresponding pixel in the next row. 086 * @param bankIndices the bank indices. 087 * @param bandOffsets the band offsets. 088 */ 089 public BandedSampleModel(int dataType, int w, int h, int scanlineStride, 090 int[] bankIndices, int[] bandOffsets) 091 { 092 super(dataType, w, h, 1, scanlineStride, bankIndices, bandOffsets); 093 } 094 095 /** 096 * Creates a new data buffer that is compatible with this sample model. 097 * 098 * @return The new data buffer. 099 */ 100 public DataBuffer createDataBuffer() 101 { 102 int size = scanlineStride * height; 103 return Buffers.createBuffer(getDataType(), size, numBanks); 104 } 105 106 /** 107 * Creates a new <code>SampleModel</code> that is compatible with this 108 * model and has the specified width and height. 109 * 110 * @param w the width (in pixels, must be greater than zero). 111 * @param h the height (in pixels, must be greater than zero). 112 * 113 * @return The new sample model. 114 * 115 * @throws IllegalArgumentException if <code>w</code> or <code>h</code> is 116 * not greater than zero. 117 * @throws IllegalArgumentException if <code>w * h</code> exceeds 118 * <code>Integer.MAX_VALUE</code>. 119 */ 120 public SampleModel createCompatibleSampleModel(int w, int h) 121 { 122 // NOTE: blackdown 1.4.1 sets all offsets to 0. Sun's 1.4.2 docs 123 // disagree. 124 125 // Compress offsets so minimum is 0, others w*scanlineStride 126 int[] newoffsets = new int[bandOffsets.length]; 127 int[] order = new int[bandOffsets.length]; 128 for (int i = 0; i < bandOffsets.length; i++) 129 order[i] = i; 130 // FIXME: This is N^2, but not a big issue, unless there's a lot of 131 // bands... 132 for (int i = 0; i < bandOffsets.length; i++) 133 for (int j = i + 1; j < bandOffsets.length; j++) 134 if (bankIndices[order[i]] > bankIndices[order[j]] 135 || (bankIndices[order[i]] == bankIndices[order[j]] 136 && bandOffsets[order[i]] > bandOffsets[order[j]])) 137 { 138 int t = order[i]; order[i] = order[j]; order[j] = t; 139 } 140 int bank = 0; 141 int offset = 0; 142 for (int i = 0; i < bandOffsets.length; i++) 143 { 144 if (bankIndices[order[i]] != bank) 145 { 146 bank = bankIndices[order[i]]; 147 offset = 0; 148 } 149 newoffsets[order[i]] = offset; 150 offset += w * scanlineStride; 151 } 152 153 return new BandedSampleModel(dataType, w, h, w, bankIndices, newoffsets); 154 } 155 156 157 public SampleModel createSubsetSampleModel(int[] bands) 158 { 159 if (bands.length > bankIndices.length) 160 throw new 161 RasterFormatException("BandedSampleModel createSubsetSampleModel too" 162 +" many bands"); 163 int[] newoff = new int[bands.length]; 164 int[] newbanks = new int[bands.length]; 165 for (int i = 0; i < bands.length; i++) 166 { 167 int b = bands[i]; 168 newoff[i] = bandOffsets[b]; 169 newbanks[i] = bankIndices[b]; 170 } 171 172 return new BandedSampleModel(dataType, width, height, scanlineStride, 173 newbanks, newoff); 174 } 175 176 /** 177 * Extract all samples of one pixel and return in an array of transfer type. 178 * 179 * Extracts the pixel at x, y from data and stores samples into the array 180 * obj. If obj is null, a new array of getTransferType() is created. 181 * 182 * @param x The x-coordinate of the pixel rectangle to store in 183 * <code>obj</code>. 184 * @param y The y-coordinate of the pixel rectangle to store in 185 * <code>obj</code>. 186 * @param obj The primitive array to store the pixels into or null to force 187 * creation. 188 * @param data The DataBuffer that is the source of the pixel data. 189 * @return The primitive array containing the pixel data. 190 * @see java.awt.image.SampleModel#getDataElements(int, int, 191 * java.lang.Object, java.awt.image.DataBuffer) 192 */ 193 public Object getDataElements(int x, int y, Object obj, DataBuffer data) 194 { 195 if (x < 0 || y < 0) 196 throw new ArrayIndexOutOfBoundsException( 197 "x and y must not be less than 0."); 198 int pixel = getSample(x, y, 0, data); 199 switch (getTransferType()) 200 { 201 case DataBuffer.TYPE_BYTE: 202 { 203 byte[] b = (byte[]) obj; 204 if (b == null) b = new byte[numBands]; 205 for (int i = 0; i < numBands; i++) 206 b[i] = (byte)getSample(x, y, i, data); 207 return b; 208 } 209 case DataBuffer.TYPE_SHORT: 210 case DataBuffer.TYPE_USHORT: 211 { 212 short[] b = (short[]) obj; 213 if (b == null) b = new short[numBands]; 214 for (int i = 0; i < numBands; i++) 215 b[i] = (short)getSample(x, y, i, data); 216 return b; 217 } 218 case DataBuffer.TYPE_INT: 219 { 220 int[] b = (int[]) obj; 221 if (b == null) b = new int[numBands]; 222 for (int i = 0; i < numBands; i++) 223 b[i] = getSample(x, y, i, data); 224 return b; 225 } 226 case DataBuffer.TYPE_FLOAT: 227 { 228 float[] b = (float[]) obj; 229 if (b == null) b = new float[numBands]; 230 for (int i = 0; i < numBands; i++) 231 b[i] = getSampleFloat(x, y, i, data); 232 return b; 233 } 234 case DataBuffer.TYPE_DOUBLE: 235 { 236 double[] b = (double[]) obj; 237 if (b == null) 238 b = new double[numBands]; 239 for (int i = 0; i < numBands; i++) 240 b[i] = getSample(x, y, i, data); 241 return b; 242 } 243 244 default: 245 // Seems like the only sensible thing to do. 246 throw new ClassCastException(); 247 } 248 } 249 250 /** 251 * Returns all the samples for the pixel at location <code>(x, y)</code> 252 * stored in the specified data buffer. 253 * 254 * @param x the x-coordinate. 255 * @param y the y-coordinate. 256 * @param iArray an array that will be populated with the sample values and 257 * returned as the result. The size of this array should be equal to the 258 * number of bands in the model. If the array is <code>null</code>, a new 259 * array is created. 260 * @param data the data buffer (<code>null</code> not permitted). 261 * 262 * @return The samples for the specified pixel. 263 * 264 * @see #setPixel(int, int, int[], DataBuffer) 265 */ 266 public int[] getPixel(int x, int y, int[] iArray, DataBuffer data) 267 { 268 if (iArray == null) 269 iArray = new int[numBands]; 270 for (int i = 0; i < numBands; i++) 271 iArray[i] = getSample(x, y, i, data); 272 273 return iArray; 274 } 275 276 /** 277 * Copy pixels from a region into an array. 278 * 279 * Copies the samples of the pixels in the rectangle starting at x, y that 280 * is w pixels wide and h scanlines high. When there is more than one band, 281 * the samples stored in order before the next pixel. This ordering isn't 282 * well specified in Sun's docs as of 1.4.2. 283 * 284 * If iArray is null, a new array is allocated, filled, and returned. 285 * 286 * @param x The x-coordinate of the pixel rectangle to store in 287 * <code>iArray</code>. 288 * @param y The y-coordinate of the pixel rectangle to store in 289 * <code>iArray</code>. 290 * @param w The width in pixels of the rectangle. 291 * @param h The height in pixels of the rectangle. 292 * @param iArray The int array to store the pixels into or null to force 293 * creation. 294 * @param data The DataBuffer that is the source of the pixel data. 295 * @return The primitive array containing the pixel data. 296 */ 297 public int[] getPixels(int x, int y, int w, int h, int[] iArray, 298 DataBuffer data) 299 { 300 if (x < 0 || y < 0) 301 throw new ArrayIndexOutOfBoundsException( 302 "x and y must not be less than 0."); 303 if (iArray == null) 304 iArray = new int[w * h * numBands]; 305 int outOffset = 0; 306 int maxX = x + w; 307 int maxY = y + h; 308 for (int yy = x; yy < maxY; yy++) 309 { 310 for (int xx = x; xx < maxX; xx++) 311 { 312 for (int b = 0; b < numBands; b++) 313 { 314 int offset = bandOffsets[b] + yy * scanlineStride + xx; 315 iArray[outOffset++] = 316 data.getElem(bankIndices[b], offset); 317 } 318 } 319 } 320 return iArray; 321 } 322 323 /** 324 * Returns a sample value for the pixel at (x, y) in the specified data 325 * buffer. 326 * 327 * @param x the x-coordinate of the pixel. 328 * @param y the y-coordinate of the pixel. 329 * @param b the band (in the range <code>0</code> to 330 * <code>getNumBands() - 1</code>). 331 * @param data the data buffer (<code>null</code> not permitted). 332 * 333 * @return The sample value. 334 * 335 * @throws NullPointerException if <code>data</code> is <code>null</code>. 336 */ 337 public int getSample(int x, int y, int b, DataBuffer data) 338 { 339 int offset = bandOffsets[b] + y * scanlineStride + x; 340 return data.getElem(bankIndices[b], offset); 341 } 342 343 /** 344 * Returns a sample value for the pixel at (x, y) in the specified data 345 * buffer. 346 * 347 * @param x the x-coordinate of the pixel. 348 * @param y the y-coordinate of the pixel. 349 * @param b the band (in the range <code>0</code> to 350 * <code>getNumBands() - 1</code>). 351 * @param data the data buffer (<code>null</code> not permitted). 352 * 353 * @return The sample value. 354 * 355 * @throws NullPointerException if <code>data</code> is <code>null</code>. 356 * 357 * @see #getSample(int, int, int, DataBuffer) 358 */ 359 public float getSampleFloat(int x, int y, int b, DataBuffer data) 360 { 361 int offset = bandOffsets[b] + y * scanlineStride + x; 362 return data.getElemFloat(bankIndices[b], offset); 363 } 364 365 /** 366 * Returns the sample value for the pixel at (x, y) in the specified data 367 * buffer. 368 * 369 * @param x the x-coordinate of the pixel. 370 * @param y the y-coordinate of the pixel. 371 * @param b the band (in the range <code>0</code> to 372 * <code>getNumBands() - 1</code>). 373 * @param data the data buffer (<code>null</code> not permitted). 374 * 375 * @return The sample value. 376 * 377 * @throws NullPointerException if <code>data</code> is <code>null</code>. 378 * 379 * @see #getSample(int, int, int, DataBuffer) 380 */ 381 public double getSampleDouble(int x, int y, int b, DataBuffer data) 382 { 383 int offset = bandOffsets[b] + y * scanlineStride + x; 384 return data.getElemDouble(bankIndices[b], offset); 385 } 386 387 /** 388 * Copy one band's samples from a region into an array. 389 * 390 * Copies from one band the samples of the pixels in the rectangle starting 391 * at x, y that is w pixels wide and h scanlines high. 392 * 393 * If iArray is null, a new array is allocated, filled, and returned. 394 * 395 * @param x The x-coordinate of the pixel rectangle to store in 396 * <code>iArray</code>. 397 * @param y The y-coordinate of the pixel rectangle to store in 398 * <code>iArray</code>. 399 * @param w The width in pixels of the rectangle. 400 * @param h The height in pixels of the rectangle. 401 * @param b The band to retrieve. 402 * @param iArray The int array to store the pixels into or null to force 403 * creation. 404 * @param data The DataBuffer that is the source of the pixel data. 405 * @return The primitive array containing the pixel data. 406 */ 407 public int[] getSamples(int x, int y, int w, int h, int b, int[] iArray, 408 DataBuffer data) 409 { 410 if (x < 0 || y < 0) 411 throw new ArrayIndexOutOfBoundsException( 412 "x and y must not be less than 0."); 413 if (iArray == null) 414 iArray = new int[w * h]; 415 int outOffset = 0; 416 int maxX = x + w; 417 int maxY = y + h; 418 for (int yy = y; yy < maxY; yy++) 419 { 420 for (int xx = x; xx < maxX; xx++) 421 { 422 int offset = bandOffsets[b] + yy * scanlineStride + xx; 423 iArray[outOffset++] = 424 data.getElem(bankIndices[b], offset); 425 } 426 } 427 return iArray; 428 } 429 430 /** 431 * Set the pixel at x, y to the value in the first element of the primitive 432 * array obj. 433 * 434 * @param x The x-coordinate of the data elements in <code>obj</code>. 435 * @param y The y-coordinate of the data elements in <code>obj</code>. 436 * @param obj The primitive array containing the data elements to set. 437 * @param data The DataBuffer to store the data elements into. 438 * @see java.awt.image.SampleModel#setDataElements(int, int, int, int, java.lang.Object, java.awt.image.DataBuffer) 439 */ 440 public void setDataElements(int x, int y, Object obj, DataBuffer data) 441 { 442 int transferType = getTransferType(); 443 if (getTransferType() != data.getDataType()) 444 { 445 throw new IllegalArgumentException("transfer type ("+ 446 getTransferType()+"), "+ 447 "does not match data "+ 448 "buffer type (" + 449 data.getDataType() + 450 ")."); 451 } 452 453 int offset = y * scanlineStride + x; 454 455 try 456 { 457 switch (transferType) 458 { 459 case DataBuffer.TYPE_BYTE: 460 { 461 DataBufferByte out = (DataBufferByte) data; 462 byte[] in = (byte[]) obj; 463 for (int i = 0; i < numBands; i++) 464 out.getData(bankIndices[i])[offset + bandOffsets[i]] = in[i]; 465 return; 466 } 467 case DataBuffer.TYPE_SHORT: 468 { 469 DataBufferShort out = (DataBufferShort) data; 470 short[] in = (short[]) obj; 471 for (int i = 0; i < numBands; i++) 472 out.getData(bankIndices[i])[offset + bandOffsets[i]] = in[i]; 473 return; 474 } 475 case DataBuffer.TYPE_USHORT: 476 { 477 DataBufferUShort out = (DataBufferUShort) data; 478 short[] in = (short[]) obj; 479 for (int i = 0; i < numBands; i++) 480 out.getData(bankIndices[i])[offset + bandOffsets[i]] = in[i]; 481 return; 482 } 483 case DataBuffer.TYPE_INT: 484 { 485 DataBufferInt out = (DataBufferInt) data; 486 int[] in = (int[]) obj; 487 for (int i = 0; i < numBands; i++) 488 out.getData(bankIndices[i])[offset + bandOffsets[i]] = in[i]; 489 return; 490 } 491 case DataBuffer.TYPE_FLOAT: 492 { 493 DataBufferFloat out = (DataBufferFloat) data; 494 float[] in = (float[]) obj; 495 for (int i = 0; i < numBands; i++) 496 out.getData(bankIndices[i])[offset + bandOffsets[i]] = in[i]; 497 return; 498 } 499 case DataBuffer.TYPE_DOUBLE: 500 { 501 DataBufferDouble out = (DataBufferDouble) data; 502 double[] in = (double[]) obj; 503 for (int i = 0; i < numBands; i++) 504 out.getData(bankIndices[i])[offset + bandOffsets[i]] = in[i]; 505 return; 506 } 507 default: 508 throw new ClassCastException("Unsupported data type"); 509 } 510 } 511 catch (ArrayIndexOutOfBoundsException aioobe) 512 { 513 String msg = "While writing data elements" 514 + ", x=" + x + ", y=" + y 515 + ", width=" + width + ", height=" + height 516 + ", scanlineStride=" + scanlineStride 517 + ", offset=" + offset 518 + ", data.getSize()=" + data.getSize() 519 + ", data.getOffset()=" + data.getOffset() 520 + ": " + aioobe; 521 throw new ArrayIndexOutOfBoundsException(msg); 522 } 523 } 524 525 /** 526 * Sets the samples for the pixel at (x, y) in the specified data buffer to 527 * the specified values. 528 * 529 * @param x the x-coordinate of the pixel. 530 * @param y the y-coordinate of the pixel. 531 * @param iArray the sample values (<code>null</code> not permitted). 532 * @param data the data buffer (<code>null</code> not permitted). 533 * 534 * @throws NullPointerException if either <code>iArray</code> or 535 * <code>data</code> is <code>null</code>. 536 */ 537 public void setPixel(int x, int y, int[] iArray, DataBuffer data) 538 { 539 for (int b = 0; b < numBands; b++) 540 data.setElem(bankIndices[b], bandOffsets[b] + y * scanlineStride + x, 541 iArray[b]); 542 } 543 544 /** 545 * Sets the sample values for the pixels in the region specified by 546 * (x, y, w, h) in the specified data buffer. The array is 547 * ordered by pixels (that is, all the samples for the first pixel are 548 * grouped together, followed by all the samples for the second pixel, and so 549 * on). 550 * 551 * @param x the x-coordinate of the top-left pixel. 552 * @param y the y-coordinate of the top-left pixel. 553 * @param w the width of the region of pixels. 554 * @param h the height of the region of pixels. 555 * @param iArray the pixel sample values (<code>null</code> not permitted). 556 * @param data the data buffer (<code>null</code> not permitted). 557 * 558 * @throws NullPointerException if either <code>iArray</code> or 559 * <code>data</code> is <code>null</code>. 560 */ 561 public void setPixels(int x, int y, int w, int h, int[] iArray, 562 DataBuffer data) 563 { 564 int inOffset = 0; 565 for (int hh = 0; hh < h; hh++) 566 { 567 for (int ww = 0; ww < w; ww++) 568 { 569 int offset = y * scanlineStride + (x + ww); 570 for (int b = 0; b < numBands; b++) 571 data.setElem(bankIndices[b], bandOffsets[b] + offset, 572 iArray[inOffset++]); 573 } 574 y++; 575 } 576 } 577 578 /** 579 * Sets the sample value for band <code>b</code> of the pixel at location 580 * <code>(x, y)</code> in the specified data buffer. 581 * 582 * @param x the x-coordinate. 583 * @param y the y-coordinate. 584 * @param b the band index. 585 * @param s the sample value. 586 * @param data the data buffer (<code>null</code> not permitted). 587 * 588 * @see #getSample(int, int, int, DataBuffer) 589 */ 590 public void setSample(int x, int y, int b, int s, DataBuffer data) 591 { 592 data.setElem(bankIndices[b], bandOffsets[b] + y * scanlineStride + x, s); 593 } 594 595 /** 596 * Sets the sample value for a band for the pixel at (x, y) in the 597 * specified data buffer. 598 * 599 * @param x the x-coordinate of the pixel. 600 * @param y the y-coordinate of the pixel. 601 * @param b the band (in the range <code>0</code> to 602 * <code>getNumBands() - 1</code>). 603 * @param s the sample value. 604 * @param data the data buffer (<code>null</code> not permitted). 605 * 606 * @throws NullPointerException if <code>data</code> is <code>null</code>. 607 */ 608 public void setSample(int x, int y, int b, float s, DataBuffer data) 609 { 610 data.setElemFloat(bankIndices[b], bandOffsets[b] + y * scanlineStride + x, 611 s); 612 } 613 614 /** 615 * Sets the sample value for a band for the pixel at (x, y) in the 616 * specified data buffer. 617 * 618 * @param x the x-coordinate of the pixel. 619 * @param y the y-coordinate of the pixel. 620 * @param b the band (in the range <code>0</code> to 621 * <code>getNumBands() - 1</code>). 622 * @param s the sample value. 623 * @param data the data buffer (<code>null</code> not permitted). 624 * 625 * @throws NullPointerException if <code>data</code> is <code>null</code>. 626 */ 627 public void setSample(int x, int y, int b, double s, DataBuffer data) 628 { 629 data.setElemDouble(bankIndices[b], bandOffsets[b] + y * scanlineStride + x, 630 s); 631 } 632 633 /** 634 * Sets the sample values for one band for the pixels in the region 635 * specified by (x, y, w, h) in the specified data buffer. 636 * 637 * @param x the x-coordinate of the top-left pixel. 638 * @param y the y-coordinate of the top-left pixel. 639 * @param w the width of the region of pixels. 640 * @param h the height of the region of pixels. 641 * @param b the band (in the range <code>0</code> to 642 * </code>getNumBands() - 1</code>). 643 * @param iArray the sample values (<code>null</code> not permitted). 644 * @param data the data buffer (<code>null</code> not permitted). 645 * 646 * @throws NullPointerException if either <code>iArray</code> or 647 * <code>data</code> is <code>null</code>. 648 */ 649 public void setSamples(int x, int y, int w, int h, int b, int[] iArray, 650 DataBuffer data) 651 { 652 if (x < 0 || y < 0) 653 throw new ArrayIndexOutOfBoundsException( 654 "x and y must not be less than 0."); 655 int inOffset = 0; 656 657 switch (getTransferType()) 658 { 659 case DataBuffer.TYPE_BYTE: 660 { 661 DataBufferByte out = (DataBufferByte) data; 662 byte[] bank = out.getData(bankIndices[b]); 663 for (int hh = 0; hh < h; hh++) 664 { 665 for (int ww = 0; ww < w; ww++) 666 { 667 int offset = bandOffsets[b] + y * scanlineStride + (x + ww); 668 bank[offset] = (byte)iArray[inOffset++]; 669 } 670 y++; 671 } 672 return; 673 } 674 case DataBuffer.TYPE_SHORT: 675 { 676 DataBufferShort out = (DataBufferShort) data; 677 short[] bank = out.getData(bankIndices[b]); 678 for (int hh = 0; hh < h; hh++) 679 { 680 for (int ww = 0; ww < w; ww++) 681 { 682 int offset = bandOffsets[b] + y * scanlineStride + (x + ww); 683 bank[offset] = (short)iArray[inOffset++]; 684 } 685 y++; 686 } 687 return; 688 } 689 case DataBuffer.TYPE_USHORT: 690 { 691 DataBufferShort out = (DataBufferShort) data; 692 short[] bank = out.getData(bankIndices[b]); 693 for (int hh = 0; hh < h; hh++) 694 { 695 for (int ww = 0; ww < w; ww++) 696 { 697 int offset = bandOffsets[b] + y * scanlineStride + (x + ww); 698 bank[offset] = (short)iArray[inOffset++]; 699 } 700 y++; 701 } 702 return; 703 } 704 case DataBuffer.TYPE_INT: 705 { 706 DataBufferInt out = (DataBufferInt) data; 707 int[] bank = out.getData(bankIndices[b]); 708 for (int hh = 0; hh < h; hh++) 709 { 710 for (int ww = 0; ww < w; ww++) 711 { 712 int offset = bandOffsets[b] + y * scanlineStride + (x + ww); 713 bank[offset] = iArray[inOffset++]; 714 } 715 y++; 716 } 717 return; 718 } 719 case DataBuffer.TYPE_FLOAT: 720 case DataBuffer.TYPE_DOUBLE: 721 break; 722 default: 723 throw new ClassCastException("Unsupported data type"); 724 } 725 726 // Default implementation probably slower for float and double 727 for (int hh = 0; hh < h; hh++) 728 { 729 for (int ww = 0; ww < w; ww++) 730 { 731 int offset = bandOffsets[b] + y * scanlineStride + (x + ww); 732 data.setElem(bankIndices[b], offset, iArray[inOffset++]); 733 } 734 y++; 735 } 736 } 737 738 /** 739 * Creates a String with some information about this SampleModel. 740 * @return A String describing this SampleModel. 741 * @see java.lang.Object#toString() 742 */ 743 public String toString() 744 { 745 StringBuffer result = new StringBuffer(); 746 result.append(getClass().getName()); 747 result.append("["); 748 result.append("scanlineStride=").append(scanlineStride); 749 for(int i = 0; i < bitMasks.length; i+=1) 750 { 751 result.append(", mask[").append(i).append("]=0x").append( 752 Integer.toHexString(bitMasks[i])); 753 } 754 755 result.append("]"); 756 return result.toString(); 757 } 758 }