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

Middelen extraheren uit ASE via C#

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

Middelen extraheren uit ASE-bestand met C#

Om items uit het ASE-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 ASE te extraheren via C#

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

  • Laad ASE 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 ASE te extraheren


//Bronbestanden die activa moeten extraheren
string file = "template.ase";
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 ASE te extraheren

    Bekijk onze live demo's om Extractor ASE 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 ASE en klik op de knop "Uitpakken"
      Download ASE bestand via de link, indien nodig

    ASE Wat is ASE bestandsformaat

    Een ASE-bestand is een 2D-animatie of -afbeelding die lagen, frames, paletten, tags en instellingen bevat.

    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.

    3MF (3D Productie-indeling)
    AMF (Additief productieformaat)
    3DS (3D Studio Mesh-bestandsindeling)
    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)