|| || || || || || || ||

---

RemoteRetriever.h

Go to the documentation of this file.

#ifndef Impala_Application_TagsLife_RemoteRetriever_h
#define Impala_Application_TagsLife_RemoteRetriever_h

#ifdef USE_CURL
//#include "Link/curl/curl.h"
#include "curl/curl.h"
#endif

#include <sys/stat.h>
#include <iostream>
#include <fstream>

#ifdef USE_BOOST_THREAD
#ifndef USE_BOOST_THREADPOOL
#include <boost/thread/thread.hpp>
#endif
#endif

#ifdef USE_BOOST_THREADPOOL
#define USE_BOOST_THREAD
// use this version for boost v. 34 (as on UvA FC8)
//#include "threadpool23/threadpool.hpp"
// use this version for boost >= 37 (as on decent machines)
#include "threadpool25/threadpool.hpp"
using namespace boost::threadpool;
#endif

#include "Visualization/RgbOglImage.h"
#include "Core/Array/ReadImage.h"

namespace Impala {
namespace Application {
namespace TagsLife {

class RemoteRetriever {
public:
    static RemoteRetriever* GetInstance() {
        if (!sInstance)
        {
            ILOG_INFO("Instantiating RemoteRetriever.");
            sInstance = new RemoteRetriever();
        }
        return sInstance;
    }

        /* requestImage returns an OGLIMAGE* that is either the resulting image or
         * if USE_BOOST_THREAD is defined an empty image of 0x0.
         *
         * This empty image will be initialized in a thread and with either the correct data or
         * with w = h = -1 in case of an error.
         */
        OGLIMAGE* requestImage(std::string url, bool fromCache=true, bool toCache=true) {
        Core::Array::Array2dVec3UInt8* empty = Core::Array::ArrayCreate<Core::Array::Array2dVec3UInt8>(0, 0, 0, 0);
        OGLIMAGE* oglIm = Visualization::RgbOglImage::OglImage(empty);
                if(!mUseCache) fromCache = toCache = false;
        RemoteImageRetriever retriever = RemoteImageRetriever(url, oglIm, fromCache, toCache, mCachePrefix);
#ifdef USE_BOOST_THREAD
#ifdef USE_BOOST_THREADPOOL
        threadpool.schedule(retriever);
#else
        boost::thread work(retriever);
#endif
#else
        retriever();
#endif
                ILOG_DEBUG("Returning image of " << oglIm->w << "x" << oglIm->h <<" pixels at " << oglIm);
        return oglIm;
    }

        std::string requestFile(std::string url, bool fromCache=true, bool toCache=true, std::string filename = "") {
                //if(filename == "" || !mUseCache) fromCache = toCache = false;
        RemoteFileRetriever retriever = RemoteFileRetriever(url, fromCache, toCache, filename);
#ifdef USE_BOOST_THREAD
#ifdef USE_BOOST_THREADPOOL
        threadpool.schedule(retriever);
#else
        boost::thread work(retriever);
#endif
#else
        retriever();
#endif
        return filename;
    }

        class RemoteFileRetriever {
        public:
                RemoteFileRetriever(std::string url, bool fromCache, bool toCache, std::string filename = "") :
                        url(url), fromCache(fromCache), toCache(toCache), filename(filename) {
                        target = std::string();
                }
                RemoteFileRetriever(std::string url, std::string &target, bool fromCache, bool toCache, std::string filename = "") :
                        url(url), fromCache(fromCache), toCache(toCache), filename(filename), target(target) {
                }

                int operator()() {
                        ILOG_DEBUG("Getting file from: " << url << " to store in " << target);

                        Core::Array::Array2dVec3UInt8* im = 0;
                        if(fromCache && FileExists(filename)) {
                                ILOG_DEBUG("Retrieving file from " << filename);
                                std::ifstream cachedFile(filename.c_str(), std::ios::binary | std::ios::in);
                                while (cachedFile.good())     // loop while extraction from file is possible
                                    target += (char) cachedFile.get();       // get character from file
                                cachedFile.close();
                                return 1;
                        }

#ifdef USE_CURL
                        CURL *h = curl_easy_init();
                        CURLcode result;

                        target = std::string();

                        curl_easy_setopt(h, CURLOPT_URL, url.c_str());
                        curl_easy_setopt(h, CURLOPT_WRITEFUNCTION, CurlCallback);
                        curl_easy_setopt(h, CURLOPT_WRITEDATA, &target);

                        ILOG_DEBUG("Retrieving remote: " << url);
                        result = curl_easy_perform(h);

                        if (result == CURLE_OK) {
                                ILOG_DEBUG("retrieved " << target.size() << ", trying decode...");

                                if(toCache) {
                                        std::ofstream cachedFile(filename.c_str(), std::ios::binary | std::ios::out);
                                        cachedFile << target;
                                        cachedFile.close();
                                } else {
                                }
                                curl_easy_cleanup(h);
                                return 1;
                        }
                        curl_easy_cleanup(h);
                        ILOG_ERROR("Could not retrieve URI: " << url);
                        return 0;
#else
                        ILOG_ERROR("Network retrieval of files not compiled in this version.");
                        return 0;
#endif
                }

