主页 > 快讯 >

比特派(bitpie)钱包app官方下载|draco

比特派(bitpie)钱包app官方下载 2024-03-07 18:21:00

GitHub - google/draco: Draco is a library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics.

Toggle navigation

Product

Actions

Automate any workflow

Packages

Host and manage packages

Security

Find and fix vulnerabilities

Codespaces

Instant dev environments

Copilot

Write better code with AI

Code review

Manage code changes

Issues

Plan and track work

Discussions

Collaborate outside of code

Explore

All features

Documentation

GitHub Skills

Blog

Solutions

For

Enterprise

Teams

Startups

Education

By Solution

CI/CD & Automation

DevOps

DevSecOps

Resources

Learning Pathways

White papers, Ebooks, Webinars

Customer Stories

Partners

Open Source

GitHub Sponsors

Fund open source developers

The ReadME Project

GitHub community articles

Repositories

Topics

Trending

Collections

Pricing

Search or jump to...

Search code, repositories, users, issues, pull requests...

Clear

Search syntax tips

Provide feedback

We read every piece of feedback, and take your input very seriously.

Include my email address so I can be contacted

Cancel

Submit feedback

Saved searches

Use saved searches to filter your results more quickly

Name

Query

To see all available qualifiers, see our documentation.

Cancel

Create saved search

You signed in with another tab or window. Reload to refresh your session.

You signed out in another tab or window. Reload to refresh your session.

You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

google

draco

Public

Notifications

Fork

920

Star

6.2k

Draco is a library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics.

google.github.io/draco/

License

Apache-2.0 license

6.2k

stars

920

forks

Branches

Draco库简析_draco几何压缩-CSDN博客

Draco库简析

最新推荐文章于 2023-02-08 09:43:20 发布

竹以

最新推荐文章于 2023-02-08 09:43:20 发布

阅读量6.5k

点赞数

分类专栏：

点云相关信息汇总

本文链接：https://blog.csdn.net/l18850339134/article/details/107785515

版权

点云相关信息汇总

专栏收录该内容

1 篇文章

0 订阅

订阅专栏

Draco库简析

一.简介

Draco是谷歌Chrome 团队在2017年1月发布的一个Draco是用于压缩和解压缩3D几何网格和点云的库，旨在改善3D图形的存储和传输，大幅加速 3D 数据的编码、传输和解码。这个开源算法的首要应用对象是浏览器。但可以去探索 Draco 在其他场景的应用，比如说非网页端。目前，谷歌提供了它的两个版本： JavaScript 和 C++。

Draco 可以被用来压缩 mesh 和点云数据。它还支持压缩点（ compressing points），连接信息，纹理协调，颜色信息，法线以及其他与几何相关的通用属性。

Draco 的算法**既支持有损模式，也支持无损。**有损压缩带来的轻微画质改变完全在承受范围之内。用于游戏和 VR 应用完全没有问题，降低的画质很难用肉眼察觉。但在科研点云数据中，任何信息都不能丢失，就应使用无损压缩。

Draco是一种基于量化的压缩方法，是一种开放格式，具有一些关键优势：

顺序优化编码：Draco编码器使用基于KD-tree的编码器重新排列点以实现最佳压缩。

通用属性：Draco可以压缩通用属性，例如强度和分类。

可配置的压缩：根据容忍的有损性，点云可以使用1到31个量化位之间的任何位置。压缩率可以调整为毫米或更高的精度。

二.文献收集

1. 文献-用Draco压缩ROS传感器和几何信息-Compressing ROS Sensor and Geometry Messages with Draco

例如，Draco非常依赖Edgebreaker[7]技术来压缩网格数据。有关基本网格压缩技术的详细综述见[8]。

对于点云数据，大多采用基于八叉树的方法，编码复杂。为了减少传输数据量，八叉树的深度被限制为取决于可用带宽的确定值。对于三维几何体，现有的方法将连通性编码和其他度量考虑在内。例如，Draco非常依赖Edgebreaker[7]技术来压缩网格数据。有关基本网格压缩技术的详细综述见[8]。

在[10]中，Doumanoglou等人。在3D几何数据的实时流媒体环境中，对Google Draco[6]、O3dgc[11]、Corto[12]和OpenCTM[13]进行了广泛的评估。他们得出了两个有趣的发现，**启发了本文的工作：Draco在延迟更高的场景中优于其他库；其次，Draco还可以有效地包含额外的顶点属性，如法线或颜色。**在这项工作中，我们利用了这种可扩展性，还将人脸属性（如材质）包含到编码的数据流中，而据我们所知，这些数据流以前从未被评估过。

Draco是Google[6]开发的一种压缩算法，可以压缩网格和点云数据。由于两种数据表示在本质上是不同的，它不依赖于单一的压缩算法，而是使用多种不同的技术在压缩比、解码速度和离散化损失方面对这两种表示进行优化压缩。因此，与一般用途的算法（例如gzip）相比，由于这种专门化，它提供了更高的性能。**对于点云数据，Draco主要依靠使用kd树重新排列点的顺序优化编码。位置数据由可配置数量的量化比特离散化。虽然这自然会导致空间分辨率的损失，但可以根据精度或视觉质量的要求对其进行微调。Draco还支持压缩任意点属性，使其非常适合于异构数据。为了压缩网格拓扑，Draco依赖于Edgebreaker算法[7]。Edgebreaker尝试以螺旋形的形式对网格进行编码，将每个三角形面在字符串中的连接进行编码，同时跟踪已经访问过的顶点和面。然后这些字符串由库单独压缩。虽然Draco允许微调许多内部参数，但压缩主要受用于压缩的量化比特数的影响（最小值为1，最大值为31）。它们可以为每个顶点属性单独设置，并允许根据所需精度以不同方式处理每个属性。另外，可以定义速度设置，其允许用户调整压缩和解压缩时间的比率以及预期的压缩比。在压缩时间上，库根据这些需求选择压缩特性的最佳组合。这种参数化允许在最佳精度以及根据需要快速编码和解码速度之间对压缩进行非常细粒度的调整。**对于我们的用户，我们坚持使用自动压缩设置并评估量化设置，因为这个参数对压缩率和几何质量有着最显著的影响。

[7] J. Rossignac, “Edgebreaker: Connectivity compression for triangle meshes,” IEEE Transactions on Visualization and Computer Graphics, vol. 5, no. 1, pp. 47–61, Jan. 1999

[8] J. Peng, C.-S. Kim, and C.-C. J. Kuo, “Technologies for 3d mesh compression: A survey,” Journal of Visual Communication and Image Representation, vol. 16, no. 6, pp. 688–733, 2005.

[10] A. Doumanoglou, P . Drakoulis, N. Zioulis, D. Zarpalas, and P . Daras,“Benchmarking open-source static 3d mesh codecs for immersivemedia interactive live streaming,” IEEE Journal on Emerging andSelected Topics in Circuits and Systems, vol. 9, no. 1, pp. 190–203, March 2019.

2. 文献-用于沉浸式媒体交互式实时流媒体的开源静态三维网格编解码器的基准测试-Benchmarking Open-Source Static 3D Mesh Codecs for Immersive Media Interactive Live Streaming

更具体地说，我们考虑了以下编解码器：Google Draco[12]、Corto[13]、MPEG的开放式3D图形压缩（O3dgc）[14]和OpenCTM[15]。在这些开源实现中，Draco基于[16]，Corto基于[17]，O3dgc基于[18]，而OpenCTM是唯一不基于任何学术出版物的库。

Draco使用Edgebreaker[16]作为其底层网格压缩算法。

**Edgebreaker：**通过一系列步骤遍历3D网格。在每一步，算法访问并编码一个尚未访问的三角形网格。在每个阶段，输入网格被划分为可以共享一个顶点但没有边的脱节区域。包围每个区域的边构成一条多边形曲线，称为“环”。循环的边缘被称为“门”，每一步都有一个门处于活动状态。在每一步中，都有一个三角形与活动门相连，但尚未访问。让v表示这个三角形的顶点，它不与门相关联。Edgebreaker编码了v相对于门的环边界和门本身的关系。Edgebreaker突出显示了5个标记为：C、L、E、R、S的情况。当v不属于活动门回路时，此情况标记为C。当v属于主动门回路并且也与主动门相连时，则根据v与（R或L）相关联的活动门侧，将此情况标记为R、L或E。当v入射到有源门的两侧时，该条件被标记为E。最后，v属于环路但不与有源门相关的条件被标记为S。在图2中，描述了所有Edgebreaker情况的示例。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6T0dwBzJ-1596521986792)(E:\markdown笔记\picture\image-20200801215436803.png)]

图3：TFAN编码示例。已经处理了黑色三角形。尚未处理蓝色三角形。当前编码为灰色的TF。将顶点聚焦为绿色。第一次访问的顶点为黄色。顶点已访问为红色。根据顶点的遍历顺序标记为焦点顶点。左：编码向量：S={1,1,1,1}，I={}。右：S={0,1,1,0}，I={2,1}。

编解码器配置文件在本小节中，我们将简要概述可通过参与此基准测试的每个3D mesh编解码器的可编程接口访问的可用配置选项。对于其中的每一个，相应配置的值隐式地影响其速率失真性能和执行时间。正如前面在第四节开头所介绍的，我们选择并命名特定的“概要文件”，这些配置文件包括每个编解码器的一组特定配置选项。在下面的小节中，将介绍这些概要文件及其选项。

**Draco:Draco对各种浮点顶点属性（位置、法线和自定义属性）进行编码，细节级别由给定的量化位指定。还支持自定义整数属性。**在我们的例子中，pervertex纹理标识符被无损地编码为整数，而纹理混合权重的精度由指定数量的量化比特控制。Draco接口允许通过“速度”设置来调整处理时间与压缩比混合比例，该设置以整数刻度表示，从10（表示最小化处理时间的选项组合）到0（表示导致最可能压缩表示的选项）。我们选择了三种配置进行基准测试，即“Draco2”、“Draco5”和“Draco9”，速度设置分别设置为2、5（默认值）和9（使用底层EdgeBreaker[16]算法的最快设置）。

本文对Corto、Draco、O3dgc和OpenCTM四种开源静态3D-mesh编解码器的比特率、失真度和处理时间进行了广泛、系统和一致的基准测试。与其他工作相比，我们的工作彻底检查了编解码器的性能，不仅压缩几何体和连通性，而且在压缩顶点法线和属性。首先，我们评估了失真率，以及正常的几何失真属性。随后，我们在上述所有方面设定了失真的目标水平，这导致了良好质量（至少在客观方面）的压缩表示，但仍然显著可压缩。对于这些预设的失真程度，我们从比特率和处理时间两个方面评估了编解码器之间的性能。我们得出的结论是，通过相对分析来判断哪个编解码器性能最好并不容易，因为没有一个编解码器在所有比特率、编码和解码时间方面都名列前茅。因此，我们继续对编解码器的性能进行研究，通过在一个远程沉浸式交互式实时流媒体场景中检查它们的理论性能。我们建立了一个TI管道的理论模型，分析计算了端到端延迟的下限和上限，以及在使用这些编解码器时某些常见网络条件下的预期帧速率。我们对TI管道理论模型的拟合值是通过之前进行的大量基准测试得到的。总的来说，我们发现在直播场景中，对于O3dgc的每个配置文件，确实存在一个在所有相关的编解码器方面性能更好的Draco概要文件。此外，除了压缩几何体和连通性的情况外，Corto编解码器在所有方面的性能都比OpenCTM的配置文件好。我们的实时流分析表明，在TI管道中选择Corto和Draco应该是一个基于网络条件的决定，Corto在RTT较低的网络设置上表现最好，而当线路的RTT增加时，Draco的表现更好。本研究的结果可供设计人员选择最佳的三维网状编解码器。此外，上述分析可作为未来3D压缩研究的基准，因为很明显，仍有改进的空间，因为根据我们的理论分析，当所使用的网络参数与实际互联网更接近时，次优帧速率被大多数人实现编解码器。

[16] J. Rossignac, “Edgebreaker: Connectivity compression for triangle meshes,” IEEE Transactions on Visualization and Computer Graphics, vol. 5, no. 1, pp. 47–61, Jan. 1999

3.文献-纹理网格vs彩色点云:V体积视频压缩的主观研究-Textured Mesh vs Coloured Point Cloud A Subjective Study for Volumetric Video Compression

Doumanoglou et al.[22]和Christaki et al.[23]研究了不同的开源网格压缩算法，在比较中发现谷歌的Draco表现最好。

考虑到VV将在不久的将来与传统的视觉媒体一起使用，我们在本文中考虑了压缩场景。考虑到最近的研究结果，我们选择了[22]、[23]、谷歌的Draco编码器来压缩以多边形网格表示的VV。在这种情况下，JPEG压缩被用于纹理图集。对于表示为点云的VVs，我们考虑了MPEG标准化工作[9]:G-PCC和V-PCC中正在开发的最先进的压缩算法。Draco和G-PCC被提出用于压缩静态体积含量，而V-PCC被开发用于压缩VV。由于Draco和G-PCC不考虑时间冗余，因此我们加入了V -PCC的all-intra选项以公平地比较它们。

三.安装和编译

源码地址：https://github.com/google/draco

编译好的程序：https://pan.baidu.com/s/1I4E0-9qgrDCZOOHYeaEZXA

源码编译

在Windows下通过Cmake构建VS2017项目并打开

C*：**\ Users \ nobody> cmake …/ -G “ Visual Studio 15 2017 Win64”*

以release版本和64位进行编译即可在debug目录下得到draco编译好的编码器和解码器在Linux下直接Cmake后在make就能编译

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TUk3dH4p-1596521986794)(E:\markdown笔记\picture\clip_image002.jpg)]

程序使用

draco_encoder将读取OBJ或PLY文件作为输入，并输出Draco编码的文件。

./draco_encoder -i testdata/bun_zipper.ply -o out.drc

量化参数的值0将不会对指定属性执行任何量化。除0以外的任何值都会将指定属性的输入值量化为该位数。例如

./draco_encoder -i testdata/bun_zipper.ply -o out.drc -qp 14

将位置量化为14位（位置坐标的默认值为11）。

一般来说，量化属性越多，压缩率就越高。由你的项目来决定它能容忍多少偏差。一般来说，大多数项目可以将量化值设置为大约11，而不会在质量上有任何明显的差异。

· 压缩级别（-cl）参数打开/关闭不同的压缩功能

./draco_encoder -i testdata/bun_zipper.ply -o out.drc -cl 8

编码点云

