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

Middelen extraheren uit 3MF via C#

Bouw uw eigen .NET apps om activa uit 3MF bestanden te extraheren met behulp van server-side API's.

Middelen extraheren uit 3MF-bestand met C#

Om items uit het 3MF-bestand te extraheren, gebruiken we

Aspose.3D for .NET

API, een veelzijdig, krachtig en gebruiksvriendelijk API voor C#-platform dat kan worden gebruikt met extract-items. Open

NuGet

pakketbeheerder, zoek naar Aspose.3D en installeren. U kunt ook de volgende opdracht gebruiken vanuit de Package Manager Console.

Pakketbeheer Console-opdracht


PM> Install-Package Aspose.3D

Stappen om activa uit 3MF te extraheren via C#

Aspose.3D maakt het de ontwikkelaars gemakkelijk om items uit het 3MF-bestand te extraheren met slechts enkele regels code.

  • Laad 3MF bestand via de constructor van Scene klasse- Maak een zip-bestandsformaatobject als uitvoerbestandsformaat- Archiefklasse maken en activaklasse uitpakken verwerken- Roep de Extract-methode aan en sla het bestand op

systeem vereisten

Aspose.3D for .NET wordt ondersteund op alle belangrijke besturingssystemen. Zorg ervoor dat u aan de volgende vereisten voldoet.

  • Microsoft Windows of een compatibel besturingssysteem met .NET Framework, .NET Core, Mono- Ontwikkelomgeving zoals Microsoft Visual Studio- Aspose.3D for .NET waarnaar wordt verwezen in uw project
 

C# code om activa uit 3MF te extraheren


//Bronbestanden die activa moeten extraheren
string file = "template.3mf";
Scene scene = new Scene(file);  

//De uitvoer is in een gecomprimeerde bestandsindeling en Directory vertegenwoordigt de naam van een bestaande map
var zipOutput = Path.Combine("Directory", "OutputFile.zip");
using var output = new FileStream(zipOutput, FileMode.Create);
using var za = new Zip(output);

//Roep de Extract-methode aan om activatie-extractiebewerkingen uit te voeren
Extract(scene,za,true);

//Oproepbare extractiemethode, de parametertextuur geeft aan: of de textuur moet worden geëxtraheerd
private void Extract(Scene scene, Zip za,bool texture)
{
    var extractor = new Extractor(za,texture);
    extractor.Extract(scene);
}

//Een gecomprimeerde bestandsverwerkingsklasse maken
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;
        }
    }
}

//Een verwerkingsklasse voor activaextractie maken
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);
    }
}
 
  • Over Aspose.3D for .NET API

    Aspose.3D is een CAD en Gameware API om 3D-bestanden te laden, aan te passen en te converteren. API is een standalone en vereist geen 3D-modellerings- of renderingsoftware. Men kan gemakkelijk API gebruiken voor Discreet3DS, WavefrontOBJ, STL (ASCII, Binair), Universal3D, FBX (ASCII, Binair), Collada, glTF, PLY, GLB, DirectX en meer formaten.

    Gratis app om activa uit 3MF te extraheren

    Bekijk onze live demo's om Extractor 3MF met volgende voordelen.

      U hoeft niets te downloaden of in te stellen
      U hoeft geen code te schrijven of te compileren
      Upload gewoon het bestand 3MF en klik op de knop "Uitpakken"
      Download 3MF bestand via de link, indien nodig

    3MF Wat is 3MF bestandsformaat

    3MF, 3D Manufacturing Format, wordt door toepassingen gebruikt om 3D objectmodellen weer te geven voor een groot aantal andere toepassingen, platforms, services en printers. Het is ontwikkeld om de beperkingen en problemen in andere 3D bestandsindelingen, zoals STL, te vermijden voor het werken met de nieuwste versies van 3D printers. 3MF is een relatief nieuw bestandsformaat dat is ontwikkeld en gepubliceerd door het 3MF-consortium.

    Meer lezen

    Andere ondersteunde app om activa uit formaten te extraheren

    Met behulp van C# kan One ook middelen extraheren uit vele andere bestandsindelingen, waaronder.

    3DS (3D Studio Mesh-bestandsindeling)
    AMF (Additief productieformaat)
    ASE (2D-animatiebestand)
    DAE (Digitale activauitwisseling)
    DXF (Tekening uitwisselingsformaat)
    DRC (Google Draco)
    FBX (3D Formaat)
    GLB (3D Binaire weergave van bestand)
    GLTF (GL-verzendformaat)
    JT (Jupiter Tessellation-bestand)
    OBJ (3D Bestandsindeling)
    PLY (Polygoon-bestandsindeling)
    PDF (3D PDF)
    RVM (AVEVA Plant Design Model)
    STL (Verwisselbare 3D oppervlaktegeometrie)
    U3D (Universal 3D)
    VRML (Virtual Reality-modelleringstaal)
    X (DirectX-modelafbeelding)
    USD (Universele scènebeschrijving)
    USDZ (Universele scènebeschrijving Zip-archief)