java 程序中如何分割图片和对图片其他操作

最新推荐文章于 2022-04-18 17:07:11 发布

lzj0470

最新推荐文章于 2022-04-18 17:07:11 发布

阅读量257

点赞数

分类专栏： java 文章标签： Java IIS C C++ C#

本文链接：https://blog.csdn.net/lzj0470/article/details/83437517

版权

java 专栏收录该内容

116 篇文章 0 订阅

订阅专栏

package com.langhua.cutFile;   
import java.io.*;      
import java.awt.*;      
import java.awt.image.*;      
import java.awt.Graphics;      
import java.awt.color.ColorSpace;      
import javax.imageio.ImageIO;      
  
import com.langhua.ImageUtils.ImageUtils;   
     
public class ChangeImageSize      
{      
    /** *//**    
     * 缩放图像    
     * @param srcImageFile 源图像文件地址    
     * @param result       缩放后的图像地址    
     * @param scale        缩放比例    
     * @param flag         缩放选择:true 放大; false 缩小;    
     */     
    public static void scale(String srcImageFile, String result, int scale, boolean flag)      
    {      
        try     
        {      
            BufferedImage src = ImageIO.read(new File(srcImageFile)); // 读入文件      
            int width = src.getWidth(); // 得到源图宽      
            int height = src.getHeight(); // 得到源图长      
            if (flag)      
            {      
                // 放大      
                width = width * scale;      
                height = height * scale;      
            }      
            else     
            {      
                // 缩小      
                width = width / scale;      
                height = height / scale;      
            }      
            Image image = src.getScaledInstance(width, height, Image.SCALE_DEFAULT);      
            BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);      
            Graphics g = tag.getGraphics();      
            g.drawImage(image, 0, 0, null); // 绘制缩小后的图      
            g.dispose();      
            ImageIO.write(tag, "JPEG", new File(result));// 输出到文件流      
        }      
        catch (IOException e)      
        {      
            e.printStackTrace();      
        }      
    }      
     
    /**  
     * 图像切割    
     * @param srcImageFile 源图像地址    
     * @param descDir      切片目标文件夹    
     * @param destWidth    目标切片宽度    
     * @param destHeight   目标切片高度    
     */     
    public static void cut(String srcImageFile, String descDir, int destWidth, int destHeight)      
    {      
        try     
        {      
            Image img;      
            ImageFilter cropFilter;    
            String dir = null;   
            // 读取源图像      
            BufferedImage bi = ImageIO.read(new File(srcImageFile));      
            int srcWidth = bi.getHeight(); // 源图宽度      
            int srcHeight = bi.getWidth(); // 源图高度   
            System.out.println("srcWidth:"+srcWidth);   
            System.out.println("srcHeight:"+srcHeight);   
            if (srcWidth > destWidth && srcHeight > destHeight)      
            {      
                Image image = bi.getScaledInstance(srcWidth, srcHeight, Image.SCALE_DEFAULT);      
                destWidth = 300; // 切片宽度      
                destHeight = 300; // 切片高度      
                int cols = 0; // 切片横向数量      
                int rows = 0; // 切片纵向数量      
                // 计算切片的横向和纵向数量      
                if (srcWidth % destWidth == 0)      
                {      
                    cols = srcWidth / destWidth;      
                }      
                else     
                {      
                    cols = (int) Math.floor(srcWidth / destWidth) + 1;      
                }      
                if (srcHeight % destHeight == 0)      
                {      
                    rows = srcHeight / destHeight;      
                }      
                else     
                {      
                    rows = (int) Math.floor(srcHeight / destHeight) + 1;      
                }      
                // 循环建立切片                  
                for (int i = 0; i < rows; i++)      
                {      
                    for (int j = 0; j < cols; j++)      
                    {      
                        // 四个参数分别为图像起点坐标和宽高      
                        // 即: CropImageFilter(int x,int y,int width,int height)      
                        cropFilter = new CropImageFilter(j * 300, i * 300, destWidth, destHeight);      
                        img = Toolkit.getDefaultToolkit().createImage(      
                                        new FilteredImageSource(image.getSource(), cropFilter));      
                        BufferedImage tag = new BufferedImage(destWidth, destHeight, BufferedImage.TYPE_INT_RGB);      
                        Graphics g = tag.getGraphics();      
                        g.drawImage(img, 0, 0, null); // 绘制缩小后的图      
                        g.dispose();      
                        // 输出为文件     
                        dir = descDir + "cut_image_" + i + "_" + j + ".jpg";   
                        File f = new File(dir);   
                        ImageIO.write(tag, "JPEG",f);   
                        System.out.println(dir);   
                        ImageUtils.pressText("水印",dir,"宋体",1,1,25,10,10);   
                    }      
                }      
            }      
        }      
        catch (Exception e)      
        {      
            e.printStackTrace();      
        }      
    }      
     
    /**   
     * 图像类型转换 GIF->JPG GIF->PNG PNG->JPG PNG->GIF(X)    
     */     
    public static void convert(String source, String result)      
    {      
        try     
        {      
            File f = new File(source);      
            f.canRead();      
            f.canWrite();      
            BufferedImage src = ImageIO.read(f);      
            ImageIO.write(src, "JPG", new File(result));      
        }      
        catch (Exception e)      
        {      
            // TODO Auto-generated catch block      
            e.printStackTrace();      
        }      
    }      
     
    /**  
     * 彩色转为黑白    
     * @param source    
     * @param result    
     */     
    public static void gray(String source, String result)      
    {      
        try     
        {      
            BufferedImage src = ImageIO.read(new File(source));      
            ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);      
            ColorConvertOp op = new ColorConvertOp(cs, null);      
            src = op.filter(src, null);      
            ImageIO.write(src, "JPEG", new File(result));      
        }      
        catch (IOException e)      
        {      
            e.printStackTrace();      
        }      
    }      
     
    /**  
     * @param args    
     */     
    public static void main(String[] args)      
    {      
        //scale("c:\\test\\456.jpg","C:\\test\\image1.jpg",2,false);      
        //cut("c:\\1.jpg","C:\\2.jpg",64,64);      
        //gray("c:\\test\\456.jpg","C:\\test\\image4.jpg");      
    }      
     
}

优化后的图像分割

package com.langhua.cutFile;   
  
import java.awt.Rectangle;   
import java.awt.image.BufferedImage;   
import java.io.File;   
import java.io.FileInputStream;   
import java.io.IOException;   
import java.util.Iterator;   
  
import javax.imageio.ImageIO;   
import javax.imageio.ImageReadParam;   
import javax.imageio.ImageReader;   
import javax.imageio.stream.ImageInputStream;   
  
import com.langhua.ImageUtils.ImageUtils;   
  
public class CutImage {   
  
    // 源图片路径名称如:c:\1.jpg   
    private String srcpath;   
  
    // 剪切图片存放路径名称.如:c:\2.jpg   
    private String subpath;   
  
    // 剪切点x坐标   
    private int x;   
  
    private int y;   
  
    // 剪切点宽度   
    private int width;   
  
    private int height;   
  
    public CutImage() {   
  
    }   
  
    public CutImage(int x, int y, int width, int height) {   
        this.x = x;   
        this.y = y;   
        this.width = width;   
        this.height = height;   
    }   
  
    /**  
     * 对图片裁剪，并把裁剪完蛋新图片保存 。  
     */  
    public void cut() throws IOException {   
  
        FileInputStream is = null;   
        ImageInputStream iis = null;   
  
        try {   
            // 读取图片文件   
            is = new FileInputStream(srcpath);   
  
            /**  
             * 返回包含所有当前已注册 ImageReader 的 Iterator，这些 ImageReader 声称能够解码指定格式。  
             * 参数：formatName - 包含非正式格式名称 . （例如 "jpeg" 或 "tiff"）等 。  
             */  
            Iterator<ImageReader> it = ImageIO   
                    .getImageReadersByFormatName("jpg");   
            ImageReader reader = it.next();   
            // 获取图片流   
            iis = ImageIO.createImageInputStream(is);   
  
            /**  
             * iis:读取源.true:只向前搜索.将它标记为 ‘只向前搜索’。 此设置意味着包含在输入源中的图像将只按顺序读取，可能允许  
             * reader 避免缓存包含与以前已经读取的图像关联的数据的那些输入部分。  
             */  
            reader.setInput(iis, true);   
  
            /**  
             * <p>  
             * 描述如何对流进行解码的类  
             * <p>  
             * .用于指定如何在输入时从 Java Image I/O 框架的上下文中的流转换一幅图像或一组图像。用于特定图像格式的插件 将从其  
             * ImageReader 实现的 getDefaultReadParam 方法中返回 ImageReadParam 的实例。  
             */  
            ImageReadParam param = reader.getDefaultReadParam();   
  
            /**  
             * 图片裁剪区域。Rectangle 指定了坐标空间中的一个区域，通过 Rectangle 对象  
             * 的左上顶点的坐标（x，y）、宽度和高度可以定义这个区域。  
             */  
            Rectangle rect = new Rectangle(x, y, width, height);   
  
            // 提供一个 BufferedImage，将其用作解码像素数据的目标。   
            param.setSourceRegion(rect);   
  
            /**  
             * 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象，并将 它作为一个完整的  
             * BufferedImage 返回。  
             */  
            BufferedImage bi = reader.read(0, param);   
  
            // 保存新图片   
            ImageIO.write(bi, "jpg", new File(subpath));   
        } finally {   
            if (is != null)   
                is.close();   
            if (iis != null)   
                iis.close();   
        }   
    }   
  
    /**  
     * 图像切割  
     *   
     * @param srcImageFile  
     *            源图像地址  
     * @param descDir  
     *            切片目标文件夹  
     * @param destWidth  
     *            目标切片宽度  
     * @param destHeight  
     *            目标切片高度 返回一个List,保存九张图片的图片名  
     */  
    public static java.util.List<String> cutImg(String srcImageFile,   
            String descDir, int destWidth, int destHeight) {   
        java.util.List<String> list = new java.util.ArrayList<String>(9);   
        try {   
            String dir = null;   
            // 读取源图像   
            BufferedImage bi = ImageIO.read(new File(srcImageFile));   
            int srcWidth = bi.getHeight(); // 源图宽度   
            int srcHeight = bi.getWidth(); // 源图高度   
            if (srcWidth > destWidth && srcHeight > destHeight) {   
                destWidth = 300; // 切片宽度   
                destHeight = 300; // 切片高度   
                int cols = 0; // 切片横向数量   
                int rows = 0; // 切片纵向数量   
  
                // 计算切片的横向和纵向数量   
                if (srcWidth % destWidth == 0) {   
                    cols = srcWidth / destWidth;   
                } else {   
                    cols = (int) Math.floor(srcWidth / destWidth) + 1;   
                }   
                if (srcHeight % destHeight == 0) {   
                    rows = srcHeight / destHeight;   
                } else {   
                    rows = (int) Math.floor(srcHeight / destHeight) + 1;   
                }   
                // 循环建立切片   
                for (int i = 0; i < rows; i++) {   
                    for (int j = 0; j < cols; j++) {   
                        CutImage cutImage = new CutImage(j * 300, i * 300, 300,   
                                300);   
                        cutImage.setSrcpath(srcImageFile);   
                        dir = descDir + "cut_image_" + i + "_" + j + ".jpg";   
                        cutImage.setSubpath(dir);   
                        cutImage.cut();   
                        list.add("cut_image_" + i + "_" + j + ".jpg");   
                        ImageUtils.pressText("水印", dir, "宋体", 1, 1, 25, 10, 10);   
                    }   
                }   
            }   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
        return list;   
    }   
  
    public int getHeight() {   
        return height;   
    }   
  
    public void setHeight(int height) {   
        this.height = height;   
    }   
  
    public String getSrcpath() {   
        return srcpath;   
    }   
  
    public void setSrcpath(String srcpath) {   
        this.srcpath = srcpath;   
    }   
  
    public String getSubpath() {   
        return subpath;   
    }   
  
    public void setSubpath(String subpath) {   
        this.subpath = subpath;   
    }   
  
    public int getWidth() {   
        return width;   
    }   
  
    public void setWidth(int width) {   
        this.width = width;   
    }   
  
    public int getX() {   
        return x;   
    }   
  
    public void setX(int x) {   
        this.x = x;   
    }   
  
    public int getY() {   
        return y;   
    }   
  
    public void setY(int y) {   
        this.y = y;   
    }   
}