读stl模型的数据

最新推荐文章于 2023-12-23 12:42:53 发布
最新推荐文章于 2023-12-23 12:42:53 发布
阅读量1k 收藏 1
点赞数
分类专栏： C/C++/QT 文章标签： stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moonlightpeng/article/details/80201306
版权

//xlFileStream.h

#pragma once
#include <Windows.h>
#include <tchar.h>
//xlFileStream.h
struct FileHeader
{
	wchar_t			Author[32];				// 文件的创建人
	wchar_t			Company[32];			// 创建人的单位
	char			Version[34];			// GUID，表示版本

	unsigned int 	Count;					// 所含Node的数量

	char			Reserved[90];			// 保留字节
};

class FileStream
{
private:
	HANDLE		m_hFile;
	bool		m_bTmpFile;

	char* __Version__;

public:
	void Close( )
	{
		CloseHandle( m_hFile );
		m_hFile = NULL;
	}

	bool CreateFile( const wchar_t lpwszPathName[] )
	{
		if(m_bTmpFile)
			m_hFile = ::CreateFile(lpwszPathName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL);
		else
			m_hFile = ::CreateFile(lpwszPathName, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

		if(m_hFile == INVALID_HANDLE_VALUE)
		{
			m_hFile = NULL;
			return false;
		}
		return true;
	}

	bool OpenFile( const wchar_t  lpwszPathName[] )
	{
		if(m_bTmpFile)
			m_hFile = ::CreateFile(lpwszPathName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_DELETE_ON_CLOSE, NULL);
		else
			m_hFile = ::CreateFile(lpwszPathName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

		if(m_hFile == INVALID_HANDLE_VALUE)
		{
			m_hFile = NULL;
			return false;
		}
		return true;
	}

	BOOL Read( void* pv, ULONG cb, LPOVERLAPPED lpOverlapped = NULL)
	{
		ULONG pcbRead;
		BOOL bRet = ReadFile(m_hFile, pv, cb, &pcbRead, lpOverlapped);
		if(!bRet)
			return false;
		if(cb != pcbRead)
			return false;
		else
			return true;
	}

	BOOL Write( void const* pv, ULONG cb, LPOVERLAPPED lpOverlapped = NULL)
	{
		ULONG pcbWritten;
		BOOL bRet = WriteFile(m_hFile, pv, cb, &pcbWritten, lpOverlapped);
		if(!bRet)
			return false;
		if(cb != pcbWritten)
			return false;
		else
			return true;
	}

	bool WriteHeader(unsigned int Count, wchar_t Author[] = NULL, wchar_t Company[] = NULL)
	{
		FileHeader header;
		if(Author != NULL)
			wcscpy_s(header.Author, wcslen(Author) + 1, Author);
		if(Company != NULL)
			wcscpy_s(header.Company, wcslen(Company) + 1, Company);
		strcpy_s(header.Version, 34, __Version__);
		header.Count = Count;

		BOOL bRet = Write(&header, sizeof(FileHeader));
		if(!bRet)
			return false;
		return true;
	}

	bool ReadHeader(unsigned int& Count, wchar_t Author[] = NULL, wchar_t Company[] = NULL)
	{
		FileHeader header;
		if(Read(&header, sizeof(FileHeader)))
		{
			if(Author != NULL)
				wcscpy_s(Author, wcslen(header.Author) + 1, header.Author);
			if(Company != NULL)
				wcscpy_s(Company, wcslen(header.Company) + 1, header.Company);
			Count = header.Count;

			if(strncmp(__Version__, header.Version, 32) != 0)
				false;
		}

		return true;
	}

public:
	FileStream( bool bTmpFile = false )  : m_hFile(0), m_bTmpFile(bTmpFile)
	{
		__Version__ = "691287C840924b6aB3C98F8C278FF967";
	}

	~FileStream( void )
	{
		CloseHandle( m_hFile );
	}
};


xlSortPoints.h

// xlSortPoints.h
// 用于完成空间点的最小堆算法，具体的

#pragma once

#include <math.h>
#include <float.h>

#include <vector>
#include <map>
using namespace std;

namespace SortPoint
{
	struct tagIndex { int i; int j; int k; };

	inline bool operator < (const tagIndex& ind1, const tagIndex& ind2)
	{
		if(ind1.i < ind2.i) return true;
		else if(ind1.i > ind2.i) return false;
		else if(ind1.j < ind2.j) return true;
		else if(ind1.j > ind2.j) return false;
		else if(ind1.k < ind2.k) return true;
		else return false;
	}

	inline bool operator > (const tagIndex& ind1, const tagIndex& ind2)
	{
		if(ind1.i > ind2.i) return true;
		else if(ind1.i < ind2.i) return false;
		else if(ind1.j > ind2.j) return true;
		else if(ind1.j < ind2.j) return false;
		else if(ind1.k > ind2.k) return true;
		else return false;
	}

	inline bool operator == (const tagIndex& ind1, const tagIndex& ind2)
	{
		if(ind1 < ind2) return false;
		else if(ind1 > ind2) return false;
		else return true;
	}

	template<typename Real>
	class CSortPoints
	{
	private:
		map<tagIndex, vector<int>> m_mapSortedPoints;
		Real	m_fOrg[3];
		Real	m_fUnit;
		Real	m_fMinDist;

		inline void GetIndex(const Real point[3], tagIndex& ind)
		{
			ind.i = int((point[0] - m_fOrg[0]) / m_fUnit);
			ind.j = int((point[1] - m_fOrg[1]) / m_fUnit);
			ind.k = int((point[2] - m_fOrg[2]) / m_fUnit);
		}

	public:
		inline int insert_point(Real pt[3], vector<Real>& points)
		{
			size_t i;
			int index;
			tagIndex ind, tmp;
			GetIndex(pt, ind);

			map<tagIndex, vector<int>>::iterator iter;
			for(tmp.i = ind.i - 1; tmp.i < ind.i + 2; tmp.i++)
			{
				for(tmp.j = ind.j - 1; tmp.j < ind.j + 2; tmp.j++)
				{
					for(tmp.k = ind.k - 1; tmp.k < ind.k + 2; tmp.k++)
					{
						iter = m_mapSortedPoints.find(tmp);
						if(iter != m_mapSortedPoints.end())
						{
							vector<int>& bucket = m_mapSortedPoints[tmp];
							for(i = 0; i < bucket.size(); i++)
							{
								index = bucket[i] * 3;
								if( (fabs(points[index + 0] - pt[0]) < m_fMinDist) && 
									(fabs(points[index + 1] - pt[1]) < m_fMinDist) && 
									(fabs(points[index + 2] - pt[2]) < m_fMinDist) )
								{
									return bucket[i];
								}
							}
						}
					}
				}
			}

			int ret = points.size() / 3;

			points.push_back(pt[0]);
			points.push_back(pt[1]);
			points.push_back(pt[2]);

			m_mapSortedPoints[ind].push_back(ret);

			return ret;
		}

		inline int NearestPoint(const vector<Real>& points, Real pt[])
		{
			tagIndex ind, tmp;
			GetIndex(pt, ind);

			size_t i;
			Real min = FLT_MAX;
			int ret = -1, index;

			map<tagIndex, vector<int>>::iterator iter;
			for(tmp.i = ind.i - 1; tmp.i < ind.i + 2; tmp.i++)
			{
				for(tmp.j = ind.j - 1; tmp.j < ind.j + 2; tmp.j++)
				{
					for(tmp.k = ind.k - 1; tmp.k < ind.k + 2; tmp.k++)
					{
						iter = m_mapSortedPoints.find(tmp);
						if(iter != m_mapSortedPoints.end())
						{
							vector<int>& bucket = m_mapSortedPoints[tmp];
							for(i = 0; i < bucket.size(); i++)
							{
								index = bucket[i] * 3;
								Real dist = pow(points[index + 0] - pt[0], 2) + pow(points[index + 1] - pt[1], 2) +
									pow(points[index + 2] - pt[2], 2);
								if(dist < min)
								{
									min = dist;
									ret = index;
								}
							}
						}
					}
				}
			}
			return ret / 3;
		}

		inline int NearestPoint(const vector<Real>& points, Real x, Real y, Real z)
		{
			Real pt[] = { x, y, z };
			return NearestPoint(points, pt);
		}

		inline int NearestPoint(const vector<Real>& points, const Real* pt)
		{
			Real p[] = { pt[0], pt[1], pt[2] };
			return NearestPoint(points, p);
		}

		Real GaussUnit(const vector<Real>& points)
		{
			Real range[6] = {
				DBL_MAX, -DBL_MAX,
				DBL_MAX, -DBL_MAX,
				DBL_MAX, -DBL_MAX,
			};

			unsigned int i, ptsize = points.size() / 3;

			for(i = 0; i < ptsize; i++)
			{
				const Real& x = points[i * 3 + 0];
				const Real& y = points[i * 3 + 1];
				const Real& z = points[i * 3 + 2];

				if(x < range[0]) range[0] = x;
				if(x > range[1]) range[1] = x;

				if(y < range[2]) range[2] = y;
				if(y > range[3]) range[3] = y;

				if(z < range[4]) range[4] = z;
				if(z > range[5]) range[5] = z;
			}

			return 2 * pow((range[1] - range[0]) * (range[3] - range[2]) * (range[5] - range[4]) / ptsize, 1/3.0);
		}

		inline void init(Real org[3], Real unit)
		{
			m_fOrg[0] = org[0]; m_fOrg[1] = org[1]; m_fOrg[2] = org[2];
			m_fUnit = unit;
		}

		inline void init(const vector<Real>& points, Real org[3], Real unit)
		{
			m_fOrg[0] = org[0]; m_fOrg[1] = org[1]; m_fOrg[2] = org[2];
			m_fUnit = unit;

			tagIndex ind;
			unsigned int size = points.size() / 3;
			for(unsigned int i = 0; i < size; i++)
			{
				GetIndex(&(points[i * 3]), ind);

				m_mapSortedPoints[ind].push_back(i);
			}
		}

		inline void init(const vector<Real>& points)
		{
			m_fOrg[0] = points[0]; m_fOrg[1] = points[1]; m_fOrg[2] = points[2];
			m_fUnit = GaussUnit(points);

			tagIndex ind;
			unsigned int size = points.size() / 3;
			for(unsigned int i = 0; i < size; i++)
			{
				GetIndex(&(points[i * 3]), ind);

				m_mapSortedPoints[ind].push_back(i);
			}
		}

		inline void clear()
		{
			m_mapSortedPoints.clear();
		}

		CSortPoints(Real min_dist = 1.0e-6f) : m_fMinDist(min_dist)
		{
		}

		~CSortPoints()
		{
		}
	};

}

stl.cpp

inline float GetUnit(float x[3], float y[3], float z[3])
{
	float ret[3];
	ret[0] = fabs(x[0] - y[0]) > fabs(x[1] - y[1]) ? fabs(x[0] - y[0]) : fabs(x[1] - y[1]);
	if (fabs(x[2] - y[2]) > ret[0]) ret[0] = fabs(x[2] - y[2]);

	ret[1] = fabs(x[0] - z[0]) > fabs(x[1] - z[1]) ? fabs(x[0] - z[0]) : fabs(x[1] - z[1]);
	if (fabs(x[2] - z[2]) > ret[1]) ret[1] = fabs(x[2] - z[2]);

	ret[2] = fabs(z[0] - y[0]) > fabs(z[1] - y[1]) ? fabs(z[0] - y[0]) : fabs(z[1] - y[1]);
	if (fabs(z[2] - y[2]) > ret[2]) ret[2] = fabs(z[2] - y[2]);

	if (ret[0] > ret[1]) ret[0] = ret[1];
	if (ret[0] > ret[2]) ret[0] = ret[2];
	return ret[0];
}

inline bool ReadSTL(const wchar_t* wszPath, vector<float>& points, vector<float>& normals, vector<__int32>& triangles)
{
	ifstream infile(wszPath);
	if (!infile)
		return false;

	float org[3], unit;
	float n[3]; float x[3]; float y[3]; float z[3];
	char unusered[2];

	int ix, iy, iz;

	SortPoint::CSortPoints<float> sorted_points;

	char string[256] = "";

	infile >> string;	//read "solid"
	if (_strnicmp(string, "solid", 5) != 0)		// 二进制
	{
		infile.close();

		FileStream fStream;
		if (!fStream.OpenFile(wszPath))
			return false;

		char info[90];
		int size;

		fStream.Read(info, sizeof(char) * 80);
		fStream.Read(&size, sizeof(int));

		for (int i = 0; i < size; i++)
		{
			fStream.Read(n, sizeof(float) * 3);
			fStream.Read(x, sizeof(float) * 3);
			fStream.Read(y, sizeof(float) * 3);
			fStream.Read(z, sizeof(float) * 3);
			fStream.Read(unusered, sizeof(char) * 2);

			if (points.size() == 0)
			{
				unit = GetUnit(x, y, z);
				org[0] = x[0]; org[1] = x[1]; org[2] = x[2];

				sorted_points.init(org, unit);
			}

			normals.push_back(n[0]); normals.push_back(n[1]); normals.push_back(n[2]);

			ix = sorted_points.insert_point(x, points);
			iy = sorted_points.insert_point(y, points);
			iz = sorted_points.insert_point(z, points);

			if (ix != iy && iy != iz && ix != iz)
				triangles.push_back(ix); triangles.push_back(iy); triangles.push_back(iz);
		}
		return true;
	}
	else		// 文本
	{
		while (_strnicmp(string, "facet", 5) != 0)	// 读到facet为止
			infile >> string;

		do
		{
			infile >> string;	//read "normal"
			infile >> n[0] >> n[1] >> n[2];

			infile >> string;	//read "outer"
			infile >> string;	//read "loop"

			infile >> string;	//read "vertex"
			infile >> x[0] >> x[1] >> x[2];

			infile >> string;	//read "vertex"
			infile >> y[0] >> y[1] >> y[2];

			infile >> string;	//read "vertex"
			infile >> z[0] >> z[1] >> z[2];

			if (points.size() == 0)
			{
				unit = GetUnit(x, y, z);
				org[0] = x[0]; org[1] = x[1]; org[2] = x[2];

				sorted_points.init(org, unit);
			}

			normals.push_back(n[0]); normals.push_back(n[1]); normals.push_back(n[2]);

			ix = sorted_points.insert_point(x, points);
			iy = sorted_points.insert_point(y, points);
			iz = sorted_points.insert_point(z, points);

			triangles.push_back(ix); triangles.push_back(iy); triangles.push_back(iz);

			infile >> string;	// read "endloop"
			infile >> string;	// read "endfacet"
			infile >> string;	// read "facet" or "endsolid"
			if (_strnicmp(string, "endsolid", 8) == 0)
			{
				infile >> string;
				if (_strnicmp(string, "solid", 8) == 0)
					infile >> string;
				else
					break;
			}
		} while (_strnicmp(string, "facet", 5) == 0);

		infile.close();
		return true;
	}

	return false;
}

inline bool WriteSTL(const wchar_t* wszPath, vector<float>& points, bool bBinary)
{
	if (!bBinary)
	{
		ofstream file(wszPath);
		if (!file)
			return false;

		file << "Solid" << endl;
		for (size_t i = 0; i < points.size(); i += 12)
		{
			file << "  Facet Normal " << points[i + 0] << " " << points[i + 1] << " " << points[i + 2] << endl;
			file << "    Outer Loop" << endl;
			file << "      Vertex   " << points[i + 3] << " " << points[i + 4] << " " << points[i + 5] << endl;
			file << "      Vertex   " << points[i + 6] << " " << points[i + 7] << " " << points[i + 8] << endl;
			file << "      Vertex   " << points[i + 9] << " " << points[i + 10] << " " << points[i + 11] << endl;
			file << "    Endloop" << endl;
			file << "  Endfacet" << endl;
		}
		file << "Endsolid" << endl;
		file.close();
	}
	else
	{
		//iostream fStream;
		FileStream fStream;
		if (!fStream.CreateFile(wszPath))
			return false;

		char info[90];
		int size = points.size() / 12;

		fStream.Write(info, sizeof(char) * 80);
		fStream.Write(&size, sizeof(int));

		for (int i = 0; i < size; i++)
		{
			fStream.Write(&(points[i * 12]), sizeof(float) * 12);
			char reserved[2];
			fStream.Write(reserved, sizeof(char) * 2);
		}
	}

	return true;
}

天人合一peng
关注
专栏目录
数据结构之STL
夜空中最亮的那颗星指引我前行
07-01 359
1，STL介绍(空间配置器详解) 标准模板库，C++的标准库之一。 STL包含6大部件：容器、迭代器、算法、仿函数、适配器和空间配置器。 容器：容纳一组元素的对象。 迭代器：提供一种访问容器中每个元素的方法。 函数对象：一个行为类似函数的对象，调用它就像调用函数一样。 算法：包括查找算法、排序算法等等。 适配器：用来修饰容器等，比如queue和stack，底层借助了deque。 空间配置器：负责空间配置和管理。 2，各种容器的特点和适应情况 3，vector二三事 vector底层实现原理 vector中
python 读取stl文件_读取STL模型 并用opengl显示
weixin_39836803的博客
12-10 3195
说起STL模型，相信使用过CAD三维软件的人都不陌生，STL = STL文件，一种3D模型文件格式STL(STereo Lithography的缩写)STL文件格式是由3D SYSTEMS 公司于1988 年制定的一个接口协议，是一种为快速原型制造技术服务的三维图形文件格式。STL 文件由多个三角形面片的定义组成，每个三角形面片的定义包括三角形各个定点的三维坐标及三角形面片的法矢量。三角形顶点的排...
opengl 显示模型，STL文件解析
10-19
解析STL文件并在opengl中显出出来模型，环境是QT。
如何读取STL文件？
热门推荐
qq_28249373的博客
07-19 1万+
STL文件有两种文件格式，分别是二进制的stl和Ascii格式的stl。下面将针对这文件的两个格式，用C语言分别写出一段简单的示例代码。 一、读取二进制的STL文件 （1）二进制stl文件的结构 文件起始的80个字节是文件头，用于存贮文件名； 紧接着用 4 个字节的整数来描述模型的三角面片个数， 后面逐个给出每个三角面片的几何信息。每个三角面片占用固定的50个字节，依次是: 3个4字节浮
C++ -- STL文件解析
DAOCHI
04-28 8695
1、 STL文件格式 STL文件是一种用许多空间小三角形面片逼近三维实体表面的3D模型。STL模型给出了组成三角形法向量的3个分量(用于确定三角面片的正反方向)及三角形的3个顶点坐标。一个完整的STL文件记录了组成实体模型的所有三角形面片的法向量数据和顶点坐标数据信息。STL文件格式包括二进制文件(BINARY)和文本文件(ASCII)两种。 1.1、STL的二进制格式 二进制STL文件用固定的字...
STL基础详解
01-07
STL基础详解，其中包含了String的用法等
什么是STL？
kuanyew的博客
05-18 860
什么是STL？1. STL概论1.1. STL基本概念1.2. STL六大组件简介1.3. STL优点2. STL三大组件2.1. 容器2.2. 算法2.3. 迭代器2.3. 案例 1. STL概论   长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西”的方法,让程序员的心血不止于随时间的迁移，人事异动而烟消云散，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种组件，从
qt读取stl文件并进行显示
05-14
STL文件是3D建模和打印中的标准格式，它存储了三维模型的几何信息。 首先，让我们了解STL文件的基本结构。STL文件由一系列的三角形面片（facets）组成，每个面片包含三个顶点和一个法向量，用于表示表面的方向。Qt...
matlab如何读取并显示stl模型
jiangzuojiben的博客
12-27 1万+
matlab函数如何读取并显示stl模型 利用stlread函数可方便的实现stl文件读取的操作，不过该实现只可读取binary格式的stl文件，并不能读取ASCII格式的stl文件，相应实现也很简单。不过本文的重点不在stl模型的读取上，而在stl模型的显示上。 patch绘制一个四边形 matlab自带的patch函数可以实现多边形的绘制 patch(X,Y,Z,C) 使用 X、Y 和 Z 在三维坐标中创建多边形。 X指的是多边形各顶点的x坐标构成的一维向量。Y,Z同理，C表示Color，通过改变C的参
基于opentk的3D模型（STL格式）显示旋转缩放等功能
04-01
对于STL模型的每个三角形，使用`glBegin(GL_TRIANGLES)`开始绘制，然后依次传递三个顶点，最后调用`glEnd()`结束绘制。 为了实现3D模型的旋转和缩放，我们需要监听用户的输入事件，如鼠标移动和滚轮滚动。在...
STLViewer读取并显示stl文件
09-02
MFC程序,读取stl文件，利用opengl显示. VC6可以正常，编译 vs2008需要稍作修改
matlab stl文件读取
12-10
matlab stl文件读取 读取的源代码
读入stl文件的一段C++代码
07-30
一个用来读取stl文件的函数，参数是stl文件的名称。stl文件需要保存成ASCII的格式
STP-STEP-IGES-BREP文件转STL（Python）
07-24
STP、STEP、IGES和STL都是用于存储几何模型的不同文件格式，各有其特点和适用场景。本文将深入探讨如何使用Python进行这些格式之间的转换。 首先，STP和STEP文件格式通常用于无损数据交换，它们基于ISO 10303标准，...
C++ STL基本组成（6大组件+13个头文件）
ym18861512953的博客
08-24 281
STL 是由容器、算法、迭代器、函数对象、适配器、内存分配器这 6 部分构成，其中后面 4 部分是为前 2 部分服务的，它们各自的含义如下表所示。 STL的组成 含义 容器 一些封装数据结构的模板类，例如 vector 向量容器、list 列表容器等。 算法 STL 提供了非常多（大约 100 个）的数据结构算法，它们都被设计成一个个的模板函数，这些算法在 std 命名空间中定义，其中大部分算法都包含在头文件 中，少部分位于头文件 中。 迭代器 在 C++ STL 中，对容器中数
什么是stl? 如何使用stl?
小青龙，创造，变强
04-01 5546
什么是stl? stl如何进行使用？
STL模型文件解析
Kir1hara的博客
02-15 2554
STL模型文件解析 （C++）
STL体系结构概述
最新发布
欢迎来到我的博客站点
12-23 1036
本文将是STL系列的第一篇文章，主要参考《STL源码剖析》，辅以网络博文，不定时更新我感兴趣的内容。
STL基本结构
ChristmasGuus
06-10 447
在C++标准中，STL被组织为下面的13个头文件：<algorithm>、<deque>、<functional>、<iterator>、<array>、<vector>、<list>、<forward_list>、<map>、<unordered_map>、<memory>、<numeric>、<queue>、<set>、<unordered_set>、<stack>和<utility>。STL可
读取出stl中的数据后如何在qt中绘制
07-29
在Qt中绘制STL（Standard Tessellation Language）数据，可以遵循以下步骤： 1. 读取STL文件：使用Qt提供的文件读取函数，如QFile或QIODevice，打开STL文件并读取二进制或文本数据。 2. 解析STL数据：根据STL文件的格式，解析文件内容，提取三角面片的顶点位置信息。 3. 创建3D场景：使用Qt中的OpenGL库（如QOpenGLWidget或QGLWidget），创建一个3D场景的窗口。 4. 绘制三角面片：使用OpenGL库提供的绘制函数，将STL文件中解析出的顶点坐标信息传递给OpenGL函数进行绘制。 5. 设置光照和视角：根据需要，通过OpenGL的函数设置光照和视角参数，以改善渲染效果。 6. 渲染场景：在OpenGL的paintGL()函数中调用绘制函数，将解析后的STL数据绘制到3D场景中。 7. 添加交互功能：根据需要，使用Qt的信号和槽机制，为3D场景添加交互功能，如旋转、缩放和平移等。 8. 更新和刷新：根据需要，使用Qt的定时器或事件循环机制，定期更新3D场景的数据和状态，以保证动态效果的展示。 总之，通过读取STL数据并利用OpenGL库来绘制，可以在Qt中实现STL数据的可视化显示。这样用户可以在Qt应用程序中直观地观察和操作STL模型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值