drwnImagePyramidCache.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-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnImagePyramidCache.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;

// drwnImagePyramidCache -----------------------------------------------------

class drwnImagePyramidCache {
protected:
    vector<string> _filenames; 

    vector<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;    

    double _downSampleRate; 
    int _minImageSize;      
    int _maxLevels;         


#ifdef DRWN_USE_PTHREADS
    pthread_mutex_t _mutex; 
#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:
    drwnImagePyramidCache(double downSampleRate = 0.5, int minSize = 32,
        int maxLevels = DRWN_INT_MAX, bool bGreyImages = GREY_IMAGES,
        bool bBigMemory = BIG_MEMORY);
    drwnImagePyramidCache(const vector<string>& filenames, double downSampleRate = 0.5,
        int minSize = 32, int maxLevels = DRWN_INT_MAX, bool bGreyImages = GREY_IMAGES,
        bool bBigMemory = BIG_MEMORY);
    ~drwnImagePyramidCache();

    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 size_t levels(unsigned indx) const { return _images[indx].size(); }
    inline size_t levels(const string& filename) const {
        return _images[(unsigned)index(filename)].size();
    }

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

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

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

protected:
    void enforceLimits();

    size_t memory(const vector<cv::Mat>& images) const;

    vector<cv::Mat> load(const string& filename) const;
};