diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ed4acb08cfa54f5c6bb3e6da3616a0f5b27f56b6
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,12 @@
+language: cpp
+compiler:
+ - gcc
+branches:
+ only:
+ - master
+before_install:
+ - sudo apt-get install qt4-dev-tools libvtk5-dev libvtk5-qt4-dev libnetcdf-dev libshp-dev libgeotiff-dev
+script: "mkdir build && cd build && cmake -DOGS_BUILD_GUI=ON .. && cmake .. && make"
+notifications:
+ email:
+ - lars.bilke@ufz.de
\ No newline at end of file
diff --git a/BaseLib/CMakeLists.txt b/BaseLib/CMakeLists.txt
index fa5d9501cf402b213ca188247346770c19f42820..e6141c5bbdbd03e1bd4807e13a44e665bee4a074 100644
--- a/BaseLib/CMakeLists.txt
+++ b/BaseLib/CMakeLists.txt
@@ -8,9 +8,9 @@ ADD_LIBRARY( BaseLib STATIC ${SOURCES})
SET_TARGET_PROPERTIES(BaseLib PROPERTIES LINKER_LANGUAGE CXX)
INCLUDE_DIRECTORIES(
- ../GeoLib
- ../MathLib
- .
+ ${CMAKE_SOURCE_DIR}/GeoLib
+ ${CMAKE_SOURCE_DIR}/MathLib
+ .
)
# Add logog subdirectory and group its targets in a Visual Studio folder
diff --git a/BaseLib/Histogram.h b/BaseLib/Histogram.h
index 33906d38a633c93b715b8d28fab80748bd29b662..8ae04be9d180d4896cb4d1eaeb97a417e80652b6 100644
--- a/BaseLib/Histogram.h
+++ b/BaseLib/Histogram.h
@@ -109,7 +109,7 @@ class Histogram
void setMaximum(const T& maximum) { _max = maximum; _dirty = true; }
const Data& getSortedData() const { return _data; }
- const std::vector<size_t>& getBinCounts() const { return _histogram; }
+ const std::vector<std::size_t>& getBinCounts() const { return _histogram; }
const unsigned int& getNrBins() const { return _nr_bins; }
const T& getMinimum() const { return _min; }
const T& getMaximum() const { return _max; }
@@ -118,7 +118,7 @@ class Histogram
void
prettyPrint(std::ostream& os, const unsigned int line_width = 16) const
{
- const size_t count_max = *std::max_element(_histogram.begin(), _histogram.end());
+ const std::size_t count_max = *std::max_element(_histogram.begin(), _histogram.end());
for (unsigned int bin = 0; bin < _nr_bins; ++bin) {
os << "[" << _min + bin * _bin_width << ", " << _min + (bin + 1) * _bin_width << ")\t";
os << _histogram[bin] << "\t";
@@ -133,7 +133,7 @@ class Histogram
protected:
Data _data;
const unsigned int _nr_bins;
- std::vector<size_t> _histogram;
+ std::vector<std::size_t> _histogram;
T _min, _max; ///< Minimum and maximum input data values.
T _bin_width;
diff --git a/BaseLib/StringTools.h b/BaseLib/StringTools.h
index a658877bea32c5c90724eb07c09884946b2aaf6e..c692af98a951c133651a06f76c14bf2253537779 100644
--- a/BaseLib/StringTools.h
+++ b/BaseLib/StringTools.h
@@ -52,7 +52,7 @@ template<typename T> std::string number2str(T d)
/**
* Converts a string into a number (double, float, int, ...)
- * Example: size_t number (str2number<size_t> (str));
+ * Example: std::size_t number (str2number<std::size_t> (str));
* \param str string to be converted
* \return the number
*/
@@ -92,7 +92,7 @@ void extractPath (std::string const& fname, std::string& path);
} // end namespace BaseLib
#ifdef MSVC
-void correctScientificNotation(std::string filename, size_t precision = 0);
+void correctScientificNotation(std::string filename, std::size_t precision = 0);
#endif
#endif //STRINGTOOLS_H
diff --git a/BaseLib/binarySearch.h b/BaseLib/binarySearch.h
index 394db9bdd52bb74bf06c2dbdfcff557367f8e95a..b17ae0e4d9c010974f50bfdfcd9f20f3930b6792 100644
--- a/BaseLib/binarySearch.h
+++ b/BaseLib/binarySearch.h
@@ -29,13 +29,13 @@ namespace BaseLib {
* @param end ending index in the sorted vector of elements
* @param array the vector of elements
* @return the id of the element in the vector or, if not found,
- * the value std::numeric_limits<size_t>::max()
+ * the value std::numeric_limits<std::size_t>::max()
*/
template <class T>
-size_t searchElement (const T& key, size_t beg, size_t end, const std::vector<T>& array)
+std::size_t searchElement (const T& key, std::size_t beg, std::size_t end, const std::vector<T>& array)
{
- if (beg >= end) return std::numeric_limits<size_t>::max();
- size_t m ((end+beg)/2);
+ if (beg >= end) return std::numeric_limits<std::size_t>::max();
+ std::size_t m ((end+beg)/2);
if (key == array[m]) {
return m;
@@ -46,7 +46,7 @@ size_t searchElement (const T& key, size_t beg, size_t end, const std::vector<T>
return searchElement (key, m+1, end, array);
}
-size_t searchElement (double const& val, size_t beg, size_t end, const std::vector<double>& array);
+std::size_t searchElement (double const& val, std::size_t beg, std::size_t end, const std::vector<double>& array);
} // end namespace BaseLib
diff --git a/BaseLib/printList.h b/BaseLib/printList.h
index dfc7174381a99996962e1d20f692bb4820b09791..ee1898932638e6371e8ec4822e92ed207dd9ecd5 100644
--- a/BaseLib/printList.h
+++ b/BaseLib/printList.h
@@ -20,10 +20,10 @@
namespace BaseLib {
-void printList (std::list<size_t> const& mylist, std::string const& title)
+void printList (std::list<std::size_t> const& mylist, std::string const& title)
{
std::cout << title << std::endl;
- for (std::list<size_t>::const_iterator my_it (mylist.begin());
+ for (std::list<std::size_t>::const_iterator my_it (mylist.begin());
my_it != mylist.end(); my_it++) {
std::cout << *my_it << " ";
}
diff --git a/BaseLib/quicksort.h b/BaseLib/quicksort.h
index 3047eaff0413fc9e7ea9b9c63d728129d87433d7..31309efacb87803291865738020cd1236610da1f 100644
--- a/BaseLib/quicksort.h
+++ b/BaseLib/quicksort.h
@@ -62,10 +62,10 @@ void quickSort(T* array, unsigned beg, unsigned end)
* @return
*/
template <typename T1, typename T2>
-size_t partition_(T1* array, size_t beg, size_t end, T2 *second_array)
+std::size_t partition_(T1* array, std::size_t beg, std::size_t end, T2 *second_array)
{
- size_t i = beg + 1;
- size_t j = end - 1;
+ std::size_t i = beg + 1;
+ std::size_t j = end - 1;
T1 m = array[beg];
for (;;) {
@@ -95,10 +95,10 @@ size_t partition_(T1* array, size_t beg, size_t end, T2 *second_array)
* @param second_array the second array is permuted according to the sort process of array
*/
template <typename T1, typename T2>
-void quicksort(T1* array, size_t beg, size_t end, T2* second_array)
+void quicksort(T1* array, std::size_t beg, std::size_t end, T2* second_array)
{
if (beg < end) {
- size_t p = partition_(array, beg, end, second_array);
+ std::size_t p = partition_(array, beg, end, second_array);
quicksort(array, beg, p, second_array);
quicksort(array, p+1, end, second_array);
}
@@ -114,15 +114,15 @@ namespace BaseLib {
template <typename T>
class Quicksort {
public:
- Quicksort (std::vector<T>& array, size_t beg, size_t end, std::vector<size_t>& perm)
+ Quicksort (std::vector<T>& array, std::size_t beg, std::size_t end, std::vector<std::size_t>& perm)
{
quicksort (array, beg, end, perm);
}
private:
- size_t partition_(std::vector<T>& array, size_t beg, size_t end, std::vector<size_t>& perm)
+ std::size_t partition_(std::vector<T>& array, std::size_t beg, std::size_t end, std::vector<std::size_t>& perm)
{
- size_t i = beg + 1;
- size_t j = end - 1;
+ std::size_t i = beg + 1;
+ std::size_t j = end - 1;
T m = array[beg];
for (;;) {
@@ -142,10 +142,10 @@ private:
return j;
}
- void quicksort(std::vector<T>& array, size_t beg, size_t end, std::vector<size_t>& perm)
+ void quicksort(std::vector<T>& array, std::size_t beg, std::size_t end, std::vector<std::size_t>& perm)
{
if (beg < end) {
- size_t p = partition_(array, beg, end, perm);
+ std::size_t p = partition_(array, beg, end, perm);
quicksort(array, beg, p, perm);
quicksort(array, p+1, end, perm);
}
@@ -156,21 +156,21 @@ private:
template <typename T>
class Quicksort <T *> {
public:
- Quicksort (std::vector<T*>& array, size_t beg, size_t end, std::vector<size_t>& perm)
+ Quicksort (std::vector<T*>& array, std::size_t beg, std::size_t end, std::vector<std::size_t>& perm)
{
quicksort (array, beg, end, perm);
}
- Quicksort (std::vector<size_t>& perm, size_t beg, size_t end, std::vector<T*>& array)
+ Quicksort (std::vector<std::size_t>& perm, std::size_t beg, std::size_t end, std::vector<T*>& array)
{
quicksort (perm, beg, end, array);
}
private:
- size_t partition_(std::vector<T*>& array, size_t beg, size_t end, std::vector<size_t>& perm)
+ std::size_t partition_(std::vector<T*>& array, std::size_t beg, std::size_t end, std::vector<std::size_t>& perm)
{
- size_t i = beg + 1;
- size_t j = end - 1;
+ std::size_t i = beg + 1;
+ std::size_t j = end - 1;
T* m = array[beg];
for (;;) {
@@ -190,20 +190,20 @@ private:
return j;
}
- void quicksort(std::vector<T*>& array, size_t beg, size_t end, std::vector<size_t>& perm)
+ void quicksort(std::vector<T*>& array, std::size_t beg, std::size_t end, std::vector<std::size_t>& perm)
{
if (beg < end) {
- size_t p = partition_(array, beg, end, perm);
+ std::size_t p = partition_(array, beg, end, perm);
quicksort(array, beg, p, perm);
quicksort(array, p+1, end, perm);
}
}
- size_t partition_(std::vector<size_t> &perm, size_t beg, size_t end, std::vector<T*>& array)
+ std::size_t partition_(std::vector<std::size_t> &perm, std::size_t beg, std::size_t end, std::vector<T*>& array)
{
- size_t i = beg + 1;
- size_t j = end - 1;
- size_t m = perm[beg];
+ std::size_t i = beg + 1;
+ std::size_t j = end - 1;
+ std::size_t m = perm[beg];
for (;;) {
while ((i < end) && (perm[i] <= m))
@@ -222,10 +222,10 @@ private:
return j;
}
- void quicksort(std::vector<size_t>& perm, size_t beg, size_t end, std::vector<T*>& array)
+ void quicksort(std::vector<std::size_t>& perm, std::size_t beg, std::size_t end, std::vector<T*>& array)
{
if (beg < end) {
- size_t p = partition_(perm, beg, end, array);
+ std::size_t p = partition_(perm, beg, end, array);
quicksort(perm, beg, p, array);
quicksort(perm, p+1, end, array);
}
diff --git a/FemLib/BoundaryCondition.h b/FemLib/BoundaryCondition.h
index 3fa9b81e1952521f812aab3521ad8f2bf365d3af..c2aa2011c6c8fa1d4bb72e5a6178ed97308fd996 100644
--- a/FemLib/BoundaryCondition.h
+++ b/FemLib/BoundaryCondition.h
@@ -28,11 +28,11 @@ public:
: FEMCondition(cond, FEMCondition::BOUNDARY_CONDITION) {};
~BoundaryCondition() {}
- size_t getTimType() const {return _tim_type; }
- void setTimType(size_t value) { _tim_type = value; }
+ std::size_t getTimType() const {return _tim_type; }
+ void setTimType(std::size_t value) { _tim_type = value; }
private:
- size_t _tim_type;
+ std::size_t _tim_type;
};
#endif //BOUNDARYCONDITION_H
diff --git a/FemLib/FEMCondition.h b/FemLib/FEMCondition.h
index 6edd27a85ea927c6c37aba86e63bb9873532946d..41c76ee3dcf34a139cb0a2d8189b553dedd00fbd 100644
--- a/FemLib/FEMCondition.h
+++ b/FemLib/FEMCondition.h
@@ -59,7 +59,7 @@ public:
CondType getCondType() const { return _type; }
/// Returns the value(s) for the distribution
- const std::vector<size_t> getDisNodes() const { return _disNodes; }
+ const std::vector<std::size_t> getDisNodes() const { return _disNodes; }
/// Returns the value(s) for the distribution
const std::vector<double> getDisValues() const { return _disValues; }
@@ -74,7 +74,7 @@ public:
void setConstantDisValue(double disValue) {_disValues.clear(); _disValues.push_back(disValue); }
/// Sets a vector of values specifying the distribution.
- void setDisValues(const std::vector<size_t> &disNodes, const std::vector<double> &disValues)
+ void setDisValues(const std::vector<std::size_t> &disNodes, const std::vector<double> &disValues)
{
_disNodes = disNodes;
_disValues = disValues;
@@ -82,7 +82,7 @@ public:
/// Sets a vector of values specifying the distribution.
/// The first value specifies the point id, the second the value for that point.
- void setDisValues(const std::vector< std::pair<size_t, double> > &dis_values);
+ void setDisValues(const std::vector< std::pair<std::size_t, double> > &dis_values);
/// Removes all distribution values
void clearDisValues() { _disValues.resize(0); };
@@ -96,7 +96,7 @@ public:
protected:
CondType _type;
std::string _geoName;
- std::vector<size_t> _disNodes;
+ std::vector<std::size_t> _disNodes;
std::vector<double> _disValues;
std::string _associated_geometry;
};
diff --git a/FemLib/SourceTerm.h b/FemLib/SourceTerm.h
index 2890d2a809f9391ba0e45ad37758ae474710c34a..f266c002bd04b9740b065a97bbdb08388e5a4e0a 100644
--- a/FemLib/SourceTerm.h
+++ b/FemLib/SourceTerm.h
@@ -28,15 +28,15 @@ public:
: FEMCondition(cond, FEMCondition::SOURCE_TERM) {};
~SourceTerm() {}
- size_t getTimType() const {return _tim_type; }
- void setTimType(size_t value) { _tim_type = value; }
+ std::size_t getTimType() const {return _tim_type; }
+ void setTimType(std::size_t value) { _tim_type = value; }
// Legacy function (only required for ascii st-files): reads values for 'direct' source terms
static void getDirectNodeValues(const std::string &filename,
- std::vector< std::pair<size_t, double> > &nodes_values);
+ std::vector< std::pair<std::size_t, double> > &nodes_values);
private:
- size_t _tim_type;
+ std::size_t _tim_type;
};
#endif //SOURCETERM_H
diff --git a/FileIO/GMSInterface.h b/FileIO/GMSInterface.h
index 0f20e7151c10ab11820fda08a29e843d46e20270..c421f6bc98839b68853d27cc6ccf8d6daf55a47a 100644
--- a/FileIO/GMSInterface.h
+++ b/FileIO/GMSInterface.h
@@ -70,7 +70,7 @@ private:
static std::vector<std::string> readSoilIDfromFile(const std::string &filename);
/// Finds the ID assigned to soilName or creates a new one ( this method is called from writeBoreholeToGMS() )
- static size_t getSoilID(std::vector<std::string> &soilID, std::string &soilName);
+ static std::size_t getSoilID(std::vector<std::string> &soilID, std::string &soilName);
};
#endif /* GMSINTERFACE_H_ */
diff --git a/FileIO/MeshIO/GMSHAdaptiveMeshDensity.h b/FileIO/MeshIO/GMSHAdaptiveMeshDensity.h
index 45c750c50e2cbf462b1be596b49967c9dbbd7934..0966ef2f90cc1be0507b8dfbf19c978e9e333477 100644
--- a/FileIO/MeshIO/GMSHAdaptiveMeshDensity.h
+++ b/FileIO/MeshIO/GMSHAdaptiveMeshDensity.h
@@ -30,13 +30,13 @@ namespace FileIO {
class GMSHAdaptiveMeshDensity: public GMSHMeshDensityStrategy {
public:
- GMSHAdaptiveMeshDensity(double pnt_density, double station_density, size_t max_pnts_per_leaf);
+ GMSHAdaptiveMeshDensity(double pnt_density, double station_density, std::size_t max_pnts_per_leaf);
virtual ~GMSHAdaptiveMeshDensity();
void init(std::vector<GeoLib::Point const*> const& pnts);
double getMeshDensityAtPoint(GeoLib::Point const*const pnt) const;
void addPoints(std::vector<GeoLib::Point const*> const& pnts);
double getMeshDensityAtStation(GeoLib::Point const*const) const;
- void getSteinerPoints (std::vector<GeoLib::Point*> & pnts, size_t additional_levels = 0) const;
+ void getSteinerPoints (std::vector<GeoLib::Point*> & pnts, std::size_t additional_levels = 0) const;
#ifndef NDEBUG
void getQuadTreeGeometry(std::vector<GeoLib::Point*> &pnts, std::vector<GeoLib::Polyline*> &plys) const;
#endif
@@ -44,7 +44,7 @@ public:
private:
double _pnt_density;
double _station_density;
- size_t _max_pnts_per_leaf;
+ std::size_t _max_pnts_per_leaf;
GeoLib::QuadTree<GeoLib::Point> *_quad_tree;
};
diff --git a/FileIO/MeshIO/GMSHInterface.h b/FileIO/MeshIO/GMSHInterface.h
index cffa6ebea507e8485cf2b728a66828f2286bc296..a964aa96bbf78c8c89290ec5d8736d34e745d17c 100644
--- a/FileIO/MeshIO/GMSHInterface.h
+++ b/FileIO/MeshIO/GMSHInterface.h
@@ -64,7 +64,7 @@ public:
GMSHInterface (GeoLib::GEOObjects & geo_objs,
bool include_stations_as_constraints,
GMSH::MeshDensityAlgorithm mesh_density_algorithm,
- double param1, double param2, size_t param3,
+ double param1, double param2, std::size_t param3,
std::vector<std::string> & selected_geometries);
/**
@@ -95,8 +95,8 @@ private:
void writePoints(std::ostream& out) const;
- size_t _n_lines;
- size_t _n_plane_sfc;
+ std::size_t _n_lines;
+ std::size_t _n_plane_sfc;
GeoLib::GEOObjects & _geo_objs;
std::vector<std::string>& _selected_geometries;
diff --git a/FileIO/MeshIO/GMSHLine.h b/FileIO/MeshIO/GMSHLine.h
index 99096aa4d756bbfee9004dd1b89f7ddb0df13762..ef7efaf2fb02e1586be8c692fab24a9cc68eb5d6 100644
--- a/FileIO/MeshIO/GMSHLine.h
+++ b/FileIO/MeshIO/GMSHLine.h
@@ -14,14 +14,14 @@ namespace FileIO {
class GMSHLine {
public:
- GMSHLine(size_t start_point_id, size_t end_point_id);
+ GMSHLine(std::size_t start_point_id, std::size_t end_point_id);
virtual ~GMSHLine();
- void write(std::ostream &os, size_t id) const;
- void resetLineData(size_t start_point_id, size_t end_point_id);
+ void write(std::ostream &os, std::size_t id) const;
+ void resetLineData(std::size_t start_point_id, std::size_t end_point_id);
private:
- size_t _start_pnt_id;
- size_t _end_pnt_id;
+ std::size_t _start_pnt_id;
+ std::size_t _end_pnt_id;
};
}
diff --git a/FileIO/MeshIO/GMSHLineLoop.h b/FileIO/MeshIO/GMSHLineLoop.h
index 51dbc4a73b0c356c4623bad7d740153425e6d415..0b1e03dcdc68859a14b5364405b8679373dc6880 100644
--- a/FileIO/MeshIO/GMSHLineLoop.h
+++ b/FileIO/MeshIO/GMSHLineLoop.h
@@ -22,7 +22,7 @@ public:
void addLine(GMSHLine* line);
bool isSurface() const { return _is_sfc; }
void setSurface(bool is_sfc) { _is_sfc = is_sfc; }
- void write(std::ostream &os, size_t offset, size_t sfc_offset = 0) const;
+ void write(std::ostream &os, std::size_t offset, std::size_t sfc_offset = 0) const;
private:
std::vector<GMSHLine*> _lines;
diff --git a/FileIO/MeshIO/GMSHPoint.h b/FileIO/MeshIO/GMSHPoint.h
index ec0a2e0b3b0596eb58507f2a66bafe26a812dc2e..ae02764aa0f5210412bfa480c46e811072d7f0c5 100644
--- a/FileIO/MeshIO/GMSHPoint.h
+++ b/FileIO/MeshIO/GMSHPoint.h
@@ -19,7 +19,7 @@ namespace FileIO {
class GMSHPoint : public GeoLib::PointWithID {
public:
- GMSHPoint(GeoLib::Point const& pnt, size_t id, double mesh_density);
+ GMSHPoint(GeoLib::Point const& pnt, std::size_t id, double mesh_density);
virtual ~GMSHPoint();
void write(std::ostream &os) const;
private:
diff --git a/FileIO/MeshIO/GMSHPolygonTree.h b/FileIO/MeshIO/GMSHPolygonTree.h
index 9adc9c2d4af52e9ea8c52dfd2c33ee34ed50fe92..bac2e17a39993f5db704c77b458c3dcf4b97579a 100644
--- a/FileIO/MeshIO/GMSHPolygonTree.h
+++ b/FileIO/MeshIO/GMSHPolygonTree.h
@@ -65,11 +65,11 @@ public:
*/
void createGMSHPoints(std::vector<FileIO::GMSHPoint*> & gmsh_pnts) const;
- virtual void writeLineLoop(size_t &line_offset, size_t &sfc_offset, std::ostream& out) const;
- void writeSubPolygonsAsLineConstraints(size_t &line_offset, size_t sfc_number, std::ostream& out) const;
- virtual void writeLineConstraints(size_t &line_offset, size_t sfc_number, std::ostream& out) const;
- void writeStations(size_t & pnt_id_offset, size_t sfc_number, std::ostream& out) const;
- void writeAdditionalPointData(size_t & pnt_id_offset, size_t sfc_number, std::ostream& out) const;
+ virtual void writeLineLoop(std::size_t &line_offset, std::size_t &sfc_offset, std::ostream& out) const;
+ void writeSubPolygonsAsLineConstraints(std::size_t &line_offset, std::size_t sfc_number, std::ostream& out) const;
+ virtual void writeLineConstraints(std::size_t &line_offset, std::size_t sfc_number, std::ostream& out) const;
+ void writeStations(std::size_t & pnt_id_offset, std::size_t sfc_number, std::ostream& out) const;
+ void writeAdditionalPointData(std::size_t & pnt_id_offset, std::size_t sfc_number, std::ostream& out) const;
private:
void getPointsFromSubPolygons(std::vector<GeoLib::Point const*>& pnts);
diff --git a/FileIO/MeshIO/TetGenInterface.h b/FileIO/MeshIO/TetGenInterface.h
index c9ebed875cb1fdb4445eb112db82a549e211e73b..ef52061de254bc9143227cffd9e28dedee29ac03 100644
--- a/FileIO/MeshIO/TetGenInterface.h
+++ b/FileIO/MeshIO/TetGenInterface.h
@@ -70,8 +70,8 @@ private:
* @param boundary_markers have the nodes boundary information (output)
* @return true, if the file header is read, false if the method detects an error
*/
- bool parseNodesFileHeader(std::string &line, size_t& n_nodes, size_t& dim,
- size_t& n_attributes, bool& boundary_markers) const;
+ bool parseNodesFileHeader(std::string &line, std::size_t& n_nodes, std::size_t& dim,
+ std::size_t& n_attributes, bool& boundary_markers) const;
/**
* method parses the lines reading the nodes from TetGen nodes file
* @param ins the input stream (input)
@@ -79,7 +79,7 @@ private:
* @param dim the spatial dimension of the node (input)
* @return true, if the nodes are read, false if the method detects an error
*/
- bool parseNodes(std::ifstream& ins, size_t n_nodes, size_t dim);
+ bool parseNodes(std::ifstream& ins, std::size_t n_nodes, std::size_t dim);
/**
* Method reads the elements from stream and stores them in the element vector of the mesh class.
@@ -96,7 +96,7 @@ private:
* @param region_attribute is on output true, if there
* @return
*/
- bool parseElementsFileHeader(std::string &line, size_t& n_tets, size_t& n_nodes_per_tet,
+ bool parseElementsFileHeader(std::string &line, std::size_t& n_tets, std::size_t& n_nodes_per_tet,
bool& region_attribute) const;
/**
* Method parses the tetrahedras and put them in the element vector of the mesh class.
@@ -106,7 +106,7 @@ private:
* @param region_attribute if region attribute is true, region information is read
* @return true, if the tetrahedras are read, false if the method detects an error
*/
- bool parseElements(std::ifstream& ins, size_t n_tets, size_t n_nodes_per_tet,
+ bool parseElements(std::ifstream& ins, std::size_t n_tets, std::size_t n_nodes_per_tet,
bool region_attribute);
/**
diff --git a/FileIO/PetrelInterface.h b/FileIO/PetrelInterface.h
index fa440c64ccbae81ca29159815e01283be49f7c3c..959d8286e3dd36b14892150ae0f32762651cc344 100644
--- a/FileIO/PetrelInterface.h
+++ b/FileIO/PetrelInterface.h
@@ -33,7 +33,7 @@ private:
std::vector<GeoLib::Point*>* pnt_vec;
std::vector<GeoLib::Point*>* well_vec;
std::vector<GeoLib::Polyline*>* ply_vec;
- static const size_t MAX_COLS_PER_ROW = 256;
+ static const std::size_t MAX_COLS_PER_ROW = 256;
};
} // end namespace FileIO
diff --git a/FileIO/XmlIO/XMLInterface.h b/FileIO/XmlIO/XMLInterface.h
index 9953c5825230d81891c8d8f38bd6fc06feabbe03..d9720480ce7200d1f9465c672e5848460b2d17bb 100644
--- a/FileIO/XmlIO/XMLInterface.h
+++ b/FileIO/XmlIO/XMLInterface.h
@@ -73,7 +73,7 @@ protected:
std::string _exportName;
std::string _schemaName;
- std::map<size_t, size_t> _idx_map;
+ std::map<std::size_t, std::size_t> _idx_map;
};
}
diff --git a/FileIO/XmlIO/XmlGmlInterface.h b/FileIO/XmlIO/XmlGmlInterface.h
index d250d0a4178f83f9ae8e4f037414dda2cf219571..dc7a0a93c6697629692605909baf12b7a1a01a1e 100644
--- a/FileIO/XmlIO/XmlGmlInterface.h
+++ b/FileIO/XmlIO/XmlGmlInterface.h
@@ -43,21 +43,21 @@ private:
/// Reads GeoLib::Point-objects from an xml-file
void readPoints ( const QDomNode &pointsRoot,
std::vector<GeoLib::Point*>* points,
- std::map<std::string, size_t>* pnt_names );
+ std::map<std::string, std::size_t>* pnt_names );
/// Reads GeoLib::Polyline-objects from an xml-file
void readPolylines ( const QDomNode &polylinesRoot,
std::vector<GeoLib::Polyline*>* polylines,
std::vector<GeoLib::Point*>* points,
- const std::vector<size_t> &pnt_id_map,
- std::map<std::string, size_t>* ply_names );
+ const std::vector<std::size_t> &pnt_id_map,
+ std::map<std::string, std::size_t>* ply_names );
/// Reads GeoLib::Surface-objects from an xml-file
void readSurfaces ( const QDomNode &surfacesRoot,
std::vector<GeoLib::Surface*>* surfaces,
std::vector<GeoLib::Point*>* points,
- const std::vector<size_t> &pnt_id_map,
- std::map<std::string, size_t>* sfc_names );
+ const std::vector<std::size_t> &pnt_id_map,
+ std::map<std::string, std::size_t>* sfc_names );
};
diff --git a/FileIO/XmlIO/XmlLutReader.h b/FileIO/XmlIO/XmlLutReader.h
index bb0a8542f63fa80fdbbd6eacb62b8c52b41cef6a..b5318e18f36e5cd1b95806a1649db10b8af0696e 100644
--- a/FileIO/XmlIO/XmlLutReader.h
+++ b/FileIO/XmlIO/XmlLutReader.h
@@ -72,10 +72,10 @@ public:
&& point.hasAttribute("b"))
{
double value = strtod((point.attribute("x")).toStdString().c_str(),0);
- char r = static_cast<int>(255 * strtod((point.attribute("r")).toStdString().c_str(),0));
- char g = static_cast<int>(255 * strtod((point.attribute("g")).toStdString().c_str(),0));
- char b = static_cast<int>(255 * strtod((point.attribute("b")).toStdString().c_str(),0));
- char o = static_cast<int>(255 * (point.hasAttribute("o") ? strtod((point.attribute("o")).toStdString().c_str(),0) : 1));
+ unsigned char r = static_cast<int>(255 * strtod((point.attribute("r")).toStdString().c_str(),0));
+ unsigned char g = static_cast<int>(255 * strtod((point.attribute("g")).toStdString().c_str(),0));
+ unsigned char b = static_cast<int>(255 * strtod((point.attribute("b")).toStdString().c_str(),0));
+ unsigned char o = static_cast<int>(255 * (point.hasAttribute("o") ? strtod((point.attribute("o")).toStdString().c_str(),0) : 1));
if (value<range[0]) range[0] = value;
if (value>range[1]) range[1] = value;
diff --git a/GeoLib/BruteForceClosestPair.h b/GeoLib/BruteForceClosestPair.h
index dad7d3b6a59977eb03a8940a0844be206722083d..d7ba5be84c754ca503ce7942c9c9957f2b8749ae 100644
--- a/GeoLib/BruteForceClosestPair.h
+++ b/GeoLib/BruteForceClosestPair.h
@@ -19,7 +19,7 @@ namespace GeoLib {
class BruteForceClosestPair : public ClosestPair {
public:
- BruteForceClosestPair(std::vector<GeoLib::Point*> const & pnts, size_t& id0, size_t& id1);
+ BruteForceClosestPair(std::vector<GeoLib::Point*> const & pnts, std::size_t& id0, std::size_t& id1);
};
} // end namespace GeoLib
diff --git a/GeoLib/ClosestPair.h b/GeoLib/ClosestPair.h
index 19a45c2cce97e5c096772118504254b55d772b1f..708241d0f8dae257900f6056eaf607703faecf84 100644
--- a/GeoLib/ClosestPair.h
+++ b/GeoLib/ClosestPair.h
@@ -24,14 +24,14 @@ namespace GeoLib {
class ClosestPair
{
public:
- ClosestPair (std::vector<GeoLib::Point*> const & pnts, size_t id0, size_t id1) :
+ ClosestPair (std::vector<GeoLib::Point*> const & pnts, std::size_t id0, std::size_t id1) :
_pnts (pnts), _id0 (id0), _id1 (id1)
{}
protected:
std::vector<GeoLib::Point*> const & _pnts;
- size_t _id0;
- size_t _id1;
+ std::size_t _id0;
+ std::size_t _id1;
};
} // end namespace GeoLib
diff --git a/GeoLib/GEOObjects.h b/GeoLib/GEOObjects.h
index d14ed15edb7c521e5ece9baed35b37a13ca96c93..daa411228e7405942e843770fff2a7e9b26dd482 100644
--- a/GeoLib/GEOObjects.h
+++ b/GeoLib/GEOObjects.h
@@ -71,7 +71,7 @@ public:
*/
virtual void addPointVec(std::vector<Point*>* points,
std::string &name,
- std::map<std::string, size_t>* pnt_names = NULL,
+ std::map<std::string, std::size_t>* pnt_names = NULL,
double eps = sqrt(std::numeric_limits<double>::min()));
/** copies the pointers to the points in the given vector to the PointVec of the provided name.
@@ -85,7 +85,7 @@ public:
* corresponding name does not exist
* */
virtual bool appendPointVec(const std::vector<Point*> &points,
- std::string const &name, std::vector<size_t>* ids = NULL);
+ std::string const &name, std::vector<std::size_t>* ids = NULL);
/**
* Method appends the point the the PointVec object with the name name. The PointVec
@@ -97,7 +97,7 @@ public:
* @return true, if the point could be inserted (i.e. was not already contained in the vector)
* else false (the user have to delete the point itself)
*/
- bool appendPoint(Point* point, std::string const &name, size_t& id);
+ bool appendPoint(Point* point, std::string const &name, std::size_t& id);
/**
* Returns the point vector with the given name.
@@ -148,7 +148,7 @@ public:
*/
virtual void addPolylineVec(std::vector<Polyline*>* lines,
const std::string &name,
- std::map<std::string,size_t>* ply_names = NULL);
+ std::map<std::string,std::size_t>* ply_names = NULL);
/** copies the pointers to the polylines in the vector to the PolylineVec with provided name.
* the pointers are managed by the GEOObjects, i.e. GEOObjects will delete the Polylines at the
@@ -190,7 +190,7 @@ public:
/** Adds a vector of surfaces with the given name to GEOObjects. */
virtual void addSurfaceVec(std::vector<Surface*>* surfaces,
const std::string &name,
- std::map<std::string, size_t>* sfc_names = NULL);
+ std::map<std::string, std::size_t>* sfc_names = NULL);
/**
* Copies the surfaces in the vector to the SurfaceVec with the given name.
@@ -228,7 +228,7 @@ public:
/// Returns the names of all geometry vectors.
void getGeometryNames (std::vector<std::string>& names) const;
- const std::string getElementNameByID(const std::string &geometry_name, GeoLib::GEOTYPE type, size_t id) const;
+ const std::string getElementNameByID(const std::string &geometry_name, GeoLib::GEOTYPE type, std::size_t id) const;
/// Returns the names of all station vectors.
void getStationVectorNames(std::vector<std::string>& names) const;
diff --git a/GeoLib/Grid.h b/GeoLib/Grid.h
index b0b9eb5e408e4a7f79db3dbf156d49f81a1d410a..9de5c8ccb238bf150d52f60fb423c52735cbeb84 100644
--- a/GeoLib/Grid.h
+++ b/GeoLib/Grid.h
@@ -13,7 +13,6 @@
#ifndef GRID_H_
#define GRID_H_
-#include <type_traits>
#include <vector>
// GeoLib
@@ -47,12 +46,12 @@ public:
*
*/
template <typename InputIterator>
- Grid(InputIterator first, InputIterator last, size_t max_num_per_grid_cell = 512) :
+ Grid(InputIterator first, InputIterator last, std::size_t max_num_per_grid_cell = 512) :
GeoLib::AABB(), _grid_cell_nodes_map(NULL)
{
// compute axis aligned bounding box
InputIterator it(first);
- size_t n_pnts(0);
+ std::size_t n_pnts(0);
while (it != last) {
n_pnts++;
this->update(copyOrAddress(*it)->getCoords());
@@ -60,7 +59,7 @@ public:
}
double delta[3] = { 0.0, 0.0, 0.0 };
- for (size_t k(0); k < 3; k++) {
+ for (std::size_t k(0); k < 3; k++) {
// make the bounding box a little bit bigger,
// such that the node with maximal coordinates fits into the grid
_max_pnt[k] *= (1.0 + 1e-6);
@@ -77,7 +76,7 @@ public:
// 1d case y = z = 0
if (fabs(delta[1]) < std::numeric_limits<double>::epsilon() &&
fabs(delta[2]) < std::numeric_limits<double>::epsilon()) {
- _n_steps[0] = static_cast<size_t> (ceil(n_pnts / (double) max_num_per_grid_cell));
+ _n_steps[0] = static_cast<std::size_t> (ceil(n_pnts / (double) max_num_per_grid_cell));
_n_steps[1] = 1;
_n_steps[2] = 1;
} else {
@@ -85,7 +84,7 @@ public:
if (fabs(delta[0]) < std::numeric_limits<double>::epsilon() &&
fabs(delta[2]) < std::numeric_limits<double>::epsilon()) {
_n_steps[0] = 1;
- _n_steps[1] = static_cast<size_t> (ceil(n_pnts / (double) max_num_per_grid_cell));
+ _n_steps[1] = static_cast<std::size_t> (ceil(n_pnts / (double) max_num_per_grid_cell));
_n_steps[2] = 1;
} else {
// 1d case x = y = 0
@@ -93,16 +92,16 @@ public:
< std::numeric_limits<double>::epsilon()) {
_n_steps[0] = 1;
_n_steps[1] = 1;
- _n_steps[2] = static_cast<size_t> (ceil(n_pnts / (double) max_num_per_grid_cell));
+ _n_steps[2] = static_cast<std::size_t> (ceil(n_pnts / (double) max_num_per_grid_cell));
} else {
// 2d case
if (fabs(delta[1]) < std::numeric_limits<double>::epsilon()) {
- _n_steps[0] = static_cast<size_t> (ceil(sqrt(n_pnts * delta[0] / (max_num_per_grid_cell * delta[2]))));
+ _n_steps[0] = static_cast<std::size_t> (ceil(sqrt(n_pnts * delta[0] / (max_num_per_grid_cell * delta[2]))));
_n_steps[1] = 1;
- _n_steps[2] = static_cast<size_t> (ceil(_n_steps[0] * delta[2] / delta[0]));
+ _n_steps[2] = static_cast<std::size_t> (ceil(_n_steps[0] * delta[2] / delta[0]));
} else {
- _n_steps[0] = static_cast<size_t> (ceil(sqrt(n_pnts * delta[0] / (max_num_per_grid_cell * delta[1]))));
- _n_steps[1] = static_cast<size_t> (ceil(_n_steps[0] * delta[1] / delta[0]));
+ _n_steps[0] = static_cast<std::size_t> (ceil(sqrt(n_pnts * delta[0] / (max_num_per_grid_cell * delta[1]))));
+ _n_steps[1] = static_cast<std::size_t> (ceil(_n_steps[0] * delta[1] / delta[0]));
_n_steps[2] = 1;
}
}
@@ -110,17 +109,17 @@ public:
}
} else {
// 3d case
- _n_steps[0] = static_cast<size_t> (ceil(pow(n_pnts * delta[0] * delta[0]
+ _n_steps[0] = static_cast<std::size_t> (ceil(pow(n_pnts * delta[0] * delta[0]
/ (max_num_per_grid_cell * delta[1] * delta[2]), 1. / 3.)));
- _n_steps[1] = static_cast<size_t> (ceil(_n_steps[0] * delta[1] / delta[0]));
- _n_steps[2] = static_cast<size_t> (ceil(_n_steps[0] * delta[2] / delta[0]));
+ _n_steps[1] = static_cast<std::size_t> (ceil(_n_steps[0] * delta[1] / delta[0]));
+ _n_steps[2] = static_cast<std::size_t> (ceil(_n_steps[0] * delta[2] / delta[0]));
}
- const size_t n_plane(_n_steps[0] * _n_steps[1]);
+ const std::size_t n_plane(_n_steps[0] * _n_steps[1]);
_grid_cell_nodes_map = new std::vector<POINT*>[n_plane * _n_steps[2]];
// some frequently used expressions to fill the grid vectors
- for (size_t k(0); k < 3; k++) {
+ for (std::size_t k(0); k < 3; k++) {
_step_sizes[k] = delta[k] / _n_steps[k];
_inverse_step_sizes[k] = 1.0 / _step_sizes[k];
}
@@ -129,9 +128,9 @@ public:
it = first;
while (it != last) {
double const* const pnt(copyOrAddress(*it)->getCoords());
- const size_t i(static_cast<size_t> ((pnt[0] - _min_pnt[0]) * _inverse_step_sizes[0]));
- const size_t j(static_cast<size_t> ((pnt[1] - _min_pnt[1]) * _inverse_step_sizes[1]));
- const size_t k(static_cast<size_t> ((pnt[2] - _min_pnt[2]) * _inverse_step_sizes[2]));
+ const std::size_t i(static_cast<std::size_t> ((pnt[0] - _min_pnt[0]) * _inverse_step_sizes[0]));
+ const std::size_t j(static_cast<std::size_t> ((pnt[1] - _min_pnt[1]) * _inverse_step_sizes[1]));
+ const std::size_t k(static_cast<std::size_t> ((pnt[2] - _min_pnt[2]) * _inverse_step_sizes[2]));
if (i >= _n_steps[0] || j >= _n_steps[1] || k >= _n_steps[2]) {
std::cout << "error computing indices " << std::endl;
@@ -142,8 +141,8 @@ public:
}
#ifndef NDEBUG
- size_t pnts_cnt(0);
- for (size_t k(0); k < n_plane * _n_steps[2]; k++)
+ std::size_t pnts_cnt(0);
+ for (std::size_t k(0); k < n_plane * _n_steps[2]; k++)
pnts_cnt += _grid_cell_nodes_map[k].size();
assert(n_pnts==pnts_cnt);
@@ -174,7 +173,7 @@ public:
*/
POINT* getNearestPoint(double const*const pnt) const
{
- size_t coords[3];
+ std::size_t coords[3];
getGridCoords(pnt, coords);
double sqr_min_dist (MathLib::sqrDist(&_min_pnt, &_max_pnt));
@@ -197,10 +196,10 @@ public:
// search in all border cells for at least one neighbor
double sqr_min_dist_tmp;
POINT* nearest_pnt_tmp(NULL);
- size_t offset(1);
+ std::size_t offset(1);
while (nearest_pnt == NULL) {
- size_t tmp_coords[3];
+ std::size_t tmp_coords[3];
for (tmp_coords[0] = coords[0]-offset; tmp_coords[0]<coords[0]+offset; tmp_coords[0]++) {
for (tmp_coords[1] = coords[1]-offset; tmp_coords[1]<coords[1]+offset; tmp_coords[1]++) {
for (tmp_coords[2] = coords[2]-offset; tmp_coords[2]<coords[2]+offset; tmp_coords[2]++) {
@@ -228,11 +227,11 @@ public:
std::vector<std::vector<POINT*> const*> vecs_of_pnts;
getVecsOfGridCellsIntersectingCube(pnt, len, vecs_of_pnts);
- const size_t n_vecs(vecs_of_pnts.size());
- for (size_t j(0); j<n_vecs; j++) {
+ const std::size_t n_vecs(vecs_of_pnts.size());
+ for (std::size_t j(0); j<n_vecs; j++) {
std::vector<POINT*> const& pnts(*(vecs_of_pnts[j]));
- const size_t n_pnts(pnts.size());
- for (size_t k(0); k<n_pnts; k++) {
+ const std::size_t n_pnts(pnts.size());
+ for (std::size_t k(0); k<n_pnts; k++) {
const double sqr_dist (MathLib::sqrDist(pnt, pnts[k]->getCoords()));
if (sqr_dist < sqr_min_dist) {
sqr_min_dist = sqr_dist;
@@ -272,7 +271,7 @@ private:
* @param pnt (input) the coordinates of the point
* @param coords (output) the coordinates of the grid cell
*/
- inline void getGridCoords(double const*const pnt, size_t* coords) const;
+ inline void getGridCoords(double const*const pnt, std::size_t* coords) const;
/**
*
@@ -304,20 +303,20 @@ private:
* ordered in the same sequence as above described
* @param coords coordinates of the grid cell
*/
- void getPointCellBorderDistances(double const*const pnt, double dists[6], size_t const* const coords) const;
+ void getPointCellBorderDistances(double const*const pnt, double dists[6], std::size_t const* const coords) const;
- bool calcNearestPointInGridCell(double const* const pnt, size_t const* const coords,
+ bool calcNearestPointInGridCell(double const* const pnt, std::size_t const* const coords,
double &sqr_min_dist,
POINT* &nearest_pnt) const
{
- const size_t grid_idx (coords[0] + coords[1] * _n_steps[0] + coords[2] * _n_steps[0] * _n_steps[1]);
- std::vector<typename std::add_pointer<typename std::remove_pointer<POINT>::type>::type> const& pnts(_grid_cell_nodes_map[grid_idx]);
+ const std::size_t grid_idx (coords[0] + coords[1] * _n_steps[0] + coords[2] * _n_steps[0] * _n_steps[1]);
+ std::vector<typename std::tr1::add_pointer<typename std::tr1::remove_pointer<POINT>::type>::type> const& pnts(_grid_cell_nodes_map[grid_idx]);
if (pnts.empty()) return false;
- const size_t n_pnts(pnts.size());
+ const std::size_t n_pnts(pnts.size());
sqr_min_dist = MathLib::sqrDist(pnts[0]->getCoords(), pnt);
nearest_pnt = pnts[0];
- for (size_t i(1); i < n_pnts; i++) {
+ for (std::size_t i(1); i < n_pnts; i++) {
const double sqr_dist(MathLib::sqrDist(pnts[i]->getCoords(), pnt));
if (sqr_dist < sqr_min_dist) {
sqr_min_dist = sqr_dist;
@@ -333,7 +332,7 @@ private:
double _step_sizes[3];
double _inverse_step_sizes[3];
- size_t _n_steps[3];
+ std::size_t _n_steps[3];
/**
* This is an array that stores pointers to POINT objects.
*/
@@ -345,19 +344,19 @@ void Grid<POINT>::getVecsOfGridCellsIntersectingCube(double const* const pnt, do
std::vector<std::vector<POINT*> const*>& pnts) const
{
double tmp_pnt[3] = { pnt[0] - half_len, pnt[1] - half_len, pnt[2] - half_len }; // min
- size_t min_coords[3];
+ std::size_t min_coords[3];
getGridCoords(tmp_pnt, min_coords);
tmp_pnt[0] = pnt[0] + half_len;
tmp_pnt[1] = pnt[1] + half_len;
tmp_pnt[2] = pnt[2] + half_len;
- size_t max_coords[3];
+ std::size_t max_coords[3];
getGridCoords(tmp_pnt, max_coords);
- size_t coords[3], steps0_x_steps1(_n_steps[0] * _n_steps[1]);
+ std::size_t coords[3], steps0_x_steps1(_n_steps[0] * _n_steps[1]);
for (coords[0] = min_coords[0]; coords[0] < max_coords[0] + 1; coords[0]++) {
for (coords[1] = min_coords[1]; coords[1] < max_coords[1] + 1; coords[1]++) {
- const size_t coords0_p_coords1_x_steps0(coords[0] + coords[1] * _n_steps[0]);
+ const std::size_t coords0_p_coords1_x_steps0(coords[0] + coords[1] * _n_steps[0]);
for (coords[2] = min_coords[2]; coords[2] < max_coords[2] + 1; coords[2]++) {
pnts.push_back(&(_grid_cell_nodes_map[coords0_p_coords1_x_steps0 + coords[2]
* steps0_x_steps1]));
@@ -380,16 +379,16 @@ void Grid<POINT>::createGridGeometry(GeoLib::GEOObjects* geo_obj) const
const double dz ((urb[2]-llf[2])/_n_steps[2]);
// create grid names and grid boxes as geometry
- for (size_t i(0); i<_n_steps[0]; i++) {
- for (size_t j(0); j<_n_steps[1]; j++) {
- for (size_t k(0); k<_n_steps[2]; k++) {
+ for (std::size_t i(0); i<_n_steps[0]; i++) {
+ for (std::size_t j(0); j<_n_steps[1]; j++) {
+ for (std::size_t k(0); k<_n_steps[2]; k++) {
std::string name("Grid-");
- name += number2str<size_t>(i);
+ name += number2str<std::size_t>(i);
name +="-";
- name += number2str<size_t>(j);
+ name += number2str<std::size_t>(j);
name += "-";
- name += number2str<size_t> (k);
+ name += number2str<std::size_t> (k);
grid_names.push_back(name);
std::vector<GeoLib::Point*>* points (new std::vector<GeoLib::Point*>);
@@ -405,14 +404,14 @@ void Grid<POINT>::createGridGeometry(GeoLib::GEOObjects* geo_obj) const
std::vector<GeoLib::Polyline*>* plys (new std::vector<GeoLib::Polyline*>);
GeoLib::Polyline* ply0 (new GeoLib::Polyline(*points));
- for (size_t l(0); l<4; l++) {
+ for (std::size_t l(0); l<4; l++) {
ply0->addPoint(l);
}
ply0->addPoint(0);
plys->push_back(ply0);
GeoLib::Polyline* ply1 (new GeoLib::Polyline(*points));
- for (size_t l(4); l<8; l++) {
+ for (std::size_t l(4); l<8; l++) {
ply1->addPoint(l);
}
ply1->addPoint(4);
@@ -449,23 +448,23 @@ void Grid<POINT>::createGridGeometry(GeoLib::GEOObjects* geo_obj) const
#endif
template <typename POINT>
-void Grid<POINT>::getGridCoords(double const*const pnt, size_t* coords) const
+void Grid<POINT>::getGridCoords(double const*const pnt, std::size_t* coords) const
{
- for (size_t k(0); k<3; k++) {
+ for (std::size_t k(0); k<3; k++) {
if (pnt[k] < _min_pnt[k]) {
coords[k] = 0;
} else {
if (pnt[k] > _max_pnt[k]) {
coords[k] = _n_steps[k]-1;
} else {
- coords[k] = static_cast<size_t>((pnt[k]-_min_pnt[k]) * _inverse_step_sizes[k]);
+ coords[k] = static_cast<std::size_t>((pnt[k]-_min_pnt[k]) * _inverse_step_sizes[k]);
}
}
}
}
template <typename POINT>
-void Grid<POINT>::getPointCellBorderDistances(double const*const pnt, double dists[6], size_t const* const coords) const
+void Grid<POINT>::getPointCellBorderDistances(double const*const pnt, double dists[6], std::size_t const* const coords) const
{
dists[0] = (pnt[2] - _min_pnt[2] + coords[2]*_step_sizes[2]); // bottom
diff --git a/GeoLib/OctTree.h b/GeoLib/OctTree.h
index 3e8a8ae602c176c8f2a043045ae64611b5412ae2..b160ff503740211bfa9a50cc48678e30793d7c64 100644
--- a/GeoLib/OctTree.h
+++ b/GeoLib/OctTree.h
@@ -18,7 +18,7 @@ namespace GeoLib {
template <typename POINT> class OctTree {
public:
- static OctTree<POINT>* createOctTree(POINT & ll, POINT & ur, size_t max_points_per_node)
+ static OctTree<POINT>* createOctTree(POINT & ll, POINT & ur, std::size_t max_points_per_node)
{
const double dx(ur[0] - ll[0]);
const double dy(ur[1] - ll[1]);
@@ -49,7 +49,7 @@ public:
virtual ~OctTree()
{
- for (size_t k(0); k < 8; k++)
+ for (std::size_t k(0); k < 8; k++)
delete _childs[k];
}
@@ -69,7 +69,7 @@ public:
if ((*pnt)[2] > _ur[2]) return false;
if (!_is_leaf) {
- for (size_t k(0); k < 8; k++) {
+ for (std::size_t k(0); k < 8; k++) {
if (_childs[k]->addPoint (pnt)) {
return true;
}
@@ -78,7 +78,7 @@ public:
// check if point is already in OctTree
bool pnt_in_tree (false);
- for (size_t k(0); k < _pnts.size() && !pnt_in_tree; k++) {
+ for (std::size_t k(0); k < _pnts.size() && !pnt_in_tree; k++) {
const double sqr_dist (MathLib::sqrDist( (_pnts[k])->getCoords(), pnt->getCoords() ));
if (sqr_dist < std::numeric_limits<double>::epsilon())
pnt_in_tree = true;
@@ -115,7 +115,7 @@ public:
pnts.push_back(*it);
}
} else {
- for (size_t k(0); k<8; k++) {
+ for (std::size_t k(0); k<8; k++) {
_childs[k]->getPointsInRange(min, max, pnts);
}
}
@@ -143,7 +143,7 @@ private:
_ll (ll), _ur (ur), _is_leaf (true)
{
// init childs
- for (size_t k(0); k < 8; k++)
+ for (std::size_t k(0); k < 8; k++)
_childs[k] = NULL;
}
@@ -197,10 +197,10 @@ private:
_childs[SEU] = new OctTree<POINT> (p0, p1);
// distribute points to sub quadtrees
- const size_t n_pnts(_pnts.size());
- for (size_t j(0); j < n_pnts; j++) {
+ const std::size_t n_pnts(_pnts.size());
+ for (std::size_t j(0); j < n_pnts; j++) {
bool nfound(true);
- for (size_t k(0); k < 8 && nfound; k++) {
+ for (std::size_t k(0); k < 8 && nfound; k++) {
if (_childs[k]->addPoint(_pnts[j])) {
nfound = false;
}
@@ -236,10 +236,10 @@ private:
/**
* maximum number of points per leaf
*/
- static size_t _max_points_per_node;
+ static std::size_t _max_points_per_node;
};
-template <typename POINT> size_t OctTree<POINT>::_max_points_per_node = 0;
+template <typename POINT> std::size_t OctTree<POINT>::_max_points_per_node = 0;
} // end namespace GeoLib
diff --git a/GeoLib/PointVec.h b/GeoLib/PointVec.h
index 05723ad019b1fdea69cd950e5423c34ebd94bba7..f90393b30e5e0c381a9ba2463fb16355abd512f5 100644
--- a/GeoLib/PointVec.h
+++ b/GeoLib/PointVec.h
@@ -71,7 +71,7 @@ public:
* @return an object of type PointVec
*/
PointVec (const std::string& name, std::vector<Point*>* points,
- std::map<std::string, size_t>* name_id_map = NULL,
+ std::map<std::string, std::size_t>* name_id_map = NULL,
PointType type = PointVec::POINT, double rel_eps = sqrt(std::numeric_limits<double>::min()));
/** Destructor deletes all Points of this PointVec. */
@@ -84,7 +84,7 @@ public:
* @param pnt the pointer to the Point
* @return the id of the point within the internal vector
*/
- size_t push_back (Point* pnt);
+ std::size_t push_back (Point* pnt);
/**
* push_back adds new elements at the end of the vector _data_vec.
@@ -101,16 +101,16 @@ public:
std::vector<Point*>* filterStations(const std::vector<PropertyBounds> &bounds) const;
- const std::vector<size_t>& getIDMap () const { return _pnt_id_map; }
+ const std::vector<std::size_t>& getIDMap () const { return _pnt_id_map; }
double getShortestPointDistance () const;
const GeoLib::AABB& getAxisAlignedBoundingBox () const;
/// Returns a subset of this point vector containing only the points specified in "subset" as PointWithID-objects
- std::vector<GeoLib::Point*>* getSubset(const std::vector<size_t> &subset);
+ std::vector<GeoLib::Point*>* getSubset(const std::vector<std::size_t> &subset);
private:
- void makePntsUnique (std::vector<GeoLib::Point*>* pnt_vec, std::vector<size_t> &pnt_id_map, double eps = sqrt(std::numeric_limits<double>::min()));
+ void makePntsUnique (std::vector<GeoLib::Point*>* pnt_vec, std::vector<std::size_t> &pnt_id_map, double eps = sqrt(std::numeric_limits<double>::min()));
/** copy constructor doesn't have an implementation */
// compiler does not create a (possible unwanted) copy constructor
@@ -123,7 +123,7 @@ private:
// this way the compiler does not create a (possible unwanted) assignment operator
PointVec& operator= (const PointVec& rhs);
- size_t uniqueInsert (Point* pnt);
+ std::size_t uniqueInsert (Point* pnt);
/** the type of the point (\sa enum PointType) */
PointType _type;
@@ -132,7 +132,7 @@ private:
* permutation of the geometric elements according
* to their lexicographical order
*/
- std::vector<size_t> _pnt_id_map;
+ std::vector<std::size_t> _pnt_id_map;
/**
* method calculates the shortest distance of points inside the _pnt_vec
diff --git a/GeoLib/PointWithID.h b/GeoLib/PointWithID.h
index 7d6a1dddf0838ef4581d2b8c38f7678a21d1483a..9dda8128dfd1748a500f5aa64b1eb5be5e4d5ed0 100644
--- a/GeoLib/PointWithID.h
+++ b/GeoLib/PointWithID.h
@@ -22,15 +22,15 @@ namespace GeoLib
*/
class PointWithID: public Point {
public:
- PointWithID(double x0, double x1, double x2, size_t id) :
+ PointWithID(double x0, double x1, double x2, std::size_t id) :
Point(x0, x1, x2), _id(id)
{}
- PointWithID(double const* const coords, size_t id) :
+ PointWithID(double const* const coords, std::size_t id) :
Point(coords), _id(id)
{}
- PointWithID(GeoLib::Point const& pnt, size_t id) :
+ PointWithID(GeoLib::Point const& pnt, std::size_t id) :
Point(pnt), _id(id)
{}
@@ -42,10 +42,10 @@ public:
Point(), _id(0)
{}
- size_t getID() const { return _id; }
+ std::size_t getID() const { return _id; }
protected:
- size_t _id;
+ std::size_t _id;
};
} // end namespace GeoLib
diff --git a/GeoLib/Polygon.h b/GeoLib/Polygon.h
index 7467f09c7d233ad324a0ff9937cdc82f8ed59215..b2d48630edebf45900a3bf781b25914d58369ea5 100644
--- a/GeoLib/Polygon.h
+++ b/GeoLib/Polygon.h
@@ -104,7 +104,7 @@ public:
bool getNextIntersectionPointPolygonLine(GeoLib::Point const & a,
GeoLib::Point const & b,
GeoLib::Point* intersection_pnt,
- size_t& seg_num) const;
+ std::size_t& seg_num) const;
void computeListOfSimplePolygons ();
@@ -119,7 +119,7 @@ private:
* @param pnt point that is edge type computed for
* @return a value of enum EdgeType
*/
- EdgeType::value getEdgeType (size_t k, GeoLib::Point const & pnt) const;
+ EdgeType::value getEdgeType (std::size_t k, GeoLib::Point const & pnt) const;
void calculateAxisAlignedBoundingBox ();
void ensureCWOrientation ();
@@ -141,7 +141,7 @@ private:
GeoLib::Polygon* createPolygonFromCircle (GeoLib::Point const& middle_pnt,
double radius,
std::vector<GeoLib::Point*> & pnts,
- size_t resolution = 12);
+ std::size_t resolution = 12);
/**
* comparison operator for polygons
diff --git a/GeoLib/Polyline.h b/GeoLib/Polyline.h
index cf7964f158f8d0bd47e44e1b4d6ebe33e41dce41..4ac1648d17403959d0064bd95294255335e9dfae 100644
--- a/GeoLib/Polyline.h
+++ b/GeoLib/Polyline.h
@@ -70,7 +70,7 @@ public:
* the (internal) _ply_pnts vector the polyline is based on.
* @param pnt_id
*/
- virtual void addPoint(size_t pnt_id);
+ virtual void addPoint(std::size_t pnt_id);
/**
* Method inserts a new point (that have to be inside the _ply_pnts vector)
@@ -78,7 +78,7 @@ public:
* @param pos the position in the polyline, pos have to be a value into the interval [0, number of points)
* @param pnt_id the id of the new point in the vector of points the polyline is based on
*/
- virtual void insertPoint(size_t pos, size_t pnt_id);
+ virtual void insertPoint(std::size_t pos, std::size_t pnt_id);
/**
* Closes a polyline by adding a line segment that connects start- and end-point.
@@ -96,7 +96,7 @@ public:
* returns the number of points,
* the number of segments is about one smaller
* */
- size_t getNumberOfPoints() const;
+ std::size_t getNumberOfPoints() const;
/** returns true if the polyline is closed */
bool isClosed() const;
@@ -107,29 +107,29 @@ public:
* @param pnt_id the id of the point
* @return true if the point is part of the polyline, else false
*/
- bool isPointIDInPolyline(size_t pnt_id) const;
+ bool isPointIDInPolyline(std::size_t pnt_id) const;
/**
* returns the index of the i-th polyline point
* in the point vector
*/
- size_t getPointID(size_t i) const;
+ std::size_t getPointID(std::size_t i) const;
/**
* Changes a point index for one point in a line
* @param idx Index of point in line
* @param id ID of point in PointVec object
*/
- void setPointID(size_t idx, size_t id);
+ void setPointID(std::size_t idx, std::size_t id);
/** \brief const access operator for the access to the i-th point of the polyline.
*/
- const Point* operator[](size_t i) const;
+ const Point* operator[](std::size_t i) const;
/**
* \brief returns the i-th point contained in the polyline
* */
- const Point* getPoint(size_t i) const;
+ const Point* getPoint(std::size_t i) const;
std::vector<Point*> const& getPointsVec () const;
@@ -138,7 +138,7 @@ public:
* @param k the k-th line segment
* @return the length of the polyline until the k-th line segment
*/
- double getLength (size_t k) const;
+ double getLength (std::size_t k) const;
/**
* get the complete length vector
@@ -157,17 +157,17 @@ protected:
* @param pnt the point
* @return a value of enum LOCATION
*/
- Location::type getLocationOfPoint (size_t k, GeoLib::Point const & pnt) const;
+ Location::type getLocationOfPoint (std::size_t k, GeoLib::Point const & pnt) const;
static bool pointsAreIdentical(const std::vector<Point*> &pnt_vec,
- size_t i,
- size_t j,
+ std::size_t i,
+ std::size_t j,
double prox);
/** a reference to the vector of pointers to the geometric points */
const std::vector<Point*> &_ply_pnts;
/** position of pointers to the geometric points */
- std::vector<size_t> _ply_pnt_ids;
+ std::vector<std::size_t> _ply_pnt_ids;
/**
* the k-th element of the vector contains the length of the polyline until the k-th segment
*/
@@ -177,7 +177,7 @@ protected:
/** overload the output operator for class Polyline */
std::ostream& operator<< (std::ostream &os, Polyline const& pl);
-bool containsEdge (const Polyline& ply, size_t id0, size_t id1);
+bool containsEdge (const Polyline& ply, std::size_t id0, std::size_t id1);
bool isLineSegmentIntersecting (const Polyline& ply, GeoLib::Point const& s0, GeoLib::Point const& s1);
diff --git a/GeoLib/PolylineWithSegmentMarker.h b/GeoLib/PolylineWithSegmentMarker.h
index 4c6a156efd4150a639b81a4b745d730f303ae49e..bb386d59d83df7f59e8bd7a61f1e9cf30936588a 100644
--- a/GeoLib/PolylineWithSegmentMarker.h
+++ b/GeoLib/PolylineWithSegmentMarker.h
@@ -21,20 +21,20 @@ public:
* @param seg_num the segment number that should be marked
* @param mark_val the value of the flag (true or false)
*/
- void markSegment(size_t seg_num, bool mark_val = true);
+ void markSegment(std::size_t seg_num, bool mark_val = true);
/**
* Method returns the value of the mark for the given segment.
* @param seg_num segment number
* @return either true if the segment is marked or false else
*/
- bool isSegmentMarked(size_t seg_num) const;
+ bool isSegmentMarked(std::size_t seg_num) const;
/**
* Method calls @see Polyline::addPoint() and initializes the mark of the
* corresponding line segment.
* @param pnt_id @see Polyline::addPoint()
*/
- virtual void addPoint(size_t pnt_id);
+ virtual void addPoint(std::size_t pnt_id);
/**
* Method calls the @see Polyline::insertPoint() and initializes the inserted line segment with the same
@@ -42,7 +42,7 @@ public:
* @param pos @see Polyline::insertPoint()
* @param pnt_id @see Polyline::insertPoint()
*/
- virtual void insertPoint(size_t pos, size_t pnt_id);
+ virtual void insertPoint(std::size_t pos, std::size_t pnt_id);
private:
std::vector<bool> _marker;
diff --git a/GeoLib/QuadTree.h b/GeoLib/QuadTree.h
index 7a6508881ef17bc9a939cb8d2bedeb9c0e0969ad..b5d7f388b22049ee7cc4875c4a80d3f86b5a174d 100644
--- a/GeoLib/QuadTree.h
+++ b/GeoLib/QuadTree.h
@@ -42,14 +42,14 @@ public:
* @param ll lower left point of the square
* @param ur upper right point of the square
*/
- QuadTree(POINT const& ll, POINT const& ur, size_t max_points_per_node) :
+ QuadTree(POINT const& ll, POINT const& ur, std::size_t max_points_per_node) :
_father (NULL), _ll (ll), _ur (ur), _depth (0), _is_leaf (true),
_max_points_per_node (max_points_per_node)
{
assert (_max_points_per_node > 0);
// init childs
- for (size_t k(0); k < 4; k++)
+ for (std::size_t k(0); k < 4; k++)
_childs[k] = NULL;
if ((_ur[0] - _ll[0]) > (_ur[1] - _ll[1]))
@@ -67,7 +67,7 @@ public:
~QuadTree()
{
if (_is_leaf)
- for (size_t k(0); k < 4; k++)
+ for (std::size_t k(0); k < 4; k++)
delete _childs[k];
}
@@ -85,13 +85,13 @@ public:
if ((*pnt)[1] > _ur[1]) return false;
if (!_is_leaf)
- for (size_t k(0); k < 4; k++)
+ for (std::size_t k(0); k < 4; k++)
if (_childs[k]->addPoint (pnt))
return true;
// check if point is already in quadtree
bool pnt_in_quadtree (false);
- for (size_t k(0); k < _pnts.size() && !pnt_in_quadtree; k++) {
+ for (std::size_t k(0); k < _pnts.size() && !pnt_in_quadtree; k++) {
const double v0((*(_pnts[k]))[0] - (*pnt)[0]);
const double v1((*(_pnts[k]))[1] - (*pnt)[1]);
const double sqr_dist (v0*v0 + v1*v1);
@@ -175,7 +175,7 @@ public:
if (_is_leaf)
leaf_list.push_back (this);
else
- for (size_t k(0); k < 4; k++)
+ for (std::size_t k(0); k < 4; k++)
_childs[k]->getLeafs (leaf_list);
}
@@ -229,12 +229,12 @@ public:
* the method GMSHAdaptiveMeshDensity::getSteinerPoints().
* @param max_depth (input/output) at the entry max_depth contains the maximum depth up to now
*/
- void getMaxDepth (size_t &max_depth) const
+ void getMaxDepth (std::size_t &max_depth) const
{
if (max_depth < _depth)
max_depth = _depth;
- for (size_t k(0); k<4; k++) {
+ for (std::size_t k(0); k<4; k++) {
if (_childs[k]) {
_childs[k]->getMaxDepth(max_depth);
}
@@ -245,7 +245,7 @@ public:
* Method returns the depth of the current QuadTree node.
* @return the depth of the current QuadTree node
*/
- size_t getDepth () const { return _depth; }
+ std::size_t getDepth () const { return _depth; }
private:
QuadTree<POINT>* getChild (Quadrant quadrant)
@@ -360,13 +360,13 @@ private:
QuadTree (POINT const& ll,
POINT const& ur,
QuadTree* father,
- size_t depth,
- size_t max_points_per_node) :
+ std::size_t depth,
+ std::size_t max_points_per_node) :
_father (father), _ll (ll), _ur (ur), _depth (depth), _is_leaf (true),
_max_points_per_node (max_points_per_node)
{
// init childs
- for (size_t k(0); k < 4; k++)
+ for (std::size_t k(0); k < 4; k++)
_childs[k] = NULL;
}
@@ -389,9 +389,9 @@ private:
_childs[3] = new QuadTree<POINT> (h_ll, h_ur, this, _depth + 1, _max_points_per_node); // south east
// distribute points to sub quadtrees
- for (size_t j(0); j < _pnts.size(); j++) {
+ for (std::size_t j(0); j < _pnts.size(); j++) {
bool nfound(true);
- for (size_t k(0); k < 4 && nfound; k++)
+ for (std::size_t k(0); k < 4 && nfound; k++)
if (_childs[k]->addPoint(_pnts[j])) nfound = false;
}
@@ -472,13 +472,13 @@ private:
* upper right point of the square
*/
POINT _ur;
- size_t _depth;
+ std::size_t _depth;
std::vector<POINT const*> _pnts;
bool _is_leaf;
/**
* maximum number of points per leaf
*/
- const size_t _max_points_per_node;
+ const std::size_t _max_points_per_node;
};
}
diff --git a/GeoLib/Raster.h b/GeoLib/Raster.h
index 6289373c7060af0d0bdf4cb4252e703848c4773b..4121556031abe53508276578a2a562e079b7f547 100644
--- a/GeoLib/Raster.h
+++ b/GeoLib/Raster.h
@@ -22,7 +22,7 @@ public:
Raster(double cell_size=1, double no_data_val=9999);
void setCellSize(double cell_size);
void setNoDataVal (double no_data_val);
- double* getRasterFromSurface (Surface const& sfc, size_t &n_x_pnts, size_t &n_y_pnts) const;
+ double* getRasterFromSurface (Surface const& sfc, std::size_t &n_x_pnts, std::size_t &n_y_pnts) const;
virtual ~Raster();
private:
double _cell_size;
diff --git a/GeoLib/SensorData.h b/GeoLib/SensorData.h
index 22246fcaecc5823ec1a49eef4c350acdacf525ec..29ce87790a745190a296909c21080fd9b9d593d9 100644
--- a/GeoLib/SensorData.h
+++ b/GeoLib/SensorData.h
@@ -69,10 +69,10 @@ public:
SensorData(const std::string &file_name);
/// Constructor using a time step vector valid for all time series that will be added later
- SensorData(std::vector<size_t> time_steps);
+ SensorData(std::vector<std::size_t> time_steps);
/// Constructor using time step bounds for all time series that will be added later
- SensorData(size_t first_timestep, size_t last_timestep, size_t step_size);
+ SensorData(std::size_t first_timestep, std::size_t last_timestep, std::size_t step_size);
~SensorData();
@@ -92,16 +92,16 @@ public:
const std::vector<SensorDataType::type>& getTimeSeriesNames() const { return _vec_names; };
/// Returns the time step vector (if it exists)
- const std::vector<size_t>& getTimeSteps() const { return _time_steps; };
+ const std::vector<std::size_t>& getTimeSteps() const { return _time_steps; };
/// Returns the first time step
- size_t getStartTime() const { return _start; };
+ std::size_t getStartTime() const { return _start; };
/// Returns the last time step
- size_t getEndTime() const { return _end; };
+ std::size_t getEndTime() const { return _end; };
/// Returns the interval between time steps (Returns "0" if a vector is given!)
- size_t getStepSize() const { return _step_size; };
+ std::size_t getStepSize() const { return _step_size; };
/// Allows to set a unit for the time steps
void setTimeUnit(TimeStepType::type t) { _time_unit = t; };
@@ -122,12 +122,12 @@ private:
/// Reads a CSV-file with time series data and fills the container.
int readDataFromFile(const std::string &file_name);
- size_t _start;
- size_t _end;
- size_t _step_size;
+ std::size_t _start;
+ std::size_t _end;
+ std::size_t _step_size;
TimeStepType::type _time_unit;
std::vector<std::string> _data_unit_string;
- std::vector<size_t> _time_steps;
+ std::vector<std::size_t> _time_steps;
std::vector<SensorDataType::type> _vec_names;
std::vector< std::vector<float>* > _data_vecs;
diff --git a/GeoLib/Surface.h b/GeoLib/Surface.h
index 7b0646eec333ae43e1afab87dc85e656e4d16c07..55f5e1709aa2999c2fee281bdf8ca10ddc642e7e 100644
--- a/GeoLib/Surface.h
+++ b/GeoLib/Surface.h
@@ -39,7 +39,7 @@ public:
/**
* adds three indices describing a triangle and updates the bounding box
* */
- void addTriangle (size_t pnt_a, size_t pnt_b, size_t pnt_c);
+ void addTriangle (std::size_t pnt_a, std::size_t pnt_b, std::size_t pnt_c);
/// Triangulates a new surface based on closed polyline.
static Surface* createSurface(const Polyline &ply);
@@ -47,11 +47,11 @@ public:
/**
* returns the number of triangles describing the Surface
* */
- size_t getNTriangles () const;
+ std::size_t getNTriangles () const;
/** \brief const access operator for the access to the i-th Triangle of the surface.
*/
- const Triangle* operator[] (size_t i) const;
+ const Triangle* operator[] (std::size_t i) const;
/**
* is the given point in the bounding volume of the surface
diff --git a/GeoLib/TemplatePoint.h b/GeoLib/TemplatePoint.h
index 44ce7846c6cf1e6e4c22f46da64260915b7f4138..d022ac03358d7d1fc791eea27dd93224388767fb 100644
--- a/GeoLib/TemplatePoint.h
+++ b/GeoLib/TemplatePoint.h
@@ -56,14 +56,14 @@ public:
* double sqrNrm2 = point[0] * point[0] + point[1] * point[1] + point[2] + point[2];
* \endcode
*/
- const T& operator[] (size_t idx) const {
+ const T& operator[] (std::size_t idx) const {
assert (idx <= 2);
return _x[idx];
}
/** \brief access operator (see book Effektiv C++ programmieren - subsection 1.3.2 ).
- * \sa const T& operator[] (size_t idx) const
+ * \sa const T& operator[] (std::size_t idx) const
*/
- T& operator[] (size_t idx) {
+ T& operator[] (std::size_t idx) {
return const_cast<T&> (static_cast<const TemplatePoint&> (*this)[idx]);
}
@@ -105,7 +105,7 @@ template <class T> TemplatePoint<T>::TemplatePoint(T x1, T x2, T x3) :
template <class T> TemplatePoint<T>::TemplatePoint (T const* x) :
GeoObject()
{
- for (size_t k(0); k<3; k++) _x[k] = x[k];
+ for (std::size_t k(0); k<3; k++) _x[k] = x[k];
}
/** overload the output operator for class Point */
diff --git a/GeoLib/TemplateVec.h b/GeoLib/TemplateVec.h
index 0fb65db51806fd6816a9305738aca929e57b93b0..4cfae7251badb86db0df48b91c797ab85a2297f2 100644
--- a/GeoLib/TemplateVec.h
+++ b/GeoLib/TemplateVec.h
@@ -32,13 +32,13 @@ public:
* In order to access the data elements a unique name is required.
* @param data_vec vector of data elements
* @param elem_name_map Names of data elements can be given by a
- * std::map<std::string, size_t>. Here the std::string is the name
- * of the element and the value for size_t stands for an index in
+ * std::map<std::string, std::size_t>. Here the std::string is the name
+ * of the element and the value for std::size_t stands for an index in
* the data_vec.
*/
TemplateVec (const std::string &name, std::vector<T*>* data_vec,
- std::map<std::string, size_t>* elem_name_map = NULL) :
+ std::map<std::string, std::size_t>* elem_name_map = NULL) :
_name(name), _data_vec(data_vec), _name_id_map (elem_name_map)
{}
@@ -47,7 +47,7 @@ public:
*/
virtual ~TemplateVec ()
{
- for (size_t k(0); k < size(); k++) delete (*_data_vec)[k];
+ for (std::size_t k(0); k < size(); k++) delete (*_data_vec)[k];
delete _data_vec;
delete _name_id_map;
}
@@ -65,7 +65,7 @@ public:
/**
* @return the number of data elements
*/
- size_t size () const { return _data_vec->size(); }
+ std::size_t size () const { return _data_vec->size(); }
/**
* get a pointer to a standard vector containing the data elements
@@ -79,9 +79,9 @@ public:
* @param id the id of the geometric element
* @return
*/
- bool getElementIDByName (const std::string& name, size_t &id) const
+ bool getElementIDByName (const std::string& name, std::size_t &id) const
{
- std::map<std::string,size_t>::const_iterator it (_name_id_map->find (name));
+ std::map<std::string,std::size_t>::const_iterator it (_name_id_map->find (name));
if (it != _name_id_map->end())
{
@@ -94,7 +94,7 @@ public:
/// Returns an element with the given name.
const T* getElementByName (const std::string& name) const
{
- size_t id;
+ std::size_t id;
bool ret (getElementIDByName (name, id));
if (ret)
return (*_data_vec)[id];
@@ -111,11 +111,11 @@ public:
* @return if there is name associated with the given id:
* true, else false
*/
- bool getNameOfElementByID (size_t id, std::string& element_name) const
+ bool getNameOfElementByID (std::size_t id, std::string& element_name) const
{
if (!_name_id_map) return false;
// search in map for id
- std::map<std::string,size_t>::const_iterator it (_name_id_map->begin());
+ std::map<std::string,std::size_t>::const_iterator it (_name_id_map->begin());
while (it != _name_id_map->end())
{
if (it->second == id)
@@ -129,10 +129,10 @@ public:
}
/// Return the name of an element based on its ID.
- void setNameOfElementByID (size_t id, std::string& element_name)
+ void setNameOfElementByID (std::size_t id, std::string& element_name)
{
if (!_name_id_map) return;
- _name_id_map->insert( std::pair<std::string, size_t>(element_name, id) );
+ _name_id_map->insert( std::pair<std::string, std::size_t>(element_name, id) );
}
/**
@@ -145,7 +145,7 @@ public:
*/
bool getNameOfElement (const T* data, std::string& name) const
{
- for (size_t k(0); k < _data_vec->size(); k++)
+ for (std::size_t k(0); k < _data_vec->size(); k++)
if ((*_data_vec)[k] == data)
return getNameOfElementByID (k, name);
@@ -160,20 +160,20 @@ public:
if (!name->empty())
{
if (_name_id_map == NULL)
- _name_id_map = new std::map <std::string, size_t>;
- _name_id_map->insert (std::pair<std::string,size_t>(*name, _data_vec->size() - 1));
+ _name_id_map = new std::map <std::string, std::size_t>;
+ _name_id_map->insert (std::pair<std::string,std::size_t>(*name, _data_vec->size() - 1));
}
}
/// Sets the given name for the element of the given ID.
- void setNameForElement(size_t id, std::string const& name)
+ void setNameForElement(std::size_t id, std::string const& name)
{
if (_name_id_map == NULL)
- _name_id_map = new std::map<std::string, size_t>;
+ _name_id_map = new std::map<std::string, std::size_t>;
if ( !_name_id_map->empty())
{
- for (std::map<std::string, size_t>::iterator it = _name_id_map->begin(); it != _name_id_map->end(); ++it)
+ for (std::map<std::string, std::size_t>::iterator it = _name_id_map->begin(); it != _name_id_map->end(); ++it)
if (it->second == id)
{
_name_id_map->erase(it); //check if old name already exists and delete it
@@ -182,7 +182,7 @@ public:
}
if (!name.empty()) {
//insert new or revised name
- _name_id_map->insert(std::pair<std::string, size_t>(name, id));
+ _name_id_map->insert(std::pair<std::string, std::size_t>(name, id));
}
}
@@ -204,7 +204,7 @@ protected:
/**
* store names associated with the element ids
*/
- std::map<std::string, size_t>* _name_id_map;
+ std::map<std::string, std::size_t>* _name_id_map;
};
} // end namespace GeoLib
diff --git a/GeoLib/Triangle.h b/GeoLib/Triangle.h
index 0c796c063199031c094acc968ec6831f5aaaf5a2..ce0176ac6cf9c3c8200fe4ccd7bf7825af429ed8 100644
--- a/GeoLib/Triangle.h
+++ b/GeoLib/Triangle.h
@@ -37,17 +37,17 @@ public:
* construction of object, initialization of reference to point vector,
* saves the three indices describing a triangle
*/
- Triangle (std::vector<Point *> const &pnt_vec, size_t pnt_a, size_t pnt_b, size_t pnt_c);
+ Triangle (std::vector<Point *> const &pnt_vec, std::size_t pnt_a, std::size_t pnt_b, std::size_t pnt_c);
/**
* saves three indices describing a triangle
* */
- void setTriangle (size_t pnt_a, size_t pnt_b, size_t pnt_c);
+ void setTriangle (std::size_t pnt_a, std::size_t pnt_b, std::size_t pnt_c);
/** \brief const access operator to access the index
* of the i-th triangle point
*/
- const size_t& operator[] (size_t i) const {
+ const std::size_t& operator[] (std::size_t i) const {
assert (i < 3);
return _pnt_ids[i];
}
@@ -55,7 +55,7 @@ public:
// /** \brief access operator to access the index
// * of the i-th triangle point
// * */
-// size_t& operator[] (size_t i) {
+// std::size_t& operator[] (std::size_t i) {
// assert (i < 3);
// return _pnt_ids[i];
// }
@@ -63,7 +63,7 @@ public:
/**
* \brief const access operator to access the i-th triangle Point
*/
- const Point* getPoint (size_t i) const {
+ const Point* getPoint (std::size_t i) const {
assert (i < 3);
return _pnts[_pnt_ids[i]];
}
@@ -92,7 +92,7 @@ protected:
/** a vector of pointers to points */
const std::vector<Point*> &_pnts;
/** position of pointers to the geometric points */
- size_t _pnt_ids[3];
+ std::size_t _pnt_ids[3];
bool _initialized;
double _longest_edge;
};
diff --git a/Gui/Base/StrictDoubleValidator.h b/Gui/Base/StrictDoubleValidator.h
index add3bd06f7bb0995a9e40617f95aab98e3803120..1798c8cf492499e36fe721d15730c063bdc9c2a5 100644
--- a/Gui/Base/StrictDoubleValidator.h
+++ b/Gui/Base/StrictDoubleValidator.h
@@ -21,7 +21,7 @@
class StrictDoubleValidator : public QDoubleValidator
{
public:
- StrictDoubleValidator ( double min, double max, size_t decimals, QObject* parent = 0) :
+ StrictDoubleValidator ( double min, double max, std::size_t decimals, QObject* parent = 0) :
QDoubleValidator( min, max, decimals, parent)
{}
diff --git a/Gui/DataView/CondFromRasterDialog.h b/Gui/DataView/CondFromRasterDialog.h
index 4dd8aeb363740875fe80166fed826af54cd04e76..877c0a5c9da5233fc1b908cd4d466f46e095a601 100644
--- a/Gui/DataView/CondFromRasterDialog.h
+++ b/Gui/DataView/CondFromRasterDialog.h
@@ -50,7 +50,7 @@ private slots:
signals:
void directNodesWritten(std::string);
- void transmitDisValues(std::vector< std::pair<size_t,double> >);
+ void transmitDisValues(std::vector< std::pair<std::size_t,double> >);
};
#endif //CONDFROMRASTERDIALOG_H
diff --git a/Gui/DataView/DataView.h b/Gui/DataView/DataView.h
index 60c558540938d7d2d92e3ebfc0d8afaf1166d112..333c5a0370da459cc9e831a07e0c1cf25119285b 100644
--- a/Gui/DataView/DataView.h
+++ b/Gui/DataView/DataView.h
@@ -83,7 +83,7 @@ private slots:
signals:
void qualityCheckRequested(VtkMeshSource*);
- void requestCondSetupDialog(const std::string&, const GeoLib::GEOTYPE, const size_t, bool on_points);
+ void requestCondSetupDialog(const std::string&, const GeoLib::GEOTYPE, const std::size_t, bool on_points);
void requestMeshRemoval(const QModelIndex&);
void requestDIRECTSourceTerms(const std::string, const std::vector<GeoLib::Point*>*);
void saveMeshAction();
diff --git a/Gui/DataView/DiagramView/DetailWindow.h b/Gui/DataView/DiagramView/DetailWindow.h
index f432efb6f8371c1f3d549c6e6fbf4eb8310ef888..9bf1fa5d5b97172fa541f4395f3966777f2f7ee2 100644
--- a/Gui/DataView/DiagramView/DetailWindow.h
+++ b/Gui/DataView/DiagramView/DetailWindow.h
@@ -39,7 +39,7 @@ public:
*/
DetailWindow(DiagramList* list, QWidget* parent = 0);
- DetailWindow(std::vector<size_t> data, QWidget* parent = 0);
+ DetailWindow(std::vector<std::size_t> data, QWidget* parent = 0);
~DetailWindow(void);
diff --git a/Gui/DataView/DiagramView/DiagramList.h b/Gui/DataView/DiagramView/DiagramList.h
index 213cb953b1e9ff4482b4b8c4ef28d037db559fe5..c51edaecad14fb24bb35acf619140031a7562dc1 100644
--- a/Gui/DataView/DiagramView/DiagramList.h
+++ b/Gui/DataView/DiagramView/DiagramList.h
@@ -70,7 +70,7 @@ public:
* \param i Number of the point to be returned.
* \return true if everything is alright. false if the point does not exist.
*/
- bool getPoint(QPointF &p, size_t i);
+ bool getPoint(QPointF &p, std::size_t i);
/// Returns the label associated with the x-axis
QString getXLabel() const { return _xLabel; }
@@ -136,7 +136,7 @@ public:
void setYUnit(QString unit) { _yUnit = unit; }
/// Returns the number of data points.
- size_t size();
+ std::size_t size();
/// Returns the width of the bounding box of all data points within the list.
double width() const { return _maxX - _minX; }
diff --git a/Gui/DataView/DirectConditionGenerator.cpp b/Gui/DataView/DirectConditionGenerator.cpp
index 4f25983ca5210f81d649b08576e0cf638c5292b5..59116f8fcba6acc3bd15f0aaa111e4cf71fd1fe2 100644
--- a/Gui/DataView/DirectConditionGenerator.cpp
+++ b/Gui/DataView/DirectConditionGenerator.cpp
@@ -17,6 +17,7 @@
#include "Mesh.h"
#include <cmath>
+#include <limits>
const std::vector< std::pair<size_t,double> >& DirectConditionGenerator::directToSurfaceNodes(const MeshLib::Mesh &mesh, const std::string &filename)
{
diff --git a/Gui/DataView/DirectConditionGenerator.h b/Gui/DataView/DirectConditionGenerator.h
index 5c9e7ab606cd162954a9df0cdb758ad7adc4f6b9..25ac9c77e3e161ef908c2a009241c17e95abd8f3 100644
--- a/Gui/DataView/DirectConditionGenerator.h
+++ b/Gui/DataView/DirectConditionGenerator.h
@@ -13,6 +13,7 @@
#define DIRECTCONDITIONGENERATOR_H
#include <vector>
+#include <string>
namespace MeshLib {
class Mesh;
@@ -24,14 +25,14 @@ public:
DirectConditionGenerator() {};
~DirectConditionGenerator() {};
- const std::vector< std::pair<size_t,double> >& directToSurfaceNodes(const MeshLib::Mesh &mesh, const std::string &filename);
+ const std::vector< std::pair<std::size_t,double> >& directToSurfaceNodes(const MeshLib::Mesh &mesh, const std::string &filename);
- const std::vector< std::pair<size_t,double> >& directWithSurfaceIntegration(MeshLib::Mesh &mesh, const std::string &filename, double scaling);
+ const std::vector< std::pair<std::size_t,double> >& directWithSurfaceIntegration(MeshLib::Mesh &mesh, const std::string &filename, double scaling);
int writeToFile(const std::string &name) const;
private:
- std::vector< std::pair<size_t,double> > _direct_values;
+ std::vector< std::pair<std::size_t,double> > _direct_values;
};
diff --git a/Gui/DataView/ElementTreeModel.h b/Gui/DataView/ElementTreeModel.h
index 756d821a37995510f37d16573d179a13e5de5fac..d9a6e28ccee54f716ca3530b2898269c856c4245 100644
--- a/Gui/DataView/ElementTreeModel.h
+++ b/Gui/DataView/ElementTreeModel.h
@@ -35,7 +35,7 @@ public slots:
void clearView();
/// Extracts information of the element with the given index from the given grid.
- void setElement(const MeshLib::Mesh* grid, const size_t elem_index);
+ void setElement(const MeshLib::Mesh* grid, const std::size_t elem_index);
private:
};
diff --git a/Gui/DataView/FEMConditionSetupDialog.h b/Gui/DataView/FEMConditionSetupDialog.h
index f38a6773de54a5bf22d99c54807711fff6045817..d53b310cc6da25b4d27eef35bbd5f5b82395ed5e 100644
--- a/Gui/DataView/FEMConditionSetupDialog.h
+++ b/Gui/DataView/FEMConditionSetupDialog.h
@@ -80,7 +80,7 @@ private slots:
void directButton_pressed();
- void addDisValues(std::vector< std::pair<size_t,double> > direct_values);
+ void addDisValues(std::vector< std::pair<std::size_t,double> > direct_values);
void copyCondOnPoints();
diff --git a/Gui/DataView/GEOModels.h b/Gui/DataView/GEOModels.h
index 8554eddebdeb88e2105c15227cc847ffdb283273..f42a4f25e02434bf52d178c1362192dc34edd946 100644
--- a/Gui/DataView/GEOModels.h
+++ b/Gui/DataView/GEOModels.h
@@ -48,11 +48,11 @@ public slots:
virtual void addPointVec(std::vector<GeoLib::Point*>* points,
std::string &name,
- std::map<std::string, size_t>* name_pnt_id_map = NULL,
+ std::map<std::string, std::size_t>* name_pnt_id_map = NULL,
double eps = sqrt(std::numeric_limits<double>::min()));
virtual bool appendPointVec(const std::vector<GeoLib::Point*> &points,
const std::string &name,
- std::vector<size_t>* ids = NULL);
+ std::vector<std::size_t>* ids = NULL);
virtual bool removePointVec(const std::string &name);
virtual void addStationVec(std::vector<GeoLib::Point*>* stations,
@@ -62,14 +62,14 @@ public slots:
virtual void addPolylineVec(std::vector<GeoLib::Polyline*>* lines,
const std::string &name,
- std::map<std::string,size_t>* ply_names = NULL);
+ std::map<std::string,std::size_t>* ply_names = NULL);
virtual bool appendPolylineVec(const std::vector<GeoLib::Polyline*> &polylines,
const std::string &name);
virtual bool removePolylineVec(const std::string &name);
virtual void addSurfaceVec(std::vector<GeoLib::Surface*>* surfaces,
const std::string &name,
- std::map<std::string,size_t>* sfc_names = NULL);
+ std::map<std::string,std::size_t>* sfc_names = NULL);
/// @brief
/// @param surfaces The surface vector.
@@ -78,14 +78,14 @@ public slots:
virtual bool removeSurfaceVec(const std::string &name);
/// Adds the name 'new_name' for the geo-object specified by the parameters
- void addNameForElement(const std::string &geometry_name, const GeoLib::GEOTYPE object_type, size_t id, std::string new_name);
+ void addNameForElement(const std::string &geometry_name, const GeoLib::GEOTYPE object_type, std::size_t id, std::string new_name);
/// Adds a generic name to all points that are part of the specified geo-object
void addNameForObjectPoints(const std::string &geometry_name, const GeoLib::GEOTYPE object_type, const std::string &geo_object_name, const std::string &new_name);
/// Calls all necessary functions to connect polyline-segments and update all views and windows.
void connectPolylineSegments(const std::string &geoName,
- std::vector<size_t> indexlist,
+ std::vector<std::size_t> indexlist,
double proximity,
std::string ply_name,
bool closePly,
diff --git a/Gui/DataView/GMSHPrefsDialog.h b/Gui/DataView/GMSHPrefsDialog.h
index df99a5c0b7babb0f2f045c187845cfd283c3cedb..756cc5b92fbe1077531eed7cfcff2add67cb1411 100644
--- a/Gui/DataView/GMSHPrefsDialog.h
+++ b/Gui/DataView/GMSHPrefsDialog.h
@@ -51,7 +51,7 @@ private slots:
void reject();
signals:
- void requestMeshing(std::vector<std::string> &, size_t, double, double, double, bool);
+ void requestMeshing(std::vector<std::string> &, std::size_t, double, double, double, bool);
};
#endif //GMSHPREFSDIALOG_H
diff --git a/Gui/DataView/GeoTreeModel.h b/Gui/DataView/GeoTreeModel.h
index 988e6067fcdbdd82a93b5887c7ac57e19d8a2529..96372e8c50f8b2a0ec00b6b86960a3b64c744ded 100644
--- a/Gui/DataView/GeoTreeModel.h
+++ b/Gui/DataView/GeoTreeModel.h
@@ -65,7 +65,7 @@ public:
*/
void removeGeoList(const std::string &name, GeoLib::GEOTYPE type = GeoLib::INVALID);
- void setNameForItem(const std::string &name, GeoLib::GEOTYPE type, size_t id, std::string item_name);
+ void setNameForItem(const std::string &name, GeoLib::GEOTYPE type, std::size_t id, std::string item_name);
/*
* Returns the geo-object specified by the given index.
@@ -82,14 +82,14 @@ private:
/// Adds children to the "Polylines" node
void addChildren(GeoObjectListItem* plyList,
const GeoLib::PolylineVec* polyline_vec,
- size_t start_index,
- size_t end_index);
+ std::size_t start_index,
+ std::size_t end_index);
/// Adds children to the "Surfaces" node
void addChildren(GeoObjectListItem* sfcList,
const GeoLib::SurfaceVec* surface_vec,
- size_t start_index,
- size_t end_index);
+ std::size_t start_index,
+ std::size_t end_index);
std::vector<GeoTreeItem*> _lists;
};
diff --git a/Gui/DataView/GeoTreeView.h b/Gui/DataView/GeoTreeView.h
index 76a86b2290389265a613c606ac861252d4331e38..7c0cc19807d77be62406d7d59ccdc9cf6fdaba1a 100644
--- a/Gui/DataView/GeoTreeView.h
+++ b/Gui/DataView/GeoTreeView.h
@@ -71,9 +71,9 @@ signals:
void listRemoved(std::string name, GeoLib::GEOTYPE);
void loadFEMCondFileRequested(std::string);
void saveToFileRequested(QString, QString) const;
- void requestCondSetupDialog(const std::string&, const GeoLib::GEOTYPE, const size_t, bool on_points);
+ void requestCondSetupDialog(const std::string&, const GeoLib::GEOTYPE, const std::size_t, bool on_points);
void requestLineEditDialog(const std::string&);
- void requestNameChangeDialog(const std::string&, const GeoLib::GEOTYPE, const size_t);
+ void requestNameChangeDialog(const std::string&, const GeoLib::GEOTYPE, const std::size_t);
//void saveFEMConditionsRequested(QString, QString);
};
diff --git a/Gui/DataView/LineEditDialog.h b/Gui/DataView/LineEditDialog.h
index d0e8a2c98499c995d07bf3958170c33a8ec57645..3cafa78018ef807d1ac9ba1e6b1afcd034eb3c46 100644
--- a/Gui/DataView/LineEditDialog.h
+++ b/Gui/DataView/LineEditDialog.h
@@ -33,7 +33,7 @@ public:
~LineEditDialog(void);
private:
- std::vector<size_t> getSelectedIndeces(QStringList list);
+ std::vector<std::size_t> getSelectedIndeces(QStringList list);
QStringListModel* _allPly;
QStringListModel* _selPly;
@@ -54,7 +54,7 @@ private slots:
signals:
void connectPolylines(const std::string&,
- std::vector<size_t>,
+ std::vector<std::size_t>,
double,
std::string,
bool,
diff --git a/Gui/DataView/LinearEditDialog.h b/Gui/DataView/LinearEditDialog.h
index 43bef2b071632ce80ea00e97e457ee5e2915ad9e..03a05d48309cfd4412eb9b27c2f82bb858174f16 100644
--- a/Gui/DataView/LinearEditDialog.h
+++ b/Gui/DataView/LinearEditDialog.h
@@ -25,11 +25,11 @@ class LinearEditDialog : public QDialog, private Ui_LinearEdit
Q_OBJECT
public:
- LinearEditDialog(const GeoLib::Polyline &line, const std::vector<size_t> &dis_nodes, const std::vector<double> &dis_values, QDialog* parent = 0);
+ LinearEditDialog(const GeoLib::Polyline &line, const std::vector<std::size_t> &dis_nodes, const std::vector<double> &dis_values, QDialog* parent = 0);
~LinearEditDialog(void);
private:
- void setupDialog(const std::vector<size_t> &dis_nodes, const std::vector<double> &dis_values);
+ void setupDialog(const std::vector<std::size_t> &dis_nodes, const std::vector<double> &dis_values);
const GeoLib::Polyline _line;
@@ -43,7 +43,7 @@ private slots:
void reject();
signals:
- void transmitDisValues(std::vector< std::pair<size_t,double> >);
+ void transmitDisValues(std::vector< std::pair<std::size_t,double> >);
};
#endif //LINEAREDITDIALOG_H
diff --git a/Gui/DataView/MshLayerMapper.h b/Gui/DataView/MshLayerMapper.h
index 391035d974310b5b9dbfda4b89e57acdc9677a9c..a8dd9bb88d329c2f965d06f8438554335e4db91a 100644
--- a/Gui/DataView/MshLayerMapper.h
+++ b/Gui/DataView/MshLayerMapper.h
@@ -36,14 +36,14 @@ public:
* \param thickness The thickness of each of these newly added layers
* \return A mesh with the requested number of layers of prism/hex elements
*/
- static MeshLib::Mesh* CreateLayers(const MeshLib::Mesh* mesh, size_t nLayers, double thickness);
+ static MeshLib::Mesh* CreateLayers(const MeshLib::Mesh* mesh, std::size_t nLayers, double thickness);
/// Maps the z-values of nodes in the designated layer of the given mesh according to the given raster.
- static int LayerMapping(MeshLib::Mesh* msh, const std::string &rasterfile,
- const size_t nLayers, const size_t layer_id, bool removeNoDataValues = false);
+ static int LayerMapping(MeshLib::Mesh* msh, const std::string &rasterfile,
+ const std::size_t nLayers, const std::size_t layer_id, bool removeNoDataValues = false);
/// Blends a mesh with the surface given by dem_raster. Nodes and elements above the surface are either removed or adapted to fit the surface.
- static MeshLib::Mesh* blendLayersWithSurface(MeshLib::Mesh* mesh, const size_t nLayers, const std::string &dem_raster);
+ static MeshLib::Mesh* blendLayersWithSurface(MeshLib::Mesh* mesh, const std::size_t nLayers, const std::string &dem_raster);
private:
/// Checks if the given mesh is within the dimensions given by xDim and yDim.
diff --git a/Gui/DataView/MshQualitySelectionDialog.h b/Gui/DataView/MshQualitySelectionDialog.h
index 0176f22adaf893cccf769f9a82d31f84aa5791f7..dfd8775bab0b122a9a5a74af1163b879c611f71e 100644
--- a/Gui/DataView/MshQualitySelectionDialog.h
+++ b/Gui/DataView/MshQualitySelectionDialog.h
@@ -12,7 +12,7 @@
#ifndef MSHQUALITYSELECTIONDIALOG_H
#define MSHQUALITYSELECTIONDIALOG_H
-#include "MSHEnums.h"
+#include "MshEnums.h"
#include "ui_MshQualitySelection.h"
#include <QDialog>
diff --git a/Gui/DataView/NetCdfConfigureDialog.h b/Gui/DataView/NetCdfConfigureDialog.h
index f7a5aed83344d3b4b8372271748da7b84d95e5fe..e42db6db4b104fe44dffa9bf3874d55fa291fea6 100644
--- a/Gui/DataView/NetCdfConfigureDialog.h
+++ b/Gui/DataView/NetCdfConfigureDialog.h
@@ -45,7 +45,7 @@ private slots:
private:
void setVariableSelect();
void setDimensionSelect();
- void getDimEdges(int dimId,size_t &size, double &firstValue, double &lastValue);
+ void getDimEdges(int dimId,std::size_t &size, double &firstValue, double &lastValue);
void getDaysTime(double minSince, QTime &time, int &days);
long convertDateToMinutes(QDateTime initialDateTime,QDate selectedDate, QTime selectedTime);
void createDataObject();
@@ -54,7 +54,7 @@ private:
int getDim4();
double getResolution();
QString setName();
- void reverseNorthSouth(double* data, size_t width, size_t height);
+ void reverseNorthSouth(double* data, std::size_t width, std::size_t height);
NcFile *_currentFile;
NcVar *_currentVar;
diff --git a/Gui/DataView/SelectMeshDialog.h b/Gui/DataView/SelectMeshDialog.h
index f6201f51ef2f77e69d3af93bd6a4a440b6ee6d5a..d1cd38b0bfaa9a5d2ff3c2fa953045ebcaddae76 100644
--- a/Gui/DataView/SelectMeshDialog.h
+++ b/Gui/DataView/SelectMeshDialog.h
@@ -57,7 +57,7 @@ private slots:
void reject();
signals:
- //void requestNameChange(const std::string&, const GeoLib::GEOTYPE, size_t, std::string);
+ //void requestNameChange(const std::string&, const GeoLib::GEOTYPE, std::size_t, std::string);
};
#endif //SELECTMESHDIALOG_H
diff --git a/Gui/DataView/SetNameDialog.h b/Gui/DataView/SetNameDialog.h
index 561f4f094f4c12acdd36d8f80188fa7ea305c668..8412b9bb3b3a28803bab5e47ea8693cf113c1301 100644
--- a/Gui/DataView/SetNameDialog.h
+++ b/Gui/DataView/SetNameDialog.h
@@ -32,7 +32,7 @@ public:
/// Constructor
SetNameDialog(const std::string &parent_name,
const std::string &object_type_name,
- size_t id,
+ std::size_t id,
const std::string &old_name,
QDialog* parent = 0);
~SetNameDialog();
@@ -49,7 +49,7 @@ private:
std::string _parent_name;
std::string _object_type_name;
- size_t _id;
+ std::size_t _id;
private slots:
/// Instructions if the OK-Button has been pressed.
@@ -59,7 +59,7 @@ private slots:
void reject();
signals:
- void requestNameChange(const std::string&, const GeoLib::GEOTYPE, size_t, std::string);
+ void requestNameChange(const std::string&, const GeoLib::GEOTYPE, std::size_t, std::string);
};
#endif //SETNAMEDIALOG_H
diff --git a/Gui/VtkAct/VtkCustomInteractorStyle.h b/Gui/VtkAct/VtkCustomInteractorStyle.h
index 8697b0b459c9bdd5e7b2e89475898d6e98ad2b91..01ae9d78a3bda118243a592941f85e35c0080bfd 100644
--- a/Gui/VtkAct/VtkCustomInteractorStyle.h
+++ b/Gui/VtkAct/VtkCustomInteractorStyle.h
@@ -88,7 +88,7 @@ signals:
void cursorChanged(Qt::CursorShape);
/// @brief Emitted when a mesh element has been picked
- void elementPicked(const MeshLib::Mesh*, const size_t);
+ void elementPicked(const MeshLib::Mesh*, const std::size_t);
};
#endif // VTKINTERACTORSTYLE_H
diff --git a/Gui/VtkVis/VtkCompositeGeoObjectFilter.h b/Gui/VtkVis/VtkCompositeGeoObjectFilter.h
index 98eed43c0964cdea25e499f0cbc77124b9192874..131c7387881a9cab58f7624ffc6b55ed6da70090 100644
--- a/Gui/VtkVis/VtkCompositeGeoObjectFilter.h
+++ b/Gui/VtkVis/VtkCompositeGeoObjectFilter.h
@@ -33,7 +33,7 @@ public:
Q_UNUSED(value);
}
- void SetIndex(size_t idx);
+ void SetIndex(std::size_t idx);
private:
float GetInitialRadius() const;
diff --git a/Gui/VtkVis/VtkConditionSource.cpp b/Gui/VtkVis/VtkConditionSource.cpp
index aa73e2e014f699f264eea5cb1f6573813bc5bb7e..5407df1174d561e97019ec6facf8ff71aa4cac18 100644
--- a/Gui/VtkVis/VtkConditionSource.cpp
+++ b/Gui/VtkVis/VtkConditionSource.cpp
@@ -271,7 +271,7 @@ int VtkConditionSource::RequestData( vtkInformation* request,
//idx_map.insert( std::pair<size_t,size_t>(pnt_idx+i, nPoints+i));
}
- for (size_t i = 0; i < 4; i++)
+ for (vtkIdType i = 0; i < 4; i++)
{
vtkIdType a[2] = {nPoints + i, nPoints + i + 4};
vtkIdType b[2] = {nPoints + (i * 2), nPoints + (i * 2 + 1)};
diff --git a/Gui/VtkVis/VtkConditionSource.h b/Gui/VtkVis/VtkConditionSource.h
index 19f0085e9be655bccfa9b7b7c2cf1ff1790b3699..2d2cf1942e0f9bfb2afdda9df68e2f8203420c1e 100644
--- a/Gui/VtkVis/VtkConditionSource.h
+++ b/Gui/VtkVis/VtkConditionSource.h
@@ -58,7 +58,7 @@ protected:
vtkInformationVector* outputVector);
private:
- //size_t getIndex(size_t idx, vtkSmartPointer<vtkPoints> newPoints, vtkSmartPointer<vtkDoubleArray> scalars, std::map<size_t, size_t> &idx_map);
+ //std::size_t getIndex(std::size_t idx, vtkSmartPointer<vtkPoints> newPoints, vtkSmartPointer<vtkDoubleArray> scalars, std::map<std::size_t, std::size_t> &idx_map);
const std::vector<GeoLib::Point*>* _points;
const std::vector<FEMCondition*>* _cond_vec;
diff --git a/Gui/VtkVis/VtkMeshConverter.h b/Gui/VtkVis/VtkMeshConverter.h
index 57188c963f7909b93942b1d3d6df7c4fd4791dcc..a75f30c52c68408042affb0a92061d5138ab3bc3 100644
--- a/Gui/VtkVis/VtkMeshConverter.h
+++ b/Gui/VtkVis/VtkMeshConverter.h
@@ -56,8 +56,8 @@ public:
*/
static MeshLib::Mesh* convertImgToMesh(const double* img,
const double origin[3],
- const size_t imgHeight,
- const size_t imgWidth,
+ const std::size_t imgHeight,
+ const std::size_t imgWidth,
const double &scalingFactor,
MshElemType::type elem_type,
UseIntensityAs::type intensity_type);
@@ -71,13 +71,13 @@ private:
int* node_idx_map,
const bool* visNodes,
const double origin[3],
- const size_t &imgHeight,
- const size_t &imgWidth,
+ const std::size_t &imgHeight,
+ const std::size_t &imgWidth,
const double &scalingFactor,
MshElemType::type elem_type,
UseIntensityAs::type intensity_type);
- static double getExistingValue(const double* img, size_t length);
+ static double getExistingValue(const double* img, std::size_t length);
};
#endif // VTKMESHCONVERTER_H
diff --git a/Gui/VtkVis/VtkRaster.h b/Gui/VtkVis/VtkRaster.h
index 4024288664961488bd1ae531f8d0078c8d9de8e6..fef63b38a8e20f9ca5392d8765002535af5cf7ab 100644
--- a/Gui/VtkVis/VtkRaster.h
+++ b/Gui/VtkVis/VtkRaster.h
@@ -69,8 +69,8 @@ public:
static float* loadDataFromASC(const std::string &fileName,
double &x0,
double &y0,
- size_t &width,
- size_t &height,
+ std::size_t &width,
+ std::size_t &height,
double &delta);
/**
@@ -80,8 +80,8 @@ public:
static float* loadDataFromSurfer(const std::string &fileName,
double &x0,
double &y0,
- size_t &width,
- size_t &height,
+ std::size_t &width,
+ std::size_t &height,
double &delta);
/**
@@ -90,8 +90,8 @@ public:
static vtkImageImport* loadImageFromArray(double* data_array,
double &x0,
double &y0,
- size_t &width,
- size_t &height,
+ std::size_t &width,
+ std::size_t &height,
double &delta,
double noData);
diff --git a/Gui/VtkVis/VtkStationSource.h b/Gui/VtkVis/VtkStationSource.h
index 516f62a02b6482042b7f04d2d0ef970a6e1c9350..01426741acfe346932e288a1f301397431e557d1 100644
--- a/Gui/VtkVis/VtkStationSource.h
+++ b/Gui/VtkVis/VtkStationSource.h
@@ -68,7 +68,7 @@ protected:
std::map<std::string, GeoLib::Color*> _colorLookupTable;
private:
- size_t GetIndexByName( std::string name );
+ std::size_t GetIndexByName( std::string name );
std::map<std::string, vtkIdType> _id_map;
};
diff --git a/Gui/VtkVis/VtkVisPipeline.h b/Gui/VtkVis/VtkVisPipeline.h
index 129f013c6ac5c0365bb838b69bb6ebbe1b322434..4ecb24cca16be78627cadfd76853ffe75197dbc5 100644
--- a/Gui/VtkVis/VtkVisPipeline.h
+++ b/Gui/VtkVis/VtkVisPipeline.h
@@ -16,7 +16,7 @@
#include "Color.h"
#include "FEMCondition.h"
#include "GeoType.h"
-#include "MSHEnums.h"
+#include "MshEnums.h"
#include "Point.h"
#include "TreeModel.h"
diff --git a/Gui/mainwindow.h b/Gui/mainwindow.h
index 3fb7ca09005a011a4f5dfa9487e93aa71490813c..f1f501d32d062412fa583a76c7abc48159930fb9 100644
--- a/Gui/mainwindow.h
+++ b/Gui/mainwindow.h
@@ -61,7 +61,7 @@ protected slots:
void save();
/// Function calls for generating GMSH files from the GUI
void callGMSH(std::vector<std::string> & selectedGeometries,
- size_t param1,
+ std::size_t param1,
double param2,
double param3,
double param4,
@@ -77,9 +77,9 @@ protected slots:
void showAddPipelineFilterItemDialog(QModelIndex parentIndex);
void showConditionWriterDialog();
/// Call dialog for creating or modifying FEM conditions.
- void showCondSetupDialog(const std::string &geometry_name, const GeoLib::GEOTYPE object_type, size_t id, bool on_points = false);
+ void showCondSetupDialog(const std::string &geometry_name, const GeoLib::GEOTYPE object_type, std::size_t id, bool on_points = false);
/// Allows setting the name for a geometric object
- void showGeoNameDialog(const std::string &geometry_name, const GeoLib::GEOTYPE object_type, size_t id);
+ void showGeoNameDialog(const std::string &geometry_name, const GeoLib::GEOTYPE object_type, std::size_t id);
/// Calls the diagram prefs dialog from the Tools menu.
void showDiagramPrefsDialog();
/// Calls the diagram prefs dialog from the station list (i.e. for a specific station).
diff --git a/MathLib/AnalyticalGeometry.h b/MathLib/AnalyticalGeometry.h
index 1ef7669b32b9e71cd83c2d8d3201da372b2d21fe..9a8874509b67ef8f83dec00f5da160b2ac63e7a2 100644
--- a/MathLib/AnalyticalGeometry.h
+++ b/MathLib/AnalyticalGeometry.h
@@ -72,7 +72,7 @@ bool isPointInTriangle (const GeoLib::Point* p,
* @param intersection_pnt the intersection point if the line segments intersect
* @return true, if the polyline contains intersections
*/
-bool lineSegmentsIntersect (const GeoLib::Polyline* ply, size_t &idx0, size_t &idx1, GeoLib::Point& intersection_pnt);
+bool lineSegmentsIntersect (const GeoLib::Polyline* ply, std::size_t &idx0, std::size_t &idx1, GeoLib::Point& intersection_pnt);
/**
* A line segment is given by its two end-points. The function checks,
diff --git a/MathLib/EarClippingTriangulation.h b/MathLib/EarClippingTriangulation.h
index 682d294ba1e315b38cb7c1d0e960533b9d62cebf..f91fc2464993c7a2e6ca9529586fa060b5cb873e 100644
--- a/MathLib/EarClippingTriangulation.h
+++ b/MathLib/EarClippingTriangulation.h
@@ -37,7 +37,7 @@ private:
inline void rotate ();
inline void ensureCWOrientation ();
- inline bool isEar(size_t v0, size_t v1, size_t v2) const;
+ inline bool isEar(std::size_t v0, std::size_t v1, std::size_t v2) const;
inline void initVertexList ();
inline void initLists ();
@@ -47,9 +47,9 @@ private:
* a copy of the polygon points
*/
std::vector<GeoLib::Point*> _pnts;
- std::list<size_t> _vertex_list;
- std::list<size_t> _convex_vertex_list;
- std::list<size_t> _ear_list;
+ std::list<std::size_t> _vertex_list;
+ std::list<std::size_t> _convex_vertex_list;
+ std::list<std::size_t> _ear_list;
/**
* triangles of the triangulation (maybe in the wrong orientation)
diff --git a/MathLib/LinAlg/Dense/Matrix.h b/MathLib/LinAlg/Dense/Matrix.h
index 744444a92eec1d545327d3119aae3f5c4c97c070..c1045cf449825bf0f857356e19bc1fdf02e092f9 100644
--- a/MathLib/LinAlg/Dense/Matrix.h
+++ b/MathLib/LinAlg/Dense/Matrix.h
@@ -26,14 +26,14 @@ namespace MathLib {
template <class T> class Matrix
{
public:
- Matrix (size_t rows, size_t cols);
- Matrix (size_t rows, size_t cols, const T& val);
+ Matrix (std::size_t rows, std::size_t cols);
+ Matrix (std::size_t rows, std::size_t cols, const T& val);
Matrix (const Matrix &src);
~Matrix ();
- size_t getNRows () const { return nrows; }
- size_t getNCols () const { return ncols; }
+ std::size_t getNRows () const { return nrows; }
+ std::size_t getNCols () const { return ncols; }
/**
* \f$ y = \alpha \cdot A x + \beta y\f$
*/
@@ -71,7 +71,7 @@ public:
*/
Matrix<T>* transpose() const; // HB & ZC
- Matrix<T>* getSubMatrix (size_t b_row, size_t b_col, size_t e_row, size_t e_col) const throw (std::range_error);
+ Matrix<T>* getSubMatrix (std::size_t b_row, std::size_t b_col, std::size_t e_row, std::size_t e_col) const throw (std::range_error);
/**
* overwrites values of the matrix with the given sub matrix
@@ -79,10 +79,10 @@ public:
* @param b_col the first column
* @param sub_mat the sub matrix
*/
- void setSubMatrix (size_t b_row, size_t b_col, const Matrix<T>& sub_mat) throw (std::range_error);
+ void setSubMatrix (std::size_t b_row, std::size_t b_col, const Matrix<T>& sub_mat) throw (std::range_error);
- inline T & operator() (size_t row, size_t col) throw (std::range_error);
- inline T & operator() (size_t row, size_t col) const throw (std::range_error);
+ inline T & operator() (std::size_t row, std::size_t col) throw (std::range_error);
+ inline T & operator() (std::size_t row, std::size_t col) const throw (std::range_error);
/**
* writes the matrix entries into the output stream
@@ -94,24 +94,24 @@ public:
private:
// zero based addressing, but Fortran storage layout
- //inline size_t address(size_t i, size_t j) const { return j*rows+i; };
+ //inline std::size_t address(std::size_t i, std::size_t j) const { return j*rows+i; };
// zero based addressing, C storage layout
- inline size_t address(size_t i, size_t j) const { return i*ncols+j; };
+ inline std::size_t address(std::size_t i, std::size_t j) const { return i*ncols+j; };
- size_t nrows;
- size_t ncols;
+ std::size_t nrows;
+ std::size_t ncols;
T *data;
};
-template<class T> Matrix<T>::Matrix (size_t rows, size_t cols)
+template<class T> Matrix<T>::Matrix (std::size_t rows, std::size_t cols)
: nrows (rows), ncols (cols), data (new T[nrows*ncols])
{}
template<class T> Matrix<T>::Matrix (const Matrix& src) :
nrows (src.getNRows ()), ncols (src.getNCols ()), data (new T[nrows * ncols])
{
- for (size_t i = 0; i < nrows; i++)
- for (size_t j = 0; j < ncols; j++)
+ for (std::size_t i = 0; i < nrows; i++)
+ for (std::size_t j = 0; j < ncols; j++)
data[address(i,j)] = src (i, j);
}
@@ -122,9 +122,9 @@ template <class T> Matrix<T>::~Matrix ()
template<class T> void Matrix<T>::axpy ( T alpha, const T* x, T beta, T* y) const
{
- for (size_t i(0); i<nrows; i++) {
+ for (std::size_t i(0); i<nrows; i++) {
y[i] += beta * y[i];
- for (size_t j(0); j<ncols; j++) {
+ for (std::size_t j(0); j<ncols; j++) {
y[i] += alpha * data[address(i,j)] * x[j];
}
}
@@ -133,9 +133,9 @@ template<class T> void Matrix<T>::axpy ( T alpha, const T* x, T beta, T* y) cons
template<class T> T* Matrix<T>::operator* (const T *x) const
{
T *y (new T[nrows]);
- for (size_t i(0); i < nrows; i++) {
+ for (std::size_t i(0); i < nrows; i++) {
y[i] = 0.0;
- for (size_t j(0); j < ncols; j++) {
+ for (std::size_t j(0); j < ncols; j++) {
y[i] += data[address(i, j)] * x[j];
}
}
@@ -151,8 +151,8 @@ template<class T> Matrix<T>* Matrix<T>::operator+ (const Matrix<T>& mat) const t
throw std::range_error("Matrix::operator+, illegal matrix size!");
Matrix<T>* y(new Matrix<T> (nrows, ncols));
- for (size_t i = 0; i < nrows; i++) {
- for (size_t j = 0; j < ncols; j++) {
+ for (std::size_t i = 0; i < nrows; i++) {
+ for (std::size_t j = 0; j < ncols; j++) {
(*y)(i, j) = data[address(i, j)] + mat(i, j);
}
}
@@ -168,8 +168,8 @@ template<class T> Matrix<T>* Matrix<T>::operator- (const Matrix<T>& mat) const t
throw std::range_error("Matrix::operator-, illegal matrix size!");
Matrix<T>* y(new Matrix<T> (nrows, ncols));
- for (size_t i = 0; i < nrows; i++) {
- for (size_t j = 0; j < ncols; j++) {
+ for (std::size_t i = 0; i < nrows; i++) {
+ for (std::size_t j = 0; j < ncols; j++) {
(*y)(i, j) = data[address(i, j)] - mat(i, j);
}
}
@@ -185,12 +185,12 @@ template<class T> Matrix<T>* Matrix<T>::operator* (const Matrix<T>& mat) const t
throw std::range_error(
"Matrix::operator*, number of rows and cols should be the same!");
- size_t y_cols(mat.getNCols());
+ std::size_t y_cols(mat.getNCols());
Matrix<T>* y(new Matrix<T> (nrows, y_cols, T(0)));
- for (size_t i = 0; i < nrows; i++) {
- for (size_t j = 0; j < y_cols; j++) {
- for (size_t k = 0; k < ncols; k++)
+ for (std::size_t i = 0; i < nrows; i++) {
+ for (std::size_t j = 0; j < y_cols; j++) {
+ for (std::size_t k = 0; k < ncols; k++)
(*y)(i, j) += data[address(i, k)] * mat(k, j);
}
}
@@ -203,8 +203,8 @@ template<class T> Matrix<T>* Matrix<T>::transpose() const
{
Matrix<T>* y(new Matrix<T> (ncols, nrows));
- for (size_t i = 0; i < nrows; i++) {
- for (size_t j = 0; j < ncols; j++) {
+ for (std::size_t i = 0; i < nrows; i++) {
+ for (std::size_t j = 0; j < ncols; j++) {
// y->data[y->address(j, i)] = data[address(i, j)];
(*y)(j,i) = data[address(i, j)];
}
@@ -213,8 +213,8 @@ template<class T> Matrix<T>* Matrix<T>::transpose() const
}
template<class T> Matrix<T>* Matrix<T>::getSubMatrix(
- size_t b_row, size_t b_col,
- size_t e_row, size_t e_col) const throw (std::range_error)
+ std::size_t b_row, std::size_t b_col,
+ std::size_t e_row, std::size_t e_col) const throw (std::range_error)
{
if (b_row >= e_row | b_col >= e_col)
throw std::range_error ("Matrix::getSubMatrix() illegal sub matrix");
@@ -222,8 +222,8 @@ template<class T> Matrix<T>* Matrix<T>::getSubMatrix(
throw std::range_error ("Matrix::getSubMatrix() illegal sub matrix");
Matrix<T>* y(new Matrix<T> (e_row-b_row, e_col-b_col));
- for (size_t i=b_row; i<e_row; i++) {
- for (size_t j=b_col; j<e_col; j++) {
+ for (std::size_t i=b_row; i<e_row; i++) {
+ for (std::size_t j=b_col; j<e_col; j++) {
(*y)(i-b_row, j-b_col) = data[address(i, j)];
}
}
@@ -231,19 +231,19 @@ template<class T> Matrix<T>* Matrix<T>::getSubMatrix(
}
template<class T> void Matrix<T>::setSubMatrix(
- size_t b_row, size_t b_col, const Matrix<T>& sub_mat) throw (std::range_error)
+ std::size_t b_row, std::size_t b_col, const Matrix<T>& sub_mat) throw (std::range_error)
{
if (b_row + sub_mat.getNRows() > nrows | b_col + sub_mat.getNCols() > ncols)
throw std::range_error ("Matrix::setSubMatrix() sub matrix to big");
- for (size_t i=0; i<sub_mat.getNRows(); i++) {
- for (size_t j=0; j<sub_mat.getNCols(); j++) {
+ for (std::size_t i=0; i<sub_mat.getNRows(); i++) {
+ for (std::size_t j=0; j<sub_mat.getNCols(); j++) {
data[address(i+b_row, j+b_col)] = sub_mat(i,j);
}
}
}
-template<class T> T& Matrix<T>::operator() (size_t row, size_t col)
+template<class T> T& Matrix<T>::operator() (std::size_t row, std::size_t col)
throw (std::range_error)
{
if ( (row >= nrows) | ( col >= ncols) )
@@ -252,7 +252,7 @@ template<class T> T& Matrix<T>::operator() (size_t row, size_t col)
}
-template<class T> T& Matrix<T>::operator() (size_t row, size_t col) const
+template<class T> T& Matrix<T>::operator() (std::size_t row, std::size_t col) const
throw (std::range_error)
{
if ( (row >= nrows) | ( col >= ncols) )
@@ -262,8 +262,8 @@ template<class T> T& Matrix<T>::operator() (size_t row, size_t col) const
template <class T> void Matrix<T>::write (std::ostream &out) const
{
- for (size_t i = 0; i < nrows; i++) {
- for (size_t j = 0; j < ncols; j++) {
+ for (std::size_t i = 0; i < nrows; i++) {
+ for (std::size_t j = 0; j < ncols; j++) {
out << data[address(i, j)] << "\t";
}
out << std::endl;
@@ -273,7 +273,7 @@ template <class T> void Matrix<T>::write (std::ostream &out) const
template <class T> T sqrFrobNrm (const Matrix<T> &mat)
{
T nrm ((T)(0));
- size_t i,j;
+ std::size_t i,j;
for (j=0; j<mat.getNCols(); j++)
for (i=0; i<mat.getNRows(); i++)
nrm += mat(i,j) * mat(i,j);
diff --git a/MathLib/LinAlg/Solvers/GaussAlgorithm.h b/MathLib/LinAlg/Solvers/GaussAlgorithm.h
index aba4f5f3781194a36ff402b71082229698a4ec4d..b8f4dc153c2f94818b0e7d140a80c851a7646a27 100644
--- a/MathLib/LinAlg/Solvers/GaussAlgorithm.h
+++ b/MathLib/LinAlg/Solvers/GaussAlgorithm.h
@@ -67,11 +67,11 @@ private:
/**
* the size of the matrix
*/
- size_t _n;
+ std::size_t _n;
/**
* the permutation of the rows
*/
- size_t* _perm;
+ std::size_t* _perm;
};
} // end namespace MathLib
diff --git a/MathLib/LinAlg/VectorNorms.h b/MathLib/LinAlg/VectorNorms.h
index c0787fd94682b92e6656bf1411bb96951c5807a1..7d843f367805a5afa60d978bf7d8e5971e89c4f9 100644
--- a/MathLib/LinAlg/VectorNorms.h
+++ b/MathLib/LinAlg/VectorNorms.h
@@ -19,7 +19,7 @@
namespace MathLib {
-double normEuklid (double const * const vec, size_t n)
+double normEuklid (double const * const vec, std::size_t n)
{
return sqrt (scpr (vec, vec, n));
}
diff --git a/MathLib/MathTools.h b/MathLib/MathTools.h
index a44cbe32b680397041610e0264668c6839e1743d..e3465289074354c7dee1f850394c5c3d811e4cb8 100644
--- a/MathLib/MathTools.h
+++ b/MathLib/MathTools.h
@@ -42,7 +42,7 @@ T scpr(T const * const v0, T const * const v1)
res += v0[k] * v1[k];
}
#else
- for (size_t k(1); k < N; k++)
+ for (std::size_t k(1); k < N; k++)
res += v0[k] * v1[k];
#endif
return res;
@@ -52,7 +52,7 @@ template <> inline
double scpr<double,3>(double const * const v0, double const * const v1)
{
double res (v0[0]*v1[0]);
- for (size_t k(1); k < 3; k++)
+ for (std::size_t k(1); k < 3; k++)
res += v0[k] * v1[k];
return res;
}
@@ -69,7 +69,7 @@ T scpr(T const * const v0, T const * const v1, unsigned n)
res += v0[k] * v1[k];
}
#else
- for (size_t k(1); k < n; k++)
+ for (std::size_t k(1); k < n; k++)
res += v0[k] * v1[k];
#endif
return res;
@@ -149,11 +149,11 @@ double calcTetrahedronVolume(const double* x1, const double* x2, const double* x
* @return base^exp
*/
template <typename T> inline
-T fastpow (T base, size_t exp)
+T fastpow (T base, std::size_t exp)
{
T result (base);
if (exp == 0) result = static_cast<T>(1);
- for (size_t k(1); k<exp; k++) {
+ for (std::size_t k(1); k<exp; k++) {
result *= base;
}
return result;
diff --git a/MathLib/Vector3.h b/MathLib/Vector3.h
index 51c145515cc5e681ca5e25272a5c4dbe99126c25..5f942d4da33e0343f59456c8d1dc4772e8393bbe 100644
--- a/MathLib/Vector3.h
+++ b/MathLib/Vector3.h
@@ -61,19 +61,19 @@ public:
{ return TemplateVector (-this->x[0], -this->x[1], -this->x[2]); }
TemplateVector& operator+=(const TemplateVector & pV) {
- for (size_t i(0); i<3; i++) this->x[i]+=pV[i];
+ for (std::size_t i(0); i<3; i++) this->x[i]+=pV[i];
return *this;
}
TemplateVector& operator+=(const GeoLib::TemplatePoint<T>& pnt)
{
- for (size_t i(0); i<3; i++) this->_x[i] += pnt[i];
+ for (std::size_t i(0); i<3; i++) this->_x[i] += pnt[i];
return *this;
}
TemplateVector& operator-=(const TemplateVector & pV)
{
- for (size_t i(0); i<3; i++) this->_x[i] -= pV[i];
+ for (std::size_t i(0); i<3; i++) this->_x[i] -= pV[i];
return *this;
}
@@ -121,7 +121,7 @@ public:
TemplateVector& operator*=(double pR)
{
- for (size_t i(0); i<3; i++) this->_x[i]*=pR;
+ for (std::size_t i(0); i<3; i++) this->_x[i]*=pR;
return *this;
}
diff --git a/MathLib/vector_io.h b/MathLib/vector_io.h
index f19689e935f122e856bd7216d36ef540cf8e49a2..a4bb54a6009c8da82f394a80443cc59a7072c509 100644
--- a/MathLib/vector_io.h
+++ b/MathLib/vector_io.h
@@ -62,11 +62,11 @@ template <class T> void read ( std::istream &in, unsigned N, T *a )
while (!in.eof () and k <= N) {
std::string t;
getline (in, t);
- size_t i1;
+ std::size_t i1;
if (t.length () != 0) {
i1 = t.find_first_not_of (ws, 0);
if (i1 != std::string::npos) {
- size_t i2 = t.find_first_of (ws, i1);
+ std::size_t i2 = t.find_first_of (ws, i1);
if (i2 != std::string::npos) {
a[k++] = lexical_cast<T> ( t.substr(i1, i2-i1) );
} else {
@@ -77,8 +77,8 @@ template <class T> void read ( std::istream &in, unsigned N, T *a )
}
}
-template <class T> int readArrays ( const std::string &fname, size_t &s,
- size_t n, T* &arr )
+template <class T> int readArrays ( const std::string &fname, std::size_t &s,
+ std::size_t n, T* &arr )
{
// open stream
std::ifstream in (fname.c_str());
@@ -92,7 +92,7 @@ template <class T> int readArrays ( const std::string &fname, size_t &s,
}
if (s > 0) {
arr = new T[s * n];
- size_t j(0), l(0);
+ std::size_t j(0), l(0);
// read values
in.open (fname.c_str(), std::ios::in);
for (j=0; j<s; ++j) {
diff --git a/MeshLib/Mesh.h b/MeshLib/Mesh.h
index cef9ece7faf78d468ff9efc9551b5ff32d1dba64..179884d7b779d73e1ba6dd1226d76ffea72442f4 100644
--- a/MeshLib/Mesh.h
+++ b/MeshLib/Mesh.h
@@ -66,10 +66,10 @@ public:
double getMaxEdgeLength() const { return _edge_length[1]; };
/// Get the number of elements
- size_t getNElements() const { return _elements.size(); };
+ std::size_t getNElements() const { return _elements.size(); };
/// Get the number of nodes
- size_t getNNodes() const { return _nodes.size(); };
+ std::size_t getNNodes() const { return _nodes.size(); };
/// Get name of the mesh.
const std::string getName() const { return _name; };
diff --git a/MeshLib/MeshQuality/MeshQualityChecker.h b/MeshLib/MeshQuality/MeshQualityChecker.h
index 6fb929e2fe89be617c39e0bfde761847be8cc4c5..66e9c0dce28ad1935fd3900c12d963ce99c1a2fb 100644
--- a/MeshLib/MeshQuality/MeshQualityChecker.h
+++ b/MeshLib/MeshQuality/MeshQualityChecker.h
@@ -36,10 +36,10 @@ public:
std::vector<double> const& getMeshQuality () const;
double getMinValue() const;
double getMaxValue() const;
- virtual BASELIB::Histogram<double> getHistogram (size_t nclasses = 0) const;
+ virtual BASELIB::Histogram<double> getHistogram (std::size_t nclasses = 0) const;
protected:
- void errorMsg (const Element* elem, size_t idx) const;
+ void errorMsg (const Element* elem, std::size_t idx) const;
double _min;
double _max;
diff --git a/MeshLib/MshEditor.h b/MeshLib/MshEditor.h
index 3c3323e049aafd2376d009f0bbe6ffa6b6bbc348..787593abd2feecea5bbffc1bc74b181c11a87af7 100644
--- a/MeshLib/MshEditor.h
+++ b/MeshLib/MshEditor.h
@@ -39,7 +39,7 @@ public:
static void getSurfaceAreaForNodes(const MeshLib::Mesh* mesh, std::vector<double> &node_area_vec);
/// Removes the mesh nodes (and connected elements) given in the nodes-list from the mesh.
- static MeshLib::Mesh* removeMeshNodes(MeshLib::Mesh* mesh, const std::vector<size_t> &nodes);
+ static MeshLib::Mesh* removeMeshNodes(MeshLib::Mesh* mesh, const std::vector<std::size_t> &nodes);
/// Returns the surface nodes of a layered mesh.
static std::vector<GeoLib::PointWithID*> getSurfaceNodes(const MeshLib::Mesh &mesh);
diff --git a/MeshLib/Node.h b/MeshLib/Node.h
index 9436e1553f949c783d877460e8adfe6e9d95c335..e329d61fb284ecaf16a338b3eeb87a6fa5daae6f 100644
--- a/MeshLib/Node.h
+++ b/MeshLib/Node.h
@@ -21,6 +21,7 @@
#include "PointWithID.h"
#include "Mesh.h"
#include "MshEditor.h"
+#include "../Gui/DataView/MshLayerMapper.h" // TODO: Move MshLayerMapper to MeshLib
namespace MeshLib {
@@ -32,11 +33,14 @@ class Element;
class Node : public GeoLib::PointWithID
{
/* friend functions: */
- friend MeshLib::Mesh* MshEditor::removeMeshNodes(MeshLib::Mesh* mesh, const std::vector<size_t> &nodes);
+ friend MeshLib::Mesh* MshEditor::removeMeshNodes(MeshLib::Mesh* mesh, const std::vector<std::size_t> &nodes);
+ friend int MshLayerMapper::LayerMapping(MeshLib::Mesh* msh, const std::string &rasterfile,
+ const std::size_t nLayers, const std::size_t layer_id,
+ bool removeNoDataValues);
/* friend classes: */
friend class Mesh;
friend class MeshCoarsener;
- friend class MshLayerMapper;
+
public:
/// Constructor using a coordinate array
@@ -55,7 +59,7 @@ public:
const std::vector<Element*>& getElements() const { return _elements; };
/// Get number of elements the node is part of.
- size_t getNElements() const { return _elements.size(); };
+ std::size_t getNElements() const { return _elements.size(); };
/// Destructor
virtual ~Node();
@@ -75,7 +79,7 @@ protected:
/// Update coordinates of a node.
/// This method automatically also updates the areas/volumes of all connected elements.
virtual void updateCoordinates(double x, double y, double z);
-
+
std::vector<Node*> _connected_nodes;
std::vector<Element*> _elements;
diff --git a/SimpleTests/MeshTests/CMakeLists.txt b/SimpleTests/MeshTests/CMakeLists.txt
index b111ec3eca8af9cfe87efbec2f458bc5e40031b0..f266d6e6e49289862b71f3542d86c4869f35af98 100644
--- a/SimpleTests/MeshTests/CMakeLists.txt
+++ b/SimpleTests/MeshTests/CMakeLists.txt
@@ -46,7 +46,7 @@ TARGET_LINK_LIBRARIES ( CollapseMeshNodes
)
# Create MeshSearchTest executable
-ADD_EXECUTABLE( MeshSearchTest
+ADD_EXECUTABLE( MeshSearchTest
MeshSearchTest.cpp
${SOURCES}
${HEADERS}
@@ -59,5 +59,6 @@ TARGET_LINK_LIBRARIES ( MeshSearchTest
BaseLib
GeoLib
logog
+ ${ADDITIONAL_LIBS}
)