`

图片 + logo（java）

 
阅读更多
package cn.test;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
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.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGEncodeParam;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

public class ImageTool {


private float quality;//图片质量

private int MAX_SIZE;//图片最大值
private int x;//水印图片在图片x轴方向位置
private int y;//水印图片在图片y轴方向位置

public ImageTool(){
//默认图片压缩质量是0.8；
quality=0.8f;
x=10;
y=10;
}

public int GetImageSize(String path){
/*
* 功能：返回path指向图片大小
* path图片路径
* */

if(!isImagepath(path)){
return 0;
}
long size=0;

    File file=new File(path);
    size=file.length();
   
    return (int)size/1024;


}
/**
* 左上角添加水印
* @param ImagePath
* @param WaterImagePath
* 1
*/
public Boolean AddWaterImageLeftUp(String ImagePath,String WaterImagePath){
/*
* 功能：在ImagePath图片左上角添加水印图片WatherImagePath
* */
Boolean b = false;
if( !isImagepath(WaterImagePath) || !isImagepath(ImagePath)){
return b;
}
try{
int IWidth=GetImageWidth(ImagePath);
int IHeight=GetImageHeight(ImagePath);
int  WWidth=GetImageWidth(WaterImagePath);
int WHeight=GetImageHeight(WaterImagePath);

if(IWidth <WWidth+x||IHeight<WHeight+y){
return b;
}
AddWaterImage(ImagePath,WaterImagePath,x,y);
b = true;

} catch (Exception e) {
            e.printStackTrace();
            b = false;
        }
return b;
       
}
/**
* 左下角添加水印
* @param ImagePath
* @param WaterImagePath
* 2
*/
public Boolean AddWaterImageLeftDown(String ImagePath,String WaterImagePath){
/*
* 功能：在ImagePath图片左下角添加水印图片WatherImagePath
* */
Boolean b = false;
if(!isImagepath(ImagePath)||!isImagepath(WaterImagePath)){
return b;
}
try{

int IWidth=GetImageWidth(ImagePath);
int IHeight=GetImageHeight(ImagePath);
int  WWidth=GetImageWidth(WaterImagePath);
int WHeight=GetImageHeight(WaterImagePath);

if(IWidth <WWidth+20||IHeight<WHeight+20){
return b;
}
AddWaterImage(ImagePath,WaterImagePath,x,IHeight-WHeight-y);
b = true;

} catch (Exception e) {
            e.printStackTrace();
            b = false;
        }
return b;
       
}
/**
* 右上角添加水印
* @param ImagePath
* @param WaterImagePath
* 3
*/
public Boolean AddWaterImageRightUp(String ImagePath,String WaterImagePath){
/*
* 功能：在ImagePath图片右上角添加水印图片WatherImagePath
* */
Boolean b = false;
if(!isImagepath(ImagePath)||!isImagepath(WaterImagePath)){
return b;
}
try{

int IWidth=GetImageWidth(ImagePath);
int IHeight=GetImageHeight(ImagePath);
int  WWidth=GetImageWidth(WaterImagePath);
int WHeight=GetImageHeight(WaterImagePath);

if(IWidth <WWidth+20||IHeight<WHeight+20){
return b;
}
AddWaterImage(ImagePath,WaterImagePath,IWidth-WWidth-x,y);
b = true;

} catch (Exception e) {
            e.printStackTrace();
            b = false;
        }
return b;
       
}
/**
* 右下角添加水印
* @param ImagePath
* @param WaterImagePath
* 4
*/
public Boolean AddWaterImageRightDown(String ImagePath,String WaterImagePath){
/*
* 功能：在ImagePath图片右上角添加水印图片WatherImagePath
* */
Boolean b = false;
if(!isImagepath(ImagePath) || !isImagepath(WaterImagePath)){
return b;
}
try{

int IWidth=GetImageWidth(ImagePath);
int IHeight=GetImageHeight(ImagePath);
int  WWidth=GetImageWidth(WaterImagePath);
int WHeight=GetImageHeight(WaterImagePath);

if(IWidth <WWidth+x||IHeight<WHeight+y){
return b;
}
AddWaterImage(ImagePath,WaterImagePath,IWidth-WWidth-x,IHeight-WHeight-y);
b = true;

} catch (Exception e) {
            e.printStackTrace();
            b = false;
        }
return b;
       
}


/*
* 手动添加一张图片水印
*
* 功能：在ImagePath图片x,y位置添加水印图片WatherImagePath
* ImagePath:原图
* WaterImagePath：水印图片
* x:水印图片在原图上横坐标
* y:水印图片在原图上纵坐标
* */
public Boolean AddWaterImage(String ImagePath, String WaterImagePath, int x, int y){

Boolean b  ;
if(!isImagepath(ImagePath) && !isImagepath(WaterImagePath)){
b = false;
}
if(x<1||y<1){
b = false;
}

try {
            //目标文件
            File _file = new File(ImagePath);

            Image src = ImageIO.read(_file);
            int wideth = src.getWidth(null);
            int height = src.getHeight(null);
            BufferedImage image = new BufferedImage(wideth, height,
                    BufferedImage.TYPE_INT_RGB);
            Graphics g = image.createGraphics();
           
            g.drawImage(src, 0, 0, wideth, height, null);

            //水印文件
            File _filebiao = new File(WaterImagePath);
            Image src_biao = ImageIO.read(_filebiao);
            int wideth_biao = src_biao.getWidth(null);
            int height_biao = src_biao.getHeight(null);
            g.drawImage(src_biao, x, y, wideth_biao, height_biao, null);
            //水印文件结束
            g.dispose();
            FileOutputStream out = new FileOutputStream(ImagePath);
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
            encoder.encode(image);
            out.close();
            b = true;
        } catch (Exception e) {
        b = false;
            e.printStackTrace();
        }
return b;
}

public void ZipImageFile(String path,float Iquality ){
/*
* 功能：按照压缩质量参数quality压缩path指向图片
* path:压缩图片路径
* Iquality:图片压缩质量
* */
if(!isImagepath(path)){
return;
}

while(GetImageSize(path)>MAX_SIZE){
zip(path,Iquality);
}

}

private void zip(String path,float Iquality){
/*
* 功能：按照压缩质量参数quality压缩path指向图片
* path:压缩图片路径
* Iquality:图片压缩质量
* */
String newImage = null;  
        try {  
            /** 对服务器上的临时文件进行处理 */ 
            Image srcFile = ImageIO.read(new File(path));
            int w = srcFile.getWidth(null);
            int h = srcFile.getHeight(null);

            int width =(int)(w*0.9);
            int height = (int)(h*0.9);
           
            ModeImageByWH(path,width,height,Iquality);
 
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
}

public void ModeImageByWH(String path,int width,int height,float Iquality){
/*
* 功能：设置path指向图片宽是width，高是height,生成图片质量Iquality
* width:新生成图片宽、
* height:新身材图片高
* Iquality:图片生成质量
* */
if(!isImagepath(path)||width<1||height<1){
return;
}
String newImage = null;  
        try {  
            /** 对服务器上的临时文件进行处理 */ 
            Image srcFile = ImageIO.read(new File(path));
           
            /** 宽,高设定 */ 
            BufferedImage tag = new BufferedImage(width, height,  
                    BufferedImage.TYPE_INT_RGB);  
            tag.getGraphics().drawImage(srcFile, 0, 0, width, height, null);  
            String filePrex = path.substring(5, path.indexOf('.'));  
            /** 压缩后的文件名 */ 
                        
            FileOutputStream out = new FileOutputStream(path);
 
            JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);  
            JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(tag);  
            /** 压缩质量 */ 
            jep.setQuality(Iquality, true);  
            encoder.encode(tag, jep);  
            out.close();  
 
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        } 

}
public int GetImageWidth(String path){
/*
* 功能：获得图片宽
* path:图片路径
* */

if(!isImagepath(path)){
return 0;
}
  try{
int Width=0;
         Image srcFile = ImageIO.read(new File(path));
         Width = srcFile.getWidth(null);
         return Width;
  } catch (IOException e) {  
          e.printStackTrace(); 
          return 0;
      }


}

public int GetImageHeight(String path){
/*
*功能:获得图片
*path:图片路径
* */
if(!isImagepath(path)){
return 0;
}
int Height=0;
try{

         Image srcFile = ImageIO.read(new File(path));
         Height = srcFile.getHeight(null);
        
        
  } catch (IOException e) {  
          e.printStackTrace(); 
          return 0;
      }
return Height;

}

public String cutImage(String path,int x,int y,int width,int height){
/*
* 功能：剪切图片,返回剪切图片地址
* path:要剪切图片地址
* x:剪切点在原图上横坐标位置
* y:剪切点在原图上纵坐标位置
* width:在横坐标x剪切点开始剪切长度
* heigth：在纵坐标y开始位置剪切长度
* */

if(!isImagepath(path)){
return null;
}

if(x<1||y<1||width<1||height<1){
return null;
}

FileInputStream is = null ;
         ImageInputStream iis =null ;
     
         try{  
        Image srcFile = ImageIO.read(new File(path));
             int w = srcFile.getWidth(null);
             int h = srcFile.getHeight(null);
             if(w<x+width||h<y+height){
            return null;
             }
        String fileType=path.substring(path.indexOf(".")+1,path.length()-path.indexOf("0")-1);
             //读取图片文件
             is = new FileInputStream(path);
            
           
             Iterator<ImageReader> it = ImageIO.getImageReadersByFormatName(fileType); 
             ImageReader reader = it.next();
          
             iis = ImageIO.createImageInputStream(is);
             reader.setInput(iis,true) ;
       
             ImageReadParam param = reader.getDefaultReadParam();                       
             Rectangle rect = new Rectangle(x, y, width, height);
                                    
             param.setSourceRegion(rect);           
             BufferedImage bi = reader.read(0,param);               
      
           
             String cutPath=path.replaceFirst("."+fileType, "_c."+fileType);
             ImageIO.write(bi, fileType, new File(cutPath));    
        
      
             if(is!=null)
                is.close() ;      
             if(iis!=null)
                iis.close();
            
             return cutPath;
         }
         catch(Exception e){
       
        e.printStackTrace();
        return null;
       
         }
         

}

private boolean isImagepath(String path){
/*
* 功能：判断imagePath是否有效值，有效返回true,无效返回false
*
* */

if(path.isEmpty()){
return false;
}

File file=new File(path);
if(!file.exists()){
return false;
}

return true;


}
private float getQuality() {
return quality;
}
public void setQuality(float quality) {
this.quality = quality;
}

public int getMAX_SIZE() {
return MAX_SIZE/1024;
}

public void setMAX_SIZE(int mAXSIZE) {
MAX_SIZE = mAXSIZE*1024;
}

public void SetWHByPercent(String path,float percent){
/*
* 功能：按照percent对应百分比重新设置path指向路径图片的长宽
* path:图片路径
* percent:百分数，新图片长宽对应原图片的百分数，
* */
if(!isImagepath(path)||percent<0){
return ;
}

int width=GetImageWidth(path);
int height=GetImageHeight(path);
ModeImageByWH(path,(int)(width*percent),(int)(height*percent),quality);


}

public void setXY(int x,int y){
/*
* 设置水印图片距离左上角位置
* x:水印图片横坐标位置
* y:水印图片纵坐标位置
* */
this.x=x*2;
this.y=y;
}
分享到：
| java 字符创截取
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java生成二维码+logo+文字说明.rar

    只需传入相应的参数，如二维码内容、logo图片路径、文字说明等，即可快速生成定制化的二维码。 在实际应用中，这个工具类可以用于各种场景，比如制作带有企业logo的宣传二维码，或者创建含有产品信息和说明的二维码...

    java 生成二维码 且中间 带图片(logo) 的方法

    在Java编程环境中，生成带有图片（logo）的二维码是一项实用的技术，这通常涉及到图像处理和二维码编码库的结合使用。以下是一种实现这个功能的方法，基于`com.google.zxing`库，一个广泛使用的二维码生成库。 首先...

    在JAVA中给图片打logo

    在Java编程语言中，给图片添加logo或水印是一项常见的任务，这通常涉及到图像处理和图形用户界面（GUI）的应用。下面将详细讲解如何在Java中实现这一功能，包括核心概念、所需工具类以及具体步骤。 1. **核心概念：...

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

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

    Java下载图片代码+教程

    ### Java下载图片代码+教程 #### 一、背景与需求 在互联网开发中，经常会遇到需要从网络上下载图片的需求。比如，在爬虫项目中抓取网页中的图片资源，或者在构建图片分享应用时需要从远程服务器下载图片显示在...

    java Springboot 生成 二维码 +logo.docx

    根据提供的文档信息，以下是对如何使用Java Spring Boot生成带有Logo的二维码的相关知识点的详细解析。 ### 1. 引入依赖库 为了实现二维码的生成功能，首先需要引入相关的依赖库。这里主要用到了`ZXing`库来进行...

    java二维码生成 带logo

    本项目专注于介绍如何在Java中生成带有Logo的二维码，并提供了相应的jar包供使用。以下将详细讲解这个过程。 首先，二维码生成的核心库通常是ZXing（Zebra Crossing），这是一个开源的条码解码库，支持多种格式的...

    java生成二维码，中间带logo，logo居中，完美实现

    在Java编程环境中，生成带有logo的二维码是一种常见的需求，尤其在品牌推广或个性化设计中。本文将详细讲解如何使用Java实现这一功能，并确保logo居中且大小可调，以达到完美的视觉效果。 首先，我们需要引入生成...

    Java二维码添加中间logo,有Zxing与QRCode两种方式

    在Java开发中，生成带有中间logo的二维码是一项实用的技术，可以增强二维码的视觉效果和品牌识别度。这里我们将深入探讨两种实现方式：Zxing（Zebra Crossing）和QRCode。 首先，Zxing是一个开源的二维码和条形码...

    手机二维码 + LOGO图片生成小程序

    针对现在流行的个性化二维码增加了二维码LOGO图片信息，说明如下： 1. 选择属于自己个性化的LOGO图片信息，生成的图片中包含此图片 2. 在二维码中加入个人的主页，别人扫描后可以自动打开主页 3. 通过ZXING方式生成...

    java写的图片叠加的小程序 可用于叠加水印 logo等

    在Java编程语言中，创建一个图片叠加的小程序可以实现各种实用功能，如添加水印、logo等元素到原图上，以保护版权或增加品牌识别度。以下是对这个主题的详细解释： 首先，我们需要理解“图片叠加”的概念。在图像...

    java zing识别、生成带logo二维码

    本项目聚焦于“java zing识别、生成带logo二维码”，这涉及到Java二维码库的使用，特别是如何在二维码中嵌入自定义logo，提升二维码的视觉效果和品牌辨识度。 首先，`QRCodeUtil.java`文件很可能是实现二维码生成的...

    java中生成二维码带logo带底部文字带压缩图片

    java 生成二维码(QRCode)图片 ，包括logo，底部文字，压缩图片

    java生成中间带logo的二维码图片（源码）

    在Java编程环境中，生成带有logo的二维码图片是一项实用的技术，常用于品牌推广或者网站链接的可视化展示。这个项目的核心在于将二维码与自定义logo结合，从而实现个性化的设计。以下是一些关于这个主题的重要知识点...

    java 生成带logo、文本的二维码并修改图片的位深度

    java 生成带logo、文本的二维码并修改图片的位深度，不努力的程序员不是一个好的程序员

    Android 图片加图片logo水印,文字水印

    本文将详细讲解如何在Android中实现图片加图片Logo水印以及文字水印，并探讨它们在不同位置的设置方法。 首先，我们需要理解Android的图像处理基础。Android提供了丰富的图像处理API，包括Bitmap类用于表示位图，...

    使用Java zxing开发的二维码 带logo彩色二维码

    本文将详细讲解如何使用Java与ZXing（Zebra Crossing）库来开发带logo的彩色二维码，以及涉及到的图片比例压缩技术。 **ZXing库介绍** ZXing（读作“zebra crossing”，斑马线）是一个开源的多格式一维和二维条码...

    生成、解析带logo的二维码（java）

    本文将详细探讨如何使用Java语言来实现这个功能，特别是如何生成带有logo的二维码，并允许自定义图片尺寸。 首先，我们需要了解二维码（Quick Response Code）的基本原理。二维码是一种二维条码，能够存储大量的...

    java生成二维码工具类（带logo和文字说明) 很实用

    本教程将深入讲解如何使用ZXing库在Java环境中生成带有Logo和文字说明的二维码，并提供一个实用的工具类。 首先，`ZXing`库提供了`com.google.zxing`包，其中包含用于生成二维码的主要类。核心类是`...

    java生成中间带logo的二维码图片

    在IT领域，特别是Java开发中，生成带有中间Logo的二维码图片是一种常见的需求，尤其是在移动支付、产品标识、信息传递等领域有着广泛的应用。本文将详细解析如何利用Java代码生成这种特殊的二维码图片，包括所需的...

Magicbox
Global site tag (gtag.js) - Google Analytics