泊松融合-Possion Blending

最新推荐文章于 2023-04-17 00:45:38 发布
最新推荐文章于 2023-04-17 00:45:38 发布
阅读量4.5k 收藏 14
点赞数 2
分类专栏： 图像处理 opencv 文章标签： 泊松融合 Opencv possion blending
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37059483/article/details/78494650
版权

  最近事情比较多，很多之前捣鼓过的东西也没有去进行一个很好的整理，马上又要进入毕业开题的节奏，机器学习也没有一个很好的掌握，泊松融合是之前很久研究了一段时间，说句实话，里面的数学确实复杂，我没有深入，再加之最后我跑的结果实在是太慢，最近小波多聚焦融合的代码也实现，后面会更新。

主要参考博客1：http://eric-yuan.me/poisson-blending/
主要参考博客2:http://blog.csdn.net/hjimce/article/details/45716603
主要参考博客3:http://blog.csdn.net/wd1603926823/article/details/49867069
主要参考博客4：http://blog.csdn.net/baimafujinji/article/details/46787837

关于图像融合
  作为图像融合方法，我们的目标是将源图像中的对象或纹理无缝融合到目标图像中，这里是一个例子：

这里写图片描述

我们打算把第一张图像中的狗（或熊？），第二张图像中的两个孩子放入第三张图像中的区域。最简单的方法是将第一张和第二张图像的像素复制并粘贴到第三张图像中，结果如下所示：

这里写图片描述

奇怪的是，在这些地区我们可以看到非常明显的差异，因为这三个来源的水的颜色是不同的，即使背景相匹配，我们也可以看到这些地区之间的接缝。为什么？

  我们的人的视觉比图像的整体强度对梯度更敏感，也就是说，我们不知道每个像素的确切值，但是如果值在某处变化，我们可以很容易地知道它的变化，事实上，导致我们的目标：克隆到另一个图像的像素，但让颜色不会突然改变，即最大限度地保留源区域的梯度。这个结果比上面的要好得多：

这里写图片描述

泊松混合概述
泊松混合是梯度域图像处理方法之一，也许下面的图片可以很好的
解释：
这里写图片描述

  • v - 图像中某个区域的渐变（作为矢量）
  • g - 选定区域的来源（狗熊，儿童…）
  • f * - 域S中存在的已知函数（上面第三个源中的水）
  • f - 存在于域Ω中的未知函数
  • Ω - 现在放在域S上的区域g（目标背景）
  • ∂Ω - 源区域和目标区域之间的边界

所以其实我们要做的只不过是给定矢量场v，找出优化的未知区域f的值。

这里写图片描述

其解是泊松方程的解:
这里写图片描述

其中div v = ∂v/∂x+∂v/∂y， 是梯度场的发散性质，Δ是拉普拉斯算子：
这里写图片描述

将拉普拉斯算子应用于泊松方程，我们可以得到：

div G = -4 f(x,y) + f(x-1,y) + f(x,y-1) + f(x+1,y) + f(x,y+1)


1-D EXAMPLE
这里写图片描述
假设我们要将左图像（4，3，5，4）的红色部分复制到右图像中。
  首先，我们得到了上左图的渐变（梯度），如图中红色条形上方数值所示，现在我们将这些像素移动到右手边的图像上，而不会突然改变值，所以我们要：
这里写图片描述

这里写图片描述

我们可以发现，上面的矩阵是核（-2 4 -2）的卷积，因为每个像素值都受到两个相邻像素的影响，这与2D情况下的拉普拉斯算子非常相似，每个像素值都受到影响由四个相邻的像素（上，下，左，右）来确定。


2-D EXAMPLE

这里写图片描述
假设我们要将一些像素复制到上面图像的白色区域（红色像素是边界像素），我们通过使用与1D情况相同的方程来进行：

Ax = b

其中 A是一个N×N矩阵，N是我们要复制的像素的数量，在这种情况下，N = 10。 

for i=1:row number
    for j=1:col number
        if(i==j)
            matrix(i, j)=-4
        elif(adjacent(pixel(j), pixel(i)))
            matrix(i, j)=1
        else
            matrix(i, j)=0
        end
    end
end

