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)
{
	// Create scene importer 
	Simplygon::spSceneImporter sgSceneImporter = sg->CreateSceneImporter();
	sgSceneImporter->SetImportFilePath(path);
	
	// Run scene importer. 
	bool importResult = sgSceneImporter->RunImport();
	if (!importResult)
	{
		throw std::exception("Failed to load scene.");
	}
	Simplygon::spScene sgScene = sgSceneImporter->GetScene();
	return sgScene;
}

void SaveScene(Simplygon::ISimplygon* sg, Simplygon::spScene sgScene, const char* path)
{
	// Create scene exporter. 
	Simplygon::spSceneExporter sgSceneExporter = sg->CreateSceneExporter();
	sgSceneExporter->SetExportFilePath(path);
	sgSceneExporter->SetScene(sgScene);
	
	// Run scene exporter. 
	bool exportResult = sgSceneExporter->RunExport();
	if (!exportResult)
	{
		throw std::exception("Failed to save scene.");
	}
}

void CheckLog(Simplygon::ISimplygon* sg)
{
	// Check if any errors occurred. 
	bool hasErrors = sg->ErrorOccurred();
	if (hasErrors)
	{
		Simplygon::spStringArray errors = sg->CreateStringArray();
		sg->GetErrorMessages(errors);
		auto errorCount = errors->GetItemCount();
		if (errorCount > 0)
		{
			printf("%s\n", "Errors:");
			for (auto errorIndex = 0U; errorIndex < errorCount; ++errorIndex)
			{
				Simplygon::spString errorString = errors->GetItem((int)errorIndex);
				printf("%s\n", errorString.c_str());
			}
			sg->ClearErrorMessages();
		}
	}
	else
	{
		printf("%s\n", "No errors.");
	}
	
	// Check if any warnings occurred. 
	bool hasWarnings = sg->WarningOccurred();
	if (hasWarnings)
	{
		Simplygon::spStringArray warnings = sg->CreateStringArray();
		sg->GetWarningMessages(warnings);
		auto warningCount = warnings->GetItemCount();
		if (warningCount > 0)
		{
			printf("%s\n", "Warnings:");
			for (auto warningIndex = 0U; warningIndex < warningCount; ++warningIndex)
			{
				Simplygon::spString warningString = warnings->GetItem((int)warningIndex);
				printf("%s\n", warningString.c_str());
			}
			sg->ClearWarningMessages();
		}
	}
	else
	{
		printf("%s\n", "No warnings.");
	}
}

