NDS莫顿码计算

已于 2025-01-16 20:46:59 修改
阅读量53 收藏
点赞数
文章标签： 算法
于 2021-04-26 11:29:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qingcaichongchong/article/details/116147909
版权 
#pragma once
#include <map>
#include "mesh_info.h"

class NDSMesh
{
public:
	NDSMesh();
	virtual ~NDSMesh();

	/// <summary>
	/// 获取图幅号
	/// </summary>
	/// <param name="longitude">经度</param>
	/// <param name="latitude">纬度</param>
	/// <returns>图幅号</returns>
	static int GetMeshID(double longitude, double latitude);

	/// <summary>
	/// 获取该图幅的经纬度信息
	/// </summary>
	/// <param name="nMeshID"></param>
	/// <returns>图幅信息</returns>
	static MeshInfo GetMeshInfo(int nMeshID);

	/// <summary>
	/// 层级
	/// </summary>
	static int s_level;

protected:

	/// <summary>
	/// 根据经度确定带号
	/// </summary>
	/// <param name="longitude">经度</param>
	/// <returns>带号</returns>
	static int GetZoneID(double longitude);

	/// <summary>
	/// 给定6度带号计算经度范围
	/// </summary>
	/// <param name="nZoneID">带号</param>
	/// <param name="dMinLon">最小经度</param>
	/// <param name="dMaxLon">最大经度</param>
	/// <returns></returns>
	static bool GetZoneBounds(int nZoneID, double& dMinLon, double& dMaxLon);


	/// <summary>
	/// 内插边框
	/// </summary>
	/// <param name="mi"></param>
	static void InterpolateMeshInfoBounds(MeshInfo& mi);


private:
	// 非法NDS图幅号
	static const int INVALID_MESH_ID;

	// 边界插值数
	static const int INTERPOLATION_POINT_COUNT;

	//存放已计算过的mesh信息
	static std::map<int, MeshInfo> map_mesh_infos;
};
/*!
 * file    nds_mesh.h
 * date    2021/04/21 18:31
 * author  yufei.xue
 * contact yufei.xue@horizon.ai
 * todo:   long description
*/

#include "nds_mesh.h"
#include <map_param/include/interface/projection.h>
#include <iostream>

// 小数精度，暂定小数点后10位
#ifndef NUMERIC_ACCURACY
#define NUMERIC_ACCURACY (1e-10) 
#endif

int NDSMesh::s_level = 11;

const int NDSMesh::INVALID_MESH_ID = -1;

const int NDSMesh::INTERPOLATION_POINT_COUNT = 16;

std::map<int, MeshInfo> NDSMesh::map_mesh_infos;


NDSMesh::NDSMesh()
{

}

NDSMesh::~NDSMesh()
{

}

