在java中使用OpenCV 进行全景图切割与拼接

参考资料 http://blog.csdn.net/qq_30832659/article/details/52494713

环境配置

1. 下载opencv3.0 http://nchc.dl.sourceforge.net/project/opencvlibrary/opencv-win/3.0.0/opencv-3.0.0.exe
2. 配置系统环境变量 将上一步下载文件解压后，大概得到2.5G左右的文件夹，根据自己解压的目录，配置环境变量，在path中加入G:\opencv\build\x86\vc12\bin;G:\opencv\build\x64\vc12\bin;
3. 使用 D:\opencv_3.0\opencv\build\java目录下有一个opencv-300.jar，引入到java工程中，这样java工程中就可以使用了。

全景图切割与拼接

ConverUtil.java

package org.lic.cv;

import java.awt.AlphaComposite;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;

import javax.imageio.ImageIO;

import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import sun.misc.BASE64Encoder;

public class ConverUtil {

    /**
     * 读取本地图片文件
     * @param filePath
     * @return Mat
     */
    public static final Mat matRead(String filePath) {
        //return Highgui.imread("/home/night/webvr/vr.jpg");
//      return Imgcodecs.imread("/home/night/webvr/vr.jpg");
        return Imgcodecs.imread(filePath);
    }

    /**
     * 读取网络图片
     * @param urlStr
     * @return
     */
    public static final BufferedImage bufferReadUrl(String urlStr){
        BufferedImage image = null;    
        try
        {
            URL url = new URL(urlStr);   
            image = ImageIO.read(url);    
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return image;
    }

    /**
     * 图片文件保存
     * @param fileName
     * @param mat
     */
    public static final void matSave(String fileName,Mat mat) {
        //Highgui.imwrite(fileName, mat);
        //Imgcodecs.imwrite(fileName, mat);
        BufferedImage buff = matToBuffer(".jpg",mat);
        bufferSave(fileName,buff);
    }

    /**
     * 读取图片文件
     * @param filePath
     * @return
     */
    public static final BufferedImage bufferRead(String filePath) {
        try {
            return ImageIO.read(new File(filePath));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 图片文件保存
     * @param fileName
     * @param buff
     */
    public static final void bufferSave(String fileName,BufferedImage buff) {
        try {
            ImageIO.write(buff, "JPEG", new File(fileName));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static final Mat matResize(Mat mat,int width,int height){
        Mat target = new Mat(width,height,mat.type());
        //Imgproc.resize(src, dst, dsize);
        Imgproc.resize(mat, target, new Size(width,height), 0, 0, Imgproc.INTER_LINEAR);
        return target;
    }

    /**
     * Mat转换为BufferedImage，已测，可用
     * @param fileExt
     * @param mat
     * @return
     */
    public static final BufferedImage matToBuffer(String fileExt,Mat mat)
    {
        MatOfByte mob = new MatOfByte();
        Imgcodecs.imencode(fileExt, mat, mob);
        // convert the "matrix of bytes" into a byte array
        byte[] byteArray = mob.toArray();
        BufferedImage bufImage = null;
        try {
            InputStream in = new ByteArrayInputStream(byteArray);
            bufImage = ImageIO.read(in);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bufImage;
    }


    /**
     * BufferedImage转换为Mat，已测，可用
     * @param bufferedImage
     * @param imgType
     * @return
     */
    public static Mat bufferToMat(BufferedImage bufferedImage, int imgType)
    {
        final int matType = CvType.CV_8UC3;

        if (bufferedImage == null) {
            throw new IllegalArgumentException("bufferToMat-> BufferedImage == null");
        }

        if (bufferedImage.getType() != imgType) {
            BufferedImage image = new BufferedImage(bufferedImage.getWidth(), bufferedImage.getHeight(), imgType);
            Graphics2D g = image.createGraphics();
            try {
                g.setComposite(AlphaComposite.Src);
                g.drawImage(bufferedImage, 0, 0, null);
            } finally {
                g.dispose();
            }
        }

        byte[] pixels = ((DataBufferByte) bufferedImage.getRaster().getDataBuffer()).getData();
        Mat mat = Mat.eye(bufferedImage.getHeight(), bufferedImage.getWidth(), matType);
        mat.put(0, 0, pixels);

        return mat;
    }

    /**
     * 将Mat图片进行Base64编码 
     * base64编码后的字符串中经常包含“+”号，在C#环境中发送给服务器后，服务器把“+”存成了“ ”空格，而在Java环境下，“+”号依然是加号
     * 所以在java环境中，解码之前，需要先把编码后的字符串中的“ ”替换成“+”号
     * <code>String des = des.replaceAll("\\+", "%2B");</code>
     * 
     * @param mat
     * @return
     */
    public static final String matEncoder(Mat mat) {
        BufferedImage buff = matToBuffer(".jpg",mat);
        ByteArrayOutputStream byteout = new ByteArrayOutputStream();
        try {
            ImageIO.write(buff, "JPEG", byteout);
        } catch (IOException e) {
            e.printStackTrace();
        }

        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode( byteout.toByteArray());
    }
}

OpenCVUtil.java

package org.lic.cv;

import java.awt.image.BufferedImage;

import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.Scalar;
import org.opencv.imgproc.Imgproc;

public class OpenCVUtil {

    static {
       /* String opencvpath = System.getProperty("user.dir") + "/lib/";
        System.out.println(opencvpath);
        String opencvDllName = opencvpath + Core.NATIVE_LIBRARY_NAME + ".dll";      //windows 环境
        //String opencvDllName = opencvpath + "libopencv_java341.so";               //Linux 环境
        System.load(opencvDllName);*/

        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }

    double[][] imageTransform =
        {
            {0, 0},
            {Math.PI /2,0},
            {Math.PI,0},
            {-Math.PI /2,0},
            {0,-Math.PI/2},
            {0,Math.PI/2}      
        };

    public static void main(String[] args)
    {
        OpenCVUtil util = new OpenCVUtil();

        BufferedImage buff = ConverUtil.bufferRead("D:\\img_lib\\test2.jpg");// /home/night/webvr/vr.jpg

        Mat[] cube = util.shear(buff, 1024, 1024);  //全景图切割
        Mat preview = util.mergeImage(cube, 512);           //预览图合成
    }

    /**
     * 全景图切割，返回6张图
     */
    public Mat[] shear(BufferedImage buff,int targetWidth,int targetHeight)
    {
        //Mat mat = ConverUtil.matRead("/home/night/webvr/vr.jpg");
        Mat mat = ConverUtil.bufferToMat(buff, buff.getType());

        Mat[] cube = new Mat[6];
        for (int i = 0; i < 6; i++) {
            cube[i] = sideCubeMapImage(mat, i, targetWidth, targetHeight);
        }

        return cube;
    }

    /**
     * 全景图切割，单面处理
     * @param in
     * @param face
     * @param faceId
     * @param width
     * @param height
     */
    private Mat sideCubeMapImage(Mat source, final int sideId,final int sideWidth,final int sideHeight)
    {
        Mat result = new Mat(sideWidth, sideHeight, source.type());

        System.out.println("==========handle "+sideId+" start ===========");
        float sourceWidth = source.cols();                                                 
        float sourceHeight = source.rows();     // 获取图片的行列数量

        Mat mapx = new Mat(sideHeight, sideWidth, CvType.CV_32F);
        Mat mapy = new Mat(sideHeight, sideWidth, CvType.CV_32F);       //分配图的x,y轴

        // Calculate adjacent (ak) and opposite (an) of the
        // triangle that is spanned from the sphere center 
        //to our cube face.
        final double an = Math.sin(Math.PI / 4);
        final double ak = Math.cos(Math.PI / 4);                                          //计算相邻ak和相反an的三角形张成球体中心

        double ftu = imageTransform[sideId][0];
        double ftv = imageTransform[sideId][1];

        // For each point in the target image, 
        // calculate the corresponding source coordinates.                      对于每个图像计算相应的源坐标
        for (int y = 0; y < sideHeight; y++) {
            for (int x = 0; x < sideWidth; x++) {           

                // Map face pixel coordinates to [-1, 1] on plane               将坐标映射在平面上
                float nx = (float)y / (float)sideHeight - 0.5f;
                float ny = (float)x / (float)sideWidth - 0.5f;

                nx *= 2;
                ny *= 2;

                // Map [-1, 1] plane coord to [-an, an]                          
                // thats the coordinates in respect to a unit sphere 
                // that contains our box. 
                nx *= an;
                ny *= an;

                double u, v;

                // Project from plane to sphere surface.
                if (ftv == 0) {
                    // Center faces
                    u = Math.atan2(nx, ak);
                    v = Math.atan2(ny * Math.cos(u), ak);
                    u += ftu;
                }
                else if (ftv > 0) {
                    // Bottom face 
                    double d = Math.sqrt(nx * nx + ny * ny);
                    v = Math.PI / 2 - Math.atan2(d, ak);
                    u = Math.atan2(ny, nx);
                }
                else {
                    // Top face
                    //cout << "aaa";
                    double d = Math.sqrt(nx * nx + ny * ny);
                    v = -Math.PI / 2 + Math.atan2(d, ak);
                    u = Math.atan2(-ny, nx);
                }

                // Map from angular coordinates to [-1, 1], respectively.
                u = u / (Math.PI);
                v = v / (Math.PI / 2);

                // Warp around, if our coordinates are out of bounds. 
                while (v < -1) {
                    v += 2;
                    u += 1;
                }
                while (v > 1) {
                    v -= 2;
                    u += 1;
                }

                while (u < -1) {
                    u += 2;
                }
                while (u > 1) {
                    u -= 2;
                }

                // Map from [-1, 1] to in texture space
                u = u / 2.0f + 0.5f;
                v = v / 2.0f + 0.5f;

                u = u*(sourceWidth-1);
                v = v*(sourceHeight-1);

                mapx.put(x, y, u);
                mapy.put(x, y, v);
            }
        }

        // Recreate output image if it has wrong size or type.
        /**
        if (result.cols() != width || result.rows() != height ||
                result.type() != source.type()) {
            result = new Mat(width, height, source.type());
        }**/

        // Do actual  using OpenCV's remap
        Imgproc.remap(source, result, mapx, mapy, Imgproc.INTER_LINEAR, Core.BORDER_CONSTANT, new Scalar(0, 0, 0));

        if (sideId == 0)
        {
            ConverUtil.matSave("D:\\img_lib\\test2_cube00.jpg", result);
        }
        else if (sideId == 1)
        {
            ConverUtil.matSave("D:\\img_lib\\test2_cube01.jpg", result);
        }
        else if (sideId == 2)
        {
            ConverUtil.matSave("D:\\img_lib\\test2_cube02.jpg", result);
        }
        else if (sideId == 3)
        {
            ConverUtil.matSave("D:\\img_lib\\test2_cube03.jpg", result);
        }
        else if (sideId == 4)
        {
            ConverUtil.matSave("D:\\img_lib\\test2_cube04.jpg", result);
        }
        else if (sideId == 5)
        {
            ConverUtil.matSave("D:\\img_lib\\test2_cube05.jpg", result);
        }

        System.out.println("==========handle "+sideId+" over ===========");

        return result;
    }

    /**
     * 全景预览图合成
     */
    private Mat mergeImage(Mat[] cube,int width)
    {

        Mat mat = new Mat(width * cube.length, width, cube[0].type());
        for(int i=0;i<cube.length;i++) {
            Mat side = ConverUtil.matResize(cube[i], 512, 512);
            mat.put(i*512, 0, getByte(side));
        }

        ConverUtil.matSave("D:\\img_lib\\test2_cube11.jpg", mat);
        return mat;
    }

    public byte[] getByte(Mat mat) {
        int width = mat.cols();
        int height = mat.rows();
        int dims = mat.channels();
        byte[] rgbdata = new byte[width*height*dims];
        mat.get(0, 0, rgbdata);
        return rgbdata;
    }

}