dataset-frames.h

Go to the documentation of this file.

/* This file is part of SOMHunter.
 *
 * Copyright (C) 2021 Frantisek Mejzlik <frankmejzlik@protonmail.com>
 *                    Mirek Kratochvil <exa.exa@gmail.com>
 *                    Patrik Vesely <prtrikvesely@gmail.com>
 *                    Vit Skrhak <v.skrhak@gmail.com>
 *
 * SOMHunter is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 2 of the License, or (at your option)
 * any later version.
 *
 * SOMHunter is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * SOMHunter. If not, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef DATASET_FRAMES_H_
#define DATASET_FRAMES_H_
 
#include <cassert>
#include <cstring>
#include <string>
#include <vector>
// ---
#include <nlohmann/json.hpp>
// ---
#include "common.h"
#include "utils.hpp"
 
namespace sh {
struct VideoFrame;
 
using VideoFramePointer = const VideoFrame*;
 
struct VideoFrame {
    VideoFrame() = default;
    VideoFrame(std::string&& filename, VideoId video_ID, ShotId shot_ID, FrameId frame_number, FrameId image_ID,
               uint8_t weekday = 0 /* Default is Monday. */, uint8_t hour = 0 /* Default is midnight. */,
               uint16_t year = 2021 /* Default is 2021. */)
        : filename{ std::move(filename) },
          video_ID{ video_ID },
          shot_ID{ shot_ID },
          frame_number{ frame_number },
          frame_ID{ image_ID },
          LSC_id{ "" },
          weekday{ weekday },
          hour{ hour },
          year{ year } {}
 
    nlohmann::json to_JSON() const {
        // clang-format off
        return nlohmann::json{
            { "videoId", video_ID }, 
            { "shotId",  shot_ID }, 
            { "frameNumber", frame_number }, 
            { "frameId", frame_ID },
            { "filename", filename }
        };
        // clang-format on
    }
 
    std::string filename;
    VideoId video_ID;
    ShotId shot_ID;
    FrameId frame_number;
    FrameId frame_ID;
 
    // *** LSC medadata ***
    std::string LSC_id;
 
    Weekday weekday;
 
    Hour hour;
 
    Year year;
};
 
struct FrameRange {
    std::vector<VideoFrame>::iterator _begin;
    std::vector<VideoFrame>::iterator _end;
 
    FrameRange() = default;
    FrameRange(std::vector<VideoFrame>::iterator b, std::vector<VideoFrame>::iterator e) : _begin(b), _end(e) {}
 
    size_t size() const { return _end - _begin; }
    const VideoFrame& operator[](size_t idx) const {
        // Iterator is random access so this is fine
        return *(_begin + idx);
    }
    VideoFrame& operator[](size_t idx) {
        // Iterator is random access so this is fine
        return *(_begin + idx);
    }
 
    std::vector<VideoFrame>::const_iterator begin() const { return _begin; }
    std::vector<VideoFrame>::iterator begin() { return _begin; }
 
    std::vector<VideoFrame>::const_iterator end() const { return _end; }
    std::vector<VideoFrame>::iterator end() { return _end; }
};
 
class FramePointerRange {
    std::vector<VideoFramePointer>::const_iterator _begin;
    std::vector<VideoFramePointer>::const_iterator _end;
    bool _valid{ false };
 
public:
    FramePointerRange() = default;
    FramePointerRange(std::vector<VideoFramePointer>::const_iterator b,
                      std::vector<VideoFramePointer>::const_iterator e)
        : _begin(b), _end(e), _valid(true) {}
    FramePointerRange(const std::vector<VideoFramePointer>& v) : _begin(v.cbegin()), _end(v.cend()), _valid(true) {}
 
    void print_display() {
        for (auto iter = begin(); iter != end(); iter++) std::cout << (*iter)->frame_ID << std::endl;
    }
 
    bool valid() const { return _valid; }
 
    size_t size() const { return _end - _begin; }
    const VideoFramePointer& operator[](size_t idx) const {
        // Iterator is random access so this is fine
        return *(_begin + idx);
    }
    const VideoFramePointer& operator[](size_t idx) {
        // Iterator is random access so this is fine
        return *(_begin + idx);
    }
 
    std::vector<VideoFramePointer>::const_iterator begin() const { return _begin; }
 
    std::vector<VideoFramePointer>::const_iterator end() const { return _end; }
};
 
class DatasetFrames {
    std::vector<FrameRange> _video_ID_to_frame_range;
    std::vector<VideoFrame> _frames;
 
    std::string frames_dir;
    std::string thumbs_dir;
    DatasetsSettings::VideoFilenameOffsets offs{};
 
public:
    DatasetFrames(const Settings& config);
 
    std::string operator[](FrameId i) const { return frames_dir + std::string{ _frames.at(i).filename }; }
 
    std::vector<VideoFrame>::iterator end() { return _frames.end(); };
    std::vector<VideoFrame>::iterator begin() { return _frames.begin(); };
 
    std::vector<VideoFrame>::const_iterator end() const { return _frames.end(); };
    std::vector<VideoFrame>::const_iterator begin() const { return _frames.begin(); };
 
    size_t get_num_videos() const { return _frames.back().video_ID + 1; }
 
    VideoFrame& get_frame(FrameId i) { return _frames[i]; }
 
    const VideoFrame& get_frame(FrameId i) const { return _frames[i]; }
 
    VideoFrame* get_frame_ptr(FrameId i) { return _frames.data() + i; }
 
    const VideoFrame* get_frame_ptr(FrameId i) const { return _frames.data() + i; }
 
    std::vector<VideoFrame>::const_iterator get_frame_it(FrameId i) const { return _frames.begin() + i; }
 
    size_t size() const { return _frames.size(); }
 
    VideoId get_video_id(FrameId img_ID) const {
        if (img_ID >= _frames.size()) {
            return VIDEO_ID_ERR_VAL;
        } else {
            return get_frame(img_ID).video_ID;
        }
    }
 
    FrameRange get_all_video_frames(VideoId video_ID) const { return _video_ID_to_frame_range[video_ID]; }
 
    FrameRange get_shot_frames(VideoId video_ID, size_t frame_num_from, size_t frame_num_to) const {
        // Get video range
        auto video_range = _video_ID_to_frame_range[video_ID];
 
        auto from_it = video_range.begin();
        auto to_it = video_range.end();
 
        --to_it;
 
        // Rewind to the first wanted frame
        while (from_it->frame_number < frame_num_from) {
            ++from_it;
        }
 
        // Rewind to the last wanted frame
        while (to_it->frame_number > frame_num_to) {
            --to_it;
        }
 
        // Return one frame behind to behave begin/end-like
        return FrameRange(from_it, to_it + 1);
    }
 
    std::vector<VideoFramePointer> ids_to_video_frame(const std::vector<FrameId>& ids) const;
    static std::vector<VideoFramePointer> range_to_video_frame(const FrameRange& ids);
 
private:
    static std::vector<std::vector<KeywordId>> parse_top_kws_for_imgs_text_file(const std::string& filepath);
 
    VideoFrame parse_video_filename(std::string&& filename);
 
    FiltersData parse_metadata_line(const std::string& line);
};
 
};  // namespace sh
 
#endif  // DATASET_FRAMES_H_