1,下载网络图片

  1. package org.jeecg.modules.ppl.utils;
  3. import java.awt.Graphics2D;
  4. import java.awt.image.BufferedImage;
  5. import java.io.*;
  6. import java.net.MalformedURLException;
  7. import java.net.URL;
  9. import javax.imageio.ImageIO;
  10. import javax.swing.ImageIcon;
  12. /**
  13.  * 下载网络图片
  14.  */
  15. public class PngUtil{
  16.     /**
  17.      * 通过链接url下载图片
  18.      * inImageUrl 网络图片url
  19.      * putImagePath 保存的本地路径
  20.      */
  21.     public static String downloadPic(String inImageUrl,String putImagePath) {
  22.         URL url = null;
  23.         int imageNumber = 0;
  24.         try {
  25.             url = new URL(inImageUrl);
  26.             DataInputStream dataInputStream = new DataInputStream(url.openStream());
  28.             putImagePath =  "E:/upload/media/lanzhou2.png";
  30.             FileOutputStream fileOutputStream = new FileOutputStream(new File(putImagePath));
  31.             ByteArrayOutputStream output = new ByteArrayOutputStream();
  33.             byte[] buffer = new byte[1024];
  34.             int length;
  36.             while ((length = dataInputStream.read(buffer)) > 0) {
  37.                 output.write(buffer, 0, length);
  38.             }
  39.             byte[] context = output.toByteArray();
  40.             fileOutputStream.write(output.toByteArray());
  41.             dataInputStream.close();
  42.             fileOutputStream.close();
  43.         } catch (MalformedURLException e) {
  44.             e.printStackTrace();
  45.             putImagePath = "错误:" + e.getMessage();
  46.         } catch (IOException e) {
  47.             e.printStackTrace();
  48.             putImagePath = "错误:" + e.getMessage();
  49.         }
  50.         return putImagePath;
  51.     }
  52. }

