Java KernelJAI.getKernelData方法代码示例

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
    * Creates a Convolve3x3OpImage given a ParameterBlock containing the image
    * source and a pre-rotated convolution kernel.  The image dimensions 
    * are derived
    * from the source image.  The tile grid layout, SampleModel, and
    * ColorModel may optionally be specified by an ImageLayout
    * object.  
    *
    * @param source a RenderedImage.
    * @param extender a BorderExtender, or null.
    * @param layout an ImageLayout optionally containing the tile grid layout,
    *        SampleModel, and ColorModel, or null.
    * @param kernel the pre-rotated convolution KernelJAI.
    * @param cobbleSources a boolean indicating whether computeRect()
    *        expects contiguous sources.
    */
   public Convolve3x3OpImage(RenderedImage source,
                             BorderExtender extender,
                             Map config,
                             ImageLayout layout,
                             KernelJAI kernel) {
super(source,
             layout,
             config,
             true,
             extender,
             kernel.getLeftPadding(),
             kernel.getRightPadding(),
             kernel.getTopPadding(),
             kernel.getBottomPadding());
       
this.kernel = kernel;
if ((kernel.getWidth() != 3) ||
    (kernel.getHeight() != 3) ||
    (kernel.getXOrigin() != 1) ||
    (kernel.getYOrigin() != 1)) {
           throw new RuntimeException(JaiI18N.getString("Convolve3x3OpImage0"));
       }

       if (sampleModel.getDataType() == DataBuffer.TYPE_BYTE) {
           float kdata[] = kernel.getKernelData();
           float k0 = kdata[0],
                 k1 = kdata[1],
                 k2 = kdata[2],
                 k3 = kdata[3],
                 k4 = kdata[4],
                 k5 = kdata[5],
                 k6 = kdata[6],
                 k7 = kdata[7],
                 k8 = kdata[8];
   
           for (int j = 0; j < 256; j++) {
               byte b = (byte)j;
               float f = (float)j;
               tables[0][b+128] = k0*f+0.5f;
               tables[1][b+128] = k1*f;
               tables[2][b+128] = k2*f;
               tables[3][b+128] = k3*f;
               tables[4][b+128] = k4*f;
               tables[5][b+128] = k5*f;
               tables[6][b+128] = k6*f;
               tables[7][b+128] = k7*f;
               tables[8][b+128] = k8*f;
           }
       }
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
    * Creates a DilateOpImage given a ParameterBlock containing the image
    * source and pre-rotated dilation kernel.  The image dimensions are 
    * derived
    * from the source image.  The tile grid layout, SampleModel, and
    * ColorModel may optionally be specified by an ImageLayout
    * object.
    *
    * @param source a RenderedImage.
    * @param extender a BorderExtender, or null.
    * @param layout an ImageLayout optionally containing the tile grid layout,
    *        SampleModel, and ColorModel, or null.
    * @param kernel the pre-rotated dilation KernelJAI.
    */
   public DilateOpImage(RenderedImage source,
                          BorderExtender extender,
                          Map config,
                          ImageLayout layout,
                          KernelJAI kernel) {
super(source,
             layout,
             config,
             true,
             extender,
             kernel.getLeftPadding(),
             kernel.getRightPadding(),
             kernel.getTopPadding(),
             kernel.getBottomPadding());
       
this.kernel = kernel;
kw = kernel.getWidth();
kh = kernel.getHeight();
kx = kernel.getXOrigin();
ky = kernel.getYOrigin();

       kdata = kernel.getKernelData();
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/** pack kernel into integers by row, aligned to the right;
    *  extra bits on the left are filled with 0 bits
    *  @params  kernel - the given kernel (already rotated)
    *  @returns an integer array of ints from packed kernel data
    */
   private final int[] packKernel(KernelJAI kernel){
int kw = kernel.getWidth();
int kh = kernel.getHeight();
       int kwPack = (31+kw)/32;
int kerPacked[] = new int[kwPack * kh];
       float[] kdata = kernel.getKernelData();
for (int j=0; j<kw; j++){
  int m = j;
  int lastCol = kwPack - 1;
  bitShiftMatrixLeft(kerPacked, kh, kwPack);
  for (int i=0; i< kh; i++, lastCol+=kwPack, m+= kw){
    if (kdata[m] > .9F){     	  // same as == 1.0F
       kerPacked[lastCol] |= 0x1;
    }
  }
}
return kerPacked;
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
    * Creates a ErodeOpImage given a ParameterBlock containing the image
    * source and pre-rotated erosion kernel.  The image dimensions are 
    * derived
    * from the source image.  The tile grid layout, SampleModel, and
    * ColorModel may optionally be specified by an ImageLayout
    * object.
    *
    * @param source a RenderedImage.
    * @param extender a BorderExtender, or null.
    * @param layout an ImageLayout optionally containing the tile grid layout,
    *        SampleModel, and ColorModel, or null.
    * @param kernel the pre-rotated erosion KernelJAI.
    */
   public ErodeOpImage(RenderedImage source,
                          BorderExtender extender,
                          Map config,
                          ImageLayout layout,
                          KernelJAI kernel) {
super(source,
             layout,
             config,
             true,
             extender,
             kernel.getLeftPadding(),
             kernel.getRightPadding(),
             kernel.getTopPadding(),
             kernel.getBottomPadding());
       
this.kernel = kernel;
kw = kernel.getWidth();
kh = kernel.getHeight();
kx = kernel.getXOrigin();
ky = kernel.getYOrigin();

       kdata = kernel.getKernelData();
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
     * Given a kernel and the gain (sharpness) factor of an
     * UnsharpMask operation, compute a modified kernel that
     * would be equivalent to the specified unsharp operation.
     *
     * for UnsharpMask function we have the following formula:
     *
     * dst(i,j) = src(i,j) + gain *
     *			(src(i,j) - SUM  SUM  K(l,m) * src(i+l,j+m))
     *				     l    m
     *
     * Which can be written as :
     *
     * dst(i,j) = SUM  SUM  Q(l,m) * src(i+l,j+m),
     *             l    m
     *
     * where Q(0,0) = 1 + gain * (1 - K(0,0)), and
     *	      Q(l,m) = - gain * K(l,m)  otherwise
     *
     * @param kernel the unsharp mask kernel
     * @param gain the unsharp mask gain (sharpness) factor.
     *
     * @return an equivalent convolution KernelJAI
     */
   public static KernelJAI getUnsharpMaskEquivalentKernel(
		    KernelJAI kernel, float gain) {

int width   = kernel.getWidth();
int height  = kernel.getHeight();
int xOrigin = kernel.getXOrigin();
int yOrigin = kernel.getYOrigin();

float oldData[] = kernel.getKernelData();
float newData[] = new float[oldData.length];

int k;

for (k = 0; k < width*height; k++)
    newData[k] = -gain * oldData[k];

k = yOrigin*width + xOrigin;
newData[k] = 1.0f + gain * (1.0f - oldData[k]);

return new KernelJAI(width, height, xOrigin, yOrigin, newData);
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
public void process() throws Exception {
    checkNull(inRaster);

    RegionMap regionMap = CoverageUtilities.getRegionParamsFromGridCoverage(inRaster);
    int cols = regionMap.getCols();
    int rows = regionMap.getRows();

    ValueType type = getKernelType(pKernel);

    KernelJAI kernel = KernelFactory.createCircle(pRadius, type);

    RenderedImage inImg = inRaster.getRenderedImage();
    RandomIter inIter = RandomIterFactory.create(inImg, null);

    WritableRaster outWR = CoverageUtilities.createWritableRaster(cols, rows, null, null, HMConstants.doubleNovalue);
    WritableRandomIter outIter = RandomIterFactory.createWritable(outWR, null);

    float[] kernelData = kernel.getKernelData();
    pm.beginTask("Processing...", cols - 2 * pRadius);
    for( int c = pRadius; c < cols - pRadius; c++ ) {
        for( int r = pRadius; r < rows - pRadius; r++ ) {
            double kernelSum = 0.0;
            int k = 0;
            double outputValue = 0.0;
            for( int kc = -pRadius; kc <= pRadius; kc++ ) {
                for( int kr = -pRadius; kr <= pRadius; kr++, k++ ) {
                    double value = inIter.getSampleDouble(c + kc, r + kr, 0);
                    if (!isNovalue(value)) {
                        outputValue = outputValue + value * kernelData[k];
                        kernelSum = kernelSum + kernelData[k];
                    }
                }
            }
            outIter.setSample(c, r, 0, outputValue / kernelSum);
        }
        pm.worked(1);
    }
    pm.done();

    outRaster = CoverageUtilities.buildCoverage("filtered", outWR, regionMap, inRaster.getCoordinateReferenceSystem());
}