draco
Draco 1.5.7 release
Atención a los usuarios de GStatic: el equipo de Draco recomienda encarecidamente utilizar las URL versionadas para acceder al contenido de Draco GSatic. Si está utilizando las URL que incluyen la subcadena v1/decoders dentro de la URL, el almacenamiento en caché perimetral y los retrasos en la propagación de GStatic pueden provocar errores transitorios que pueden ser difíciles de diagnosticar cuando se lanzan nuevas versiones de Draco. Para evitar el problema, fije sus sitios a una versión versionada.
install_test de src/draco/tools para obtener más información.https://github.com/google/draco/releases
Draco es una biblioteca para comprimir y descomprimir mallas geométricas 3D y nubes de puntos. Su objetivo es mejorar el almacenamiento y la transmisión de gráficos 3D.
Draco fue diseñado y construido para brindar eficiencia y velocidad de compresión. El código admite la compresión de puntos, información de conectividad, coordenadas de textura, información de color, normales y cualquier otro atributo genérico asociado con la geometría. Con Draco, las aplicaciones que utilizan gráficos 3D pueden ser significativamente más pequeñas sin comprometer la fidelidad visual. Para los usuarios, esto significa que las aplicaciones ahora se pueden descargar más rápido, los gráficos 3D en el navegador se pueden cargar más rápido y las escenas VR y AR ahora se pueden transmitir con una fracción del ancho de banda y renderizar rápidamente.
Draco se lanza como código fuente C++ que se puede utilizar para comprimir gráficos 3D, así como decodificadores C++ y Javascript para los datos codificados.
Contenido
Consulte EDIFICIO para obtener instrucciones de construcción.
Para obtener la mejor información sobre el uso de Unity con Draco, visite https://github.com/attenereder/DracoUnity
Para ver un ejemplo sencillo del uso de Unity con Draco, consulte README en la carpeta de Unity.
Se recomienda siempre extraer los decodificadores Draco WASM y JavaScript de:
https://www.gstatic.com/draco/v1/decoders/Los usuarios se beneficiarán de tener el decodificador Draco en caché a medida que más sitios comiencen a usar la URL estática.
El objetivo predeterminado creado a partir de los archivos de compilación serán las aplicaciones de línea de comandos draco_encoder y draco_decoder . Además, draco_transcoder se genera cuando CMake se ejecuta con la variable DRACO_TRANSCODER_SUPPORTED configurada en ON (consulte BUILDING para obtener más detalles). Para todas las aplicaciones, si las ejecuta sin ningún argumento o -h , las aplicaciones generarán uso y opciones.
draco_encoder leerá archivos OBJ, STL o PLY como entrada y generará archivos codificados en Draco. Hemos incluido la malla Bunny de Stanford para realizar pruebas. La línea de comando básica se ve así:
./draco_encoder -i testdata/bun_zipper.ply -o out.drc Un valor de 0 para el parámetro de cuantificación no realizará ninguna cuantificación en el atributo especificado. Cualquier valor distinto de 0 cuantificará los valores de entrada para el atributo especificado en ese número de bits. Por ejemplo:
./draco_encoder -i testdata/bun_zipper.ply -o out.drc -qp 14Cuantizará las posiciones a 14 bits (el valor predeterminado es 11 para las coordenadas de posición).
En general, cuanto más cuantice sus atributos, mejor tasa de compresión obtendrá. Depende de su proyecto decidir cuánta desviación tolerará. En general, la mayoría de los proyectos pueden establecer valores de cuantización de aproximadamente 11 sin ninguna diferencia notable en la calidad.
El parámetro de nivel de compresión ( -cl ) activa/desactiva diferentes funciones de compresión.
./draco_encoder -i testdata/bun_zipper.ply -o out.drc -cl 8 En general, la configuración más alta, 10 , tendrá la mayor velocidad de compresión pero la peor descompresión. 0 tendrá la menor compresión, pero la mejor velocidad de descompresión. La configuración predeterminada es 7 .
Puede codificar datos de nubes de puntos con draco_encoder especificando el parámetro -point_cloud . Si especifica el parámetro -point_cloud con un archivo de entrada de malla, draco_encoder ignorará los datos de conectividad y codificará las posiciones del archivo de malla.
./draco_encoder -point_cloud -i testdata/bun_zipper.ply -o out.drcEsta línea de comando codificará la entrada de malla como una nube de puntos, aunque es posible que la entrada no produzca una compresión que sea representativa de otras nubes de puntos. Específicamente, se pueden esperar tasas de compresión mucho mejores para nubes de puntos más grandes y densas.
draco_decoder leerá archivos Draco como entrada y generará archivos OBJ, STL o PLY. La línea de comando básica se ve así:
./draco_decoder -i in.drc -o out.obj draco_transcoder se puede utilizar para agregar compresión Draco a los activos glTF. La línea de comando básica se ve así:
./draco_transcoder -i in.glb -o out.glb Esta línea de comando agregará compresión geométrica a todas las mallas en el archivo in.glb . Los valores de cuantificación para diferentes atributos glTF se pueden especificar de manera similar a la herramienta draco_encoder . Por ejemplo -qp se puede utilizar para definir la cuantificación del atributo de posición:
./draco_transcoder -i in.glb -o out.glb -qp 12 Si desea agregar decodificación a sus aplicaciones, deberá incluir la biblioteca draco_dec . Para utilizar el decodificador Draco, necesita inicializar un DecoderBuffer con los datos comprimidos. Luego llame DecodeMeshFromBuffer() para devolver un objeto de malla decodificado o llame DecodePointCloudFromBuffer() para devolver un objeto PointCloud decodificado. Por ejemplo:
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);
} Consulte src/draco/mesh/mesh.h para ver la interfaz de clase Mesh completa y src/draco/point_cloud/point_cloud.h para ver la interfaz de clase PointCloud completa.
El codificador de Javascript se encuentra en javascript/draco_encoder.js . La API del codificador se puede utilizar para comprimir mallas y nubes de puntos. Para utilizar el codificador, primero debe crear una instancia de DracoEncoderModule . Luego use esta instancia para crear objetos MeshBuilder y Encoder . MeshBuilder se utiliza para construir una malla a partir de datos geométricos que luego podrían ser comprimidos por Encoder . Primero cree un objeto de malla usando new encoderModule.Mesh() . Luego, use AddFacesToMesh() para agregar índices a la malla y use AddFloatAttributeToMesh() para agregar datos de atributos a la malla, por ejemplo, coordenadas de posición, normal, color y textura. Una vez construida una malla, puede usar EncodeMeshToDracoBuffer() para comprimir la malla. Por ejemplo:
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 ) ;Consulte src/draco/javascript/emscripten/draco_web_encoder.idl para obtener la API completa.
El decodificador de Javascript se encuentra en javascript/draco_decoder.js. El decodificador Javascript puede decodificar mallas y nubes de puntos. Para utilizar el decodificador, primero debe crear una instancia de DracoDecoderModule . Luego, la instancia se utiliza para crear objetos DecoderBuffer y Decoder . Configure los datos codificados en DecoderBuffer . Luego llame GetEncodedGeometryType() para identificar el tipo de geometría, por ejemplo, malla o nube de puntos. Luego llame DecodeBufferToMesh() o DecodeBufferToPointCloud() , que devolverá un objeto Mesh o una nube de puntos. Por ejemplo:
// 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 ) ;Consulte src/draco/javascript/emscripten/draco_web_decoder.idl para obtener la API completa.
El decodificador Javascript está construido con memoria dinámica. Esto permitirá que el decodificador funcione con todos los datos comprimidos. Pero esta opción no es la más rápida. La preasignación de la memoria produce una mejora de la velocidad del decodificador de aproximadamente 2 veces. Si conoce todos los requisitos de memoria de su proyecto, puede activar la memoria estática cambiando CMakeLists.txt en consecuencia.
A partir de la versión 1.0, Draco proporciona funcionalidad de metadatos para codificar datos distintos de la geometría. Podría usarse para codificar cualquier dato personalizado junto con la geometría. Por ejemplo, podemos habilitar la funcionalidad de metadatos para codificar el nombre de los atributos, el nombre de los subobjetos y la información personalizada. Para una malla y nube de puntos, puede tener una clase de metadatos de geometría de nivel superior. Los metadatos de nivel superior pueden tener metadatos jerárquicos. Aparte de eso, los metadatos de nivel superior pueden tener metadatos para cada atributo, lo que se denomina metadatos de atributo. Los metadatos del atributo deben inicializarse con la identificación del atributo correspondiente dentro de la malla. La API de metadatos se proporciona tanto en C++ como en Javascript. Por ejemplo, para agregar metadatos 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));Para leer metadatos de una geometría 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 " );Consulte src/draco/metadata y src/draco/point_cloud para obtener la API completa.
El paquete Draco NPM NodeJS se encuentra en javascript/npm/draco3d. Consulte el documento en la carpeta para conocer el uso detallado.
Aquí hay un ejemplo de una compresión geométrica con Draco cargado a través de un decodificador Javascript usando el renderizador three.js .
Consulte el archivo javascript/example/README.md para obtener más información.
Las versiones prediseñadas de los decodificadores Draco javascript creados por Emscripten están alojadas en www.gstatic.com en directorios etiquetados con la versión:
https://www.gstatic.com/draco/versioned/decoders/VERSION/*
A partir de la versión v1.4.3, los archivos disponibles son:
A partir de la versión v1.5.1, están disponibles las compilaciones habilitadas para la aserción de los siguientes archivos:
Si tiene preguntas o comentarios, envíe un correo electrónico a [email protected].
Si encontró un error en esta biblioteca, presente un problema en https://github.com/google/draco/issues
Se recomiendan parches, que pueden enviarse bifurcando este proyecto y enviando una solicitud de extracción a través de GitHub. Consulte CONTRIBUCIÓN para obtener más detalles.
Licenciado bajo la Licencia Apache, Versión 2.0 (la "Licencia"); no puede utilizar este archivo excepto de conformidad con la Licencia. Puede obtener una copia de la Licencia en
http://www.apache.org/licenses/LICENSE-2.0
A menos que lo exija la ley aplicable o se acuerde por escrito, el software distribuido bajo la Licencia se distribuye "TAL CUAL", SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sean expresas o implícitas. Consulte la Licencia para conocer el idioma específico que rige los permisos y limitaciones de la Licencia.
Modelo de conejito del departamento gráfico de Stanford https://graphics.stanford.edu/data/3Dscanrep/
