Revit二次开发小技巧（十五）构件的最小矩形外轮廓

已于 2023-01-09 09:20:57 修改
阅读量588 收藏 9
点赞数 4
分类专栏： Revit二次开发小技巧 文章标签： c# 经验分享
于 2022-12-15 23:12:44 首次发布
包包熊出品
本文链接：https://blog.csdn.net/Oneal5354/article/details/128336383
版权

前言：我们会经常遇到需要计算一个构件的最小外轮廓，一般直接取BoundingBox只有最大和最小值坐标，也是基于x-y坐标系下的。往往不是最小的矩形，所以分享下面的算法来计算最小的外轮廓，条件为法向量是指向Z轴的，暂时没有考虑曲线的情况

背景

需要得到下面构件的最小外接矩形
在这里插入图片描述
一般我们使用BoundingBox只能取到最大包络框，而且是基于x-y坐标系下面的。
在这里插入图片描述
实际上我们需要的是最小的外接矩形
在这里插入图片描述

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Autodesk.Revit.UI;
using Autodesk.Revit.DB;
using Autodesk.Revit.Attributes;
using Autodesk.Revit.UI.Selection;

namespace RevitTest
{
    [Transaction(TransactionMode.Manual)]
    public class MinimumBoundingRectangleCmd : IExternalCommand
    {
        public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
        {
            UIDocument uidoc = commandData.Application.ActiveUIDocument;
            Document doc = uidoc.Document;
            Reference selRef;
            try
            {
                selRef = uidoc.Selection.PickObject(ObjectType.Element, "选择构件");
            }
            catch
            {
                return Result.Succeeded;
            }
            //实体构件
            List<CurveLoop> downCLList = GetDownFaceCurveLoop(GetSolids(doc.GetElement(selRef)));
            //得到凸包轮廓
            List<Line> convexColsure = GetConvexClosure(doc, downCLList.SelectMany(x => x).OfType<Line>().ToList());
            //得到最小的轮廓
            List<Line> minBoundingRectangle = GetMinimumBoundingRectangle(doc, convexColsure);
            Transaction trans = new Transaction(doc, "生成轮廓线");
            trans.Start();
            minBoundingRectangle.ForEach(x => LineTest(doc, x));
            trans.Commit();
            return Result.Succeeded;
        }
        /// <summary>
        /// 得到最小的矩形轮廓
        /// </summary>
        /// <param name="convexColsure"></param>
        /// <returns></returns>
        public List<Line> GetMinimumBoundingRectangle(Document doc, List<Line> convexColsure)
        {
            List<Line> result = new List<Line>();
            //确定x-y坐标系下最大的外轮廓
            IEnumerable<XYZ> pointList = convexColsure.Select(x => x.GetEndPoint(0));
            double area = double.MaxValue;
            foreach (var l in convexColsure)
            {
                List<Line> rectabgleLineList = GetMinimumBoundingOnPoints(pointList, l.Direction, XYZ.BasisZ.CrossProduct(l.Direction));
                double nwArea = rectabgleLineList[0].Length * rectabgleLineList[1].Length;
                if (nwArea < area)
                {
                    area = nwArea;
                    result = rectabgleLineList;
                }
            }
            return result;
        }
        /// <summary>
        /// 获取点集中的最大点和最小点
        /// </summary>
        /// <param name="points">点集合</param>
        /// <param name="xAxis">x轴</param>
        /// <param name="yAxis">y轴</param>
        /// <returns></returns>
        public List<Line> GetMinimumBoundingOnPoints(IEnumerable<XYZ> points, XYZ xAxis, XYZ yAxis)
        {
            XYZ minPoint = null;
            XYZ maxPoint = null;
            if (points.Count() < 2)
            {
                return null;
            }
            Transform transform = Transform.Identity;
            transform.BasisX = xAxis;
            transform.BasisY = yAxis;
            //取逆矩阵，转回想要的坐标系
            transform = transform.Inverse;
            double minX = int.MaxValue;
            double maxX = int.MinValue;
            double minY = int.MaxValue;
            double maxY = int.MinValue;
            double minZ = int.MaxValue;
            double maxZ = int.MinValue;
            foreach (var xyz in points)
            {
                //转换
                XYZ current = transform == null ? xyz : transform.OfPoint(xyz);
                minX = Math.Min(current.X, minX);
                maxX = Math.Max(current.X, maxX);
                minY = Math.Min(current.Y, minY);
                maxY = Math.Max(current.Y, maxY);
                minZ = Math.Min(current.Z, minZ);
                maxZ = Math.Max(current.Z, maxZ);
            }
            minPoint = new XYZ(minX, minY, minZ);
            maxPoint = new XYZ(maxX, maxY, maxZ);
            XYZ point1 = new XYZ(minX, maxY, maxZ);
            XYZ point2 = new XYZ(maxX, minY, minZ);
            List<Line> result = new List<Line>()
            {
                Line.CreateBound(point1,minPoint).CreateTransformed(transform.Inverse) as Line,
                Line.CreateBound(minPoint,point2).CreateTransformed(transform.Inverse) as Line,
                Line.CreateBound(point2,maxPoint).CreateTransformed(transform.Inverse) as Line,
                Line.CreateBound(maxPoint,point1).CreateTransformed(transform.Inverse) as Line,
            };
            return result;
        }

