drwnImageCache.h

/*****************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2017, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnImageCache.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <cassert>
#include <map>

#include "cv.h"

#include "drwnBase.h"
#include "drwnIO.h"

using namespace std;

// drwnImageCache ------------------------------------------------------------

class drwnImageCache {
protected:
    vector<string> _filenames; 

    vector<cv::Mat> _images;   
    vector<list<unsigned>::iterator> _free_list_map; 
    vector<unsigned> _lock_counter; 

    list<unsigned> _free_list;

    bool _bGreyImages;     
    bool _bBigMemoryModel; 
    size_t _imagesLoaded;  
    size_t _memoryUsed;    

#ifdef DRWN_USE_PTHREADS
    pthread_mutex_t _mutex; // thread safety
#endif

    // debug statistics
    unsigned _dbImagesLocked;
    unsigned _dbImagesLoaded;
    size_t _dbMaxMemUsed;

public:
    static size_t MAX_IMAGES; 
    static size_t MAX_MEMORY; 
    static bool GREY_IMAGES;  
    static bool BIG_MEMORY;   

public:
    drwnImageCache(bool bGreyImages = GREY_IMAGES, bool bBigMemory = BIG_MEMORY);
    drwnImageCache(const vector<string>& filenames, bool bGreyImages = GREY_IMAGES,
        bool bBigMemory = BIG_MEMORY);
    virtual ~drwnImageCache();

    void initialize(const vector<string>& filenames);

    void append(const string& filename);

    void clear();

    bool empty() const { return (_imagesLoaded == 0); }
    size_t size() const { return _imagesLoaded; }
    size_t numLocked() const { return _imagesLoaded - _free_list.size(); }
    size_t memory() const { return _memoryUsed; }

    const string& filename(unsigned indx) const { return _filenames[indx]; }

    int index(const string& filename) const {
        vector<string>::const_iterator it = find(_filenames.begin(), _filenames.end(), filename);
        if (it == _filenames.end()) return -1;
        return (int)(it - _filenames.begin());
    }

    void lock(unsigned indx);
    void lock(const string& filename) { lock((unsigned)index(filename)); }

    inline const cv::Mat& get(unsigned indx) const { return _images[indx]; }
    inline const cv::Mat& get(const string& filename) const {
        return _images[(unsigned)index(filename)];
    }

    void unlock(unsigned indx);
    void unlock(const string& filename) { unlock((unsigned)index(filename)); }

    cv::Mat copy(unsigned indx);
    cv::Mat copy(const string& filename) { return copy((unsigned)index(filename)); }

protected:
    void enforceLimits();

    virtual cv::Mat load(const string& filename) const;
};