levelSet.cpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit 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.
 *
 *  bitpit 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 bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
# include "bitpit_operators.hpp"
# include "bitpit_patchkernel.hpp"
# include "bitpit_surfunstructured.hpp"
# include "bitpit_volcartesian.hpp"
# include "bitpit_voloctree.hpp"
# include "bitpit_volunstructured.hpp"
 
# include "levelSetCommon.hpp"
# include "levelSetKernel.hpp"
# include "levelSetCartesianKernel.hpp"
# include "levelSetComplementObject.hpp"
# include "levelSetOctreeKernel.hpp"
# include "levelSetObject.hpp"
# include "levelSetProxyObject.hpp"
# include "levelSetBooleanObject.hpp"
# include "levelSetSegmentationObject.hpp"
# include "levelSetMaskObject.hpp"
# include "levelSetUnstructuredKernel.hpp"
 
# include "levelSet.hpp"
 
namespace bitpit {
 
LevelSet::LevelSet(LevelSetFillIn expectedFillIn) {
 
    m_expectedFillIn = expectedFillIn ;
 
    m_objects.clear() ;
 
    m_signedDistance = true ;
 
    m_forceSignPropagation   = false;
    m_signPropagationEnabled = false;
 
    m_narrowBandSize = 0;
 
}
 
void LevelSet::clear(){
    removeObjects();
    m_kernel.reset();
}
 
void LevelSet::update( const std::vector<adaption::Info> &adaptionData ){
 
    assert(m_kernel && "LevelSet::setMesh() must be called prior to LevelSet::update()");
 
    // Update kernel
    bool updated = m_kernel->update( adaptionData ) ;
    if (!updated) {
        return;
    }
 
    // Update objects
    for( int id : m_orderedObjectsIds){
        LevelSetObject *object = m_objects.at(id).get() ;
        object->update( adaptionData ) ;
    }
}
 
double LevelSet::getNarrowBandSize() const {
    return m_narrowBandSize;
}
 
void LevelSet::setNarrowBandSize(double size) {
    // Set narrow band size
    m_narrowBandSize = std::max(size, 0.);
 
    // Set object narrow band size
    for (auto &objectEntry : m_objects) {
        LevelSetObject *object = objectEntry.second.get();
        object->setNarrowBandSize(size);
    }
}
 
void LevelSet::setMesh( VolumeKernel* mesh ) {
 
    // Mesh can be set only once
    if (m_kernel) {
        throw std::runtime_error ("Mesh can be set just once.");
    }
 
    // Create the kernel
    if (VolCartesian *cartesian = dynamic_cast<VolCartesian *>(mesh)) {
        m_kernel = std::unique_ptr<LevelSetKernel>(new LevelSetCartesianKernel(*cartesian, m_expectedFillIn));
    } else if (VolOctree *octree = dynamic_cast<VolOctree *>(mesh)) {
        m_kernel = std::unique_ptr<LevelSetKernel>(new LevelSetOctreeKernel(*octree, m_expectedFillIn));
    } else if (VolUnstructured *unstructured = dynamic_cast<VolUnstructured*>(mesh)) {
        m_kernel = std::unique_ptr<LevelSetKernel>(new LevelSetUnstructuredKernel(*unstructured, m_expectedFillIn));
    } else {
        throw std::runtime_error ("Unable to create the levelset kernel. Mesh type non supported.");
    }
 
    // Assign the kernel to the existing objects
    for( int id : m_orderedObjectsIds){
        LevelSetObject *object = m_objects.at(id).get() ;
        object->setKernel(m_kernel.get());
    }
 
}
 
int LevelSet::addObject( std::unique_ptr<SurfUnstructured> &&segmentation, double angle, int id ) {
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetSegmentationObject(id, std::move(segmentation), angle));
 
    return registerObject(std::move(object));
}
 
int LevelSet::addObject( SurfUnstructured *segmentation, double angle, int id ) {
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetSegmentationObject(id, segmentation, angle));
 
    return registerObject(std::move(object));
}
 
int LevelSet::addObject( SurfUnstructured *segmentation, double angle, LevelSetSurfaceSmoothing surfaceSmoothing, int id ) {
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetSegmentationObject(id, segmentation, angle, surfaceSmoothing));
 
    return registerObject(std::move(object));
}
 
int LevelSet::addObject( std::unique_ptr<SurfaceKernel> &&segmentation, double angle, int id ) {
 
    auto surfUnstructured = std::unique_ptr<SurfUnstructured>(dynamic_cast<SurfUnstructured *>(segmentation.release())) ;
    if (!surfUnstructured) {
        throw std::runtime_error ("Segmentation type not supported");
    }
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetSegmentationObject(id, std::move(surfUnstructured), angle));
 
    return registerObject(std::move(object));
}
 
int LevelSet::addObject( SurfaceKernel *segmentation, double angle, int id ) {
 
    SurfUnstructured *surfUnstructured = dynamic_cast<SurfUnstructured *>(segmentation);
    if (!surfUnstructured) {
        throw std::runtime_error ("Segmentation type not supported");
    }
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetSegmentationObject(id, surfUnstructured, angle));
 
    return registerObject(std::move(object));
}
 