        /// <summary>
        /// 得到凸包轮廓
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="lines"></param>
        /// <returns></returns>
        public List<Line> GetConvexClosure(Document doc, List<Line> lines)
        {
            List<Line> result = new List<Line>();
            List<XYZ> allPointList = new List<XYZ>();
            lines.ForEach(x =>
            {
                XYZ point1 = SetZ(x.GetEndPoint(0), 0);
                XYZ point2 = SetZ(x.GetEndPoint(1), 0);
                if (allPointList.FirstOrDefault(m => m.DistanceTo(point1) < 1 / 304.8) == null)
                    allPointList.Add(point1);
                if (allPointList.FirstOrDefault(m => m.DistanceTo(point2) < 1 / 304.8) == null)
                    allPointList.Add(point2);
            });
            //找出最x轴最小的点，然后Y轴最小点
            XYZ originPoint = allPointList.OrderBy(x => x.DotProduct(XYZ.BasisX)).ThenBy(x => x.DotProduct(XYZ.BasisY)).FirstOrDefault();
            //LineTest(doc, Line.CreateBound(originPoint, originPoint.Add(XYZ.BasisX * 100)));
            XYZ startPoint = originPoint;
            XYZ endPoint = null;
            while (true)
            {
                if (allPointList.Count == 0) break;
                XYZ startDirection = new XYZ();
                if (endPoint == null)
                    startDirection = -XYZ.BasisY;
                else
                    startDirection = (endPoint - startPoint).Normalize();
                IEnumerable<XYZ> directionList = allPointList.OrderBy(x =>
                {
                    if (x.DistanceTo(startPoint) < 1 / 304.8 || (endPoint != null && x.DistanceTo(endPoint) < 1 / 304.8)) return 1000000000;
                    XYZ direction = (x - startPoint).Normalize();
                    return startDirection.AngleOnPlaneTo(direction, XYZ.BasisZ);
                });
                XYZ onePoint = directionList.FirstOrDefault();
                result.Add(Line.CreateBound(startPoint, onePoint));
                if (onePoint.DistanceTo(originPoint) < 1 / 304.8) break;
                endPoint = startPoint;
                startPoint = onePoint;
            }
            return result;
        }

        /// <summary>
        /// 返回坐标的Z值
        /// </summary>
        /// <param name="point"></param>
        /// <param name="zValue"></param>
        /// <returns></returns>
        public XYZ SetZ(XYZ point, double zValue)
        {
            return new XYZ(point.X, point.Y, zValue);
        }

