write_normalized_at() [1/2]

MAYAFLUX_API void MayaFlux::Kakshya::write_normalized_at	(	DataVariant &	v,
		ImageFormat	format,
		const std::optional< DataDimension::ValueRange > &	range,
		size_t	elem_index,
		double	value
	)

Write one element from a normalised double, with optional range remapping.

Inverse of read_normalized_at, with clamping on the integer paths. If range is provided, the value is linearly remapped from [0.0, 1.0] to [range.min, range.max] before writing. Out-of-range indices are ignored.

Parameters

v	Destination variant.
format	Pixel format governing the uint16 interpretation.
range	Optional value range for remapping.
elem_index	Element index.
value	Normalised value.

Definition at line 222 of file PixelStorage.cpp.

{
    std::visit(
        [&](auto& vec) {
            using T = typename std::decay_t<decltype(vec)>::value_type;
 
            if constexpr (std::is_same_v<T, uint8_t>
                || std::is_same_v<T, uint16_t>
                || std::is_same_v<T, float>) {
 
                if (elem_index >= vec.size())
                    return;
 
                double raw {};
 
                if (range) {
                    if (std::isnan(value)) {
                        if (!range->invalid)
                            return;
                        raw = *range->invalid;
                    } else {
                        raw = range->min
                            + std::clamp(value, 0.0, 1.0) * (range->max - range->min);
                    }
                } else if constexpr (std::is_same_v<T, uint8_t>) {
                    raw = std::clamp(value * 255.0, 0.0, 255.0);
                } else if constexpr (std::is_same_v<T, uint16_t>) {
                    raw = is_float_format(format)
                        ? value
                        : std::clamp(value * 65535.0, 0.0, 65535.0);
                } else {
                    raw = value;
                }
 
                if constexpr (std::is_same_v<T, uint8_t>) {
                    vec[elem_index] = static_cast<uint8_t>(std::clamp(raw, 0.0, 255.0));
                } else if constexpr (std::is_same_v<T, uint16_t>) {
                    if (is_float_format(format)) {
                        vec[elem_index] = encode_half(static_cast<float>(raw));
                    } else {
                        vec[elem_index] = static_cast<uint16_t>(std::clamp(raw, 0.0, 65535.0));
                    }
                } else {
                    vec[elem_index] = static_cast<float>(raw);
                }
            }
        },
        v);
}

References format, is_float_format(), and value.

Referenced by MayaFlux::Kakshya::VideoStreamContainer::set_value_impl(), and write_normalized_at().

Here is the call graph for this function:

Here is the caller graph for this function: