3D骨架提取

最新推荐文章于 2022-10-27 15:19:01 发布
最新推荐文章于 2022-10-27 15:19:01 发布
阅读量2.2k 收藏 22
点赞数 5
分类专栏： ITK 文章标签： 骨架提取 ITK
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43229348/article/details/121211612
版权

3D骨架提取算法的Python实现和C++实现，包括骨架提取以及写入树文件中：
在这里插入图片描述

（1）Python

import itk
# python -m pip install --upgrade pip
# python -m pip install itk-thickness3d

def OutputTXT(filePath, list_centerLinePoint):
    with open(filePath, "w+") as fout:
        fout.writelines(
            [" ".join([str(i) for i in centerLinePoint]) + "\n" for centerLinePoint in list_centerLinePoint])


def Collect26Neighbors(image, p_index):
    offset = [
        [-1, -1, 1], [0, -1, 1], [1, -1, 1], [-1, -1, 0], [0, -1, 0], [1, -1, 0], [-1, -1, -1], [0, -1, -1],
        [1, -1, -1],
        [-1, 0, 1], [0, 0, 1], [1, 0, 1], [-1, 0, 0], [1, 0, 0], [-1, 0, -1], [0, 0, -1], [1, 0, -1],
        [-1, 1, 1], [0, 1, 1], [1, 1, 1], [-1, 1, 0], [0, 1, 0], [1, 1, 0], [-1, 1, -1], [0, 1, -1], [1, 1, -1]]
    Np = [1 if image.GetPixel(tuple([p_index[i] + offset[l][i] for i in range(3)])) == 1 else 0 for l in range(26)]
    return Np


def ReturnId(p_index, list_centerLinePoint):
    # [(id, x, y, z, parentId, leftChildId, rightChildId),...]

    id = None
    for i in range(len(list_centerLinePoint)):
        if list_centerLinePoint[i][1:4] == list(p_index):
            id = list_centerLinePoint[i][0]
            break
    return id


def ReturnIndex(j, p_index):
    offset = [
        [-1, -1, 1], [0, -1, 1], [1, -1, 1], [-1, -1, 0], [0, -1, 0], [1, -1, 0], [-1, -1, -1], [0, -1, -1],
        [1, -1, -1],
        [-1, 0, 1], [0, 0, 1], [1, 0, 1], [-1, 0, 0], [1, 0, 0], [-1, 0, -1], [0, 0, -1], [1, 0, -1],
        [-1, 1, 1], [0, 1, 1], [1, 1, 1], [-1, 1, 0], [0, 1, 0], [1, 1, 0], [-1, 1, -1], [0, 1, -1], [1, 1, -1]]
    re_index = [p_index[i] + offset[j][i] for i in range(3)]
    return re_index


def ReturnJx(Np, count=1):
    ct = 0
    j = []
    for i in range(26):
        if Np[i] == 1:
            j.append(i)
            ct += 1
        if count == ct:
            break
    return j[0] if count == 1 else j

def MarkAllPoints(image):
    size = image.GetLargestPossibleRegion().GetSize()
    id_ini = 0
    list_centerline_vec = []
    for i in range(size[0] - 1):
        for j in range(size[1] - 1):
            for k in range(size[2] - 1):
                index = (i, j, k)
                value = image.GetPixel(index)
                if value == 0:
                    continue
                else:
                    list_centerline_vec.append([id_ini, i, j, k])  # [(id, x, y, z),...]
                    id_ini = id_ini + 1
    return list_centerline_vec


