Java Doc for InterpolationTable.java in  » 6.0-JDK-Modules » Java-Advanced-Imaging » javax » media » jai » Java Source Code / Java DocumentationJava Source Code and Java Documentation

An InterpolationTable defines a separable interpolation, with a set of kernels for each dimension. The number of bins may vary between the two dimensions. Both the horizontal and vertical interpolation kernels have a "key" element. This element is positioned over the which The kernels are stored in double precision, floating- and fixed-point form. The fixed point representation has a user-specified fractional precision. It is the user's responsibility to specify an appropriate level of precision that will not cause overflow when accumulating the results of a convolution against a set of source pixels, using 32-bit integer arithmetic.

dataH and dataV are required to contain width * 2subsampleBitsH and height * 2subsampleBitsV entries respectively, otherwise an IllegalArgumentException will be thrown.

If dataV is null, it is assumed to be a copy of dataH and the keyY, height, and subsampleBitsV parameters are ignored.
Parameters:
  keyX - The array offset of the horizontal resampling kernel center
Parameters:
  keyY - The array offset of the vertical resampling kernel center
Parameters:
  width - the width of a horizontal resampling kernel.
Parameters:
  height - the height of a vertical resampling kernel.

dataH and dataV are required to contain width * 2subsampleBitsH and height * 2subsampleBitsV entries respectively, otherwise an IllegalArgumentException will be thrown.

If dataV is null, it is assumed to be a copy of dataH and the keyY, height, and subsampleBitsV parameters are ignored.
Parameters:
  keyX - The array offset of the horizontal resampling kernel center
Parameters:
  keyY - The array offset of the vertical resampling kernel center
Parameters:
  width - the width of a horizontal resampling kernel.
Parameters:
  height - the height of a vertical resampling kernel.

dataH and dataV are required to contain width * 2subsampleBitsH and height * 2subsampleBitsV entries respectively, otherwise an IllegalArgumentException will be thrown.

If dataV is null, it is assumed to be a copy of dataH and the keyY, height, and subsampleBitsV parameters are ignored.
Parameters:
  keyX - The array offset of the horizontal resampling kernel center
Parameters:
  keyY - The array offset of the vertical resampling kernel center
Parameters:
  width - the width of a horizontal resampling kernel.
Parameters:
  height - the height of a vertical resampling kernel.

dataH and dataV are required to contain width * 2subsampleBitsH and height * 2subsampleBitsV entries respectively, otherwise an IllegalArgumentException will be thrown.

If dataV is null, it is assumed to be a copy of dataH and the keyY, height, and subsampleBitsV parameters are ignored.
Parameters:
  keyX - The array offset of the horizontal resampling kernel center
Parameters:
  keyY - The array offset of the vertical resampling kernel center
Parameters:
  width - the width of a horizontal resampling kernel.
Parameters:
  height - the height of a vertical resampling kernel. Ignoredif dataV is null.
Parameters:
  subsampleBitsH - the log (base 2) of the number of horizontalsubsample positions. Must be positive.
Parameters:
  subsampleBitsV - the log (base 2) of the number of verticalsubsample positions. Must be positive. Ignored if dataV is null.
Parameters:
  precisionBits - the number of bits of fractional precisionto be used when resampling integral sample values. Must be positive.The same value is used for both horizontal and verticalresampling.
Parameters:
  dataH - the horizontal table entries, as an int array of2subsampleBitsH entries each of length width. The array is cloned internally.
Parameters:
  dataV - the vertical table entries, as an int array of2subsampleBitsV entries each of length height, or null. The array is cloned internally.If null, the dataH table is used for vertical interpolationas well and the keyY, height, and subsampleBitsVparameters are ignored.
throws:
  IllegalArgumentException - if the size of the data arraysare incorrect.

dataH and dataV are required to contain width * 2subsampleBitsH and height * 2subsampleBitsV entries respectively, otherwise an IllegalArgumentException will be thrown.

If dataV is null, it is assumed to be a copy of dataH and the keyY, height, and subsampleBitsV parameters are ignored.
Parameters:
  keyX - The array offset of the horizontal resampling kernel center
Parameters:
  keyY - The array offset of the vertical resampling kernel center
Parameters:
  width - the width of a horizontal resampling kernel.
Parameters:
  height - the height of a vertical resampling kernel. Ignoredif dataV is null.
Parameters:
  subsampleBitsH - the log (base 2) of the number of horizontalsubsample positions. Must be positive.
Parameters:
  subsampleBitsV - the log (base 2) of the number of verticalsubsample positions. Must be positive. Ignored if dataV is null.
Parameters:
  precisionBits - the number of bits of fractional precisionto be used when resampling integral sample values.The same value is used for both horizontal and verticalresampling. Must be positive.
Parameters:
  dataH - the horizontal table entries, as a float array of2subsampleBitsH entries each of length width.
Parameters:
  dataV - the vertical table entries, as a float array of2subsampleBitsV entries each of length height, or null.If null, the dataH table is used for vertical interpolationas well and the keyY, height, and subsampleBitsVparameters are ignored.
throws:
  IllegalArgumentException - if the size of the data arraysare incorrect.

dataH and dataV are required to contain width * 2subsampleBitsH and height * 2subsampleBitsV entries respectively, otherwise an IllegalArgumentException will be thrown.

If dataV is null, it is assumed to be a copy of dataH and the keyY, height, and subsampleBitsV parameters are ignored.
Parameters:
  keyX - The array offset of the horizontal resampling kernel center
Parameters:
  keyY - The array offset of the vertical resampling kernel center
Parameters:
  width - the width of a horizontal resampling kernel.