通过指定-point_cloud参数，可以使用draco_encoder对点云数据进行编码。如果使用网格输入文件指定-point_cloud参数，则draco_encoder将忽略连接数据并从网格文件编码位置

./draco_encoder -point_cloud -i testdata/bun_zipper.ply -o out.drc

此命令行将网格输入编码为点云，即使输入可能不会产生代表其他点云的压缩

解码点云

draco_decoder将读取draco文件作为输入，并输出OBJ或PLY文件。基本命令行如下所示：

./draco_decoder -i in.drc -o out.obj

压缩测试

（1）40m obj文件压缩成1m,时间在1s之后，在浏览器解码渲染时间也在1s之内，快速，但是没有材质信息，模型质量还未验证。

（2）150m压缩成6m,cl=7,encodeTime=3.6s,decodeTime=5.2s,importTime=1.5s。

压缩效率很高，浏览器解码和渲染时间也能接受，但是这样直接压缩大型文件，在浏览器渲染时会占用大量本地内存，高达1.3G内存都被这个页面占用。渲染质量未验证。

四.框架及源码初步分析

1.编码框架

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y1MGirDe-1596521986796)(E:\markdown笔记\picture\image-20200803131119370.png)]

2.支持的算法、属性等信息

以下为配置代码，可以简要了解Draco库中支持的各种算法和方案

总结：

支持的比特流版本? kDracoPointCloudBitstreamVersionMajor = 2; kDracoPointCloudBitstreamVersionMinor = 3; kDracoMeshBitstreamVersionMajor = 2; kDracoMeshBitstreamVersionMinor = 2; 比特流连接支持的版本？ kDracoPointCloudBitstreamVersion = DRACO_BITSTREAM_VERSION （kDracoPointCloudBitstreamVersionMajor， kDracoPointCloudBitstreamVersionMinor）; DracoMeshBitstreamVersion = DRACO_BITSTREAM_VERSION （ kDracoMeshBitstreamVersionMajor，kDracoMeshBitstreamVersionMinor）；当前支持的文件形式点云三角网格点云的编码方法 POINT_CLOUD_SEQUENTIAL_ENCODING POINT_CLOUD_KD_TREE_ENCODING 网格的编码方法 MESH_SEQUENTIAL_ENCODING MESH_EDGEBREAKER_ENCODING 支持的各种属性编码器 BASIC_ATTRIBUTE_ENCODER MESH_TRAVERSAL_ATTRIBUTE_ENCODER KD_TREE_ATTRIBUTE_ENCODER 支持的顺序编码器？ SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC = 0 通用 SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER 整数 SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION 量化 SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS 法线支持的预测算法（mesh）？ PREDICTION_NONE = -2，不使用 PREDICTION_UNDEFINED = -1，未定义 PREDICTION_DIFFERENCE = 0，差分 PREDICTION_PARALLELOGRAM = 1 平行四边形 PREDICTION_MULTI_PARALLELOGRAM = 2 多平行四边形 PREDICTION_TEX_COORDS_DEPRECATED = 3，特克斯弃用坐标？ PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM = 4 约束多平行四边形 PREDICTION_TEX_COORDS_PORTABLE = 5 特克斯坐标便携式 PREDICTION_GEOMETRIC_NORMAL = 6 几何法线支持的预测方案转换列表 PREDICTION_TRANSFORM_NONE = -1， //基本delta变换，其中将预测计算为差预测值和原始值。 PREDICTION_TRANSFORM_DELTA = 0， //改进的增量转换，其中所有计算的增量值都被包装围绕固定间隔降低熵。 PREDICTION_TRANSFORM_WRAP = 1 //使用倒置图块对法线坐标进行专门的转换。 PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON = 2 //使用规范化的倒数对法线坐标进行专门的变换磁贴。 PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED = 3，支持的网格遍历算法 MESH_TRAVERSAL_DEPTH_FIRST = 0，深度优先 MESH_TRAVERSAL_PREDICTION_DEGREE = 1 等级？优先支持用于压缩edgebreaker算法的变体算法列表？ // 用于网格连通性压缩的边断方法的所有变体列表。 MESH_EDGEBREAKER_STANDARD_ENCODING = 0，标准编码 MESH_EDGEBREAKER_PREDICTIVE_ENCODING = 1，预测编码 MESH_EDGEBREAKER_VALENCE_ENCODING = 2 瓦兰斯编码？

//draco_enc_config compression_share.h

// Currently, we support point cloud and triangular mesh encoding.

// TODO(draco-eng) Convert enum to enum class (safety, not performance).

//支持点云和三角网格编码

enum EncodedGeometryType {

INVALID_GEOMETRY_TYPE = -1,

POINT_CLOUD = 0,

TRIANGULAR_MESH,

};

// List of encoding methods for point clouds.

//对于点云支持顺序编码和八叉树编码

enum PointCloudEncodingMethod {

POINT_CLOUD_SEQUENTIAL_ENCODING = 0,

POINT_CLOUD_KD_TREE_ENCODING

};

// List of encoding methods for meshes.

// 对于网格支持顺序编码和EDGEBREAKER编码

enum MeshEncoderMethod {

MESH_SEQUENTIAL_ENCODING = 0,

MESH_EDGEBREAKER_ENCODING,

};

// List of various attribute encoders supported by our framework. The entries

// are used as unique identifiers of the encoders and their values should not

// be changed!

//各种属性的列表编码器支持我们的框架。编码器的条目作为惟一标识符和它们的值不应该改变!

enum AttributeEncoderType {

BASIC_ATTRIBUTE_ENCODER = 0,

MESH_TRAVERSAL_ATTRIBUTE_ENCODER,

KD_TREE_ATTRIBUTE_ENCODER,

};

//各种连续属性列表编码器/解码器,可以用于我们的管道。的值代表解码器使用的惟一标识符,他们不应该被改变。

enum SequentialAttributeEncoderType {

SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC = 0,

SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER,

SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION,

SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS,

};

// List of all prediction methods currently supported by our framework.

//draco目前支持的预测编码

enum PredictionSchemeMethod {

// Special value indicating that no prediction scheme was used.

PREDICTION_NONE = -2,

// Used when no specific prediction scheme is required.

PREDICTION_UNDEFINED = -1,

PREDICTION_DIFFERENCE = 0,

MESH_PREDICTION_PARALLELOGRAM = 1,

MESH_PREDICTION_MULTI_PARALLELOGRAM = 2,

MESH_PREDICTION_TEX_COORDS_DEPRECATED = 3,

MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM = 4,

MESH_PREDICTION_TEX_COORDS_PORTABLE = 5,

MESH_PREDICTION_GEOMETRIC_NORMAL = 6,

NUM_PREDICTION_SCHEMES

};

// List of all prediction scheme transforms used by our framework.

//预测方案转换列表？

enum PredictionSchemeTransformType {

PREDICTION_TRANSFORM_NONE = -1,

// Basic delta transform where the prediction is computed as difference the

// predicted and original value.

PREDICTION_TRANSFORM_DELTA = 0,

// An improved delta transform where all computed delta values are wrapped

// around a fixed interval which lowers the entropy.

PREDICTION_TRANSFORM_WRAP = 1,

// Specialized transform for normal coordinates using inverted tiles.

PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON = 2,

// Specialized transform for normal coordinates using canonicalized inverted

// tiles.

PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED = 3,

};

// List of all mesh traversal methods supported by Draco framework.

//列出Draco框架支持的所有网格遍历方法。

enum MeshTraversalMethod {

MESH_TRAVERSAL_DEPTH_FIRST = 0,

MESH_TRAVERSAL_PREDICTION_DEGREE = 1,

NUM_TRAVERSAL_METHODS

};

// List of all variant of the edgebreaker method that is used for compression

// of mesh connectivity.

//用于网格连通性压缩的边断方法的所有变体列表。

enum MeshEdgebreakerConnectivityEncodingMethod {

MESH_EDGEBREAKER_STANDARD_ENCODING = 0,

MESH_EDGEBREAKER_PREDICTIVE_ENCODING = 1, // Deprecated.

MESH_EDGEBREAKER_VALENCE_ENCODING = 2,

};

// Draco header V1

struct DracoHeader {

int8_t draco_string[5];

uint8_t version_major;

uint8_t version_minor;

uint8_t encoder_type;

uint8_t encoder_method;

uint16_t flags;

};

enum NormalPredictionMode {

ONE_TRIANGLE = 0, // To be deprecated.

TRIANGLE_AREA = 1,

};

// Different methods used for symbol entropy encoding.

//符号熵编码的不同方法

enum SymbolCodingMethod {

SYMBOL_CODING_TAGGED = 0,

SYMBOL_CODING_RAW = 1,

NUM_SYMBOL_CODING_METHODS,

};

// Mask for setting and getting the bit for metadata in |flags| of header.

#define METADATA_FLAG_MASK 0x8000

} // namespace draco

#endif // DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_

3.Draco实现过程简析（mesh）

参考网址：https://blog.csdn.net/woolseyyy/article/details/63684045?utm_medium=distribute.pc_relevant.none-task-blog-baidujs-2&spm=1001.2101.3001.4242

3.1.encoder过程

encode入口：/tools/draco_encoder.cc: int main()

代码前面大多是对用户设定的数值和编码器等进行选择，其核心代码：

if (mesh && mesh->num_faces() > 0)

ret = EncodeMeshToFile(*mesh, encoder_options, options.output);

else

ret = EncodePointCloudToFile(*pc.get(), encoder_options, options.output);

这里先做判断，判断数据中是否有多个面:

如果有面，则进行Mesh to File的过程若不存在面，则只进行PointCloud to File的过程

PointCloud是n维空间中的点的集合，PointCloud的相关信息在*…/point_cloud/point_cloud.h* 中，内容较多，暂不贴出而Mesh是PointCloud的继承类，Mesh只是比PointCloud多了Face数据: …/mesh/mesh.h

3.2.MeshToFile和MeshToBuffer过程

核心代码：

int EncodeMeshToFile(const draco::Mesh &mesh,

const draco::EncoderOptions &options,

const std::string &file) {

draco::CycleTimer timer;

// Encode the geometry.

draco::EncoderBuffer buffer;

timer.Start();

if (!draco::EncodeMeshToBuffer(mesh, options, &buffer)) {

printf("Failed to encode the mesh.\n");

return -1;

}

timer.Stop();

// Save the encoded geometry into a file.

std::ofstream out_file(file, std::ios::binary);

if (!out_file) {

printf("Failed to create the output file.\n");

return -1;

}

out_file.write(buffer.data(), buffer.size());

printf("Encoded mesh saved to %s (%" PRId64 " ms to encode)\n", file.c_str(),

timer.GetInMs());

printf("\nEncoded size = %zu bytes\n\n", buffer.size());

return 0;

}

这里可以分为两步：

调用 draco::EncodeMeshToBuffer 将 Mesh encode 并存入buffer中将buffer内容调用系统i/o写入file中

函数：draco::EncodeMeshToBuffer

这里draco::EncodeMeshToBuffer的前两个参数是输入，第三个参数是输出，即buffer。这个函数的功能是根据option选择相应的encoder并进行编码，将结果存入buffer中

这个函数前面一部分都在处理option，根据option选择哪种encoder:

Sequential encodingEdgebreaker encoding

函数源码：

