geom_opencv.h

Go to the documentation of this file.

//
//  geom_opencv.h
//  ConscienceRobotManager
//
//  Created by Louis Grignon on 19/08/2025.
//  Copyright © 2025 IliesZaoui. All rights reserved.
//
 
#ifndef geom_opencv_h
#define geom_opencv_h
 
#include <cmath>
 
#include "geom.h"
#include <opencv2/opencv.hpp>
 
namespace conscience_utils::geom {
 
double getIntersectionOverUnion(const cv::Rect2d &bb1, const cv::Rect2d &bb2);
 
template <typename T>
bool isIncludedInOther(const cv::Rect_<T> &rect1, const cv::Rect_<T> &rect2) {
    cv::Point_<T> tl1 = rect1.tl();
    cv::Point_<T> br1 = rect1.br();
    if (tl1.inside(rect2) && br1.inside(rect2)) {
        return true;
    }
 
    cv::Point_<T> tl2 = rect2.tl();
    cv::Point_<T> br2 = rect2.br();
    if (tl2.inside(rect1) && br2.inside(rect1)) {
        return true;
    }
 
    return false;
}
 
template <typename T>
cv::Point_<T> rectangleCenter(const cv::Rect_<T> &rect) {
    return cv::Point_<T>(rect.x + rect.width / 2.0, rect.y + rect.height / 2.0);
}
 
template <typename T>
T distanceBetween(const cv::Point_<T> &point, const cv::Point_<T> &point2) {
    return sqrt(pow(point2.x - point.x, 2) + pow(point2.y - point.y, 2));
}
 
template <typename T>
inline cv::Point_<T> pointsCenter(const cv::Point_<T> &point, const cv::Point_<T> &point2) {
    return cv::Point_<T>((point.x + point2.x) / 2.0, (point.y + point2.y) / 2.0);
}
 
template <typename T>
T distanceBetween(const cv::Rect_<T> &rectangle1, const cv::Rect_<T> &rectangle2) {
    return distanceBetween(rectangleCenter(rectangle1), rectangleCenter(rectangle2));
}
 
template <typename T>
string rectToString(const cv::Rect_<T> &rect) {
    return "[" + to_string(rect.x) + ", " + to_string(rect.y) + " w=" + to_string(rect.width) + " h=" + to_string(rect.height) + "]";
}
 
template <typename T>
string pointToString(const cv::Point_<T> &point) {
    return "[" + to_string(point.x) + ", " + to_string(point.y) + "]";
}
 
template <typename T>
string sizeToString(const cv::Size_<T> &size) {
    return "[w=" + to_string(size.width) + ",h=" + to_string(size.height) + "]";
}
 
template <typename T>
cv::Rect_<T> averageRectangle(const vector<cv::Rect_<T>> &rectangles) {
    T x = 0;
    T y = 0;
    T width = 0;
    T height = 0;
 
    for (auto rectangle : rectangles) {
        x += rectangle.x;
        y += rectangle.y;
        width += rectangle.width;
        height += rectangle.height;
    }
 
    x /= rectangles.size();
    y /= rectangles.size();
    width /= rectangles.size();
    height /= rectangles.size();
 
    return cv::Rect_<T>(x, y, width, height);
}
 
template <typename T>
bool equals(const cv::Size_<T> &size1, const cv::Size_<T> &size2) {
    return size1.width == size2.width && size1.height == size2.height;
}
 
bool isRotationMatrix(const cv::Mat &R);
cv::Vec3f rotationMatrixToEulerAngles(const cv::Mat &R);
 
void rotateMatrix(const cv::Mat &src, double angleDegrees, cv::Mat &target, cv::Scalar fillColor = cv::Scalar(255, 255, 255));
 
template <typename T>
double anglePointsInRad(const cv::Point_<T> &point, const cv::Point_<T> &point2) {
    double hypotenuse = distanceBetween(point, point2);
    double adjacent = point2.x - point.x;
    double angle = acos(adjacent / hypotenuse);
    return angle;
}
 
bool matIsEqual(const cv::Mat &img1, const cv::Mat &img2);
 
}
 
#endif