java 实现全景图切割算法 （生成krpano可用文件）

最新推荐文章于 2024-05-15 09:19:11 发布
原创 最新推荐文章于 2024-05-15 09:19:11 发布 · 1.4k 阅读 · 11 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#opencv #计算机视觉 #cv
本文介绍了一个使用OpenCV进行图像处理的实用工具类，该类支持全景图切割、预览图合成等操作，并利用多线程提高处理效率。代码展示了如何使用Guava的并发工具和OpenCV库来实现图像的并行处理。

废话不说，上代码

package com.hgj.exhibition.imagehandel;

import com.google.common.util.concurrent.*;
import org.opencv.core.*;
import org.opencv.imgproc.Imgproc;

import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class OpenCVUtil {

    private String saveUrl;
    public OpenCVUtil(String saveUrl){
        this.saveUrl=saveUrl;
    }

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

    /**
     * 处理函数 多个 文件
     * @param fileListUrl
     */
    public  List<List<Mat>> handels( List<String> fileListUrl ){
        final ExecutorService pool = Executors.newFixedThreadPool(fileListUrl.size());
        List<List<Mat>> matLis = new ArrayList<>();

        try {
            ListeningExecutorService executorService = MoreExecutors.listeningDecorator(pool);
            List<ListenableFuture<List<Mat>>> futures = new ArrayList<>();
            for (String url : fileListUrl) {
                ListenableFuture<List<Mat>> listenableFuture = executorService.submit(new ImageHandel(url));
                Futures.addCallback(listenableFuture, new FutureCallback<List<Mat>>() {
                    public void onSuccess(List<Mat> result) {
                        matLis.add(result);
                    }

                    public void onFailure(Throwable t) {
                        //  LOG.info("Add result value into value list error.", t);
                        throw new RuntimeException(t);
                    }
                }, executorService);
                futures.add(listenableFuture);
            }
             Futures.allAsList(futures).get();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            pool.shutdown();
        }
        return matLis;
    }

    class ImageHandel implements Callable<List<Mat>> {
        private String path;
        public ImageHandel(String path){
            this.path=path;
        }
        @Override
        public List<Mat> call() {
            return handel(path);
        }
    }
        /**
         * 处理函数 单个图片
         * @param imageUrl
         */
    public static List<Mat> handel(String imageUrl){
      //  System.out.println(System.currentTimeMillis());
        OpenCVUtil util = new OpenCVUtil();
        BufferedImage buff = ConverUtil.bufferRead(imageUrl);//
        Mat[] cube = util.shear(buff, 1936, 1936);  //全景图切割
        List<Mat> mats=new ArrayList<Mat>();
        mats.add(cube[3]);
        mats.add(cube[0]);
        mats.add(cube[1]);
        mats.add(cube[2]);
        mats.add(cube[4]);
        mats.add(cube[5]);
        Mat preview=new Mat(256,1536,CvType.CV_8UC1);
        Core.vconcat(mats,preview);

        Mat handelpreview = new Mat();
        Imgproc.resize(preview, handelpreview, new Size(256,1536), 0, 0, Imgproc.INTER_LINEAR);
        mats.add(handelpreview);

        Mat thumb = new Mat();
        Imgproc.resize(mats.get(1), thumb, new Size(240,240), 0, 0, Imgproc.INTER_LINEAR);
        mats.add(thumb);
        return mats;
      //  ConverUtil.matSave(util.saveUrl+"preview.jpg", endst);
       // System.out.println(System.currentTimeMillis());
      //  Mat preview = util.mergeImage(cube, 512);           //预览图合成
    }

    /**
     * 全景图切割，返回6张图
     */
    public Mat[] shear(BufferedImage buff,int targetWidth,int targetHeight)
    {
        //Mat mat = com.imagehandel.ConverUtil.matRead("/home/night/webvr/vr.jpg");
        Mat mat = ConverUtil.bufferToMat(buff, buff.getType());
        final ExecutorService pool = Executors.newFixedThreadPool(6);
        ListeningExecutorService executorService = MoreExecutors.listeningDecorator(pool);
        List<ListenableFuture<HashMap<Integer,Mat>>> futures = new ArrayList<>();
        try {
            Mat[] cube = new Mat[6];
            for (int i = 0; i < 6; i++) {
              //  cube[i] = sideCubeMapImage(mat, i, targetWidth, targetHeight);
                  ListenableFuture<HashMap<Integer,Mat>> listenableFuture = executorService.submit(new MatHandel(mat,i,targetWidth,targetHeight));
                Futures.addCallback(listenableFuture, new FutureCallback<HashMap<Integer,Mat>>() {
                    public void onSuccess(HashMap<Integer,Mat> result) {
                      for(int i:result.keySet()){
                          cube[i]=result.get(i);
                      }
                    }
                    public void onFailure(Throwable t) {
                      //  LOG.info("Add result value into value list error.", t);
                        throw new RuntimeException(t);
                    }
                },executorService);
                futures.add(listenableFuture);
            }
            ListenableFuture<List<HashMap<Integer,Mat>>> allAsList = Futures.allAsList(futures);
            allAsList.get();
            return cube;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            pool.shutdown();
        }
      return null;
    }

    class MatHandel implements  Callable<HashMap<Integer,Mat>>{
        private Mat mat;
        private int index;
        private int width;
        private int height;
        public MatHandel( Mat mat,int index, int width, int height){
            this.mat=mat;
            this.index=index;
            this.width=width;
            this.height=height;
        }
        public HashMap<Integer,Mat> call() throws Exception {
            System.out.println("call execute..");
            Mat mat = sideCubeMapImage(this.mat, index, width, height);
            //   TimeUnit.SECONDS.sleep(1);
            HashMap<Integer,Mat> matHashMap=new HashMap<>();
            matHashMap.put(index,mat);
            return matHashMap;
        }
    }
    /**
     * 全景图切割，单面处理
     * @param source
     * @param sideId
     * @param sideWidth
     * @param sideHeight
     * @return
     */
    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);
            }
        }

        /**
         if (result.cols() != width || result.rows() != height ||
         result.type() != source.type()) {
         result = new Mat(width, height, source.type());
         }**/

        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\\pano_f.jpg", result);
         //   Mat endst = new Mat();
           // Imgproc.resize(result, endst, new Size(240,240), 0, 0, Imgproc.INTER_LINEAR);
           // ConverUtil.matSave(this.saveUrl+"thumb.jpg", endst);
        }
        else if (sideId == 1)
        {
            //ConverUtil.matSave(this.saveUrl+"pano_r.jpg", result);
        }
        else if (sideId == 2)
        {
          //  ConverUtil.matSave(this.saveUrl+"pano_b.jpg", result);
        }
        else if (sideId == 3)
        {
            //ConverUtil.matSave(this.saveUrl+"pano_l.jpg", result);
        }
        else if (sideId == 4)
        {
            result= rotateRight(result,1);
           // ConverUtil.matSave(this.saveUrl+"pano_u.jpg", mat);
        }
        else if (sideId == 5)
        {
            result= rotateRight(result,0);
           // ConverUtil.matSave(this.saveUrl+"pano_d.jpg", mat);
        }

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

        return result;
    }


    /**
     * 图像整体向左旋转90度
     *
     * @param src Mat
     * @return 旋转后的Mat
     */
    public static Mat rotateRight(Mat src,int flipCode) {
        Mat tmp = new Mat();
        // 此函数是转置、（即将图像逆时针旋转90度，然后再关于x轴对称）
        Core.transpose(src, tmp);
        Mat result = new Mat();
        // flipCode = 0 绕x轴旋转180， 也就是关于x轴对称
        // flipCode = 1 绕y轴旋转180， 也就是关于y轴对称
        // flipCode = -1 此函数关于原点对称
        Core.flip(tmp, result, flipCode);
        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;
    }

}

 

 

