This example shows how to use the Reduction processor with a visibility cameras generated from an arbitrary geometry.

// Copyright (c) Microsoft Corporation. 
// Licensed under the MIT license. 

#include <string>
#include <stdlib.h>
#include <filesystem>
#include <future>
#include "SimplygonLoader.h"


Simplygon::spScene LoadScene(Simplygon::ISimplygon* sg, const char* path)
{
	Simplygon::spScene sgScene;
	Simplygon::spSceneImporter sgSceneImporter = sg->CreateSceneImporter();

	sgSceneImporter->SetImportFilePath(path);
	bool sucess =sgSceneImporter->RunImport();
	if (!sucess)
	{
		throw std::exception("Failed to load scene.");
	}
	sgScene =sgSceneImporter->GetScene();
	return sgScene;
}

void RunReduction(Simplygon::ISimplygon* sg)
{
	// Load scene to process 
	Simplygon::spScene sgScene =LoadScene(sg,"./../Assets/ObscuredTeapot/ObscuredTeapot.obj");
	// Load camera gemometry 
	Simplygon::spScene sgSceneGeometryCamera =LoadScene(sg,"./../Assets/ObscuredTeapot/CameraMesh.obj");
	// Select Mesh Nodes 
	int selectionSetId =sgSceneGeometryCamera->SelectNodes("ISceneMesh");
	Simplygon::spSelectionSetTable sgSelectionSetsTable =sgSceneGeometryCamera->GetSelectionSetTable();
	Simplygon::spSelectionSet selectionSceneMeshes =sgSelectionSetsTable->GetSelectionSet(selectionSetId);
	auto itemCount =selectionSceneMeshes->GetItemCount();
	Simplygon::spSelectionSet cameraSelectionSet =sg->CreateSelectionSet();
	// Copy each mesh from camera scene into a scene and created a camera selection set based on those 
	// ids. 
	for (auto meshIndex=0U; meshIndex<itemCount; ++meshIndex)
	{
		Simplygon::spString meshNodeId =selectionSceneMeshes->GetItem(meshIndex);
		Simplygon::spSceneNode sceneNode =sgSceneGeometryCamera->GetNodeByGUID(meshNodeId);
		Simplygon::spSceneMesh sceneMesh = Simplygon::spSceneMesh::SafeCast(sceneNode);
		Simplygon::spGeometryData geom =sceneMesh->GetGeometry();
		Simplygon::spSceneMesh cameraMesh =sgScene->GetRootNode()->CreateChildMesh(geom);

		Simplygon::spString nodeId =cameraMesh->GetNodeGUID();
		cameraSelectionSet->AddItem(nodeId);
	}

	int cameraSelectionSetId =sgScene->GetSelectionSetTable()->AddSelectionSet(cameraSelectionSet);

	// Create the reduction processor. 
	Simplygon::spReductionProcessor sgReductionProcessor = sg->CreateReductionProcessor();

	// Get settings objects 
	Simplygon::spReductionSettings sgReductionSettings = sgReductionProcessor->GetReductionSettings();
	Simplygon::spVisibilitySettings sgVisibilitySettings = sgReductionProcessor->GetVisibilitySettings();

	// Set camera selection set id with 
	sgVisibilitySettings->SetCameraSelectionSetID( cameraSelectionSetId );

	// Setup visibility setting enable GPU based computation, 
	sgVisibilitySettings->SetUseVisibilityWeightsInReducer( true );
	sgVisibilitySettings->SetUseVisibilityWeightsInTexcoordGenerator( false );
	sgVisibilitySettings->SetComputeVisibilityMode( Simplygon::EComputeVisibilityMode::DirectX );
	sgVisibilitySettings->SetConservativeMode( false );
	sgVisibilitySettings->SetCullOccludedGeometry( true );
	sgVisibilitySettings->SetFillNonVisibleAreaThreshold( 0.0f );
	sgVisibilitySettings->SetRemoveTrianglesNotOccludingOtherTriangles( false );
	sgVisibilitySettings->SetUseBackfaceCulling( true );

	// Set reduction target to triangle ratio with a ratio of 50%. 
	sgReductionSettings->SetReductionTargetTriangleRatio( 0.5f );

	sgReductionProcessor->SetScene( sgScene );

	// Start the reduction process. 
	sgReductionProcessor->RunProcessing();

	Simplygon::spSceneExporter  sgSceneExporter = sg->CreateSceneExporter();
	sgSceneExporter->SetScene(sgScene);
	sgSceneExporter->SetExportFilePath( "ReductionOutput.fbx" );
	if(!sgSceneExporter->RunExport())
		throw std::exception("Failed to save ReductionOutput.fbx.");

}

int main()
{
	Simplygon::ISimplygon* sg = NULL;
	Simplygon::EErrorCodes initval = Simplygon::Initialize( &sg );
	if( initval != Simplygon::EErrorCodes::NoError )
	{
		return int(initval);
	}

	RunReduction(sg);

	Simplygon::Deinitialize(sg);

	return 0;
}

// Copyright (c) Microsoft Corporation. 
// Licensed under the MIT license. 

using System;
using System.IO;
using System.Threading.Tasks;

public class Program
{
    static Simplygon.spScene LoadScene(Simplygon.ISimplygon sg, string path)
    {
        Simplygon.spScene sgScene;
        using (Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter())
        {
            sgSceneImporter.SetImportFilePath(path);
            bool sucess =sgSceneImporter.RunImport();
            if (!sucess)
            {
                throw new System.Exception("Failed to load scene.");
            }
            sgScene =sgSceneImporter.GetScene();
        }
        return sgScene;
    }
    static void RunReduction(Simplygon.ISimplygon sg)
    {
        // Load scene to process 
        Simplygon.spScene sgScene =LoadScene(sg,"./../Assets/ObscuredTeapot/ObscuredTeapot.obj");
        // Load camera gemometry 
        Simplygon.spScene sgSceneGeometryCamera =LoadScene(sg,"./../Assets/ObscuredTeapot/CameraMesh.obj");
        // Select Mesh Nodes 
        int selectionSetId =sgSceneGeometryCamera.SelectNodes("ISceneMesh");
        Simplygon.spSelectionSetTable sgSelectionSetsTable =sgSceneGeometryCamera.GetSelectionSetTable();
        Simplygon.spSelectionSet selectionSceneMeshes =sgSelectionSetsTable.GetSelectionSet(selectionSetId);
        var itemCount =selectionSceneMeshes.GetItemCount();
        Simplygon.spSelectionSet cameraSelectionSet =sg.CreateSelectionSet();
        // Copy each mesh from camera scene into a scene and created a camera selection set based on those 
        // ids. 
        for (uint meshIndex=0; meshIndex<itemCount; ++meshIndex)
        {
            string meshNodeId =selectionSceneMeshes.GetItem(meshIndex);
            Simplygon.spSceneNode sceneNode =sgSceneGeometryCamera.GetNodeByGUID(meshNodeId);
            Simplygon.spSceneMesh sceneMesh = Simplygon.spSceneMesh.SafeCast(sceneNode);
            Simplygon.spGeometryData geom =sceneMesh.GetGeometry();
            Simplygon.spSceneMesh cameraMesh =sgScene.GetRootNode().CreateChildMesh(geom);

            string nodeId =cameraMesh.GetNodeGUID();
            cameraSelectionSet.AddItem(nodeId);
        }

        int cameraSelectionSetId =sgScene.GetSelectionSetTable().AddSelectionSet(cameraSelectionSet);

        // Create the reduction processor. 
        using (Simplygon.spReductionProcessor sgReductionProcessor = sg.CreateReductionProcessor())
        {
            // Get settings objects 
            using (Simplygon.spReductionSettings sgReductionSettings = sgReductionProcessor.GetReductionSettings())
            using (Simplygon.spVisibilitySettings sgVisibilitySettings = sgReductionProcessor.GetVisibilitySettings())
            {
                // Set camera selection set id with 
                sgVisibilitySettings.SetCameraSelectionSetID( cameraSelectionSetId );

                // Setup visibility setting enable GPU based computation, 
                sgVisibilitySettings.SetUseVisibilityWeightsInReducer( true );
                sgVisibilitySettings.SetUseVisibilityWeightsInTexcoordGenerator( false );
                sgVisibilitySettings.SetComputeVisibilityMode( Simplygon.EComputeVisibilityMode.DirectX );
                sgVisibilitySettings.SetConservativeMode( false );
                sgVisibilitySettings.SetCullOccludedGeometry( true );
                sgVisibilitySettings.SetFillNonVisibleAreaThreshold( 0.0f );
                sgVisibilitySettings.SetRemoveTrianglesNotOccludingOtherTriangles( false );
                sgVisibilitySettings.SetUseBackfaceCulling( true );

                // Set reduction target to triangle ratio with a ratio of 50%. 
                sgReductionSettings.SetReductionTargetTriangleRatio( 0.5f );

            }
            sgReductionProcessor.SetScene( sgScene );

            // Start the reduction process. 
            sgReductionProcessor.RunProcessing();

        }
        using (Simplygon.spSceneExporter sgSceneExporter = sg.CreateSceneExporter())
        {
            sgSceneExporter.SetScene(sgScene);
            sgSceneExporter.SetExportFilePath( "ReductionOutput.fbx" );
            if(!sgSceneExporter.RunExport())
                throw new System.Exception("Failed to save ReductionOutput.fbx.");

        }
    }
    static int Main(string[] args)
    {
        using (var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage))
        {
            if (errorCode != Simplygon.EErrorCodes.NoError)
                return (int)errorCode;
            RunReduction(sg);
        }

