Scene.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 <deque>
#include <string>
#include <iostream>
#include <fstream>
 
#include "Engine/AcousticRaytracerConfiguration.h"
#include "Accelerator/BruteForceAccelerator.h"
#include "Accelerator/KdtreeAccelerator.h"
#include "Accelerator/BvhAccelerator.h"
#include "Accelerator/GridAccelerator.h"
 
#include "Triangle.h"
#include "Scene.h"
 
#include <math.h>
 
void Scene::clean()
{
    for (unsigned int i = 0; i < shapes.size(); i++)
    {
        delete shapes.at(i);
    }
    shapes.clear();
    registeredVertices.clear();
    vertices.clear();
    globalBox.isNull = true;
    compteurPrimitive = 0;
    compteurFace = 0;
    if (accelerator)
    {
        delete accelerator;
    }
}
 
bool Scene::finish(int accelerator_id /* = 3*/,
                   leafTreatment::treatment _intersectionChoice /* = leafTreatment::FIRST*/)
{
    switch (accelerator_id)
    {
        case 0:
            accelerator = new BruteForceAccelerator(&shapes, globalBox);
            break;
        case 1:
            accelerator = new GridAccelerator(&shapes, globalBox);
            break;
        case 2:
            accelerator = new BvhAccelerator(&shapes, globalBox,
                                             AcousticRaytracerConfiguration::get()->MaxTreeDepth, "middle");
            break;
        case 3:
            accelerator = new KdtreeAccelerator(&shapes, globalBox);
            break;
        default:
            accelerator = new GridAccelerator(&shapes, globalBox);
            break;
    }
 
    accelerator->setIntersectionChoice(_intersectionChoice);
 
    return accelerator->build();
}
 
bool Scene::getIndex(vec3& search, unsigned int& result)
{
    std::map<vec3, unsigned int, compVec>::iterator it = registeredVertices.find(search);
    if (it != registeredVertices.end())
    {
        result = it->second;
        return true;
    }
 
    return false;
}
 
bool Scene::getVertex(unsigned int& search, vec3& result)
{
    if (search < vertices.size())
    {
        result = vertices[search];
        return true;
    }
 
    return false;
}
 
bool Scene::addVertex(const vec3& newVertex, unsigned int& index)
{
    std::map<vec3, unsigned int, compVec>::iterator it = registeredVertices.find(newVertex);
    if (it != registeredVertices.end())
    {
        index = it->second;
        return false;
    }
    else
    {
        index = static_cast<unsigned int>(vertices.size());
        vertices.push_back(newVertex);
        registeredVertices.insert(std::pair<vec3, unsigned int>(newVertex, index));
        return true;
    }
}
 
Shape* Scene::addTriangle(unsigned int i1, unsigned int i2, unsigned int i3, Material* m, const bool& isSol)
{
    Triangle* triangle = new Triangle(i1, i2, i3, &vertices, m, isSol);
    addShape(triangle);
 
    return triangle;
}
 
void Scene::addBuilding(vec3 origine, vec3 dimension, Material* m)
{
 
    unsigned int p1 = 0, p2 = 0, p3 = 0, p4 = 0, p5 = 0, p6 = 0, p7 = 0, p8 = 0;
 
    addVertex(origine, p1);
    addVertex(vec3(origine.x + dimension.x, origine.y, origine.z), p2);
    addVertex(vec3(origine.x + dimension.x, origine.y + dimension.y, origine.z), p3);
    addVertex(vec3(origine.x, origine.y + dimension.y, origine.z), p4);
    addVertex(vec3(origine.x, origine.y, origine.z + dimension.z), p5);
    addVertex(vec3(origine.x + dimension.x, origine.y, origine.z + dimension.z), p6);
    addVertex(vec3(origine.x + dimension.x, origine.y + dimension.y, origine.z + dimension.z), p7);
    addVertex(vec3(origine.x, origine.y + dimension.y, origine.z + dimension.z), p8);
 
    addTriangle(p1, p2, p6, m);
    addTriangle(p6, p5, p1, m);
 
    addTriangle(p3, p4, p8, m);
    addTriangle(p8, p7, p3, m);
 
    addTriangle(p2, p3, p7, m);
    addTriangle(p7, p6, p2, m);
 
    addTriangle(p8, p4, p1, m);
    addTriangle(p1, p5, p8, m);
 
    addTriangle(p5, p6, p7, m);
    addTriangle(p7, p8, p5, m);
}
 
std::vector<Shape*> Scene::getShapes(int shape_type)
{
    std::vector<Shape*> vec;
    for (unsigned int i = 0; i < shapes.size(); i++)
    {
        if (shapes.at(i)->form() == shape_type)
        {
            vec.push_back(shapes.at(i));
        }
    }
    return vec;
}
 