工具类 

package com.hgj.exhibition.imagehandel;

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;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferByte;
import java.io.*;
import java.net.URL;

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());
    }
}
java全自动生成krpano全景漫游-部分源码
11-19
krpano java
独辟蹊径：逆推Krpano切图算法，实现在浏览器切多层级瓦片图
liuqinrui520的博客
10-03 2051
1、内附DEMO和源码，带你了解krpano切图，一步一步推理出Krpano多分辨率切图算法； 2、了解瓦片地图金字塔模型； 3、这是一个有趣的过程；
全景图剪切程序Sphere2Cube（一张全景生成六张立方体天空盒图Cubmap）
热门推荐
jaccen的专栏
07-26 1万+
1.介绍   将一张全景图片贴在立方体天空盒上，需要uv进行映射，分别对应六个面的纹理；  2.实现  查阅了网上，发现大概有如下几种实现方式； 基于opencv进行分割，  保存出6张图片 基于opengl，通过改变LookAt摄像机方向，获取6张texture通过FBO，再通过glreadpixel读回数据进行保存； 由于直接需要将数据做cubmap，所以我实现的方式是：将全景图片分...
根据krpano切片还原成全景图
u010674395的专栏
10-25 6537
分享部分代码 $id = '1.tiles'; $f = array('b', 'd', 'f', 'l', 'r', 'u'); $root = dirname(__file__) . '/' . $id; $max = 0; $lists = array(); // 获得最大层数和最大层数内的图片集 getDownloadImage($root, $arr);
【昼伏夜出】krpano vr 将瓦片图和立方体图还原成全景图
liuqinrui520的博客
07-26 1210
将krpano切出来的瓦片图，还原成全景图
基于java和vue进行krpano全景编辑器开发方案
weixin_28749189的博客
03-02 1344
总之，Java实现基于Krpano的全景编辑器方案需要熟悉Java Web开发和Krpano引擎开发以及相关的Web前端技术和数据库知识。同时，需要考虑用户需求和系统性能等方面，确保编辑器的易用性和可扩展性。Krpano是一款基于Flash和HTML5技术的全景虚拟现实展示引擎，其提供了丰富的API和插件，可以方便地创建交互式全景场景。2.集成Krpano引擎，使用Krpano提供的API和插件来创建和编辑全景场景。4.实现上传和下载功能，允许用户上传全景图像和相关资源，以及下载编辑后的全景场景。
ImagesUtil java图片操作 缩放图像、切割图像、图像类型转换、彩色转黑白、文字水印、图片水印等
alexgaoyihang的专栏
03-22 2061
import java.awt.AlphaComposite; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.Toolkit; import java.awt.color
【krpano工具】java调用制作全景图
m0_69253358的博客
10-09 1015
【krpano】【krpano】
Java实现功能化krpano
qq_38171693的博客
04-15 2165
Java实现功能化krpano 最近公司要求将一些图片实现vr漫游浏览，在网上找了一些资源发现一个名为krpano的工具可以实现这个功能，用这个工具实现其实很简单，首先解压这个工具，然后在网上找激活码将这个工具激活，激活后打开这个文件夹 当这个bat文件执行完后会在原图片存储位置生成一个叫vtour的文件夹； 闲话不多说下面介绍如何使用Java功能化这个工具； 实现原理 下载krpano后使用...
基于java后端的krpano实现
02-28
基于java后端的krpnao实现，分离方法代码和执行代码，增加了背景音乐，载入进度条和底部logo图的功能。
基于java后端的 krpano 功能化
小浩子的博客
08-18 9464
最近领导要求全景图的展示效果跟XX公司做的一样，仔细研究了一下XX公司的效果，发现用的是krpano，了解了krpano后，就要将krpano功能化，做成一个功能。很多全景公司采用krpano做，只要集成了一个krpano，效果也可以做的跟他们一样。难点是，krpano每生成处理一张全景图，都会生成很多个文件夹，怎么将它功能化？第一件想到的当然是百度！可是没找到有价值的情报。 于是google，找到
如何使用java代码自动生成对应的krpano全景
qq_35989280的博客
09-10 1753
由于公司业务的需求，需要对app中用户与全景的数据对接到web页面上，就需要使用到krpano全景工具，这个工具可以到百度进行搜索，到对应的官网上面就可以进行下载了。 但是关于对krpano全景工具进行功能化，进行自动生成的教程和博客的话，就少之又少，因为是新手，我也是通过参考下面两个网站，来创建一个自己的生成全景工具。 http://blog.csdn.net/u012084981/arti
纯java实现全景图切割(无需opencv)
liuwenmin_123的博客
05-15 546
每个面再进行切割成不同层级和像素。获取像素点上的三色数组。
java全自动生成krpano全景漫游
大大的博客
07-30 1万+
之前有需求想把krpano功能化，让后台全自动生成，但是在网上并没有看到相关的帖子，于是我就对krpano研究了一天，总算给实现了，随着VR的发展，这项技术肯定会有更多的人学习，我就把我研究出来的解决过程分享给大家吧！！！ 准备工作：   1.下载krpano-1.19-pr8（我用的是这个版本），下载地址：https://krpano.com/download/，至于破解我就不讲了，网上有很...
java bufferedimage 转byte,如何在Java中将byte []转换为BufferedImage？
weixin_33085941的博客
02-27 359
I'm posting this thread because I have some difficulties to deal with pictures in Java. I would like to be able to convert a picture into a byte[] array, and then to be able to do the reverse operatio...
java的image数组_Java：BufferedImage到字节数组并返回
weixin_36084686的博客
02-27 625
Java：BufferedImage到字节数组并返回我看到一些人有类似的问题，但我还没有find我正在寻找的东西。所以，我有一个方法读取input图像，并将其转换为字节数组：File imgPath = new File(ImageName); BufferedImage bufferedImage = ImageIO.read(imgPath); WritableRaster raster = ...
Java整合OpenCV实现全景图切割合并
技术交流，进来交个朋友
11-02 5260
一共分为三步实现： 1，windows安装OpenCV 2，springboot整合OpenCV 3，实现全景图切割合并 windows安装OpenCV 下载OpenCV 官网下载地址：https://opencv.org/releases/ 这里下载的是windows版本的，如需下载安装lunix版本，请移步： Lunix安装/编译/部署OpenCV4.5.2生成so文件 下载完成后得到exe程序安装包 运行exe安装包后得到 到这一步其实就已经完成了，特别简单！！！ 但是我当时在网上看的时候好多
在java中使用OpenCV 进行全景图切割与拼接
李鬼989的专栏
03-19 5161
参考资料 http://blog.csdn.net/qq_30832659/article/details/52494713 环境配置 下载opencv3.0 http://nchc.dl.sourceforge.net/project/opencvlibrary/opencv-win/3.0.0/opencv-3.0.0.exe 配置系统环境变量 将上一步下载文件解压后，大概得到2....
C++ 使用opencv实现全景图切割
qq_33620771的博客
08-12 1095
全景图六张图片的点 float M_PI = 3.14159265358979323846f; float faceTransform[6][2] = { {0, 0}, {M_PI / 2,0}, {M_PI,0}, {-M_PI / 2,0}, {0,-M_PI / 2}, {0,M_PI / 2} }; c++实现源码 // ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 //...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值