ROI.hpp

// This file is part of the AliceVision project.
// Copyright (c) 2022 AliceVision contributors.
// This Source Code Form is subject to the terms of the Mozilla Public License,
// v. 2.0. If a copy of the MPL was not distributed with this file,
// You can obtain one at https://mozilla.org/MPL/2.0/.
 
#pragma once
 
// allows code sharing between NVCC and other compilers
#if defined(__NVCC__)
    #define CUDA_HOST_DEVICE __host__ __device__
    #define CUDA_HOST __host__
    #define CUDA_CEIL(f) ceil(f)
    #define CUDA_FLOOR(f) floor(f)
    #define CUDA_MIN(a, b) min(a, b)
    #define CUDA_MAX(a, b) max(a, b)
#elif defined(ACPP_LIBKERNEL_IS_DEVICE_PASS)
    #include <aliceVision/depthMap_sycl/sycl/sycl.hpp>
    #define CUDA_HOST_DEVICE
    #define CUDA_HOST
    #define CUDA_CEIL(f) sycl::ceil(f)
    #define CUDA_FLOOR(f) sycl::floor(f)
    #define CUDA_MIN(a, b) sycl::min(a, b)
    #define CUDA_MAX(a, b) sycl::max(a, b)
#else
    #define CUDA_HOST_DEVICE
    #define CUDA_HOST
    #define CUDA_CEIL(f) std::ceil(f)
    #define CUDA_FLOOR(f) std::floor(f)
    #define CUDA_MIN(a, b) std::min(a, b)
    #define CUDA_MAX(a, b) std::max(a, b)
    #include <algorithm>
    #include <cmath>
    #include <ostream>
#endif
 
namespace aliceVision {
 
/*
 * @struct Range
 * @brief Small CPU and GPU host / device struct describing a 1d range.
 */
struct Range
{
    unsigned int begin = 0;
    unsigned int end = 0;
 
    // default constructor
    Range() = default;
 
    CUDA_HOST_DEVICE Range(unsigned int in_begin, unsigned int in_end)
      : begin(in_begin),
        end(in_end)
    {}
 
    CUDA_HOST_DEVICE inline unsigned int size() const { return end - begin; }
 
    CUDA_HOST_DEVICE inline bool isEmpty() const { return begin >= end; }
 
    CUDA_HOST inline bool contains(unsigned int i) const { return ((begin <= i) && (end > i)); }
};
 
inline Range intersect(const Range& a, const Range& b) { return Range(CUDA_MAX(a.begin, b.begin), CUDA_MIN(a.end, b.end)); }
 
/*
 * @struct ROI
 * @brief Small CPU and GPU host / device struct describing a rectangular 2d region of interest.
 */
struct ROI
{
    Range x, y;
 
    // default constructor
    ROI() = default;
 
    CUDA_HOST_DEVICE ROI(unsigned int in_beginX, unsigned int in_endX, unsigned int in_beginY, unsigned int in_endY)
      : x(in_beginX, in_endX),
        y(in_beginY, in_endY)
    {}
 
    CUDA_HOST_DEVICE ROI(const Range& in_rangeX, const Range& in_rangeY)
      : x(in_rangeX),
        y(in_rangeY)
    {}
 
    CUDA_HOST_DEVICE inline unsigned int width() const { return x.size(); }
 
    CUDA_HOST_DEVICE inline unsigned int height() const { return y.size(); }
 
    CUDA_HOST_DEVICE inline bool isEmpty() const { return x.isEmpty() || y.isEmpty(); }
 
    CUDA_HOST inline bool contains(unsigned int in_x, unsigned int in_y) const { return (x.contains(in_x) && y.contains(in_y)); }
};
 
CUDA_HOST inline bool checkImageROI(const ROI& roi, int width, int height)
{
    return ((roi.x.end <= (unsigned int)(width)) && (roi.x.begin < roi.x.end) && (roi.y.end <= (unsigned int)(height)) && (roi.y.begin < roi.y.end));
}
 
CUDA_HOST inline Range downscaleRange(const Range& range, float downscale)
{
    return Range(CUDA_FLOOR(range.begin / downscale), CUDA_CEIL(range.end / downscale));
}
 
CUDA_HOST inline Range upscaleRange(const Range& range, float upscale)
{
    return Range(CUDA_FLOOR(range.begin * upscale), CUDA_CEIL(range.end * upscale));
}
 
CUDA_HOST inline Range inflateRange(const Range& range, float factor)
{
    const float midRange = range.begin + (range.size() * 0.5f);
    const float inflateSize = range.size() * factor * 0.5f;
    return Range(CUDA_FLOOR(CUDA_MAX(midRange - inflateSize, 0.f)), CUDA_CEIL(midRange + inflateSize));
}
 
CUDA_HOST inline ROI downscaleROI(const ROI& roi, float downscale) { return ROI(downscaleRange(roi.x, downscale), downscaleRange(roi.y, downscale)); }
 
CUDA_HOST inline ROI upscaleROI(const ROI& roi, float upscale) { return ROI(upscaleRange(roi.x, upscale), upscaleRange(roi.y, upscale)); }
 
CUDA_HOST inline ROI inflateROI(const ROI& roi, float factor) { return ROI(inflateRange(roi.x, factor), inflateRange(roi.y, factor)); }
 
inline ROI intersect(const ROI& a, const ROI& b) { return ROI(intersect(a.x, b.x), intersect(a.y, b.y)); }
 
#if !defined(__NVCC__)
inline std::ostream& operator<<(std::ostream& os, const Range& range)
{
    os << range.begin << "-" << range.end;
    return os;
}
inline std::ostream& operator<<(std::ostream& os, const ROI& roi)
{
    os << "x: " << roi.x << ", y: " << roi.y;
    return os;
}
#endif
 
}  // namespace aliceVision