void RunReduction(Simplygon::ISimplygon* sg)
{
	// Load scene to process. 	
	printf("%s\n", "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. 	
	printf("%s\n", "Start the reduction process.");
	sgReductionProcessor->RunProcessing();
	
	// Save processed scene. 	
	printf("%s\n", "Save processed scene.");
	SaveScene(sg, sgScene, "Output.fbx");
	
	// Check log for any warnings or errors. 	
	printf("%s\n", "Check log for any warnings or errors.");
	CheckLog(sg);
}

int main()
{
	Simplygon::ISimplygon* sg = NULL;
	Simplygon::EErrorCodes initval = Simplygon::Initialize( &sg );
	if( initval != Simplygon::EErrorCodes::NoError )
	{
		printf( "Failed to initialize Simplygon: ErrorCode(%d)", (int)initval );
		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)
    {
        // Create scene importer 
        using Simplygon.spSceneImporter sgSceneImporter = sg.CreateSceneImporter();
        sgSceneImporter.SetImportFilePath(path);
        
        // Run scene importer. 
        bool importResult = sgSceneImporter.RunImport();
        if (!importResult)
        {
            throw new System.Exception("Failed to load scene.");
        }
        Simplygon.spScene sgScene = sgSceneImporter.GetScene();
        return sgScene;
    }
    static void SaveScene(Simplygon.ISimplygon sg, Simplygon.spScene sgScene, string path)
    {
        // Create scene exporter. 
        using Simplygon.spSceneExporter sgSceneExporter = sg.CreateSceneExporter();
        sgSceneExporter.SetExportFilePath(path);
        sgSceneExporter.SetScene(sgScene);
        
        // Run scene exporter. 
        bool exportResult = sgSceneExporter.RunExport();
        if (!exportResult)
        {
            throw new System.Exception("Failed to save scene.");
        }
    }
    static void CheckLog(Simplygon.ISimplygon sg)
    {
        // Check if any errors occurred. 
        bool hasErrors = sg.ErrorOccurred();
        if (hasErrors)
        {
            Simplygon.spStringArray errors = sg.CreateStringArray();
            sg.GetErrorMessages(errors);
            var errorCount = errors.GetItemCount();
            if (errorCount > 0)
            {
                Console.WriteLine("Errors:");
                for (uint errorIndex = 0; errorIndex < errorCount; ++errorIndex)
                {
                    string errorString = errors.GetItem((int)errorIndex);
                    Console.WriteLine(errorString);
                }
                sg.ClearErrorMessages();
            }
        }
        else
        {
            Console.WriteLine("No errors.");
        }
        
        // Check if any warnings occurred. 
        bool hasWarnings = sg.WarningOccurred();
        if (hasWarnings)
        {
            Simplygon.spStringArray warnings = sg.CreateStringArray();
            sg.GetWarningMessages(warnings);
            var warningCount = warnings.GetItemCount();
            if (warningCount > 0)
            {
                Console.WriteLine("Warnings:");
                for (uint warningIndex = 0; warningIndex < warningCount; ++warningIndex)
                {
                    string warningString = warnings.GetItem((int)warningIndex);
                    Console.WriteLine(warningString);
                }
                sg.ClearWarningMessages();
            }
        }
        else
        {
            Console.WriteLine("No warnings.");
        }
    }
    static void RunReduction(Simplygon.ISimplygon sg)
    {
        // Load scene to process.         
        Console.WriteLine("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.         
        Console.WriteLine("Start the reduction process.");
        sgReductionProcessor.RunProcessing();
        
        // Save processed scene.         
        Console.WriteLine("Save processed scene.");
        SaveScene(sg, sgScene, "Output.fbx");
        
        // Check log for any warnings or errors.         
        Console.WriteLine("Check log for any warnings or errors.");
        CheckLog(sg);
    }
    static int Main(string[] args)
    {
        using var sg = Simplygon.Loader.InitSimplygon(out var errorCode, out var errorMessage);
        if (errorCode != Simplygon.EErrorCodes.NoError)
        {
            Console.WriteLine( $"Failed to initialize Simplygon: ErrorCode({(int)errorCode}) {errorMessage}" );
            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):
    # Create scene importer 
    sgSceneImporter = sg.CreateSceneImporter()
    sgSceneImporter.SetImportFilePath(path)
    
    # Run scene importer. 
    importResult = sgSceneImporter.RunImport()
    if not importResult:
        raise Exception('Failed to load scene.')
    sgScene = sgSceneImporter.GetScene()
    return sgScene

def SaveScene(sg: Simplygon.ISimplygon, sgScene:Simplygon.spScene, path: str):
    # Create scene exporter. 
    sgSceneExporter = sg.CreateSceneExporter()
    sgSceneExporter.SetExportFilePath(path)
    sgSceneExporter.SetScene(sgScene)
    
    # Run scene exporter. 
    exportResult = sgSceneExporter.RunExport()
    if not exportResult:
        raise Exception('Failed to save scene.')

def CheckLog(sg: Simplygon.ISimplygon):
    # Check if any errors occurred. 
    hasErrors = sg.ErrorOccurred()
    if hasErrors:
        errors = sg.CreateStringArray()
        sg.GetErrorMessages(errors)
        errorCount = errors.GetItemCount()
        if errorCount > 0:
            print("Errors:")
            for errorIndex in range(errorCount):
                errorString = errors.GetItem(errorIndex)
                print(errorString)
            sg.ClearErrorMessages()
    else:
        print("No errors.")
    
    # Check if any warnings occurred. 
    hasWarnings = sg.WarningOccurred()
    if hasWarnings:
        warnings = sg.CreateStringArray()
        sg.GetWarningMessages(warnings)
        warningCount = warnings.GetItemCount()
        if warningCount > 0:
            print("Warnings:")
            for warningIndex in range(warningCount):
                warningString = warnings.GetItem(warningIndex)
                print(warningString)
            sg.ClearWarningMessages()
    else:
        print("No warnings.")

def RunReduction(sg: Simplygon.ISimplygon):
    # Load scene to process.     
    print("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.     
    print("Start the reduction process.")
    sgReductionProcessor.RunProcessing()
    
    # Save processed scene.     
    print("Save processed scene.")
    SaveScene(sg, sgScene, "Output.fbx")
    
    # Check log for any warnings or errors.     
    print("Check log for any warnings or errors.")
    CheckLog(sg)

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

    RunReduction(sg)

    sg = None
    gc.collect()