Ontwikkelgids voor markeren

De LCC Unity SDK ondersteunt bewerkingsbewerkingen zoals markeren en knippen op 3DGS-scènes. Deze gids behandelt markeer gerelateerde bewerkingen: het selecteren van een gebied via 2D-geprojecteerde texturen, 3D-geometrie of een combinatie van beide, zodat het geselecteerde gebied wordt gemarkeerd, met ondersteuning voor normale selectie en omgekeerde selectie.

Opmerking:
De huidige markeerfunctie is slechts een runtime-weergave-effect; het wijzigt het oorspronkelijke gegevensbestand op geen enkele manier en ondersteunt het opslaan of exporteren van het bewerkingsresultaat niet. Gebruik de XGRIDS LCC Editor-softwaretool als je kleuraanpassing, knippen en opslaan van gegevens nodig hebt.
Als je de gegevens niet wilt wijzigen, kun je de bewerkingen ook opnemen en ze de volgende keer na het laden van de gegevens opnieuw afspelen.

Vereisten

Het markeren van een scène via de SDK vereist de volgende voorwaarden:

Ga vóór het laden van de gegevens naar de bewerkstatus. De SDK bevindt zich standaard in de browse-status (View), die de beste prestaties biedt en wordt aanbevolen voor normaal browsen. Schakel voor bewerkingsbewerkingen zoals markeren via SetEditorMode(true) naar de bewerkstatus voordat je Load aanroept. Deze methode werkt alleen als deze wordt aangeroepen vóór het laden van alle gegevens.
Voer de markeerbewerking uit nadat de gegevens zijn geladen. De markeerinterface moet worden aangeroepen nadat de scènegegevens volledig zijn geladen.

Stap 1: De scène opzetten

Bereid de GameObjects voor die nodig zijn voor markeren in de scène, zoals hieronder wordt weergegeven.

Scènehiërarchiestructuur voor het markeervoorbeeld

Main Camera: de scènecamera; 2D-markering gebruikt de view- en projectiematrices ervan.
LCCManager: een leeg GameObject met een genormaliseerde Transform, waaraan het LCCManager-script is toegevoegd.
LCCRenderer: een leeg GameObject met de Transform ingesteld op Rotation.x = -90, Scale.x = -1 (uitgelijnd met het coördinatensysteem van de LCC-gegevens), gebruikt om het later te schrijven Highlight-script aan toe te voegen.
3D-selectiegeometrie: hulpobjecten voor 3D-markering. Het voorbeeld bevat 3 Cubes (Box1, Box2, Box3) en 1 Sphere (Clipsphere); door deze objecten te verplaatsen en te schalen, wordt de positie en grootte van de markeerselectie bepaald.

Opmerking:
Raadpleeg voor instellingen met betrekking tot de rendercamera, LCCManager en LCCRenderer-GameObjects de relevante secties van Snelstartgids voor pc en Optimalisatiegids voor projectinstellingen.

Selectiegeometrie die wordt gebruikt voor 3D-markering (Box1 / Box2 / Box3 / Clipsphere)

Stap 2: De gegevensstructuren begrijpen

Bij markeren zijn drie bewerkingsmethoden betrokken — 2D, 3D en 2D/3D gemengd. De gebruikte enums en structs zijn als volgt.

public enum SelectMode    { normal, invert, clip }  // normale selectie, inverteren, realtime knippen
public enum OperationMode { normal, erase }         // normale selectie, selectie wissen
public enum ShapeType     { box, sphere }           // 3D Box-selectie, 3D Sphere-selectie
public enum EditType      { Edit2D, Edit3D }        // 2D-bewerking, 3D-bewerking

// 2D-textuurselectie
public struct Data2D
{
    public Texture2D texture;   // 2D-maskertextuur
    public Matrix4x4 mv;        // cameraviewmatrix
    public Matrix4x4 mvp;       // cameraview-projectiematrix
    public SelectMode mode;     // selectiemodus
}

// 3D-geometrieselectie
public struct Data3D
{
    public ShapeType type;          // geometrietype (box / sphere)
    public Matrix4x4 invMat;        // world-to-local (inverse) matrix van de geometrie
    public OperationMode operation; // bewerkingstype (normale vereniging / wissen verschil)
    public SelectMode mode;         // selectiemodus
}

