Add Noise Model

Noise (facade)
  └── NoiseModel (abstract base)
        ├── GaussianNoiseModel (standard + dynamic bias)
        └── CustomNoiseModel (extends Gaussian, range-binned, XML-parameterized)

/*
 * Copyright (c) 2026 LG Electronics Inc.
 *
 * SPDX-License-Identifier: MIT
 */

using System;

public class MyNoiseModel : NoiseModel
{
	// Custom parameters
	private readonly double _myParam;

	public MyNoiseModel(in SDFormat.Noise parameter)
		: base(parameter)
	{
		// Extract parameters from SDFormat.Noise or custom fields
		_myParam = parameter.StdDev; // or a custom parameter
	}

	public override T Generate<T>(T data, float deltaTime)
	{
		var value = Convert.ToDouble(data);

		// Apply your noise model
		var noise = ComputeNoise(value, deltaTime);
		var output = value + bias + noise;

		// Apply quantization if enabled
		if (_quantized)
		{
			if (Math.Abs(_parameter.Precision - 0d) > Epsilon)
			{
				output = Math.Round(output / _parameter.Precision) * _parameter.Precision;
			}
		}

		// Apply clamping
		return (T)Convert.ChangeType(Clamp(output), typeof(T));
	}

	private double ComputeNoise(double value, float deltaTime)
	{
		// Your noise algorithm here
		// Use RandomNumberGenerator for RNG:
		var random = RandomNumberGenerator.GetNormal(0, _myParam);
		return random;
	}
}

public Noise(in SDFormat.Noise noise)
{
	switch (noise.Type)
	{
		case SDFormat.NoiseType.Gaussian:
		case SDFormat.NoiseType.GaussianQuantized:
			_noiseModel = new GaussianNoiseModel(noise);
			if (noise.Type == SDFormat.NoiseType.GaussianQuantized)
				_noiseModel.SetQuantization(true);
			break;

		case SDFormat.NoiseType.MyType:  // Add new case
			_noiseModel = new MyNoiseModel(noise);
			break;

		default:
			_noiseModel = null;
			break;
	}
}

// In the sensor device class:
private Noise _noise;

public void SetupNoise(in SDFormat.Noise noise)
{
	_noise = new Noise(noise);
	_noise.SetClampMin(0);        // optional: clamp minimum
	_noise.SetClampMax(maxRange); // optional: clamp maximum
}

// Apply to single value:
protected override void GenerateMessage()
{
	float value = ReadSensorValue();
	_noise.Apply<float>(ref value, Time.fixedDeltaTime);
	_msg.Value = value;
}

// Apply to array (parallelized automatically):
protected override void GenerateMessage()
{
	float[] data = ReadSensorArray();
	_noise.Apply<float>(data, Time.fixedDeltaTime);
}

// Available in base class:
protected readonly SDFormat.Noise _parameter;  // Original SDF noise parameters
protected double bias;                          // Sampled bias (from BiasMean/BiasStdDev)
protected bool _quantized;                      // Whether to quantize output
protected double clampMin, clampMax;            // Output clamping bounds

// Methods:
protected double Clamp(in double value);        // Apply clamping
protected double Expm1(in double value);        // exp(x) - 1 helper

// Static RNG:
RandomNumberGenerator.GetNormal(mean, stddev);  // Box-Muller Gaussian
RandomNumberGenerator.GetNormal();              // Standard normal (0, 1)
RandomNumberGenerator.GetUniform();             // Uniform [0, 1)

// Available if extending GaussianNoiseModel:
protected double ComputeDynamicBias(in float deltaTime)
{
	// Uses _parameter.DynamicBiasStdDev and DynamicBiasCorrelationTime
	// Returns time-varying bias using Ornstein-Uhlenbeck process
}

// In a camera device:
_noiseMaterial = new Material(Shader.Find("Sensor/Camera/GaussianNoise"));
_noiseMaterial.SetFloat("_Mean", mean);
_noiseMaterial.SetFloat("_StdDev", stddev);

// Applied via CommandBuffer blit in the camera's render pipeline

// Thread count: max(1, ProcessorCount / 4)
Parallel.For(0, data.Length, _parallelOptions, i =>
{
    data[i] = _noiseModel.Generate(data[i], deltaTime);
});