        /// <summary>
        /// 得到实体集合中的所有底面轮廓集合
        /// </summary>
        /// <param name="solids"></param>
        /// <returns></returns>
        public List<CurveLoop> GetDownFaceCurveLoop(List<Solid> solids)
        {
            List<CurveLoop> result = new List<CurveLoop>();
            List<PlanarFace> topFaceList = new List<PlanarFace>();
            foreach (var s in solids)
            {
                foreach (Face geoFace in s.Faces)
                {
                    PlanarFace temFace = geoFace as PlanarFace;
                    if (temFace == null) continue;
                    if (IsParallel(temFace.FaceNormal, XYZ.BasisZ, false))
                    {
                        topFaceList.Add(temFace);
                        //break;
                    }
                }
            }

            foreach (var topFace in topFaceList)
            {
                var curveLoopList = topFace.GetEdgesAsCurveLoops().ToList();
                result.AddRange(curveLoopList);
            }
            return result;
        }
        /// <summary>
        /// 计算两点平面上的距离
        /// </summary>
        /// <param name="onePoint"></param>
        /// <param name="twoPoint"></param>
        /// <returns></returns>
        public double GetHorizontalDistance(XYZ onePoint, XYZ twoPoint)
        {
            return Math.Pow(Math.Pow(onePoint.X - twoPoint.X, 2) + Math.Pow(onePoint.Y - twoPoint.Y, 2), 0.5);
        }

        /// <summary>
        /// 生成直线
        /// </summary>
        /// <param name="doc"></param>
        /// <param name="l"></param>
        /// <returns></returns>
        public ModelCurve LineTest(Document doc, Line l)
        {
            XYZ basicZ = XYZ.BasisZ;
            if (l.Direction.AngleTo(XYZ.BasisZ) < 0.0001 || l.Direction.AngleTo(-XYZ.BasisZ) < 0.0001)
                basicZ = XYZ.BasisY;
            XYZ normal = basicZ.CrossProduct(l.Direction).Normalize();

            Plane plane = Plane.CreateByNormalAndOrigin(normal, l.GetEndPoint(0));

            Transaction transCreate = null;
            if (!doc.IsModifiable)
                transCreate = new Transaction(doc, "模型线测试");
            transCreate?.Start();
            SketchPlane sktpl = SketchPlane.Create(doc, plane);
            ModelCurve mc = doc.IsFamilyDocument ? doc.FamilyCreate.NewModelCurve(l, sktpl) : doc.Create.NewModelCurve(l, sktpl);
            transCreate?.Commit();
            return mc;
        }
        /// <summary>
        /// 拿到对应构件的Solid集合
        /// </summary>
        /// <param name="elem"></param>
        /// <param name="vdtLevel"></param>
        /// <returns></returns>
        public List<Solid> GetSolids(Element elem, ViewDetailLevel vdtLevel = ViewDetailLevel.Fine)
        {
            if (elem == null)
            {
                return new List<Solid>();
            }
            GeometryElement geometryElement = elem.get_Geometry(new Options
            {
                ComputeReferences = true,
                DetailLevel = vdtLevel,
                IncludeNonVisibleObjects = false,
            });
            return GetSolids(geometryElement);
        }
        /// <summary>
        /// 获取所有的Solid
        /// </summary>
        /// <param name="geometryElement"></param>
        /// <returns></returns>
        public List<Solid> GetSolids(GeometryElement geometryElement)
        {
            List<Solid> result = new List<Solid>();
            foreach (GeometryObject geomObj in geometryElement)
            {
                Solid solid = geomObj as Solid;
                if (null != solid)
                {
                    result.Add(solid);
                    continue;
                }
                //If this GeometryObject is Instance, call AddCurvesAndSolids
                GeometryInstance geomInst = geomObj as GeometryInstance;
                if (null != geomInst)
                {
                    GeometryElement transformedGeomElem = geomInst.GetInstanceGeometry(Transform.Identity);
                    result.AddRange(GetSolids(transformedGeomElem));
                }
            }
            return result;
        }
        /// <summary>
        /// 得到实体指定方向的一开始的面(取该方向上最里面的面)
        /// </summary>
        /// <param name="targetSolid"></param>
        /// <returns></returns>
        public List<CurveLoop> GetDirectionOriginCurveLoop(Solid targetSolid, XYZ direction)
        {
            List<CurveLoop> result = new List<CurveLoop>();
            List<PlanarFace> topFaceList = new List<PlanarFace>();
            foreach (Face geoFace in targetSolid.Faces)
            {
                PlanarFace temFace = geoFace as PlanarFace;
                if (temFace == null) continue;
                if (IsParallel(temFace.FaceNormal, direction))
                {
                    topFaceList.Add(temFace);
                }
            }
            var topFace = topFaceList.OrderBy(x => x.Origin.DotProduct(direction)).FirstOrDefault();
            var curveLoopList = topFace.GetEdgesAsCurveLoops().ToList();
            result.AddRange(curveLoopList);
            return result;
        }
        /// <summary>
        /// 向量是否平行
        /// </summary>
        /// <param name="vector1"></param>
        /// <param name="vector2"></param>
        /// <param name="v">true为同向平行，false为反向平行，null为平行</param>
        /// <param name="tolerance">允许误差的角度</param>
        /// <returns></returns>
        public bool IsParallel(XYZ vector1, XYZ vector2, bool? v = null, double tolerance = 0.1)
        {
            var angle = vector1.AngleTo(vector2) / Math.PI * 180;
            if (v == null)
            {
                return angle >= 180 - tolerance || angle <= tolerance;
            }
            else if (v == true)
            {
                return angle <= tolerance;
            }
            else
            {
                return angle >= 180 - tolerance;
            }
        }
        /// <summary>
        /// 传入集合的集合体，批量操作
        /// </summary>
        /// <param name="solids"></param>
        /// <param name="booleanOperationsType"></param>
        /// <returns></returns>
        public Solid GetUnionSolid(List<Solid> solids, BooleanOperationsType booleanOperationsType)
        {
            Solid firstSolid = solids[0];
            solids.RemoveAt(0);
            //对所有的几何体进行融合
            foreach (var oneSoild in solids)
            {
                try
                {
                    firstSolid = SolidBooleanOperation(firstSolid, oneSoild, booleanOperationsType);
                }
                catch
                {

                }

            }
            return firstSolid;
        }
        /// <summary>
        /// Solid布尔操作
        /// </summary>
        /// <param name="solidA"></param>
        /// <param name="solidB"></param>
        /// <param name="booleanOperationsType"></param>
        /// <returns></returns>
        public Solid SolidBooleanOperation(Solid solidA, Solid solidB, BooleanOperationsType booleanOperationsType)
        {
            Solid result = null;
            try
            {
                result = BooleanOperationsUtils.ExecuteBooleanOperation(solidA, solidB, booleanOperationsType);
            }
            catch (Exception ex)
            {
                result = BooleanOperationsUtils.ExecuteBooleanOperation(solidB, solidA, booleanOperationsType);
            }
            return result;
        }

    }
}

