ShapeFactory.h

Go to the documentation of this file.

#ifndef SHAPE_FACTORY_H
#define SHAPE_FACTORY_H
 
#include "CoreEnums.h"
#include "ShapeBase.h"
#include "SimulationClassBase.h"
 
#if VTK_PRESENT
#include "VtkRayCasting.h"
#endif
 
#include <cmath>
#include <memory>
#include <string>
#include <vector>
 
template <typename T>
class ShapeFactory
{
    private:
        bool m_shape_file;
        Dimension m_dimension;
        std::shared_ptr<ShapeBase<T>> m_simulation_shape{std::make_shared<ShapeBase<T>>()};
        std::string m_shape_file_path;
 
        void oneDSingleFacetGenerator();
        void loadShapeFile();
        void create();
 
    public:
        ShapeFactory(SimulationClassBase<T>* sim, bool shape_file, const std::string& dimension);
 
        std::shared_ptr<ShapeBase<T>> getShapePtr() { return m_simulation_shape; }
};
 
template <typename T>
ShapeFactory<T>::ShapeFactory(SimulationClassBase<T>* sim, const bool shape_file,
                              const std::string& dimension)
    : m_shape_file{shape_file}, m_dimension(setDimension(dimension))
{
    std::cout << "[ShapeFactory]: " << shape_file << " " << dimension << "\n";
    if (m_shape_file)
    {
        m_shape_file_path = sim->m_simulation_config.getStringParameters("shape_model_path");
    }
    create();
    sim->m_simulation_config.forceValueOverwrite(
        "number_of_facets", std::to_string(m_simulation_shape->getNumberOfFacets()));
}
 
template <typename T>
void ShapeFactory<T>::create()
{
    switch (m_dimension)
    {
        case Dimension::OneD:
            if (!m_shape_file)
            {
                oneDSingleFacetGenerator();
            }
            else
            {
                loadShapeFile();
            }
            break;
        // TwoD and ThreeD always need loadShapeFile
        default:
            loadShapeFile();
            break;
    }
}
 
template <typename T>
void ShapeFactory<T>::oneDSingleFacetGenerator()
{
    // Will be replaced with an implementation that allows for arbitraty rotation of the facet.
    std::vector<std::vector<T>> vertices(
        {{-0.5, -0.5, 0.0}, {0.5, -0.5, 0.0}, {0.5, 0.5, 0.0}, {-0.5, 0.5, 0.0}});
    std::vector<std::vector<int>> faces({{0, 1, 2, 3}});
    std::vector<std::vector<T>> normals({{0.0, 0.0, 1.0}});
    std::vector<T> areas({1.0});
 
    m_simulation_shape->setVertices(vertices);
    m_simulation_shape->setFaces(faces);
    m_simulation_shape->setNormals(normals);
    m_simulation_shape->setAreas(areas);
 
    try
    {
        m_simulation_shape->validityCheck();
    }
    catch (const std::runtime_error& e)
    {
        std::cerr << "[ShapeFactory]: Failed creating the ShapeBase object!\n[ShapeFactory]: "
                  << e.what() << '\n';
        throw std::runtime_error(
            static_cast<std::string>(
                "[ShapeFactory]: Failed creating the ShapeBase object!\n[ShapeFactory]: ")
            + static_cast<std::string>(e.what()));
    }
}
 
template <typename T>
void ShapeFactory<T>::loadShapeFile()
{
// Currently only VTK loading supported
#ifdef VTK_PRESENT
    VtkRayCasting vtk_shape_loader(m_shape_file_path.c_str(), false);
 
    m_simulation_shape->setVertices(vtk_shape_loader.getVertices());
    m_simulation_shape->setFaces(vtk_shape_loader.getFaces());
    m_simulation_shape->setNormals(vtk_shape_loader.getNormals());
    m_simulation_shape->setAreas(vtk_shape_loader.getAreas());
 
    m_simulation_shape->validityCheck();
    return;
#endif
    {
        std::cerr
            << "[ShapeFactory]: Selected shape model is not supported. Check the options and if "
               "you are certain it "
               "should be available, check that third party libraries are linked correctly.\n";
        throw std::runtime_error(static_cast<std::string>(
            "[ShapeFactory]: Selected shape model is not supported. Check the options and if you "
            "are certain it "
            "should be available, check that third party libraries are linked correctly."));
    }
}
 
#endif