Triangle.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 "Triangle.h"
 
#include <math.h>
 
Triangle::Triangle(const vec3& p1, const vec3& p2, const vec3& p3, Material* m, const bool& isSol)
{
    name = "unknown triangle";
    Shape::setIsSol(isSol);
    material = m;
    p = p1;
    u = p2 - p1;
    v = p3 - p1;
    vertices = NULL;
 
    planeNormal.cross(u, v);
    normal = planeNormal;
    normal.normalize();
 
    updateBBox();
}
 
Triangle::Triangle(unsigned int p1, unsigned int p2, unsigned int p3, std::vector<vec3>* _vertices,
                   Material* _m, const bool& isSol)
{
    Shape::setIsSol(isSol);
    vertices = _vertices;
    material = _m;
 
    localVertices.push_back(p1);
    localVertices.push_back(p2);
    localVertices.push_back(p3);
 
    vec3 v1 = vertices->at(p1);
    vec3 v2 = vertices->at(p2);
    vec3 v3 = vertices->at(p3);
 
    p = v1;
    u = v2 - v1;
    v = v3 - v1;
 
    planeNormal.cross(u, v);
    normal = planeNormal;
    normal.normalize();
 
    updateBBox();
}
 
void Triangle::updateBBox()
{
    box = BBox(p, p);
    box = box.Union(p + u);
    box = box.Union(p + v);
    box.pMin = vec3((decimal)(box.pMin.x - 0.01), (decimal)(box.pMin.y - 0.01), (decimal)(box.pMin.z - 0.01));
    box.pMax = vec3((decimal)(box.pMax.x + 0.01), (decimal)(box.pMax.y + 0.01), (decimal)(box.pMax.z + 0.01));
};
 
bool Triangle::getIntersection(Ray& ray, Intersection& inter)
{
    constexpr decimal EPSILON = 0.00001;
 
    const vec3& directeur = ray.getDirection();
 
    // This scalar product was previously recomputed several times.
    const decimal denominator = planeNormal.dot(directeur);
 
    // Back-face culling or ray parallel with the plane containing the triangle.
    if (denominator >= 0.)
    {
        return false;
    }
 
    const vec3 w0 = Vector_r(ray.getPosition(), p);
 
    const decimal t = -planeNormal.dot(w0) / denominator;
 
    vec3 temporary;
 
    temporary.cross(w0, v);
    const decimal iu = temporary.dot(directeur) / denominator;
 
    temporary.cross(u, w0);
    const decimal iv = temporary.dot(directeur) / denominator;
 
    if (t >= -EPSILON && iu >= -EPSILON && iu <= 1. + EPSILON && iv >= -EPSILON && iv <= 1. + EPSILON &&
        iu + iv <= 1. + EPSILON)
    {
        inter.t = t;
        inter.p = this;
        inter.forme = TRIANGLE;
 
        return true;
    }
 
    return false;
}
 
bool Triangle::sample(decimal density, std::vector<vec3>& samples)
{
 
    vec3 proj = vertices->at(localVertices.at(0))
                    .closestPointOnLine(vertices->at(localVertices.at(1)), vertices->at(localVertices.at(2)));
 
    decimal areaTriangle =
        (decimal)(vertices->at(localVertices.at(1)).distance(vertices->at(localVertices.at(2))) *
                  proj.distance(vertices->at(localVertices.at(0))) / 2.);
 
    unsigned int nbSamples = (unsigned int)(areaTriangle * density) + 1;
 
    for (unsigned int i = 0; i < nbSamples; i++)
    {
        decimal randU = 1.;
        decimal randV = 1.;
        while (randU + randV > 1.)
        {
            randU = (decimal)rand() / (decimal)RAND_MAX;
            randV = (decimal)rand() / (decimal)RAND_MAX;
        }
        samples.push_back(p + u * randU + v * randV);
    }
 
    return true;
}