2,图片转换成透明底图片(推荐)

  1. package org.jeecg.modules.ppl.utils;
  3. import java.awt.*;
  4. import java.awt.image.BufferedImage;
  5. import java.io.*;
  6. import java.net.MalformedURLException;
  7. import java.net.URL;
  9. import javax.imageio.ImageIO;
  10. import javax.imageio.stream.FileImageInputStream;
  11. import javax.imageio.stream.FileImageOutputStream;
  12. import javax.swing.ImageIcon;
  14. /**
  15.  * 生成透明图片
  16.  */
  17. public class PngUtil{
  18.     /**
  19.      * 通过链接url下载图片
  20.      * inImageUrl 网络图片url
  21.      * putImagePath 保存的本地路径
  22.      */
  23.     public static String downloadPic(String inImageUrl,String putImagePath) {
  24.         URL url = null;
  25.         int imageNumber = 0;
  26.         try {
  27.             url = new URL(inImageUrl);
  28.             DataInputStream dataInputStream = new DataInputStream(url.openStream());
  30.             putImagePath =  "E:/upload/media/lanzhou2.png";
  32.             FileOutputStream fileOutputStream = new FileOutputStream(new File(putImagePath));
  33.             ByteArrayOutputStream output = new ByteArrayOutputStream();
  35.             byte[] buffer = new byte[1024];
  36.             int length;
  38.             while ((length = dataInputStream.read(buffer)) > 0) {
  39.                 output.write(buffer, 0, length);
  40.             }
  41.             byte[] context = output.toByteArray();
  42.             fileOutputStream.write(output.toByteArray());
  43.             dataInputStream.close();
  44.             fileOutputStream.close();
  45.         } catch (MalformedURLException e) {
  46.             e.printStackTrace();
  47.             putImagePath = "错误:" + e.getMessage();
  48.         } catch (IOException e) {
  49.             e.printStackTrace();
  50.             putImagePath = "错误:" + e.getMessage();
  51.         }
  52.         return putImagePath;
  53.     }
  54.     /**
  55.      * @param imgSrc 原图片地址
  56.      * @param imgTarget 新图片地址
  57.      * @return 转换结果ture or false
  58.      */
  59.     public static boolean transferAlpha2File(String imgSrc, String imgTarget) {
  60.         File file = new File(imgSrc);
  61.         InputStream is = null;
  62.         boolean result = false;
  63.         try {
  64.             is = new FileInputStream(file);
  65.             // 如果是MultipartFile类型，那么自身也有转换成流的方法：is = file.getInputStream();
  66.             BufferedImage bi = ImageIO.read(is);
  67.             Image image = (Image) bi;
  68.             ImageIcon imageIcon = new ImageIcon(image);
  69.             BufferedImage bufferedImage = new BufferedImage(imageIcon.getIconWidth(), imageIcon.getIconHeight(),BufferedImage.TYPE_4BYTE_ABGR);
  70.             Graphics2D g2D = (Graphics2D) bufferedImage.getGraphics();
  71.             g2D.drawImage(imageIcon.getImage(), 0, 0, imageIcon.getImageObserver());
  72.             int alpha = 0;
  73.             for (int j1 = bufferedImage.getMinY(); j1 < bufferedImage.getHeight(); j1++) {
  74.                 for (int j2 = bufferedImage.getMinX(); j2 < bufferedImage.getWidth(); j2++) {
  75.                     int rgb = bufferedImage.getRGB(j2, j1);
  76.                     int R = (rgb & 0xff0000) >> 16;
  77.                     int G = (rgb & 0xff00) >> 8;
  78.                     int B = (rgb & 0xff);
  79.                     if (((255 - R) < 30) && ((255 - G) < 30) && ((255 - B) < 30)) {
  80.                         rgb = ((alpha + 1) << 24) | (rgb & 0x00ffffff);
  81.                     }
  82.                     bufferedImage.setRGB(j2, j1, rgb);
  83.                 }
  84.             }
  85.             g2D.drawImage(bufferedImage, 0, 0, imageIcon.getImageObserver());
  86.             result = ImageIO.write(bufferedImage, "png", new File(imgTarget));// 直接输出文件
  87. //            result = ImageIO.write(bufferedImage, "jpg", new File(imgTarget));// 直接输出文件
  88.         } catch (Exception e) {
  89.             e.printStackTrace();
  90.             result = false;
  91.         } finally {
  92.             if (is != null) {
  93.                 try {
  94.                     is.close();
  95.                 } catch (IOException e) {
  96.                     // TODO Auto-generated catch block
  97.                 }
  98.             }
  99.         }
  100.         return result;
  101.     }
  103.     /**
  104.      * 透明图片的byte数组
  105.      * @param imgSrc
  106.      * @return
  107.      */
  108.     public static byte[] transferAlpha2Byte(String imgSrc) {
  109.         ByteArrayOutputStream byteArrayOutputStream = null;
  110.         File file = new File(imgSrc);
  111.         InputStream is = null;
  112.         byte[] result = null;
  113.         try {
  114.             is = new FileInputStream(file);
  115.             // 如果是MultipartFile类型，那么自身也有转换成流的方法：is = file.getInputStream();
  116.             BufferedImage bi = ImageIO.read(is);
  117.             Image image = (Image) bi;
  118.             ImageIcon imageIcon = new ImageIcon(image);
  119.             BufferedImage bufferedImage = new BufferedImage(imageIcon.getIconWidth(), imageIcon.getIconHeight(),BufferedImage.TYPE_4BYTE_ABGR);
  120.             Graphics2D g2D = (Graphics2D) bufferedImage.getGraphics();
  121.             g2D.drawImage(imageIcon.getImage(), 0, 0, imageIcon.getImageObserver());
  122.             int alpha = 0;
  123.             for (int j1 = bufferedImage.getMinY(); j1 < bufferedImage.getHeight(); j1++) {
  124.                 for (int j2 = bufferedImage.getMinX(); j2 < bufferedImage.getWidth(); j2++) {
  125.                     int rgb = bufferedImage.getRGB(j2, j1);
  126.                     int R = (rgb & 0xff0000) >> 16;
  127.                     int G = (rgb & 0xff00) >> 8;
  128.                     int B = (rgb & 0xff);
  129.                     if (((255 - R) < 30) && ((255 - G) < 30) && ((255 - B) < 30)) {
  130.                         rgb = ((alpha + 1) << 24) | (rgb & 0x00ffffff);
  131.                     }
  132.                     bufferedImage.setRGB(j2, j1, rgb);
  133.                 }
  134.             }
  135.             g2D.drawImage(bufferedImage, 0, 0, imageIcon.getImageObserver());
  136.             byteArrayOutputStream = new ByteArrayOutputStream();
  137.             ImageIO.write(bufferedImage, "png", byteArrayOutputStream);// 转换成byte数组
  138.             result = byteArrayOutputStream.toByteArray();
  139.         } catch (Exception e) {
  140.             e.printStackTrace();
  141.         } finally {
  142.             if (is != null) {
  143.                 try {
  144.                     is.close();
  145.                 } catch (IOException e) {
  146.                     // TODO Auto-generated catch block
  147.                 }
  148.             }
  149.             if (byteArrayOutputStream != null) {
  150.                 try {
  151.                     byteArrayOutputStream.close();
  152.                 } catch (IOException e) {
  153.                     // TODO Auto-generated catch block
  154.                 }
  155.             }
  156.         }
  157.         return result;
  158.     }
  159.     /**
  160.      * byte数组到图片
  161.      */
  162.     public static void byteToImage(byte[] data,String path){
  163.         if (data.length < 3 || path.equals("")) return;
  164.         try {
  165.             FileImageOutputStream imageOutput = new FileImageOutputStream(new File(path));
  166.             imageOutput.write(data, 0, data.length);
  167.             imageOutput.close();
  168.         } catch(Exception ex) {
  169.             System.out.println("Exception: " + ex.getMessage());
  170.             ex.printStackTrace();
  171.         }
  172.     }
  173.     /**
  174.      * 图片转化为byte数组
  175.      * @param path
  176.      * @return
  177.      */
  178.     public byte[] imageToByte(String path){
  179.         byte[] data = null;
  180.         FileImageInputStream input = null;
  181.         try {
  182.             input = new FileImageInputStream(new File(path));
  183.             ByteArrayOutputStream output = new ByteArrayOutputStream();
  184.             byte[] buf = new byte[1024];
  185.             int numBytesRead = 0;
  186.             while ((numBytesRead = input.read(buf)) != -1) {
  187.                 output.write(buf, 0, numBytesRead);
  188.             }
  189.             data = output.toByteArray();
  190.             output.close();
  191.             input.close();
  192.         } catch (FileNotFoundException ex1) {
  193.             ex1.printStackTrace();
  194.         } catch (IOException ex1) {
  195.             ex1.printStackTrace();
  196.         }
  197.         return data;
  198.     }
  199.     /**
  200.      * 图片转base64编码
  201.      * 拼接 "data:image/png;base64,"
  202.      */
  203.     public static String imageToBase64(String path){
  204.         byte[] bytes = imageToByte(path);
  205.         String base64String = Base64.encodeBase64String(bytes);
  206.         return base64String;
  207.     }
  208. }