int LevelSet::addObject( SurfaceKernel *segmentation, double angle, LevelSetSurfaceSmoothing surfaceSmoothing, int id ) {
 
    SurfUnstructured *surfUnstructured = dynamic_cast<SurfUnstructured *>(segmentation);
    if (!surfUnstructured) {
        throw std::runtime_error ("Segmentation type not supported");
    }
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetSegmentationObject(id, surfUnstructured, angle, surfaceSmoothing));
 
    return registerObject(std::move(object));
}
 
int LevelSet::addObject( const std::unordered_set<long> &list, int id ) {
 
    assert(m_kernel && " levelset: setMesh must be called before adding a mask object ");
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetMaskObject(id, list, *m_kernel->getMesh()));
 
    return registerObject(std::move(object));
}
 
int LevelSet::addObject( const std::vector<long> &list, long refInterface, bool invert, int id ) {
 
    assert(m_kernel && " levelset: setMesh must be called before adding a mask object ");
 
    auto object = std::unique_ptr<LevelSetObject>(new LevelSetMaskObject(id, list, refInterface, invert, *m_kernel->getMesh()));
 
    return registerObject(std::move(object));
};
 
int LevelSet::addObject( std::unique_ptr<LevelSetObject> &&object ) {
 
    return registerObject(std::move(object));
};
 
int LevelSet::registerObject( std::unique_ptr<LevelSetObject> &&object ) {
 
    // Set object id
    int id = object->getId();
    if (id == levelSetDefaults::OBJECT) {
        id = m_objectIdentifierGenerator.generate();
        object->setId(id);
    } else {
        m_objectIdentifierGenerator.setAssigned(id);
    }
 
    // Set object properties
    object->setDefaultLevelSetSigndness(m_signedDistance);
    object->setNarrowBandSize(m_narrowBandSize);
    if (m_forceSignPropagation) {
        if (m_signPropagationEnabled) {
            object->setCellBulkEvaluationMode(LevelSetBulkEvaluationMode::SIGN_PROPAGATION);
        } else {
            object->setCellBulkEvaluationMode(LevelSetBulkEvaluationMode::NONE);
        }
    }
 
    // Set object kernel
    if (m_kernel) {
        object->setKernel(m_kernel.get());
    }
 
    // Add the object to the levelset
    m_objects[id] = std::move(object) ;
    registerObjectId(id);
    incrementObjectsReferenceCount(id);
 
    return id;
}
 
void LevelSet::removeObjects() {
    m_orderedObjectsIds.clear();
    m_objectIdentifierGenerator.reset();
    m_objects.clear();
}
 
bool LevelSet::removeObject(int id) {
    return unregisterObject(id, false);
 
}
 
bool LevelSet::unregisterObject(int id, bool force) {
    if( !force && !isObjectRemovable(id) ) {
        return false;
    }
 
    decrementObjectsReferenceCount(id);
    unregisterObjectId(id);
    m_objectIdentifierGenerator.trash(id);
    m_objects.erase(id);
 
    return true;
 
}
 
bool LevelSet::isObjectRemovable(int id) {
    auto objectItr = m_objects.find(id) ;
    if( objectItr == m_objects.end() ){
        return false;
    }
 
    const LevelSetObject *object = objectItr->second.get() ;
    if( object->getReferenceCount() > 0 ) {
        return false;
    }
 
    return true;
 
}
 
void LevelSet::registerObjectId( int id ) {
 
    // Add the id from the list
    //
    // Ids should be sorted according to the order in which they corresponding objects should be
    // processed: first the ids of the primary objects (in the order the objects were added to
    // the levelset) and then the ids of the other objects (in the order the objects were added
    // to the levelset).
    std::vector<int>::iterator idItr;
    if(getObjectPtr(id)->isPrimary()){
        std::vector<int>::iterator orderedIdsBegin = m_orderedObjectsIds.begin();
        std::vector<int>::iterator orderedIdsEnd   = m_orderedObjectsIds.end();
 
        for (idItr = orderedIdsBegin; idItr != orderedIdsEnd; ++idItr) {
            int candidateId = *idItr ;
            const LevelSetObject *candidateObject = getObjectPtr(candidateId) ;
            if( !candidateObject->isPrimary() ){
                break;
            }
        }
    } else {
        idItr = m_orderedObjectsIds.end();
    }
 
    m_orderedObjectsIds.insert(idItr, id) ;
 
}
 
void LevelSet::unregisterObjectId(int id){
 
    // Remove the id from the list
    std::vector<int>::iterator orderedIdsBegin = m_orderedObjectsIds.begin();
    std::vector<int>::iterator orderedIdsEnd   = m_orderedObjectsIds.end();
 
    std::vector<int>::iterator idItr = std::find(orderedIdsBegin, orderedIdsEnd, id);
    assert(idItr != orderedIdsEnd);
    m_orderedObjectsIds.erase(idItr);
 
}
 
