HTML JPG PDF XML STL

STL

Eszközök kinyerése innen: STL a következőn keresztül: C#

Készítse el saját .NET alkalmazásait, hogy kivonja az eszközöket STL fájlokból szerveroldali API-k segítségével.

Eszközök kibontása a STL fájlból a C# használatával

Ahhoz, hogy a(z) STL fájlból kivonjuk az elemeket, a következőt használjuk:

Aspose.3D for .NET

API, amely funkciókban gazdag, hatékony és könnyen használható API a C# platformhoz, amelyet az elemek kivonatával lehet használni. Nyisd ki

NuGet

csomagkezelő, keressen Aspose.3D és telepítse. A következő parancsot is használhatja a Package Manager konzolból.

Csomagkezelő konzolparancs
PM> Install-Package Aspose.3D

Lépések az eszközök kinyeréséhez innen: STL a következőn keresztül: C#

A Aspose.3D segítségével a fejlesztők egyszerűen kinyerhetik az elemeket a STL fájlból, mindössze néhány sornyi kóddal.

STL fájl betöltése a Scene osztály konstruktorán keresztül- Hozzon létre zip fájlformátum objektumot kimeneti fájlformátumként- Hozzon létre archív osztályt, és kezelje az eszközosztály kivonatát- Hívja meg az Extract metódust, és mentse el a fájlt

rendszerkövetelmények

A(z) Aspose.3D for .NET minden nagyobb operációs rendszeren támogatott. Csak győződjön meg arról, hogy rendelkezik a következő előfeltételekkel.

Microsoft Windows vagy egy kompatibilis operációs rendszer .NET Framework, .NET Core, Mono- Fejlesztői környezet, például a Microsoft Visual Studio- A projektben hivatkozott Aspose.3D for .NET

C# kód az eszközök kinyeréséhez innen: STL
//Forrásfájlok, amelyeknek ki kell bontania az eszközöket
string file = "template.stl";
Scene scene = new Scene(file);  

//A kimenet tömörített fájlformátumú, a könyvtár pedig egy meglévő mappa nevét jelöli
var zipOutput = Path.Combine("Directory", "OutputFile.zip");
using var output = new FileStream(zipOutput, FileMode.Create);
using var za = new Zip(output);

//Hívja meg az Extract metódust eszközkinyerési műveletek végrehajtásához
Extract(scene,za,true);

//Hívható kivonatolási módszer, A paraméter textúrája jelzi: ki kell-e bontani a textúrát
private void Extract(Scene scene, Zip za,bool texture)
{
    var extractor = new Extractor(za,texture);
    extractor.Extract(scene);
}

//Hozzon létre egy tömörített fájlfeldolgozási osztályt
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;
        }
    }
}

//Hozzon létre egy eszközkinyerési feldolgozási osztályt
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);
    }
}

Körülbelül Aspose.3D for .NET API

A Aspose.3D egy CAD és egy Gameware API, amely 3D fájlok betöltésére, módosítására és konvertálására szolgál. A API önálló, és nem igényel semmilyen 3D modellező vagy megjelenítő szoftvert. A API egyszerűen használható a következőhöz: Discreet3DS, WavefrontOBJ, STL (ASCII, bináris), Universal3D, FBX (ASCII, bináris), Collada, glTF, PLY, GLB, DirectX és további formátumok.

Ingyenes alkalmazás eszközök kinyerésére innen: STL

Tekintse meg élő bemutatóinkat Kivonó STL a következő előnyökkel.

Nem kell letölteni vagy beállítani semmit

Nem kell kódot írni vagy fordítani

Csak töltsön fel STL fájlt, és nyomja meg a "Kicsomagolás" gombot

Ha szükséges, töltsön le STL fájlt a linkről

STL Mi a STL fájlformátum

A STL, a sztereolitrográfia rövidítése, egy felcserélhető fájlformátum, amely háromdimenziós felületi geometriát képvisel. A fájlformátumot számos területen használják, például a gyors prototípuskészítésben, a 3D nyomtatásban és a számítógéppel segített gyártásban. A felületet kis háromszögek sorozataként ábrázolja, amelyeket lapoknak nevezünk, ahol minden oldalt egy merőleges irány és három pont ír le, amelyek a háromszög csúcsait képviselik.

Bővebben

Egyéb támogatott alkalmazások az eszközök formátumokból való kinyerésére

A C# használatával sok más fájlformátumból is kivonhatók az eszközök, beleértve a.

3MF (3D Gyártási formátum)

AMF (Additív gyártási formátum)

ASE (2D animációs fájl)

DAE (Digitális Eszközcsere)

DXF (Rajzcsere formátum)

DRC (Google Draco)

FBX (3D Formátum)

GLB (3D Fájl bináris megjelenítése)

GLTF (GL átviteli formátum)

JT (Jupiter Testszellációs Fájl)

OBJ (3D Fájlformátum)

PLY (Sokszög fájlformátum)

PDF (3D PDF)

RVM (AVEVA üzemtervezési modell)

3DS (3D Studio Mesh fájlformátum)

U3D (Universal 3D)

VRML (Virtuális valóság modellező nyelv)

x (DirectX modell képe)

USD (Univerzális jelenetleírás)

USDZ (Universal Scene Description Zip Archive)