levelSetCommon.hpp

/*---------------------------------------------------------------------------*\
 *
 *  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/>.
 *
\*---------------------------------------------------------------------------*/
 
# ifndef __BITPIT_LEVELSET_COMMON_HPP__
# define __BITPIT_LEVELSET_COMMON_HPP__
 
// Standard Template Library
# include <array>
# include <limits>
# include <unordered_map>
# include <vector>
 
namespace bitpit{

const double LEVELSET_NARROW_BAND_UNLIMITED = std::numeric_limits<double>::max();

namespace levelSetDefaults{
    const double                            VALUE = 1.e18 ;             
    const std::array<double,3>              GRADIENT = {{0.,0.,0.}};    
    const std::array<double,3>              POINT = {{0.,0.,0.}};       
    const short                             SIGN = 1;                   
    const double                            SIZE = 1.e18 ;              
    const int                               OBJECT = -1 ;               
    const int                               PART  = -1 ;                
    const long                              SUPPORT = -1 ;              
    const std::array<double,3>              NORMAL = {{0.,0.,0.}};      
    const double                            NARROW_BAND_SIZE = -1 ;     
};
 
struct LevelSetInfo{
    double                                  value ;                     
    std::array<double,3>                    gradient ;                  
 
    LevelSetInfo() ;
    LevelSetInfo( double , const std::array<double,3> &) ;
};

enum class LevelSetZone {
    NARROW_BAND,        
    BULK,               
};

enum class LevelSetCellLocation {
    UNKNOWN = -1,                
    NARROW_BAND_DISTANCE,        
    NARROW_BAND_INTERSECTED,     
    NARROW_BAND_NEIGHBOUR,       
    NARROW_BAND_UNDEFINED,       
    BULK,                        
};

enum class LevelSetBooleanOperation{
    UNION =0,                                                           
    INTERSECTION =1,                                                    
    SUBTRACTION =2                                                      
};

enum class LevelSetIntersectionStatus{
    FALSE=0,                                                            
    TRUE=1,                                                             
    CLOSE=2                                                             
};

enum class LevelSetIntersectionMode{
    FAST_FUZZY=0,                   
    FAST_GUARANTEE_TRUE=1,          
    FAST_GUARANTEE_FALSE=2,         
    ACCURATE=3                      
};

enum class LevelSetFillIn{
    SPARSE,                         
    DENSE,                          
};
 
typedef LevelSetFillIn LevelSetCacheType;

enum class LevelSetCacheMode{
    BEGIN = 0,
    NONE = 0,              
    ON_DEMAND,             
    NARROW_BAND,           
    FULL,                  
    END,
    COUNT = END - BEGIN,
};

enum class LevelSetBulkEvaluationMode{
    BEGIN = 0,
    NONE = 0,              
    SIGN_PROPAGATION,      
    EXACT,                 
    END,
    COUNT = END - BEGIN,
};

enum class LevelSetField{
    BEGIN = 0,
    VALUE = BEGIN,                  
    SIGN,                           
    GRADIENT,                       
    SUPPORT,                        
    PART,                           
    NORMAL,                         
    END,
    COUNT = END - BEGIN,
    UNDEFINED
};

enum class LevelSetSurfaceSmoothing{
    LOW_ORDER,                      
    HIGH_ORDER                      
};

struct LevelSetFieldHasher
{
    std::size_t operator()(const LevelSetField &field) const
    {
        return static_cast<int>(field);
    }
};

typedef std::vector<LevelSetField> LevelSetFieldset;

template<typename value_t>
using LevelSetFieldMap = std::unordered_map<LevelSetField, value_t, LevelSetFieldHasher>;

enum class LevelSetWriteField{
    VALUE    = static_cast<int>(LevelSetField::VALUE),     
    SIGN     = static_cast<int>(LevelSetField::SIGN),      
    GRADIENT = static_cast<int>(LevelSetField::GRADIENT),  
    SUPPORT  = static_cast<int>(LevelSetField::SUPPORT),   
    PART     = static_cast<int>(LevelSetField::PART),      
    NORMAL   = static_cast<int>(LevelSetField::NORMAL),    
    ALL,                                                   
    DEFAULT                                                
};
 
}
 
#endif