read_normalized_at() [1/2]

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

Read one element as a normalised double, with optional range remapping.

Same as read_normalized_at, but if range is provided, the value is linearly remapped from [range.min, range.max] to [0.0, 1.0]. Values outside the range are clamped to 0.0 or 1.0.

Parameters

v	Source variant.
format	Pixel format governing the uint16 interpretation.
range	Optional value range for remapping.
elem_index	Element index. Returns 0.0 when out of range.

Definition at line 166 of file PixelStorage.cpp.

{
    return std::visit(
        [&](const auto& vec) -> double {
            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 0.0;
 
                double raw {};
                double type_max = 1.0;
 
                if constexpr (std::is_same_v<T, uint8_t>) {
                    raw = static_cast<double>(vec[elem_index]);
                    type_max = 255.0;
                } else if constexpr (std::is_same_v<T, uint16_t>) {
                    if (is_float_format(format)) {
                        raw = static_cast<double>(decode_half(vec[elem_index]));
                    } else {
                        raw = static_cast<double>(vec[elem_index]);
                        type_max = 65535.0;
                    }
                } else {
                    raw = static_cast<double>(vec[elem_index]);
                }
 
                if (!range)
                    return raw / type_max;
 
                if (range->invalid && raw == *range->invalid)
                    return std::numeric_limits<double>::quiet_NaN();
 
                const double span = range->max - range->min;
                if (span <= 0.0)
                    return 0.0;
 
                return std::clamp((raw - range->min) / span, 0.0, 1.0);
            } else {
                return 0.0;
            }
        },
        v);
}

References format, and is_float_format().

Referenced by MayaFlux::Kakshya::VideoStreamContainer::get_value_impl(), and read_normalized_at().

Here is the call graph for this function:

Here is the caller graph for this function: