HTML JPG PDF XML PLY

PLY

Extraer activos de PLY a través de C#

Cree sus propias aplicaciones .NET para extraer recursos de archivos PLY mediante las API del lado del servidor.

Cómo extraer activos del archivo PLY usando C#

Para extraer activos del archivo PLY, usaremos

Aspose.3D for .NET

API, que es una plataforma API para C# rica en funciones, potente y fácil de usar para usar con recursos de extracción. Abierto

NuGet

administrador de paquetes, busque Aspose.3D e instalar También puede usar el siguiente comando desde la Consola del administrador de paquetes.

Comando de la consola del Administrador de paquetes
PM> Install-Package Aspose.3D

Pasos para extraer activos de PLY a través de C#

Aspose.3D facilita a los desarrolladores la extracción de activos del archivo PLY con solo unas pocas líneas de código.

Cargue el archivo PLY a través del constructor de la clase Escena- Crear objeto de formato de archivo zip como formato de archivo de salida- Crear clase de archivo y manejar la clase de activo de extracción- Llame al método Extract y guarde el archivo

Requisitos del sistema

Aspose.3D for .NET es compatible con todos los principales sistemas operativos. Solo asegúrese de tener los siguientes requisitos previos.

Microsoft Windows o un sistema operativo compatible con .NET Framework, .NET Core, Mono- Entorno de desarrollo como Microsoft Visual Studio- Aspose.3D for .NET referenciado en su proyecto

Código C# para extraer recursos de PLY
//Archivos de origen que necesitan extraer activos
string file = "template.ply";
Scene scene = new Scene(file);  

//La salida está en un formato de archivo comprimido y Directorio representa el nombre de una carpeta existente
var zipOutput = Path.Combine("Directory", "OutputFile.zip");
using var output = new FileStream(zipOutput, FileMode.Create);
using var za = new Zip(output);

//Llame al método Extract para realizar operaciones de extracción de activos
Extract(scene,za,true);

//Método de extracción invocable, la textura del parámetro indica: si se extrae la textura
private void Extract(Scene scene, Zip za,bool texture)
{
    var extractor = new Extractor(za,texture);
    extractor.Extract(scene);
}

//Crear una clase de procesamiento de archivos comprimidos
class Zip : IDisposable
{
    private ZipArchive archive;
    private HashSet<string> entries = new HashSet<string>();

    public Zip(Stream stream)
    {
        archive = new ZipArchive(stream, ZipArchiveMode.Create);
    }
    public void Dispose()
    {
        archive.Dispose();
    }

    public void Add(string fileName, byte[] content, bool enableCompression)
    {
        var entryName = PickName(fileName);
        var compressionLevel = enableCompression ? CompressionLevel.Fastest : CompressionLevel.NoCompression;
        var entry = archive.CreateEntry(entryName, compressionLevel);
        using var stream = entry.Open();
        stream.Write(content, 0, content.Length);
    }
    
    private string PickName(string fileName)
    {
        if (!entries.Contains(fileName))
        {
            entries.Add(fileName);
            return fileName;
        }
        var baseName = Path.GetFileNameWithoutExtension(fileName);
        var ext = Path.GetExtension(fileName);
        for (var idx = 2; ; idx++)
        {
            var newName = baseName + "_" + idx;
            if (!string.IsNullOrEmpty(ext))
                newName += ext;
            if (entries.Contains(newName))
                continue;
            entries.Add(newName);
            return newName;
        }
    }
}

//Crear una clase de procesamiento de extracción de activos
class Extractor
{
    private Zip zip;
    private bool texture;
    HashSet<A3DObject> visited = new HashSet<A3DObject>();
    public Extractor(Zip zip,bool texture)
    {
        this.zip = zip;
        this.texture = texture;
    }