def GenerateTree(image):
    centerline_vec = MarkAllPoints(image)
    for i in range(len(centerline_vec)):
        p_index = centerline_vec[i][1:4]
        Np = Collect26Neighbors(image, p_index)
        sum = 0
        for j in range(26):
            sum += Np[j]
        if sum == 0:
            centerline_vec[i].extend([-1, -1, -1])
        #  判断是端点的情况
        if sum == 1:
            j = ReturnJx(Np, count=1)
            if j <= 12:
                parent_index = ReturnIndex(j, p_index)
                centerline_vec[i].extend([ReturnId(parent_index, centerline_vec), -1, -1])
            # 如果只有一个childId一律设置成左childId
            if j >= 13:
                leftChild_index = ReturnIndex(j, p_index)
                centerline_vec[i].extend([-1, ReturnId(leftChild_index, centerline_vec), -1])
        if sum == 2:
            j = ReturnJx(Np, count=2)
            parent_index = ReturnIndex(j[0], p_index)
            leftChild_index = ReturnIndex(j[1], p_index)
            centerline_vec[i].extend(
                [ReturnId(parent_index, centerline_vec), ReturnId(leftChild_index, centerline_vec), -1])
        if sum == 3:
            j = ReturnJx(Np, count=3)
            parent_index = ReturnIndex(j[0], p_index)
            leftChild_index = ReturnIndex(j[1], p_index)
            rightChild_index = ReturnIndex(j[2], p_index)
            centerline_vec[i].extend([ReturnId(parent_index, centerline_vec), ReturnId(leftChild_index, centerline_vec),
                                      ReturnId(rightChild_index, centerline_vec)])
    return centerline_vec


if __name__ == '__main__':
    input_filename = "3.nii.gz"
    # input_filename = "3_mask.nii.gz"
    img = itk.imread(input_filename)
    thining_map = itk.BinaryThinningImageFilter3D.New(img)
    # print(dir(thining_map))
    itk.imwrite(thining_map, "3_thining.nii.gz")
    image = thining_map.GetOutput()
    centerline_vec_final = GenerateTree(image)
    path = "CenterlinePoints.txt"
    OutputTXT(path, centerline_vec_final)

（2）C++

#include "itkImage.h"
#include "itkImageFileReader.h"
#include "itkImageFileWriter.h"
#include "itkBinaryThinningImageFilter3D.h"
#include "itkTestingMacros.h"
 // PNG对应
#include <itkPNGImageIOFactory.h>
// BMP对应
#include <itkBMPImageIOFactory.h>
// JPG对应
#include <itkJPEGImageIOFactory.h>
// mhd格式图像
#include <itkMetaImageIOFactory.h>
// nii格式图片
#include <itkNiftiImageIOFactory.h>


#include <iostream>
#include <cmath>
#include <ctime>
#include <fstream>
#include <string> 



const unsigned int Dimension = 3;
using PixelType = unsigned char;
using ImageType = itk::Image<PixelType, Dimension>;

typedef itk::Image<PixelType, Dimension> ImageType;
typedef itk::ImageFileReader<ImageType> ReaderType;
typedef itk::ImageFileWriter<ImageType> WriterType;
typedef itk::Point<PixelType, 3> PointType;


//下面是生成中心线树的代码
class CenterlinePoint {
public:
	int x;
	int y;
	int z;
	int id;
	int parentId;
	int liftChildId;
	int rightChildId;

};

//输出坐标TXT文件
void OutputTXT(const char* path, std::vector<CenterlinePoint> centerline_vec_final) {
	std::ofstream fout(path);
	if (fout) {
		for (int i = 0; i < centerline_vec_final.size(); i++) {
			fout << centerline_vec_final[i].id << " " << centerline_vec_final[i].x << " " << centerline_vec_final[i].y << " " << centerline_vec_final[i].z << " " << centerline_vec_final[i].parentId << " " << centerline_vec_final[i].liftChildId << " " << centerline_vec_final[i].rightChildId << std::endl;
		}
	}
	fout.close();
}

//对p的26邻接体素编号,并且改成0，1赋值（0：背景，1：前景）
void Collect26Neighbors(ImageType::Pointer image, int p_index[3], int *Np) {
	int offset[26][3] = {
	{-1,-1,1},{0,-1,1},{1,-1,1},{-1,-1,0},{0,-1,0},{1,-1,0},{-1,-1,-1},{0,-1,-1},{1,-1,-1},
	{-1,0,1},{0,0,1},{1,0,1},{-1,0,0},{1,0,0},{-1,0,-1},{0,0,-1},{1,0,-1},
	{-1,1,1},{0,1,1},{1,1,1},{-1,1,0},{0,1,0},{1,1,0},{-1,1,-1},{0,1,-1},{1,1,-1} };
	ImageType::IndexType index;
	ImageType::PixelType value;

	for (int l = 0; l < 26; l++) {
		index[0] = p_index[0] + offset[l][0];
		index[1] = p_index[1] + offset[l][1];
		index[2] = p_index[2] + offset[l][2];
		
		value = image->GetPixel(index);
		std::cout << int(value) << std::endl;
		if (value == 1) { Np[l] = 1; }
		else { Np[l] = 0; }
	}
}
int ReturnId(int p_index[3], std::vector<CenterlinePoint> centerline_vec) {
	int id = -1;
	for (int i = 0; i < centerline_vec.size(); i++) {
		if (centerline_vec[i].x == p_index[0] && centerline_vec[i].y == p_index[1] && centerline_vec[i].z == p_index[2]) {
			id = centerline_vec[i].id;
		}
	}
	return id;
}