int NDSMesh::GetMeshID(double longitude, double latitude)
{
	// 判断是否在全球经纬度范围之内，如果不在合法范围内，则返回非法图幅号
	if (longitude > 180.0 ||
		longitude < -180.0 ||
		latitude > 90.0 ||
		latitude < -90.0)
	{
		return INVALID_MESH_ID;
	}

	int dwCode = 0; // 返回值，NDS Level13 编码double
	int nLevel = s_level; // 固定的等级，就是13等级

	double dMinX = 0.0;
	double dMaxX = 0.0;

	double dMinY = -90.0;
	double dMaxY = 90.0;

	// 在NDS的编码计算中，Level 0, Level 1 稍微有些许差异，需要单独处理，Level 2以后规律很明显，可以循环处理
	// 先处理0级编码
	// 先判断是在西半球，还是在东半球，Level 0级，西半球编码为1，东半球编码为0
	// 0 级编码
	if (longitude > 0 ||
		std::fabs(longitude) < NUMERIC_ACCURACY)
	{
		dMinX = 0.0;			// 东半球范围
		dMaxX = 180.0;		    // 东半球范围
	}
	else
	{
		dMinX = -180;			// 西半球
		dMaxX = 0;				// 西半球
		dwCode = 1 << (2 * nLevel);		// 将Level0的编码 1 写入到图幅号中
	}

	// 再处理一下1级编码
	// 循环迭代，一直到nLevel等级，目前nLevel固定为13
	for (int i = 1; i <= nLevel; i++)
	{
		// 通过等级，计算当前等级下，判断半球被切分了多少次，2^n
		int nTiles = 1 << i;

		// 当前等级的经纬度间隔数		
		double longitudeInterval = 180.0 / nTiles;
		double latitudeInterval = 180.0 / nTiles;

		double longitudeMiddle = dMinX + longitudeInterval;
		double latitudeMiddle = dMinY + latitudeInterval;

		int dwLevelSubCode = 0;

		if (i % 2 == 0 || i > 2) // 偶数
		{
			// 从下往上，从左往右
			if (longitude > longitudeMiddle ||
				std::fabs(longitude - longitudeMiddle) < NUMERIC_ACCURACY)
			{
				dMinX = longitudeMiddle;

				if (latitude > latitudeMiddle ||
					std::fabs(latitude - latitudeMiddle) < NUMERIC_ACCURACY)
				{
					// 11						
					dMinY = latitudeMiddle;
					dwLevelSubCode = 3; //11
				}
				else
				{
					// 01
					dMaxY = latitudeMiddle;
					dwLevelSubCode = 1; //01
				}
			}
			else
			{
				dMaxX = longitudeMiddle;

				if (latitude > latitudeMiddle ||
					std::fabs(latitude - latitudeMiddle) < NUMERIC_ACCURACY)
				{
					// 10						
					dMinY = latitudeMiddle;
					dwLevelSubCode = 2; //10
				}
				else
				{
					// 00
					dMaxY = latitudeMiddle;
					dwLevelSubCode = 0;
				}
			}

		}
		else // 奇数
		{
			// 从上往下，从左往右
			if (longitude > longitudeMiddle ||
				std::fabs(longitude - longitudeMiddle) < NUMERIC_ACCURACY)
			{
				dMinX = longitudeMiddle;

				if (latitude > latitudeMiddle ||
					std::fabs(latitude - latitudeMiddle) < NUMERIC_ACCURACY)
				{
					// 01
					dMinY = latitudeMiddle;
					dwLevelSubCode = 1;
				}
				else
				{
					// 11
					dMaxY = latitudeMiddle;
					dwLevelSubCode = 3;
				}
			}
			else
			{
				dMaxX = longitudeMiddle;

				if (latitude > latitudeMiddle ||
					std::fabs(latitude - latitudeMiddle) < NUMERIC_ACCURACY)
				{
					// 00
					dMinY = latitudeMiddle;
					dwLevelSubCode = 0;
				}
				else
				{
					// 10
					dMaxY = latitudeMiddle;
					dwLevelSubCode = 2;
				}
			}
		}

		// 更新dwCode
		dwCode |= dwLevelSubCode << ((nLevel - i) * 2);
	}

	return dwCode;
}

MeshInfo NDSMesh::GetMeshInfo(int nMeshID)
{
	auto it = map_mesh_infos.find(nMeshID);
	if (it != map_mesh_infos.end())
	{
		return it->second;
	}

	std::vector<int> masks(s_level + 1, 0);
	for (int i = 0; i <= s_level; i++)
	{
		if(i == 0)
			masks[0] = 0x1 << (s_level * 2);
		else
			masks[i] = 0x3 << (s_level - i) * 2;
	}
	//std::reverse(masks.begin(), masks.end());

	MeshInfo meshInfo;
	meshInfo.level_ = s_level;
	meshInfo.id_ = nMeshID;

	//首先计算图幅的经纬度范围
	meshInfo.min_lon_ = 0;
	meshInfo.max_lon_ = 180;
	meshInfo.min_lat_ = -90;
	meshInfo.max_lat_ = 90;

	if ((masks[0] & nMeshID) == masks[0])
	{
		meshInfo.min_lon_ = -180;
		meshInfo.max_lon_ = 0;
		meshInfo.min_lat_ = -90;
		meshInfo.max_lat_ = 90;
	}

	int nSubCode = masks[1] & nMeshID;
	nSubCode >>= 2 * (s_level - 1);
	switch (nSubCode)
	{
	case 0:
	{
		meshInfo.max_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
		meshInfo.min_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);
	}
	break;
	case 1:
	{
		meshInfo.min_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
		meshInfo.min_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);
	}
	break;
	case 2:
	{
		meshInfo.max_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
		meshInfo.max_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);
	}
	break;
	case 3:
	{
		meshInfo.min_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
		meshInfo.max_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);
	}
	break;

	}

	for (std::size_t i = 2; i < s_level + 1; i++)
	{
		nSubCode = masks[i] & nMeshID;
		nSubCode >>= 2 * (s_level - i);

		switch (nSubCode)
		{
		case 0:
		{
			meshInfo.max_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
			meshInfo.max_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);

		}
		break;
		case 1:
		{
			meshInfo.min_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
			meshInfo.max_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);
		}
		break;
		case 2:
		{
			meshInfo.max_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
			meshInfo.min_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);
		}
		break;
		case 3:
		{
			meshInfo.min_lon_ = meshInfo.min_lon_ + 0.5 * (meshInfo.max_lon_ - meshInfo.min_lon_);
			meshInfo.min_lat_ = meshInfo.min_lat_ + 0.5 * (meshInfo.max_lat_ - meshInfo.min_lat_);
		}
		break;
		}
	}

	// 判断该图幅是否跨带
	int nMinZoneID = GetZoneID(meshInfo.min_lon_);
	int nMaxZoneID = GetZoneID(meshInfo.max_lon_);
	meshInfo.is_cross_zone_ = (nMinZoneID != nMaxZoneID);

	// 计算带号
	if (meshInfo.is_cross_zone_) // 跨带了要计算，应该使用哪一个带
	{
		// 获取最小带号的边界范围
		double dMinZoneMinX = 0.0;
		double dMinZoneMaxX = 0.0;

		GetZoneBounds(nMinZoneID, dMinZoneMinX, dMinZoneMaxX);

		// 将经度范围从[-180, 180]，映射到[0, 360]
		if (dMinZoneMaxX < 0)
		{
			dMinZoneMaxX += 360.0;
		}

		// 将NDS图幅范围的经度也映射到[0, 360]
		double dMeshMinX = meshInfo.min_lon_;
		double dMeshMaxX = meshInfo.max_lon_;

		if (dMeshMinX < 0)
		{
			dMeshMinX += 360.0;
		}

		if (dMeshMaxX < 0)
		{
			dMeshMaxX += 360.0;
		}

		// 计算图幅的中央经线
		double dMeshCentralX = dMeshMinX + 0.5 * (dMeshMaxX - dMeshMinX);

		// 查看两个带公共边界处距离NDS图幅中央经线关系
		if (dMeshCentralX < dMinZoneMaxX) // 说明图幅的数据大部分在带号稍微小的带中
		{
			meshInfo.zone_id_ = nMinZoneID;
		}
		else
		{
			meshInfo.zone_id_ = nMaxZoneID;
		}
	}
	else
	{
		meshInfo.zone_id_ = nMinZoneID;
	}

	InterpolateMeshInfoBounds(meshInfo);

	map_mesh_infos[nMeshID] = meshInfo;
	return meshInfo;
}