// 2D / 3D gemengde selectie
public struct DataMix
{
    public EditType editType;       // bewerkingstype (vereist; bepaalt of 2D- of 3D-velden worden gebruikt)
    public Texture2D texture;       // 2D-maskertextuur (gebruikt door Edit2D)
    public Matrix4x4 mv;            // cameraviewmatrix (gebruikt door Edit2D)
    public Matrix4x4 mvp;           // cameraview-projectiematrix (gebruikt door Edit2D)
    public ShapeType type;          // geometrietype (gebruikt door Edit3D)
    public Matrix4x4 invMat;        // inverse matrix van de geometrie (gebruikt door Edit3D)
    public OperationMode operation; // bewerkingstype (gebruikt door Edit3D)
    public SelectMode mode;         // selectiemodus (vereist)
}

Er zijn drie punten om op te letten bij de selectielijst:

De lijst is geordend. Of het nu 2D of 3D is, items in de lijst worden op volgorde van kracht; zorg ervoor dat de volgorde van toevoegen overeenkomt met je verwachting.
Inverteren is een bewerkingsopdracht en hoeft niet te worden gekoppeld aan specifieke selectiegegevens. Voeg eenvoudig een item toe met mode = SelectMode.invert om het momenteel geselecteerde gebied te inverteren.
Het maximumaantal items in één lijst is 255. Bij overschrijding wordt een foutcode geretourneerd.

Stap 3: De markeer-API's begrijpen

Alle markeer gerelateerde interfaces worden geleverd door LCCManager, waaronder drie SetHighlight-overloads en één afsluitmethode.

SetHighlight (2D-textuurmarkering)

// Retourwaarde: int
// 0: succes
// 1: lijst is null of heeft 0 elementen
// 2: lijstelementen overschrijden het maximum van 255
public int SetHighlight(List<Data2D> _2Ds)

Markeert de scène met behulp van een 2D-geprojecteerd textuurmasker; het deel buiten het gemarkeerde gebied wordt gedimd.

SetHighlight (3D-geometriemarkering)

// Retourwaarde: int
// 0: succes
// 1: lijst is null of heeft 0 elementen
// 2: lijstelementen overschrijden het maximum van 255
// 3: het aantal selectiegeometrieën is 0
public int SetHighlight(List<Data3D> _3Ds)

Definieert het markeergebied met behulp van 3D-geometrie (balk, kubus, bol), met ondersteuning voor combinaties van vereniging en verschil. Er is ten minste één geometrie met operation == OperationMode.normal vereist.

SetHighlight (gemengde-modusmarkering)

// Retourwaarde: int
// 0: succes
// 1: lijst is null of heeft 0 elementen
// 2: lijstelementen overschrijden het maximum van 255
public int SetHighlight(List<DataMix> _Mix)

Definieert het markeergebied met behulp van 2D-texturen en 3D-geometrie tegelijk; elk item bepaalt via editType of het als 2D of 3D wordt verwerkt.

QuitHighlightMode

// Retourwaarde: void
public void QuitHighlightMode()

Sluit de markeermodus af en herstelt de normale weergave van de scène.

Tip:
De drie SetHighlight-overloads sluiten elkaar uit. Roep bij het wisselen van markeermethode of het wissen van de huidige markering eerst QuitHighlightMode() aan en stel vervolgens de nieuwe markering in.

Stap 4: Specificatie van de 2D-maskertextuur

2D-markering beschrijft de selectie via een maskertextuur en ondersteunt diverse selectiemethoden zoals vierhoeken, driehoeken, penselen en lasso's — markeer eenvoudig de overeenkomstige pixels in de textuur met de geselecteerde waarde. Bij 2D-bewerkingen moet de camera worden vergrendeld en moet de textuur vanuit een vast gezichtspunt worden gemarkeerd. De textuur- en pixelwaarden volgen deze conventies:

De textuur is vast op 1024 × 1024, R8 enkel kanaal, geen Mipmap, puntfiltering (FilterMode.Point) en geklemde sampling (TextureWrapMode.Clamp).
Conventies voor pixelwaarden:

Pixelwaarde	Betekenis
`128`	Standaard (niet geselecteerd)
`240`	Geselecteerd
`180`	Deselecteren (het al geselecteerde gebied wissen)
`0`	Knippen

In een markeerscenario worden doorgaans alleen de twee waarden 128 (standaard) en 240 (geselecteerd) gebruikt.

