Java KernelJAI.getXOrigin方法代码示例

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包/类
/**
 * Determines whether a kernel is the Floyd-Steinberg kernel.
 *
 * @param kernel The <code>KernelJAI</code> to examine.
 * @return Whether the kernel argument is the Floyd-Steinberg kernel.
 */
private static boolean isFloydSteinbergKernel(KernelJAI kernel) {
    int ky = kernel.getYOrigin();

    return (kernel.getWidth() == 3 &&
            kernel.getXOrigin() == 1 &&
            kernel.getHeight() - ky == 2 &&
            Math.abs(kernel.getElement(2, ky) - 7.0F/16.0F) <
            FLOAT_EPSILON &&
            Math.abs(kernel.getElement(0, ky+1) - 3.0F/16.0F) <
            FLOAT_EPSILON &&
            Math.abs(kernel.getElement(1, ky+1) - 5.0F/16.0F) <
            FLOAT_EPSILON &&
            Math.abs(kernel.getElement(2, ky+1) - 1.0F/16.0F) <
            FLOAT_EPSILON);
}
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
    * Creates a DilateBinaryOpImage 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 DilateBinaryOpImage(RenderedImage source,
		       BorderExtender extender,
		       Map config,
		       ImageLayout layout,
		       KernelJAI kernel) {
super(source,
             layout,
             configHelper(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();

kwPack = (kw+31)/32;
kdataPack  = packKernel(kernel);
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
    * Creates a ConvolveOpImage given a ParameterBlock containing the image
    * source and 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.
    */
   public ConvolveOpImage(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();
   }
 

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包/类
/**
    * Creates a ErodeBinaryOpImage 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 ErodeBinaryOpImage(RenderedImage source,
                          BorderExtender extender,
                          Map config,
                          ImageLayout layout,
                          KernelJAI kernel) {
super(source,
             layout,
             configHelper(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();

kwPack = (kw+31)/32;
kdataPack  = packKernel(kernel);   
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
 * Creates a SeparableConvoveOpImage on the source 
 * with the given pre-rotated kernel.  The image dimensions are
 * derived  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 a pre-rotated convolution kernel
 */
public SeparableConvolveOpImage(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();
    hValues = kernel.getHorizontalKernelData();
    vValues = kernel.getVerticalKernelData();

    if (sampleModel.getDataType() == DataBuffer.TYPE_BYTE) {
        hTables = new float[hValues.length][256];
        for (int i = 0; i < hValues.length; i++) {
            float k = hValues[i];
            for (int j = 0; j < 256; j++) {
                byte b = (byte)j;
                float f = (float)j;
                hTables[i][b+128] = k*f;
            }
        }
    }
}
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
    * Create a new instance of UnsharpMaskOpImage in the rendered layer.
    * This method satisfies the implementation of RIF.
    *
    * @param paramBlock  The source image, the unsharp mask kernel and
    *			  the gain factor.
    */
   public RenderedImage create(ParameterBlock paramBlock,
                               RenderingHints renderHints) {
       // Get ImageLayout from renderHints if any.
       ImageLayout layout = RIFUtil.getImageLayoutHint(renderHints);
       

       // Get BorderExtender from renderHints if any.
       BorderExtender extender = RIFUtil.getBorderExtenderHint(renderHints);

// map the input kernel + gain factor to an equivalent
// convolution kernel and then do a normal convolve.
KernelJAI unRotatedKernel =
	ImageUtil.getUnsharpMaskEquivalentKernel(
		(KernelJAI)paramBlock.getObjectParameter(0),
		paramBlock.getFloatParameter(1));

       KernelJAI kJAI = unRotatedKernel.getRotatedKernel();

RenderedImage source = paramBlock.getRenderedSource(0);
       int dataType = source.getSampleModel().getDataType();

       boolean dataTypeOk = (dataType == DataBuffer.TYPE_BYTE  ||
                             dataType == DataBuffer.TYPE_SHORT ||
                             dataType == DataBuffer.TYPE_INT);

       if ((kJAI.getWidth()   == 3) && (kJAI.getHeight()  == 3) &&
           (kJAI.getXOrigin() == 1) && (kJAI.getYOrigin() == 1) && dataTypeOk) {
           return new Convolve3x3OpImage(source,
                                         extender,
                                         renderHints,
                                         layout,
                                         kJAI);
       } else if (kJAI.isSeparable()) {
          return new SeparableConvolveOpImage(source,
                                              extender,
                                              renderHints,
                                              layout,
                                              kJAI);

       } else {
           return new ConvolveOpImage(source,
                                      extender,
                                      renderHints,
                                      layout,
                                      kJAI);
       }
   }
 

import javax.media.jai.KernelJAI; //导入方法依赖的package包/类
/**
 * Create a new instance of ConvolveOpImage in the rendered layer.
 * This method satisfies the implementation of RIF.
 *
 * @param paramBlock  The source image and the convolution kernel.
 */
public RenderedImage create(ParameterBlock paramBlock,
                            RenderingHints renderHints) {
    // Get ImageLayout from renderHints if any.
    ImageLayout layout = RIFUtil.getImageLayoutHint(renderHints);
    

    // Get BorderExtender from renderHints if any.
    BorderExtender extender = RIFUtil.getBorderExtenderHint(renderHints);

    KernelJAI unRotatedKernel = 
        (KernelJAI)paramBlock.getObjectParameter(0);
    KernelJAI kJAI = unRotatedKernel.getRotatedKernel();

    int dataType = 
       paramBlock.getRenderedSource(0).getSampleModel().getDataType();
    boolean dataTypeOk = (dataType == DataBuffer.TYPE_BYTE ||
                          dataType == DataBuffer.TYPE_SHORT ||
                          dataType == DataBuffer.TYPE_INT);

    if (kJAI.getWidth() == 3 && kJAI.getHeight() == 3 &&
        kJAI.getXOrigin() == 1 && kJAI.getYOrigin() == 1 &&
        dataTypeOk) {
        return new Convolve3x3OpImage(paramBlock.getRenderedSource(0),
                                      extender,
                                      renderHints,
                                      layout,
                                      kJAI);
    } else if (kJAI.isSeparable()) {
       return new SeparableConvolveOpImage(paramBlock.getRenderedSource(0),
                                           extender,
                                           renderHints,
                                           layout,
                                           kJAI);

    } else {
        return new ConvolveOpImage(paramBlock.getRenderedSource(0),
                                   extender,
                                   renderHints,
                                   layout,
                                   kJAI);
    }
}
 

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);
   }