void ReturnIndex(int re_index[3], int j, int p_index[3]) {
	int offset[26][3] = {
		{-1,-1,1},{0,-1,1},{1,-1,1},{-1,-1,0},{0,-1,0},{1,-1,0},{-1,-1,-1},{0,-1,-1},{1,-1,-1},
		{-1,0,1},{0,0,1},{1,0,1},{-1,0,0},{1,0,0},{-1,0,-1},{0,0,-1},{1,0,-1},
		{-1,1,1},{0,1,1},{1,1,1},{-1,1,0},{0,1,0},{1,1,0},{-1,1,-1},{0,1,-1},{1,1,-1} };
	re_index[0] = p_index[0] + offset[j][0];
	re_index[1] = p_index[1] + offset[j][1];
	re_index[2] = p_index[2] + offset[j][2];
}

int ReturnJ1(int Np[26]) {
	int j;
	for (int i = 0; i < 26; i++) {
		if (Np[i] == 1) {
			j = i;
		}
	}
	return j;
}

void ReturnJ2(int *j, int Np[26]) {
	int count = 0;
	for (int i = 0; i < 26; i++) {
		if (Np[i] == 1) {
			j[count++] = i;
		}
		if (count == 2)
			break;
	}
}

void ReturnJ3(int *j, int Np[26])
{
	int count = 0;
	for (int i = 0; i < 26; i++) {
		if (Np[i] == 1) {
			j[count++] = i;
		}
		if (count == 3)
			break;
	}
}

std::vector<CenterlinePoint> MarkAllPoints(ImageType::Pointer image)
{
	std::vector<CenterlinePoint> centerline_vec;
	ImageType::SizeType size = image->GetLargestPossibleRegion().GetSize();
	ImageType::IndexType index;
	ImageType::PixelType value;
	int id_ini = 0;
	for (int i = 1; i < size[0] - 1; i++) {
		for (int j = 1; j < size[1] - 1; j++) {
			for (int k = 1; k < size[2] - 1; k++) {
				index[0] = i;
				index[1] = j;
				index[2] = k;
				value = image->GetPixel(index);
				if (value == 0) { continue; }
				else {
					CenterlinePoint cpt;
					cpt.x = i;
					cpt.y = j;
					cpt.z = k;
					cpt.id = id_ini;
					id_ini = id_ini + 1;
					centerline_vec.push_back(cpt);
				}
			}
		}
	}
	return centerline_vec;
}

