UniformCircularSampler.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "UniformCircularSampler.h"
 
UniformCircularSampler::UniformCircularSampler(unsigned int nbRays /* = 1*/,
                                               const vec3& normal /* = vec3{0., 0., 1.} */)
    : Sampler(nbRays), _normal(normal)
{
    init();
}
 
UniformCircularSampler::UniformCircularSampler(const UniformCircularSampler& sampler) : Sampler(sampler)
{
    _u = sampler._u;
    _v = sampler._v;
    _normal = sampler._normal;
    _i = sampler._i;
    _dTheta = sampler._dTheta;
}
 
UniformCircularSampler::UniformCircularSampler(UniformCircularSampler* pSampler) : Sampler(pSampler)
{
    _u = pSampler->_u;
    _v = pSampler->_v;
    _normal = pSampler->_normal;
    _i = pSampler->_i;
    _dTheta = pSampler->_dTheta;
}
 
Sampler* UniformCircularSampler::Clone()
{
    Sampler* sampler = new UniformCircularSampler(this);
    return sampler;
}
 
void UniformCircularSampler::init()
{
    // build an orthonormal basis of a plane orthogonal to _normal
    if (abs(_normal.x) < EPSILON_13 && abs(_normal.y) < EPSILON_13)
    {
        // _normal is colinear to (0, 0, 1)
        // in this case, we get directly an orthonormal basis using e1 and e2
        _u = vec3{1., 0., 0.};
        _v = vec3{0., 1., 0.};
    }
    else
    {
        // _normal is not colinear to (0, 0, 1)
        // in this case, we have to build an orthonormal basis:
        // - define a candidate u_prime, non-colinear with _normal
        // - build u, orthogonal to _normal using the Gram-Schmidt process
        // - build v using cross product
        // - normalize u and v
        const vec3 u_prime{0., 0., 1.};
        _u = vec3{u_prime - _normal * (u_prime * _normal) / (_normal * _normal)};
        _v = vec3{_u ^ _normal};
        _u.normalize();
        _v.normalize();
    }
 
    _i = 0;
    _dTheta = M_2PI / _nb_rays;
}
 
vec3 UniformCircularSampler::getSample()
{
    const decimal theta{_i * _dTheta};
    vec3 v{_u * std::cos(theta) + _v * std::sin(theta)};
    _i++;
    return v;
}
 
bool UniformCircularSampler::isAcceptableSample(vec3 v)
{
    return std::abs(v * _normal) < EPSILON_6;
}