libjava/java/awt/image/SampleModel.java

   1 /* Copyright (C) 2000, 2001, 2002  Free Software Foundation
   2
   3 This file is part of GNU Classpath.
   4
   5 GNU Classpath is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Classpath is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Classpath; see the file COPYING.  If not, write to the
  17 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18 02111-1307 USA.
  19
  20 Linking this library statically or dynamically with other modules is
  21 making a combined work based on this library.  Thus, the terms and
  22 conditions of the GNU General Public License cover the whole
  23 combination.
  24
  25 As a special exception, the copyright holders of this library give you
  26 permission to link this library with independent modules to produce an
  27 executable, regardless of the license terms of these independent
  28 modules, and to copy and distribute the resulting executable under
  29 terms of your choice, provided that you also meet, for each linked
  30 independent module, the terms and conditions of the license of that
  31 module.  An independent module is a module which is not derived from
  32 or based on this library.  If you modify this library, you may extend
  33 this exception to your version of the library, but you are not
  34 obligated to do so.  If you do not wish to do so, delete this
  35 exception statement from your version. */
  36
  37 package java.awt.image;
  38
  39 /**
  40  * @author Rolf W. Rasmussen <rolfwr@ii.uib.no>
  41  */
  42 public abstract class SampleModel
  43 {
  44   /** Width of image described. */
  45   protected int width;
  46
  47   /** Height of image described. */
  48   protected int height;
  49
  50   /** Number of bands in the image described. */
  51   protected int numBands;
  52
  53   /**
  54    * The DataBuffer type that is used to store the data of the image
  55    * described.
  56    */
  57   protected int dataType;
  58
  59   public SampleModel(int dataType, int w, int h, int numBands)
  60   {
  61     if ((w<=0) || (h<=0)) throw new IllegalArgumentException();
  62
  63     // FIXME: How can an int be greater than Integer.MAX_VALUE?
  64     // FIXME: How do we identify an unsupported data type?
  65
  66     this.dataType = dataType;
  67     this.width = w;
  68     this.height = h;
  69     this.numBands = numBands;
  70   }
  71
  72   public final int getWidth()
  73   {
  74     return width;
  75   }
  76
  77   public final int getHeight()
  78   {
  79     return height;
  80   }
  81
  82   public final int getNumBands()
  83   {
  84     return numBands;
  85   }
  86
  87   public abstract int getNumDataElements();
  88
  89   public final int getDataType()
  90   {
  91     return dataType;
  92   }
  93
  94   public int getTransferType()
  95   {
  96     // FIXME: Is this a reasonable default implementation?
  97     return dataType;
  98   }
  99
 100   public int[] getPixel(int x, int y, int[] iArray, DataBuffer data)
 101   {
 102     if (iArray == null) iArray = new int[numBands];
 103     for (int b=0; b<numBands; b++) iArray[b] = getSample(x, y, b, data);
 104     return iArray;
 105   }
 106
 107   /**
 108    *
 109    * This method is provided as a faster alternative to getPixel(),
 110    * that can be used when there is no need to decode the pixel into
 111    * separate sample values.
 112    *
 113    * @param obj An array to return the pixel data in. If null, an
 114    * array of the right type and size will be created.
 115    *
 116    * @return A single pixel as an array object of a primitive type,
 117    * based on the transfer type. Eg. if transfer type is
 118    * DataBuffer.TYPE_USHORT, then a short[] object is returned.
 119    */
 120   public abstract Object getDataElements(int x, int y, Object obj,
 121                                          DataBuffer data);
 122
 123
 124   public Object getDataElements(int x, int y, int w, int h, Object obj,
 125                                 DataBuffer data)
 126   {
 127     int size = w*h;
 128     int numDataElements = getNumDataElements();
 129     int dataSize = numDataElements*size;
 130
 131     if (obj == null)
 132       {
 133         switch (getTransferType())
 134           {
 135           case DataBuffer.TYPE_BYTE:
 136             obj = new byte[dataSize];
 137             break;
 138           case DataBuffer.TYPE_USHORT:
 139             obj = new short[dataSize];
 140             break;
 141           case DataBuffer.TYPE_INT:
 142             obj = new int[dataSize];
 143             break;
 144           default:
 145             // Seems like the only sensible thing to do.
 146             throw new ClassCastException();
 147           }
 148       }
 149     Object pixelData = null;
 150     int outOffset = 0;
 151     for (int yy = y; yy<(y+h); yy++)
 152       {
 153         for (int xx = x; xx<(x+w); xx++)
 154           {
 155             pixelData = getDataElements(xx, yy, pixelData, data);
 156             System.arraycopy(pixelData, 0, obj, outOffset,
 157                              numDataElements);
 158             outOffset += numDataElements;
 159           }
 160       }
 161     return obj;
 162   }
 163
 164   public abstract void setDataElements(int x, int y, Object obj,
 165                                        DataBuffer data);
 166
 167   public void setDataElements(int x, int y, int w, int h,
 168                               Object obj, DataBuffer data)
 169   {
 170     int size = w*h;
 171     int numDataElements = getNumDataElements();
 172     int dataSize = numDataElements*size;
 173
 174     Object pixelData;
 175     switch (getTransferType())
 176       {
 177       case DataBuffer.TYPE_BYTE:
 178         pixelData = new byte[numDataElements];
 179         break;
 180       case DataBuffer.TYPE_USHORT:
 181         pixelData = new short[numDataElements];
 182         break;
 183       case DataBuffer.TYPE_INT:
 184         pixelData = new int[numDataElements];
 185         break;
 186       default:
 187         // Seems like the only sensible thing to do.
 188         throw new ClassCastException();
 189       }
 190     int inOffset = 0;
 191
 192     for (int yy=y; yy<(y+h); yy++)
 193       {
 194         for (int xx=x; xx<(x+w); xx++)
 195           {
 196             System.arraycopy(obj, inOffset, pixelData, 0,
 197                              numDataElements);
 198             setDataElements(xx, yy, pixelData, data);
 199             inOffset += numDataElements;
 200           }
 201       }
 202   }
 203
 204   public float[] getPixel(int x, int y, float[] fArray, DataBuffer data)
 205   {
 206     if (fArray == null) fArray = new float[numBands];
 207
 208     for (int b=0; b<numBands; b++)
 209       {
 210         fArray[b] = getSampleFloat(x, y, b, data);
 211       }
 212     return fArray;
 213   }
 214
 215   public double[] getPixel(int x, int y, double[] dArray, DataBuffer data) {
 216     if (dArray == null) dArray = new double[numBands];
 217     for (int b=0; b<numBands; b++)
 218       {
 219         dArray[b] = getSampleDouble(x, y, b, data);
 220       }
 221     return dArray;
 222   }
 223
 224   /* FIXME: Should it return a banded or pixel interleaved array of
 225      samples? (Assume interleaved.) */
 226   public int[] getPixels(int x, int y, int w, int h, int[] iArray,
 227                          DataBuffer data)
 228   {
 229     int size = w*h;
 230     int outOffset = 0;
 231     int[] pixel = null;
 232     if (iArray == null) iArray = new int[w*h*numBands];
 233     for (int yy=y; yy<(y+h); yy++)
 234       {
 235         for (int xx=x; xx<(x+w); xx++)
 236           {
 237             getPixel(xx, yy, pixel, data);
 238             System.arraycopy(pixel, 0, iArray, outOffset, numBands);
 239             outOffset += numBands;
 240           }
 241       }
 242     return iArray;
 243   }
 244
 245   /* FIXME: Should it return a banded or pixel interleaved array of
 246      samples? (Assume interleaved.) */
 247   public float[] getPixels(int x, int y, int w, int h, float[] fArray,
 248                            DataBuffer data)
 249   {
 250     int size = w*h;
 251     int outOffset = 0;
 252     float[] pixel = null;
 253     if (fArray == null) fArray = new float[w*h*numBands];
 254     for (int yy=y; yy<(y+h); yy++)
 255       {
 256         for (int xx=x; xx<(x+w); xx++)
 257           {
 258             getPixel(xx, yy, pixel, data);
 259             System.arraycopy(pixel, 0, fArray, outOffset, numBands);
 260             outOffset += numBands;
 261           }
 262       }
 263     return fArray;
 264   }
 265
 266   /* FIXME: Should it return a banded or pixel interleaved array of
 267      samples? (Assume interleaved.) */
 268   public double[] getPixels(int x, int y, int w, int h, double[] dArray,
 269                             DataBuffer data)
 270   {
 271     int size = w*h;
 272     int outOffset = 0;
 273     double[] pixel = null;
 274     if (dArray == null) dArray = new double[w*h*numBands];
 275     for (int yy=y; yy<(y+h); yy++)
 276       {
 277         for (int xx=x; xx<(x+w); xx++)
 278           {
 279             getPixel(xx, yy, pixel, data);
 280             System.arraycopy(pixel, 0, dArray, outOffset, numBands);
 281             outOffset += numBands;
 282           }
 283       }
 284     return dArray;
 285   }
 286
 287   public abstract int getSample(int x, int y, int b, DataBuffer data);
 288
 289   public float getSampleFloat(int x, int y, int b, DataBuffer data)
 290   {
 291     return getSample(x, y, b, data);
 292   }
 293
 294   public double getSampleDouble(int x, int y, int b, DataBuffer data)
 295   {
 296     return getSampleFloat(x, y, b, data);
 297   }
 298
 299   public int[] getSamples(int x, int y, int w, int h, int b,
 300                           int[] iArray, DataBuffer data)
 301   {
 302     int size = w*h;
 303     int outOffset = 0;
 304     if (iArray == null) iArray = new int[size];
 305     for (int yy=y; yy<(y+h); yy++)
 306       {
 307         for (int xx=x; xx<(x+w); xx++)
 308           {
 309             iArray[outOffset++] = getSample(xx, yy, b, data);
 310           }
 311       }
 312     return iArray;
 313   }
 314
 315   public float[] getSamples(int x, int y, int w, int h, int b,
 316                             float[] fArray, DataBuffer data)
 317   {
 318     int size = w*h;
 319     int outOffset = 0;
 320     if (fArray == null) fArray = new float[size];
 321     for (int yy=y; yy<(y+h); yy++)
 322       {
 323         for (int xx=x; xx<(x+w); xx++)
 324           {
 325             fArray[outOffset++] = getSampleFloat(xx, yy, b, data);
 326           }
 327       }
 328     return fArray;
 329   }
 330
 331   public double[] getSamples(int x, int y, int w, int h, int b,
 332                              double[] dArray, DataBuffer data)
 333   {
 334     int size = w*h;
 335     int outOffset = 0;
 336     if (dArray == null) dArray = new double[size];
 337     for (int yy=y; yy<(y+h); yy++)
 338       {
 339         for (int xx=x; xx<(x+w); xx++)
 340           {
 341             dArray[outOffset++] = getSampleDouble(xx, yy, b, data);
 342           }
 343       }
 344     return dArray;
 345   }
 346
 347   public void setPixel(int x, int y, int[] iArray, DataBuffer data)
 348   {
 349     for (int b=0; b<numBands; b++) setSample(x, y, b, iArray[b], data);
 350   }
 351
 352   public void setPixel(int x, int y, float[] fArray, DataBuffer data)
 353   {
 354     for (int b=0; b<numBands; b++) setSample(x, y, b, fArray[b], data);
 355   }
 356
 357   public void setPixel(int x, int y, double[] dArray, DataBuffer data)
 358   {
 359     for (int b=0; b<numBands; b++) setSample(x, y, b, dArray[b], data);
 360   }
 361
 362   public void setPixels(int x, int y, int w, int h, int[] iArray,
 363                         DataBuffer data)
 364   {
 365     int inOffset = 0;
 366     int[] pixel = new int[numBands];
 367     for (int yy=y; yy<(y+h); yy++)
 368       {
 369         for (int xx=x; xx<(x+w); xx++)
 370           {
 371             System.arraycopy(iArray, inOffset, pixel, 0, numBands);
 372             setPixel(xx, yy, pixel, data);
 373             inOffset += numBands;
 374           }
 375       }
 376   }
 377
 378   public void setPixels(int x, int y, int w, int h, float[] fArray,
 379                         DataBuffer data)
 380   {
 381     int inOffset = 0;
 382     float[] pixel = new float[numBands];
 383     for (int yy=y; yy<(y+h); yy++)
 384       {
 385         for (int xx=x; xx<(x+w); xx++)
 386           {
 387             System.arraycopy(fArray, inOffset, pixel, 0, numBands);
 388             setPixel(xx, yy, pixel, data);
 389             inOffset += numBands;
 390           }
 391       }
 392   }
 393
 394   public void setPixels(int x, int y, int w, int h, double[] dArray,
 395                         DataBuffer data)
 396   {
 397     int inOffset = 0;
 398     double[] pixel = new double[numBands];
 399     for (int yy=y; yy<(y+h); yy++)
 400       {
 401         for (int xx=x; xx<(x+w); xx++)
 402           {
 403             System.arraycopy(dArray, inOffset, pixel, 0, numBands);
 404             setPixel(xx, yy, pixel, data);
 405             inOffset += numBands;
 406           }
 407       }
 408   }
 409
 410   public abstract void setSample(int x, int y, int b, int s,
 411                                  DataBuffer data);
 412
 413   public void setSample(int x, int y, int b, float s,
 414                         DataBuffer data)
 415   {
 416     setSample(x, y, b, (int) s, data);
 417   }
 418
 419   public void setSample(int x, int y, int b, double s,
 420                         DataBuffer data)
 421   {
 422     setSample(x, y, b, (float) s, data);
 423   }
 424
 425   public void setSamples(int x, int y, int w, int h, int b,
 426                          int[] iArray, DataBuffer data)
 427   {
 428     int size = w*h;
 429     int inOffset = 0;
 430     for (int yy=y; yy<(y+h); yy++)
 431       for (int xx=x; xx<(x+w); xx++)
 432         setSample(xx, yy, b, iArray[inOffset++], data);
 433   }
 434
 435   public void setSamples(int x, int y, int w, int h, int b,
 436                          float[] fArray, DataBuffer data)
 437   {
 438     int size = w*h;
 439     int inOffset = 0;
 440     for (int yy=y; yy<(y+h); yy++)
 441       for (int xx=x; xx<(x+w); xx++)
 442         setSample(xx, yy, b, fArray[inOffset++], data);
 443
 444     }
 445
 446     public void setSamples(int x, int y, int w, int h, int b,
 447                            double[] dArray, DataBuffer data) {
 448       int size = w*h;
 449       int inOffset = 0;
 450       for (int yy=y; yy<(y+h); yy++)
 451         for (int xx=x; xx<(x+w); xx++)
 452           setSample(xx, yy, b, dArray[inOffset++], data);
 453     }
 454
 455     public abstract SampleModel createCompatibleSampleModel(int w, int h);
 456
 457     public abstract SampleModel createSubsetSampleModel(int[] bands);
 458
 459     public abstract DataBuffer createDataBuffer();
 460
 461     public abstract int[] getSampleSize();
 462
 463     public abstract int getSampleSize(int band);
 464 }