思路

一、确定底面轮廓线

通过找到构件的所有底面，然后返回所有的面的轮廓线
在这里插入图片描述

二、根据轮廓线计算凸包轮廓

把线的起终点都添加到集合里面，然后去重。由于我们当前方法仅处理法向量为XYZ.BasisZ的平面，需要把所有的点都降到统一的平面上，默认Z轴为0。
在这里插入图片描述
凸包算法的思路：

  1. 找到X轴和Y轴数值最小的点，确定为原点，也为起点
    在这里插入图片描述

  2. 默认开始的方向为-Y轴的方向
    在这里插入图片描述

  3. 根据点集里面的点，分别构建一个起点出发，指向其他点的向量。
    在这里插入图片描述

  4. 如果是原点的时候，就找-Y轴和哪个点构造的向量的逆时针夹角最小。这个点就是我们要的下一个凸点。
    在这里插入图片描述

  5. 以找到的凸点为起点，找到的凸点和上一个凸点的向量为初始向量。重复构造点集向量，找最小夹角的过程。

  6. 在回到原点的时候，寻找结束。
    在这里插入图片描述

三、根据凸包轮廓生成矩形轮廓

  1. 以凸包轮廓的每一条线的方向为X轴，通过Z轴和X轴的叉乘得到Y轴
    在这里插入图片描述

  2. 以X和Y轴的单位向量，构建一个Transform对象，并把BasisX和BasisY设置组成对应的XY轴方向。（相当于把构件以点旋转了一定角度，把坐标系变成我们要的坐标系）
    在这里插入图片描述

  3. 把所有的点都转到以我们需要的XY轴的坐标系下，再计算四个角点，并连成矩形。得到的线再转回到项目的坐标下，就得到这条边对应的外接矩形了。
    在这里插入图片描述

  4. 所有的边都计算一个外接矩形，然后得到哪个外接矩形面积最小，就是我们要的那个了。
    在这里插入图片描述