bool EncodeMeshToBuffer(const Mesh &m, const EncoderOptions &options,

EncoderBuffer *out_buffer) {

std::unique_ptr encoder;

// Select the encoding method only based on the provided options.

int encoding_method = options.GetGlobalInt("encoding_method", -1);

if (encoding_method == -1) {

// For now select the edgebreaker for all options expect of speed 10

if (options.GetSpeed() == 10) {

encoding_method = MESH_SEQUENTIAL_ENCODING;

} else {

encoding_method = MESH_EDGEBREAKER_ENCODING;

}

if (encoding_method == MESH_EDGEBREAKER_ENCODING) {

encoder = std::unique_ptr(new MeshEdgeBreakerEncoder());

} else {

encoder = std::unique_ptr(new MeshSequentialEncoder());

}

if (encoder)

encoder->SetMesh(m);

return EncodeGeometryToBuffer(encoder.get(), options, out_buffer);

}

然后利用encoder->SetMesh(const Mesh &m)来对encoder内部的一些数据进行了初始化，就是把Mesh和CloudPoint信息在Encoder里也存了一下

源码：

…/compression/mesh/mesh_encoder.cc

void MeshEncoder::SetMesh(const Mesh &m) {

mesh_ = &m;

SetPointCloud(m);

}

…/compression/point_cloud/point_cloud_encoder.cc

void PointCloudEncoder::SetPointCloud(const PointCloud &pc) {

point_cloud_ = &pc;

}

（这里因为Mesh是PointCloud的继承，所以直接把Mesh数据传进SetPointCloud函数了）

最后进行了几何信息的编码，这是这个函数的核心代码，之前都没干什么正事，这里进行了真正的编码

3.3.EncodeGeometryToBuffer过程

最后进行了几何信息的编码，这是这个函数的核心代码

return EncodeGeometryToBuffer(encoder.get(), options, out_buffer);

…/compression/encode.cc

bool EncodeGeometryToBuffer(PointCloudEncoder *encoder,

const EncoderOptions &options,

EncoderBuffer *out_buffer) {

if (!encoder)

return false;

if (!EncodeHeader(*encoder, out_buffer))

return false;

if (!encoder->Encode(options, out_buffer))

return false;

return true;

}

这里首先用EncoderHeader将encoder的一些基本信息写入buffer，以便今后decode 这些信息包括:”DRACO”字符串标识、major version、minor version、encoder type(point cloud, mesh, …)、selected encoding method (edgebreaker, etc…)、保留标识

然后用encoder->Encode根据option对数据进行编码，写入buffer.

3.4.Encoder编码过程

在这个函数中，具体对encoder data、geometry data、point atrributes进行了编码。

这里InitializeEncoder的功能是可以由派生类实现，以执行编码器的任何自定义初始化。在Encode()方法中调用。

EncodeEncoderData的功能是决定是否应该用于编码任何编码特定的数据

不过这两个都是预留接口，设置了虚函数但没有实现，直接返回true

EncoderGeometryData()会把mesh 的 connectivity进行编码并存入buffer，根据encoder的不同，编码connectivity的方式会分为sequential encoding 和 edgebreaker encoding。

…/compression/point_cloud/point_cloud_encoder.cc

bool PointCloudEncoder::Encode(const EncoderOptions &options,

EncoderBuffer *out_buffer) {

options_ = &options;

buffer_ = out_buffer;

// Cleanup from previous runs.

attributes_encoders_.clear();

attribute_to_encoder_map_.clear();

attributes_encoder_ids_order_.clear();

if (!point_cloud_)

return false;

if (!InitializeEncoder())

return false;

if (!EncodeEncoderData())

return false;

if (!EncodeGeometryData())

return false;

if (!EncodePointAttributes())

return false;

return true;

}

3.4.EncodePointAttributes

这里point attributes 的意思是指定每个属性的特定数据。通常，存储在点云中的多个点可以共享相同的属性值，该类在点id和属性值id之间提供了必要的映射。

我的理解是，通过这个函数进行属性压缩。

源码及其位置：

…/compression/point_cloud/point_cloud_encoder.cc

bool PointCloudEncoder::EncodePointAttributes() {

if (!GenerateAttributesEncoders())

return false;

// Encode the number of attribute encoders.

buffer_->Encode(static_cast(attributes_encoders_.size()));

// Initialize all the encoders (this is used for example to init attribute

// dependencies, no data is encoded in this step).

for (auto &att_enc : attributes_encoders_) {

if (!att_enc->Initialize(this, point_cloud_))

return false;

}

// Rearrange attributes to respect dependencies between individual attributes.

if (!RearrangeAttributesEncoders())

return false;

// Encode any data that is necessary to create the corresponding attribute

// decoder.

for (int att_encoder_id : attributes_encoder_ids_order_) {

if (!EncodeAttributesEncoderIdentifier(att_encoder_id))

return false;

}

// Also encode any attribute encoder data (such as the info about encoded

// attributes).

for (int att_encoder_id : attributes_encoder_ids_order_) {

if (!attributes_encoders_[att_encoder_id]->EncodeAttributesEncoderData(

buffer_))

return false;

}

// Lastly encode all the attributes using the provided attribute encoders.

if (!EncodeAllAttributes())

return false;

return true;

}

3.6、7、8…还有好多，实在看不懂，先放着了。

4.Draco库的代码应用案例

这是网上找到的一个通过调用库函数实现自建代码实现的案例，源码如下：

压缩三角网，包括点的位置meshPositions、法线meshnormals、纹理坐标meshUv

示例使用c++完成。

具体步骤

1、初始化变量和数据。

初始化一个四边形，两个三角网

//顶点信息

float meshPositions[12] = {0, 0, 0,

100, 0, 0,

100, 100, 0,

0, 100, 0};

//法线信息

float meshnormals[12] = {0, 1, 0,

0, 1, 0,

0, 1, 0};

//纹理信息

float meshUv[8] = {0, 0,

0, 1,

1, 1,

1, 0};

//索引信息,两个三角形

unsigned short primitiveIndices[6] = {3, 1, 0,

3, 2, 1};

2、将数据初始化到draco中

创建draco对象

// Add faces to Draco mesh. 向Draco网格添加面。

std::unique_ptr dracoMesh(new draco::Mesh());

//写入面索引

const int numTriangles = sizeof(primitiveIndices) / sizeof(primitiveIndices[0]) / 3;//面个数

dracoMesh->SetNumFaces(numTriangles);//设置面个数

for (draco::FaceIndex i(0); i < numTriangles; ++i) {

draco::Mesh::Face face;

face[0] = primitiveIndices[i.value() * 3];

face[1] = primitiveIndices[i.value() * 3 + 1];

face[2] = primitiveIndices[i.value() * 3 + 2];

dracoMesh->SetFace(i, face);

}

压缩顶点

//顶点位置

//为Draco网格创建属性。

draco::GeometryAttribute::Type att_type = draco::GeometryAttribute::POSITION;

const int componentCount = 3;//每个顶点有xyz三个值

//顶点

const int vertexCount = sizeof(meshPositions) / sizeof(meshPositions[0]) / componentCount;

draco::PointAttribute att;

int byte_stride = sizeof(float) * componentCount;//每个顶点的步长，xyz坐标和数据大小，3*4 xyz是3每个是浮点型

att.Init(att_type, componentCount, draco::DT_FLOAT32, false, byte_stride);

int att_id = dracoMesh->AddAttribute(att, /* identity_mapping */ true, vertexCount);

draco::PointAttribute *att_ptr = dracoMesh->attribute(att_id);

//要注意压缩网格后属性id不必与唯一ID相同，但unqiue id不会改变。添加顶点

for (draco::PointIndex i(0); i < vertexCount; i++) {

std::vector vertex_data(componentCount);

memcpy(&vertex_data[0], &meshPositions[i.value() * componentCount], sizeof(float) * componentCount);

att_ptr->SetAttributeValue(att_ptr->mapped_index(i), &vertex_data[0]);

}

法线

//法线

const int normalCount = sizeof(meshnormals) / sizeof(meshnormals[0]) / componentCount;

att_type = draco::GeometryAttribute::NORMAL;

draco::PointAttribute attnormal;

attnormal.Init(att_type, componentCount, draco::DT_FLOAT32, false, sizeof(float) * componentCount);

int normalatt_id = dracoMesh->AddAttribute(attnormal, /* identity_mapping */ true, normalCount);

draco::PointAttribute *normalatt_ptr = dracoMesh->attribute(normalatt_id);

//要注意压缩网格后属性id不必与唯一ID相同，但unqiue id不会改变。添加法线

for (draco::PointIndex i(0); i < normalCount; i++) {

std::vector vertex_data(componentCount);

memcpy(&vertex_data[0], &meshnormals[i.value() * componentCount], sizeof(float) * componentCount);

normalatt_ptr->SetAttributeValue(normalatt_ptr->mapped_index(i), &vertex_data[0]);

}

纹理

//纹理

int uvCounts=2;

const int uvCount = sizeof(meshUv) / sizeof(meshUv[0]) / uvCounts;

att_type = draco::GeometryAttribute::TEX_COORD;

draco::PointAttribute attUv;

attnormal.Init(att_type, 2, draco::DT_FLOAT32, false, sizeof(float) * uvCounts);

int uvatt_id = dracoMesh->AddAttribute(attnormal, true, normalCount);

draco::PointAttribute *uvatt_ptr = dracoMesh->attribute(uvatt_id);

for (draco::PointIndex i(0); i < uvCount; i++) {

std::vector vertex_data(uvCounts);

memcpy(&vertex_data[0], &meshUv[i.value() * uvCounts], sizeof(float) * uvCounts);

uvatt_ptr->SetAttributeValue(uvatt_ptr->mapped_index(i), &vertex_data[0]);

}

3、创建draco压缩对象

//压缩draco

draco::Encoder encoder;

const int posQuantizationBits = 14;

const int texcoordsQuantizationBits = 10;

const int normalsQuantizationBits = 10;

const int colorQuantizationBits = 8;

const int genericQuantizationBits = 8;

//设置压缩参数

encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, posQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, texcoordsQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, normalsQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::COLOR, colorQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::GENERIC, genericQuantizationBits);

draco::EncoderBuffer dracoBuffer;//压缩后存储的对象

const draco::Status status = encoder.EncodeMeshToBuffer(*dracoMesh, &dracoBuffer);//压缩数据

4、获取压缩的数据

if (!status.ok()) {

std::cerr << "Error: Encode mesh.\n";

} else {

std::cout << "success" << std::endl;

std::cout << dracoBuffer.size() << std::endl;//压缩后的数据大小

std::cout << dracoBuffer.data() << std::endl;//压缩后的数据

}

完整代码如下

int main(int argc, char **argv) {

std::cout << "Hello, World!" << std::endl;

//顶点信息

float meshPositions[12] = {0, 0, 0,

100, 0, 0,

100, 100, 0,

0, 100, 0};

//法线信息

float meshnormals[12] = {0, 1, 0,

0, 1, 0,

0, 1, 0};

//纹理信息

float meshUv[8] = {0, 0,

0, 1,

1, 1,

1, 0};

//索引信息,两个三角形

unsigned short primitiveIndices[6] = {3, 1, 0,

3, 2, 1};

// Add faces to Draco mesh. 向Draco网格添加面。

std::unique_ptr dracoMesh(new draco::Mesh());

//写入面索引

const int numTriangles = sizeof(primitiveIndices) / sizeof(primitiveIndices[0]) / 3;//面个数

dracoMesh->SetNumFaces(numTriangles);//设置面个数

for (draco::FaceIndex i(0); i < numTriangles; ++i) {

draco::Mesh::Face face;

face[0] = primitiveIndices[i.value() * 3];

face[1] = primitiveIndices[i.value() * 3 + 1];

face[2] = primitiveIndices[i.value() * 3 + 2];

dracoMesh->SetFace(i, face);

}

//顶点位置

//为Draco网格创建属性。

draco::GeometryAttribute::Type att_type = draco::GeometryAttribute::POSITION;

const int componentCount = 3;//每个顶点有xyz三个值

//顶点

const int vertexCount = sizeof(meshPositions) / sizeof(meshPositions[0]) / componentCount;

draco::PointAttribute att;

int byte_stride = sizeof(float) * componentCount;//每个顶点的步长，xyz坐标和数据大小，3*4 xyz是3每个是浮点型

att.Init(att_type, componentCount, draco::DT_FLOAT32, false, byte_stride);

int att_id = dracoMesh->AddAttribute(att, /* identity_mapping */ true, vertexCount);

draco::PointAttribute *att_ptr = dracoMesh->attribute(att_id);

//要注意压缩网格后属性id不必与唯一ID相同，但unqiue id不会改变。添加顶点

for (draco::PointIndex i(0); i < vertexCount; i++) {

std::vector vertex_data(componentCount);

memcpy(&vertex_data[0], &meshPositions[i.value() * componentCount], sizeof(float) * componentCount);

att_ptr->SetAttributeValue(att_ptr->mapped_index(i), &vertex_data[0]);

}

//法线

const int normalCount = sizeof(meshnormals) / sizeof(meshnormals[0]) / componentCount;

att_type = draco::GeometryAttribute::NORMAL;

draco::PointAttribute attnormal;

attnormal.Init(att_type, componentCount, draco::DT_FLOAT32, false, sizeof(float) * componentCount);

int normalatt_id = dracoMesh->AddAttribute(attnormal, /* identity_mapping */ true, normalCount);

draco::PointAttribute *normalatt_ptr = dracoMesh->attribute(normalatt_id);

//要注意压缩网格后属性id不必与唯一ID相同，但unqiue id不会改变。添加法线

for (draco::PointIndex i(0); i < normalCount; i++) {

std::vector vertex_data(componentCount);

memcpy(&vertex_data[0], &meshnormals[i.value() * componentCount], sizeof(float) * componentCount);

normalatt_ptr->SetAttributeValue(normalatt_ptr->mapped_index(i), &vertex_data[0]);

}

//纹理

int uvCounts=2;

const int uvCount = sizeof(meshUv) / sizeof(meshUv[0]) / uvCounts;

att_type = draco::GeometryAttribute::TEX_COORD;

draco::PointAttribute attUv;

attnormal.Init(att_type, 2, draco::DT_FLOAT32, false, sizeof(float) * uvCounts);

int uvatt_id = dracoMesh->AddAttribute(attnormal, true, normalCount);

draco::PointAttribute *uvatt_ptr = dracoMesh->attribute(uvatt_id);

for (draco::PointIndex i(0); i < uvCount; i++) {

std::vector vertex_data(uvCounts);

memcpy(&vertex_data[0], &meshUv[i.value() * uvCounts], sizeof(float) * uvCounts);

uvatt_ptr->SetAttributeValue(uvatt_ptr->mapped_index(i), &vertex_data[0]);

}

//压缩draco

draco::Encoder encoder;

const int posQuantizationBits = 14;

const int texcoordsQuantizationBits = 10;

const int normalsQuantizationBits = 10;

const int colorQuantizationBits = 8;

const int genericQuantizationBits = 8;

//设置压缩参数

encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, posQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, texcoordsQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, normalsQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::COLOR, colorQuantizationBits);

encoder.SetAttributeQuantization(draco::GeometryAttribute::GENERIC, genericQuantizationBits);

draco::EncoderBuffer dracoBuffer;//压缩后存储的对象

const draco::Status status = encoder.EncodeMeshToBuffer(*dracoMesh, &dracoBuffer);//压缩数据

if (!status.ok()) {

std::cerr << "Error: Encode mesh.\n";

} else {

std::cout << "success" << std::endl;

std::cout << dracoBuffer.size() << std::endl;//压缩后的数据大小

std::cout << dracoBuffer.data() << std::endl;//压缩后的数据

}

system("pause");

return 0;

}

五.总结

它用 edge breaker 算法去压缩面的信息，并产生 CornerTable，用平行四边形差分方式压缩顶点属性信息。

Draco 里面还有其他的压缩顶点属性值的算法，如kd-tree、差分等，详细见各种 PredictionScheme。

1､Draco 在当前的VR、AR生态下，基本上没有直接使用的价值，想用它必须理解原理并修改源码。 2､Draco 里面有比较好的mesh压缩方案，有利于游戏引擎公司基于该代码优化自己的模型设计。 3､Draco 所能压缩的只是3D模型文件中的一部分，而3D相关的资源大头（图片）还是一个老大难的问题

总的来说，Draco整体思路是将网格的连接信息和几何信息进行分别编码并进行存储。 bute::GENERIC, genericQuantizationBits); draco::EncoderBuffer dracoBuffer;//压缩后存储的对象 const draco::Status status = encoder.EncodeMeshToBuffer(*dracoMesh, &dracoBuffer);//压缩数据 if (!status.ok()) { std::cerr << “Error: Encode mesh.\n”; } else { std::cout << “success” << std::endl; std::cout << dracoBuffer.size() << std::endl;//压缩后的数据大小 std::cout << dracoBuffer.data() << std::endl;//压缩后的数据 } system(“pause”); return 0; }

## 五.总结

它用 edge breaker 算法去压缩面的信息，并产生 CornerTable，用平行四边形差分方式压缩顶点属性信息。

Draco 里面还有其他的压缩顶点属性值的算法，如kd-tree、差分等，详细见各种 PredictionScheme。

1､Draco 在当前的VR、AR生态下，基本上没有直接使用的价值，想用它必须理解原理并修改源码。

2､Draco 里面有比较好的mesh压缩方案，有利于游戏引擎公司基于该代码优化自己的模型设计。

3､Draco 所能压缩的只是3D模型文件中的一部分，而3D相关的资源大头（图片）还是一个老大难的问题

总的来说，Draco整体思路是将网格的连接信息和几何信息进行分别编码并进行存储。

其中，几何信息使用SequentialAttributeEncodersController/KdTreeAttributesEncoder进行编码。而Sequential内部会对数据进行量化、预测压缩、熵编码。其中熵编码采用了rANS算法。Draco进行了层层封装、科学地使用多态，使得代码层次清晰，可扩展性好，但也带来了一定的阅读障碍。采用的Edgebreaker算法压缩性能方面还有待提升，对float的编码采用动态建立熵编码可能会比较慢，在直播情景下还需要实验验证并改进。

优惠劵

竹以

关注

踩

觉得还不错?

一键收藏

知道了

Draco库简析

Draco库简析一.简介 Draco是谷歌Chrome 团队在2017年1月发布的一个Draco是用于压缩和解压缩3D几何网格和点云的库，旨在改善3D图形的存储和传输，大幅加速 3D 数据的编码、传输和解码。这个开源算法的首要应用对象是浏览器。但可以去探索 Draco 在其他场景的应用，比如说非网页端。目前，谷歌提供了它的两个版本： JavaScript 和 C++。 Draco 可以被用来压缩 mesh 和点云数据。它还支持压缩点（ compressing points），连接信息

复制链接

扫一扫

专栏目录

适用3dtiles转gltf b3dm的draco编译静态库

05-30

vs2017 gltf draco c++ x64 release for cesium

3D文件压缩库——Draco简析

【网格压缩测评】MeshQuan、MeshOpt、Draco - 知乎

【网格压缩测评】MeshQuan、MeshOpt、Draco - 知乎切换模式写文章登录/注册【网格压缩测评】MeshQuan、MeshOpt、DracoDeepKolos乐观自信目录介绍KHR_mesh_quantization和EXT_meshopt_compression用途、用法性能（压缩、加载、解析）可用（场景、范围）缺点猜想未来改进方向总结介绍GLTF的压缩，估计都知道Draco，因为适配GLTFLoader到小程序的原因，发现还有不少其他压缩扩展，比如KHR_mesh_quantization和EXT_meshopt_compressionKHR_mesh_quantizationQuantization也就是向量化，是把用浮点数表示的数据使用整形数据表示，方便压缩存储，但是会丢失精度。之前在tfjs的模型有见过类似的方法，gltf的网格数据都是使用浮点数储存，一个单精度浮点数占32位4byte，一个顶点3个数12byte，纹理坐标8byte，法线，12byte，正切空间16byte，一个顶点附带的信息数量就需要48byte，那么使用通过该扩展，使用SHORT来保存顶点坐标，纹理坐标4byte，使用BYTE存储法线坐标4byte, 正切空间4byte（为了不破坏标准都是4的倍数byte），一共20byte所以经过向量化之后的网格能有大概58.4%的压缩。EXT_meshopt_compression该扩展于r122进入three。其压缩的pipeline如下。其中第五步则是上面的向量化。KHR_DRACO_MESH_COMPRESSIONhttps://github.com/google/draco 进一步了解可以阅读大佬的分析，默认压缩参数比上面的都激进些由于wasm的支持和js的体积和worker数量限制问题，小程序下就不太合适了。js版decoder比three都要大用法KHR_mesh_quantization和EXT_meshopt_compression可以使用同一个工具gltfpack> npm i -g gltfpack

# gltfpack命令行工具是C项目构建出WASM执行的，目测未来会有更多wasm这类项目产出

# KHR的优化版的basis trancoder是使用assemblyscript编译成wasm

# 转成KHR_mesh_quantization

> gltfpack -i model.glb -o out.glb

# EXT_meshopt_compression只需加个-cc参数即可

> gltfpack -i model.glb -o out.glb -cc使用gltfpack的好处是向量化的参数是可以调整的（需要meshopt扩展），比如法线需要更高精度的话修改-vn即可，具体使用阅读gltfpack -h即可KHR_DRACO_MESH_COMPRESSION可以使用gltf-pipeline> npm i -g gltf-pipeline

> gltf-pipeline -i model.glb -o out.glb -d同样也可以调整draco的向量化参数性能（压缩、加载、解析）那么下来就需要对比其压缩网格的性能对比了使用的模型是来源于glTF-Sample-Models这里可以看到仅仅有顶点数据ReciprocatingSaw.glb则是draco是最好的，其实原因也很简单，Draco默认压缩参数比meshQuan激进得多，但是有动画的BrainStem.glb meshOpt是最好的。WaterBottle.glb是都差不太多，因为顶点数量有限，纹理占据大量主要体积。那么由于默认参数是不相同的，对比起来draco就有优势了，所以把其他需要相同压缩参数重新对比下，这次仅仅需要对比BrainStem和ReciprocatingSaw即可，这里把gltfpack参数向draco对齐> gltfpack -i model.glb -o out.glb -vp 11 -vt 10

> gltfpack -i model.glb -o out.glb -vp 11 -vt 10 -cc可以看到即便修改了参数，MeshQuan大小还是没有变，因为已经成为标准的了，向量化的参数已经是固定无法修改了，但是MeshOpt有些许提升。Decoder加载使用某个压缩方案，除了需要对比压缩大小，还得对比decoder的加载难易程度（web，小程序等环境下），还有DracoLoader十几KB还没算进去值得注意是MeshOpt wasm版本是包含了两个版本一个是基础版，一个使用SIMD版不过官方没有提供asm版本，需要手动通过binaryen/wasm2js转换下即可，或者使用我转换好的meshopt_decoder.asm.module.js在decoder层面上感觉是MeshOpt完胜解析时间对比这里使用模型是默认参数压缩后的，电源模式是高性能，CPU一直在最高频率。尝试五次求均值，均是wasm版本。其中MeshOpt是SIMD版本，Chrome 88可以看到MeshQuan和MeshOpt均比未压缩加载时间减少了不少，Draco则增加不少，如果考虑decoder的加载时间则需要看首次加载，3个扩展里只有Darco会有影响，因为只有Draco是第一次加载gltf需要从网络下载wasm，MeshOpt是序列化好存在字符串里，使用时只需unpack即可，无需网络请求。asm版的解析时间对比在可用性部分压缩前后效果对比按道理除了对比性能上面的指标，还得对比压缩后是否出问题了，但是这个并不容易指标化，还是得看设计师是否妥协了，但是为了直观对比，所以我编写了一个compressed-model-diff工具有3个对比模式和线框对比在线使用。可用（场景、范围）可用场景主要取决于Decoder加载难以程度和大小了可以看到Draco在小程序上面就比较难受了，而MeshQuan无需decoder所以可用性是最高的，MeshOpt只需使用asm版兼容小程序ios即可。所以如果需要兼容小程序平台，Draco就比较不太合适了，当然也可以对应平台加载对应的模型的方法，但是模型效果就需要对应平台单独微调了，还是全平台统一模型可维护性更高。所以这里单独补充MeshOpt asm版的decode性能但是有了奇怪的发现：第一次解析耗时很高，但是大概第3次接近未压缩的性能，第五次接近wasm的性能，这是为什么呢？是否说明一个潜在的优化方法呢？先看看火狐的这个第一个支持ASM的浏览器如何，是否有类似的情况出现？貌似在这个情况下火狐对js执行比chrome强不少，wasm反而没带来更好的效果，但是还是出现了类似的规律，是否说明decoder是需要一个预热，告诉浏览器decode的代码需要特殊优化？所以这个通过加载一个1.21kb的Triangle-meshopt.glb，5次，再加载测试模型，记录数据貌似莫得效果，估计是warm up的次数没够，Triangle-meshopt.glb，只有3个顶点，执行5次也就15个，量级没上去。从Web 3D是否需要WebAssembly?找到了答案因为chrome浏览器的v8引擎支持JIT: Just-in-Time compilation，所以js程序的执行性能接近wasm（对于Web 3D程序，性能热点的逻辑会在主循环中多次被执行。而v8会在多次执行后，确定热点代码，会将其优化为字节码；然后从下次执行开始，直接执行字节码）火狐下asm第一次加载耗时是未压缩的1.5 ~ 2.3倍chrome下asm第一次加载耗时是未压缩的3.08 ~ 4.4倍当然由于只是微信小程序IOS下，IPhone的CPU本身比较好，所以还能接受，如果能找到warm up方法，第1次加载耗时等于第5次的就更好了。缺点向量化毕竟是丢失精度的有损压缩方法，但是也正如KHR_mesh_quantization所介绍，是一个精度和大小的妥协 Vertex attributes are usually stored using FLOAT component type. However, this can result in excess precision and increased memory consumption and transmission size, as well as reduced rendering performance. KHR_mesh_quantization的缺点是向量化参数固定，无法修改，好处也是，无需额外decoder，而EXT_meshopt_compression则其升级版，可自定义向量化参数，比如法线精度要求高的时候可以增大容量KHR_draco_mesh_compression这个比较知名的扩展，在这次测评下虽然纯顶点的模型压缩比最高，但是相比之下，其decoder大小和decode性能均不突出。KHR_mesh_quantization和EXT_meshopt_compression都是固定转换，比如模型本身如果尺寸很小，其使用到的浮点数范围也很小，这时候丢失精度的情况就比较大了，解决办法除了增加存储的容量，更简单的其实是，放大模型，让顶点之间的距离变大，使用的时候再缩小即可。文本描述可能没有那么直观还是看动图吧。模型放大10倍后，不是同一个模型版本忽略颜色变化中间包包的差异基本可以忽略不计，但是下面还是有纹理偏移出现。猜想未来改进方向由上面的固定向量化导致模型处于小浮点数范围出现的误差问题可以推测下一步可以优化：动态向量化+偏移，目测可以进一步提供精度和压缩比，但是decoder的耗时会增加。比如把模型的BoundingBox.xyz最大值作为映射到0-1，再映射到整型/自定义XByte，当然模型里面的子mesh也可以如此，也可以xyz分别维护等等。当然只是想法，本文其实目的就是因为发现一个牛皮的扩展MeshOpt，但是想相对严谨去测试验证引入到项目可用性的，也是一个探索的过程。总结MeshOpt牛皮发布于 2021-03-26 23:29three.jsWebGL赞同 242 条评论分享喜欢收藏申请

压缩gltf/glb模型踩坑与解决 three.js DRACOLoader - 掘金

首页首页

沸点

课程

直播

活动

竞赛

商城

APP

插件搜索历史

清空

创作者中心

写文章发沸点写笔记写代码草稿箱创作灵感

会员

压缩gltf/glb模型踩坑与解决 three.js DRACOLoader

lgldl

VIP.5 如鱼得水

2022-03-08

2,870

前言

使用前端three.js加载3d模型过程中，往往会出现模型大小过大导致前端加载时间过长，降低用户体验。

本文所记录的是笔者在使用gltf-pipeline压缩3d模型中踩坑DRACOLoader与解决的一个过程。

所采用的three库版本为 ^0.138.2

解决方案与介绍

通过gltf-pipeline可以大幅度压缩gltf/glb模型文件。

并且有如下的作用

将 glTF 转换为 glb（和反向）

将缓冲区/纹理保存为嵌入或单独的文件

将 glTF 1.0 模型转换为 glTF 2.0（使用KHR_techniques_webgl和KHR_blend扩展）

应用Draco网格压缩

安装

npm install -g gltf-pipeline

或者

yarn global add gltf-pipeline

常用压缩命令

gltf-pipeline -i model.glb -o modelDraco.glb -d

使用 Draco 压缩网格 model.glb 文件，modelDraco.glb为压缩后输出文件名

gltf-pipeline -i model.glb -o modelDraco.glb -d -s

压缩并编写单独的缓冲区、着色器和纹理。

在three.js中使用Draco压缩网格后的文件

坑与解决过程

在多次百度之后写出的代码

let dracoLoader = new DRACOLoader();

dracoLoader.setDecoderPath("path");

dracoLoader.preload();

const loader = new GLTFLoader().setPath("path");

loader.setDRACOLoader(dracoLoader);

loader.load("modelName", (gltf) => {

scene.addObject(gltf.scene);

gltf = null;

});

在这里我遇到了一个大坑：

Uncaught SyntaxError: Unexpected token '<'

解决：

在问题过程排查中，发现网络请求是请求了模型数据的

后续发现bolb:xxx的请求不是写的应用层所发出的

之后通过阅读DRACOLoader.js的源码得

网络请求中bolb:xxx请求是由第250行URL.createObjectURL所创建的,创建该请求需要

draco_decoder.js

draco_wasm_wrapper.js

draco_decoder.wasm

并且请求的路径是使用setDecoderPath方法所设定

后续查阅资料得到

draco_decoder.js— Emscripten 编译的解码器，与任何现代浏览器兼容。

draco_decoder.wasm— WebAssembly 解码器，与较新的浏览器和设备兼容。

draco_wasm_wrapper.js— WASM 解码器的 JavaScript 包装器。

在node_modules安装的包中获取three版本对应的draco路径为

node_modules\three\examples\js\libs

将改文件夹复制到public文件夹下并在DRACOLoader.setDecoderPath时候设置该对应路径即可

最后的解决代码与自己的封装

import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader";

import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";

