예제 #1
0
        /// <summary>
        /// Performs a convolution on BufferedImages.  Each component of the
        /// source image will be convolved (including the alpha component, if
        /// present).
        /// If the color model in the source image is not the same as that
        /// in the destination image, the pixels will be converted
        /// in the destination.  If the destination image is null,
        /// a BufferedImage will be created with the source ColorModel.
        /// The IllegalArgumentException may be thrown if the source is the
        /// same as the destination. </summary>
        /// <param name="src"> the source <code>BufferedImage</code> to filter </param>
        /// <param name="dst"> the destination <code>BufferedImage</code> for the
        ///        filtered <code>src</code> </param>
        /// <returns> the filtered <code>BufferedImage</code> </returns>
        /// <exception cref="NullPointerException"> if <code>src</code> is <code>null</code> </exception>
        /// <exception cref="IllegalArgumentException"> if <code>src</code> equals
        ///         <code>dst</code> </exception>
        /// <exception cref="ImagingOpException"> if <code>src</code> cannot be filtered </exception>
        public BufferedImage Filter(BufferedImage src, BufferedImage dst)
        {
            if (src == null)
            {
                throw new NullPointerException("src image is null");
            }
            if (src == dst)
            {
                throw new IllegalArgumentException("src image cannot be the " + "same as the dst image");
            }

            bool          needToConvert = false;
            ColorModel    srcCM         = src.ColorModel;
            ColorModel    dstCM;
            BufferedImage origDst = dst;

            // Can't convolve an IndexColorModel.  Need to expand it
            if (srcCM is IndexColorModel)
            {
                IndexColorModel icm = (IndexColorModel)srcCM;
                src   = icm.ConvertToIntDiscrete(src.Raster, false);
                srcCM = src.ColorModel;
            }

            if (dst == null)
            {
                dst     = CreateCompatibleDestImage(src, null);
                dstCM   = srcCM;
                origDst = dst;
            }
            else
            {
                dstCM = dst.ColorModel;
                if (srcCM.ColorSpace.Type != dstCM.ColorSpace.Type)
                {
                    needToConvert = true;
                    dst           = CreateCompatibleDestImage(src, null);
                    dstCM         = dst.ColorModel;
                }
                else if (dstCM is IndexColorModel)
                {
                    dst   = CreateCompatibleDestImage(src, null);
                    dstCM = dst.ColorModel;
                }
            }

            if (ImagingLib.filter(this, src, dst) == null)
            {
                throw new ImagingOpException("Unable to convolve src image");
            }

            if (needToConvert)
            {
                ColorConvertOp ccop = new ColorConvertOp(Hints);
                ccop.Filter(dst, origDst);
            }
            else if (origDst != dst)
            {
                java.awt.Graphics2D g = origDst.CreateGraphics();
                try
                {
                    g.DrawImage(dst, 0, 0, null);
                }
                finally
                {
                    g.Dispose();
                }
            }

            return(origDst);
        }
