ImageUtils

package com.papcic.epcis.epciscommon.intqry.biz.util;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

import com.pingan.security.common.repack.java.util.Arrays;

public class ImageUtils {

	public static Byte[] transe2ByteArray(byte[] src) {
		if(null == src) {
			return null;
		}
		Byte[] retArr = new Byte[src.length];
		for(int i = 0, size = src.length; i < size; i++) {
			retArr[i] = new Byte(src[i]);
		}
		
		return retArr;
	}
	
	public static byte[] transe2byteArray(Byte[] src) {
		if(null == src) {
			return null;
		}
		byte[] retArr = new byte[src.length];
		for(int i = 0, size = src.length; i < size; i++) {
			retArr[i] = src[i].byteValue();
		}
		
		return retArr;
	}
	
	/**
	 * 向dest数字中的destPos位置开始写入src数组，直到dest末尾
	 * @param dest 目标Byte数组
	 * @param destPos 0开始的位置
	 * @param src 源byte数组
	 */
	public static Byte[] arrayCopy(Byte[] dest, int destPos, byte[] src) {
		if(null != dest && null != src) {
			int destLen = dest.length;
			if(destPos < destLen) {
				int tmpIndex = destPos;
				int srcLen = src.length;
				int i = 0;
				while(tmpIndex < destLen && i < srcLen) {
					dest[tmpIndex] = new Byte(src[i]);
					tmpIndex ++;
					i ++;
				}
			}
		}

		return dest;
	}
	
	public static void main(String[] a) {
		Byte[] dest = new Byte[5];
		byte[] src = new byte[3];
		Arrays.fill(src, (byte)0);
		dest = arrayCopy(dest, 1, src);
	}
	
	public static Byte[] getImageContent(String imagePath) {
		Byte[] retData = null;
		byte[] data = null;
		if(null != imagePath) {
			File imgFile = new File(imagePath);
			if(imgFile.exists() && imgFile.isFile()) {
				BufferedInputStream in = null;
				
				//读取图片字节数组
				try {
					in = new BufferedInputStream(new FileInputStream(imgFile));
					data = new byte[in.available()];
					in.read(data);
					retData = transe2ByteArray(data);
					in.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
		return retData;
	}
	
	public static Byte[] getImageContentNew(String imagePath) {
		Byte[] retData = null;
		FileInputStream in = null;  
        int bufferSize = 5120;
        try {  
            // 获取源文件和目标文件的输入输出流    
            in = new FileInputStream(imagePath); 
            retData = new Byte[in.available()];
            // 获取输出通道  
            FileChannel fcIn = in.getChannel();  
            ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
            int count = 0;
            while (true) {  
                // clear方法重设缓冲区，使它可以接受读入的数据  
                buffer.clear();  
                // 从输入通道中将数据读到缓冲区  
                int r = fcIn.read(buffer);  
                if (r == -1) {  
                    break;  
                }  
                // flip方法让缓冲区可以将新读入的数据写入另一个通道    
                buffer.flip();  
                byte[] tmpContent = buffer.array();
                retData = arrayCopy(retData, count * bufferSize, tmpContent);
                count ++;
            }  
  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            if (in != null) {  
                try {  
                    in.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        } 
		
		return retData;
	}
	
	public static void writeImageContent(Byte[] imageContent, String newImgPath) throws IOException {
		File imgFile = new File(newImgPath);
		if(!imgFile.exists()) {
			imgFile.createNewFile();
		}
		FileOutputStream fw = new FileOutputStream(imgFile);
		byte[] byteArr = transe2byteArray(imageContent);
		fw.write(byteArr);
		fw.flush();
		fw.close();
	}
	
	public static void writeImageContentNew(Byte[] imageContent, String newImgPath) throws IOException {
        FileOutputStream out = null;
        int bufferSize = 5120;
        try {  
            // 获取源文件和目标文件的输入输出流    
            out = new FileOutputStream(newImgPath);  
            // 获取输出通道  
            FileChannel fcOut = out.getChannel();  
            ByteBuffer buffer = ByteBuffer.allocate(bufferSize);
            byte[] byteArr = transe2byteArray(imageContent);
            int dealCount = 0;
            while (true) {  
                // clear方法重设缓冲区，使它可以接受读入的数据  
                buffer.clear();
                if((dealCount + bufferSize) > byteArr.length) {
                	buffer = ByteBuffer.wrap(byteArr, dealCount, byteArr.length - dealCount);
                    fcOut.write(buffer);
                    break;
                } else {
                	buffer = ByteBuffer.wrap(byteArr, dealCount, bufferSize);
                	dealCount += bufferSize;
                    fcOut.write(buffer);
                }
            }  
  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            if (out != null) {  
                try {
                	out.flush();
                    out.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        } 
	}
	
	/**
	 * 删除图片文件
	 * @param imgPath
	 * @return 1:删除成功 -1:删除失败 0:文件不存在
	 * @throws IOException
	 */
	public static int deleteImage(String imgPath) throws IOException {
		int ret = 0;
		File imgFile = new File(imgPath);
		if(imgFile.exists()) {
			boolean isDeleted = imgFile.delete();
			if(isDeleted) {
				ret = 1;
			} else {
				ret = -1;
			}
		} else {
			ret = 0;
		}
		
		return ret;
	}
}