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.
203 lines
8.8 KiB
C++
203 lines
8.8 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 <array>
|
|
#include <vector>
|
|
|
|
#include <glibmm/ustring.h>
|
|
|
|
#include "coord2d.h"
|
|
#include "imagedata.h"
|
|
#include "rtengine.h"
|
|
#include "colortemp.h"
|
|
#include "array2D.h"
|
|
|
|
template<typename T>
|
|
class LUT;
|
|
|
|
using LUTf = LUT<float>;
|
|
|
|
template<typename T, const size_t num>
|
|
class multi_array2D;
|
|
|
|
namespace rtengine
|
|
{
|
|
|
|
class ColorTemp;
|
|
class DCPProfile;
|
|
class DCPProfileApplyState;
|
|
class Imagefloat;
|
|
class RetinexgaintransmissionCurve;
|
|
class RetinextransmissionCurve;
|
|
|
|
namespace procparams
|
|
{
|
|
|
|
struct CoarseTransformParams;
|
|
struct ColorManagementParams;
|
|
struct FilmNegativeParams;
|
|
struct LensProfParams;
|
|
struct RAWParams;
|
|
struct RetinexParams;
|
|
struct ToneCurveParams;
|
|
struct CaptureSharpeningParams;
|
|
};
|
|
|
|
class ImageMatrices
|
|
{
|
|
|
|
public:
|
|
double rgb_cam[3][3] = {};
|
|
double cam_rgb[3][3] = {};
|
|
double xyz_cam[3][3] = {};
|
|
double cam_xyz[3][3] = {};
|
|
};
|
|
|
|
// TODO: Move implementation to .cc (Flössie)
|
|
class ImageSource : public InitialImage
|
|
{
|
|
|
|
private:
|
|
int references;
|
|
|
|
protected:
|
|
double redAWBMul, greenAWBMul, blueAWBMul; // local copy of the multipliers, to avoid recomputing the values
|
|
cmsHPROFILE embProfile;
|
|
Glib::ustring fileName;
|
|
FramesData* idata;
|
|
ImageMatrices imatrices;
|
|
double dirpyrdenoiseExpComp;
|
|
|
|
public:
|
|
ImageSource () : references (1), redAWBMul(-1.), greenAWBMul(-1.), blueAWBMul(-1.),
|
|
embProfile(nullptr), idata(nullptr), dirpyrdenoiseExpComp(RT_INFINITY) {}
|
|
|
|
~ImageSource () override {}
|
|
virtual int load (const Glib::ustring &fname) = 0;
|
|
virtual void preprocess (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) {};
|
|
virtual void filmNegativeProcess (const procparams::FilmNegativeParams ¶ms, std::array<float, 3>& filmBaseValues) {};
|
|
virtual bool getFilmNegativeExponents (Coord2D spotA, Coord2D spotB, int tran, const procparams::FilmNegativeParams& currentParams, std::array<float, 3>& newExps) { return false; };
|
|
virtual bool getRawSpotValues (Coord2D spot, int spotSize, int tran, const procparams::FilmNegativeParams ¶ms, std::array<float, 3>& rawValues) { return false; };
|
|
virtual void demosaic (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold, bool cache = false) {};
|
|
virtual void retinex (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &deh, const procparams::ToneCurveParams& Tc, LUTf & cdcurve, LUTf & mapcurve, const RetinextransmissionCurve & dehatransmissionCurve, const RetinexgaintransmissionCurve & dehagaintransmissionCurve, multi_array2D<float, 4> &conversionBuffer, bool dehacontlutili, bool mapcontlutili, bool useHsl, float &minCD, float &maxCD, float &mini, float &maxi, float &Tmean, float &Tsigma, float &Tmin, float &Tmax, LUTu &histLRETI) {};
|
|
virtual void retinexPrepareCurves (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) {};
|
|
virtual void retinexPrepareBuffers (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) {};
|
|
virtual void flush () = 0;
|
|
virtual void HLRecovery_Global (const procparams::ToneCurveParams &hrp) {};
|
|
virtual void HLRecovery_inpaint (float** red, float** green, float** blue) {};
|
|
|
|
virtual bool isRGBSourceModified () const = 0; // tracks whether cached rgb output of demosaic has been modified
|
|
|
|
virtual void setBorder (unsigned int border) {}
|
|
virtual void setCurrentFrame (unsigned int frameNum) = 0;
|
|
virtual int getFrameCount () = 0;
|
|
virtual int getFlatFieldAutoClipValue () = 0;
|
|
|
|
|
|
// use right after demosaicing image, add coarse transformation and put the result in the provided Imagefloat*
|
|
virtual void getImage (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const procparams::ToneCurveParams &hlp, const procparams::RAWParams &raw) = 0;
|
|
virtual eSensorType getSensorType () const = 0;
|
|
virtual bool isMono () const = 0;
|
|
// true is ready to provide the AutoWB, i.e. when the image has been demosaiced for RawImageSource
|
|
virtual bool isWBProviderReady () = 0;
|
|
|
|
virtual void convertColorSpace (Imagefloat* image, const procparams::ColorManagementParams &cmp, const ColorTemp &wb) = 0; // DIRTY HACK: this method is derived in rawimagesource and strimagesource, but (...,RAWParams raw) will be used ONLY for raw images
|
|
virtual void getAutoWBMultipliers (double &rm, double &gm, double &bm) = 0;
|
|
virtual void getAutoWBMultipliersitc(double &tempref, double &greenref, double &tempitc, double & greenitc, float &studgood, int begx, int begy, int yEn, int xEn, int cx, int cy, int bf_h, int bf_w, double &rm, double &gm, double &bm, const procparams::WBParams & wbpar, const procparams::ColorManagementParams &cmp, const procparams::RAWParams &raw) = 0;
|
|
virtual ColorTemp getWB () const = 0;
|
|
virtual ColorTemp getSpotWB (std::vector<Coord2D> &red, std::vector<Coord2D> &green, std::vector<Coord2D> &blue, int tran, double equal) = 0;
|
|
virtual void WBauto(double &tempref, double &greenref, array2D<float> &redloc, array2D<float> &greenloc, array2D<float> &blueloc, int bfw, int bfh, double &avg_rm, double &avg_gm, double &avg_bm, double &tempitc, double &greenitc, float &studgood, bool &twotimes, const procparams::WBParams & wbpar, int begx, int begy, int yEn, int xEn, int cx, int cy, const procparams::ColorManagementParams &cmp, const procparams::RAWParams &raw) = 0;
|
|
virtual void getrgbloc(int begx, int begy, int yEn, int xEn, int cx, int cy, int bf_h, int bf_w) = 0;
|
|
|
|
virtual double getDefGain () const
|
|
{
|
|
return 1.0;
|
|
}
|
|
|
|
virtual void getFullSize (int& w, int& h, int tr = TR_NONE) {}
|
|
virtual void getSize (const PreviewProps &pp, int& w, int& h) = 0;
|
|
virtual int getRotateDegree() const
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
virtual ImageMatrices* getImageMatrices () = 0;
|
|
virtual bool isRAW () const = 0;
|
|
virtual DCPProfile* getDCP (const procparams::ColorManagementParams &cmp, DCPProfileApplyState &as)
|
|
{
|
|
return nullptr;
|
|
};
|
|
|
|
virtual void setProgressListener (ProgressListener* pl) {}
|
|
|
|
void increaseRef () final
|
|
{
|
|
references++;
|
|
}
|
|
void decreaseRef () final
|
|
{
|
|
references--;
|
|
|
|
if (!references) {
|
|
delete this;
|
|
}
|
|
}
|
|
|
|
virtual void getAutoExpHistogram (LUTu & histogram, int& histcompr) = 0;
|
|
virtual void getRAWHistogram (LUTu & histRedRaw, LUTu & histGreenRaw, LUTu & histBlueRaw)
|
|
{
|
|
histRedRaw.clear();
|
|
histGreenRaw.clear();
|
|
histBlueRaw.clear(); // only some sources will supply this
|
|
}
|
|
|
|
// for RAW files, compute a tone curve using histogram matching on the embedded thumbnail
|
|
virtual void getAutoMatchedToneCurve(const procparams::ColorManagementParams &cp, std::vector<double> &outCurve)
|
|
{
|
|
outCurve = { 0.0 };
|
|
}
|
|
|
|
double getDirPyrDenoiseExpComp ( )
|
|
{
|
|
return dirpyrdenoiseExpComp;
|
|
}
|
|
// functions inherited from the InitialImage interface
|
|
Glib::ustring getFileName () final
|
|
{
|
|
return fileName;
|
|
}
|
|
cmsHPROFILE getEmbeddedProfile () final
|
|
{
|
|
return embProfile;
|
|
}
|
|
const FramesMetaData* getMetaData () final
|
|
{
|
|
return idata;
|
|
}
|
|
ImageSource* getImageSource () override
|
|
{
|
|
return this;
|
|
}
|
|
virtual void getRawValues(int x, int y, int rotate, int &R, int &G, int &B) = 0;
|
|
virtual void captureSharpening(const procparams::CaptureSharpeningParams &sharpeningParams, bool showMask, double &conrastThreshold, double &radius) = 0;
|
|
};
|
|
|
|
}
|