예제 #2
0
        /// <summary>
        /// Transforms the source <CODE>BufferedImage</CODE> and stores the results
        /// in the destination <CODE>BufferedImage</CODE>.
        /// If the color models for the two images do not match, a color
        /// conversion into the destination color model is performed.
        /// If the destination image is null,
        /// a <CODE>BufferedImage</CODE> is created with the source
        /// <CODE>ColorModel</CODE>.
        /// <para>
        /// The coordinates of the rectangle returned by
        /// <code>getBounds2D(BufferedImage)</code>
        /// are not necessarily the same as the coordinates of the
        /// <code>BufferedImage</code> returned by this method.  If the
        /// upper-left corner coordinates of the rectangle are
        /// negative then this part of the rectangle is not drawn.  If the
        /// upper-left corner coordinates of the  rectangle are positive
        /// then the filtered image is drawn at that position in the
        /// destination <code>BufferedImage</code>.
        /// </para>
        /// <para>
        /// An <CODE>IllegalArgumentException</CODE> is thrown if the source is
        /// the same as the destination.
        ///
        /// </para>
        /// </summary>
        /// <param name="src"> The <CODE>BufferedImage</CODE> to transform. </param>
        /// <param name="dst"> The <CODE>BufferedImage</CODE> in which to store the results
        /// of the transformation.
        /// </param>
        /// <returns> The filtered <CODE>BufferedImage</CODE>. </returns>
        /// <exception cref="IllegalArgumentException"> if <code>src</code> and
        ///         <code>dst</code> are the same </exception>
        /// <exception cref="ImagingOpException"> if the image cannot be transformed
        ///         because of a data-processing error that might be
        ///         caused by an invalid image format, tile format, or
        ///         image-processing operation, or any other unsupported
        ///         operation. </exception>
        public BufferedImage Filter(BufferedImage src, BufferedImage dst)
        {
            if (src == null)
            {
                throw new NullPointerException("src image is null");
            }
            if (src == dst)
            {
                throw new IllegalArgumentException("src image cannot be the " + "same as the dst image");
            }

            bool          needToConvert = false;
            ColorModel    srcCM         = src.ColorModel;
            ColorModel    dstCM;
            BufferedImage origDst = dst;

            if (dst == null)
            {
                dst     = CreateCompatibleDestImage(src, null);
                dstCM   = srcCM;
                origDst = dst;
            }
            else
            {
                dstCM = dst.ColorModel;
                if (srcCM.ColorSpace.Type != dstCM.ColorSpace.Type)
                {
                    int  type      = Xform.Type;
                    bool needTrans = ((type & (Xform.TYPE_MASK_ROTATION | Xform.TYPE_GENERAL_TRANSFORM)) != 0);
                    if (!needTrans && type != Xform.TYPE_TRANSLATION && type != Xform.TYPE_IDENTITY)
                    {
                        double[] mtx = new double[4];
                        Xform.GetMatrix(mtx);
                        // Check out the matrix.  A non-integral scale will force ARGB
                        // since the edge conditions can't be guaranteed.
                        needTrans = (mtx[0] != (int)mtx[0] || mtx[3] != (int)mtx[3]);
                    }

                    if (needTrans && srcCM.Transparency == java.awt.Transparency_Fields.OPAQUE)
                    {
                        // Need to convert first
                        ColorConvertOp ccop   = new ColorConvertOp(Hints);
                        BufferedImage  tmpSrc = null;
                        int            sw     = src.Width;
                        int            sh     = src.Height;
                        if (dstCM.Transparency == java.awt.Transparency_Fields.OPAQUE)
                        {
                            tmpSrc = new BufferedImage(sw, sh, BufferedImage.TYPE_INT_ARGB);
                        }
                        else
                        {
                            WritableRaster r = dstCM.CreateCompatibleWritableRaster(sw, sh);
                            tmpSrc = new BufferedImage(dstCM, r, dstCM.AlphaPremultiplied, null);
                        }
                        src = ccop.Filter(src, tmpSrc);
                    }
                    else
                    {
                        needToConvert = true;
                        dst           = CreateCompatibleDestImage(src, null);
                    }
                }
            }

            if (InterpolationType_Renamed != TYPE_NEAREST_NEIGHBOR && dst.ColorModel is IndexColorModel)
            {
                dst = new BufferedImage(dst.Width, dst.Height, BufferedImage.TYPE_INT_ARGB);
            }
            if (ImagingLib.filter(this, src, dst) == null)
            {
                throw new ImagingOpException("Unable to transform src image");
            }

            if (needToConvert)
            {
                ColorConvertOp ccop = new ColorConvertOp(Hints);
                ccop.Filter(dst, origDst);
            }
            else if (origDst != dst)
            {
                java.awt.Graphics2D g = origDst.CreateGraphics();
                try
                {
                    g.Composite = AlphaComposite.Src;
                    g.DrawImage(dst, 0, 0, null);
                }
                finally
                {
                    g.Dispose();
                }
            }

            return(origDst);
        }