所以在这种情况下矩阵是这样的：
这里写图片描述
(备注：)我个人觉得有上述代码的不出来我圈出来的四个红色方框的值，可能是我理解有问题，有明白的朋友望告知。

在这个等式中，b是一个N元素矢量，并且由下式创建：

b[i] = div ( G( Source(x,y) ) ) + Neighbor(target i) ; i=1..N

div v 可以用本文前面的公式计算，Neighbour意味着像素i的4个邻居属于边界，例如：
Neighbor(pixel 1) are pixels left, up, right;
Neighbor(pixel 8) are pixels left, up;
Neighbor(pixel 5) is pixels up.

如果我们知道矩阵A和向量b，就可以计算向量x，它是目标图像内像素的值。

x = A \ b（’\’表示矩阵左除）
或者x = A -1 * b

这篇文章基本上就是第一篇博客抄录过来的，里面还提到关于泊松方程快速解法的相关知识，我也没去研究，不做详细说明。
博主链接已给出，快速解法链接如下：
点我开始跳转


3.Code

测试代码如下：


// Poisson Blending
// Using stupid way (just solving Ax = b)
// Author: Eric Yuan
// Blog: http://eric-yuan.me
// You are free to use the following code for ANY purpose.
// 
// You can improve it by using advanced methods, 
// About solving discrete Poisson Equation using Jacobi, SOR, Conjugate Gradients, and FFT
// see here: http://www.cs.berkeley.edu/~demmel/cs267/lecture24/lecture24.html
// 

#include "opencv2/core/core.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <math.h>
#include <iostream>
#include <time.h>

using namespace cv;
using namespace std;

#define elif else if
#define ATD at<double>


// calculate horizontal gradient, img(i, j + 1) - img(i, j)
Mat 
    getGradientXp(Mat &img){
        int height = img.rows;
        int width = img.cols;
        Mat cat = repeat(img, 1, 2);

        Rect roi = Rect(1, 0, width, height);
        Mat roimat = cat(roi);
        return roimat - img;
}

// calculate vertical gradient, img(i + 1, j) - img(i, j)
Mat 
    getGradientYp(Mat &img){
        int height = img.rows;
        int width = img.cols;
        Mat cat = repeat(img, 2, 1);

        Rect roi = Rect(0, 1, width, height);
        Mat roimat = cat(roi);
        return roimat - img;
}

// calculate horizontal gradient, img(i, j - 1) - img(i, j)
Mat 
    getGradientXn(Mat &img){
        int height = img.rows;
        int width = img.cols;
        Mat cat = repeat(img, 1, 2);

        Rect roi = Rect(width - 1, 0, width, height);
        Mat roimat = cat(roi);
        return roimat - img;
}

// calculate vertical gradient, img(i - 1, j) - img(i, j)
Mat 
    getGradientYn(Mat &img){
        int height = img.rows;
        int width = img.cols;
        Mat cat = repeat(img, 2, 1);

        Rect roi = Rect(0, height - 1, width, height);
        Mat roimat = cat(roi);
        return roimat - img;
}

int
    getLabel(int i, int j, int height, int width){
        return i * width + j;
}