std::vector<CenterlinePoint> GenerateTree(ImageType::Pointer image) {
	std::vector<CenterlinePoint> centerline_vec;
	centerline_vec = MarkAllPoints(image);
	for (int i = 0; i < centerline_vec.size(); i++) {
		int p_index[3];
		p_index[0] = centerline_vec[i].x;
		p_index[1] = centerline_vec[i].y;
		p_index[2] = centerline_vec[i].z;
		int Np[26];
		Collect26Neighbors(image, p_index, Np);
		int sum = 0;
		for (int j = 0; j < 26; j++) {
			sum = sum + Np[j];
		}
		if (sum == 0) {
			centerline_vec[i].parentId = -1;
			centerline_vec[i].liftChildId = -1;
			centerline_vec[i].rightChildId = -1;
		}

		//判断是端点的情况
		if (sum == 1) {
			int j = ReturnJ1(Np);
			if (j <= 12) {
				int parent_index[3];
				ReturnIndex(parent_index, j, p_index);
				centerline_vec[i].parentId = ReturnId(parent_index, centerline_vec);
				centerline_vec[i].liftChildId = -1;
				centerline_vec[i].rightChildId = -1;
			}
			//如果只有一个childId一律设置成左childId
			if (j >= 13) {
				int liftChild_index[3];
				ReturnIndex(liftChild_index, j, p_index);
				centerline_vec[i].parentId = -1;
				centerline_vec[i].liftChildId = ReturnId(liftChild_index, centerline_vec);
				centerline_vec[i].rightChildId = -1;
			}
		}
		if (sum == 2) {
			int j[2];
			ReturnJ2(j, Np);
			int parent_index[3];
			ReturnIndex(parent_index, j[0], p_index);
			int liftChild_index[3];
			ReturnIndex(liftChild_index, j[1], p_index);
			centerline_vec[i].parentId = ReturnId(parent_index, centerline_vec);
			centerline_vec[i].liftChildId = ReturnId(liftChild_index, centerline_vec);
			centerline_vec[i].rightChildId = -1;
		}
		if (sum == 3) {
			int j[3];
			ReturnJ3(j, Np);
			int parent_index[3];
			ReturnIndex(parent_index, j[0], p_index);
			int liftChild_index[3];
			ReturnIndex(liftChild_index, j[1], p_index);
			int rightChild_index[3];
			ReturnIndex(rightChild_index, j[2], p_index);
			centerline_vec[i].parentId = ReturnId(parent_index, centerline_vec);
			centerline_vec[i].liftChildId = ReturnId(liftChild_index, centerline_vec);
			centerline_vec[i].rightChildId = ReturnId(rightChild_index, centerline_vec);
		}
	}
	return centerline_vec;
}

int main(int argc, char * argv[])
{
	// Verify the number of parameters in the command line
	if (argc == 2)
	{
		std::cerr << "Missing parameters." << std::endl;
		std::cerr << "Usage: " << std::endl;
		std::cerr << argv[0] << " inputImageFile outputImageFile" << std::endl;
		return EXIT_FAILURE;
	}
	const char * infilename = "3.nii";
	const char * outfilename = "3_thining.nii";

	// Read image
	//itk::ObjectFactoryBase::UnRegisterAllFactories();
	//itk::NiftiImageIOFactory::RegisterOneFactory();

	itk::ObjectFactoryBase::RegisterFactory(itk::NiftiImageIOFactory::New());
	// itk::ObjectFactoryBase::RegisterFactory(itk::MetaImageIOFactory::New()); mhd
	// itk::PNGImageIOFactory::New()或itk::BMPImageIOFactory::New() // 或itk::JPGImageIOFactory::New()
	using ReaderType = itk::ImageFileReader<ImageType>;
	ReaderType::Pointer reader = ReaderType::New();
	reader->SetFileName(infilename);

	ITK_TRY_EXPECT_NO_EXCEPTION(reader->Update());

	// Define the thinning filter
	using ThinningFilterType = itk::BinaryThinningImageFilter3D<ImageType, ImageType>;
	ThinningFilterType::Pointer thinningFilter = ThinningFilterType::New();

	ITK_EXERCISE_BASIC_OBJECT_METHODS(thinningFilter, BinaryThinningImageFilter3D, ImageToImageFilter);

	thinningFilter->SetInput(reader->GetOutput());
	ITK_TRY_EXPECT_NO_EXCEPTION(thinningFilter->Update());
	ImageType::Pointer image = thinningFilter->GetOutput();
	// 以二叉树的形式保存结果，本人非CS出身，如有问题欢迎指正。
	std::vector<CenterlinePoint> centerline_vec_final;
	centerline_vec_final = GenerateTree(image);
	const char* path = "CenterlinePoints.txt";
	OutputTXT(path, centerline_vec_final);
	// output to file
	// itk::ObjectFactoryBase::RegisterFactory(itk::MetaImageIOFactory::New());  mhd
	// itk::PNGImageIOFactory::New()或itk::BMPImageIOFactory::New() // 或itk::JPGImageIOFactory::New()
	using WriterType = itk::ImageFileWriter<ImageType>;
	WriterType::Pointer writer = WriterType::New();
	writer->SetInput(thinningFilter->GetOutput());
	writer->SetFileName(outfilename);

	ITK_TRY_EXPECT_NO_EXCEPTION(writer->Update());

	std::cout << "Test finished.";
	return EXIT_SUCCESS;
}