写在最后

希望这篇文章可以给你带来帮助~~~

baobao熊
关注
  • 4
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
revit二次开发读取cad信息并生成构件
06-12
通过研究这个项目，开发者可以学习到具体的编程技巧和方法，进一步掌握Revit二次开发读取CAD信息并生成构件的技术。 总之，Revit二次开发结合Teigha库，可以高效地实现CAD到Revit的模型转换，提升设计和建模的效率...
Revit二次开发，创建任意视角的3d视图
09-23
在Revit二次开发中，创建任意视角的3d视图是一项关键技能，这涉及到Revit API的深入理解和灵活运用。Revit是Autodesk公司推出的一款强大的建筑信息模型（BIM）软件，它允许用户创建、编辑和管理建筑设计的三维模型。...
一组点，怎么求轮廓最小外接矩形？？C#实现
最新发布
weixin_39899255的博客
04-23 1235
该算法的基本思想是，在点集上绕着一个点旋转卡尺，保持卡尺间距不变，直到卡尺夹住点集边界上的两个点，记录此时卡尺的长度。然后，将卡尺旋转一定角度，直到卡尺夹住另外两个点，再记录此时的卡尺长度。重复这个过程直到卡尺夹住了所有的点，最终得到的最小卡尺长度就是最小外接矩形的对角线长度。找到距离点P1最远的点P2，将卡尺从P1和P2的中点开始沿着点集的凸包边缘旋转，记录此时卡尺的长度。记录每个旋转角度下的最小卡尺长度，最终得到的最小卡尺长度就是最小外接矩形的对角线长度。
Revit Family API 创建参考平面
weixin_34163741的博客
11-14 317
使用API来编辑族时，使用doc.FamilyCreate.NewReferencePlane();创建参考平面。//Revit Family API 创建参考平面[TransactionAttribute(Autodesk.Revit.Attributes.TransactionMode.Manual)]public class cmdCreateReferencePlane : IExtern...
25-轮廓最小外接矩形（minAreaRect()）(EmguCV学习)
hello
03-22 4957
文章目录说明Code效果 说明 Code using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Emgu.CV; using Emgu.Util; using Emgu.CV.Util; using Emgu...
Revit二次开发 获取墙相交的墙，获取墙垂直的墙、平行的墙
qq_42707143的博客
01-06 689
Revit二次开发 获取墙相交的墙，获取墙垂直的墙、平行的墙
Revit二次开发——提取剖面视图中截面轮廓
qq_29821795的博客
04-16 1735
问题 在之前的业务开发中，需要用户定义剖面视图，然后通过程序自动提取相应剖面的截面轮廓。但是，由于Revit项目文件中的模型都是体的概念，即使剖面视图中显示的是二维轮廓的形状，依旧无法通过API直接获取相应的截面曲线或者截面坐标点。 解决思路 但是经过一番思考，我们可以采用曲线救国的方案，可以先通过将剖面视图自动导出为CAD的dwg文件格式，然后再通过Teigha.Net的类库去解析dwg文件，来获取到截面轮廓的曲线对象数据。 代码实例 剖面视图导出 SelectViewSectionList为剖面视图对象
Revit二次开发 防止弹窗
12-31
使用Revit二次开发，commandData.Application.OpenAndActivateDocument打开文件时，revit可能会弹出找不到参照等提示框，此资源可避免提示框的弹出
Revit二次开发，通过xml或者json等文件自动生成菜单
10-27
在Revit二次开发中，创建自定义菜单是一个常见的需求，以增强软件的用户界面和功能。这通常涉及到编程技术，如C#或Python，并利用Revit API。标题提及的“通过xml或者json等文件自动生成菜单”是一种灵活的方法，...
Revit二次开发小技巧（十四）封闭墙体最大外轮廓
包包熊的博客
12-12 393
封闭墙体找最大外轮廓
获取洞口边界及在墙上开洞（Revit二次开发）
weixin_46433786的博客
09-24 2305
一、洞口类图 #mermaid-svg-8CPGxHq9ZTevDBGx .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-8CPGxHq9ZTevDBGx .label text{fill:#333}#mermaid-svg-8CPGxHq9ZTevDBGx .node rect,#mermaid-svg-8CP
Revit二次开发-查找户型外墙
BIM技术园
12-01 1423
最近开发需要查找一个户型的最外圈墙。如下图所示： 经过一番研究，终于发现了一个完美方式，当然也是借助Revit本身功能。 思路如下： 在整个模型外圈用房间分隔线画一个包围框，然后创建房间，根据房间边界线找到墙。...
revit二次开发载入外部族_Revit幕墙门窗的创建方法
weixin_39578867的博客
12-17 720
在Revit软件中有一个现象，是把幕墙的门窗和普通建筑门窗做了区分，普通建筑门窗可以在墙体上剪切墙体，从而放置门窗。但是在幕墙上要放置门窗的话，需要用用公制门和公制窗的族样板来制作，我们来看下族样板。这里以幕墙窗为例来和大家分享一下幕墙窗应该怎么制作，首先我们需要选择这个公制窗-幕墙的族样板。打开之后，在平面视图中，这个族样板很简单，只是用Exterior来区分了窗户的内外，同时可以看到几条参照平...
Revit二次开发之ExporterIFCUtils 获得墙上的柱子 墙连接的墙，闭合曲线面积
u010585773的专栏
10-23 1203
UIApplication uiapp = commandData.Application;             UIDocument uidoc = uiapp.ActiveUIDocument;             Document doc = uidoc.Document;             Reference refer_1 = uidoc.Selection.Pick...
revit二次开发（获取墙的边长和面的面积）
qq_34968766的博客
07-23 2417
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Autodesk.Revit.DB; using Autodesk.Revit.Attributes; using Autodesk.Revit.UI; u...
Revit二次开发 添加、获取墙核心边界信息
MonkeyBananas的博客
07-14 1534
//创建结构层（厚度、功能、材质） IList<CompoundStructureLayer> layers = new List<CompoundStructureLayer>(); //创建一条核心边界 CompoundStructureLayerlayerSurfaceThickness = newCompoundStructureLayer(thickness, MaterialFunctionAssignment.Finish1, ElementId.InvalidE...
Revit二次开发 获取模型截面线、截面轮廓
旋转De陀螺
03-20 1672
Revit二次开发 模型截面线； Revit二次开发 截面轮廓； Revit二次开发 横切面线； Revit二次开发 视图平面线； Revit二次开发 获取模型截面线； Revit二次开发 获取截面轮廓； Revit二次开发 获取横切面线； Revit二次开发 获取视图平面线；
Building Coder（Revit 二次开发）- 图形化显示区域边界
摘花换酒的专栏
10-15 3948
原文链接：Graphically Display Area Boundary Loops 我最近研究了一个关于检测区域边界是否闭合的问题，方法是在 RevitLookup 中查看相关的坐标值。但是我想人脑很难分析这么多的数据，所以靠谱的方式你懂的，还是创建一个外部命令(DisplayBoundary)来自动化地完成。该命令遍历选中区域（或是模型中的所有区域）的边界片段，然后创建一个曲线来代表
Revit二次开发入门教程：叶雄进讲解
"Revit2011APIDevTV1是叶雄进(Joe Ye)于2010年5月为Autodesk DevTech创作的一系列Revit二次开发入门教程。这些教程主要针对Revit 2011版本，旨在帮助用户掌握Revit API的使用，进行高效的二次开发工作，提升建筑设计...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

baobao熊

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

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

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

打赏作者

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

抵扣说明：

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

余额充值