wxImageCache.cpp

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
 
#include "wxImageCache.h"
#include "vigra_ext/utils.h"
#include "hugin/config_defaults.h"
#include "base_wx/platform.h"
#include "wxcms.h"
 
wxImage imageCacheEntry2wxImage(ImageCache::EntryPtr e)
{
    if (e->imageFloat->size().area() > 0)
    {
        // for float images we need to apply the mapping as selected by the user
        // in the preferences
        const int mapping = wxConfigBase::Get()->Read("/ImageCache/Mapping", HUGIN_IMGCACHE_MAPPING_FLOAT);
        // find average and variance
        vigra::RGBToGrayAccessor<vigra::RGBValue<float> > ga;
        vigra::FindAverageAndVariance<float> mean;   // init functor
        vigra::inspectImage(srcImageRange(*(e->imageFloat), ga), mean);
        // create temporary image with remapped tone scale
        vigra::BRGBImage mappedImg(e->imageFloat->size());
        // scale image to (mean - 3 * std deviation) - (mean + 3 * std deviation), 
        vigra_ext::applyMapping(srcImageRange(*(e->imageFloat)), destImage(mappedImg), std::max(mean.average() - 3 * sqrt(mean.variance()), 1e-6f), mean.average() + 3 * sqrt(mean.variance()), mapping);
        // convert to wxImage
        wxImage mappedwxImg(mappedImg.width(), mappedImg.height(), (unsigned char *)mappedImg.data(), true);
        return mappedwxImg.Copy();
    }
    else
    {
        ImageCacheRGB8Ptr img = e->get8BitImage();
        if (img)
        {
            return wxImage(img->width(), img->height(), (unsigned char *)img->data(), true);
        }
        else
        {
            // invalid wxImage
            return wxImage();
        };
    };
}
 
void GeneratePreviewSelectedFile(wxStaticBitmap* control, ImageCache::EntryPtr cacheEntry, const bool hasMonitorProfile, const cmsHPROFILE& monitorProfile)
{
    wxBusyCursor busyCursor;
    wxImage img = imageCacheEntry2wxImage(cacheEntry);
 
    double iRatio = img.GetWidth() / (double)img.GetHeight();
    wxSize sz;
    // estimate image size
    sz = control->GetContainingSizer()->GetSize();
    double sRatio = (double)sz.GetWidth() / sz.GetHeight();
    if (iRatio > sRatio)
    {
        // image is wider than screen, display landscape
        sz.SetHeight((int)(sz.GetWidth() / iRatio));
    }
    else
    {
        // portrait
        sz.SetWidth((int)(sz.GetHeight() * iRatio));
    }
    // Make sure the size is positive:
    // on a small window, m_smallImgCtrl can have 0 width.
    sz.IncTo(wxSize(1, 1));
    wxImageResizeQuality resizeQuality = wxIMAGE_QUALITY_NORMAL;
    if (std::max(img.GetWidth(), img.GetHeight()) > (ULONG_MAX >> 16))
    {
        // wxIMAGE_QUALITY_NORMAL resizes the image with ResampleNearest
        // this algorithm works only if image dimensions are smaller then 
        // ULONG_MAX >> 16 (actual size of unsigned long differ from system
        // to system)
        resizeQuality = wxIMAGE_QUALITY_BOX_AVERAGE;
    };
    wxImage scaled = img.Scale(sz.GetWidth(), sz.GetHeight(), resizeQuality);
    // now apply color profile
    if (!cacheEntry->iccProfile->empty() || hasMonitorProfile)
    {
        vigra::ImageImportInfo::ICCProfile iccProfile;
        // ignore icc profile for float images, because we have already color remapped image
        if (cacheEntry->imageFloat->width() == 0)
        {
            iccProfile = *(cacheEntry->iccProfile);
        }
        HuginBase::Color::CorrectImage(scaled, iccProfile, monitorProfile);
    };
    wxBitmap scaledBitmap(scaled);
    // set the DPI scale factor in wxBitmap, otherwise wxStaticBitmap scales the wxBitmap also
    scaledBitmap.SetScaleFactor(control->GetDPIScaleFactor());
    control->SetBitmap(scaledBitmap);
    control->GetParent()->Layout();
    control->Refresh();
}
 
wxDEFINE_EVENT(EVT_IMAGE_READY, ImageReadyEvent);
wxDEFINE_EVENT(EVT_LOADING_FAILED, wxCommandEvent);
 
ImageReadyEvent::ImageReadyEvent(HuginBase::ImageCache::RequestPtr request, HuginBase::ImageCache::EntryPtr entry) : wxEvent(0, EVT_IMAGE_READY), request(request), entry(entry)
{
}
 
wxEvent* ImageReadyEvent::Clone() const
{
    return new ImageReadyEvent(request, entry);
}
 
bool ImageCacheApp::OnInit()
{
    UpdateImageCacheSize();
    Bind(EVT_IMAGE_READY, &ImageCacheApp::relayImageLoaded, this);
    // Connect to ImageCache: we need to tell it when it is safe to handle UI events.
    ImageCache::getInstance().asyncLoadCompleteSignal = &ImageCacheApp::imageLoadedAsync;
    return true;
}
 
void ImageCacheApp::relayImageLoaded(ImageReadyEvent& event)
{
    if (event.entry.get())
    {
        ImageCache::getInstance().postEvent(event.request, event.entry);
    }
    else
    {
        // loading failed, first remove request from image cache list
        ImageCache::getInstance().removeRequest(event.request);
        // now notify main frame to remove the failed image from project
        wxCommandEvent e(EVT_LOADING_FAILED);
        e.SetString(wxString(event.request->getFilename().c_str(), HUGIN_CONV_FILENAME));
        wxTheApp->GetTopWindow()->GetEventHandler()->AddPendingEvent(e);
    };
}
 
void ImageCacheApp::imageLoadedAsync(ImageCache::RequestPtr request, ImageCache::EntryPtr entry)
{
    ImageReadyEvent event(request, entry);
    // AddPendingEvent adds the event to the event queue and returns without
    // processing it. This is necessary since we are probably not in the
    // UI thread, but the event handler must be run in the UI thread since it
    // could update image views.
    wxTheApp->GetTopWindow()->GetEventHandler()->AddPendingEvent(event);
}
 
void UpdateImageCacheSize()
{
#if defined __WXMSW__
    unsigned long long mem = HUGIN_IMGCACHE_UPPERBOUND;
    unsigned long mem_low = wxConfigBase::Get()->Read("/ImageCache/UpperBound", HUGIN_IMGCACHE_UPPERBOUND);
    unsigned long mem_high = wxConfigBase::Get()->Read("/ImageCache/UpperBoundHigh", 0l);
    if (mem_high > 0)
    {
        mem = ((unsigned long long) mem_high << 32) + mem_low;
    }
    else
    {
        mem = mem_low;
    }
    ImageCache::getInstance().SetUpperLimit(mem);
#else
    ImageCache::getInstance().SetUpperLimit(wxConfigBase::Get()->Read("/ImageCache/UpperBound", HUGIN_IMGCACHE_UPPERBOUND));
#endif
}