// get Matrix A.
Mat
    getA(int height, int width){

        Mat A = Mat::eye(height * width, height * width, CV_64FC1);
        A *= -4;
        Mat M = Mat::zeros(height, width, CV_64FC1);
        Mat temp = Mat::ones(height, width - 2, CV_64FC1);
        Rect roi = Rect(1, 0, width - 2, height);
        Mat roimat = M(roi);
        temp.copyTo(roimat);
        temp = Mat::ones(height - 2, width, CV_64FC1);
        roi = Rect(0, 1, width, height - 2);
        roimat = M(roi);
        temp.copyTo(roimat);
        temp = Mat::ones(height - 2, width - 2, CV_64FC1);
        temp *= 2;
        roi = Rect(1, 1, width - 2, height - 2);
        roimat = M(roi);
        temp.copyTo(roimat);

        for(int i=0; i<height; i++){
            for(int j=0; j<width; j++){
                int label = getLabel(i, j, height, width);
                if(M.ATD(i, j) == 0){
                    if(i == 0)  A.ATD(getLabel(i + 1, j, height, width), label) = 1;
                    elif(i == height - 1)   A.ATD(getLabel(i - 1, j, height, width), label) = 1;
                    if(j == 0)  A.ATD(getLabel(i, j + 1, height, width), label) = 1;
                    elif(j == width - 1)   A.ATD(getLabel(i, j - 1, height, width), label) = 1;
                }elif(M.ATD(i, j) == 1){
                    if(i == 0){
                        A.ATD(getLabel(i + 1, j, height, width), label) = 1;
                        A.ATD(getLabel(i, j - 1, height, width), label) = 1;
                        A.ATD(getLabel(i, j + 1, height, width), label) = 1;
                    }elif(i == height - 1){
                        A.ATD(getLabel(i - 1, j, height, width), label) = 1;
                        A.ATD(getLabel(i, j - 1, height, width), label) = 1;
                        A.ATD(getLabel(i, j + 1, height, width), label) = 1;
                    }
                    if(j == 0){
                        A.ATD(getLabel(i, j + 1, height, width), label) = 1;
                        A.ATD(getLabel(i - 1, j, height, width), label) = 1;
                        A.ATD(getLabel(i + 1, j, height, width), label) = 1;
                    }elif(j == width - 1){
                        A.ATD(getLabel(i, j - 1, height, width), label) = 1;
                        A.ATD(getLabel(i - 1, j, height, width), label) = 1;
                        A.ATD(getLabel(i + 1, j, height, width), label) = 1;
                    }
                }else{
                    A.ATD(getLabel(i, j - 1, height, width), label) = 1;
                    A.ATD(getLabel(i, j + 1, height, width), label) = 1;
                    A.ATD(getLabel(i - 1, j, height, width), label) = 1;
                    A.ATD(getLabel(i + 1, j, height, width), label) = 1;
                }
            }
        }
        return A;
}

// Get the following Laplacian matrix
// 0  1  0
// 1 -4  1
// 0  1  0
Mat
    getLaplacian(){
        Mat laplacian = Mat::zeros(3, 3, CV_64FC1);
        laplacian.ATD(0, 1) = 1.0;
        laplacian.ATD(1, 0) = 1.0;
        laplacian.ATD(1, 2) = 1.0;
        laplacian.ATD(2, 1) = 1.0;
        laplacian.ATD(1, 1) = -4.0; 
        return laplacian;
}

// Calculate b
// using convolution.
Mat
    getB1(Mat &img1, Mat &img2, int posX, int posY, Rect ROI){
        Mat Lap;
        filter2D(img1, Lap, -1, getLaplacian());
        int roiheight = ROI.height;
        int roiwidth = ROI.width;
        Mat B = Mat::zeros(roiheight * roiwidth, 1, CV_64FC1);
        for(int i=0; i<roiheight; i++){
            for(int j=0; j<roiwidth; j++){
                double temp = 0.0;
                temp += Lap.ATD(i + ROI.y, j + ROI.x);
                if(i == 0)              temp -= img2.ATD(i - 1 + posY, j + posX);
                if(i == roiheight - 1)  temp -= img2.ATD(i + 1 + posY, j + posX);
                if(j == 0)              temp -= img2.ATD(i + posY, j - 1 + posX);
                if(j == roiwidth - 1)   temp -= img2.ATD(i + posY, j + 1 + posX);
                B.ATD(getLabel(i, j, roiheight, roiwidth), 0) = temp;
            }
        }
        return B;
}

// Calculate b
// using getGradient functions.
Mat
    getB2(Mat &img1, Mat &img2, int posX, int posY, Rect ROI){
        Mat grad = getGradientXp(img1) + getGradientYp(img1) + getGradientXn(img1) + getGradientYn(img1);
        int roiheight = ROI.height;
        int roiwidth = ROI.width;
        Mat B = Mat::zeros(roiheight * roiwidth, 1, CV_64FC1);
        for(int i=0; i<roiheight; i++){
            for(int j=0; j<roiwidth; j++){
                double temp = 0.0;
                temp += grad.ATD(i + ROI.y, j + ROI.x);
                if(i == 0)              temp -= img2.ATD(i - 1 + posY, j + posX);
                if(i == roiheight - 1)  temp -= img2.ATD(i + 1 + posY, j + posX);
                if(j == 0)              temp -= img2.ATD(i + posY, j - 1 + posX);
                if(j == roiwidth - 1)   temp -= img2.ATD(i + posY, j + 1 + posX);
                B.ATD(getLabel(i, j, roiheight, roiwidth), 0) = temp;
            }
        }
        return B;
}