int NDSMesh::GetZoneID(double longitude)
{
	return static_cast<int>((longitude + 180) / 6) + 1;
}

bool NDSMesh::GetZoneBounds(int nZoneID, double& dMinLon, double& dMaxLon)
{
	if (nZoneID < 1 || nZoneID > 60)
	{
		return false;
	}

	dMinLon = 6.0 * (nZoneID - 1) - 180.0;
	dMaxLon = 6.0 * (nZoneID - 1) - 174.0;
	return true;
}

void NDSMesh::InterpolateMeshInfoBounds(MeshInfo& mi)
{
	mi.bounds_.clear();

	double dIntervalLongitude = (mi.max_lon_ - mi.min_lon_) / INTERPOLATION_POINT_COUNT;
	double dIntervalLatitude = (mi.max_lat_ - mi.min_lat_) / INTERPOLATION_POINT_COUNT;

	Eigen::Vector2d pnt3D;

	// 进行坐标转换，转换成平面坐标
	char zone_id[20];
	map_interface::LLtoUTM(mi.min_lat_,
		mi.min_lon_,
		pnt3D.y(),
		pnt3D.x(),
		zone_id
	);

	mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());

	// 每一个边上中间增加16个点，以提高边框精度
	// 左边
	for (int i = 1; i < INTERPOLATION_POINT_COUNT; i++)
	{
		map_interface::LLtoUTM(
			mi.min_lat_ + i * dIntervalLatitude,
			mi.min_lon_,
			pnt3D.y(),
			pnt3D.x(),
			zone_id
		);
		mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());
	}

	map_interface::LLtoUTM(
		mi.max_lat_,
		mi.min_lon_,
		pnt3D.y(),
		pnt3D.x(),
		zone_id
	);

	mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());

	// 上边
	for (int i = 1; i < INTERPOLATION_POINT_COUNT; i++)
	{
		map_interface::LLtoUTM(
			mi.max_lat_,
			mi.min_lon_ + i * dIntervalLongitude,
			pnt3D.y(),
			pnt3D.x(),
			zone_id
		);

		mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());
	}

	map_interface::LLtoUTM(
		mi.max_lat_,
		mi.max_lon_,
		pnt3D.y(),
		pnt3D.x(),
		zone_id
	);

	mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());

	// 右边
	for (int i = 1; i < INTERPOLATION_POINT_COUNT; i++)
	{
		map_interface::LLtoUTM(
			mi.max_lat_ - i * dIntervalLatitude,
			mi.max_lon_,
			pnt3D.y(),
			pnt3D.x(),
			zone_id
		);

		mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());
	}

	map_interface::LLtoUTM(
		mi.min_lat_,
		mi.max_lon_,
		pnt3D.y(),
		pnt3D.x(),
		zone_id
	);

	mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());

	// 下边
	for (int i = 1; i < INTERPOLATION_POINT_COUNT; i++)
	{
		map_interface::LLtoUTM(
			mi.min_lat_,
			mi.max_lon_ - i * dIntervalLongitude,
			pnt3D.y(),
			pnt3D.x(),
			zone_id
		);

		mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());
	}

	map_interface::LLtoUTM(
		mi.min_lat_,
		mi.min_lon_,
		pnt3D.y(),
		pnt3D.x(),
		zone_id
	);

	mi.bounds_.emplace_back(pnt3D.x(), pnt3D.y());
}

【导航地图DB-NDS地图格式】
j8267643的博客
07-17 1966
NDS数据的分类NDS数据是分类保存的数据，每个Building Block代表一个种类的数据NDS数据的分类 -各Building Block的简单介绍Share Data共有数据，各个Building Block共有的情报Routing经路计算数据BMDBasic Map Display，地图描画数据Name文字数据，包括除POI外的所有文字数据POIPOI详细情报数据IconIcon数据Speech。
Partitioning of Geographic Data（NDS，导航数据标准中的地理数据分区）
weixin_44379346的博客
03-24 4114
学习笔记（一）：Partitioning of Geographic Data（NDS，导航数据标准中的地理数据分区）
NDS格式：通过经纬度获得所在的TileId
Y_123_654321的博客
02-10 811
NDS格式中，通过经纬度获得TileId。
NDS：一种适于更新的导航电子地图数据存储标准
导航电子地图的专栏
07-31 2万+
NDS：一种适于更新的导航电子地图数据存储标准 摘要：随着导航电子地图需求的不断增长，地图数据更新技术已成为制约其发展的一个瓶颈。本文介绍了新一代可以支持增量更新的导航电子地图存储标准NDS的研究情况，阐述了其产生的背景和发展目标，分析了其适于更新的数据模型，详细论述了其数据内容的特点和其完善的地图数据更新机制，并以一个地图数据更新的实例，生动的展示NDS在地图数据更新上的特点，为导航
ArcGIS分享: 地图分幅及编号
热门推荐
bingbing_h的博客
05-14 2万+
回顾《地图学》标准分幅制图及编号规范规则，ArcGIS示例实操应用。
TileID编码与TileID解码莫顿码NDS与WGS84坐标转换（Python、C++双实现）
yujikang123的博客
10-25 1296
莫顿编码定义了一条 Z 形的空间填充曲线，因此莫顿编码通常也称Z阶曲线(Z-order curve)。在 N 维空间中对于彼此接近的坐标具有彼此接近的莫顿码, 可以应用于为一个整数对产生一个唯一索引。例如，对于坐标系中的坐标点使用莫顿编码生成的莫顿码，可以唯一索引对应的点。这些索引为“Z”形排序。如下图以Z形(左上->右上->左下->右下)分别代表1。根据上图的对照变，可以看出 红色的位存储Tile等级，蓝色位不存储，灰色位存储 NDS 横、纵坐标的莫顿码。莫顿码是将多维数据转化为一维数据的编码。
关于莫顿编码计算过程
weixin_44312010的博客
10-12 1万+
关于摩顿编码的计算 莫顿码的基本原理 莫顿码是一种将多维空间中的点坐标用一个一维的数值来表示，通过利用莫顿编码的方式来讲空间中点所对应的空间关系用莫顿码值之间的相邻关系来近似表示。 莫顿编码的计算方式 1.通过依次对多维空间中的点进行“迭代交叉计算”； 2.通过利用查询表来计算对应的莫顿码； 在本篇博客中，我增添了对于二维几何和三维几何坐标所对应的莫顿码值的整个过程。 ...
三维坐标莫顿码计算 c++算法程序
小小码农的博客
05-28 9076
莫顿码可以将多维数据转化为一维数据编码，根据一维编码位数可确定多维数据保留精度，是一种比较常用的压缩编码方法，尤其是作为哈希表的映射算法等，加速了树结构数据的存储和访问速度。莫顿编码也叫z-order code ，因为其编码顺序按照空间z序.从二维莫顿编码的计算开始：上图展示了8*8的图像每个像素的空间编码，从000000到111111，用一维二进制数，编码了x,y值在0-7的位置坐标。交错二进制...
计算莫顿码00233355
05-14
莫顿码的计算方法如下： 将二维坐标分别转换为二进制数，并将它们交替组合起来，形成一个新的二进制数，这个新的二进制数就是该点的莫顿码。 以点 (0, 23) 为例，它的二进制坐标分别为 (0, 10111)，将它们交替组合...
栅格数据的十进制四叉树编程与莫顿码转换
1. 确定莫顿码的长度，然后将莫顿码的二进制表示分为两部分，每部分长度相等（如果莫顿码长度是奇数，则将最高位单独作为一部分）。 2. 分别将这两部分看作是x坐标和y坐标的二进制表示。 3. 将二进制坐标转换为十...
NDS导航格式说明2.1
10-10
NDS 2.1 导航标准文档，可查看NDS各个模块如何组成。 NDS
Rust语言实现的莫顿码算法解析
资源摘要信息:"莫顿码（Morton Code），又称Z-order曲线，是一种将多维数据映射到一维数据的方法，以便于数据的存储和搜索。莫顿码能够将二维空间的点编码到一个一维的整数序列中，使得相邻的二维点在经过莫顿码转换...
Architecture of NDS（Navigation Data Standard）
book_withc的专栏
07-15 1795
介绍下Navigation Data Standard (so-called NDS databases)的架构，和其最重要的一些概念。, 1，NDS Database and its Interfaces      NDS的数据可以称为是一个database，是被其标准文档所规范好的标准database。作为一个标准化的database，也就是你生产出来的NDS和别人生产出来的NDS，数
经纬度数据库存储格式_NDS数据格式介绍
weixin_39884074的博客
01-16 2567
NDS .e.v 是由汽车制造商、系统供应商、和地图共用商组成的注册制组织。其提倡标准化导航数据的物理存储格式。nds 数据结构1. nds按功能将数据划分成building block，其中routing building block和name building block是强制的，其他的都是可选的2. nds数据的分层和划分： WGS84 和 EGM96 nds使用的是WGS84坐标系...
根据经纬度坐标计算NDS标准下的格网ID
Kevin00Xu的博客
03-03 2892
根据经纬度坐标计算NDS标准下的格网ID前言一、NDS是如何划分格网并编码的二、计算格网ID的具体实现总结 前言 一、NDS是如何划分格网并编码的 这里直接引用原文。 Navigation Data Standard uses WGS 84, the World Geodetic System dating from 1984, as the standard coordinate reference system for representing latitude and longitude of obj
【DRL】最简单的策略梯度(Policy Gradient)算法
最新发布
xfxuezhang.cn
06-12 208
最简策略梯度(Policy Gradient)算法的实现
【LeetCode 热题100】网格路径类 DP 系列题：不同路径 & 最小路径和（力扣62 / 64 ）（Go语言版）
小韩的博客
06-08 604
本篇介绍了网格路径类动态规划问题，涵盖 LeetCode 第 62 题“不同路径”和第 64 题“最小路径和”。通过定义状态 `dp[i][j]` 和转移方程，分别解决路径计数与最小代价问题。两题均支持一维数组优化空间复杂度。总结对比了两题的异同，并延伸至带障碍路径、三角形路径等问题，帮助读者掌握网格 DP 的核心思路：明确状态、写出转移、找准边界。
【算法笔记】树套树
fans2306的博客
06-08 1070
在面对二维区间统计问题查询某个一维区间中，大于某个值的数的个数对一个序列同时支持区间查询 + 单点修改我们常用的一维数据结构（如线段树、树状数组）往往显得力不从心。树套树。“树套树”顾名思义，就是一棵树中的每个节点再套一棵树。外层：线段树/树状数组，按照下标维护区间内层：平衡树（如 STLmultiset或手写）维护该区间内的值集合单点修改某个值查询区间中小于/大于某值的数的个数查询区间第kkk小数值（需平衡树）
【2025CVPR】模型融合新范式：PLeaS算法详解（基于排列与最小二乘的模型合并技术）
hasakie的博客
06-08 138
本文深入解析ICLR 2025顶会论文《PLeaS: Merging Models with Permutations and Least Squares》，揭示模型融合领域突破性进展.随着开源模型的爆发式增长，如何高效合并多个专用模型成为关键挑战。传统方法存在三大痛点：而PLeaS创新性地解决了这些难题，实现：PLeaS（Permutations and Least Squares）包含两个核心阶段： 数学本质​： minPi​∈Sdi​​​∥ZiA​−Pi​ZiB​∥F2​ 其中ZiA​,ZiB​是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

神气爱哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值