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

悠悠 2022-05-29 06:55 349阅读 0赞

参考资料 [http://blog.csdn.net/qq\_30832659/article/details/52494713][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][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;
        }
    
    }

[http_blog.csdn.net_qq_30832659_article_details_52494713]: http://blog.csdn.net/qq_30832659/article/details/52494713
[http_nchc.dl.sourceforge.net_project_opencvlibrary_opencv-win_3.0.0_opencv-3.0.0.exe]: http://nchc.dl.sourceforge.net/project/opencvlibrary/opencv-win/3.0.0/opencv-3.0.0.exe