예제 #3
0
        /// <summary>
        /// Performs a lookup operation on a <code>BufferedImage</code>.
        /// If the color model in the source image is not the same as that
        /// in the destination image, the pixels will be converted
        /// in the destination.  If the destination image is <code>null</code>,
        /// a <code>BufferedImage</code> will be created with an appropriate
        /// <code>ColorModel</code>.  An <code>IllegalArgumentException</code>
        /// might be thrown if the number of arrays in the
        /// <code>LookupTable</code> does not meet the restrictions
        /// stated in the class comment above, or if the source image
        /// has an <code>IndexColorModel</code>. </summary>
        /// <param name="src"> the <code>BufferedImage</code> to be filtered </param>
        /// <param name="dst"> the <code>BufferedImage</code> in which to
        ///            store the results of the filter operation </param>
        /// <returns> the filtered <code>BufferedImage</code>. </returns>
        /// <exception cref="IllegalArgumentException"> if the number of arrays in the
        ///         <code>LookupTable</code> does not meet the restrictions
        ///         described in the class comments, or if the source image
        ///         has an <code>IndexColorModel</code>. </exception>
        public BufferedImage Filter(BufferedImage src, BufferedImage dst)
        {
            ColorModel srcCM    = src.ColorModel;
            int        numBands = srcCM.NumColorComponents;
            ColorModel dstCM;

            if (srcCM is IndexColorModel)
            {
                throw new IllegalArgumentException("LookupOp cannot be " + "performed on an indexed image");
            }
            int numComponents = Ltable.NumComponents;

            if (numComponents != 1 && numComponents != srcCM.NumComponents && numComponents != srcCM.NumColorComponents)
            {
                throw new IllegalArgumentException("Number of arrays in the " + " lookup table (" + numComponents + " is not compatible with the " + " src image: " + src);
            }


            bool needToConvert = false;

            int width  = src.Width;
            int height = src.Height;

            if (dst == null)
            {
                dst   = CreateCompatibleDestImage(src, null);
                dstCM = srcCM;
            }
            else
            {
                if (width != dst.Width)
                {
                    throw new IllegalArgumentException("Src width (" + width + ") not equal to dst width (" + dst.Width + ")");
                }
                if (height != dst.Height)
                {
                    throw new IllegalArgumentException("Src height (" + height + ") not equal to dst height (" + dst.Height + ")");
                }

                dstCM = dst.ColorModel;
                if (srcCM.ColorSpace.Type != dstCM.ColorSpace.Type)
                {
                    needToConvert = true;
                    dst           = CreateCompatibleDestImage(src, null);
                }
            }

            BufferedImage origDst = dst;

            if (ImagingLib.filter(this, src, dst) == null)
            {
                // Do it the slow way
                WritableRaster srcRaster = src.Raster;
                WritableRaster dstRaster = dst.Raster;

                if (srcCM.HasAlpha())
                {
                    if (numBands - 1 == numComponents || numComponents == 1)
                    {
                        int   minx  = srcRaster.MinX;
                        int   miny  = srcRaster.MinY;
                        int[] bands = new int[numBands - 1];
                        for (int i = 0; i < numBands - 1; i++)
                        {
                            bands[i] = i;
                        }
                        srcRaster = srcRaster.CreateWritableChild(minx, miny, srcRaster.Width, srcRaster.Height, minx, miny, bands);
                    }
                }
                if (dstCM.HasAlpha())
                {
                    int dstNumBands = dstRaster.NumBands;
                    if (dstNumBands - 1 == numComponents || numComponents == 1)
                    {
                        int   minx  = dstRaster.MinX;
                        int   miny  = dstRaster.MinY;
                        int[] bands = new int[numBands - 1];
                        for (int i = 0; i < numBands - 1; i++)
                        {
                            bands[i] = i;
                        }
                        dstRaster = dstRaster.CreateWritableChild(minx, miny, dstRaster.Width, dstRaster.Height, minx, miny, bands);
                    }
                }

                Filter(srcRaster, dstRaster);
            }

            if (needToConvert)
            {
                // ColorModels are not the same
                ColorConvertOp ccop = new ColorConvertOp(Hints);
                ccop.Filter(dst, origDst);
            }

            return(origDst);
        }