/**

* path:存放模型父路径

* modelName:模型名

* setCenter:是否居中

* scale:模型的缩放比设定

* position:模型的位置

* rotation:模型的局部旋转

function loadModuleByDRACOLoader(

path,

modelName,

setCenter,

scale,

position,

rotation

) {

let scaleVec3, positionVec3;

if (typeof scale == "number") {

scaleVec3 = new THREE.Vector3(scale, scale, scale);

} else {

scaleVec3 = new THREE.Vector3(scale.x, scale.y, scale.z);

}

if (typeof position == "number") {

positionVec3 = new THREE.Vector3(position, position, position);

} else {

positionVec3 = new THREE.Vector3(position.x, position.y, position.z);

}

let dracoLoader = new DRACOLoader();

dracoLoader.setDecoderPath("./moduler/draco/"); // 设置public下的解码路径，注意最后面的/

dracoLoader.setDecoderConfig({ type: "js" }); //使用兼容性强的draco_decoder.js解码器

dracoLoader.preload();

const loader = new GLTFLoader().setPath(path);

loader.setDRACOLoader(dracoLoader);

return new Promise((res, rj) => {

loader.load(modelName, (gltf) => {

if (setCenter) {

gltf.scene.traverse(function(child) {

if (setCenter && child.isMesh) {

child.geometry.center();

}

});

}

gltf.scene.scale.copy(scaleVec3);

gltf.scene.position.copy(positionVec3);

if (rotation) {

gltf.scene.rotation.copy(rotation);

}

scene.add(gltf.scene);

res(gltf.scene);

gltf = null;

});

}

调用

loadModuleByDRACOLoader('./moduler/', "grow4-processed.glb", false, 1, 0)

结语

因为遇到这个坑之后没有找到对应的解决方法，所以写了该文章作为记录也给遇到相同问题的开发者避坑。

还有大三求内推

lgldl

学生

文章

5.2k

阅读

粉丝目录收起

前言

解决方案与介绍

安装

常用压缩命令

在three.js中使用Draco压缩网格后的文件

坑与解决过程

解决：

最后的解决代码与自己的封装

结语

相关推荐还在封装 xxxForm，xxxTable 残害你的同事？试试这个工具 1.9k阅读 · 26点赞小册上新 | 前端工程体验优化实战 1.4k阅读 · 1点赞【深圳招聘】凹凸实验室 Taro 团队招人啦！ 1.2k阅读 · 6点赞Modal 管理体操二三事 (实践篇) 411阅读 · 10点赞前端监控sdk开发（五）白屏检测 82阅读 · 1点赞友情链接：

Robert Frost - American Writers 2

2011-中国发展报告

快穿之主神大人有点慌丨穿越丨科幻丨AI专辑

许你惜年时光全文免费阅读

大都市区空间结构与可持续交通

Obstetrics&Gynecology: PreTest Self-Assessment and Review

3D文件压缩库——Draco简析_draco_encoder-CSDN博客

3D文件压缩库——Draco简析

最新推荐文章于 2023-12-14 10:27:14 发布

夕阳叹

最新推荐文章于 2023-12-14 10:27:14 发布

阅读量1.5w

点赞数

分类专栏：

Android图形显示

文章标签：

压缩

模型

本文链接：https://blog.csdn.net/jxt1234and2010/article/details/53999155

版权

Android图形显示

专栏收录该内容

24 篇文章

63 订阅

订阅专栏

3D文件压缩库——Draco简析

今年1月份时，google发布了名为“Draco”的3D图形开源压缩库，下载了其代码来看了下，感觉虽然暂时用不到，但还是有前途的，故简单做下分析。

注：Draco 代码地址： https://github.com/google/draco

基本使用

编译

cmake . + make 编译源码，生成 draco_encoder 和 draco_decoder 两个可执行文件

编码/压缩

使用 draco_encoder 压缩 obj 或 ply 的文件：

./draco_encoder -i torusknot.obj

结果如下：

Encoder options:

Compression level = 5

Positions: Quantization = 14 bits

Texture coordinates: Quantization = 12 bits

Normals: Quantization = 10 bits

Encoded mesh saved to torusknot.obj.drc (3 ms to encode)

Encoded size = 2272 bytes

（1）Compression level：这个决定后续选用什么算法进行压缩，值越高，速度越慢，压缩效果越好。（2）Positions: Quantization = 14 bits：顶点属性值是由浮点转换为整数再编码的，14位表示用(1<<14)（即2的14次方）去乘浮点数，然后取整。

解码

./draco_decoder -i torusknot.obj.drc -o torusknot.obj

这里必须指定obj的输出文件，不然会解成ply格式，这样面的信息就没了。

原理

3D文件格式

一个3D模型文件，一般包含顶点、面、材质、动画等各种引擎渲染所需要的信息。 ply文件格式只包含顶点信息，而obj文件包含顶点信息和面的信息。这两者的联系如图所示：顶点信息就是该点的物体坐标、法线向量、纹理坐标等，如果绑定了骨骼，还有各块骨骼的权重。面的信息指怎么由顶点围成面，它是一系列顶点索引的集合。如 f1: 0,1,2 表示由 x0, x1, x2 三个点围成一个面。

但这两种格式都不满足3D项目的需求，我们所用的模型文件还需要材质信息，动画信息等，因此在项目中想用draco，必须将其改造一下。

流程与算法

这里只列obj文件格式的编码流程图：这里面采用的是如下文献的算法: http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf 它用 edge breaker 算法去压缩面的信息，并产生 CornerTable，用平行四边形差分方式压缩顶点属性信息。

Draco 里面还有其他的压缩顶点属性值的算法，如kd-tree、差分等，详细见各种 PredictionScheme，不多述。

Draco作用

1､Draco 在当前的VR、AR生态下，基本上没有直接使用的价值，想用它必须理解原理并修改源码。 2､Draco 里面有比较好的mesh压缩方案，有利于游戏引擎公司基于该代码优化自己的模型设计。 3､Draco 所能压缩的只是3D模型文件中的一部分，而3D相关的资源大头（图片）还是一个老大难的问题。

优惠劵

夕阳叹

关注

踩

觉得还不错?

一键收藏

知道了

3D文件压缩库——Draco简析

3D文件压缩库——Draco简析今年1月份时，google发布了名为“Draco”的3D图形开源压缩库，下载了其代码来看了下，感觉虽然暂时用不到，但还是有前途的，故简单做下分析。注：Draco 代码地址： https://github.com/google/draco基本使用编译cmake . + make 编译源码，生成 draco_encoder 和 draco_decoder 两个可执行文件

复制链接

扫一扫

专栏目录

3D图形开源压缩库Draco.zip

07-19

Draco 是一种库，用于压缩和解压缩 3D 几何网格（geometric mesh）和点云（point cloud）。换句话说，它显著缩小了 3D 图形文件的大小，同时对 3D 图形的观看者来说又根本不严重影响视觉效果。它还旨在改善 3D 图形的压缩和传输。来自谷歌 Chrome Media 团队的贾米森·布雷特勒（Jamieson Brettle）和法兰克·加利根（Frank Galligan）在解释 Draco 时说：“Draco 是为了提升压缩效率和速度而设计和研制的。代码支持压缩点、连接信息、纹理坐标、颜色信息、正常量以及与几何形状有关的任何其他一般属性。有了 Draco，使用 3D 图形的应用程序可以小巧得多，又不影响视觉逼真度。对于用户来说，这意味着现在应用程序下载起来更快了，浏览器中的 3D 图形加载起来更快了，现在只需要少量的带宽就可以传输虚拟现实和增强现实了，而且可以迅速呈现、画面极其逼真。”Draco 是作为 C 源代码发布的，可以用来压缩 3D 图形，另外还发布了处理编码数据的 C 和 Javascript 解码器。

标签：Draco

【window环境】已经编译的 draco-1.4.1.zip 对应最新版本 1.4.1

04-25

谷歌开源 draco window环境下已经编译好了，可以直接使用，如果想学linux编译，可以看我的csdn文章

5 条评论

您还未登录，请先

后发表或查看评论

Draco压缩算法使用

春夜喜雨的专栏

10-14

3453

关于Draco压缩算法：Draco是一个开源的Lib库，提供3D图形mesh和点云的压缩和解压。它的目标是提升3D图形的存储和传输效率。

Google 3D压缩项目Draco简析

JM-Nie的博客

08-08

5212

谷歌3D图形压缩库Draco项目简介

...

GLB/GLTF 模型压缩轻量化

谷歌开源 3D 数据压缩算法 Draco以及代码分析_draco压缩-CSDN博客

谷歌开源 3D 数据压缩算法 Draco以及代码分析

最新推荐文章于 2023-12-14 10:27:14 发布

coloriy

最新推荐文章于 2023-12-14 10:27:14 发布

阅读量1.1w

点赞数

分类专栏：

媒体格式

编解码

媒体格式

同时被 3 个专栏收录

49 篇文章

3 订阅

订阅专栏

编解码

36 篇文章

2 订阅

订阅专栏

3 篇文章

0 订阅

订阅专栏

Draco 由谷歌 Chrome 媒体团队设计，旨在大幅加速 3D 数据的编码、传输和解码。因为研发团队的 Chrome 背景，这个开源算法的首要应用对象是浏览器。但既然谷歌把它开源，现在全世界的开发者可以去探索 Draco 在其他场景的应用，比如说非网页端。目前，谷歌提供了它的两个版本： JavaScript 和 C++。

Draco 可以被用来压缩 mesh 和点云数据。它还支持压缩点（ compressing points），连接信息，纹理协调，颜色信息，法线（ normals）以及其他与几何相关的通用属性。下面是谷歌官方发布的 Draco Mesh 文件压缩率，可以看出，它大幅优于 ZIP。

图一：Draco 压缩率与 ZIP 之间的比较

注：第一行为未压缩数据

图二：Draco 编码/解码性能

谷歌宣称，若使用 Draco，含 3D 图像的应用，其文件大小能大幅缩小，并不在视觉保真度上做妥协。对于用户来说，这意味着 app 下载会更快，浏览器的 3D 图像载入得更快，VR 和 AR 画面的传输只需要占用原先一小部分的带宽、渲染得更快并且看起来画质清晰。

另外，在 Draco JavaScript 解码器支持下，传输 3D 图像的网页应用会变得非常地快；而该解码器可以和 3D 网页浏览器绑定起来。这意味着 Draco 普及之后，天朝网速拖后腿的广大群众都可以享受到在线看高清影视带来的满满幸福感。让所有连接网络的用户都能享受到高清视觉体验，正是 Draco 的使命之一。

Draco 的算法既支持有损模式，也支持无损。这给普通消费者带来的好处还不太明显——毕竟大多数人对分辨率并没有强迫症，有损压缩带来的轻微画质改变完全在承受范围之内。但对专业应用和科研应用的意义就很大了。这就好比 JPEG 之于 PNG。后者用于游戏和 VR 应用完全没有问题，降低的画质很难用肉眼察觉。但在科研点云数据中，任何信息都不能丢失。

http://betanews.com/2017/01/13/google-draco-3d-graphics-open-source-github/

Google releases 'Draco' 3D graphics open source compression library on GitHub

Google is a significant contributor to the open source community. This is notable, as the company is wildly successful and its products are used by many. It incorporates open source code in its offerings, and then contributes back too. The search giant's visibility lends credibility to open source ideology.

Today, Google announces yet another open source project. Called "Draco," it is a compression library designed for 3D graphics. The project can dramatically reduce the size of 3D graphic files without significant visual impact to the person viewing.

"The Chrome Media team has created Draco, an open source compression library to improve the storage and transmission of 3D graphics. Draco can be used to compress meshes and point-cloud data. It also supports compressing points, connectivity information, texture coordinates, color information, normals and any other generic attributes associated with geometry," says Jamieson Brettle and Frank Galligan, Chrome Media Team, Google.

Brettle and Galligan explain, "With Draco, applications using 3D graphics can be significantly smaller without compromising visual fidelity. For users this means apps can now be downloaded faster, 3D graphics in the browser can load quicker, and VR and AR scenes can now be transmitted with a fraction of the bandwidth, rendered quickly and look fantastic."

You can see Draco in action below. If you want to check out the code, you can view the open source project on GitHub here.

Draco encode过程代码分析 - 探究其数据编码方式

Introduction

Draco是谷歌在2017年1月发布的一个3D图形开源压缩库，提供了多种算法进行压缩和解压缩。对于encoder过程，Draco整体思路是将网格的连接信息和几何信息进行分别编码并进行存储。其中，连接信息使用了edgebreaker等算法进行了编码压缩，几何信息对数据进行量化、预测压缩、熵编码。其中熵编码采用了rANS算法。不过和原先预想的不同，Draco并未建立一张静态查询表，而是利用算法动态地生成。本文从encoder入口开始，一层一层分析其代码，试图弄清其数据编码方式。 github源码: https://github.com/google/draco

encoder 过程

encode 过程入口

…/tools/draco_encoder.cc: int main()

int main(int argc, char **argv) {

Options options;

const int argc_check = argc - 1;

for (int i = 1; i < argc; ++i) {

if (!strcmp("-h", argv[i]) || !strcmp("-?", argv[i])) {

Usage();

return 0;

} else if (!strcmp("-i", argv[i]) && i < argc_check) {

options.input = argv[++i];

} else if (!strcmp("-o", argv[i]) && i < argc_check) {

options.output = argv[++i];

} else if (!strcmp("-point_cloud", argv[i])) {

options.is_point_cloud = true;

} else if (!strcmp("-qp", argv[i]) && i < argc_check) {

options.pos_quantization_bits = StringToInt(argv[++i]);

if (options.pos_quantization_bits > 31) {

printf(

"Error: The maximum number of quantization bits for the position "

"attribute is 31.\n");

return -1;

}

} else if (!strcmp("-qt", argv[i]) && i < argc_check) {

options.tex_coords_quantization_bits = StringToInt(argv[++i]);

if (options.tex_coords_quantization_bits > 31) {

printf(

"Error: The maximum number of quantization bits for the texture "

"coordinate attribute is 31.\n");

return -1;

}

} else if (!strcmp("-qn", argv[i]) && i < argc_check) {

options.normals_quantization_bits = StringToInt(argv[++i]);

if (options.normals_quantization_bits > 31) {

printf(

"Error: The maximum number of quantization bits for the normal "

"attribute is 31.\n");

return -1;

}

} else if (!strcmp("-cl", argv[i]) && i < argc_check) {

options.compression_level = StringToInt(argv[++i]);

}

if (argc < 3 || options.input.empty()) {

Usage();

return -1;

}

std::unique_ptr pc;

draco::Mesh *mesh = nullptr;

if (!options.is_point_cloud) {

std::unique_ptr in_mesh =

draco::ReadMeshFromFile(options.input);

if (!in_mesh) {

printf("Failed loading the input mesh.\n");

return -1;

}

mesh = in_mesh.get();

pc = std::move(in_mesh);

} else {

pc = draco::ReadPointCloudFromFile(options.input);

if (!pc) {

printf("Failed loading the input point cloud.\n");

return -1;

}

// Setup encoder options.

draco::EncoderOptions encoder_options = draco::CreateDefaultEncoderOptions();

if (options.pos_quantization_bits > 0) {

draco::SetNamedAttributeQuantization(&encoder_options, *pc.get(),

draco::GeometryAttribute::POSITION,

options.pos_quantization_bits);

}

if (options.tex_coords_quantization_bits > 0) {

draco::SetNamedAttributeQuantization(&encoder_options, *pc.get(),

draco::GeometryAttribute::TEX_COORD,

options.tex_coords_quantization_bits);

}

if (options.normals_quantization_bits > 0) {

draco::SetNamedAttributeQuantization(&encoder_options, *pc.get(),

draco::GeometryAttribute::NORMAL,

options.normals_quantization_bits);

}

// Convert compression level to speed (that 0 = slowest, 10 = fastest).

const int speed = 10 - options.compression_level;

draco::SetSpeedOptions(&encoder_options, speed, speed);

if (options.output.empty()) {

// Create a default output file by attaching .drc to the input file name.

options.output = options.input + ".drc";

}

PrintOptions(*pc.get(), options);

int ret = -1;

if (mesh && mesh->num_faces() > 0)

ret = EncodeMeshToFile(*mesh, encoder_options, options.output);

else

ret = EncodePointCloudToFile(*pc.get(), encoder_options, options.output);

if (ret != -1 && options.compression_level < 10) {

printf(

"For better compression, increase the compression level '-cl' (up to "

"10).\n\n");

}

return ret;

}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109

这一部分前大半都是在处理命令，核心代码就是最后两行：

if (mesh && mesh->num_faces() > 0)

ret = EncodeMeshToFile(*mesh, encoder_options, options.output);

else

ret = EncodePointCloudToFile(*pc.get(), encoder_options, options.output);

1234

这里先做判断，判断数据中是否有多个面:

如果有面，则进行Mesh to File的过程若不存在面，则只进行PointCloud to File的过程

其中，两个函数都会一个bool变量，来表示是否成功 > PointCloud是n维空间中的点的集合，PointCloud的相关信息在 …/point_cloud/point_cloud.h 中，内容较多，暂不贴出而Mesh是PointCloud的继承类，Mesh只是比PointCloud多了Face数据: …/mesh/mesh.h

class Mesh : public PointCloud {

public:

typedef std::array Face;

Mesh();

void AddFace(const Face &face) { faces_.push_back(face); }

void SetFace(FaceIndex face_id, const Face &face) {

if (face_id >= faces_.size()) {

faces_.resize(face_id.value() + 1, Face());

}

faces_[face_id] = face;

}

1234567891011

MeshToFile

接下来分析MeshToFile过程

int EncodeMeshToFile(const draco::Mesh &mesh,

const draco::EncoderOptions &options,

const std::string &file) {

draco::CycleTimer timer;

// Encode the geometry.

draco::EncoderBuffer buffer;

timer.Start();

if (!draco::EncodeMeshToBuffer(mesh, options, &buffer)) {

printf("Failed to encode the mesh.\n");

return -1;

}

timer.Stop();

// Save the encoded geometry into a file.

std::ofstream out_file(file, std::ios::binary);

if (!out_file) {

printf("Failed to create the output file.\n");

return -1;

}

out_file.write(buffer.data(), buffer.size());

printf("Encoded mesh saved to %s (%" PRId64 " ms to encode)\n", file.c_str(),

timer.GetInMs());

printf("\nEncoded size = %zu bytes\n\n", buffer.size());

return 0;

}

123456789101112131415161718192021222324

这里可以分为两步：

调用 draco::EncodeMeshToBuffer 将 Mesh encode 并存入buffer中将buffer内容调用系统i/o写入file中

这里draco::EncodeMeshToBuffer的前两个参数是输入，第三个参数是输出，即buffer

draco::EncodeMeshToBuffer

这个函数的功能是根据option选择相应的encoder并进行编码，将结果存入buffer中先来看下整个函数: …/compression/encode.cc

bool EncodeMeshToBuffer(const Mesh &m, const EncoderOptions &options,

EncoderBuffer *out_buffer) {

std::unique_ptr encoder;

// Select the encoding method only based on the provided options.

int encoding_method = options.GetGlobalInt("encoding_method", -1);

if (encoding_method == -1) {

// For now select the edgebreaker for all options expect of speed 10

if (options.GetSpeed() == 10) {

encoding_method = MESH_SEQUENTIAL_ENCODING;

} else {

encoding_method = MESH_EDGEBREAKER_ENCODING;

}

if (encoding_method == MESH_EDGEBREAKER_ENCODING) {

encoder = std::unique_ptr(new MeshEdgeBreakerEncoder());

} else {

encoder = std::unique_ptr(new MeshSequentialEncoder());

}

if (encoder)

encoder->SetMesh(m);

return EncodeGeometryToBuffer(encoder.get(), options, out_buffer);

}

12345678910111213141516171819202122

这个函数前面一部分都在处理option，根据option选择哪种encoder:

Sequential encodingEdgebreaker encoding

if (encoding_method == MESH_EDGEBREAKER_ENCODING) {

encoder = std::unique_ptr(new MeshEdgeBreakerEncoder());

} else {

encoder = std::unique_ptr(new MeshSequentialEncoder());

}

12345

然后利用encoder->SetMesh(const Mesh &m)来对encoder内部的一些数据进行了初始化 > 就是把Mesh和CloudPoint信息在Encoder里也存了一下 …/compression/mesh/mesh_encoder.cc

void MeshEncoder::SetMesh(const Mesh &m) {

mesh_ = &m;

SetPointCloud(m);

}

1234

…/compression/point_cloud/point_cloud_encoder.cc

void PointCloudEncoder::SetPointCloud(const PointCloud &pc) {

point_cloud_ = &pc;

}

123

（这里因为Mesh是PointCloud的继承，所以直接把Mesh数据传进SetPointCloud函数了）

最后进行了几何信息的编码，这是这个函数的核心代码，之前都没干什么正事，这里进行了真正的编码

return EncodeGeometryToBuffer(encoder.get(), options, out_buffer);

这个函数从encoder中拿到encoder的指针，进行相应操作，然后将结果写入buffer中

EncodeGeometryToBuffer

…/compression/encode.cc

bool EncodeGeometryToBuffer(PointCloudEncoder *encoder,

const EncoderOptions &options,

EncoderBuffer *out_buffer) {

if (!encoder)

return false;

if (!EncodeHeader(*encoder, out_buffer))

return false;

if (!encoder->Encode(options, out_buffer))

return false;

return true;

}

1234567891011

然后用encoder->Encode根据option对数据进行编码，写入buffer

encoder->Encode

在这个函数中，具体对encoder data、geometry data、point atrributes进行了编码 …/compression/point_cloud/point_cloud_encoder.cc

bool PointCloudEncoder::Encode(const EncoderOptions &options,

EncoderBuffer *out_buffer) {

options_ = &options;

buffer_ = out_buffer;

// Cleanup from previous runs.

attributes_encoders_.clear();

attribute_to_encoder_map_.clear();

attributes_encoder_ids_order_.clear();

if (!point_cloud_)

return false;

if (!InitializeEncoder())

return false;

if (!EncodeEncoderData())

return false;

if (!EncodeGeometryData())

return false;

if (!EncodePointAttributes())

return false;

return true;

}

12345678910111213141516171819202122

这里InitializeEncoder的功能是 > Can be implemented by derived classes to perform any custom initialization of the encoder. Called in the Encode() method.

EncodeEncoderData的功能是 > Should be used to encode any encoder-specific data.

不过这两个都是预留接口，设置了虚函数但没有实现，直接返回true

EncoderGeometryData()会把mesh 的 connectivity进行编码并存入buffer，根据encoder的不同，编码connectivity的方式会分为sequential encoding 和 edgebreaker encoding。这里暂时先暂停对connectivity编码过程的进一步探究，先研究顶点坐标等信息是如何压缩编码的

EncodePointAttributes

这里point attributes 的意思是 > point specific data about each attribute. In general, multiple points stored in a point cloud can share the same attribute value and this class provides the necessary mapping between point ids and attribute value ids.

是顶点坐标一类的信息

…/compression/point_cloud/point_cloud_encoder.cc

bool PointCloudEncoder::EncodePointAttributes() {

if (!GenerateAttributesEncoders())

return false;

// Encode the number of attribute encoders.

buffer_->Encode(static_cast(attributes_encoders_.size()));

// Initialize all the encoders (this is used for example to init attribute

// dependencies, no data is encoded in this step).

for (auto &att_enc : attributes_encoders_) {

if (!att_enc->Initialize(this, point_cloud_))

return false;

}

// Rearrange attributes to respect dependencies between individual attributes.

if (!RearrangeAttributesEncoders())

return false;

// Encode any data that is necessary to create the corresponding attribute

// decoder.

for (int att_encoder_id : attributes_encoder_ids_order_) {

if (!EncodeAttributesEncoderIdentifier(att_encoder_id))

return false;

}

// Also encode any attribute encoder data (such as the info about encoded

// attributes).

for (int att_encoder_id : attributes_encoder_ids_order_) {

if (!attributes_encoders_[att_encoder_id]->EncodeAttributesEncoderData(

buffer_))

return false;

}

// Lastly encode all the attributes using the provided attribute encoders.

if (!EncodeAllAttributes())

return false;

return true;

}

1234567891011121314151617181920212223242526272829303132333435363738

Initialize() 初始化值传递将值传入AttributesEncoder中

RearrangeAttributesEncoders() (有待仔细求证) 这里主要考虑了不止有顶点信息这一种attribute，可能还有color等attribute，而这里的作用就是把这些attribute的encoder排好序。暂不继续探究，继续探究float数据是如何储存的

EncodeAttributesEncoderIdentifier是一个预留接口，无实质内容，直接返回true

然后用每一种attribute encoder，对attribute的一些基本信息进行编码和记录。基本信息包括：attribute number、attribute type、data type、components count等

最后用EncodeAllAttributes对数据进行编码

bool PointCloudEncoder::EncodeAllAttributes() {

for (int att_encoder_id : attributes_encoder_ids_order_) {

if (!attributes_encoders_[att_encoder_id]->EncodeAttributes(buffer_))

return false;

}

return true;

}

1234567

EncodeAttributes()是多态的，框架目前实现了SequentialAttributeEncodersController和KdTreeAttributesEncoder两种encoder，我们选前者进行讨论

SequentialAttributeEncodersController

…/compression/attributes/sequential_attribute_encoders_controller.cc

bool SequentialAttributeEncodersController::EncodeAttributes(

EncoderBuffer *buffer) {

if (!sequencer_ || !sequencer_->GenerateSequence(&point_ids_))

return false;

for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {

if (!sequential_encoders_[i]->Encode(point_ids_, buffer))

return false;

}

return true;

}

12345678910

(这里不明白哪来那么多sequential_encoders…还有哪些sequential_encoders)

继续深一层 SequentialAttributeEncoder::Encode

SequentialAttributeEncodersController

…/compression/attributes/sequential_attribute_encoders_encoder.cc

bool SequentialAttributeEncoder::Encode(

const std::vector &point_ids, EncoderBuffer *out_buffer) {

if (!EncodeValues(point_ids, out_buffer))

return false;

if (is_parent_encoder_ && IsLossyEncoder()) {

if (!PrepareLossyAttributeData())

return false;

}

return true;

}

12345678910

这里又是一层封装而后面的is_parent_encoder是与预测有关，IsLossyEncoder是拓展接口，未实现，直接返回false

深入EncodeValues

EncodeValues

…/compression/attributes/sequential_attribute_encoder.cc

bool SequentialAttributeEncoder::EncodeValues(

const std::vector &point_ids, EncoderBuffer *out_buffer) {

const int entry_size = attribute_->byte_stride();

const std::unique_ptr value_data_ptr(new uint8_t[entry_size]);

uint8_t *const value_data = value_data_ptr.get();

// Encode all attribute values in their native raw format.

for (uint32_t i = 0; i < point_ids.size(); ++i) {

const AttributeValueIndex entry_id = attribute_->mapped_index(point_ids[i]);

attribute_->GetValue(entry_id, value_data);

out_buffer->Encode(value_data, entry_size);

}

return true;

}

12345678910111213

该函数根据index将atrribute的值取出，然后存入buffer > 这里out_buffer->Encode是直接将内容插入buffer末尾，并未进行压缩或编码，可能之后谷歌出2.0还会对这个地方做一些文章吧 …/core/encoder_buffer.h

bool Encode(const void *data, size_t data_size) {

if (bit_encoder_active())

return false;

const uint8_t *src_data = reinterpret_cast(data);

buffer_.insert(buffer_.end(), src_data, src_data + data_size);

return true;

}

1234567

这个地方看起来很纳闷，怎么会没有进行任何压缩呢？但SequentialAttributeEncoder这个类是这样描述的： > A base class for encoding attribute values of a single attribute using a given sequence of point ids. The default implementation encodes all attribute values directly to the buffer but derived classes can perform any custom encoding (such as quantization) by overriding the EncodeValues() method.

查看SequentialAttributeEncoder类就可以发现，它有一些继承那么到底在哪里决定具体的继承呢？通过搜索和查找，我们发现在这个地方决定了具体是哪个继承类刚才在PointCloudEncoder::EncodePointAttributes的分析中，没有对Initialize进行仔细分析 …/compression/point_cloud/point_cloud_encoder.cc

// Initialize all the encoders (this is used for example to init attribute

// dependencies, no data is encoded in this step).

for (auto &att_enc : attributes_encoders_) {

if (!att_enc->Initialize(this, point_cloud_))

return false;

}

123456

追踪入Initialize …/compression/attribute/attribute_encoder.cc

bool AttributesEncoder::Initialize(PointCloudEncoder *encoder,

const PointCloud *pc) {

point_cloud_encoder_ = encoder;

point_cloud_ = pc;

return true;

}

123456

原先以为这就是初始化，仅仅做了一些初始化值传递，但事实上这是一个虚函数 …/compression/attributes/sequential/attribute_encoders_controller.cc

bool SequentialAttributeEncodersController::Initialize(

PointCloudEncoder *encoder, const PointCloud *pc) {

if (!AttributesEncoder::Initialize(encoder, pc))

return false;

if (!CreateSequentialEncoders())

return false;

// Initialize all value encoders.

for (int i = 0; i < num_attributes(); ++i) {

const int32_t att_id = GetAttributeId(i);

if (!sequential_encoders_[i]->Initialize(encoder, att_id))

return false;

}

return true;

}

1234567891011121314

而其中的CreateSequentialEncoders()干了这样一件事：它用另一个函数CreateSequentialEncoder为每一个attribute建立了一个encoder …/compression/attributes/sequential/attribute_encoders_controller.cc

equentialAttributeEncodersController::CreateSequentialEncoder(int i) {

const int32_t att_id = GetAttributeId(i);

const PointAttribute *const att = encoder()->point_cloud()->attribute(att_id);

switch (att->data_type()) {

case DT_UINT8:

case DT_INT8:

case DT_UINT16:

case DT_INT16:

case DT_UINT32:

case DT_INT32:

return std::unique_ptr(

new SequentialIntegerAttributeEncoder());

case DT_FLOAT32:

if (encoder()->options()->GetAttributeInt(att_id, "quantization_bits",

-1) > 0) {

if (att->attribute_type() == GeometryAttribute::NORMAL) {

// We currently only support normals with float coordinates

// and must be quantized.

return std::unique_ptr(

new SequentialNormalAttributeEncoder());

} else {

return std::unique_ptr(

new SequentialQuantizationAttributeEncoder());

}

break;

default:

break;

}

// Return the default attribute encoder.

return std::unique_ptr(

new SequentialAttributeEncoder());

}

12345678910111213141516171819202122232425262728293031323334

而CreateSequentialEncoder则根据data type建立对应的encoder，目前框架内支持的只有三种：SequentialIntegerAttributeEncoder, SequentialNormalAttributeEncoder, SequentialQuantizationAttributeEncoder

我们可以继续分析EncodeValues了，因为SequentialNormalAttributeEncoder, SequentialQuantizationAttributeEncoder是SequentialIntegerAttributeEncoder的继承类，我们来分析SequentialIntegerAttributeEncoder

SequentialIntegerAttributeEncoder

…/compression/attributes/sequential_integer_attribute_encoder.cc

bool SequentialIntegerAttributeEncoder::EncodeValues(

const std::vector &point_ids, EncoderBuffer *out_buffer) {

// Initialize general quantization data.

const PointAttribute *const attrib = attribute();

if (attrib->size() == 0)

return true;

int8_t prediction_scheme_method = PREDICTION_NONE;

if (prediction_scheme_)

prediction_scheme_method =

static_cast(prediction_scheme_->GetPredictionMethod());

out_buffer->Encode(prediction_scheme_method);

if (prediction_scheme_) {

out_buffer->Encode(

static_cast(prediction_scheme_->GetTransformType()));

}

if (!PrepareValues(point_ids))

return false;

const int num_components = values_.size() / point_ids.size();

// All integer values are initialized. Process them using the prediction

// scheme if we have one.

if (prediction_scheme_) {

prediction_scheme_->Encode(values_.data(), &values_[0], values_.size(),

num_components, point_ids.data());

}

if (prediction_scheme_ == nullptr ||

!prediction_scheme_->AreCorrectionsPositive()) {

ConvertSignedIntsToSymbols(values_.data(), values_.size(),

reinterpret_cast(values_.data()));

}

if (encoder() == nullptr || encoder()->options()->GetGlobalBool(

"use_built_in_attribute_compression", true)) {

out_buffer->Encode(static_cast(1));

if (!EncodeSymbols(reinterpret_cast(values_.data()),

point_ids.size() * num_components, num_components,

out_buffer)) {

return false;

}

} else {

// No compression. Just store the raw integer values, using the number of

// bytes as needed.

// To compute the maximum bit-length, first OR all values.

uint32_t masked_value = 0;

for (uint32_t i = 0; i < values_.size(); ++i) {

masked_value |= values_[i];

}

// Compute the msb of the ORed value.

int value_msb_pos = 0;

if (masked_value != 0) {

value_msb_pos = bits::MostSignificantBit(masked_value);

}

const int num_bytes = 1 + value_msb_pos / 8;

out_buffer->Encode(static_cast(0));

out_buffer->Encode(static_cast(num_bytes));

if (num_bytes == sizeof(decltype(values_)::value_type)) {

out_buffer->Encode(values_.data(), sizeof(int32_t) * values_.size());

} else {

for (uint32_t i = 0; i < values_.size(); ++i) {

out_buffer->Encode(&values_[i], num_bytes);

}

if (prediction_scheme_) {

prediction_scheme_->EncodePredictionData(out_buffer);

}

return true;

}

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374

这里主要做了三件事

预处理数据利用预测压缩数据将int编码为symbol 并利用rANS熵编码算法进行压缩编码

预处理 - PrepareValues 进行一些格式转换等处理，此外，在SequentialQuantizationAttributeEncoder和SequentialNormalAttributeEncoder中，会进行量化

利用预测压缩数据

prediction_scheme_->Encode(values_.data(), &values_[0], values_.size(),

num_components, point_ids.data());

目前框架内包含了parallelogram, multi parallelogram, tex coords三种预测方法

进行压缩编码

EncodeSymbols(reinterpret_cast(values_.data()),

point_ids.size() * num_components, num_components,

out_buffer)

123

EncodeSymbols

EncodeSymbols内部是先对待处理数据进行了测算，根据测算结果决定利用哪种熵编码技术

…/core/symbol_encoding.cc

bool EncodeSymbols(const uint32_t *symbols, int num_values, int num_components,

EncoderBuffer *target_buffer) {

if (num_values < 0)

return false;

if (num_values == 0)

return true;

if (num_components <= 0)

num_components = 1;

std::vector bit_lengths;

uint32_t max_value;

ComputeBitLengths(symbols, num_values, num_components, &bit_lengths,

&max_value);

// Compute the total bit length used by all values. This will be used for

// computing a heuristic that chooses the optimal entropy encoding scheme.

uint64_t total_bit_length = 0;

for (size_t i = 0; i < bit_lengths.size(); ++i) {

total_bit_length += bit_lengths[i];

}

const int64_t num_component_values = num_values / num_components;

// The average number of bits necessary for encoding a single entry value.

const int64_t average_bit_length =

static_cast(ceil(static_cast(total_bit_length) /

static_cast(num_component_values)));

// The estimated average number of bits necessary for encoding a single

// bit-length tag.

int64_t average_bits_per_tag = static_cast(

ceil(static_cast(bits::MostSignificantBit(average_bit_length)) /

static_cast(num_components)));

if (average_bits_per_tag <= 0)

average_bits_per_tag = 1;

// Estimate the number of bits needed for encoding the values using the tagged

// scheme. 32 * 8 is the overhead for encoding the entropy encoding table.

const int64_t tagged_scheme_total_bits =

num_component_values *

(num_components * average_bit_length + average_bits_per_tag) +

32 * 8;

// Estimate the number of bits needed by the "raw" scheme. In this case,

// max_value * 8 is the overhead of the entropy table.

const int64_t raw_scheme_total_bits =

num_values * average_bit_length + max_value * 8;

// The maximum bit length of a single entry value that we can encode using

// the raw scheme.

const int max_value_bit_length = bits::MostSignificantBit(max_value) + 1;

if (tagged_scheme_total_bits < raw_scheme_total_bits ||

max_value_bit_length > kMaxRawEncodingBitLength) {

// Use the tagged scheme.

target_buffer->Encode(static_cast(0));

return EncodeTaggedSymbols(

symbols, num_values, num_components, bit_lengths, target_buffer);

}

// Else use the raw scheme.

target_buffer->Encode(static_cast(1));

return EncodeRawSymbols(symbols, num_values, &max_value,

target_buffer);

}

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162

前面大部分都在算各种特征，来决定用哪种scheme

// The maximum bit length of a single entry value that we can encode using

// the raw scheme.

const int max_value_bit_length = bits::MostSignificantBit(max_value) + 1;

if (tagged_scheme_total_bits < raw_scheme_total_bits ||

max_value_bit_length > kMaxRawEncodingBitLength) {

// Use the tagged scheme.

target_buffer->Encode(static_cast(0));

return EncodeTaggedSymbols(

symbols, num_values, num_components, bit_lengths, target_buffer);

}

// Else use the raw scheme.

target_buffer->Encode(static_cast(1));

return EncodeRawSymbols(symbols, num_values, &max_value,

target_buffer);

123456789101112131415

有TaggedSymbols和RawSymbols两种，但是都用了RAnsSymbolEncoder 其中，rANS(Asymmetric Numeral Systems)是一种熵编码，框架参考了http://arxiv.org/abs/1311.2540v2实现

小结

总的来说，Draco整体思路是将网格的连接信息和几何信息进行分别编码并进行存储。其中，几何信息使用SequentialAttributeEncodersController/KdTreeAttributesEncoder进行编码。而Sequential内部会对数据进行量化、预测压缩、熵编码。其中熵编码采用了rANS算法。 Draco进行了层层封装、科学地使用多态，使得代码层次清晰，可扩展性好，但也带来了一定的阅读障碍。采用的Edgebreaker算法压缩性能方面还有待提升，对float的编码采用动态建立熵编码可能会比较慢，在直播情景下还需要实验验证并改进。

@Woolsey

2017/3/19

优惠劵

coloriy

关注

踩

觉得还不错?

一键收藏

知道了

谷歌开源 3D 数据压缩算法 Draco以及代码分析

复制链接

扫一扫

专栏目录

3D图形开源压缩库Draco.zip

07-19

标签：Draco

cpp-Draco是Google开源的3D图形压缩

08-16

Draco是Google开源的3D 图形压缩

1 条评论

您还未登录，请先

后发表或查看评论

3D文件压缩库——Draco简析

既然青春留不住，还是做个大叔好!

06-25

1683

此文转自：https://blog.csdn.net/jxt1234and2010/article/details/53999155

3D文件压缩库——Draco简析

今年1月份时，google发布了名为“Draco”的3D图形开源压缩库，下载了其代码来看了下，感觉虽然暂时用不到，但还是有前途的，故简单做下分析。

注：Draco 代码地址：

https://github.com/google/draco

基本使用

编译

cmake . + make 编译源码，生成 draco_encoder 和 draco

GLB/GLTF 模型压缩轻量化

ygtu2018的博客

12-14

1018

Google 3D压缩项目Draco简析

JM-Nie的博客

08-08

5212

谷歌3D图形压缩库Draco项目简介

...

Draco压缩算法

jadesl的专栏

04-19

2135

Draco压缩算法详解

Draco压缩算法使用

Draco - glTF模型压缩利器

新缸中之脑

07-06

3391

Draco 是用于网格压缩的 glTF 扩展以及由 Google 开发的开源库，用于压缩和解压缩 3D 网格以显着减小 3D 内容的大小。它压缩顶点位置、法线、颜色、纹理坐标和任何其他通用顶点属性，从而提高在网络上传输 3D 内容的效率和速度。

这意味着更小的文件大小和更快的流式传输，尤其是在 3D Tiles 的情况下，当新的图块出现或需要新的细节级别时，它经常流式传输新的 glTF 模型。我们一直在与 Khronos 和 Google 合作使 Draco 成为 glTF 扩展，你现在可以在 Ces

Cesium开发： Draco模型压缩

PHP代码的博客

02-08

459

Draco 由谷歌 Chrome 媒体团队设计，旨在大幅加速 3D 数据的编码、传输和解码

Draco使用笔记(1)——图形解压缩

人生海海山山而川

05-18

2365

详细论述了使用Draco进行图形解压缩的过程。

使用Draco压缩GLTF模型

GIS小虫的博客

01-17

866

draco：Draco是用于压缩和解压缩3D几何网格和点云的库。旨在改善3D图形的存储和传输

02-26

消息

版本1.4.1发行

现在建议使用版本化的gstatic.com WASM和Javascript解码器。要使用v1.4.1，请使用以下URL：

将*替换为要加载的文件。例如

这适用于v1.3.6和v1.4.0发行版，并将与将来的Draco发行版一起使用。

Bug修复

1.4.0版发行

WASM和JavaScript解码器是从静态URL托管的。

建议始终从此URL提取Draco WASM和JavaScript解码器：

将*替换为要加载的文件。例如

随着更多站点开始使用静态URL，用户将受益于将Draco解码器缓存在缓存中

更改了npm模块以使用WASM，从而使性能提高了约200％。

将Emscripten更新为2.0。

这将导致Draco编解码器模块返回一个Promise，而不是直接返回该模块。

请查看有关如何处理承诺的示例代码。

将NORMAL

draco编译后exe 3D压缩

01-10

DracoUnity:Draco 3D数据压缩Unity软件包

05-05

Draco 3D数据压缩Unity软件包

Unity软件包，它将集成到Unity中。

支持以下构建目标

WebGL

iOS（arm64和armv7a）

Android（x86，arm64和armv7a）

Windows（64位和32位）

通用Windows平台（x64，x86，ARM，ARM64）

macOS（Apple Silicon和Intel）

Linux（64位和32位）

正在安装

最简单的安装方法是下载并打开

它运行一个脚本，该脚本通过来安装Draco 3D数据压缩Unity软件包。之后，它会在“程序包管理器”中列出，并可从那里进行更新。

故障排除-缺少代码签名

此程序包中使用的二进制库没有代码签名。出于这个原因，特别是macOS不允许您加载ktx_unity.bundle （请参阅）。

这是使其在macOS上运行的步骤

首次使用DracoUnity打开项目

DRACO:相关数据的数据缩减算法-matlab开发

05-30

3D文件压缩库——Draco简析 - 刘世涛6192 - 博客园

会员

周边

新闻

博问

AI培训

云市场

所有博客

当前博客

我的博客

我的园子

账号设置

简洁模式 ...

退出登录

刘世涛619247

博客园

首页

新随笔

联系 ::

管理

公告

3D文件压缩库——Draco简析

今年1月份时，google发布了名为“Draco”的3D图形开源压缩库，下载了其代码来看了下，感觉虽然暂时用不到，但还是有前途的，故简单做下分析。

注：Draco 代码地址： https://github.com/google/draco

基本使用

编译

cmake . + make 编译源码，生成 draco_encoder 和 draco_decoder 两个可执行文件

编码/压缩

使用 draco_encoder 压缩 obj 或 ply 的文件：

./draco_encoder -i torusknot.obj

结果如下：

Encoder options:

Compression level = 5

Positions: Quantization = 14 bits

Texture coordinates: Quantization = 12 bits

Normals: Quantization = 10 bits

Encoded mesh saved to torusknot.obj.drc (3 ms to encode)

Encoded size = 2272 bytes

1）Compression level：这个决定后续选用什么算法进行压缩，值越高，速度越慢，压缩效果越好。（2）Positions: Quantization = 14 bits：顶点属性值是由浮点转换为整数再编码的，14位表示用(1<<14)（即2的14次方）去乘浮点数，然后取整。

解码

./draco_decoder -i torusknot.obj.drc -o torusknot.obj

这里必须指定obj的输出文件，不然会解成ply格式，这样面的信息就没了。

原理

3D文件格式

但这两种格式都不满足3D项目的需求，我们所用的模型文件还需要材质信息，动画信息等，因此在项目中想用draco，必须将其改造一下。

流程与算法

Draco 里面还有其他的压缩顶点属性值的算法，如kd-tree、差分等，详细见各种 PredictionScheme，不多述。

Draco作用

posted on

2018-03-16 13:41

刘世涛6192

阅读(2769)

编辑

会员力量，点亮园子希望

刷新页面返回顶部

博客园

Draco使用笔记(1)——图形解压缩-腾讯云开发者社区-腾讯云

o使用笔记(1)——图形解压缩-腾讯云开发者社区-腾讯云charlee44Draco使用笔记(1)——图形解压缩关注作者腾讯云开发者社区文档建议反馈控制台首页学习活动专区工具TVP最新优惠活动文章/答案/技术大牛搜索搜索关闭发布登录/注册首页学习活动专区工具TVP最新优惠活动返回腾讯云官网charlee44首页学习活动专区工具TVP最新优惠活动返回腾讯云官网社区首页 >专栏 >Draco使用笔记(1)——图形解压缩Draco使用笔记(1)——图形解压缩charlee44关注发布于 2022-05-19 12:51:314220发布于 2022-05-19 12:51:31举报文章被收录于专栏：代码编写世界代码编写世界目录1. 概述2. 详论2.1. 工具2.2. 代码1. 概述Draco是Google开发的图形压缩库，用于压缩和解压缩3D几何网格（geometric mesh）和点云（point cloud）。Draco还可以直接对obj或者ply格式的三维数据进行压缩和解压缩，甚至编译成wasm在浏览器端对glTF压缩和解压缩。2. 详论2.1. 工具Draco编译完成后直接提供了压缩和解压缩的工具draco_decoder.exe和draco_encoder.exe。通过命令行，我们对某个已经压缩好的文件进行解压缩：draco_decoder -i "D:/1.bin" -o "D:/1.ply"复制2.2. 代码如果需要用代码的方式实现，可以参考draco_decoder.exe中的源码，具体实现如下：#include

#include

using namespace draco;

using namespace std;

int main() {

string filePath = "D:/1.bin";

ifstream infile(filePath, ios::binary);

infile.seekg(0, std::ios::end);

size_t data_size = infile.tellg();

infile.seekg(0, std::ios::beg);

vector data(data_size, 0);

infile.read(data.data(), data_size);

DecoderBuffer buffer;

buffer.Init(data.data(), data_size);

//解压缩

std::unique_ptr pc;

auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);

if (!type_statusor.ok()) {

return 1;

}

//解析数据

const draco::EncodedGeometryType geom_type = type_statusor.value();

if (geom_type == draco::TRIANGULAR_MESH) {

draco::Decoder decoder;

auto statusor = decoder.DecodeMeshFromBuffer(&buffer);

if (!statusor.ok()) {

return 1;

}

std::unique_ptr mesh = std::move(statusor).value();

if (mesh) {

const int pos_att_id =

mesh->GetNamedAttributeId(GeometryAttribute::POSITION);

//解析顶点属性

for (PointIndex v(0); v < mesh->num_points(); ++v) {

const auto *const pos_att = mesh->attribute(pos_att_id);

const uint8_t *pos = pos_att->GetAddress(pos_att->mapped_index(v));

int64_t length = pos_att->byte_stride();

float temp[3];

memcpy(temp, pos, length);

printf("%f,%f,%f\t", temp[0], temp[1], temp[2]);

}

//解析顶点索引

for (FaceIndex f(0); f < mesh->num_faces(); ++f) {

printf("%d,%d,%d\t", mesh->face(f)[0].value(), mesh->face(f)[1].value(),

mesh->face(f)[2].value());

}

}复制需要注意的就是两点：传入draco::Decoder进行解压缩的需要二进制流，这个在从文件读取时一定要注意，很容易读成了文本流导致不能正常解压缩。对draco::Mesh的解析。draco::Mesh的顶点属性中的buffer并不是顶点索引中存储的数据。这个时压缩算法决定的，解析Mesh时一定要按照实例中解析。直接解析顶点属性中的buffer会得不到正确的顶点顺序。本文参与腾讯云自媒体分享计划，分享自作者个人站点/博客。原始发表：2022-05-18，如有侵权请联系 cloudcommunity@tencent.com 删除前往查看文件存储编程算法本文分享自作者个人站点/博客前往查看如有侵权，请联系 cloudcommunity@tencent.com 删除。本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！文件存储编程算法评论登录后参与评论0 条评论热度最新登录后参与评论推荐阅读LV.关注文章0获赞0目录目录1. 概述2. 详论2.1. 工具2.2. 代码相关产品与服务文件存储文件存储（Cloud File Storage，CFS）为您提供安全可靠、可扩展的共享文件存储服务。文件存储可与腾讯云服务器、容器服务、批量计算等服务搭配使用，为多个计算节点提供容量和性能可弹性扩展的高性能共享存储。腾讯云文件存储的管理界面简单、易使用，可实现对现有应用的无缝集成；按实际用量付费，为您节约成本，简化 IT 运维工作。产品介绍产品文档2024新春采购节领券社区专栏文章阅读清单互动问答技术沙龙技术视频团队主页腾讯云TI平台活动自媒体分享计划邀请作者入驻自荐上首页技术竞赛资源技术周刊社区标签开发者手册开发者实验室关于社区规范免责声明联系我们友情链接腾讯云开发者扫码关注腾讯云开发者领取腾讯云代金券热门产品域名注册云服务器区块链服务消息队列网络加速云数据库域名解析云存储视频直播热门推荐人脸识别腾讯会议企业云CDN加速视频通话图像分析MySQL 数据库SSL 证书语音识别更多推荐数据安全负载均衡短信文字识别云点播商标注册小程序开发网站监控数据迁移Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云版权所有深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569腾讯云计算（北京）有限责任公司京ICP证150476号 | 京ICP备11018762号 | 京公网安备号11010802020287问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档Copyright © 2013 - 2024 Tencent Cloud.All Rights Reserved. 腾讯云版权所有登录后参与评论00

Draco 3D Graphics Compression

Toggle navigation

Draco 3D

Github

Demo

Example

Spec

Draft Specification

Author README

Draco is an open-source library for compressing and decompressing 3D

geometric meshes and point clouds. It is intended to improve the storage

and transmission of 3D graphics.

View on GitHub »

Take the Codelab

Learn about compressing and viewing 3D models with Draco, and about different compression models and their effects.

Codelab »

Draft Bitstream Spec

View and contribute to the in-progress Draco Bitstream Specification and Decoding Guide. (Also see the instructions for authors.)

Bitstream Spec »

Related Projects

NPM Package

WebVR

Khronos glTF

three.js

YouTube: Comparing Draco to gzip

YouTube: Draco Announced on Google Developer Show

谷歌draco-腾讯云开发者社区-腾讯云

aco-腾讯云开发者社区-腾讯云点云PCL博主谷歌draco关注作者腾讯云开发者社区文档建议反馈控制台首页学习活动专区工具TVP最新优惠活动文章/答案/技术大牛搜索搜索关闭发布登录/注册首页学习活动专区工具TVP最新优惠活动返回腾讯云官网点云PCL博主首页学习活动专区工具TVP最新优惠活动返回腾讯云官网社区首页 >专栏 >谷歌draco谷歌draco点云PCL博主关注发布于 2019-07-31 11:46:011.6K0发布于 2019-07-31 11:46:01举报文章被收录于专栏：点云PCL点云PCL Draco 由谷歌 Chrome 媒体团队设计，旨在大幅加速 3D 数据的编码、传输和解码。因为研发团队的 Chrome 背景，这个开源算法的首要应用对象是浏览器。但既然谷歌把它开源，现在全世界的开发者可以去探索 Draco 在其他场景的应用，比如说非网页端。目前，谷歌提供了它的两个版本： JavaScript 和 C++。Draco 可以被用来压缩 mesh 和点云数据。它还支持压缩点（ compressing points），连接信息，纹理协调，颜色信息，法线（ normals）以及其他与几何相关的通用属性。下面是谷歌官方发布的 Draco Mesh 文件压缩率，可以看出，它大幅优于 ZIP。Draco 的算法既支持有损模式，也支持无损。这给普通消费者带来的好处还不太明显——毕竟大多数人对分辨率并没有强迫症，有损压缩带来的轻微画质改变完全在承受范围之内。但对专业应用和科研应用的意义就很大了。这就好比 JPEG 之于 PNG。后者用于游戏和 VR 应用完全没有问题，降低的画质很难用肉眼察觉。但在科研点云数据中，任何信息都不能丢失。如何使用draco?github上简介：Draco is a library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics.(1)下载源码git clone https://github.com/google/draco.git (2) cd dracs mkdir build cmake .. 如果提示你cmake的版本太低了，则需要升级cmake ，命令如下 sudo add-apt-repository ppa:george-edison55/cmake-3.x sudo apt-get update 如果你从来没装过cmake 则sudo apt-get install cmake(经过测试即使装过还是用这个命令直接升级比较好)

如果你装过cmake 则sudo apt-get upgrade安装完后，用命令：cmake --version 查看当前的cmake版本，可以看到现在cmake的版本为3.2.2之后就可以编译通过，make 一下傻等片刻就安装成功那么就可以使用查看一下效果，为了可视化以下，所以还是使用强大的PCL库来对比以下，在PCL库中读取PLY文件也是有对应的函数的class pcl::PCDReader()与class pcl::FLYReader() 分别是PCD，和FLY文件格式的接口的实现class pcl::PCDWriter()与class pcl::FLYWriter()分别是对PCD，FLY文件写入接口的实现查看发现它们的其他函数基本都是一样的，就是把PCD 换成FLY即可所以我们就可以使用draco来编码FLY格式的点云数据，然后在解码生成FLY文件，再在点云库中可视化一下，并且查看编码前后编码后文件的大小，可以看看编码的效率首先我们查看原始的文件以及它的大小3M 原始文件大小对原文件编码生成了out.drc文件并查看文件大小113.KB的大小编码命令编码后的文件大小并可视化原始点云，如下图：然后为了在可视化编码后再解码的效果，所以再查看解压后的大小为431.5KB 解码命令解码后的文件的大小可视化的效果和之前的是一样的，同时为了查看有没有丢失点数，打印出来看一下，发现点云数目没有变化都是35947 data points 总结以下，原来的文本是3M，编码后是113.KB文件，文件很小，压缩的效率非常高，为了再可视化，所以再解压，可视化的效果与原点云效果是一样的，原始文件可视化并输出点云的大小解码后的点云可视化并打印点云数目结合PCL库可视化的代码如下：#include //标准C++库中的输入输出的头文件

#include //PCD读写类相关的头文件

#include //PCL中支持的点类型的头文件

#include #include

#include

int main (int argc, char** argv)

{

//创建一个PointCloud boost共享指针并进行实例化

pcl::PointCloud::Ptr cloud (new pcl::PointCloud);

//打开点云文件

if (pcl::io::loadPLYFile ("bun_zipper.ply", *cloud) == -1)

{

PCL_ERROR ("Couldn't read file bun_zipper.ply \n"); return (-1);

}std::cout << "Loaded "

<< cloud->width * cloud->height << " data points from bun_zipper.ply with the following fields: "

<< std::endl;boost::shared_ptr viewer(new pcl::visualization::PCLVisualizer("cloud"));

viewer->addPointCloud(cloud,"cloud");while(!viewer->wasStopped())

{

viewer->spinOnce(100);

boost::this_thread::sleep(boost::posix_time::microseconds(1000000));

} return (0);

}复制对于draco的算法以及代码都没有详细的研究，这里只是看看它的压缩效率，同时我们在编码的时候，那几条命令时可以设置参数的，也可以设置编码的等级，所以还需要更加深入的研究，如有问题可以与我交流，谢谢本文参与腾讯云自媒体分享计划，分享自微信公众号。原始发表：2019-07-12，如有侵权请联系 cloudcommunity@tencent.com 删除打包bashbash 指令apt-gethttp本文分享自点云PCL 微信公众号，前往查看如有侵权，请联系 cloudcommunity@tencent.com 删除。本文参与腾讯云自媒体分享计划，欢迎热爱写作的你一起参与！打包bashbash 指令apt-gethttp评论登录后参与评论0 条评论热度最新登录后参与评论推荐阅读LV.关注文章0获赞0领券社区专栏文章阅读清单互动问答技术沙龙技术视频团队主页腾讯云TI平台活动自媒体分享计划邀请作者入驻自荐上首页技术竞赛资源技术周刊社区标签开发者手册开发者实验室关于社区规范免责声明联系我们友情链接腾讯云开发者扫码关注腾讯云开发者领取腾讯云代金券热门产品域名注册云服务器区块链服务消息队列网络加速云数据库域名解析云存储视频直播热门推荐人脸识别腾讯会议企业云CDN加速视频通话图像分析MySQL 数据库SSL 证书语音识别更多推荐数据安全负载均衡短信文字识别云点播商标注册小程序开发网站监控数据迁移Copyright © 2013 - 2024 Tencent Cloud. All Rights Reserved. 腾讯云版权所有深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569腾讯云计算（北京）有限责任公司京ICP证150476号 | 京ICP备11018762号 | 京公网安备号11010802020287问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档Copyright © 2013 - 2024 Tencent Cloud.All Rights Reserved. 腾讯云版权所有登录后参与评论00

本文链接：https://www.siyuewuyu.com/article/89.html

上一篇：imtoken钱包下载链接|doge币

下一篇：imtoken官网正版下载|eee

imtoken 钱包助记词格式是什么

...

下载imtoken钱包需要注意什么

...

imtoken导入钱包是什么意思

...

imtoken 钱包是做什么的

...

imtoken里钱包名称是什么

...

比特派(bitpie)钱包app官方下载|draco

GitHub - google/draco: Draco is a library for compressing and decompressing 3D geometric meshes and point clouds. It is intended to improve the storage and transmission of 3D graphics.

Draco库简析_draco几何压缩-CSDN博客

【网格压缩测评】MeshQuan、MeshOpt、Draco - 知乎

压缩gltf/glb模型踩坑与解决 three.js DRACOLoader - 掘金

3D文件压缩库——Draco简析_draco_encoder-CSDN博客

谷歌开源 3D 数据压缩算法 Draco以及代码分析_draco压缩-CSDN博客

3D文件压缩库——Draco简析 - 刘世涛6192 - 博客园

Draco使用笔记(1)——图形解压缩-腾讯云开发者社区-腾讯云

Draco 3D Graphics Compression

谷歌draco-腾讯云开发者社区-腾讯云

相关文章

imtoken 钱包助记词格式是什么

下载imtoken钱包需要注意什么

imtoken导入钱包是什么意思

imtoken 钱包是做什么的

imtoken里钱包名称是什么

Copyright © 2007-2023 imToken钱包官网下载钱包(imToken钱包官网下载Wallet)|全球领先数字货币多链钱包