Update for int and size_t

Author: alexbeattie42

OpenSim/Common/XsensDataReader.cpp

@@ -21,7 +21,7 @@ XsensDataReader* XsensDataReader::clone() const {
 
 typedef struct XsensDataReader::XsensIMU {
     std::string name;
-    int data_size;
+    size_t data_size;
     std::string rotation_format;
     std::map<std::string, std::string> comments;
     std::map<std::string, size_t> header;
@@ -55,12 +55,12 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
             _settings.get_rotation_representation();
     const std::string prefix = _settings.get_trial_prefix();
 
-    const int n_imus = _settings.getProperty_ExperimentalSensors().size();
+    const size_t n_imus = _settings.getProperty_ExperimentalSensors().size();
 
     // Prepare all the file handles
     // format: name, filename
     std::vector<std::pair<std::string, std::string>> imuFiles;
-    for (int index = 0; index < n_imus; ++index) {
+    for (size_t index = 0; index < n_imus; ++index) {
         std::string prefix = _settings.get_trial_prefix();
         const ExperimentalSensor& nextItem =
                 _settings.get_ExperimentalSensors(index);
@@ -109,7 +109,7 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
                 tokens = FileAdapter::tokenize(line, delimiter);
                 // Process each header in the line
                 for (const auto& token : tokens) {
-                    int tokenIndex = std::distance(tokens.begin(),
+                    size_t tokenIndex = std::distance(tokens.begin(),
                             std::find(tokens.begin(), tokens.end(), token));
                     imu.header.insert({token, tokenIndex});
                 }
@@ -166,7 +166,7 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
                                 imu.rotation_format + "\" and delimiter: \"" +
                                 delimiter + "\"");
                 std::vector<std::string> next_row;
-                int row_count = 0;
+                size_t row_count = 0;
                 while (!(next_row = FileAdapter::getNextLine(
                                  stream, delimiter + "\r"))
                                 .empty()) {
@@ -222,7 +222,6 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
                     if (found_rot_mat) {
                         // Create Mat33 then convert into Quaternion
                         SimTK::Mat33 imu_matrix{SimTK::NaN};
-                        int matrix_entry_index = 0;
                         imu_matrix[0][0] = OpenSim::IO::stod(
                                 next_row[imu.header.at(rot_mat_h[0])]);
                         imu_matrix[1][0] = OpenSim::IO::stod(
@@ -254,7 +253,7 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
 
     // Ensure all files have the same size, update rate, and rotation
     // format
-    std::vector<int> line_lengths(imus.size());
+    std::vector<size_t> line_lengths(imus.size());
     std::vector<double> update_rates(imus.size());
     std::vector<std::string> rotation_formats(imus.size());
 
@@ -293,29 +292,30 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
             "format!");
 
     // These have all been checked for uniformity
-    const int n_lines = line_lengths[0];
+    const size_t n_lines = line_lengths[0];
     const double sampling_rate = update_rates[0];
     const std::string rotation_format = rotation_formats[0];
 
+    OPENSIM_THROW_IF(
+            (n_lines > static_cast<size_t>(std::numeric_limits<int>::max())),
+            IOError, "Too many lines present in the data files!");
     // Will read data into pre-allocated Matrices in-memory rather than
     // appendRow on the fly to avoid the overhead of
-    SimTK::Matrix_<SimTK::Quaternion> rotationsData{n_lines, n_imus};
-    SimTK::Matrix_<SimTK::Vec3> linearAccelerationData{n_lines, n_imus};
-    SimTK::Matrix_<SimTK::Vec3> magneticHeadingData{n_lines, n_imus};
-    SimTK::Matrix_<SimTK::Vec3> angularVelocityData{n_lines, n_imus};
-
-    const bool has_acc =
-            std::all_of(imus.begin(), imus.end(), [&n_lines](const auto& imu) {
-                return imu.acc.size() == static_cast<std::size_t>(n_lines);
-            });
-    const bool has_gyr =
-            std::all_of(imus.begin(), imus.end(), [&n_lines](const auto& imu) {
-                return imu.gyr.size() == static_cast<std::size_t>(n_lines);
-            });
-    const bool has_mag =
-            std::all_of(imus.begin(), imus.end(), [&n_lines](const auto& imu) {
-                return imu.mag.size() == static_cast<std::size_t>(n_lines);
-            });
+    SimTK::Matrix_<SimTK::Quaternion> rotationsData{
+            static_cast<int>(n_lines), n_imus};
+    SimTK::Matrix_<SimTK::Vec3> linearAccelerationData{
+            static_cast<int>(n_lines), n_imus};
+    SimTK::Matrix_<SimTK::Vec3> magneticHeadingData{
+            static_cast<int>(n_lines), n_imus};
+    SimTK::Matrix_<SimTK::Vec3> angularVelocityData{
+            static_cast<int>(n_lines), n_imus};
+
+    const bool has_acc = std::all_of(imus.begin(), imus.end(),
+            [&n_lines](const auto& imu) { return imu.acc.size() == n_lines; });
+    const bool has_gyr = std::all_of(imus.begin(), imus.end(),
+            [&n_lines](const auto& imu) { return imu.gyr.size() == n_lines; });
+    const bool has_mag = std::all_of(imus.begin(), imus.end(),
+            [&n_lines](const auto& imu) { return imu.mag.size() == n_lines; });
 
     // We use a vector of row indices to transform over the rows (i.e., the time
     // steps)
@@ -340,18 +340,15 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
                         n_imus, SimTK::Vec3(SimTK::NaN));
                 const bool has_quat = std::all_of(
                         imus.begin(), imus.end(), [&n_lines](const auto& imu) {
-                            return imu.quat.size() ==
-                                   static_cast<std::size_t>(n_lines);
+                            return imu.quat.size() == n_lines;
                         });
                 const bool has_euler = std::all_of(
                         imus.begin(), imus.end(), [&n_lines](const auto& imu) {
-                            return imu.euler.size() ==
-                                   static_cast<std::size_t>(n_lines);
+                            return imu.euler.size() == n_lines;
                         });
                 const bool has_rot_mat = std::all_of(
                         imus.begin(), imus.end(), [&n_lines](const auto& imu) {
-                            return imu.rot_mat.size() ==
-                                   static_cast<std::size_t>(n_lines);
+                            return imu.rot_mat.size() == n_lines;
                         });
                 if (has_acc) {
                     std::transform(imus.begin(), imus.end(),
@@ -403,7 +400,7 @@ DataAdapter::OutputTables XsensDataReader::extendRead(
 
     const double timeIncrement = 1.0 / sampling_rate;
     const auto times =
-            createVectorLinspaceInterval(n_lines, 0.0, timeIncrement);
+            createVectorLinspaceInterval(static_cast<int>(n_lines), 0.0, timeIncrement);
     // Zero data matrices if the data is not found
     if (!has_acc) { linearAccelerationData.resize(0, n_imus); }
     if (!has_mag) { magneticHeadingData.resize(0, n_imus); }