helpersSynthesis.cpp

#include"../include/helpersSynthesis.h"
 
 
 
 
std::vector<uint32_t> generate_picture_EBO(const cv::Size& s)
{
    const size_t W = s.width;
    const size_t H = s.height;
 
    size_t elements_number = 3 * 2 * (H - 1) * (W - 1);
    std::vector<uint32_t> indices;
    indices.resize(elements_number);
 
    size_t offset = 0;
    for (size_t y = 0; y < H - 1; ++y)
    {
        for (size_t x = 0; x < W - 1; ++x)
        {
            indices[3 * INDEX_E(x, y, (W - 1)) + 0] = uint32_t(INDEX_E(x, y, W));
            indices[3 * INDEX_E(x, y, (W - 1)) + 1] = uint32_t(INDEX_E(x + 1, y, W));
            indices[3 * INDEX_E(x, y, (W - 1)) + 2] = uint32_t(INDEX_E(x, y + 1, W));
            offset += 3;
        }
    }
 
    for (size_t y = 1; y < H; ++y)
    {
        for (size_t x = 0; x < W - 1; ++x)
        {
            indices[offset + 3 * INDEX_E(x, y - 1, (W - 1)) + 0] = uint32_t(INDEX_E(x, y, W));
            indices[offset + 3 * INDEX_E(x, y - 1, (W - 1)) + 1] = uint32_t(INDEX_E(x + 1, y - 1, W));
            indices[offset + 3 * INDEX_E(x, y - 1, (W - 1)) + 2] = uint32_t(INDEX_E(x + 1, y, W));
        }
    }
 
    printf("Real number of elements %i\n", int(elements_number));
    return indices;
}
 
cv::Matx33f rotationMatrixFromRotationAroundX(float rx)
{
    return cv::Matx33f(
        1.f, 0.f, 0.f,
        0.f, cos(rx), -sin(rx),
        0.f, sin(rx), cos(rx));
}
 
cv::Matx33f rotationMatrixFromRotationAroundY(float ry)
{
    return cv::Matx33f(
        cos(ry), 0.f, sin(ry),
        0.f, 1.f, 0.f,
        -sin(ry), 0.f, cos(ry));
}
 
cv::Matx33f rotationMatrixFromRotationAroundZ(float rz)
{
    return cv::Matx33f(
        cos(rz), -sin(rz), 0.f,
        sin(rz), cos(rz), 0.f,
        0.f, 0.f, 1.f);
}
 
cv::Matx33f EulerAnglesToRotationMatrix(cv::Vec3f rotation)
{
    // /!\ should be in rad !!!!!!!!!!!!!!!
    //for rotation in OMAF
    return
        rotationMatrixFromRotationAroundZ(rotation[0]) *
        rotationMatrixFromRotationAroundY(rotation[1]) *
        rotationMatrixFromRotationAroundX(rotation[2]);
}
 
cv::Matx33f EulerAnglesDegreeToRotationMatrixNotOMAF(cv::Vec3f rotationDegrees)
{
    // /!\ should be in degree !!!!!!!!!!!!!!!
    // not for OMAF !!!!
    cv::Vec3f tmp = rotationDegrees;
    auto const radperdeg = 0.01745329252f;
    auto rotation = radperdeg * tmp;
    return rotationMatrixFromRotationAroundZ(rotation[2]) *
        rotationMatrixFromRotationAroundY(rotation[1]) *
        rotationMatrixFromRotationAroundX(rotation[0]);
}
 
 
glm::mat3x3 glmRotationMatrixFromRotationAroundX(float rx)
{
    /*The following is not correct because glm use column major representation
    return glm::mat3x3(
        1.f, 0.f, 0.f,
        0.f, cos(rx), -sin(rx),
        0.f, sin(rx), cos(rx));*/
    //the correct way:
    return glm::mat3x3(
        1.f, 0.f, 0.f,
        0.f, cos(rx), sin(rx),
        0.f, -sin(rx), cos(rx));
}
 
glm::mat3x3 glmRotationMatrixFromRotationAroundY(float ry)
{
    /*
    The following is not correct because glm use column major representation
    return glm::mat3x3(
        cos(ry), 0.f, sin(ry),
        0.f, 1.f, 0.f,
        -sin(ry), 0.f, cos(ry));*/
        //the correct way:
    return glm::mat3x3(
        cos(ry), 0.f, -sin(ry),
        0.f, 1.f, 0.f,
        sin(ry), 0.f, cos(ry));
}
 
glm::mat3x3 glmRotationMatrixFromRotationAroundZ(float rz)
{
    /*The following is not correct because glm use column major representation
    return glm::mat3x3(
        cos(rz), -sin(rz), 0.f,
        sin(rz), cos(rz), 0.f,
        0.f, 0.f, 1.f);*/
        //the correct way:
    return glm::mat3x3(
        cos(rz), sin(rz), 0.f,
        -sin(rz), cos(rz), 0.f,
        0.f, 0.f, 1.f);
}
 
glm::mat3x3 glmEulerAnglesDegreeToRotationMatrix(glm::vec3 rotationDegrees)
{
    // /!\ should be in rad !!!!!!!!!!!!!!!
    //for rotation in OMAF
    auto const radperdeg = 0.01745329252f;
    auto rotation = radperdeg * rotationDegrees;
    return
        glmRotationMatrixFromRotationAroundZ(rotation[0]) *
        glmRotationMatrixFromRotationAroundY(rotation[1]) *
        glmRotationMatrixFromRotationAroundX(rotation[2]);
}
 
glm::mat3x3 glmEulerAnglesDegreeToRotationMatrixNotOMAF(glm::vec3 rotationDegrees)
{
    // /!\ should be in degree !!!!!!!!!!!!!!!
    // not for OMAF !!!!
    auto const radperdeg = 0.01745329252f;
    auto rotation = radperdeg * rotationDegrees;
    return glmRotationMatrixFromRotationAroundZ(rotation[2]) *
        glmRotationMatrixFromRotationAroundY(rotation[1]) *
        glmRotationMatrixFromRotationAroundX(rotation[0]);
}