`
低调衬着那一抹妖娆
  • 浏览: 30810 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

Java 图片分割处理

阅读更多
    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);          
                        }        
                    }        
                }        
            }        
            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");         
                    }     
                }     
            }     
        } 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;     
    }     
}

 

分享到:
评论

相关推荐

    java 水印 图像处理 图片分割 裁剪 缩放

    3. **图片分割**:在图像处理中,图片分割是将图像分成多个有意义的区域或对象的过程。这可能涉及到阈值分割、边缘检测(如Canny算法)或区域生长算法。Java库如OpenCV提供了这些功能,使得开发者能够进行复杂的图像...

    基于java的图像分割(数字图像处理)

    本项目是基于Java实现的图像分割算法,涉及到的知识点广泛,包括全局阈值分割、Roberts边缘检测以及灰度图像处理和直方图分析。 1. **全局阈值分割**: 全局阈值分割是一种简单的二值化方法,它通过设定一个全局...

    java 图片 切割 保存

    3. **切割图片** 使用`getSubimage()`方法从原始图片中获取子图像。假设我们有一个缩放因子,我们可能需要先按比例缩小图片,然后切割。 ```java int scaledWidth = (int) (image.getWidth() * scaleFactor); ...

    java 切割图片 可预览,完整效果

    在Java编程语言中,处理图片上传并进行剪切是一项常见的任务,尤其在Web应用或图形处理软件中。本文将深入探讨如何使用Java实现这个功能,包括图片上传、预览以及剪切的完整流程。 首先,我们需要理解图片上传的...

    java javascript 图片切割

    **Java图片切割** Java作为一个强大的后端开发语言,其丰富的库资源使得图片处理变得非常方便。核心的Java API提供了对图像处理的基本支持,如`java.awt.image.BufferedImage`类可以用于读取、创建和操作图像。在...

    java ocr 图片解析

    综上所述,实现Java OCR图片解析涉及多个步骤,从图像处理到字符识别,再到结果后处理,都需要深入理解相关技术和工具。通过不断优化,我们可以构建出高效、准确的OCR系统,满足各种应用场景的需求。

    Jquery+java图片切割 滤镜功能

    开发者可以利用`drawImage()`方法和`clip()`函数,设置裁剪区域,然后绘制到新的画布上,从而达到切割图片的效果。同时,Jquery的API使得这些操作更加便捷,减少了代码量,提高了开发效率。 其次,滤镜功能是指在...

    java图片处理工具类

    ### Java 图片处理工具类详解 #### 一、概述 在Java开发中,对图片进行处理是一项常见的需求,比如在Web应用中,我们可能需要对用户上传的图片进行压缩、裁剪、添加水印等操作。`ImageUtils`类正是为了解决这类...

    java 头像截图 java切割图片

    在Java编程语言中,处理图像任务,如截图和切割图片,是常见的需求,尤其是在开发Web应用或社交平台时,例如用户头像的处理。本文将详细介绍如何使用Java进行头像截图和图片切割。 首先,Java提供了`java.awt.image...

    java线程图片切割与处理

    Java线程图片切割与处理涉及Java图像处理技术,利用Java的多线程功能来实现图像的并发操作。在Java中,图像处理主要依赖于`java.awt`包中的`Image`类,这是一个抽象类,提供了处理图像的基本方法。通过`Applet`类或`...

    Java图片处理

    通过以上几个示例,我们可以看到 Java 提供了丰富的 API 来处理各种图片操作,包括缩放、切割、格式转换以及彩色转黑白等。这些功能不仅能够满足基本的需求,还提供了很多扩展的可能性,使得 Java 成为了处理图像的...

    Java图片处理解决方案:ImageMagick快速入门教程.docx

    Java 图片处理解决方案中,ImageMagick 是一个免费的创建、编辑、合成图片的软件,可以实现图片切割、颜色替换、图片缩略图、图片水印等各种效果。ImageMagick 是免费开源软件,支持大多数操作系统,包括 Linux、...

    java源码-基于图像处理的车牌识别源码.zip

    在本项目中,我们主要探讨的是一个基于Java语言的图像处理技术,用于实现对国内车牌号码的自动识别系统。这个源码库提供了完整的程序代码,旨在帮助开发者理解并实现车牌识别的核心算法。以下是对该技术及其相关知识...

    图片缩放、压缩技术java实现

    Java提供了多种库来处理图片压缩,如Apache Commons Imaging(旧称Sanselan)和ImageMagick的Java绑定。其中,Java Advanced Imaging (JAI) 是Java标准扩展的一部分,它提供了丰富的图像处理功能,包括压缩。 使用...

    数字图像处理 java实现

    Java作为一种跨平台的编程语言,提供了丰富的库和工具来支持数字图像处理。本项目聚焦于利用Java实现一系列基本的图像操作,如装载图像、处理灰度图像、提取像素、对数变换、梯度锐化、图像翻转以及直方图均衡化。...

    java实现图片上传并添加水印效果(文字水印,蒙版,logo图片),自动进行文字大小行数位置匹配 ,文字自动换行

    在Java编程中,实现图片上传并添加水印效果是一项常见的任务,这通常涉及到图像处理、图形用户界面(GUI)和文件I/O等多个方面。在这个项目中,我们将关注以下几个关键知识点: 1. **Java图像处理库**:Java标准库...

    java实现多张jgp图片转动画gif格式

    在Java编程环境中,将多张JPEG格式的图片转换为动态GIF格式是一项常见的图像处理任务。这个Demo展示了如何使用Java的图像处理库来完成这一过程。以下是对这个过程的详细解释: 首先,我们需要一个能够处理GIF格式的...

    javacv对图片进行文字提取,定位指定文字在图片的位置坐标,提高识别速度

    JavaCV 是一个强大的 Java 库,它为 Java 和 Android ...总之,JavaCV 结合 OpenCV 和 Tesseract 可以帮助我们高效地完成图片中文字的提取和定位,通过优化图像处理和识别流程,可以显著提高 OCR 系统的速度和准确性。

    java拼图游戏 源代码

    开发者可能编写了算法将图片分割成不同大小的块,根据难度设置调整块的数量和形状,这涉及到图像的切割、保存和随机排列。 4. **算法实现** - 在拼图游戏中,可能存在一些算法来辅助游戏逻辑,如判断拼图是否完成...

    JAVA图像处理完整版

    这个"JAVA图像处理完整版"的压缩包很可能是包含了一系列教程、代码示例或库,帮助开发者深入理解并实践Java中的图像操作。在这个主题中,我们将探讨几个关键的知识点,包括基本概念、API使用、图像操作以及实际应用...

Global site tag (gtag.js) - Google Analytics