        return 0;
    }
}

# Copyright (c) Microsoft Corporation. 
# Licensed under the MIT license. 

import math
import os
import sys
import glob
import gc
import threading

from pathlib import Path
from simplygon import simplygon_loader
from simplygon import Simplygon


def LoadScene(sg: Simplygon.ISimplygon, path: str):
    sgSceneImporter = sg.CreateSceneImporter()

    sgSceneImporter.SetImportFilePath(path);
    sucess =sgSceneImporter.RunImport();
    if not sucess:
        raise Exception('Failed to load scene.')
    sgScene =sgSceneImporter.GetScene();
    return sgScene

def RunReduction(sg: Simplygon.ISimplygon):
    # Load scene to process 
    sgScene =LoadScene(sg,"./../Assets/ObscuredTeapot/ObscuredTeapot.obj");
    # Load camera gemometry 
    sgSceneGeometryCamera =LoadScene(sg,"./../Assets/ObscuredTeapot/CameraMesh.obj");
    # Select Mesh Nodes 
    selectionSetId =sgSceneGeometryCamera.SelectNodes("ISceneMesh");
    sgSelectionSetsTable =sgSceneGeometryCamera.GetSelectionSetTable();
    selectionSceneMeshes =sgSelectionSetsTable.GetSelectionSet(selectionSetId);
    itemCount =selectionSceneMeshes.GetItemCount();
    cameraSelectionSet =sg.CreateSelectionSet();
    # Copy each mesh from camera scene into a scene and created a camera selection set based on those 
    # ids. 
    for meshIndex in range(itemCount):
        meshNodeId =selectionSceneMeshes.GetItem(meshIndex);
        sceneNode =sgSceneGeometryCamera.GetNodeByGUID(meshNodeId);
        sceneMesh = Simplygon.spSceneMesh.SafeCast(sceneNode);
        geom =sceneMesh.GetGeometry();
        cameraMesh =sgScene.GetRootNode().CreateChildMesh(geom);

        nodeId =cameraMesh.GetNodeGUID();
        cameraSelectionSet.AddItem(nodeId);

    cameraSelectionSetId =sgScene.GetSelectionSetTable().AddSelectionSet(cameraSelectionSet);

    # Create the reduction processor. 
    sgReductionProcessor = sg.CreateReductionProcessor()

    # Get settings objects 
    sgReductionSettings = sgReductionProcessor.GetReductionSettings()
    sgVisibilitySettings = sgReductionProcessor.GetVisibilitySettings()

    # Set camera selection set id with 
    sgVisibilitySettings.SetCameraSelectionSetID( cameraSelectionSetId )

    # Setup visibility setting enable GPU based computation, 
    sgVisibilitySettings.SetUseVisibilityWeightsInReducer( True )
    sgVisibilitySettings.SetUseVisibilityWeightsInTexcoordGenerator( False )
    sgVisibilitySettings.SetComputeVisibilityMode( Simplygon.EComputeVisibilityMode_DirectX )
    sgVisibilitySettings.SetConservativeMode( False )
    sgVisibilitySettings.SetCullOccludedGeometry( True )
    sgVisibilitySettings.SetFillNonVisibleAreaThreshold( 0.0 )
    sgVisibilitySettings.SetRemoveTrianglesNotOccludingOtherTriangles( False )
    sgVisibilitySettings.SetUseBackfaceCulling( True )

    # Set reduction target to triangle ratio with a ratio of 50%. 
    sgReductionSettings.SetReductionTargetTriangleRatio( 0.5 )

    sgReductionProcessor.SetScene( sgScene )

    # Start the reduction process. 
    sgReductionProcessor.RunProcessing()

    sgSceneExporter = sg.CreateSceneExporter()
    sgSceneExporter.SetScene(sgScene)
    sgSceneExporter.SetExportFilePath( 'ReductionOutput.fbx' )
    if not sgSceneExporter.RunExport():
        raise Exception('Failed to save ReductionOutput.fbx.')


if __name__ == '__main__':
    sg = simplygon_loader.init_simplygon()
    if sg is None:
        exit(Simplygon.GetLastInitializationError())

    RunReduction(sg)

    sg = None
    gc.collect()