22eee9787e
* Added new feature to calculate channel multipliers from crop area. This also saves the crop area channel medians to the processing profiles, in order to get a more consistent color balance when batch-applying the same profile to multiple pictures from the same film roll. * Fixed wrong initialization of array, and missing check for the result of `getFilmNegativeMedians()`. Moved `ImProcCoordinator::translateCoord()` from private member to anonymous namespace. Fixed some whitespace and formatting issues. * Fixed some formatting issues * Passed `ipf` parameter as const in `translateCoord`. Narrowed `using namespace` to single class `Coord2D`. * Added `scaleGain` entry to thumbnail metadata file, to make `scale_mul` multipliers available in thumbnail processing phase. This simplifies multiplier calculations, so that "faking" thumbnail multipliers in the main image processing is not necessary anymore. This way, output values are immune to slight variations of multipliers between successive shots taken with in-camera AWB turned on. Shifted multipliers so that the output channel medians are balanced when "Camera WB" is selected. This way, just computing multipliers from crop and setting "Camera WB" (which is the default) gives a pretty well balanced image as a starting point. * New channel scaling method, based on a film base color sample instead of crop area channel medians. Channels are scaled so that the converted film base values are equal to 1/512th of the output range (65k). This giver better black levels in the output, and more consistency when batch-processing multiple negatives. The output is now compensated for a known fixed WB value, so that the film base will appear grey when WB is set to 3500K, Green=1. Added PPVERSION 347 to preserve backwards compatibility: when a processing profile saved by RT 5.7 is loaded (PPVERSION=346), the new fields are initialized to the special value -1, which will instruct the main processing to follow the old channel scaling behaviour. The old channel scaling multipliers will then be converted to the new film base values so that the resulting image is the same, and the fields will be overwritten as soon as the PP is saved again. This will transparently upgrade the processing profile. When the new behaviour is used, but the film base values are still unset, they are estimated based on channel medians, excluding a 20% border around the image. This should give a better result out-of-the-box for pictures containing a large film holder. * Code cleanup from review * Run astyle on film neg source files * Fixed automated build failure caused by incompatible libraries on my dev PC. * Simplified `Thumbnail::processFilmNegative` method signature. There is no need to pass in `rmi`,`gmi`,`bmi` multipliers from the caller, i can do the same with my own internal multipliers. * Added `FilmNegListener` class to pass estimeted film base values to the GUI after first processing. Removed old `filmBaseValues` instance variable from RawImageSource. * Code cleanup * Forgot to set baseValues flag in `PartialPasteDlg::applyPaste` Fixed `filmBaseValuesLabel` not updating when reading zero baseValues. Normally not needed (the label is updated later by the listener), but when the user is browsing through pictures the listener won't fire, so the label must be updated to show values are unset. * Overwritten channel scaling multipliers by calling `get_colorsCoeff` with `forceAutoWB=false`. Initially, in `RawImageSource::load`, channels are auto-balanced by averaging the whole picture when computing multipliers. This can give different multipliers for multiple shots of the same camera, which will lead to inconsistent conversions when batch-processing multiple negatives. This commit re-sets `scale_mul`, `ref_pre_mul`, etc., in order to "undo" the auto-WB and use the normal camera multipliers. * Found an easier way to get stable overall multipliers, removed the (horrible) on-the-fly mutation of scaling instance variables.
429 lines
12 KiB
C++
429 lines
12 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;
|
|
|
|
/** @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
|
|
{
|
|
|
|
friend class Crop;
|
|
|
|
protected:
|
|
Imagefloat *orig_prev;
|
|
Imagefloat *oprevi;
|
|
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;
|
|
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;
|
|
|
|
LUTf CAMBrightCurveJ, CAMBrightCurveQ;
|
|
|
|
LUTf rCurve;
|
|
LUTf gCurve;
|
|
LUTf bCurve;
|
|
ToneCurve customToneCurve1;
|
|
ToneCurve customToneCurve2;
|
|
ColorGradientCurve ctColorCurve;
|
|
OpacityCurve ctOpacityCurve;
|
|
NoiseCurve noiseLCurve;
|
|
NoiseCurve noiseCCurve;
|
|
WavCurve wavCLVCurve;
|
|
Wavblcurve wavblcurve;
|
|
WavOpacityCurveRG waOpacityCurveRG;
|
|
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;
|
|
AutoChromaListener* adnListener;
|
|
WaveletListener* awavListener;
|
|
RetinexListener* dehaListener;
|
|
|
|
HistogramListener* hListener;
|
|
std::vector<SizeListener*> sizeListeners;
|
|
|
|
std::vector<Crop*> crops;
|
|
|
|
bool resultValid;
|
|
|
|
MyMutex minit; // to gain mutually exclusive access to ... to what exactly?
|
|
|
|
void reallocAll ();
|
|
void updateLRGBHistograms ();
|
|
void setScale (int prevscale);
|
|
void updatePreviewImage (int todo, bool panningRelatedChange);
|
|
|
|
MyMutex mProcessing;
|
|
const std::unique_ptr<ProcParams> params;
|
|
|
|
// 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;
|
|
|
|
public:
|
|
|
|
ImProcCoordinator ();
|
|
~ImProcCoordinator () override;
|
|
void assign (ImageSource* imgsrc);
|
|
|
|
void getParams (procparams::ProcParams* dst) 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;
|
|
|
|
|
|
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;
|
|
|
|
bool getAutoWB (double& temp, double& green, double equal, double tempBias) override;
|
|
void getCamWB (double& temp, double& green) override;
|
|
void getSpotWB (int x, int y, int rectSize, double& temp, double& green) override;
|
|
bool getFilmNegativeExponents(int xA, int yA, int xB, int yB, std::array<float, 3>& newExps) override;
|
|
bool getRawSpotValues(int x, int y, int spotSize, std::array<float, 3>& rawValues) 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 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
|
|
{
|
|
hListener = h;
|
|
}
|
|
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 setAutoChromaListener (AutoChromaListener* adn) override
|
|
{
|
|
adnListener = adn;
|
|
}
|
|
void setRetinexListener (RetinexListener* adh) override
|
|
{
|
|
dehaListener = adh;
|
|
}
|
|
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;
|
|
|
|
};
|
|
|
|
}
|