// Solve equation and reshape it back to the right height and width.
Mat
    getResult(Mat &A, Mat &B, Rect &ROI){
        Mat result;
        solve(A, B, result);
        result = result.reshape(0, ROI.height);
        return  result;
}



// img1: 3-channel image, we wanna move something in it into img2.
// img2: 3-channel image, dst image.
// ROI: the position and size of the block we want to move in img1.
// posX, posY: where we want to move the block to in img2

Mat
    poisson_blending(Mat &img1, Mat &img2, Rect ROI, int posX, int posY){

        int roiheight = ROI.height;
        int roiwidth = ROI.width;
        Mat A = getA(roiheight, roiwidth);

        // we must do the poisson blending to each channel.
        vector<Mat> rgb1;
        split(img1, rgb1);
        vector<Mat> rgb2;
        split(img2, rgb2);

        vector<Mat> result;
        Mat merged, res, Br, Bg, Bb;
        // For calculating B, you can use either getB1() or getB2()
        Br = getB1(rgb1[0], rgb2[0], posX, posY, ROI);
        //Br = getB2(rgb1[0], rgb2[0], posX, posY, ROI);
        res = getResult(A, Br, ROI);
        result.push_back(res);
        cout<<"R channel finished..."<<endl;
        Bg = getB1(rgb1[1], rgb2[1], posX, posY, ROI);
        //Bg = getB2(rgb1[1], rgb2[1], posX, posY, ROI);
        res = getResult(A, Bg, ROI);
        result.push_back(res);
        cout<<"G channel finished..."<<endl;
        Bb = getB1(rgb1[2], rgb2[2], posX, posY, ROI);
        //Bb = getB2(rgb1[2], rgb2[2], posX, posY, ROI);
        res = getResult(A, Bb, ROI);
        result.push_back(res);
        cout<<"B channel finished..."<<endl;

        // merge the 3 gray images into a 3-channel image 
        merge(result,merged);
        return merged; 
}

int 
    main(int argc, char** argv)
{
    long start, end;
    start = clock();

    Mat img1, img2;
    Mat in1 = imread("girl.jpg");
    Mat in2 = imread("ocean.jpg");
    imshow("src", in1);
    imshow("dst", in2);
    in1.convertTo(img1, CV_64FC3);
    in2.convertTo(img2, CV_64FC3);

    Rect rc = Rect(92, 40, 55, 90);
    Mat result = poisson_blending(img1, img2, rc, 184, 220);
    result.convertTo(result, CV_8UC1);
    Rect rc2 = Rect(184, 220, 55, 90);
    Mat roimat = in2(rc2);
    result.copyTo(roimat);

    end = clock();
    cout<<"used time: "<<((double)(end - start)) / CLOCKS_PER_SEC<<" second"<<endl;
    imshow("roi", result);
    imshow("result", in2);

    waitKey(0);
    return 0;
}

opencv3已经有相应封装好的类直接调用就好

#include<opencv2\opencv.hpp>

using namespace cv;
int main()
{
  Mat src = imread("images/015-CT.png");
  Mat dst = imread("images/015-MR-T2.png");
  if(src.empty()||dst.empty())
  {
    return 0;
  }

  Mat src_mask = 255 * Mat::ones(src.rows, src.cols, src.depth());

  Point center(dst.cols / 2, dst.rows / 2);


  Mat normal_clone;
  Mat mixed_clone;

  seamlessClone(src, dst, src_mask, center, normal_clone, NORMAL_CLONE);
  seamlessClone(src, dst, src_mask, center, mixed_clone, MIXED_CLONE);

  imshow("normal_clone",normal_clone);
  imshow("mixed_clone",mixed_clone);
  waitKey(0);
  return 1;
}

关于最后的效果，并没有论文中展示的那么好
可能与我选取的图片也有关系以及对opencv代码的
理解，不过不得不承认opencv的代码优化确实做的好
，非常的快。

