HTML JPG PDF XML 3MF
Aspose.3D  for .NET
3MF

Extraer activos de 3MF a través de C#

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

Cómo extraer activos del archivo 3MF usando C#

Para extraer activos del archivo 3MF, 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 3MF a través de C#

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

  • Cargue el archivo 3MF 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 3MF


//Archivos de origen que necesitan extraer activos
string file = "template.3mf";
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 3MF

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

      No es necesario descargar ni configurar nada
      No es necesario escribir o compilar código
      Simplemente cargue el archivo 3MF y presione el botón "Extraer"
      Descargue el archivo 3MF desde el enlace, si es necesario

    3MF Qué es 3MF Formato de archivo

    3MF, 3D formato de fabricación, lo utilizan las aplicaciones para representar 3D modelos de objetos en una variedad de otras aplicaciones, plataformas, servicios e impresoras. Se creó para evitar las limitaciones y los problemas de otros formatos de archivo 3D, como STL, para trabajar con las últimas versiones de las impresoras 3D. 3MF es un formato de archivo relativamente nuevo desarrollado y publicado por el consorcio 3MF.

    Leer más

    Otra aplicación compatible para extraer activos de formatos

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

    3DS (3D Formato de archivo de malla de Studio)
    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)
    PLY (Formato de archivo de polígono)
    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)