SurfaceTriangulator.cpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#include "SurfaceTriangulator.hpp"
 
namespace mimmo{
 
SurfaceTriangulator::SurfaceTriangulator(){
    m_name = "mimmo.SurfaceTriangulator";
    m_workOnTarget = false;
 
};
 
SurfaceTriangulator::SurfaceTriangulator(const bitpit::Config::Section & rootXML){
 
    m_name = "mimmo.SurfaceTriangulator";
    m_workOnTarget = false;
 
    std::string fallback_name = "ClassNONE";
    std::string input = rootXML.get("ClassName", fallback_name);
    input = bitpit::utils::string::trim(input);
    if(input == "mimmo.SurfaceTriangulator"){
        absorbSectionXML(rootXML);
    }else{
        warningXML(m_log, m_name);
    };
}
 
SurfaceTriangulator::~SurfaceTriangulator(){};
 
SurfaceTriangulator::SurfaceTriangulator(const SurfaceTriangulator & other):BaseManipulation(other){
    m_workOnTarget = other.m_workOnTarget;
};
 
SurfaceTriangulator & SurfaceTriangulator::operator=(SurfaceTriangulator other){
    swap(other);
    return  *this;
};
 
void SurfaceTriangulator::swap(SurfaceTriangulator &x) noexcept
{
   std::swap(m_workOnTarget, x.m_workOnTarget);
   std::swap(m_intPatch, x.m_intPatch);
   BaseManipulation::swap(x);
}
 
void SurfaceTriangulator::buildPorts(){
 
    bool built = true;
    built = (built && createPortIn<mimmo::MimmoSharedPointer<MimmoObject>, SurfaceTriangulator>(this, &mimmo::SurfaceTriangulator::setGeometry,M_GEOM, true));
    built = (built && createPortOut<mimmo::MimmoSharedPointer<MimmoObject>, SurfaceTriangulator>(this, &mimmo::SurfaceTriangulator::getGeometry, M_GEOM));
    m_arePortsBuilt = built;
};
 
 
mimmo::MimmoSharedPointer<MimmoObject>  SurfaceTriangulator::getGeometry(){
    if(m_workOnTarget)  return BaseManipulation::getGeometry();
    else                return m_intPatch;
};
 
bool  SurfaceTriangulator::isWorkingOnTarget(){
    return m_workOnTarget;
};
 
void SurfaceTriangulator::setGeometry(mimmo::MimmoSharedPointer<MimmoObject> geo){
    if(!geo)    return;
    BaseManipulation::setGeometry(geo);
};
 
void        SurfaceTriangulator::setWorkOnTarget(bool flag){
    m_workOnTarget = flag;
};
 
void SurfaceTriangulator::execute(){
 
    mimmo::MimmoSharedPointer<MimmoObject> target = BaseManipulation::getGeometry();
 
    if (target == nullptr){
        throw std::runtime_error (m_name + " : nullptr pointer to linked geometry");
    }
 
    if(!m_workOnTarget){
        //create internal patch as clone of the linked geometry and set target pointing to it
        m_intPatch = mimmo::MimmoSharedPointer<MimmoObject>(target->clone());
        target = m_intPatch;
    }
 
    target->triangulate();
};
 
void     SurfaceTriangulator::plotOptionalResults(){
 
    write(getGeometry());
 
}
 
void SurfaceTriangulator::absorbSectionXML(const bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    //start absorbing
    BaseManipulation::absorbSectionXML(slotXML, name);
 
    if(slotXML.hasOption("WorkOnTarget")){
        std::string input = slotXML.get("WorkOnTarget");
        input = bitpit::utils::string::trim(input);
        bool value = false;
        if(!input.empty()){
            std::stringstream ss(input);
            ss >> value;
        }
        setWorkOnTarget(value);
    }
 
};
 
void SurfaceTriangulator::flushSectionXML(bitpit::Config::Section & slotXML, std::string name){
 
    BITPIT_UNUSED(name);
 
    BaseManipulation::flushSectionXML(slotXML,name);
    slotXML.set("WorkOnTarget", std::to_string(int(m_workOnTarget)));
};
 
}