69c1caafa1
* Change Preferences for observer whitebalance * Change label white balance preferences * Added Preferences 2 parameters Whitebalance auto correlation * Add Preference Temperature correlation - sort and tooltip * Change to rtengine cmakelist * Apply patch from Lawrence37 * Small comment code * Change defaut order prefrences wba * Added force extra algoritm to Preferences * Harmonize itcwb sorted * Add fields to Preferences Itcwb * Change settings precision Itcwb in Preferences * Change tooltip Itcwb preferences * First stage Itwcwb settings in main with pp3 and selction in preferences * Second stage Itwcwb settings in main with pp3 and selction in preferences * Third stage Itwcwb settings in main with pp3 and selction in preferences * Add itcwb_fgreen student - green optimize * Add Itcwb green range * Itcwb history msg - first tooltips * Remove force-extra because always used * reused force-extra to use entire CIExy for sampling datas * Removed inwanted text in console * Set sensitive for Itcwbframe * Various change - comment .. * Small code review - chnage tooltips * Remove settings itcwb_delta in Rawimagesource.cc to simplify * Remove Itcwb Observer - put a single observer for everything - general - itcwb * Fixed conflicts in colortemp.cc * Various change - fixed bug - simplify * Fixed limits for settings pp3 - chnage tooltip * Clean unused code * Put itcwb_findgreen in GUI * Added checkbox 'Low sampling' to find the settings of 5.9 * Set Observer to Observer 10° - preferences default * Missing setting Low sampling * Show white balance multipliers * Change default settings - Itcwb_sorted * Move observer from preferences to WB * Make observer selectable for camera WB * Ensure observer checkbox is in sync with PP3 * Set default ITCWB low sampling for PP3s from <=5.9 Ensure temperature correlation white balance algorithm 1 is used when opening edits from versions 5.9 and earlier. * Removed unused White-balance frame in Preferences * Comment some GUI sliders checkbox * Removed all GUI itcwb in preferences and whitebalance * Removed forgotten code in preferences * Remove labels tooltips history Itcwb --------- Co-authored-by: Lawrence Lee <45837045+Lawrence37@users.noreply.github.com>
625 lines
19 KiB
C++
625 lines
19 KiB
C++
/*
|
|
* This file is part of RawTherapee.
|
|
*
|
|
* Copyright (c) 2004-2010 Gabor Horvath <hgabor@rawtherapee.com>
|
|
*
|
|
* RawTherapee 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* RawTherapee 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 RawTherapee. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
|
|
#include "array2D.h"
|
|
#include "colortemp.h"
|
|
#include "curves.h"
|
|
#include "dcrop.h"
|
|
#include "imagesource.h"
|
|
#include "improcfun.h"
|
|
#include "LUT.h"
|
|
#include "rtengine.h"
|
|
|
|
#include "../rtgui/threadutils.h"
|
|
|
|
namespace Glib
|
|
{
|
|
class Thread;
|
|
}
|
|
|
|
namespace rtengine
|
|
{
|
|
|
|
using namespace procparams;
|
|
|
|
class Crop;
|
|
class TweakOperator;
|
|
|
|
/** @brief Manages the image processing, espc. of the preview windows
|
|
*
|
|
* There is one ImProcCoordinator per edit panel.
|
|
*
|
|
* The ImProcCoordinator handle an sized down image representation of the full image, that is used when paning
|
|
* and in the Navigator object.
|
|
*
|
|
* Each ImProcCoordinator handles an rtengine::Crop list, which process images too with their own pipeline,
|
|
* but using this class' LUT and other precomputed parameters. The main preview area is displaying a non framed Crop object,
|
|
* while detail windows are framed Crop objects.
|
|
*/
|
|
class ImProcCoordinator final : public StagedImageProcessor, public HistogramObservable
|
|
{
|
|
|
|
friend class Crop;
|
|
|
|
protected:
|
|
Imagefloat *orig_prev;
|
|
Imagefloat *oprevi;
|
|
Imagefloat *spotprev;
|
|
LabImage *oprevl;
|
|
LabImage *nprevl;
|
|
Imagefloat *fattal_11_dcrop_cache; // global cache for ToneMapFattal02 used in 1:1 detail windows (except when denoise is active)
|
|
Image8 *previmg; // displayed image in monitor color space, showing the output profile as well (soft-proofing enabled, which then correspond to workimg) or not
|
|
Image8 *workimg; // internal image in output color space for analysis
|
|
CieImage *ncie;
|
|
|
|
ImageSource* imgsrc;
|
|
|
|
ColorTemp currWB;
|
|
ColorTemp autoWB;
|
|
ColorTemp currWBloc;
|
|
ColorTemp autoWBloc;
|
|
ColorTemp currWBitc;
|
|
|
|
double lastAwbEqual;
|
|
StandardObserver lastAwbObserver{ColorTemp::DEFAULT_OBSERVER};
|
|
double lastAwbTempBias;
|
|
Glib::ustring lastAwbauto;
|
|
|
|
Glib::ustring monitorProfile;
|
|
RenderingIntent monitorIntent;
|
|
bool softProof;
|
|
bool gamutCheck;
|
|
bool sharpMask;
|
|
bool sharpMaskChanged;
|
|
int scale;
|
|
bool highDetailPreprocessComputed;
|
|
bool highDetailRawComputed;
|
|
bool allocated;
|
|
|
|
void freeAll();
|
|
|
|
// Precomputed values used by DetailedCrop ----------------------------------------------
|
|
|
|
float bwAutoR, bwAutoG, bwAutoB;
|
|
float CAMMean;
|
|
LUTf hltonecurve;
|
|
LUTf shtonecurve;
|
|
LUTf tonecurve;
|
|
|
|
LUTf lumacurve;
|
|
LUTf chroma_acurve;
|
|
LUTf chroma_bcurve;
|
|
LUTf satcurve;
|
|
LUTf lhskcurve;
|
|
LUTf clcurve;
|
|
// multi_array2D<float, 3> conversionBuffer;
|
|
multi_array2D<float, 4> conversionBuffer;
|
|
LUTf wavclCurve;
|
|
LUTf clToningcurve;
|
|
LUTf cl2Toningcurve;
|
|
LUTf Noisecurve;
|
|
LUTf NoiseCCcurve;
|
|
|
|
LUTu vhist16, vhist16bw;
|
|
LUTu lhist16CAM;
|
|
LUTu lhist16CCAM;
|
|
LUTu lhist16RETI;
|
|
LUTu lhist16CLlad, lhist16LClad;
|
|
LUTu histRed, histRedRaw;
|
|
LUTu histGreen, histGreenRaw;
|
|
LUTu histBlue, histBlueRaw;
|
|
LUTu histLuma, histToneCurve, histToneCurveBW, histLCurve, histCCurve;
|
|
LUTu histLLCurve, histLCAM, histCCAM, histClad, bcabhist, histChroma, histLRETI;
|
|
bool hist_lrgb_dirty;
|
|
/// Used to simulate a lazy update of the raw histogram.
|
|
bool hist_raw_dirty;
|
|
int vectorscopeScale;
|
|
bool vectorscope_hc_dirty, vectorscope_hs_dirty;
|
|
array2D<int> vectorscope_hc, vectorscope_hs;
|
|
/// Waveform's intensity. Same as height of reference image.
|
|
int waveformScale;
|
|
bool waveform_dirty;
|
|
array2D<int> waveformRed, waveformGreen, waveformBlue, waveformLuma;
|
|
|
|
LUTf CAMBrightCurveJ, CAMBrightCurveQ;
|
|
|
|
LUTf rCurve;
|
|
LUTf gCurve;
|
|
LUTf bCurve;
|
|
ToneCurve customToneCurve1;
|
|
ToneCurve customToneCurve2;
|
|
ColorGradientCurve ctColorCurve;
|
|
OpacityCurve ctOpacityCurve;
|
|
NoiseCurve noiseLCurve;
|
|
NoiseCurve noiseCCurve;
|
|
WavCurve wavCLVCurve;
|
|
WavCurve wavdenoise;
|
|
WavCurve wavdenoiseh;
|
|
Wavblcurve wavblcurve;
|
|
WavOpacityCurveRG waOpacityCurveRG;
|
|
WavOpacityCurveSH waOpacityCurveSH;
|
|
WavOpacityCurveBY waOpacityCurveBY;
|
|
WavOpacityCurveW waOpacityCurveW;
|
|
WavOpacityCurveWL waOpacityCurveWL;
|
|
RetinextransmissionCurve dehatransmissionCurve;
|
|
RetinexgaintransmissionCurve dehagaintransmissionCurve;
|
|
|
|
ColorAppearance customColCurve1;
|
|
ColorAppearance customColCurve2;
|
|
ColorAppearance customColCurve3;
|
|
ToneCurve beforeToneCurveBW;
|
|
ToneCurve afterToneCurveBW;
|
|
|
|
LUTu rcurvehist, rcurvehistCropped, rbeforehist;
|
|
LUTu gcurvehist, gcurvehistCropped, gbeforehist;
|
|
LUTu bcurvehist, bcurvehistCropped, bbeforehist;
|
|
|
|
// ------------------------------------------------------------------------------------
|
|
|
|
int fw, fh, tr, fullw, fullh;
|
|
int pW, pH;
|
|
|
|
ProgressListener* plistener;
|
|
PreviewImageListener* imageListener;
|
|
AutoExpListener* aeListener;
|
|
AutoCamListener* acListener;
|
|
AutoBWListener* abwListener;
|
|
AutoWBListener* awbListener;
|
|
FlatFieldAutoClipListener *flatFieldAutoClipListener;
|
|
AutoContrastListener *bayerAutoContrastListener;
|
|
AutoContrastListener *xtransAutoContrastListener;
|
|
AutoContrastListener *pdSharpenAutoContrastListener;
|
|
AutoRadiusListener *pdSharpenAutoRadiusListener;
|
|
FrameCountListener *frameCountListener;
|
|
ImageTypeListener *imageTypeListener;
|
|
FilmNegListener *filmNegListener;
|
|
AutoColorTonListener* actListener;
|
|
AutoprimListener* primListener;
|
|
AutoChromaListener* adnListener;
|
|
WaveletListener* awavListener;
|
|
RetinexListener* dehaListener;
|
|
// LocallabListener* locallListener;
|
|
|
|
|
|
HistogramListener* hListener;
|
|
std::vector<SizeListener*> sizeListeners;
|
|
|
|
std::vector<Crop*> crops;
|
|
|
|
bool resultValid;
|
|
|
|
MyMutex minit; // to gain mutually exclusive access to ... to what exactly?
|
|
|
|
void backupParams();
|
|
void restoreParams();
|
|
void allocCache (Imagefloat* &imgfloat);
|
|
void notifyHistogramChanged();
|
|
void reallocAll();
|
|
/// Updates L, R, G, and B histograms. Returns true unless not updated.
|
|
bool updateLRGBHistograms();
|
|
/// Updates the H-C vectorscope. Returns true unless not updated.
|
|
bool updateVectorscopeHC();
|
|
/// Updates the H-S vectorscope. Returns true unless not updated.
|
|
bool updateVectorscopeHS();
|
|
/// Updates all waveforms. Returns true unless not updated.
|
|
bool updateWaveforms();
|
|
void setScale(int prevscale);
|
|
void updatePreviewImage (int todo, bool panningRelatedChange);
|
|
|
|
MyMutex mProcessing;
|
|
const std::unique_ptr<ProcParams> params; // used for the rendering, can be eventually tweaked
|
|
std::unique_ptr<ProcParams> paramsBackup; // backup of the untweaked procparams
|
|
TweakOperator* tweakOperator;
|
|
|
|
// for optimization purpose, the output profile, output rendering intent and
|
|
// output BPC will trigger a regeneration of the profile on parameter change only
|
|
// and automatically
|
|
Glib::ustring lastOutputProfile;
|
|
RenderingIntent lastOutputIntent;
|
|
bool lastOutputBPC;
|
|
|
|
// members of the updater:
|
|
Glib::Thread* thread;
|
|
MyMutex updaterThreadStart;
|
|
MyMutex paramsUpdateMutex;
|
|
int changeSinceLast;
|
|
bool updaterRunning;
|
|
const std::unique_ptr<ProcParams> nextParams;
|
|
bool destroying;
|
|
bool utili;
|
|
bool autili;
|
|
bool butili;
|
|
bool ccutili;
|
|
bool cclutili;
|
|
bool clcutili;
|
|
bool opautili;
|
|
bool wavcontlutili;
|
|
void startProcessing();
|
|
void process();
|
|
float colourToningSatLimit;
|
|
float colourToningSatLimitOpacity;
|
|
bool highQualityComputed;
|
|
cmsHTRANSFORM customTransformIn;
|
|
cmsHTRANSFORM customTransformOut;
|
|
ImProcFunctions ipf;
|
|
|
|
//locallab
|
|
LocallabListener* locallListener;
|
|
LUTf lllocalcurve;
|
|
LUTf cllocalcurve;
|
|
LUTf lclocalcurve;
|
|
LUTf cclocalcurve;
|
|
LUTf rgblocalcurve;
|
|
LUTf exlocalcurve;
|
|
LUTf hltonecurveloc;
|
|
LUTf shtonecurveloc;
|
|
LUTf tonecurveloc;
|
|
LUTf lightCurveloc;
|
|
LUTf lmasklocalcurve;
|
|
LUTf lmaskexplocalcurve;
|
|
LUTf lmaskSHlocalcurve;
|
|
LUTf lmaskviblocalcurve;
|
|
LUTf lmasktmlocalcurve;
|
|
LUTf lmaskretilocalcurve;
|
|
LUTf lmaskcblocalcurve;
|
|
LUTf lmaskbllocalcurve;
|
|
LUTf lmasklclocalcurve;
|
|
LUTf lmaskloglocalcurve;
|
|
LUTf lmasklocal_curve;
|
|
LUTf lmaskcielocalcurve;
|
|
LUTf cielocalcurve;
|
|
LUTf cielocalcurve2;
|
|
LUTf jzlocalcurve;
|
|
LUTf czlocalcurve;
|
|
LUTf czjzlocalcurve;
|
|
|
|
LocretigainCurve locRETgainCurve;
|
|
LocretitransCurve locRETtransCurve;
|
|
LocretigainCurverab locRETgainCurverab;
|
|
LocLHCurve loclhCurve;
|
|
LocHHCurve lochhCurve;
|
|
LocCHCurve locchCurve;
|
|
LocHHCurve lochhCurvejz;
|
|
LocCHCurve locchCurvejz;
|
|
LocLHCurve loclhCurvejz;
|
|
LocCCmaskCurve locccmasCurve;
|
|
LocLLmaskCurve locllmasCurve;
|
|
LocHHmaskCurve lochhmasCurve;
|
|
LocHHmaskCurve lochhhmasCurve;
|
|
LocCCmaskCurve locccmasexpCurve;
|
|
LocLLmaskCurve locllmasexpCurve;
|
|
LocHHmaskCurve lochhmasexpCurve;
|
|
LocCCmaskCurve locccmasSHCurve;
|
|
LocLLmaskCurve locllmasSHCurve;
|
|
LocHHmaskCurve lochhmasSHCurve;
|
|
LocCCmaskCurve locccmasvibCurve;
|
|
LocLLmaskCurve locllmasvibCurve;
|
|
LocHHmaskCurve lochhmasvibCurve;
|
|
LocCCmaskCurve locccmaslcCurve;
|
|
LocLLmaskCurve locllmaslcCurve;
|
|
LocHHmaskCurve lochhmaslcCurve;
|
|
LocCCmaskCurve locccmascbCurve;
|
|
LocLLmaskCurve locllmascbCurve;
|
|
LocHHmaskCurve lochhmascbCurve;
|
|
LocCCmaskCurve locccmasretiCurve;
|
|
LocLLmaskCurve locllmasretiCurve;
|
|
LocHHmaskCurve lochhmasretiCurve;
|
|
LocCCmaskCurve locccmastmCurve;
|
|
LocLLmaskCurve locllmastmCurve;
|
|
LocHHmaskCurve lochhmastmCurve;
|
|
LocCCmaskCurve locccmasblCurve;
|
|
LocLLmaskCurve locllmasblCurve;
|
|
LocHHmaskCurve lochhmasblCurve;
|
|
LocCCmaskCurve locccmas_Curve;
|
|
LocLLmaskCurve locllmas_Curve;
|
|
LocHHmaskCurve lochhmas_Curve;
|
|
LocHHmaskCurve lochhhmas_Curve;
|
|
LocCCmaskCurve locccmaslogCurve;
|
|
LocLLmaskCurve locllmaslogCurve;
|
|
LocHHmaskCurve lochhmaslogCurve;
|
|
LocCCmaskCurve locccmascieCurve;
|
|
LocLLmaskCurve locllmascieCurve;
|
|
LocHHmaskCurve lochhmascieCurve;
|
|
|
|
LocwavCurve locwavCurve;
|
|
LocwavCurve loclmasCurveblwav;
|
|
LocwavCurve loclmasCurvecolwav;
|
|
LocwavCurve loclevwavCurve;
|
|
LocwavCurve locconwavCurve;
|
|
LocwavCurve loccompwavCurve;
|
|
LocwavCurve loccomprewavCurve;
|
|
LocwavCurve locwavCurveden;
|
|
LocwavCurve locedgwavCurve;
|
|
LocwavCurve loclmasCurve_wav;
|
|
LocwavCurve locwavCurvehue;
|
|
LocwavCurve locwavCurvejz;
|
|
|
|
std::vector<float> huerefs;
|
|
std::vector<float> huerefblurs;
|
|
std::vector<float> chromarefblurs;
|
|
std::vector<float> lumarefblurs;
|
|
std::vector<float> chromarefs;
|
|
std::vector<float> lumarefs;
|
|
std::vector<float> sobelrefs;
|
|
std::vector<float> avgs;
|
|
std::vector<float> meantms;
|
|
std::vector<float> stdtms;
|
|
std::vector<float> meanretis;
|
|
std::vector<float> stdretis;
|
|
bool lastspotdup;
|
|
bool previewDeltaE;
|
|
int locallColorMask;
|
|
int locallColorMaskinv;
|
|
int locallExpMask;
|
|
int locallExpMaskinv;
|
|
int locallSHMask;
|
|
int locallSHMaskinv;
|
|
int locallvibMask;
|
|
int localllcMask;
|
|
int locallcbMask;
|
|
int locallretiMask;
|
|
int locallsoftMask;
|
|
int localltmMask;
|
|
int locallblMask;
|
|
int locallsharMask;
|
|
int localllogMask;
|
|
int locall_Mask;
|
|
int locallcieMask;
|
|
|
|
public:
|
|
|
|
ImProcCoordinator ();
|
|
~ImProcCoordinator () override;
|
|
void assign (ImageSource* imgsrc);
|
|
|
|
void getParams (procparams::ProcParams* dst, bool tweaked=false) override;
|
|
|
|
void startProcessing (int changeCode) override;
|
|
ProcParams* beginUpdateParams () override;
|
|
void endUpdateParams (ProcEvent change) override; // must be called after beginUpdateParams, triggers update
|
|
void endUpdateParams (int changeFlags) override;
|
|
void stopProcessing () override;
|
|
|
|
std::string *retistrsav;
|
|
|
|
void setPreviewScale (int scale) override
|
|
{
|
|
setScale(scale);
|
|
}
|
|
int getPreviewScale () override
|
|
{
|
|
return scale;
|
|
}
|
|
|
|
//void fullUpdatePreviewImage ();
|
|
|
|
int getFullWidth () override
|
|
{
|
|
return fullw;
|
|
}
|
|
int getFullHeight () override
|
|
{
|
|
return fullh;
|
|
}
|
|
|
|
int getPreviewWidth () override
|
|
{
|
|
return pW;
|
|
}
|
|
int getPreviewHeight () override
|
|
{
|
|
return pH;
|
|
}
|
|
|
|
DetailedCrop* createCrop (::EditDataProvider *editDataProvider, bool isDetailWindow) override;
|
|
|
|
void setTweakOperator (TweakOperator *tOperator) override;
|
|
void unsetTweakOperator (TweakOperator *tOperator) override;
|
|
bool getAutoWB (double& temp, double& green, double equal, StandardObserver observer, double tempBias) override;
|
|
void getCamWB (double& temp, double& green, StandardObserver observer) override;
|
|
void getSpotWB (int x, int y, int rectSize, double& temp, double& green) override;
|
|
bool getFilmNegativeSpot(int x, int y, int spotSize, FilmNegativeParams::RGB &refInput, FilmNegativeParams::RGB &refOutput) override;
|
|
void getAutoCrop (double ratio, int &x, int &y, int &w, int &h) override;
|
|
bool getHighQualComputed() override;
|
|
void setHighQualComputed() override;
|
|
void setMonitorProfile (const Glib::ustring& profile, RenderingIntent intent) override;
|
|
void getMonitorProfile (Glib::ustring& profile, RenderingIntent& intent) const override;
|
|
void setSoftProofing (bool softProof, bool gamutCheck) override;
|
|
void getSoftProofing (bool &softProof, bool &gamutCheck) override;
|
|
ProcEvent setSharpMask (bool sharpMask) override;
|
|
bool updateTryLock () override
|
|
{
|
|
return updaterThreadStart.trylock();
|
|
}
|
|
void updateUnLock () override
|
|
{
|
|
updaterThreadStart.unlock();
|
|
}
|
|
|
|
void setLocallabMaskVisibility(bool previewDeltaE, int locallColorMask, int locallColorMaskinv, int locallExpMask, int locallExpMaskinv, int locallSHMask, int locallSHMaskinv, int locallvibMask, int locallsoftMask, int locallblMask, int localltmMask, int locallretiMask, int locallsharMask, int localllcMask, int locallcbMask, int localllogMask, int locall_Mask, int locallcieMask) override
|
|
{
|
|
this->previewDeltaE = previewDeltaE;
|
|
this->locallColorMask = locallColorMask;
|
|
this->locallColorMaskinv = locallColorMaskinv;
|
|
this->locallExpMask = locallExpMask;
|
|
this->locallExpMaskinv = locallExpMaskinv;
|
|
this->locallSHMask = locallSHMask;
|
|
this->locallSHMaskinv = locallSHMaskinv;
|
|
this->locallvibMask = locallvibMask;
|
|
this->locallsoftMask = locallsoftMask;
|
|
this->locallblMask = locallblMask;
|
|
this->localltmMask = localltmMask;
|
|
this->locallretiMask = locallretiMask;
|
|
this->locallsharMask = locallsharMask;
|
|
this->localllcMask = localllcMask;
|
|
this->locallcbMask = locallcbMask;
|
|
this->localllogMask = localllogMask;
|
|
this->locall_Mask = locall_Mask;
|
|
this->locallcieMask = locallcieMask;
|
|
}
|
|
|
|
void setProgressListener (ProgressListener* pl) override
|
|
{
|
|
plistener = pl;
|
|
}
|
|
void setPreviewImageListener (PreviewImageListener* il) override
|
|
{
|
|
imageListener = il;
|
|
}
|
|
void setSizeListener (SizeListener* il) override
|
|
{
|
|
sizeListeners.push_back(il);
|
|
}
|
|
void delSizeListener (SizeListener* il) override
|
|
{
|
|
std::vector<SizeListener*>::iterator it = std::find(sizeListeners.begin(), sizeListeners.end(), il);
|
|
|
|
if (it != sizeListeners.end()) {
|
|
sizeListeners.erase(it);
|
|
}
|
|
}
|
|
void setAutoExpListener (AutoExpListener* ael) override
|
|
{
|
|
aeListener = ael;
|
|
}
|
|
void setHistogramListener (HistogramListener *h) override
|
|
{
|
|
if (hListener) {
|
|
hListener->setObservable(nullptr);
|
|
}
|
|
hListener = h;
|
|
if (h) {
|
|
h->setObservable(this);
|
|
}
|
|
}
|
|
void setAutoCamListener (AutoCamListener* acl) override
|
|
{
|
|
acListener = acl;
|
|
}
|
|
void setAutoBWListener (AutoBWListener* abw) override
|
|
{
|
|
abwListener = abw;
|
|
}
|
|
void setAutoWBListener (AutoWBListener* awb) override
|
|
{
|
|
awbListener = awb;
|
|
}
|
|
void setAutoColorTonListener (AutoColorTonListener* bwct) override
|
|
{
|
|
actListener = bwct;
|
|
}
|
|
void setAutoprimListener (AutoprimListener* pri) override
|
|
{
|
|
primListener = pri;
|
|
}
|
|
void setAutoChromaListener (AutoChromaListener* adn) override
|
|
{
|
|
adnListener = adn;
|
|
}
|
|
void setRetinexListener (RetinexListener* adh) override
|
|
{
|
|
dehaListener = adh;
|
|
}
|
|
void setLocallabListener (LocallabListener* lla) override
|
|
{
|
|
locallListener = lla;
|
|
}
|
|
void setWaveletListener (WaveletListener* awa) override
|
|
{
|
|
awavListener = awa;
|
|
}
|
|
|
|
void setFrameCountListener (FrameCountListener* fcl) override
|
|
{
|
|
frameCountListener = fcl;
|
|
}
|
|
|
|
void setFlatFieldAutoClipListener (FlatFieldAutoClipListener* ffacl) override
|
|
{
|
|
flatFieldAutoClipListener = ffacl;
|
|
}
|
|
void setBayerAutoContrastListener (AutoContrastListener* acl) override
|
|
{
|
|
bayerAutoContrastListener = acl;
|
|
}
|
|
|
|
void setXtransAutoContrastListener (AutoContrastListener* acl) override
|
|
{
|
|
xtransAutoContrastListener = acl;
|
|
}
|
|
|
|
void setpdSharpenAutoRadiusListener (AutoRadiusListener* acl) override
|
|
{
|
|
pdSharpenAutoRadiusListener = acl;
|
|
}
|
|
|
|
void setpdSharpenAutoContrastListener (AutoContrastListener* acl) override
|
|
{
|
|
pdSharpenAutoContrastListener = acl;
|
|
}
|
|
|
|
void setImageTypeListener (ImageTypeListener* itl) override
|
|
{
|
|
imageTypeListener = itl;
|
|
}
|
|
|
|
void setFilmNegListener (FilmNegListener* fnl) override
|
|
{
|
|
filmNegListener = fnl;
|
|
}
|
|
|
|
void saveInputICCReference (const Glib::ustring& fname, bool apply_wb) override;
|
|
|
|
InitialImage* getInitialImage () override
|
|
{
|
|
return imgsrc;
|
|
}
|
|
|
|
cmsHTRANSFORM& getCustomTransformIn ()
|
|
{
|
|
return customTransformIn;
|
|
}
|
|
|
|
cmsHTRANSFORM& getCustomTransformOut ()
|
|
{
|
|
return customTransformOut;
|
|
}
|
|
|
|
struct DenoiseInfoStore {
|
|
DenoiseInfoStore() : chM(0), max_r{}, max_b{}, ch_M{}, valid(false) {}
|
|
float chM;
|
|
float max_r[9];
|
|
float max_b[9];
|
|
float ch_M[9];
|
|
bool valid;
|
|
|
|
} denoiseInfoStore;
|
|
|
|
void requestUpdateHistogram() override;
|
|
void requestUpdateHistogramRaw() override;
|
|
void requestUpdateVectorscopeHC() override;
|
|
void requestUpdateVectorscopeHS() override;
|
|
void requestUpdateWaveform() override;
|
|
};
|
|
|
|
}
|