void Scene::export_to_ply(std::string fileName)
{
    // using long long cause of a limitation of MS visual studio 10 in std::to_string
    long long nb_vertex = vertices.size();
    long long nb_faces = shapes.size();
 
    // Create the file content as a vector of string
    std::deque<std::string> file_content;
 
    // Create header
    file_content.push_back(std::string("ply\n"));
    file_content.push_back(std::string("format ascii 1.0\n"));
    file_content.push_back(std::string("element vertex ") + std::to_string(nb_vertex) + std::string("\n"));
    file_content.push_back(std::string("property float x\n"));
    file_content.push_back(std::string("property float y\n"));
    file_content.push_back(std::string("property float z\n"));
    file_content.push_back(std::string("element face ") + std::to_string(nb_faces) + std::string("\n"));
    file_content.push_back(std::string("property list uchar int vertex_indices\n"));
    file_content.push_back(std::string("property uchar red\n"));
    file_content.push_back(std::string("property uchar green\n"));
    file_content.push_back(std::string("property uchar blue\n"));
    file_content.push_back(std::string("end_header\n"));
    // Creation of vertex list
    std::string line;
    for (unsigned int i = 0; i < vertices.size(); i++)
    {
        line = std::to_string(static_cast<long double>(vertices.at(i).x)) + " " +
               std::to_string(static_cast<long double>(vertices.at(i).y)) + " " +
               std::to_string(static_cast<long double>(vertices.at(i).z)) + "\n";
        file_content.push_back(line);
    }
 
    // Creation of faces list
    std::vector<unsigned int>* vertice_index = nullptr;
    for (unsigned int i = 0; i < shapes.size(); i++)
    {
        if (shapes.at(i)->form() != TRIANGLE)
        {
            continue;
        }
 
        vertice_index = shapes.at(i)->getLocalVertices();
        file_content.push_back(std::to_string(static_cast<long long>(3)) + " " +
                               std::to_string(static_cast<long long>(vertice_index->at(0))) + " " +
                               std::to_string(static_cast<long long>(vertice_index->at(1))) + " " +
                               std::to_string(static_cast<long long>(vertice_index->at(2))) + " " +
                               std::string("0 255 0\n"));
    }
 
    // Create the file
    std::ofstream out(fileName, std::ios::out);
    for (unsigned int i = 0; i < file_content.size(); i++)
    {
        out << file_content.at(i);
    }
 
    out.close();
}
 
void Scene::import_from_ply(std::string fileName)
{
    std::ifstream in(fileName.c_str());
    std::string keyword;
    int nb_vertex = 0, nb_faces = 0;
    in >> keyword; // ply
    if (keyword != "ply")
    {
        std::cerr << "Read: " + keyword + "\n" + fileName + " is not a ply file !" << std::endl;
        exit(-1);
    }
    in >> keyword >> keyword >> keyword;                       // format ascii 1.0
    in >> keyword >> keyword >> nb_vertex;                     // element vertex 119
    in >> keyword >> keyword >> keyword;                       // property float x
    in >> keyword >> keyword >> keyword;                       // property float y
    in >> keyword >> keyword >> keyword;                       // property float z
    in >> keyword >> keyword >> nb_faces;                      // element face 198
    in >> keyword >> keyword >> keyword >> keyword >> keyword; // property list uchar int vertex_indices
    in >> keyword >> keyword >> keyword;                       // property int material_index ?
    bool material = false;
    if (keyword == "material_index")
    {
        material = true;
        in >> keyword >> keyword >> keyword; // property uchar red
    }
    in >> keyword >> keyword >> keyword; // property uchar green
    in >> keyword >> keyword >> keyword; // property uchar blue
    if (material)
    {
        in >> keyword >> keyword >> keyword;                       // element material 5
        in >> keyword >> keyword >> keyword >> keyword >> keyword; // property list uchar uchar id
    }
    in >> keyword; // end_header
    float x = NAN, y = NAN, z = NAN;
    // Read vertex:
    for (int i = 0; i < nb_vertex; i++)
    {
        unsigned int p = 0;
        in >> x >> y >> z; // x y z
        addVertex(vec3(x, y, z), p);
    }
    int i1 = 0, i2 = 0, i3 = 0;
    Material* m = new Material();
    // Read faces:
    int n = 0;
    for (int i = 0; i < nb_faces; i++)
    {
        in >> n >> i1 >> i2 >> i3; // vertices
        if (material)
            in >> keyword;                   // material
        in >> keyword >> keyword >> keyword; // color
        if (n != 3)
        {
            std::cerr << "The shape " << i << " is not a Triangle !" << std::endl;
            exit(-1);
        }
        addTriangle(i1, i2, i3, m, false);
    }
    in.close();
}