draco
Draco 1.5.7 release
Attention aux utilisateurs de GStatic : l'équipe Draco recommande fortement d'utiliser les URL versionnées pour accéder au contenu Draco GStatic. Si vous utilisez des URL qui incluent la sous-chaîne v1/decoders dans l'URL, la mise en cache périphérique et les retards de propagation GStatic peuvent entraîner des erreurs passagères qui peuvent être difficiles à diagnostiquer lors du lancement de nouvelles versions de Draco. Pour éviter ce problème, épinglez vos sites sur une version versionnée.
install_test de src/draco/tools pour plus d'informations.https://github.com/google/draco/releases
Draco est une bibliothèque permettant de compresser et décompresser des maillages géométriques 3D et des nuages de points. Il est destiné à améliorer le stockage et la transmission des graphiques 3D.
Draco a été conçu et construit pour l'efficacité et la vitesse de compression. Le code prend en charge la compression des points, des informations de connectivité, des coordonnées de texture, des informations de couleur, des normales et tout autre attribut générique associé à la géométrie. Avec Draco, les applications utilisant des graphiques 3D peuvent être considérablement plus petites sans compromettre la fidélité visuelle. Pour les utilisateurs, cela signifie que les applications peuvent désormais être téléchargées plus rapidement, que les graphiques 3D dans le navigateur peuvent se charger plus rapidement et que les scènes VR et AR peuvent désormais être transmises avec une fraction de la bande passante et rendues rapidement.
Draco est publié sous forme de code source C++ qui peut être utilisé pour compresser des graphiques 3D ainsi que des décodeurs C++ et Javascript pour les données codées.
Contenu
Voir BÂTIMENT pour les instructions de construction.
Pour obtenir les meilleures informations sur l'utilisation de Unity avec Draco, veuillez visiter https://github.com/atteneder/DracoUnity
Pour un exemple simple d'utilisation de Unity avec Draco, voir README dans le dossier Unity.
Il est recommandé de toujours extraire vos décodeurs Draco WASM et JavaScript de :
https://www.gstatic.com/draco/v1/decoders/Les utilisateurs bénéficieront de la présence du décodeur Draco en cache à mesure que de plus en plus de sites commenceront à utiliser l'URL statique.
La cible par défaut créée à partir des fichiers de build sera les applications en ligne de commande draco_encoder et draco_decoder . De plus, draco_transcoder est généré lorsque CMake est exécuté avec la variable DRACO_TRANSCODER_SUPPORTED définie sur ON (voir BUILDING pour plus de détails). Pour toutes les applications, si vous les exécutez sans aucun argument ni -h , les applications afficheront l'utilisation et les options.
draco_encoder lira les fichiers OBJ, STL ou PLY en entrée et produira les fichiers codés Draco. Nous avons inclus le maillage Bunny de Stanford pour les tests. La ligne de commande de base ressemble à ceci :
./draco_encoder -i testdata/bun_zipper.ply -o out.drc Une valeur de 0 pour le paramètre de quantification n'effectuera aucune quantification sur l'attribut spécifié. Toute valeur autre que 0 quantifiera les valeurs d'entrée pour l'attribut spécifié sur ce nombre de bits. Par exemple:
./draco_encoder -i testdata/bun_zipper.ply -o out.drc -qp 14quantifiera les positions sur 14 bits (la valeur par défaut est 11 pour les coordonnées de position).
En général, plus vous quantifiez vos attributs, meilleur sera le taux de compression que vous obtiendrez. C'est à votre projet de décider du degré d'écart qu'il tolérera. En général, la plupart des projets peuvent définir des valeurs de quantification d'environ 11 sans différence de qualité notable.
Le paramètre de niveau de compression ( -cl ) active/désactive différentes fonctionnalités de compression.
./draco_encoder -i testdata/bun_zipper.ply -o out.drc -cl 8 En général, le réglage le plus élevé, 10 , aura la plus grande vitesse de compression mais la pire vitesse de décompression. 0 aura le moins de compression, mais la meilleure vitesse de décompression. Le paramètre par défaut est 7 .
Vous pouvez encoder les données de nuages de points avec draco_encoder en spécifiant le paramètre -point_cloud . Si vous spécifiez le paramètre -point_cloud avec un fichier d'entrée de maillage, draco_encoder ignorera les données de connectivité et encodera les positions du fichier de maillage.
./draco_encoder -point_cloud -i testdata/bun_zipper.ply -o out.drcCette ligne de commande encodera l'entrée du maillage sous forme de nuage de points, même si l'entrée ne produit pas de compression représentative d'autres nuages de points. Plus précisément, on peut s’attendre à des taux de compression bien meilleurs pour des nuages de points plus grands et plus denses.
draco_decoder lira les fichiers Draco en entrée et produira les fichiers OBJ, STL ou PLY. La ligne de commande de base ressemble à ceci :
./draco_decoder -i in.drc -o out.obj draco_transcoder peut être utilisé pour ajouter la compression Draco aux actifs glTF. La ligne de commande de base ressemble à ceci :
./draco_transcoder -i in.glb -o out.glb Cette ligne de commande ajoutera une compression géométrique à tous les maillages du fichier in.glb . Les valeurs de quantification pour différents attributs glTF peuvent être spécifiées de la même manière que l'outil draco_encoder . Par exemple, -qp peut être utilisé pour définir la quantification de l'attribut position :
./draco_transcoder -i in.glb -o out.glb -qp 12 Si vous souhaitez ajouter du décodage à vos applications, vous devrez inclure la bibliothèque draco_dec . Pour utiliser le décodeur Draco, vous devez initialiser un DecoderBuffer avec les données compressées. Appelez ensuite DecodeMeshFromBuffer() pour renvoyer un objet maillage décodé ou appelez DecodePointCloudFromBuffer() pour renvoyer un objet PointCloud décodé. Par exemple:
draco::DecoderBuffer buffer;
buffer.Init(data.data(), data.size());
const draco::EncodedGeometryType geom_type =
draco::GetEncodedGeometryType (&buffer);
if (geom_type == draco::TRIANGULAR_MESH) {
unique_ptr<draco::Mesh> mesh = draco::DecodeMeshFromBuffer (&buffer);
} else if (geom_type == draco::POINT_CLOUD) {
unique_ptr<draco::PointCloud> pc = draco::DecodePointCloudFromBuffer (&buffer);
} Veuillez consulter src/draco/mesh/mesh.h pour l'interface complète de la classe Mesh et src/draco/point_cloud/point_cloud.h pour l'interface complète de la classe PointCloud .
L'encodeur Javascript se trouve dans javascript/draco_encoder.js . L'API de l'encodeur peut être utilisée pour compresser le maillage et le nuage de points. Pour utiliser l'encodeur, vous devez d'abord créer une instance de DracoEncoderModule . Utilisez ensuite cette instance pour créer des objets MeshBuilder et Encoder . MeshBuilder est utilisé pour construire un maillage à partir de données géométriques qui pourraient ensuite être compressées par Encoder . Créez d’abord un objet maillé en utilisant new encoderModule.Mesh() . Ensuite, utilisez AddFacesToMesh() pour ajouter des indices au maillage et utilisez AddFloatAttributeToMesh() pour ajouter des données d'attribut au maillage, par exemple les coordonnées de position, de normale, de couleur et de texture. Une fois un maillage construit, vous pouvez ensuite utiliser EncodeMeshToDracoBuffer() pour compresser le maillage. Par exemple:
const mesh = {
indices : new Uint32Array ( indices ) ,
vertices : new Float32Array ( vertices ) ,
normals : new Float32Array ( normals )
} ;
const encoderModule = DracoEncoderModule ( ) ;
const encoder = new encoderModule . Encoder ( ) ;
const meshBuilder = new encoderModule . MeshBuilder ( ) ;
const dracoMesh = new encoderModule . Mesh ( ) ;
const numFaces = mesh . indices . length / 3 ;
const numPoints = mesh . vertices . length ;
meshBuilder . AddFacesToMesh ( dracoMesh , numFaces , mesh . indices ) ;
meshBuilder . AddFloatAttributeToMesh ( dracoMesh , encoderModule . POSITION ,
numPoints , 3 , mesh . vertices ) ;
if ( mesh . hasOwnProperty ( 'normals' ) ) {
meshBuilder . AddFloatAttributeToMesh (
dracoMesh , encoderModule . NORMAL , numPoints , 3 , mesh . normals ) ;
}
if ( mesh . hasOwnProperty ( 'colors' ) ) {
meshBuilder . AddFloatAttributeToMesh (
dracoMesh , encoderModule . COLOR , numPoints , 3 , mesh . colors ) ;
}
if ( mesh . hasOwnProperty ( 'texcoords' ) ) {
meshBuilder . AddFloatAttributeToMesh (
dracoMesh , encoderModule . TEX_COORD , numPoints , 3 , mesh . texcoords ) ;
}
if ( method === "edgebreaker" ) {
encoder . SetEncodingMethod ( encoderModule . MESH_EDGEBREAKER_ENCODING ) ;
} else if ( method === "sequential" ) {
encoder . SetEncodingMethod ( encoderModule . MESH_SEQUENTIAL_ENCODING ) ;
}
const encodedData = new encoderModule . DracoInt8Array ( ) ;
// Use default encoding setting.
const encodedLen = encoder . EncodeMeshToDracoBuffer ( dracoMesh ,
encodedData ) ;
encoderModule . destroy ( dracoMesh ) ;
encoderModule . destroy ( encoder ) ;
encoderModule . destroy ( meshBuilder ) ;Veuillez consulter src/draco/javascript/emscripten/draco_web_encoder.idl pour l'API complète.
Le décodeur Javascript se trouve dans javascript/draco_decoder.js. Le décodeur Javascript peut décoder le maillage et le nuage de points. Pour utiliser le décodeur, vous devez d'abord créer une instance de DracoDecoderModule . L'instance est ensuite utilisée pour créer des objets DecoderBuffer et Decoder . Définissez les données codées dans le DecoderBuffer . Appelez ensuite GetEncodedGeometryType() pour identifier le type de géométrie, par exemple un maillage ou un nuage de points. Appelez ensuite DecodeBufferToMesh() ou DecodeBufferToPointCloud() , qui renverra un objet Mesh ou un nuage de points. Par exemple:
// Create the Draco decoder.
const decoderModule = DracoDecoderModule ( ) ;
const buffer = new decoderModule . DecoderBuffer ( ) ;
buffer . Init ( byteArray , byteArray . length ) ;
// Create a buffer to hold the encoded data.
const decoder = new decoderModule . Decoder ( ) ;
const geometryType = decoder . GetEncodedGeometryType ( buffer ) ;
// Decode the encoded geometry.
let outputGeometry ;
let status ;
if ( geometryType == decoderModule . TRIANGULAR_MESH ) {
outputGeometry = new decoderModule . Mesh ( ) ;
status = decoder . DecodeBufferToMesh ( buffer , outputGeometry ) ;
} else {
outputGeometry = new decoderModule . PointCloud ( ) ;
status = decoder . DecodeBufferToPointCloud ( buffer , outputGeometry ) ;
}
// You must explicitly delete objects created from the DracoDecoderModule
// or Decoder.
decoderModule . destroy ( outputGeometry ) ;
decoderModule . destroy ( decoder ) ;
decoderModule . destroy ( buffer ) ;Veuillez consulter src/draco/javascript/emscripten/draco_web_decoder.idl pour l'API complète.
Le décodeur Javascript est construit avec une mémoire dynamique. Cela permettra au décodeur de fonctionner avec toutes les données compressées. Mais cette option n’est pas la plus rapide. La pré-allocation de la mémoire permet d'améliorer la vitesse du décodeur d'environ 2x. Si vous connaissez tous les besoins en mémoire de votre projet, vous pouvez activer la mémoire statique en modifiant CMakeLists.txt en conséquence.
À partir de la version 1.0, Draco fournit une fonctionnalité de métadonnées pour coder des données autres que la géométrie. Il pourrait être utilisé pour coder n’importe quelle donnée personnalisée ainsi que la géométrie. Par exemple, nous pouvons activer la fonctionnalité de métadonnées pour coder le nom des attributs, le nom des sous-objets et des informations personnalisées. Pour un maillage et un nuage de points, il peut avoir une classe de métadonnées géométriques de niveau supérieur. Les métadonnées de niveau supérieur peuvent alors avoir des métadonnées hiérarchiques. En dehors de cela, les métadonnées de niveau supérieur peuvent avoir des métadonnées pour chaque attribut, appelées métadonnées d'attribut. Les métadonnées d'attribut doivent être initialisées avec l'identifiant d'attribut correspondant dans le maillage. L'API de métadonnées est fournie à la fois en C++ et en Javascript. Par exemple, pour ajouter des métadonnées en C++ :
draco::PointCloud pc;
// Add metadata for the geometry.
std::unique_ptr<draco::GeometryMetadata> metadata =
std::unique_ptr<draco::GeometryMetadata>( new draco::GeometryMetadata());
metadata-> AddEntryString ( " description " , " This is an example. " );
pc.AddMetadata(std::move(metadata));
// Add metadata for attributes.
draco::GeometryAttribute pos_att;
pos_att.Init(draco::GeometryAttribute::POSITION, nullptr , 3 ,
draco::DT_FLOAT32, false , 12 , 0 );
const uint32_t pos_att_id = pc.AddAttribute(pos_att, false , 0 );
std::unique_ptr<draco::AttributeMetadata> pos_metadata =
std::unique_ptr<draco::AttributeMetadata>(
new draco::AttributeMetadata(pos_att_id));
pos_metadata-> AddEntryString ( " name " , " position " );
// Directly add attribute metadata to geometry.
// You can do this without explicitly add |GeometryMetadata| to mesh.
pc.AddAttributeMetadata(pos_att_id, std::move(pos_metadata));Pour lire les métadonnées d'une géométrie en C++ :
// Get metadata for the geometry.
const draco::GeometryMetadata *pc_metadata = pc.GetMetadata();
// Request metadata for a specific attribute.
const draco::AttributeMetadata *requested_pos_metadata =
pc.GetAttributeMetadataByStringEntry( " name " , " position " );Veuillez consulter src/draco/metadata et src/draco/point_cloud pour l'API complète.
Le package Draco NPM NodeJS se trouve dans javascript/npm/draco3d. Veuillez consulter la documentation dans le dossier pour une utilisation détaillée.
Voici un exemple de géométrie compressée avec Draco chargé via un décodeur Javascript utilisant le moteur de rendu three.js .
Veuillez consulter le fichier javascript/example/README.md pour plus d'informations.
Les versions prédéfinies des décodeurs javascript Draco construits par Emscripten sont hébergées sur www.gstatic.com dans des répertoires étiquetés version :
https://www.gstatic.com/draco/versioned/decoders/VERSION/*
Depuis la version v1.4.3, les fichiers disponibles sont :
À partir de la version v1.5.1, les versions activées par les assertions des fichiers suivants sont disponibles :
Pour toute question/commentaire, veuillez envoyer un e-mail à [email protected]
Si vous avez trouvé une erreur dans cette bibliothèque, veuillez signaler un problème sur https://github.com/google/draco/issues
Les correctifs sont encouragés et peuvent être soumis en bifurquant ce projet et en soumettant une pull request via GitHub. Voir CONTRIBUTION pour plus de détails.
Sous licence Apache, version 2.0 (la « Licence » ); vous ne pouvez pas utiliser ce fichier sauf en conformité avec la licence. Vous pouvez obtenir une copie de la licence à
http://www.apache.org/licenses/LICENSE-2.0
Sauf disposition contraire de la loi applicable ou accord écrit, le logiciel distribué sous la licence est distribué « TEL QUEL », SANS GARANTIE OU CONDITION D'AUCUNE SORTE, expresse ou implicite. Consultez la licence pour connaître la langue spécifique régissant les autorisations et les limitations en vertu de la licence.
Modèle de lapin du département graphique de Stanford https://graphics.stanford.edu/data/3Dscanrep/