void LevelSet::incrementObjectsReferenceCount(int parentId) {
 
    const LevelSetObject *parentObject = getObjectPtr(parentId);
    if( parentObject->isPrimary() ){
        return;
    }
 
    if( const LevelSetProxyBaseObject *parentProxyObject = dynamic_cast<const LevelSetProxyBaseObject *>(parentObject) ){
        for ( int sourceObjectId : parentProxyObject->getSourceObjectIds() ){
            getObjectPtr(sourceObjectId)->incrementReferenceCount();
        }
    }
 
}
 
void LevelSet::decrementObjectsReferenceCount(int parentId) {
 
    const LevelSetObject *parentObject = getObjectPtr(parentId);
    if( parentObject->isPrimary() ){
        return;
    }
 
    if( const LevelSetProxyBaseObject *parentProxyObject = dynamic_cast<const LevelSetProxyBaseObject *>(parentObject) ){
        for ( int sourceObjectId : parentProxyObject->getSourceObjectIds() ){
            getObjectPtr(sourceObjectId)->decrementReferenceCount();
        }
    }
 
}
 
LevelSetObject & LevelSet::getObject( int id) const{
    return getObject<LevelSetObject>(id);
}
 
LevelSetObject * LevelSet::getObjectPtr( int id) const{
    return getObjectPtr<LevelSetObject>(id);
}
 
std::vector<LevelSetObject *>  LevelSet::getObjectPtrs( ) const{
    return getObjectPtrs<LevelSetObject>();
}
 
int LevelSet::getObjectCount( ) const{
    return m_objects.size() ;
}
 
std::vector<int> LevelSet::getObjectIds( ) const{
    std::vector<int> ids ;
    ids.reserve(m_objects.size()) ;
    for(const auto &entry : m_objects) {
        ids.push_back(entry.first) ;
    }
 
    return ids ;
}
 
void LevelSet::dump( std::ostream &stream ) const{
 
    utils::binary::write(stream, m_expectedFillIn);
    utils::binary::write(stream, m_signedDistance);
    utils::binary::write(stream, m_forceSignPropagation);
    utils::binary::write(stream, m_signPropagationEnabled);
    utils::binary::write(stream, m_narrowBandSize);
 
    m_objectIdentifierGenerator.dump(stream);
    for( const auto &object : m_objects ){
        object.second->dump( stream ) ;
    }
    utils::binary::write(stream, m_orderedObjectsIds);
 
}
 
void LevelSet::restore( std::istream &stream ){
 
    utils::binary::read(stream, m_expectedFillIn);
    utils::binary::read(stream, m_signedDistance);
    utils::binary::read(stream, m_forceSignPropagation);
    utils::binary::read(stream, m_signPropagationEnabled);
    utils::binary::read(stream, m_narrowBandSize);
 
    m_objectIdentifierGenerator.restore(stream);
    for( const auto &object : m_objects ){
        object.second->restore( stream ) ;
    }
    utils::binary::read(stream, m_orderedObjectsIds);
 
}
 
void LevelSet::setSign(bool flag){
    m_signedDistance = flag;
 
}
 
void LevelSet::setPropagateSign(bool flag){
    // Set propagation
    m_forceSignPropagation   = true;
    m_signPropagationEnabled = flag;
 
    // Set object bulk evaluation mode
    for (auto &objectEntry : m_objects) {
        LevelSetObject *object = objectEntry.second.get();
        if (m_forceSignPropagation) {
            if (m_signPropagationEnabled) {
                object->setCellBulkEvaluationMode(LevelSetBulkEvaluationMode::SIGN_PROPAGATION);
            } else {
                object->setCellBulkEvaluationMode(LevelSetBulkEvaluationMode::NONE);
            }
        }
    }
}
 
double LevelSet::getSizeNarrowBand() const{
    return getNarrowBandSize();
}
 
void LevelSet::setSizeNarrowBand(double size){
    return setNarrowBandSize(size);
}
 
void LevelSet::compute(){
 
    // Nothing to do
 
}
 
void LevelSet::compute( int id ){
 
    BITPIT_UNUSED(id);
 
    // Nothing to do
 
}
 
void LevelSet::compute( const std::vector<int> &ids ){
 
    BITPIT_UNUSED(ids);
 
    // Nothing to do
 
}
 
void LevelSet::update( const std::vector<adaption::Info> &adaptionData, int id){
 
    BITPIT_UNUSED(id);
 
    log::warning() << " It is not possible to update the levelset for a specific objects." << std::endl;
    log::warning() << " Levelset will be computed for all the objects." << std::endl;
 
    update(adaptionData);
 
}
 
void LevelSet::update( const std::vector<adaption::Info> &adaptionData, const std::vector<int> &ids ){
 
    BITPIT_UNUSED(ids);
 
    log::warning() << " It is not possible to update the levelset for a specific objects." << std::endl;
    log::warning() << " Levelset will be computed for all the objects." << std::endl;
 
    update(adaptionData);
 
}
 
#if BITPIT_ENABLE_MPI
void LevelSet::partition( const std::vector<adaption::Info> &adaptionData ){
 
    update ( adaptionData ) ;
 
}
#endif
 
}