VTKUtils.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 "VTK.hpp"
 
namespace bitpit{
 
uint8_t vtk::getElementNodeCount( VTKElementType type){
 
    switch (type){
 
        case VTKElementType::VERTEX:
            return 1 ;
 
        case VTKElementType::LINE:
            return 2 ;
 
        case VTKElementType::TRIANGLE:
        case VTKElementType::QUADRATIC_EDGE:
            return 3 ;
 
        case VTKElementType::PIXEL:
        case VTKElementType::QUAD:
        case VTKElementType::TETRA:
            return 4 ;
 
        case VTKElementType::VOXEL:
        case VTKElementType::HEXAHEDRON:
        case VTKElementType::QUADRATIC_QUAD:
        case VTKElementType::QUADRATIC_TETRA:
            return 8 ;
 
        case VTKElementType::WEDGE:
        case VTKElementType::QUADRATIC_TRIANGLE:
            return 6 ;
 
        case VTKElementType::PYRAMID:
            return 5 ;
 
        case VTKElementType::QUADRATIC_HEXAHEDRON:
            return 20 ;
 
        default:
            return 0 ;
 
    }
 
 
}
 
bool vtk::convertStringToDataArray( const std::string &line, VTKField &field  ){
 
    std::string typ, name, code, com, offs ;
    int         components(1), offset ;
 
    VTKFormat    codex ;
    VTKDataType  type ;
    VTKFieldType comp(VTKFieldType::SCALAR) ;
 
    bool  success(true) ;
 
 
    if( bitpit::utils::string::keywordInString( line, "<DataArray ") ){
        success = success && bitpit::utils::string::getAfterKeyword( line, "type=", '\"', typ) ;
        success = success && bitpit::utils::string::getAfterKeyword( line, "Name=", '\"', name) ;
        success = success && bitpit::utils::string::getAfterKeyword( line, "format=", '\"', code) ;
 
        if( bitpit::utils::string::getAfterKeyword( line, "NumberOfComponents=", '\"', com)  ){
            bitpit::utils::string::convertString( com, components ) ;
        }
 
        if(components==3)
            comp=VTKFieldType::VECTOR ;
        else if(components==9)
            comp=VTKFieldType::TENSOR ;
 
        vtk::convertStringToEnum( typ, type) ;
        vtk::convertStringToEnum( code, codex) ;
 
        field.setDataType(type) ;
        field.setName(name) ;
        field.setCodification(codex) ;
        if(name != "connectivity") 
            field.setFieldType(comp) ;
 
        if(code=="appended") {
            if( bitpit::utils::string::getAfterKeyword( line, "offset=", '\"', offs) ){
                bitpit::utils::string::convertString( offs, offset ) ;
                field.setOffset(offset) ;
            }
            else{
                success = false ;
            }
        }
 
        return success ;
    }
 
    else{
        return false ;
    }
 
 
}
 
std::string  vtk::convertDataArrayToString( const VTKField &field ){
 
    std::stringstream   os("") ;
    unsigned            comp = field.getComponentCount() ;
 
    os << "        <DataArray "
        << "type=\"" << vtk::convertEnumToString( field.getDataType() ) << "\" "
        << "Name=\"" << field.getName() << "\" "
        << "NumberOfComponents=\""<< comp << "\" "
        << "format=\"" << vtk::convertEnumToString(field.getCodification()) << "\" ";
 
    if( field.getCodification() == VTKFormat::APPENDED ){
        os << "offset=\"" << field.getOffset() << "\" " ;
    }
 
    os << ">" ;
 
    return( os.str() ) ;       
 
 
}
 
std::string  vtk::convertPDataArrayToString( const VTKField &field ){
 
    std::stringstream  os("") ;
    unsigned            comp = field.getComponentCount() ;
 
    os << "        <PDataArray "
        << "type=\"" << vtk::convertEnumToString(field.getDataType()) << "\" "
        << "Name=\"" << field.getName() << "\" "
        << "NumberOfComponents=\""<< comp << "\" " 
        << ">" ;
 
    return( os.str() ) ;
 
}
 
std::string vtk::convertEnumToString( VTKLocation loc ){
   
    switch(loc){
        case VTKLocation::CELL :
            return("Cell");
        case VTKLocation::POINT :
            return("Point");
        case VTKLocation::UNDEFINED :
            return("Undefined") ;
        default:
            return("Undefined") ;
    }
}
 
std::string vtk::convertEnumToString( VTKFormat cod ){
    
    switch(cod){
        case VTKFormat::ASCII :
            return("ascii");
        case VTKFormat::APPENDED :
            return("appended");
        case VTKFormat::UNDEFINED :
            return("Undefined") ;
        default:
            return("Undefined") ;
    }
}
 
std::string vtk::convertEnumToString( VTKDataType type ){
    
    switch(type){
        case VTKDataType::Int8 :
            return("Int8");
        case VTKDataType::Int16 :
            return("Int16");
        case VTKDataType::Int32 :
            return("Int32");
        case VTKDataType::Int64 :
            return("Int64");
        case VTKDataType::UInt8 :
            return("UInt8");
        case VTKDataType::UInt16 :
            return("UInt16");
        case VTKDataType::UInt32 :
            return("UInt32");
        case VTKDataType::UInt64 :
            return("UInt64");
        case VTKDataType::Float32 :
            return("Float32");
        case VTKDataType::Float64 :
            return("Float64");
        case VTKDataType::UNDEFINED :
            return("Undefined");
        default:
            return("Undefined") ;
    }
}
 
bool vtk::convertStringToEnum(  const std::string &str, VTKLocation &loc ){
    
 
    if( str == "Cell"){
        loc = VTKLocation::CELL;
        return(true);
 
    } else if ( str == "Point" ){
        loc = VTKLocation::POINT;
        return(true);
 
    } else {
        loc = VTKLocation::UNDEFINED ;
        return(false);
    }
 
}
 
bool vtk::convertStringToEnum( const  std::string &str, VTKFormat &cod ){
    
 
    if( str == "ascii"){
        cod = VTKFormat::ASCII ;
        return(true);
 
    } else if ( str == "appended" ){
        cod = VTKFormat::APPENDED ;
        return(true);
 
    } else {
        cod = VTKFormat::UNDEFINED ;
        return(false);
    }
 
}
 
bool vtk::convertStringToEnum( const std::string &str, VTKDataType &type ){
 
    if ( str =="Int8" ){
        type = VTKDataType::Int8;
        return(true);
    }
 
    else if ( str =="Int16" ){
        type = VTKDataType::Int16;
        return(true);
    }
 
    else if ( str =="Int32" ){
        type = VTKDataType::Int32;
        return(true);
    }
 
    else if ( str =="Int64" ){
        type = VTKDataType::Int64;
        return(true);
    }
 
    else if ( str =="UInt8" ){
        type = VTKDataType::UInt8;
        return(true);
    }
 
    else if ( str =="UInt16" ){
        type = VTKDataType::UInt16;
        return(true);
    }
 
    else if ( str =="UInt32" ){
        type = VTKDataType::UInt32;
        return(true);
    }
 
    else if ( str =="UInt64" ){
        type = VTKDataType::UInt64;
        return(true);
    }
 
    else if ( str =="Float32" ){
        type = VTKDataType::Float32;
        return(true);
    }
 
    else if ( str =="Float64" ){
        type = VTKDataType::Float64;
        return(true);
    }
 
    else {
        type = VTKDataType::UNDEFINED;
        return(false);
    }
 
}
 
 
}