3,图片转换成透明底图片(不推荐,图片会模糊)

  1. package org.jeecg.modules.ppl.utils;
  3. import java.awt.Graphics2D;
  4. import java.awt.image.BufferedImage;
  5. import java.io.*;
  6. import java.net.MalformedURLException;
  7. import java.net.URL;
  9. import javax.imageio.ImageIO;
  10. import javax.swing.ImageIcon;
  12. /**
  13.  * 生成透明图片
  14.  */
  15. public class PngUtil{
  16.     //色差范围0~255
  17.     public static int color_range = 20;
  18.     public static void opacityPng(String imgPath) throws IOException {
  19.         BufferedImage image = ImageIO.read(new File(imgPath));
  20.         // 高度和宽度
  21.         int height = image.getHeight();
  22.         int width = image.getWidth();
  24.         // 生产背景透明和内容透明的图片
  25.         ImageIcon imageIcon = new ImageIcon(image);
  26.         BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_4BYTE_ABGR);
  27.         Graphics2D g2D = (Graphics2D) bufferedImage.getGraphics(); // 获取画笔
  28.         g2D.drawImage(imageIcon.getImage(), 0, 0, null); // 绘制Image的图片，使用了imageIcon.getImage()，目的就是得到image,直接使用image就可以的
  30.         int alpha = 0; // 图片透明度
  31.         // 外层遍历是Y轴的像素
  32.         for (int y = bufferedImage.getMinY(); y < bufferedImage.getHeight(); y++) {
  33.             // 内层遍历是X轴的像素
  34.             for (int x = bufferedImage.getMinX(); x < bufferedImage.getWidth(); x++) {
  35.                 int rgb = bufferedImage.getRGB(x, y);
  36.                 // 对当前颜色判断是否在指定区间内
  37.                 if (colorInRange(rgb)){
  38.                     alpha = 0;
  39.                 }else{
  40.                     // 设置为不透明
  41.                     alpha = 255;
  42.                 }
  43.                 // #AARRGGBB 最前两位为透明度
  44.                 rgb = (alpha << 24) | (rgb & 0x00ffffff);
  45.                 bufferedImage.setRGB(x, y, rgb);
  46.             }
  47.         }
  48.         // 绘制设置了RGB的新图片,这一步感觉不用也可以只是透明地方的深浅有变化而已，就像蒙了两层的感觉
  49.         g2D.drawImage(bufferedImage, 0, 0, null);
  50.         // 生成图片为PNG
  51.         ImageIO.write(bufferedImage, "png", new File("E:/upload/media/lanzhou1.png"));
  52.     }
  54.     // 判断是背景还是内容
  55.     public static boolean colorInRange(int color) {
  56.         int red = (color & 0xff0000) >> 16;// 获取color(RGB)中R位
  57.         int green = (color & 0x00ff00) >> 8;// 获取color(RGB)中G位
  58.         int blue = (color & 0x0000ff); // 获取color(RGB)中B位
  59.         // 通过RGB三分量来判断当前颜色是否在指定的颜色区间内
  60.         if (red >= color_range && green >= color_range && blue >= color_range){
  61.             return true;
  62.         };
  63.         return false;
  64.     }
  65.     /**
  66.      * 通过链接url下载图片
  67.      * inImageUrl 网络图片url
  68.      * putImagePath 保存的本地路径
  69.      */
  70.     public static String downloadPic(String inImageUrl,String putImagePath) {
  71.         URL url = null;
  72.         int imageNumber = 0;
  73.         try {
  74.             url = new URL(inImageUrl);
  75.             DataInputStream dataInputStream = new DataInputStream(url.openStream());
  77.             putImagePath =  "E:/upload/media/lanzhou2.png";
  79.             FileOutputStream fileOutputStream = new FileOutputStream(new File(putImagePath));
  80.             ByteArrayOutputStream output = new ByteArrayOutputStream();
  82.             byte[] buffer = new byte[1024];
  83.             int length;
  85.             while ((length = dataInputStream.read(buffer)) > 0) {
  86.                 output.write(buffer, 0, length);
  87.             }
  88.             byte[] context = output.toByteArray();
  89.             fileOutputStream.write(output.toByteArray());
  90.             dataInputStream.close();
  91.             fileOutputStream.close();
  92.         } catch (MalformedURLException e) {
  93.             e.printStackTrace();
  94.             putImagePath = "错误:" + e.getMessage();
  95.         } catch (IOException e) {
  96.             e.printStackTrace();
  97.             putImagePath = "错误:" + e.getMessage();
  98.         }
  99.         return putImagePath;
  100.     }
  101. }