Parameters:
  height - the height of a vertical resampling kernel. Ignoredif dataV is null.
Parameters:
  subsampleBitsH - the log (base 2) of the number of horizontalsubsample positions. Must be positive.
Parameters:
  subsampleBitsV - the log (base 2) of the number of verticalsubsample positions. Must be positive. Ignored if dataV is null.
Parameters:
  precisionBits - the number of bits of fractional precisionto be used when resampling integral sample values.The same value is used for both horizontal and verticalresampling. Must be positive.
Parameters:
  dataH - the horizontal table entries, as a double array of2subsampleBitsH entries each of length width.
Parameters:
  dataV - the vertical table entries, as a double array of2subsampleBitsV entries each of length height, or null.If null, the dataH table is used for vertical interpolationas well and the keyY, height, and subsampleBitsVparameters are ignored.

The following code, given an instance interp of class InterpolationTable, will perform interpolation of a set of getWidth() samples at a given fractional position (bin) xfrac between 0 and 2getSubsampleBitsH() - 1:

 int interpolateH(InterpolationTable interp, int[] samples, int xfrac) {
 int[] dataH = interp.getHorizontalTableData();
 int precisionBits = interp.getPrecisionBits();
 int round = 1 << (precisionBits - 1);
 int width = interp.getWidth();
 int offset = width*xfrac;
 int sum = 0;
 for (int i = 0; i < width; i++) {
 sum += dataH[offset + i]*samples[i];
 }
 return (sum + round) >> precisionBits;
 }
 

In practice, the values dataH, precisionBits, etc., may be extracted once and reused to interpolate multiple output pixels. An array of ints.

The following code, given an instance interp of class InterpolationTable, will perform interpolation of a set of getWidth() double samples at a given fractional position xfrac between 0.0F and 1.0F:

 double interpolateH(InterpolationTable interp,
 double[] samples, float xfrac) {
 double[] dataH = interp.getHorizontalTableDataDouble();
 int width = interp.getWidth();
 int numSubsamplesH = 1 << getSubsampleBitsH();
 int ifrac = (int)(xfrac*numSubsamplesH);
 int offset = width*ifrac;
 double sum = 0.0;
 for (int i = 0; i < width; i++) {
 sum += dataH[offset + i]*samples[i];
 }
 return sum;
 }
 

In practice, the values dataH, numSubsamplesH, etc., may be extracted once and reused to interpolate multiple output pixels. An array of doubles.

The following code, given an instance interp of class InterpolationTable, will perform interpolation of a set of getWidth() floating-point samples at a given fractional position xfrac between 0.0F and 1.0F:

 float interpolateH(InterpolationTable interp,
 float[] samples, float xfrac) {
 float[] dataH = interp.getHorizontalTableDataFloat();
 int width = interp.getWidth();
 int numSubsamplesH = 1 << getSubsampleBitsH();
 int ifrac = (int)(xfrac*numSubsamplesH);
 int offset = width*ifrac;
 float sum = 0.0F;
 for (int i = 0; i < width; i++) {
 sum += dataH[offset + i]*samples[i];
 }
 return sum;
 }
 

In practice, the values dataH, numSubsamplesH, etc., may be extracted once and reused to interpolate multiple output pixels. An array of floats.

The following code, given an instance interp of class InterpolationTable, will perform interpolation of a set of getHeight() samples at a given fractional position (bin) yfrac between 0 and 2getSubsampleBitsV() - 1:

 int interpolateV(InterpolationTable interp, int[] samples, int yfrac) {
 int[] dataV = interp.getVerticalTableData();
 int precisionBits = interp.getPrecisionBits();
 int round = 1 << (precisionBits - 1);
 int height = interp.getHeight();
 int offset = height*yfrac;
 int sum = 0;
 for (int i = 0; i < height; i++) {
 sum += dataV[offset + i]*samples[i];
 }
 return (sum + round) >> precisionBits;
 }
 

In practice, the values dataV, precisionBits, etc., may be extracted once and reused to interpolate multiple output pixels. An array of ints.

The following code, given an instance interp of class InterpolationTable, will perform interpolation of a set of getHeight() double samples at a given fractional position yfrac between 0.0F and 1.0F:

 double interpolateV(InterpolationTable interp,
 double[] samples, float yfrac) {
 double[] dataV = interp.getVerticalTableDataDouble();
 int height = interp.getHeight();
 int numSubsamplesV = 1 << getSubsampleBitsV();
 int ifrac = (int)(yfrac*numSubsamplesV);
 int offset = height*ifrac;
 double sum = 0.0;
 for (int i = 0; i < height; i++) {
 sum += dataV[offset + i]*samples[i];
 }
 return sum;
 }
 

In practice, the values dataV, numSubsamplesV, etc., may be extracted once and reused to interpolate multiple output pixels. An array of doubles.

The following code, given an instance interp of class InterpolationTable, will perform interpolation of a set of getHeight() floating-point samples at a given fractional position yfrac between 0.0F and 1.0F:

 float interpolateV(InterpolationTable interp,
 float[] samples, float yfrac) {
 float[] dataV = interp.getVerticalTableDataFloat();
 int height = interp.getHeight();
 int numSubsamplesV = 1 << getSubsampleBitsV();
 int ifrac = (int)(yfrac*numSubsamplesV);
 int offset = height*ifrac;
 float sum = 0.0F;
 for (int i = 0; i < height; i++) {
 sum += dataV[offset + i]*samples[i];
 }
 return sum;
 }
 

In practice, the values dataV, numSubsamplesV, etc., may be extracted once and reused to interpolate multiple output pixels. An array of floats.