hash_vision_step()

size_t MayaFlux::Kinesis::Vision::hash_vision_step ( VisionOp  op, const VisionParams &  params  )

inline

Hash a VisionStep's op and parameters together.

Keys GPU dispatch memoization on VisionPass::completed, which spans one walk including any suspensions. Two steps hashing equal are treated as interchangeable, so every field that changes the output must be hashed.

Definition at line 621 of file VisionOp.hpp.

{
    size_t seed = std::hash<std::string_view> {}(Reflect::enum_to_string(op));
 
    std::visit([&seed](const auto& p) {
        using T = std::decay_t<decltype(p)>;
        if constexpr (std::is_same_v<T, std::monostate>) {
        } else if constexpr (std::is_same_v<T, ThresholdParams>) {
            hash_combine(seed, std::hash<float> {}(p.value));
            hash_combine(seed, std::hash<uint8_t> {}(static_cast<uint8_t>(p.channels)));
            for (const auto& band : p.bands) {
                hash_combine(seed, std::hash<float> {}(band.lo));
                hash_combine(seed, std::hash<float> {}(band.hi));
            }
        } else if constexpr (std::is_same_v<T, ThresholdAdaptiveParams>) {
            hash_combine(seed, std::hash<uint32_t> {}(p.block_size));
            hash_combine(seed, std::hash<float> {}(p.offset));
            hash_combine(seed, std::hash<uint8_t> {}(static_cast<uint8_t>(p.channels)));
        } else if constexpr (std::is_same_v<T, OtsuParams>) {
            hash_combine(seed, std::hash<uint8_t> {}(static_cast<uint8_t>(p.channels)));
        } else if constexpr (std::is_same_v<T, NormalizeRangeParams>) {
            hash_combine(seed, std::hash<float> {}(p.lo));
            hash_combine(seed, std::hash<float> {}(p.hi));
        } else if constexpr (std::is_same_v<T, GaussianBlurParams>) {
            hash_combine(seed, std::hash<float> {}(p.sigma));
        } else if constexpr (std::is_same_v<T, FilterSeparableParams>) {
            for (float v : p.kernel_x)
                hash_combine(seed, std::hash<float> {}(v));
            for (float v : p.kernel_y)
                hash_combine(seed, std::hash<float> {}(v));
        } else if constexpr (std::is_same_v<T, CannyParams>) {
            hash_combine(seed, std::hash<float> {}(p.sigma));
            hash_combine(seed, std::hash<float> {}(p.low_threshold));
            hash_combine(seed, std::hash<float> {}(p.high_threshold));
        } else if constexpr (std::is_same_v<T, MorphParams>) {
            hash_combine(seed, std::hash<uint32_t> {}(p.radius));
        } else if constexpr (std::is_same_v<T, HarrisParams>) {
            hash_combine(seed, std::hash<float> {}(p.k));
            hash_combine(seed, std::hash<float> {}(p.sigma));
            hash_region(seed, p.region);
        } else if constexpr (std::is_same_v<T, ExtractPeaksParams>) {
            hash_combine(seed, std::hash<float> {}(p.threshold));
            hash_combine(seed, std::hash<uint32_t> {}(p.nms_radius));
            hash_combine(seed, std::hash<bool> {}(p.export_keypoints));
            hash_region(seed, p.region);
        } else if constexpr (std::is_same_v<T, TrackKeypointsParams>) {
            hash_combine(seed, std::hash<uint32_t> {}(p.window_radius));
            hash_combine(seed, std::hash<uint32_t> {}(p.max_iterations));
            hash_combine(seed, std::hash<float> {}(p.eigen_threshold));
            hash_combine(seed, std::hash<float> {}(p.error_threshold));
            hash_combine(seed, std::hash<uint32_t> {}(p.levels));
            hash_combine(seed, std::hash<uint32_t> {}(p.max_points));
            hash_combine(seed, std::hash<float> {}(p.min_distance));
            hash_combine(seed, std::hash<float> {}(p.forward_backward_threshold));
            hash_combine(seed, std::hash<bool> {}(p.export_tracks));
            hash_combine(seed, std::hash<bool> {}(p.host_tracks));
        } else if constexpr (std::is_same_v<T, FindContoursParams>) {
            hash_combine(seed, std::hash<float> {}(p.min_area));
            hash_combine(seed, std::hash<uint32_t> {}(p.max_contours));
            hash_combine(seed, std::hash<uint32_t> {}(p.max_points_per_contour));
            hash_combine(seed, std::hash<bool> {}(p.as_image));
            hash_combine(seed, std::hash<bool> {}(p.export_contours_buffer));
        } else if constexpr (std::is_same_v<T, ConnectedComponentsParams>) {
            hash_combine(seed, std::hash<bool> {}(p.export_labels));
            hash_combine(seed, std::hash<bool> {}(p.with_colors));
            hash_combine(seed, std::hash<bool> {}(p.export_boxes));
            hash_combine(seed, std::hash<bool> {}(p.export_label_buffer));
        } else if constexpr (std::is_same_v<T, OpticalFlowDenseParams>) {
            hash_combine(seed, std::hash<uint32_t> {}(p.window_radius));
            hash_combine(seed, std::hash<uint32_t> {}(p.iterations));
            hash_combine(seed, std::hash<uint32_t> {}(p.levels));
            hash_combine(seed, std::hash<float> {}(p.eigen_threshold));
            hash_combine(seed, std::hash<float> {}(p.max_step));
            hash_combine(seed, std::hash<bool> {}(p.visualize));
            hash_combine(seed, std::hash<float> {}(p.visual_range));
            hash_combine(seed, std::hash<float> {}(p.visual_min_motion));
        } else if constexpr (std::is_same_v<T, ConfineParams>) {
            hash_combine(seed, std::hash<float> {}(p.bounds.x));
            hash_combine(seed, std::hash<float> {}(p.bounds.y));
            hash_combine(seed, std::hash<float> {}(p.bounds.w));
            hash_combine(seed, std::hash<float> {}(p.bounds.h));
            hash_combine(seed, std::hash<bool> {}(p.resize_to_source));
        }
    },
        params);
 
    return seed;
}

References MayaFlux::Reflect::enum_to_string(), hash_combine(), and hash_region().

Referenced by MayaFlux::Yantra::VisionGpuExecutor::run().

Here is the call graph for this function:

Here is the caller graph for this function: