mirror of
https://github.com/qgis/QGIS.git
synced 2025-02-27 00:33:48 -05:00
1073 lines
26 KiB
C++
1073 lines
26 KiB
C++
/*
|
|
MDAL - Mesh Data Abstraction Library (MIT License)
|
|
Copyright (C) 2018 Peter Petrik (zilolv at gmail dot com)
|
|
*/
|
|
|
|
#include "mdal_utils.hpp"
|
|
#include <string>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
#include <math.h>
|
|
#include <assert.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <ctime>
|
|
#include <stdlib.h>
|
|
|
|
std::string MDAL::getEnvVar( const std::string &varname, const std::string &defaultVal )
|
|
{
|
|
if ( varname.empty() )
|
|
return std::string();
|
|
|
|
char *envVarC = getenv( varname.c_str() );
|
|
|
|
if ( !envVarC )
|
|
return defaultVal;
|
|
else
|
|
return std::string( envVarC );
|
|
}
|
|
|
|
bool MDAL::fileExists( const std::string &filename )
|
|
{
|
|
std::ifstream in( filename );
|
|
return in.good();
|
|
}
|
|
|
|
std::string MDAL::readFileToString( const std::string &filename )
|
|
{
|
|
if ( MDAL::fileExists( filename ) )
|
|
{
|
|
std::ifstream t( filename );
|
|
std::stringstream buffer;
|
|
buffer << t.rdbuf();
|
|
return buffer.str();
|
|
}
|
|
return "";
|
|
}
|
|
|
|
bool MDAL::startsWith( const std::string &str, const std::string &substr, ContainsBehaviour behaviour )
|
|
{
|
|
if ( ( str.size() < substr.size() ) || substr.empty() )
|
|
return false;
|
|
|
|
if ( behaviour == ContainsBehaviour::CaseSensitive )
|
|
return str.rfind( substr, 0 ) == 0;
|
|
else
|
|
return startsWith( toLower( str ), toLower( substr ), ContainsBehaviour::CaseSensitive );
|
|
}
|
|
|
|
bool MDAL::endsWith( const std::string &str, const std::string &substr, ContainsBehaviour behaviour )
|
|
{
|
|
if ( ( str.size() < substr.size() ) || substr.empty() )
|
|
return false;
|
|
|
|
if ( behaviour == ContainsBehaviour::CaseSensitive )
|
|
return str.rfind( substr ) == ( str.size() - substr.size() );
|
|
else
|
|
return endsWith( toLower( str ), toLower( substr ), ContainsBehaviour::CaseSensitive );
|
|
}
|
|
|
|
std::vector<std::string> MDAL::split( const std::string &str,
|
|
const char delimiter
|
|
)
|
|
{
|
|
std::vector<std::string> list;
|
|
std::string::const_iterator start = str.begin();
|
|
std::string::const_iterator end = str.end();
|
|
std::string::const_iterator next;
|
|
std::string token;
|
|
do
|
|
{
|
|
next = std::find( start, end, delimiter );
|
|
token = std::string( start, next );
|
|
if ( !token.empty() )
|
|
list.push_back( token );
|
|
|
|
if ( next == end )
|
|
break;
|
|
else
|
|
start = next + 1;
|
|
}
|
|
while ( true );
|
|
return list;
|
|
}
|
|
|
|
|
|
std::vector<std::string> MDAL::split( const std::string &str,
|
|
const std::string &delimiter )
|
|
{
|
|
std::vector<std::string> list;
|
|
std::string::size_type start = 0;
|
|
std::string::size_type next;
|
|
std::string token;
|
|
do
|
|
{
|
|
next = str.find( delimiter, start );
|
|
if ( next == std::string::npos )
|
|
token = str.substr( start ); // rest of the string
|
|
else
|
|
token = str.substr( start, next - start ); // part of the string
|
|
if ( !token.empty() )
|
|
list.push_back( token );
|
|
start = next + delimiter.size();
|
|
}
|
|
while ( next != std::string::npos );
|
|
return list;
|
|
}
|
|
|
|
size_t MDAL::toSizeT( const std::string &str )
|
|
{
|
|
int i = atoi( str.c_str() );
|
|
if ( i < 0 ) // consistent with atoi return
|
|
i = 0;
|
|
return static_cast< size_t >( i );
|
|
}
|
|
|
|
size_t MDAL::toSizeT( const char &str )
|
|
{
|
|
int i = atoi( &str );
|
|
if ( i < 0 ) // consistent with atoi return
|
|
i = 0;
|
|
return static_cast< size_t >( i );
|
|
}
|
|
|
|
size_t MDAL::toSizeT( const double value )
|
|
{
|
|
return static_cast<size_t>( value );
|
|
}
|
|
|
|
int MDAL::toInt( const size_t value )
|
|
{
|
|
if ( value > std::numeric_limits<int>::max() )
|
|
throw std::runtime_error( "Invalid cast" );
|
|
return static_cast< int >( value );
|
|
}
|
|
|
|
double MDAL::toDouble( const size_t value )
|
|
{
|
|
return static_cast< double >( value );
|
|
}
|
|
|
|
double MDAL::toDouble( const std::string &str )
|
|
{
|
|
return atof( str.c_str() );
|
|
}
|
|
|
|
int MDAL::toInt( const std::string &str )
|
|
{
|
|
return atoi( str.c_str() );
|
|
}
|
|
|
|
std::string MDAL::baseName( const std::string &filename, bool keepExtension )
|
|
{
|
|
// https://stackoverflow.com/a/8520815/2838364
|
|
std::string fname( filename );
|
|
|
|
// Remove directory if present.
|
|
// Do this before extension removal incase directory has a period character.
|
|
const size_t last_slash_idx = fname.find_last_of( "\\/" );
|
|
if ( std::string::npos != last_slash_idx )
|
|
{
|
|
fname.erase( 0, last_slash_idx + 1 );
|
|
}
|
|
|
|
if ( !keepExtension )
|
|
{
|
|
// Remove extension if present.
|
|
const size_t period_idx = fname.rfind( '.' );
|
|
if ( std::string::npos != period_idx )
|
|
{
|
|
fname.erase( period_idx );
|
|
}
|
|
}
|
|
return fname;
|
|
}
|
|
|
|
std::string MDAL::fileExtension( const std::string &path )
|
|
{
|
|
std::string filename = MDAL::baseName( path, true );
|
|
|
|
const size_t lastDotIx = filename.find_last_of( "." );
|
|
if ( std::string::npos == lastDotIx )
|
|
{
|
|
return std::string();
|
|
}
|
|
|
|
std::string extension = filename.substr( lastDotIx );
|
|
|
|
return extension;
|
|
}
|
|
|
|
std::string MDAL::pathJoin( const std::string &path1, const std::string &path2 )
|
|
{
|
|
//https://stackoverflow.com/questions/6297738/how-to-build-a-full-path-string-safely-from-separate-strings#6297807
|
|
#ifdef _MSC_VER
|
|
return path1 + "\\" + path2;
|
|
#else
|
|
return path1 + "/" + path2;
|
|
#endif
|
|
}
|
|
|
|
std::string MDAL::dirName( const std::string &filename )
|
|
{
|
|
std::string dname( filename );
|
|
const size_t last_slash_idx = dname.find_last_of( "\\/" );
|
|
if ( std::string::npos != last_slash_idx )
|
|
{
|
|
dname.erase( last_slash_idx, dname.size() - last_slash_idx );
|
|
}
|
|
return dname;
|
|
}
|
|
|
|
bool MDAL::contains( const std::string &str, const std::string &substr, ContainsBehaviour behaviour )
|
|
{
|
|
if ( behaviour == ContainsBehaviour::CaseSensitive )
|
|
return str.find( substr ) != std::string::npos;
|
|
else
|
|
{
|
|
auto it = std::search(
|
|
str.begin(), str.end(),
|
|
substr.begin(), substr.end(),
|
|
[]( char ch1, char ch2 )
|
|
{
|
|
#ifdef _MSC_VER
|
|
return toupper( ch1 ) == toupper( ch2 );
|
|
#else
|
|
return std::toupper( ch1 ) == std::toupper( ch2 );
|
|
#endif
|
|
}
|
|
);
|
|
return ( it != str.end() );
|
|
}
|
|
}
|
|
|
|
bool MDAL::toBool( const std::string &str )
|
|
{
|
|
int i = atoi( str.c_str() );
|
|
return i != 0;
|
|
}
|
|
|
|
bool MDAL::contains( const std::vector<std::string> &list, const std::string &str )
|
|
{
|
|
return std::find( list.begin(), list.end(), str ) != list.end();
|
|
}
|
|
|
|
std::string MDAL::join( const std::vector<std::string> parts, const std::string &delimiter )
|
|
{
|
|
std::stringstream res;
|
|
for ( auto iter = parts.begin(); iter != parts.end(); iter++ )
|
|
{
|
|
if ( iter != parts.begin() ) res << delimiter;
|
|
res << *iter;
|
|
}
|
|
return res.str();
|
|
}
|
|
|
|
std::string MDAL::leftJustified( const std::string &str, size_t width, char fill )
|
|
{
|
|
std::string ret( str );
|
|
if ( ret.size() > width )
|
|
{
|
|
ret = ret.substr( 0, width );
|
|
}
|
|
else
|
|
{
|
|
ret = ret + std::string( width - ret.size(), fill );
|
|
}
|
|
assert( ret.size() == width );
|
|
return ret;
|
|
}
|
|
|
|
std::string MDAL::toLower( const std::string &std )
|
|
{
|
|
std::string res( std );
|
|
#ifdef WIN32
|
|
//silence algorithm(1443): warning C4244: '=': conversion from 'int' to 'char'
|
|
std::transform( res.begin(), res.end(), res.begin(),
|
|
[]( char c ) {return static_cast<char>( ::tolower( c ) );} );
|
|
#else
|
|
std::transform( res.begin(), res.end(), res.begin(), ::tolower );
|
|
#endif
|
|
return res;
|
|
}
|
|
|
|
std::string MDAL::replace( const std::string &str, const std::string &substr, const std::string &replacestr, MDAL::ContainsBehaviour behaviour )
|
|
{
|
|
std::string res( str );
|
|
if ( behaviour == ContainsBehaviour::CaseSensitive )
|
|
{
|
|
while ( res.find( substr ) != std::string::npos )
|
|
{
|
|
res.replace( res.find( substr ), substr.size(), replacestr );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// https://stackoverflow.com/a/40577390/2838364
|
|
std::string lower_s = toLower( str );
|
|
std::string lower_substring = toLower( substr );
|
|
|
|
auto position = lower_s.find( lower_substring );
|
|
while ( position != std::string::npos )
|
|
{
|
|
res.replace( position, lower_substring.size(), replacestr );
|
|
lower_s.replace( position, lower_substring.size(), replacestr );
|
|
position = lower_s.find( lower_substring );
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
std::string MDAL::removeFrom( const std::string &str, const std::string &substr )
|
|
{
|
|
std::string res( str );
|
|
size_t pos = res.rfind( substr );
|
|
if ( pos != std::string::npos )
|
|
{
|
|
res = res.substr( 0, pos );
|
|
}
|
|
return res;
|
|
|
|
}
|
|
|
|
// http://www.cplusplus.com/faq/sequences/strings/trim/
|
|
std::string MDAL::trim( const std::string &s, const std::string &delimiters )
|
|
{
|
|
if ( s.empty() )
|
|
return s;
|
|
|
|
return ltrim( rtrim( s, delimiters ), delimiters );
|
|
}
|
|
|
|
// http://www.cplusplus.com/faq/sequences/strings/trim/
|
|
std::string MDAL::ltrim( const std::string &s, const std::string &delimiters )
|
|
{
|
|
if ( s.empty() )
|
|
return s;
|
|
|
|
size_t found = s.find_first_not_of( delimiters );
|
|
|
|
if ( found == std::string::npos )
|
|
{
|
|
return "";
|
|
}
|
|
else
|
|
{
|
|
return s.substr( found );
|
|
}
|
|
}
|
|
|
|
// http://www.cplusplus.com/faq/sequences/strings/trim/
|
|
std::string MDAL::rtrim( const std::string &s, const std::string &delimiters )
|
|
{
|
|
if ( s.empty() )
|
|
return s;
|
|
|
|
size_t found = s.find_last_not_of( delimiters );
|
|
if ( found == std::string::npos )
|
|
{
|
|
return "";
|
|
}
|
|
else
|
|
{
|
|
return s.substr( 0, found + 1 );
|
|
}
|
|
}
|
|
|
|
MDAL::BBox MDAL::computeExtent( const MDAL::Vertices &vertices )
|
|
{
|
|
BBox b;
|
|
|
|
if ( vertices.empty() )
|
|
return b;
|
|
|
|
b.minX = vertices[0].x;
|
|
b.maxX = vertices[0].x;
|
|
b.minY = vertices[0].y;
|
|
b.maxY = vertices[0].y;
|
|
|
|
for ( Vertices::size_type i = 0; i < vertices.size(); i++ )
|
|
{
|
|
const Vertex &n = vertices[i];
|
|
if ( n.x > b.maxX ) b.maxX = n.x;
|
|
if ( n.x < b.minX ) b.minX = n.x;
|
|
if ( n.y > b.maxY ) b.maxY = n.y;
|
|
if ( n.y < b.minY ) b.minY = n.y;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
double MDAL::safeValue( double val, double nodata, double eps )
|
|
{
|
|
if ( std::isnan( val ) )
|
|
return val;
|
|
|
|
if ( std::isnan( nodata ) )
|
|
return val;
|
|
|
|
if ( equals( val, nodata, eps ) )
|
|
return std::numeric_limits<double>::quiet_NaN();
|
|
|
|
return val;
|
|
}
|
|
|
|
double MDAL::parseTimeUnits( const std::string &units )
|
|
{
|
|
double divBy = 1;
|
|
// We are trying to parse strings like
|
|
//
|
|
// "seconds since 2001-05-05 00:00:00"
|
|
// "hours since 1900-01-01 00:00:0.0"
|
|
// "days since 1961-01-01 00:00:00"
|
|
//
|
|
// or simply
|
|
// hours, days, seconds, ...
|
|
|
|
const std::vector<std::string> units_list = MDAL::split( units, " since " );
|
|
std::string unit_definition = units;
|
|
if ( !units_list.empty() )
|
|
{
|
|
unit_definition = units_list[0];
|
|
}
|
|
|
|
// Give me hours
|
|
if ( units_list[0] == "seconds" )
|
|
{
|
|
divBy = 3600.0;
|
|
}
|
|
else if ( units_list[0] == "minutes" )
|
|
{
|
|
divBy = 60.0;
|
|
}
|
|
else if ( units_list[0] == "days" )
|
|
{
|
|
divBy = 1.0 / 24.0;
|
|
}
|
|
|
|
return divBy;
|
|
}
|
|
|
|
std::string MDAL::getCurrentTimeStamp()
|
|
{
|
|
time_t t ;
|
|
struct tm *tmp ;
|
|
char MY_TIME[50];
|
|
time( &t );
|
|
tmp = localtime( &t );
|
|
strftime( MY_TIME, sizeof( MY_TIME ), "%Y-%m-%dT%H:%M:%S%z", tmp );
|
|
std::string s = MDAL::trim( MY_TIME );
|
|
return s;
|
|
}
|
|
|
|
MDAL::Statistics _calculateStatistics( const std::vector<double> &values, size_t count, bool isVector, const std::vector<int> &active )
|
|
{
|
|
MDAL::Statistics ret;
|
|
|
|
double min = std::numeric_limits<double>::quiet_NaN();
|
|
double max = std::numeric_limits<double>::quiet_NaN();
|
|
bool firstIteration = true;
|
|
|
|
for ( size_t i = 0; i < count; ++i )
|
|
{
|
|
if ( !active.empty() && active.at( i ) == 0 )
|
|
continue;
|
|
|
|
double magnitude;
|
|
if ( isVector )
|
|
{
|
|
double x = values[2 * i];
|
|
double y = values[2 * i + 1];
|
|
if ( std::isnan( x ) || std::isnan( y ) )
|
|
continue;
|
|
magnitude = sqrt( x * x + y * y );
|
|
}
|
|
else
|
|
{
|
|
double x = values[i];
|
|
if ( std::isnan( x ) )
|
|
continue;
|
|
magnitude = x;
|
|
}
|
|
|
|
if ( firstIteration )
|
|
{
|
|
firstIteration = false;
|
|
min = magnitude;
|
|
max = magnitude;
|
|
}
|
|
else
|
|
{
|
|
if ( magnitude < min )
|
|
{
|
|
min = magnitude;
|
|
}
|
|
if ( magnitude > max )
|
|
{
|
|
max = magnitude;
|
|
}
|
|
}
|
|
}
|
|
|
|
ret.minimum = min;
|
|
ret.maximum = max;
|
|
return ret;
|
|
}
|
|
|
|
MDAL::Statistics MDAL::calculateStatistics( std::shared_ptr<MDAL::DatasetGroup> grp )
|
|
{
|
|
return calculateStatistics( grp.get() );
|
|
}
|
|
|
|
MDAL::Statistics MDAL::calculateStatistics( DatasetGroup *grp )
|
|
{
|
|
Statistics ret;
|
|
if ( !grp )
|
|
return ret;
|
|
|
|
for ( std::shared_ptr<Dataset> ds : grp->datasets )
|
|
{
|
|
MDAL::Statistics dsStats = ds->statistics();
|
|
combineStatistics( ret, dsStats );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
MDAL::Statistics MDAL::calculateStatistics( std::shared_ptr<Dataset> dataset )
|
|
{
|
|
Statistics ret;
|
|
if ( !dataset )
|
|
return ret;
|
|
|
|
bool isVector = !dataset->group()->isScalar();
|
|
bool is3D = dataset->group()->dataLocation() == MDAL_DataLocation::DataOnVolumes;
|
|
size_t bufLen = 2000;
|
|
std::vector<double> buffer( isVector ? bufLen * 2 : bufLen );
|
|
std::vector<int> activeBuffer;
|
|
bool activeFaceFlag = dataset->group()->dataLocation() == MDAL_DataLocation::DataOnFaces && dataset->supportsActiveFlag();
|
|
|
|
if ( activeFaceFlag )
|
|
activeBuffer.resize( bufLen );
|
|
|
|
size_t i = 0;
|
|
while ( i < dataset->valuesCount() )
|
|
{
|
|
size_t valsRead;
|
|
if ( is3D )
|
|
{
|
|
if ( isVector )
|
|
{
|
|
valsRead = dataset->vectorVolumesData( i, bufLen, buffer.data() );
|
|
}
|
|
else
|
|
{
|
|
valsRead = dataset->scalarVolumesData( i, bufLen, buffer.data() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( isVector )
|
|
{
|
|
valsRead = dataset->vectorData( i, bufLen, buffer.data() );
|
|
}
|
|
else
|
|
{
|
|
valsRead = dataset->scalarData( i, bufLen, buffer.data() );
|
|
}
|
|
|
|
if ( activeFaceFlag )
|
|
dataset->activeData( i, bufLen, activeBuffer.data() );
|
|
}
|
|
if ( valsRead == 0 )
|
|
return ret;
|
|
|
|
MDAL::Statistics dsStats = _calculateStatistics( buffer, valsRead, isVector, activeBuffer );
|
|
combineStatistics( ret, dsStats );
|
|
i += valsRead;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void MDAL::combineStatistics( MDAL::Statistics &main, const MDAL::Statistics &other )
|
|
{
|
|
if ( std::isnan( main.minimum ) ||
|
|
( !std::isnan( other.minimum ) && ( main.minimum > other.minimum ) ) )
|
|
{
|
|
main.minimum = other.minimum;
|
|
}
|
|
|
|
if ( std::isnan( main.maximum ) ||
|
|
( !std::isnan( other.maximum ) && ( main.maximum < other.maximum ) ) )
|
|
{
|
|
main.maximum = other.maximum;
|
|
}
|
|
}
|
|
|
|
void MDAL::addBedElevationDatasetGroup( MDAL::Mesh *mesh, const Vertices &vertices )
|
|
{
|
|
std::vector<double> values( mesh->verticesCount() );
|
|
for ( size_t i = 0; i < vertices.size(); ++i )
|
|
{
|
|
values[i] = vertices[i].z;
|
|
}
|
|
addVertexScalarDatasetGroup( mesh, values, "Bed Elevation" );
|
|
}
|
|
|
|
static void _addScalarDatasetGroup( MDAL::Mesh *mesh,
|
|
const std::vector<double> &values,
|
|
const std::string &name,
|
|
MDAL_DataLocation location
|
|
)
|
|
{
|
|
if ( !mesh )
|
|
return;
|
|
|
|
size_t maxCount = 0;
|
|
switch ( location )
|
|
{
|
|
case MDAL_DataLocation::DataOnVertices: maxCount = mesh->verticesCount(); break;
|
|
case MDAL_DataLocation::DataOnFaces: maxCount = mesh->facesCount(); break;
|
|
case MDAL_DataLocation::DataOnEdges: maxCount = mesh->edgesCount(); break;
|
|
default:
|
|
assert( false );
|
|
}
|
|
|
|
if ( values.empty() )
|
|
return;
|
|
|
|
if ( maxCount == 0 )
|
|
return;
|
|
|
|
assert( values.size() == maxCount );
|
|
|
|
std::shared_ptr<MDAL::DatasetGroup> group = std::make_shared< MDAL::DatasetGroup >(
|
|
mesh->driverName(),
|
|
mesh,
|
|
mesh->uri(),
|
|
name
|
|
);
|
|
group->setDataLocation( location );
|
|
group->setIsScalar( true );
|
|
|
|
std::shared_ptr<MDAL::MemoryDataset2D> dataset = std::make_shared< MDAL::MemoryDataset2D >( group.get() );
|
|
dataset->setTime( 0.0 );
|
|
memcpy( dataset->values(), values.data(), sizeof( double )*values.size() );
|
|
dataset->setStatistics( MDAL::calculateStatistics( dataset ) );
|
|
group->datasets.push_back( dataset );
|
|
group->setStatistics( MDAL::calculateStatistics( group ) );
|
|
mesh->datasetGroups.push_back( group );
|
|
}
|
|
|
|
|
|
void MDAL::addFaceScalarDatasetGroup( MDAL::Mesh *mesh,
|
|
const std::vector<double> &values,
|
|
const std::string &name )
|
|
{
|
|
_addScalarDatasetGroup( mesh, values, name, MDAL_DataLocation::DataOnFaces );
|
|
}
|
|
|
|
void MDAL::addVertexScalarDatasetGroup( MDAL::Mesh *mesh, const std::vector<double> &values, const std::string &name )
|
|
{
|
|
_addScalarDatasetGroup( mesh, values, name, MDAL_DataLocation::DataOnVertices );
|
|
}
|
|
|
|
void MDAL::addEdgeScalarDatasetGroup( MDAL::Mesh *mesh, const std::vector<double> &values, const std::string &name )
|
|
{
|
|
_addScalarDatasetGroup( mesh, values, name, MDAL_DataLocation::DataOnEdges );
|
|
}
|
|
|
|
bool MDAL::isNativeLittleEndian()
|
|
{
|
|
// https://stackoverflow.com/a/4181991/2838364
|
|
int n = 1;
|
|
return ( *( char * )&n == 1 );
|
|
}
|
|
|
|
std::string MDAL::coordinateToString( double coordinate, int precision )
|
|
{
|
|
std::ostringstream oss;
|
|
oss.setf( std::ios::fixed );
|
|
if ( fabs( coordinate ) > 180 )
|
|
oss.precision( precision ); //seems to not be a geographic coordinate, so 'precision' digits after the digital point
|
|
else
|
|
oss.precision( 6 + precision ); //could be a geographic coordinate, so 'precision'+6 digits after the digital point
|
|
|
|
oss << coordinate;
|
|
|
|
std::string returnString = oss.str();
|
|
|
|
//remove unnecessary '0' or '.'
|
|
if ( returnString.size() > 0 )
|
|
{
|
|
while ( '0' == returnString.back() )
|
|
{
|
|
returnString.pop_back();
|
|
}
|
|
|
|
if ( '.' == returnString.back() )
|
|
returnString.pop_back();
|
|
}
|
|
|
|
return returnString;
|
|
}
|
|
|
|
std::string MDAL::doubleToString( double value, int precision )
|
|
{
|
|
std::ostringstream oss;
|
|
oss.precision( precision );
|
|
oss << value;
|
|
return oss.str();
|
|
}
|
|
|
|
std::string MDAL::prependZero( const std::string &str, size_t length )
|
|
{
|
|
if ( length <= str.size() )
|
|
return str;
|
|
|
|
return std::string( length - str.size(), '0' ).append( str );
|
|
}
|
|
|
|
MDAL::RelativeTimestamp::Unit MDAL::parseDurationTimeUnit( const std::string &timeUnit )
|
|
{
|
|
MDAL::RelativeTimestamp::Unit unit = MDAL::RelativeTimestamp::hours; //default unit
|
|
|
|
if ( timeUnit == "millisec" ||
|
|
timeUnit == "msec" ||
|
|
timeUnit == "millisecs" ||
|
|
timeUnit == "msecs"
|
|
)
|
|
{
|
|
unit = MDAL::RelativeTimestamp::milliseconds;
|
|
}
|
|
else if ( timeUnit == "second" ||
|
|
timeUnit == "seconds" ||
|
|
timeUnit == "Seconds" ||
|
|
timeUnit == "sec" ||
|
|
timeUnit == "secs" ||
|
|
timeUnit == "s" ||
|
|
timeUnit == "se" || // ascii_dat format
|
|
timeUnit == "2" ) // ascii_dat format
|
|
{
|
|
unit = MDAL::RelativeTimestamp::seconds;
|
|
}
|
|
else if ( timeUnit == "minute" ||
|
|
timeUnit == "minutes" ||
|
|
timeUnit == "Minutes" ||
|
|
timeUnit == "min" ||
|
|
timeUnit == "mins" ||
|
|
timeUnit == "mi" || // ascii_dat format
|
|
timeUnit == "1" ) // ascii_dat format
|
|
{
|
|
unit = MDAL::RelativeTimestamp::minutes;
|
|
}
|
|
else if ( timeUnit == "day" ||
|
|
timeUnit == "days" ||
|
|
timeUnit == "Days" )
|
|
{
|
|
unit = MDAL::RelativeTimestamp::days;
|
|
}
|
|
else if ( timeUnit == "week" ||
|
|
timeUnit == "weeks" )
|
|
{
|
|
unit = MDAL::RelativeTimestamp::weeks;
|
|
}
|
|
|
|
|
|
return unit;
|
|
}
|
|
|
|
MDAL::RelativeTimestamp::Unit MDAL::parseCFTimeUnit( std::string timeInformation )
|
|
{
|
|
auto strings = MDAL::split( timeInformation, ' ' );
|
|
if ( strings.size() < 3 )
|
|
return MDAL::RelativeTimestamp::hours; //default value
|
|
|
|
if ( strings[1] == "since" )
|
|
{
|
|
std::string timeUnit = strings[0];
|
|
if ( timeUnit == "month" ||
|
|
timeUnit == "months" ||
|
|
timeUnit == "mon" ||
|
|
timeUnit == "mons" )
|
|
{
|
|
return MDAL::RelativeTimestamp::months_CF;
|
|
}
|
|
else if ( timeUnit == "year" ||
|
|
timeUnit == "years" ||
|
|
timeUnit == "yr" ||
|
|
timeUnit == "yrs" )
|
|
{
|
|
return MDAL::RelativeTimestamp::exact_years;
|
|
}
|
|
|
|
return MDAL::parseDurationTimeUnit( strings[0] );
|
|
}
|
|
|
|
return MDAL::RelativeTimestamp::hours;//default value
|
|
}
|
|
|
|
MDAL::DateTime MDAL::parseCFReferenceTime( const std::string &timeInformation, const std::string &calendarString )
|
|
{
|
|
auto strings = MDAL::split( timeInformation, ' ' );
|
|
if ( strings.size() < 3 )
|
|
return MDAL::DateTime();
|
|
|
|
if ( strings[1] != "since" )
|
|
return MDAL::DateTime();
|
|
|
|
std::string dateString = strings[2];
|
|
|
|
auto dateStringValues = MDAL::split( dateString, '-' );
|
|
if ( dateStringValues.size() != 3 )
|
|
return MDAL::DateTime();
|
|
|
|
int year = MDAL::toInt( dateStringValues[0] );
|
|
int month = MDAL::toInt( dateStringValues[1] );
|
|
int day = MDAL::toInt( dateStringValues[2] );
|
|
|
|
int hours = 0;
|
|
int minutes = 0;
|
|
double seconds = 0;
|
|
|
|
if ( strings.size() > 3 )
|
|
{
|
|
std::string timeString = strings[3];
|
|
auto timeStringsValue = MDAL::split( timeString, ":" );
|
|
if ( timeStringsValue.size() == 3 )
|
|
{
|
|
hours = MDAL::toInt( timeStringsValue[0] );
|
|
minutes = MDAL::toInt( timeStringsValue[1] );
|
|
seconds = MDAL::toDouble( timeStringsValue[2] );
|
|
}
|
|
}
|
|
|
|
MDAL::DateTime::Calendar calendar;
|
|
if ( calendarString == "gregorian" || calendarString == "standard" || calendarString.empty() )
|
|
calendar = MDAL::DateTime::Gregorian;
|
|
else if ( calendarString == "proleptic_gregorian" )
|
|
calendar = MDAL::DateTime::ProlepticGregorian;
|
|
else if ( calendarString == "julian" )
|
|
calendar = MDAL::DateTime::Julian;
|
|
else
|
|
return MDAL::DateTime();
|
|
|
|
return MDAL::DateTime( year, month, day, hours, minutes, seconds, calendar );
|
|
}
|
|
|
|
bool MDAL::getHeaderLine( std::ifstream &stream, std::string &line )
|
|
{
|
|
if ( !stream.is_open() ) return false;
|
|
char b[100] = "";
|
|
if ( ! stream.get( b, sizeof( b ) - 1, '\n' ) ) return false;
|
|
line = std::string( b );
|
|
return true;
|
|
}
|
|
|
|
MDAL::Error::Error( MDAL_Status status, std::string message, std::string driverName ): status( status ), mssg( message ), driver( driverName ) {}
|
|
|
|
void MDAL::Error::setDriver( std::string driverName )
|
|
{
|
|
driver = driverName;
|
|
}
|
|
|
|
void MDAL::parseDriverFromUri( const std::string &uri, std::string &driver )
|
|
{
|
|
bool hasDriverSet = ( uri.find( ":\"" ) != std::string::npos );
|
|
driver = "";
|
|
|
|
if ( !hasDriverSet )
|
|
return;
|
|
|
|
driver = MDAL::split( uri, ":\"" )[0];
|
|
}
|
|
|
|
void MDAL::parseMeshFileFromUri( const std::string &uri, std::string &meshFile )
|
|
{
|
|
bool hasDriverSet = ( uri.find( ":\"" ) != std::string::npos );
|
|
bool hasSpecificMeshSet = ( uri.find( "\":" ) != std::string::npos );
|
|
meshFile = "";
|
|
|
|
if ( !hasDriverSet && !hasSpecificMeshSet )
|
|
meshFile = MDAL::trim( uri, "\"" );
|
|
else if ( hasDriverSet && hasSpecificMeshSet )
|
|
{
|
|
std::string token = MDAL::split( uri, ":\"" )[1]; // split from driver
|
|
token = MDAL::split( token, "\":" )[0]; // split from specific mesh
|
|
meshFile = MDAL::trim( token, "\"" );
|
|
}
|
|
else if ( hasDriverSet )
|
|
{
|
|
std::string token = MDAL::split( uri, ":\"" )[1]; // split from driver
|
|
meshFile = MDAL::trim( token, "\"" );
|
|
}
|
|
else if ( hasSpecificMeshSet )
|
|
{
|
|
std::string token = MDAL::split( uri, "\":" )[0]; // split from specific mesh
|
|
meshFile = MDAL::trim( token, "\"" );
|
|
}
|
|
}
|
|
|
|
void parseSpecificMeshFromUri( const std::string &uri, std::string &meshName )
|
|
{
|
|
bool hasSpecificMeshSet = ( uri.find( "\":" ) != std::string::npos );
|
|
meshName = "";
|
|
|
|
if ( !hasSpecificMeshSet )
|
|
return;
|
|
|
|
std::vector<std::string> tokens = MDAL::split( uri, "\":" );
|
|
if ( tokens.size() > 1 )
|
|
{
|
|
meshName = MDAL::trim( tokens.at( 1 ), "\"" );
|
|
}
|
|
}
|
|
|
|
void MDAL::parseDriverAndMeshFromUri( const std::string &uri, std::string &driver, std::string &meshFile, std::string &meshName )
|
|
{
|
|
parseDriverFromUri( uri, driver );
|
|
parseMeshFileFromUri( uri, meshFile );
|
|
parseSpecificMeshFromUri( uri, meshName );
|
|
}
|
|
|
|
std::string MDAL::buildMeshUri( const std::string &meshFile, const std::string &meshName, const std::string &driver )
|
|
{
|
|
if ( meshFile.empty() )
|
|
return std::string();
|
|
|
|
std::string uri( "" );
|
|
|
|
bool hasDriverName = !driver.empty();
|
|
bool hasMeshName = !meshName.empty();
|
|
|
|
if ( hasDriverName && hasMeshName )
|
|
uri = driver + ":\"" + meshFile + "\":" + meshName;
|
|
else if ( !hasDriverName && !hasMeshName )
|
|
uri = meshFile;
|
|
else if ( hasDriverName ) // only driver
|
|
uri = driver + ":\"" + meshFile + "\"";
|
|
else if ( hasMeshName ) // only mesh name
|
|
uri = "\"" + meshFile + "\":" + meshName;
|
|
|
|
return uri;
|
|
}
|
|
|
|
std::string MDAL::buildAndMergeMeshUris( const std::string &meshFile, const std::vector<std::string> &meshNames, const std::string &driver )
|
|
{
|
|
std::string mergedUris;
|
|
size_t meshNamesCount = meshNames.size();
|
|
|
|
for ( size_t i = 0; i < meshNamesCount; ++i )
|
|
{
|
|
mergedUris += buildMeshUri( meshFile, meshNames.at( i ), driver );
|
|
|
|
if ( ( i + 1 ) < meshNamesCount ) // If this is not the last mesh in array, add separator
|
|
mergedUris += ";;";
|
|
}
|
|
|
|
if ( meshNamesCount == 0 )
|
|
mergedUris = buildMeshUri( meshFile, "", driver );
|
|
|
|
return mergedUris;
|
|
}
|
|
|
|
MDAL::Library::Library( std::string libraryFile )
|
|
{
|
|
d = new Data;
|
|
d->mLibraryFile = libraryFile;
|
|
}
|
|
|
|
MDAL::Library::~Library()
|
|
{
|
|
d->mRef--;
|
|
#ifdef WIN32
|
|
if ( d->mLibrary && d->mRef == 0 )
|
|
FreeLibrary( d->mLibrary );
|
|
#else
|
|
if ( d->mLibrary && d->mRef == 0 )
|
|
dlclose( d->mLibrary );
|
|
#endif
|
|
}
|
|
|
|
MDAL::Library::Library( const MDAL::Library &other )
|
|
{
|
|
*this = other;
|
|
}
|
|
|
|
MDAL::Library &MDAL::Library::operator=( const MDAL::Library &other )
|
|
{
|
|
d = other.d;
|
|
d->mRef++;
|
|
|
|
return ( *this );
|
|
}
|
|
|
|
bool MDAL::Library::isValid()
|
|
{
|
|
if ( !d->mLibrary )
|
|
loadLibrary();
|
|
|
|
return d->mLibrary != nullptr;
|
|
}
|
|
|
|
std::vector<std::string> MDAL::Library::libraryFilesInDir( const std::string &dirPath )
|
|
{
|
|
std::vector<std::string> filesList;
|
|
#if defined(WIN32)
|
|
WIN32_FIND_DATA data;
|
|
HANDLE hFind;
|
|
std::string pattern = dirPath;
|
|
pattern.push_back( '*' );
|
|
|
|
hFind = FindFirstFile( pattern.c_str(), &data );
|
|
|
|
if ( hFind == INVALID_HANDLE_VALUE )
|
|
return filesList;
|
|
|
|
do
|
|
{
|
|
std::string fileName( data.cFileName );
|
|
if ( !fileName.empty() && fileExtension( fileName ) == ".dll" )
|
|
filesList.push_back( fileName );
|
|
}
|
|
while ( FindNextFile( hFind, &data ) != 0 );
|
|
|
|
FindClose( hFind );
|
|
#else
|
|
DIR *dir = opendir( dirPath.c_str() );
|
|
struct dirent *de = readdir( dir );
|
|
while ( de != nullptr )
|
|
{
|
|
std::string fileName( de->d_name );
|
|
if ( !fileName.empty() )
|
|
{
|
|
std::string extentsion = fileExtension( fileName );
|
|
if ( extentsion == ".so" || extentsion == ".dylib" )
|
|
filesList.push_back( fileName );
|
|
}
|
|
de = readdir( dir );
|
|
}
|
|
|
|
closedir( dir );
|
|
#endif
|
|
return filesList;
|
|
}
|
|
|
|
bool MDAL::Library::loadLibrary()
|
|
{
|
|
//should we allow only one successful loading?
|
|
if ( d->mLibrary )
|
|
return false;
|
|
#ifdef WIN32
|
|
UINT uOldErrorMode =
|
|
SetErrorMode( SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS );
|
|
d->mLibrary = LoadLibrary( d->mLibraryFile.c_str() );
|
|
SetErrorMode( uOldErrorMode );
|
|
#else
|
|
d->mLibrary = dlopen( d->mLibraryFile.c_str(), RTLD_LAZY );
|
|
#endif
|
|
|
|
return d->mLibrary != nullptr;
|
|
}
|