    private bool CanVisit(A3DObject obj)
    {
        if (visited.Contains(obj))
            return false;
        visited.Add(obj);
        return true;
    }
    public void Extract(Scene scene)
    {
        if (scene.Library != null && scene.Library.Count > 0)
        {
            foreach (var obj in scene.Library)
            {
                Visit(obj);
            }
        }
        VisitNode(scene.RootNode);
    }
    private void VisitNode(Node node)
    {
        if (!CanVisit(node))
            return;
        if (texture)
        {
            foreach (var mat in node.Materials)
            {
                VisitMaterial(mat);
            }
        }

        foreach (var entity in node.Entities)
        {
            if (entity is Mesh)
                Save((Mesh)entity, node.Name);
        }
        
        foreach (var child in node.ChildNodes)
        {
            VisitNode(child);
        }
    }
    private void VisitMaterial(Material mat)
    {
        if (!CanVisit(mat))
            return;
        if (!texture)
            return;
        foreach (var tslot in mat)
        {
            if (tslot.Texture is Texture)
            {
                Save((Texture)tslot.Texture);
            }
        }
    }
    private void Visit(A3DObject obj)
    {
        if (texture && obj is Texture)
        {
            Save((Texture)obj);
        }
        else if (obj is Mesh)
        {
            Save((Mesh)obj, null);
        }
        else if (obj is Node)
        {
            VisitNode((Node)obj);
        }
    }
    private void Save(Mesh mesh, string? nodeName)
    {
        if (!CanVisit(mesh))
            return;
        Scene scene = new Scene(mesh);
        using (var ms = new MemoryStream())
        {
            scene.Save(ms, FileFormat.FBX7400ASCII);
            var name = nodeName;
            if (string.IsNullOrEmpty(name))
                name = mesh.Name;
            if (string.IsNullOrEmpty(name))
                name = "mesh";
            var ext = ".fbx";
            zip.Add(name + ext, ms.ToArray(), true);
        }
    }
    private void Save(Texture tex)
    {
        if (tex.Content == null || !CanVisit(tex))
            return;
        var fileName = tex.FileName != null ? Path.GetFileName(tex.FileName) : null;
        zip.Add(fileName, tex.Content, false);
    }
}

Acerca de Aspose.3D for .NET API

Aspose.3D es un CAD y Gameware API para cargar, modificar y convertir archivos 3D. API es independiente y no requiere ningún 3D software de modelado o renderizado. Uno puede usar fácilmente API para Discreet3DS, WavefrontOBJ, STL (ASCII, binario), Universal3D, FBX (ASCII, binario), Collada, glTF, PLY, GLB, DirectX y más formatos.

Aplicación gratuita para extraer activos de PLY

Consulte nuestras demostraciones en vivo para Extractor PLY con los siguientes beneficios.

No es necesario descargar ni configurar nada

No es necesario escribir o compilar código

Simplemente cargue el archivo PLY y presione el botón "Extraer"

Descargue el archivo PLY desde el enlace, si es necesario

PLY Qué es PLY Formato de archivo

PLY, formato de archivo de polígono, representa el formato de archivo 3D que almacena objetos gráficos descritos como una colección de polígonos. El propósito de este formato de archivo era establecer un tipo de archivo simple y fácil que fuera lo suficientemente general como para ser útil para una amplia gama de modelos. El formato de archivo PLY viene en formato ASCII y binario para un almacenamiento compacto y para guardar y cargar rápidamente.

Otra aplicación compatible para extraer activos de formatos

Con C#, también se pueden extraer activos de muchos otros formatos de archivo, incluidos.

3MF (3D formato de fabricación)

AMF (Formato de fabricación aditiva)

ASE (Archivo de animación 2D)

DAE (Intercambio de activos digitales)

DXF (Formato de intercambio de dibujos)

DRC (Google Draco)

FBX (3D Formato)

GLB (3D Representación binaria de archivos)

GLTF (Formato de transmisión GL)

JT (Archivo de teselado de Júpiter)

OBJ (3D formato de archivo)

3DS (3D Formato de archivo de malla de Studio)

PDF (3D PDF)

RVM (Modelo de diseño de planta de AVEVA)

STL (Geometría de superficie intercambiable 3D)

U3D (Universal 3D)

VRML (Lenguaje de modelado de realidad virtual)

X (Imagen del modelo de DirectX)

USD (Descripción de la escena universal)

USDZ (Universal Escena Descripción Zip Archivo)