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

Extraer activos de AMF a través de C#

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

Cómo extraer activos del archivo AMF usando C#

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

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

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


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

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

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

    AMF Qué es AMF Formato de archivo

    El formato de archivo de fabricación aditiva (AMF) define estándares abiertos para la descripción de objetos para ser utilizados por procesos de fabricación aditiva como la impresión 3D. Los programas CAD usan el formato de archivo AMF haciendo uso de información como la geometría, el color y el material de los objetos. AMF es diferente al formato STL ya que el lateral no admite color, materiales, entramados ni constelaciones.

    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.

    3MF (3D formato de fabricación)
    3DS (3D Formato de archivo de malla de Studio)
    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)