frame_reader.h

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <cctype>
#include <cerrno>
#include <cstring>
#include <stdexcept>
#include <string>
#include <vector>
 
#include <dirent.h>
#include <sys/stat.h>
 
namespace ncorr {
 
inline const std::vector<std::string>& image_extensions() {
    static const std::vector<std::string> kImageExtensions = {".png", ".tif", ".tiff",
                                                              ".bmp", ".jpg", ".jpeg"};
    return kImageExtensions;
}
 
inline bool has_image_extension(const std::string& lower_name) {
    for (const std::string& ext : image_extensions()) {
        if (lower_name.size() > ext.size() &&
            lower_name.compare(lower_name.size() - ext.size(), ext.size(), ext) == 0) {
            return true;
        }
    }
    return false;
}
 
inline bool natural_less(const std::string& a, const std::string& b) {
    size_t i = 0, j = 0;
    while (i < a.size() && j < b.size()) {
        if (std::isdigit(static_cast<unsigned char>(a[i])) &&
            std::isdigit(static_cast<unsigned char>(b[j]))) {
            // Compare two runs of digits by numeric value (skip leading zeros).
            size_t ai = i, bj = j;
            while (ai < a.size() && std::isdigit(static_cast<unsigned char>(a[ai]))) ++ai;
            while (bj < b.size() && std::isdigit(static_cast<unsigned char>(b[bj]))) ++bj;
            std::string da = a.substr(i, ai - i);
            std::string db = b.substr(j, bj - j);
            da.erase(0, da.find_first_not_of('0'));
            db.erase(0, db.find_first_not_of('0'));
            if (da.size() != db.size()) return da.size() < db.size();
            if (da != db) return da < db;
            i = ai;
            j = bj;
        } else {
            if (a[i] != b[j]) return a[i] < b[j];
            ++i;
            ++j;
        }
    }
    return a.size() < b.size();
}
 
inline std::vector<std::string> discover_frames(const std::string& folder,
                                                const std::string& ref_path,
                                                const std::string& roi_path) {
    std::vector<std::string> frames;
    DIR* dir = opendir(folder.c_str());
    if (!dir) {
        throw std::runtime_error("Cannot open folder '" + folder + "': " + std::strerror(errno));
    }
 
    // Get basenames to exclude.
    std::string roi_basename = "";
    std::string ref_basename = "";
    if (!roi_path.empty()) {
        size_t pos = roi_path.find_last_of("/\\");
        roi_basename = (pos != std::string::npos) ? roi_path.substr(pos + 1) : roi_path;
    }
    if (!ref_path.empty()) {
        size_t pos = ref_path.find_last_of("/\\");
        ref_basename = (pos != std::string::npos) ? ref_path.substr(pos + 1) : ref_path;
    }
 
    struct dirent* entry;
    while ((entry = readdir(dir)) != nullptr) {
        std::string name = entry->d_name;
 
        // Skip empty names (defensive) and hidden files / "." / ".." entries.
        if (name.empty() || name[0] == '.') continue;
 
        // Skip nested sub-directories: only regular files are valid frames.
        std::string full_path = folder + "/" + name;
        struct stat st;
        if (stat(full_path.c_str(), &st) == 0 && S_ISDIR(st.st_mode)) continue;
 
        // Check for image extensions (case-insensitive, length-safe).
        std::string lower_name = name;
        std::transform(lower_name.begin(), lower_name.end(), lower_name.begin(),
                       [](unsigned char c) { return std::tolower(c); });
 
        if (!has_image_extension(lower_name)) continue;
 
        // Skip reserved roi.png / ref.png by default.
        if (lower_name == "roi.png") continue;
        if (lower_name == "ref.png") continue;
 
        // Skip explicitly specified roi and ref files.
        if (!roi_basename.empty() && name == roi_basename) continue;
        if (!ref_basename.empty() && name == ref_basename) continue;
 
        frames.push_back(full_path);
    }
    closedir(dir);
 
    // Sort frames naturally (handles both padded and unpadded numbered files).
    std::sort(frames.begin(), frames.end(), natural_less);
 
    return frames;
}
 
}  // namespace ncorr