BBox.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
 
#ifndef CVCORE_BBOX_H
#define CVCORE_BBOX_H
 
#include <algorithm>
#include <stdexcept>
#include <utility>
 
namespace cvcore {
 
struct BBox
{
    int xmin{0}; 
    int ymin{0}; 
    int xmax{0}; 
    int ymax{0}; 
    BBox clamp(const BBox &clampBox) const
    {
        BBox outbox;
        outbox.xmin = std::max(clampBox.xmin, xmin);
        outbox.xmax = std::min(clampBox.xmax, xmax);
        outbox.ymin = std::max(clampBox.ymin, ymin);
        outbox.ymax = std::min(clampBox.ymax, ymax);
        return outbox;
    }
 
    size_t getWidth() const
    {
        return xmax - xmin;
    }
 
    size_t getHeight() const
    {
        return ymax - ymin;
    }
 
    bool isValid() const
    {
        return (xmin < xmax) && (ymin < ymax) && (getWidth() > 0) && (getHeight() > 0);
    }
 
    std::pair<int, int> getCenter() const
    {
        int centerX = xmin + getWidth() / 2;
        int centerY = ymin + getHeight() / 2;
        return std::pair<int, int>(centerX, centerY);
    }
 
    BBox scale(float scaleW, float scaleH) const
    {
        auto center = getCenter();
        float newW  = getWidth() * scaleW;
        float newH  = getHeight() * scaleH;
        BBox outbox;
        outbox.xmin = center.first - newW / 2;
        outbox.xmax = center.first + newW / 2;
        outbox.ymin = center.second - newH / 2;
        outbox.ymax = center.second + newH / 2;
 
        return outbox;
    }
 
    BBox squarify(const BBox &clampBox) const
    {
        size_t w = getWidth();
        size_t h = getHeight();
 
        BBox clampedBox1 = clamp(clampBox);
        if (!clampedBox1.isValid())
        {
            throw std::range_error("Invalid bounding box generated\n");
        }
        float scaleW     = static_cast<float>(std::max(w, h)) / w;
        float scaleH     = static_cast<float>(std::max(w, h)) / h;
        BBox scaledBBox  = clampedBox1.scale(scaleW, scaleH);
        BBox clampedBox2 = scaledBBox.clamp(clampBox);
        if (!clampedBox2.isValid())
        {
            throw std::range_error("Invalid bounding box generated\n");
        }
        size_t newW      = clampedBox2.getWidth();
        size_t newH      = clampedBox2.getHeight();
        size_t minW      = std::min(newH, newW);
        clampedBox2.ymax = clampedBox2.ymin + minW;
        clampedBox2.xmax = clampedBox2.xmin + minW;
        return clampedBox2;
    }
};
 
} // namespace cvcore
#endif // CVCORE_BBOX_H