Stap 5: Het script schrijven

Maak een nieuw C#-script aan met de naam Highlight.cs. Voltooi eerst het basisskelet: ga in Start naar de bewerkstatus en laad de gegevens; stel na het laden de laadmarkering in zodat de latere markeermethoden deze kunnen controleren.

using LCCCore;
using System.Collections.Generic;
using UnityEngine;

public class Highlight : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath;
    public GameObject m_Box1;
    public GameObject m_Box2;
    public GameObject m_Box3;
    public GameObject m_Clipsphere;

    private LCCCore.Renderer m_renderer;
    private Camera m_camera;
    private bool m_isLoaded = false;

    void Start()
    {
        m_camera = Camera.main;
        m_manager.SetPlatformType(PlatformType.PC);

        // Ga naar de bewerkmodus; moet vóór Load worden aangeroepen
        m_manager.SetEditorMode(true);

        m_renderer = m_manager.GetRender(this.transform);
        if (m_renderer == null)
            Debug.LogError("GetRender mislukt, controleer of de manager correct is ingesteld en of het bestandspad geldig is.");

        m_renderer.Load(m_FilePath, onLoadProgress, onLoadCallback);
    }

    private void onLoadProgress(float value)
    {
        Debug.Log($"laadvoortgang: {value}");
    }

    private void onLoadCallback()
    {
        Debug.Log("gegevens geladen !!!");
        m_isLoaded = true;
    }

    // 2D / 3D / gemengde markeermethoden hieronder
}

Opmerking:
SetEditorMode(true) moet vóór Load worden aangeroepen om van kracht te worden; en SetHighlight moet worden aangeroepen nadat de gegevens zijn geladen (nadat de onLoadCallback-callback is geactiveerd).

Stap 6: Het script toevoegen en eigenschappen instellen

Voeg het Highlight.cs-script toe aan het LCCRenderer-GameObject.
Sleep in het Inspector-venster het LCCManager-GameObject naar de eigenschap Manager van het script.
Vul het LCC-bestandspad in bij de eigenschap File Path.
Sleep Box1, Box2, Box3 en Clipsphere in de scène respectievelijk naar de bijbehorende eigenschappen van het script.

Stel de eigenschappen van het Highlight-script in de Inspector in

Stap 7: Voorbeelden van markeerbewerkingen

Voeg de onderstaande methoden toe aan de klasse Highlight en roep de bijbehorende methode na het uitvoeren en na het laden van de gegevens aan.

2D-textuurmarkering

Maak twee R8-maskertexturen, markeer de te markeren pixels als 240 en de rest als 128, maak vervolgens Data2D met de cameramatrices en voeg deze toe aan de lijst.

public void on2DHighlight()
{
    // Textuurgrootte is vast op 1024*1024; houd de overige eigenschappen gelijk aan het voorbeeld
    Texture2D _texture = new Texture2D(1024, 1024, TextureFormat.R8, false);
    _texture.filterMode = FilterMode.Point;
    _texture.wrapMode = TextureWrapMode.Clamp;

    int _count = 1024 * 1024;
    int _half = _count / 2;
    byte[] _values = new byte[_count];
    for (int i = 0; i < _count; i++)
    {
        if (i < _half)
            _values[i] = 240;    // 240 betekent geselecteerd, 128 betekent standaard, 0 betekent knippen
        else
            _values[i] = 128;
    }
    _texture.SetPixelData(_values, 0);

    Texture2D _texture2 = new Texture2D(1024, 1024, TextureFormat.R8, false);
    _texture2.filterMode = FilterMode.Point;
    _texture2.wrapMode = TextureWrapMode.Clamp;
    byte[] _values2 = new byte[_count];
    for (int i = 0; i < _count; i++)
    {
        if (i > _count * 0.75 && i < _count * 0.9)
            _values2[i] = 240;
        else
            _values2[i] = 128;
    }
    _texture2.SetPixelData(_values2, 0);

    List<Data2D> _2Ds = new List<Data2D>();
    Data2D _2d01 = new Data2D();
    _2d01.mv = m_camera.worldToCameraMatrix;
    _2d01.texture = _texture;
    _2d01.mode = SelectMode.normal;
    _2d01.mvp = GL.GetGPUProjectionMatrix(m_camera.projectionMatrix, true) * m_camera.worldToCameraMatrix;
    _2Ds.Add(_2d01);

    Data2D _2d02 = new Data2D();
    _2d02.mv = m_camera.worldToCameraMatrix;
    _2d02.texture = _texture2;
    _2d02.mode = SelectMode.normal;
    _2d02.mvp = GL.GetGPUProjectionMatrix(m_camera.projectionMatrix, true) * m_camera.worldToCameraMatrix;
    _2Ds.Add(_2d02);

    m_manager.SetHighlight(_2Ds);
}

Code-uitleg: er worden twee maskertexturen opgebouwd. Het eerste masker selecteert de onderste helft van het scherm (de schermoorsprong is de linkerbenedenhoek) en het tweede masker selecteert het 0.75 tot 0.9-gebied van de bovenste helft van het scherm. Het voorbeeldeffect is als volgt.

In de praktijk kun je verschillende selectietools zoals rechthoeken, driehoeken, penselen en lasso's gebruiken om de overeenkomstige posities op het masker te selecteren.

Effect van 2D-textuurmarkering

3D-geometriemarkering

Gebruik de worldToLocalMatrix van de geometrie als de selectie-inversematrix, combineer vereniging (normal) en verschil (erase) via operation, en implementeer omgekeerde selectie via een item met mode = SelectMode.invert.

public void on3DHighlight()
{
    List<Data3D> _3Ds = new List<Data3D>();
    var _mat1 = m_Box1.transform.worldToLocalMatrix;
    var _mat2 = m_Box2.transform.worldToLocalMatrix;
    var _mat3 = m_Box3.transform.worldToLocalMatrix;
    var _mat4 = m_Clipsphere.transform.worldToLocalMatrix;

    // Box-selectie
    Data3D _3d01 = new Data3D();
    _3d01.type = ShapeType.box;
    _3d01.operation = OperationMode.normal;
    _3d01.mode = SelectMode.normal;
    _3d01.invMat = _mat1;
    _3Ds.Add(_3d01);

    Data3D _3d02 = new Data3D();
    _3d02.type = ShapeType.box;
    _3d02.operation = OperationMode.normal;
    _3d02.mode = SelectMode.normal;
    _3d02.invMat = _mat2;
    _3Ds.Add(_3d02);

    // Sphere-selectie
    Data3D _3d04 = new Data3D();
    _3d04.type = ShapeType.sphere;
    _3d04.operation = OperationMode.normal;
    _3d04.mode = SelectMode.normal;
    _3d04.invMat = _mat4;
    _3Ds.Add(_3d04);

    // Box/Sphere wissen (verschil)
    Data3D _3d03 = new Data3D();
    _3d03.type = ShapeType.box;
    _3d03.operation = OperationMode.erase;
    _3d03.mode = SelectMode.normal;
    _3d03.invMat = _mat3;
    _3Ds.Add(_3d03);

    // Inverteren
    //Data3D _3d05 = new Data3D();
    //_3d05.mode = SelectMode.invert;
    //_3Ds.Add(_3d05);

    m_manager.SetHighlight(_3Ds);
}

Code-uitleg: er worden 4 geometrieën gebruikt, waarbij Box1, Box2 en Sphere normale selecties zijn en Box3 een wisselectie is, dat wil zeggen het wissen van het eerder geselecteerde gebied. Met de inverteren-gerelateerde code uitgecommentarieerd is het voorbeeldeffect als volgt:

Effect van 3D-geometriemarkering

Haal het commentaar van de inverteren-code weg zodat inverteren van kracht wordt; het voorbeeldeffect is als volgt. Inverteren draait het eerder geselecteerde gebied om; het is een opdracht en hoeft niet te worden gekoppeld aan bewerkingsgegevens.

Let er vooral op dat de lijst geordend is; verschillende bewerkingsstappen produceren verschillende eindeffecten.

Effect van 3D-geometrie + inverteren markering

Gemengde-modusmarkering

Meng 2D-textuur- en 3D-geometrie-items in dezelfde lijst; elk item geeft via editType zijn verwerkingsmethode op.

public void onMixHighlight()
{
    // --- Voorbereiding van 2D-selectie ---
    // Textuurgrootte is vast op 1024*1024; houd de overige eigenschappen gelijk aan het voorbeeld
    Texture2D _texture = new Texture2D(1024, 1024, TextureFormat.R8, false);
    _texture.filterMode = FilterMode.Point;
    _texture.wrapMode = TextureWrapMode.Clamp;

    int _count = 1024 * 1024;
    int _half = _count / 2;
    byte[] _values = new byte[_count];
    for (int i = 0; i < _count; i++)
    {
        if (i < _half)
            _values[i] = 128;    // 128 betekent standaard, 240 betekent geselecteerd, 0 betekent knippen
        else
            _values[i] = 240;
    }
    _texture.SetPixelData(_values, 0);

    List<DataMix> _Mixs = new List<DataMix>();
    DataMix _mix01 = new DataMix();
    _mix01.editType = EditType.Edit2D;
    _mix01.mv = m_camera.worldToCameraMatrix;
    _mix01.texture = _texture;
    _mix01.mode = SelectMode.normal;
    _mix01.mvp = GL.GetGPUProjectionMatrix(m_camera.projectionMatrix, true) * m_camera.worldToCameraMatrix;
    _Mixs.Add(_mix01);

    // --- Voorbereiding van 3D-selectie ---
    var _mat1 = m_Box1.transform.worldToLocalMatrix;
    var _mat2 = m_Box2.transform.worldToLocalMatrix;
    var _mat3 = m_Box3.transform.worldToLocalMatrix;
    var _mat4 = m_Clipsphere.transform.worldToLocalMatrix;

    // Box-selectie
    DataMix _mix02 = new DataMix();
    _mix02.editType = EditType.Edit3D;
    _mix02.type = ShapeType.box;
    _mix02.operation = OperationMode.normal;
    _mix02.mode = SelectMode.normal;
    _mix02.invMat = _mat1;
    _Mixs.Add(_mix02);

    DataMix _mix03 = new DataMix();
    _mix03.editType = EditType.Edit3D;
    _mix03.type = ShapeType.box;
    _mix03.operation = OperationMode.normal;
    _mix03.mode = SelectMode.normal;
    _mix03.invMat = _mat2;
    _Mixs.Add(_mix03);

    // Sphere-selectie
    DataMix _mix04 = new DataMix();
    _mix04.editType = EditType.Edit3D;
    _mix04.type = ShapeType.sphere;
    _mix04.operation = OperationMode.normal;
    _mix04.mode = SelectMode.normal;
    _mix04.invMat = _mat4;
    _Mixs.Add(_mix04);

    // Box/Sphere wissen (verschil)
    DataMix _mix05 = new DataMix();
    _mix05.editType = EditType.Edit3D;
    _mix05.type = ShapeType.box;
    _mix05.operation = OperationMode.erase;
    _mix05.mode = SelectMode.normal;
    _mix05.invMat = _mat3;
    _Mixs.Add(_mix05);

    // Inverteren (naar behoefte inschakelen)
    DataMix _mix06 = new DataMix();
    _mix06.editType = EditType.Edit3D;
    _mix06.type = ShapeType.box;
    _mix06.mode = SelectMode.invert;
    //_Mixs.Add(_mix06);

    m_manager.SetHighlight(_Mixs);
}

Code-uitleg: er worden 4 geometrieën en 1 2D-textuur gebruikt, waarmee 2D- en 3D-gemengde verwerking mogelijk is. Het voorbeeldeffect is als volgt:

Effect van gemengde-modusmarkering

Stap 8: Markeren afsluiten

Roep QuitHighlightMode() aan om de huidige markering te wissen en de normale weergave van de scène te herstellen.

public void onClearHighlight()
{
    m_manager.QuitHighlightMode();
}

Belangrijkste stappen

De belangrijkste stappen voor het markeren van een 3DGS-scène:

Roep SetEditorMode(true) vóór het laden van de gegevens aan om naar de bewerkstatus te gaan.
Roep SetHighlight nadat de gegevens zijn geladen aan (nadat de onLoadCallback-callback is geactiveerd, of geactiveerd via een knop/gebeurtenis).
Kies naar behoefte 2D-textuur, 3D-geometrie of gemengde modus en zorg ervoor dat de volgorde van toevoegen van de selectielijst overeenkomt met je verwachting.
De 2D-maskertextuur is vast op 1024 × 1024, R8 enkel kanaal; vul de pixelwaarden volgens conventie in (128 standaard, 240 geselecteerd).
Roep bij het wissen of wisselen van markeringen eerst QuitHighlightMode() aan.