青雲-吾道乐途
关注
  • 2
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
图像泊松融合(possion blending)算法
01-24
该代码是matlab代码，描述图像的泊松融合算法，该融合算法在一般情况下优于拉普拉斯融合，是目前传统算法中，通用的较好的融合算法
【计算机图形学】poisson Image Editing泊松图像融合算法
没有最好，只有更好
08-29 3584
为了解决将源图像的一部分区域ROI(Region of Interest)直接复制到目标图像时，边界过渡不自然的问题，如下图中间所示。本论文提出seamless cloning无缝融合算法，其主要实现思想是，首先把ROI的梯度场覆盖到目标图像的梯度场上，得到融合图像的梯度场，对其求偏导，得到散度b，然后通过非边界点与拉普拉斯卷积核进行卷积，并且通过边界点的约束条件，得到稀疏矩阵A，最后通过求解Af=b方程，f就是融合图像的每个像素点的R,G,B值。...
泊松融合原理浅析
TracelessLe的专栏
02-04 9411
前言 参考资料 [1] OpenCV Docs - Seamless Cloning [2] OpenCV GitHub - opencv/modules/photo/src/seamless_cloning.cpp [3] OpenCV GitHub - opencv/modules/photo/src/seamless_cloning_impl.cpp [4] csdn - 图像处理（十二）图像融合(1)Seamless cloning泊松克隆-Siggraph 2004 [5] 知乎 - 12. 泊松
泊松融合
qq_38284961的博客
03-23 2537
原文地址：http://blog.csdn.net/hjimce/article/details/45716603 作者：hjimce 本篇博文主要讲解2004年Siggraph的经典paper：《Poisson Image Editing》，在图像融合领域，融合效果最牛逼的paper。讲这个算法，我没打算讲太多理论的公式，理论的东西，对于大部分数学比较差的人来说看了就头晕。什么散度、拉普拉斯...
图像融合之泊松融合（Poisson Blending）
ChuanjieZhu
04-23 2万+
论文为2003Patrick P´erez 《Poisson Image Editing》，Microsoft Research UK 译作，泊松图像编辑，因为此算法的功能有很多： 1.Insertion 2. Feature exchange 3. Inserting objects with holes 4. Texture flattening 5.Loc...
基于领域梯度的泊松图像融合 (Gradient domain fusion)
qq_52170360的博客
04-17 421
泊松融合可以解决原图像中的部分区域复制到目标图像的区域Ω\OmegaΩ中，边界过渡不自然的问题。主要思想是：融合需要保证使前景部分区域与背景而言，尽量平滑并且保持边界一致。首先将该部分区域的梯度场覆盖到目标图像的梯度场上，得到融合图像的梯度场，对其求偏导得到散度b，然后通过非边界点与拉普拉斯卷积核进行卷积，并且通过边界点的约束条件，得到稀疏矩阵A，最后通过求解AfbAf=bAfb的方程得到ffffff就是融合图像的每个像素点RGB值。
泊松融合——用了拉普拉斯但没有金字塔
zcg1942的博客
11-04 720
这样解出来的融合区域的值和参考图不一致，但是梯度近似，且具体的值是基于边界和梯度求解出来的，所以整体会和背景处于同一亮度/颜色水平。但如果参考图对应的mask不够精细，参考图本身的梯度和背景图仍然差异过大，这样的引导场得到的融合效果还是不佳。因为人眼对二阶导是更敏感的，所以只要我们指定了融合区域内部的梯度值，并且知道融合边界处的值，理论上就可以求解出来。上图d使用了参考图和背景图的极大值，相比于b的保守引导场，尽可能保留了更多的纹理信息，不至于在融合区域保留参考图的背景而造成突兀。这样从一阶导到了二阶导。
泊松融合matlab 实现 possion blending
01-24
泊松融合 能够将两个图片无缝衔接，过渡自然。
泊松分布-JAVA程序图形界面化
12-06
用JAVA开发的泊松分布的图形界面，示例泊松随机过程的生成。可以设置参数lambda，生成到达时间个数，是否批量，输入生成BI的最大值等。点生成按钮，生成坐标的图形。
数据分析实战 - 泊松回归-航班数据分析
11-11
在数据分析实战中，泊松回归是一种常用于计数数据的统计建模方法，尤其适合处理非负整数计数数据。在这个案例中，我们将利用Python编程语言和泊松回归对航班数据进行分析，以理解O形环在航天飞机发射过程中的热损伤...
原创matlab实现泊松过程样本轨道模型及参数估计-possion1.m
08-12
原创matlab实现泊松过程样本轨道模型及参数估计-possion1.m 详见附件
泊松融合vs图像和谐化
专业主义
06-09 1614
大的方向来说图像融合可分为三个层次：像素级融合、特征级融合和决策级融合。传统的融合算法有、、。
【图像融合】泊松彩色图像融合【含Matlab源码 1830期】
Matlab领域的博客
01-16 266
泊松彩色图像融合 完整的代码，方可运行；可提供运行操作视频！适合小白！
随机过程：复合泊松过程
ResumeProject的博客
01-02 8378
E(Nt)=E((λt)kk!e−λt)=λt（泊松过程的期望均值都为λ）E(N_t)=E(\frac{(\lambda t)^k}{k!}e^{-\lambda t})=\lambda t（泊松过程的期望均值都为\lambda）E(Nt​)=E(k!(λt)k​e−λt)=λt（泊松过程的期望均值都为λ） 复合泊松过程de定义级性质 Yt=∑n=1Ntξn,Nt为泊松过程，ξn独立同分布，则对于任意t≥0Y_t=\sum_{n=1}^{N_t} \xi_n ,N_t为泊松过程，\xi_n独立同分布，则对于
泊松融合：Poisson Image Editing
qq_34901691的博客
08-19 1313
Poisson Image Editing 文章目录Poisson Image EditingPoisson solution to guided interpolationSeamless cloning 前面的文章详细地解读了抠图方面的论文Poisson Matting，接下来将解读与泊松抠图互为逆过程的泊松融合算法，与泊松抠图一样，泊松融合的核心也是对满足狄利克雷边界的泊松方程的求解。 Poisson solution to guided interpolation 如下图所示，首先我们定义插值问题：
计算机视觉预备知识,计算机视觉：泊松融合
weixin_35039377的博客
06-27 638
Poisson Blending4:更多用途Poisson Blending0:预备知识(图像的梯度、泊松方程)进入正题之前，我们先补充一下基础知识。图像的梯度什么是图像的梯度？我们可以把图像看成是一个离散的函数，函数在某一点的梯度是它的导数，那么根据导数的定义，我们可以把图像在某一点的梯度定义为：下一个点的像素值-这个点的像素值,即g(i)=f(i+1)-f(i)。至于下一个像素点在那个位置，要...
灰度共生矩阵的原理及实现(特征提取)-OpenCV
热门推荐
qingyun_wudaoletu的博客
10-20 7万+
最近在研究机器学习相关内容，后面会尽量花时间整理成一个系列的博客，然后朋友让我帮他实现一种基于SVR支持向量回归的图像质量评价方法，然而在文章的开头竟然发现 灰度共生矩阵这个陌生的家伙，于是便有此文。 主要参考博客1：http://blog.csdn.net/jialeheyeshu/article/details/51337225 主要参考博客2：http://blog.csdn....
泊松融合 python
最新发布
11-25
泊松融合是一种图像处理技术，通过将多幅图像进行叠加和融合，来生成一幅新的图像。而Python是一种广泛应用于科学计算和图像处理领域的编程语言。因此，泊松融合在Python中得到了广泛的应用和发展。 在Python中，可以使用OpenCV和numpy等库来实现泊松融合。首先，需要加载原始图像和目标图像，并通过OpenCV提供的函数获取它们的梯度信息。然后，利用numpy库来构建泊松方程，并通过迭代求解来实现泊松融合过程。最后，将融合后的图像保存到指定的路径中。 除了使用库函数，也可以通过编写自定义的泊松融合算法来实现。从原始图像中提取目标区域，计算梯度信息，然后利用泊松方程和迭代算法来实现融合过程。这需要对图像处理和数学知识有一定的了解，以及对Python编程语言有较高的熟练程度。 总的来说，泊松融合在Python中的实现有多种方式，可以根据具体的应用场景和需求来选择合适的方法。利用Python强大的科学计算和图像处理功能，可以轻松实现泊松融合算法，并应用于各种图像处理任务中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值