예제 #4
0
        /// <summary>
        /// Rescales the source BufferedImage.
        /// If the color model in the source image is not the same as that
        /// in the destination image, the pixels will be converted
        /// in the destination.  If the destination image is null,
        /// a BufferedImage will be created with the source ColorModel.
        /// An IllegalArgumentException may be thrown if the number of
        /// scaling factors/offsets in this object does not meet the
        /// restrictions stated in the class comments above, or if the
        /// source image has an IndexColorModel. </summary>
        /// <param name="src"> the <code>BufferedImage</code> to be filtered </param>
        /// <param name="dst"> the destination for the filtering operation
        ///            or <code>null</code> </param>
        /// <returns> the filtered <code>BufferedImage</code>. </returns>
        /// <exception cref="IllegalArgumentException"> if the <code>ColorModel</code>
        ///         of <code>src</code> is an <code>IndexColorModel</code>,
        ///         or if the number of scaling factors and offsets in this
        ///         <code>RescaleOp</code> do not meet the requirements
        ///         stated in the class comments. </exception>
        public BufferedImage Filter(BufferedImage src, BufferedImage dst)
        {
            ColorModel srcCM = src.ColorModel;
            ColorModel dstCM;
            int        numBands = srcCM.NumColorComponents;


            if (srcCM is IndexColorModel)
            {
                throw new IllegalArgumentException("Rescaling cannot be " + "performed on an indexed image");
            }
            if (Length != 1 && Length != numBands && Length != srcCM.NumComponents)
            {
                throw new IllegalArgumentException("Number of scaling constants " + "does not equal the number of" + " of color or color/alpha " + " components");
            }

            bool needToConvert = false;

            // Include alpha
            if (Length > numBands && srcCM.HasAlpha())
            {
                Length = numBands + 1;
            }

            int width  = src.Width;
            int height = src.Height;

            if (dst == null)
            {
                dst   = CreateCompatibleDestImage(src, null);
                dstCM = srcCM;
            }
            else
            {
                if (width != dst.Width)
                {
                    throw new IllegalArgumentException("Src width (" + width + ") not equal to dst width (" + dst.Width + ")");
                }
                if (height != dst.Height)
                {
                    throw new IllegalArgumentException("Src height (" + height + ") not equal to dst height (" + dst.Height + ")");
                }

                dstCM = dst.ColorModel;
                if (srcCM.ColorSpace.Type != dstCM.ColorSpace.Type)
                {
                    needToConvert = true;
                    dst           = CreateCompatibleDestImage(src, null);
                }
            }

            BufferedImage origDst = dst;

            //
            // Try to use a native BI rescale operation first
            //
            if (ImagingLib.filter(this, src, dst) == null)
            {
                //
                // Native BI rescale failed - convert to rasters
                //
                WritableRaster srcRaster = src.Raster;
                WritableRaster dstRaster = dst.Raster;

                if (srcCM.HasAlpha())
                {
                    if (numBands - 1 == Length || Length == 1)
                    {
                        int   minx  = srcRaster.MinX;
                        int   miny  = srcRaster.MinY;
                        int[] bands = new int[numBands - 1];
                        for (int i = 0; i < numBands - 1; i++)
                        {
                            bands[i] = i;
                        }
                        srcRaster = srcRaster.CreateWritableChild(minx, miny, srcRaster.Width, srcRaster.Height, minx, miny, bands);
                    }
                }
                if (dstCM.HasAlpha())
                {
                    int dstNumBands = dstRaster.NumBands;
                    if (dstNumBands - 1 == Length || Length == 1)
                    {
                        int   minx  = dstRaster.MinX;
                        int   miny  = dstRaster.MinY;
                        int[] bands = new int[numBands - 1];
                        for (int i = 0; i < numBands - 1; i++)
                        {
                            bands[i] = i;
                        }
                        dstRaster = dstRaster.CreateWritableChild(minx, miny, dstRaster.Width, dstRaster.Height, minx, miny, bands);
                    }
                }

                //
                // Call the raster filter method
                //
                Filter(srcRaster, dstRaster);
            }

            if (needToConvert)
            {
                // ColorModels are not the same
                ColorConvertOp ccop = new ColorConvertOp(Hints);
                ccop.Filter(dst, origDst);
            }

            return(origDst);
        }