                bool FileExists(std::string strFilename) {
                        struct stat stFileInfo;
                        int intStat = stat(strFilename.c_str(),&stFileInfo);
                        if(intStat == 0) return true;
                        return false;
                }

#ifdef USE_CURL
                static size_t CurlCallback(char *data, size_t size, size_t nmemb, std::string *buffer) {
                                if (buffer != 0) {
                                        buffer->append(data, size * nmemb);
                                } else return 0;
                                return size * nmemb;
                }
#endif

                std::string url, filename, target;
                bool toCache, fromCache;
        };

        class RemoteImageRetriever : RemoteFileRetriever {
        public:
                RemoteImageRetriever(std::string &url, OGLIMAGE* &oglIm, bool fromCache, bool toCache, std::string cachePrefix) :
                        oglIm(oglIm), RemoteFileRetriever(url, fromCache, toCache) {
                        filename = cachePrefix + url.substr(url.find_last_of('/')+1);
                }

                int operator()() {
                        ILOG_DEBUG("Getting Image from: " << url << " to store in " << target);

                        if((toCache || fromCache) && !FileExists("Cache")) {
                                ILOG_WARN("Cache folder does not exists, continuing without cache");
                                toCache = fromCache = false;
                        }

                        Core::Array::Array2dVec3UInt8* im = 0;

                        RemoteFileRetriever::operator()();

                        Core::Array::ReadJpgFromMemory(im, (char*) target.c_str(), target.size());
                        if(im != 0) {
                                oglIm->imageHandle = im;
                                oglIm->h = im->CH();
                                oglIm->w = im->CW();
                                oglIm->changed = 1;
                                ILOG_DEBUG("Loaded an image of " << oglIm->w << "x" << oglIm->h <<" pixels to " << oglIm << " from " << url);
                                return 1;
                        }

                        ILOG_ERROR("Failed to load image from " << url << "! (buffer.size = " << target.size() << ")");

                        oglIm->h = -1;
                        oglIm->w = -1;
                        oglIm->changed = 1;
                        return 0;
                }

                OGLIMAGE* oglIm;
        };

private:
        RemoteRetriever(std::string cachePrefix = "Cache/") // constructor: private
        {

#ifdef USE_CURL
                if (!sCurlInit) {
                        ILOG_DEBUG("Initializing CURL...");
                        // Only does something on Windows
                        curl_global_init(CURL_GLOBAL_WIN32);
                        sCurlInit = true;
                }
#endif

#ifdef USE_BOOST_THREADPOOL
                threadpool = pool(8);
#endif
                mCachePrefix = cachePrefix;
                //if(FileExists(mCachePrefix))
                mUseCache = true;
                //else
                //      ILOG_WARN("Cache folder does not exists, continuing without cache");
        }

        RemoteRetriever(RemoteRetriever const&){};             // copy constructor: private
        RemoteRetriever& operator=(RemoteRetriever const&){};  // assignment operator: private

        bool                                                     mUseCache;
        std::string                                              mCachePrefix;

        static RemoteRetriever*          sInstance;

#ifdef USE_CURL
        static bool sCurlInit;
#endif

#ifdef USE_BOOST_THREADPOOL
        pool threadpool;
#endif

    ILOG_VAR_DEC;
};

RemoteRetriever* RemoteRetriever::sInstance = 0;

#ifdef USE_CURL
bool RemoteRetriever::sCurlInit = false;
#endif

ILOG_VAR_INIT(RemoteRetriever, Application.TagsLife);

}
}
}

#endif // Impala_Application_TagsLife_RemoteRetriever_h

---