如有问题，欢迎指正

求则得之，舍则失之
关注
  • 5
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
三维细化提取骨架线程序
05-22
细化提取血管中心线，itk读取和输出mhd图像，最终生成血管中心线树结构，实现算法K. Palágyi, E. Balogh, A. Kuba, C. Halmai, B. Erdőhelyi, E. Sorantin, K. Hausegger, A sequential 3D thinning algorithm and its medical applications, Biennial International Conference on Information Processing in Medical Imaging, (2001) 409- 415.
3D模型的骨架提取
03-25
这是一篇介绍虚拟人生成模型中3D骨架模型的生成方法的文章，值得一看。
【3D实践】3D模型骨架提取及分析
尹豆的博客
04-28 9794
作者：憨豆酒（YinDou），联系我[email protected]，熟悉图形学，图像处理领域，本章的源代码可在此仓库中找到：<https://github.com/ModestBean/person-summary> 如果大家发现错误以及不合理之处，还希望多多指出。 - [我的Github] - [我的CSDN] 1 运行结果 经历了一个痛苦的过程，做骨架提取的很少众，做三维骨...
3D骨架（细化）提取算法C++
花生米
10-30 2699
网上的细化算法大部分都是对2D图像进行提取，对3D图像进行细化代码介绍太少了。目前比较流行的有两个版本。 matlat版本 Skeleton3D。 ITK版本 itkBinaryThinningImageFilter3D.h。 ITK版本比较麻烦，需要将数据转成ITK的格式，读取很不方便。所以我将ITK版本的细化算法使用C++写了一遍。使用的是VS2019版本，输入的是3维的二进制数据。链接是ThinningAlgo3D。 ...
ThinningAlgo3D.zip
10-30
根据itkBinaryThinningImageFilter3D骨架提取算法改的C++版本。使用的是vs2019版本。输入的是3维二进制数据，代码提供数据的读取与保存。
两种图像骨架提取算法的研究原理及实现
dagunliyu123的博客
10-03 4509
图像骨架提取，实际上就是提取目标在图像上的中心像素轮廓。说白了就是以目标中心为准，对目标进行细化，一般细化后的目标都是单层像素宽度。比如输入图像是这样： 输出骨架图像(红色) 关于骨架提取，现存的算法有一千种以上（论文[1]中谈到，There are more than one thousand algorithms that have been published ...
扩展ITKThickness3D报错了
fanre的专栏
10-27 217
删掉这一行。
itk中的数据细化算法
就这样吧
05-27 2130
细化算法一般都对二值图像的骨架提取，这是一个从面变成线，还要保持原有图像形态的过程。是一个渐变的过程，少不了的迭代，就像对一棵树一层一层的剥皮，最后就剩下芯（sorry，我这里的说法有错误，也有一次产生骨架的算法，不迭代，之前的认知是错误的！）。 细化算法的差异在于迭代的方法，理论知识大家自行搜索，都是基础算法。这里，itk中的类叫做itkBinaryThinningImageFil
python 提取图中头像_医学图像处理案例（十一）——3D骨架提取算法
weixin_33478314的博客
01-01 1256
今天将分享人体三维主动脉血管骨架提取案例。1、常见3D骨架提取算法常见的两种图像细化方法有(1)、核滤波器，(2)、决策树。核滤波器方法是将结构元素应用在图像上，例如迭代地侵蚀物体的表面，直到仅保留骨架为止，该方法通常可以扩展到更高维度上。决策树方法是迭代处理26邻域内中目标和背景体素所有可能的二进制组合，并在每次迭代时找到所有可删除的表面点，虽然该方法仅限于2D和3D，但却比形态滤波...
python 实现将Numpy数组保存为图像
09-18
今天小编就为大家分享一篇python 实现将Numpy数组保存为图像，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
数字图像处理图像的骨架生成和提取（Matlab）三种方法
05-15
数字图像处理图像的骨架生成和提取（Matlab），有三种方法，推荐给大家！
SIFT3D-master.zip_3d sift_SIFT3D算法_sift 3D_sift3d_特征描述
07-15
经典sift3d算法,有c++和matlab两个版本。
python数字图像处理之骨架提取与分水岭算法
12-24
骨架提取与分水岭算法也属于形态学处理范畴，都放在morphology子模块内。 1、骨架提取 骨架提取，也叫二值图像细化。这种算法能将一个连通区域细化成一个像素的宽度，用于特征提取和目标拓扑表示。 morphology子模块提供了两个函数用于骨架提取，分别是Skeletonize（）函数和medial_axis（）函数。我们先来看Skeletonize（）函数。 格式为：skimage.morphology.skeletonize(image) 输入和输出都是一幅二值图像。 例1： from skimage import morphology,draw import numpy as np
3d点云数据植物骨架提取代码demo+测试数据
05-27
3d点云数据植物骨架提取代码demo+测试数据，代码可以跑通
Skeleton.zip_3d animation _skeleton 模型_三维 骨架提取_提取三维骨架_骨架
07-15
骨架提取软件，可提取三维表面模型的骨架，用于动漫设计等。
openpose各种骨架提取模型文件（全）20200504
05-04
手势识别系列文章之基于单目视觉的openpose手部骨架提取，文章链接：https://blog.csdn.net/kissgoodbye2012/article/details/105892907
三维模型特征提取方法概述
qq_29462849的博客
11-06 5235
点击上方“计算机视觉工坊”，选择“星标”干货第一时间送达作者I开拓者5号@CSDN编辑I3D视觉开发者社区一、三维特征提取概述三维特征提取是模式识别中最基本的研究内容之一，可以有效地缓...
【三维重建】三维骨架提取——相关文献和资料
weixin_43768222的博客
04-18 2276
骨架提取，其实在2D图像中，已经有了较大的应用。但在3D中，一直有研究，但总有种不够完善的感觉，这有点涉及到图形学等知识。 3D的骨架提取，根据模型输入的不同主要分为两种：点云（point cloud）和面片（mesh），一个是零散的无序的输入，一个是具有封闭曲面的输入。 1. 3d skeletons: A state-of-the-art report (2016年) 2. 基于改进自适应k均值聚类的三维点云骨架提取的研究 (自动化学报2020) 3. L1-medial skeleton o
三维网格骨架提取之二
weixin_36429070的博客
07-31 1223
骨架是网格模型的中轴，可以被当做是分水岭。许多三维模型算法通过分析它的骨架而非模型本身，来降低问题的维度。 骨架提取算法有3个关注点： 精确的计算三维模型的骨架是一个复杂、计算量大的问题。 根据骨架提取的定义，骨架化的过程对模型边界的噪声十分敏感。（通常用Smooth对模型做预处理）。 参考自 1.《三维模型骨架提取算法研究与实现》彭艺。 2.《Skeletonization and Segmentationof Binary Voxel Shapes》 ...
如何利用手写机械臂写字
最新发布
06-01
利用手写机械臂写字需要进行以下步骤： 1. 机械臂建模：首先需要建立机械臂的模型，包括机械臂的关节数、关节类型、DH参数等关键参数。可以使用CAD软件进行建模，也可以使用MATLAB中的Robotics System Toolbox提供的建模工具箱进行建模。 2. 运动控制：在机械臂建模完成后，需要使用运动控制算法来实现机械臂的运动控制。其中，最基本的算法是逆运动学算法，通过计算机械臂的关节角度来实现机械臂的运动。同时，还需要考虑机械臂的速度和加速度等参数，以保证机械臂的运动平稳。 3. 字体生成：在机械臂的运动控制完成后，需要生成需要写的字体。可以使用MATLAB提供的字体库进行生成，也可以使用其他字体生成工具进行生成。 4. 机械臂写字：在机械臂运动和字体生成都完成后，就可以开始利用机械臂进行写字了。需要将机械臂的末端工具和墨水笔等工具连接起来，然后通过运动控制算法控制机械臂的运动轨迹，实现机械臂写字的功能。 需要注意的是，手写机械臂写字需要精细的运动控制和字体生成技术，需要通过不断的实践和优化来提高写字的质量和效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值