liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some first cleanups for locallab periphery

Browse Source
This commit is contained in:
Ingo Weyrich 2020-06-26 21:20:26 +02:00
parent d7c6b4b8f9
commit 01e48cc809
7 changed files with 344 additions and 750 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
rtengine/curves.cc
View File

@ -203,7 +203,6 @@ const double CurveFactory::sRGBGammaCurve = 2.4;
void fillCurveArray(DiagonalCurve* diagCurve, LUTf &outCurve, int skip, bool needed) void fillCurveArray(DiagonalCurve* diagCurve, LUTf &outCurve, int skip, bool needed)
{ {
if (needed) { if (needed) {
for (int i = 0; i <= 0xffff; i += i < 0xffff - skip ? skip : 1) { for (int i = 0; i <= 0xffff; i += i < 0xffff - skip ? skip : 1) {
// change to [0,1] range // change to [0,1] range
float val = (float)i / 65535.f; float val = (float)i / 65535.f;
@ -441,41 +440,21 @@ void CurveFactory::curveToning(const std::vector<double>& curvePoints, LUTf & To
fillCurveArray(dCurve.get(), ToningCurve, skip, needed); fillCurveArray(dCurve.get(), ToningCurve, skip, needed);
} }
void CurveFactory::curveLocal(bool & locallutili, const std::vector<double>& curvePoints, LUTf & LocalLCurve, int skip) bool CurveFactory::curveLocal(const std::vector<double>& curvePoints, LUTf& LocalCurve, int skip)
{ {
bool needed = false; bool needed = false;
std::unique_ptr<DiagonalCurve> dCurve; std::unique_ptr<DiagonalCurve> dCurve;
if (!curvePoints.empty() && curvePoints[0] != 0) { if (!curvePoints.empty() && curvePoints[0] != 0) {
dCurve = std::unique_ptr<DiagonalCurve> (new DiagonalCurve(curvePoints, CURVES_MIN_POLY_POINTS / skip)); dCurve.reset(new DiagonalCurve(curvePoints, CURVES_MIN_POLY_POINTS / skip));
if (dCurve && !dCurve->isIdentity()) { if (dCurve && !dCurve->isIdentity()) {
needed = true; needed = true;
locallutili = true;
} }
} }
fillCurveArray(dCurve.get(), LocalLCurve, skip, needed); fillCurveArray(dCurve.get(), LocalCurve, skip, needed);
//LocalLCurve.dump("wav"); return needed;
}
void CurveFactory::curveCCLocal(bool & localcutili, const std::vector<double>& curvePoints, LUTf & LocalCCurve, int skip)
{
bool needed = false;
std::unique_ptr<DiagonalCurve> dCurve;
if (!curvePoints.empty() && curvePoints[0] != 0) {
dCurve = std::unique_ptr<DiagonalCurve> (new DiagonalCurve(curvePoints, CURVES_MIN_POLY_POINTS / skip));
if (dCurve && !dCurve->isIdentity()) {
needed = true;
localcutili = true;
}
}
fillCurveArray(dCurve.get(), LocalCCurve, skip, needed);
//LocalLCurve.dump("wav");
} }
@ -498,46 +477,6 @@ void CurveFactory::curveskLocal(bool & localskutili, const std::vector<double>&
} }
void CurveFactory::curveexLocal(bool & localexutili, const std::vector<double>& curvePoints, LUTf & LocalexCurve, int skip)
{
bool needed = false;
std::unique_ptr<DiagonalCurve> dCurve;
// if (localexutili && !curvePoints.empty() && curvePoints[0] != 0) {
if (!curvePoints.empty() && curvePoints[0] != 0) {
dCurve = std::unique_ptr<DiagonalCurve> (new DiagonalCurve(curvePoints, CURVES_MIN_POLY_POINTS / skip));
if (dCurve && !dCurve->isIdentity()) {
needed = true;
localexutili = true;
}
}
fillCurveArray(dCurve.get(), LocalexCurve, skip, needed);
}
void CurveFactory::curvemaskLocal(bool & localmaskutili, const std::vector<double>& curvePoints, LUTf & LocalmaskCurve, int skip)
{
bool needed = false;
std::unique_ptr<DiagonalCurve> dCurve;
// if (localexutili && !curvePoints.empty() && curvePoints[0] != 0) {
if (!curvePoints.empty() && curvePoints[0] != 0) {
dCurve = std::unique_ptr<DiagonalCurve> (new DiagonalCurve(curvePoints, CURVES_MIN_POLY_POINTS / skip));
if (dCurve && !dCurve->isIdentity()) {
needed = true;
localmaskutili = true;
}
}
fillCurveArray(dCurve.get(), LocalmaskCurve, skip, needed);
}
void CurveFactory::localLCurve(double br, double contr, /*const std::vector<double>& curvePoints,*/ void CurveFactory::localLCurve(double br, double contr, /*const std::vector<double>& curvePoints,*/
LUTu & histogram, LUTf & outCurve, LUTu & histogram, LUTf & outCurve,
int skip, bool & utili) int skip, bool & utili)
@ -2548,16 +2487,17 @@ void LocHHmaskCurve::Set(const Curve &pCurve)
void LocHHmaskCurve::Set(const std::vector<double> &curvePoints, bool & lhmasutili) bool LocHHmaskCurve::Set(const std::vector<double> &curvePoints)
{ {
// if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { // if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2); FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2);
ttcurve.setIdentityValue(0.); ttcurve.setIdentityValue(0.);
lhmasutili = true;
Set(ttcurve); Set(ttcurve);
return true;
} else { } else {
Reset(); Reset();
return false;
} }
} }
@ -2598,16 +2538,17 @@ void LocCCmaskCurve::Set(const Curve &pCurve)
void LocCCmaskCurve::Set(const std::vector<double> &curvePoints, bool & lcmasutili) bool LocCCmaskCurve::Set(const std::vector<double> &curvePoints)
{ {
// if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { // if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2); FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2);
ttcurve.setIdentityValue(0.); ttcurve.setIdentityValue(0.);
lcmasutili = true;
Set(ttcurve); Set(ttcurve);
return true;
} else { } else {
Reset(); Reset();
return false;
} }
} }
@ -2644,16 +2585,17 @@ void LocLLmaskCurve::Set(const Curve &pCurve)
void LocLLmaskCurve::Set(const std::vector<double> &curvePoints, bool & llmasutili) bool LocLLmaskCurve::Set(const std::vector<double> &curvePoints)
{ {
// if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { // if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2); FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2);
ttcurve.setIdentityValue(0.); ttcurve.setIdentityValue(0.);
llmasutili = true;
Set(ttcurve); Set(ttcurve);
return true;
} else { } else {
Reset(); Reset();
return false;
} }
} }
@ -2692,16 +2634,17 @@ void LocHHCurve::Set(const Curve &pCurve)
void LocHHCurve::Set(const std::vector<double> &curvePoints, bool &HHutili) bool LocHHCurve::Set(const std::vector<double> &curvePoints)
{ {
// if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { // if (HHutili && !curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2); FlatCurve ttcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2);
ttcurve.setIdentityValue(0.); ttcurve.setIdentityValue(0.);
Set(ttcurve); Set(ttcurve);
HHutili = true; return true;
} else { } else {
Reset(); Reset();
return false;
} }
} }
@ -2740,7 +2683,7 @@ void LocLHCurve::Set(const Curve &pCurve)
void LocLHCurve::Set(const std::vector<double> &curvePoints, bool &LHutili) bool LocLHCurve::Set(const std::vector<double> &curvePoints)
{ {
if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
@ -2748,9 +2691,10 @@ void LocLHCurve::Set(const std::vector<double> &curvePoints, bool &LHutili)
FlatCurve tcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2); FlatCurve tcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2);
tcurve.setIdentityValue(0.); tcurve.setIdentityValue(0.);
Set(tcurve); Set(tcurve);
LHutili = true; return true;
} else { } else {
Reset(); Reset();
return false;
} }
} }
@ -2784,16 +2728,17 @@ void LocwavCurve::Set(const Curve &pCurve)
//lutLocCurve.dump("wav"); //lutLocCurve.dump("wav");
} }
void LocwavCurve::Set(const std::vector<double> &curvePoints, bool & lcwavutili) bool LocwavCurve::Set(const std::vector<double> &curvePoints)
{ {
if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) { if (!curvePoints.empty() && curvePoints[0] > FCT_Linear && curvePoints[0] < FCT_Unchanged) {
FlatCurve tcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2); FlatCurve tcurve(curvePoints, false, CURVES_MIN_POLY_POINTS / 2);
tcurve.setIdentityValue(0.); tcurve.setIdentityValue(0.);
lcwavutili = true;
Set(tcurve); Set(tcurve);
return true;
} else { } else {
Reset(); Reset();
return false;
} }
} }

17
rtengine/curves.h
View File

@ -375,11 +375,8 @@ public:
static void curveToning(const std::vector<double>& curvePoints, LUTf & ToningCurve, int skip); static void curveToning(const std::vector<double>& curvePoints, LUTf & ToningCurve, int skip);
static void curveLocal(bool & locallutili, const std::vector<double>& curvePoints, LUTf & LocalLCurve, int skip); static bool curveLocal(const std::vector<double>& curvePoints, LUTf& LocalCurve, int skip);
static void curveCCLocal(bool & localcutili, const std::vector<double>& curvePoints, LUTf & LocalCCurve, int skip);
static void curveskLocal(bool & localskutili, const std::vector<double>& curvePoints, LUTf & LocalskCurve, int skip); static void curveskLocal(bool & localskutili, const std::vector<double>& curvePoints, LUTf & LocalskCurve, int skip);
static void curveexLocal(bool & localexutili, const std::vector<double>& curvePoints, LUTf & LocalexCurve, int skip);
static void curvemaskLocal(bool & localmaskutili, const std::vector<double>& curvePoints, LUTf & LocalmaskCurve, int skip);
static void complexsgnCurve(bool & autili, bool & butili, bool & ccutili, bool & clcutili, const std::vector<double>& acurvePoints, static void complexsgnCurve(bool & autili, bool & butili, bool & ccutili, bool & clcutili, const std::vector<double>& acurvePoints,
const std::vector<double>& bcurvePoints, const std::vector<double>& cccurvePoints, const std::vector<double>& lccurvePoints, LUTf & aoutCurve, LUTf & boutCurve, LUTf & satCurve, LUTf & lhskCurve, const std::vector<double>& bcurvePoints, const std::vector<double>& cccurvePoints, const std::vector<double>& lccurvePoints, LUTf & aoutCurve, LUTf & boutCurve, LUTf & satCurve, LUTf & lhskCurve,
@ -632,7 +629,7 @@ public:
virtual ~LocLHCurve() {}; virtual ~LocLHCurve() {};
LocLHCurve(); LocLHCurve();
void Reset(); void Reset();
void Set(const std::vector<double> &curvePoints, bool &LHutili); bool Set(const std::vector<double> &curvePoints);
float getSum() const float getSum() const
{ {
return sum; return sum;
@ -1184,7 +1181,7 @@ public:
virtual ~LocHHmaskCurve() {}; virtual ~LocHHmaskCurve() {};
LocHHmaskCurve(); LocHHmaskCurve();
void Reset(); void Reset();
void Set(const std::vector<double> &curvePoints, bool & lhmasutili); bool Set(const std::vector<double> &curvePoints);
float getSum() const float getSum() const
{ {
return sum; return sum;
@ -1213,7 +1210,7 @@ public:
virtual ~LocCCmaskCurve() {}; virtual ~LocCCmaskCurve() {};
LocCCmaskCurve(); LocCCmaskCurve();
void Reset(); void Reset();
void Set(const std::vector<double> &curvePoints, bool & lcmasutili); bool Set(const std::vector<double> &curvePoints);
float getSum() const float getSum() const
{ {
return sum; return sum;
@ -1241,7 +1238,7 @@ public:
virtual ~LocLLmaskCurve() {}; virtual ~LocLLmaskCurve() {};
LocLLmaskCurve(); LocLLmaskCurve();
void Reset(); void Reset();
void Set(const std::vector<double> &curvePoints, bool & llmasutili); bool Set(const std::vector<double> &curvePoints);
float getSum() const float getSum() const
{ {
return sum; return sum;
@ -1270,7 +1267,7 @@ public:
virtual ~LocHHCurve() {}; virtual ~LocHHCurve() {};
LocHHCurve(); LocHHCurve();
void Reset(); void Reset();
void Set(const std::vector<double> &curvePoints, bool &HHutili); bool Set(const std::vector<double> &curvePoints);
float getSum() const float getSum() const
{ {
return sum; return sum;
@ -1355,7 +1352,7 @@ public:
virtual ~LocwavCurve() {}; virtual ~LocwavCurve() {};
LocwavCurve(); LocwavCurve();
void Reset(); void Reset();
void Set(const std::vector<double> &curvePoints, bool &lcwavutili); bool Set(const std::vector<double> &curvePoints);
float getSum() const float getSum() const
{ {
return sum; return sum;

489
rtengine/dcrop.cc
View File

@ -52,7 +52,7 @@ namespace rtengine
{ {
Crop::Crop(ImProcCoordinator* parent, EditDataProvider *editDataProvider, bool isDetailWindow) Crop::Crop(ImProcCoordinator* parent, EditDataProvider *editDataProvider, bool isDetailWindow)
: PipetteBuffer(editDataProvider), origCrop(nullptr), laboCrop(nullptr), labnCrop(nullptr), reservCrop(nullptr), lastorigCrop(nullptr), : PipetteBuffer(editDataProvider), origCrop(nullptr), laboCrop(nullptr), labnCrop(nullptr),
cropImg(nullptr), shbuf_real(nullptr), transCrop(nullptr), cieCrop(nullptr), shbuffer(nullptr), cropImg(nullptr), shbuf_real(nullptr), transCrop(nullptr), cieCrop(nullptr), shbuffer(nullptr),
updating(false), newUpdatePending(false), skip(10), updating(false), newUpdatePending(false), skip(10),
cropx(0), cropy(0), cropw(-1), croph(-1), cropx(0), cropy(0), cropw(-1), croph(-1),
@ -856,9 +856,6 @@ void Crop::update(int todo)
//if (tutu) { // //if (tutu) { //
//I made a little change here. Rather than have luminanceCurve (and others) use in/out lab images, we can do more if we copy right here. //I made a little change here. Rather than have luminanceCurve (and others) use in/out lab images, we can do more if we copy right here.
labnCrop->CopyFrom(laboCrop); labnCrop->CopyFrom(laboCrop);
reservCrop->CopyFrom(laboCrop);
lastorigCrop->CopyFrom(laboCrop);
//parent->ipf.luminanceCurve (labnCrop, labnCrop, parent->lumacurve); //parent->ipf.luminanceCurve (labnCrop, labnCrop, parent->lumacurve);
bool utili = parent->utili; bool utili = parent->utili;
@ -868,207 +865,131 @@ void Crop::update(int todo)
bool clcutili = parent->clcutili; bool clcutili = parent->clcutili;
bool cclutili = parent->cclutili; bool cclutili = parent->cclutili;
bool locallutili = parent->locallutili;
LUTf lllocalcurve2(65536, 0);
bool localclutili = parent->localclutili;
LUTf cllocalcurve2(65536, 0);
bool locallcutili = parent->locallcutili;
LUTf lclocalcurve2(65536, 0);
bool localcutili = parent->locallutili;
LUTf cclocalcurve2(65536, 0);
bool localrgbutili = parent->localrgbutili;
LUTf rgblocalcurve2(65536, 0);
bool localexutili = parent->localexutili;
LUTf exlocalcurve2(65536, 0);
bool localmaskutili = parent->localmaskutili;
bool localmaskexputili = parent->localmaskexputili;
bool localmaskSHutili = parent->localmaskSHutili;
bool localmaskvibutili = parent->localmaskvibutili;
bool localmasktmutili = parent->localmasktmutili;
bool localmaskretiutili = parent->localmaskretiutili;
bool localmaskcbutili = parent->localmaskcbutili;
bool localmaskblutili = parent->localmaskblutili;
bool localmasklcutili = parent->localmasklcutili;
LUTf lmasklocalcurve2(65536, 0);
LUTf lmaskexplocalcurve2(65536, 0);
LUTf lmaskSHlocalcurve2(65536, 0);
LUTf lmaskviblocalcurve2(65536, 0);
LUTf lmasktmlocalcurve2(65536, 0);
LUTf lmaskretilocalcurve2(65536, 0);
LUTf lmaskcblocalcurve2(65536, 0);
LUTf lmaskbllocalcurve2(65536, 0);
LUTf lmasklclocalcurve2(65536, 0);
LUTf hltonecurveloc2(65536, 0); //65536
LUTf shtonecurveloc2(65536, 0);
LUTf tonecurveloc2(65536, 0);
LUTf lightCurveloc2(32770, 0);
bool LHutili = parent->LHutili;
bool HHutili = parent->HHutili;
bool llmasutili = parent->llmasutili;
bool lhmasutili = parent->lhmasutili;
bool lhhmasutili = parent->lhhmasutili;
bool lcmasutili = parent->lcmasutili;
bool lhmasexputili = parent->lhmasexputili;
bool lcmasexputili = parent->lcmasexputili;
bool llmasexputili = parent->llmasexputili;
bool lhmasSHutili = parent->lhmasSHutili;
bool lcmasSHutili = parent->lcmasSHutili;
bool llmasSHutili = parent->llmasSHutili;
bool lhmasvibutili = parent->lhmasvibutili;
bool lcmasvibutili = parent->lcmasvibutili;
bool llmasvibutili = parent->llmasvibutili;
bool lhmaslcutili = parent->lhmaslcutili;
bool lcmaslcutili = parent->lcmaslcutili;
bool llmaslcutili = parent->llmaslcutili;
bool lhmascbutili = parent->lhmascbutili;
bool lcmascbutili = parent->lcmascbutili;
bool llmascbutili = parent->llmascbutili;
bool lhmasretiutili = parent->lhmasretiutili;
bool lcmasretiutili = parent->lcmasretiutili;
bool llmasretiutili = parent->llmasretiutili;
bool lhmastmutili = parent->lhmastmutili;
bool lcmastmutili = parent->lcmastmutili;
bool llmastmutili = parent->llmastmutili;
bool lhmasblutili = parent->lhmasblutili;
bool lcmasblutili = parent->lcmasblutili;
bool llmasblutili = parent->llmasblutili;
bool locwavutili = parent->locwavutili;
bool locwavdenutili = parent->locwavdenutili;
bool loclevwavutili = parent->loclevwavutili;
bool locconwavutili = parent->locconwavutili;
bool loccompwavutili = parent->loccompwavutili;
bool loccomprewavutili = parent->loccomprewavutili;
bool locedgwavutili = parent->locedgwavutili;
bool lmasutiliblwav = parent->lmasutiliblwav;
bool lmasutilicolwav = parent->lmasutilicolwav;
// float avg = parent->avg;
LUTu dummy;
bool needslocal = params.locallab.enabled;
LocretigainCurve locRETgainCurve;
LocretitransCurve locRETtransCurve;
LocLHCurve loclhCurve;
LocHHCurve lochhCurve;
LocCCmaskCurve locccmasCurve;
LocLLmaskCurve locllmasCurve;
LocHHmaskCurve lochhmasCurve;
LocHHmaskCurve lochhhmasCurve;
LocCCmaskCurve locccmasexpCurve;
LocLLmaskCurve locllmasexpCurve;
LocHHmaskCurve lochhmasexpCurve;
LocCCmaskCurve locccmasSHCurve;
LocLLmaskCurve locllmasSHCurve;
LocHHmaskCurve lochhmasSHCurve;
// LocHHmaskCurve lochhhmasSHCurve;
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;
LocwavCurve locwavCurve;
LocwavCurve loclmasCurveblwav;
LocwavCurve loclmasCurvecolwav;
LocwavCurve loclevwavCurve;
LocwavCurve locconwavCurve;
LocwavCurve loccompwavCurve;
LocwavCurve loccomprewavCurve;
LocwavCurve locedgwavCurve;
LocwavCurve locwavCurveden;
LocretigainCurverab locRETgainCurverab;
locallutili = false;
int sca = skip;
// bool tyty = false;
// int maxspot = 1;
bool needslocal = params.locallab.enabled && !params.locallab.spots.empty();
if (needslocal) { if (needslocal) {
const std::unique_ptr<LabImage> reservCrop(new LabImage(laboCrop->W, laboCrop->H));
reservCrop->CopyFrom(laboCrop);
const std::unique_ptr<LabImage> lastorigCrop(new LabImage(laboCrop->W, laboCrop->H));
lastorigCrop->CopyFrom(laboCrop);
auto& lllocalcurve2 = parent->lllocalcurve;
auto& cllocalcurve2 = parent->cllocalcurve;
auto& lclocalcurve2 = parent->lclocalcurve;
auto& cclocalcurve2 = parent->cclocalcurve;
auto& rgblocalcurve2 = parent->rgblocalcurve;
auto& exlocalcurve2 = parent->exlocalcurve;
auto& lmasklocalcurve2 = parent->lmasklocalcurve;
auto& lmaskexplocalcurve2 = parent->lmaskexplocalcurve;
auto& lmaskSHlocalcurve2 = parent->lmaskSHlocalcurve;
auto& lmaskviblocalcurve2 = parent->lmaskviblocalcurve;
auto& lmasktmlocalcurve2 = parent->lmasktmlocalcurve;
auto& lmaskretilocalcurve2 = parent->lmaskretilocalcurve;
auto& lmaskcblocalcurve2 = parent->lmaskcblocalcurve;
auto& lmaskbllocalcurve2 = parent->lmaskbllocalcurve;
auto& lmasklclocalcurve2 = parent->lmasklclocalcurve;
auto& hltonecurveloc2 = parent->hltonecurveloc;
auto& shtonecurveloc2 = parent->shtonecurveloc;
auto& tonecurveloc2 = parent->tonecurveloc;
auto& lightCurveloc2 = parent->lightCurveloc;
auto& locRETgainCurve = parent->locRETgainCurve;
auto& locRETtransCurve = parent->locRETtransCurve;
auto& loclhCurve = parent->loclhCurve;
auto& lochhCurve = parent->lochhCurve;
auto& locccmasCurve = parent->locccmasCurve;
auto& locllmasCurve = parent->locllmasCurve;
auto& lochhmasCurve = parent->lochhmasCurve;
auto& lochhhmasCurve = parent->lochhhmasCurve;
auto& locccmasexpCurve = parent->locccmasexpCurve;
auto& locllmasexpCurve = parent->locllmasexpCurve;
auto& lochhmasexpCurve = parent->lochhmasexpCurve;
auto& locccmasSHCurve = parent->locccmasSHCurve;
auto& locllmasSHCurve = parent->locllmasSHCurve;
auto& lochhmasSHCurve = parent->lochhmasSHCurve;
auto& locccmasvibCurve = parent->locccmasvibCurve;
auto& locllmasvibCurve = parent->locllmasvibCurve;
auto& lochhmasvibCurve = parent->lochhmasvibCurve;
auto& locccmaslcCurve = parent->locccmaslcCurve;
auto& locllmaslcCurve = parent->locllmaslcCurve;
auto& lochhmaslcCurve = parent->lochhmaslcCurve;
auto& locccmascbCurve = parent->locccmascbCurve;
auto& locllmascbCurve = parent->locllmascbCurve;
auto& lochhmascbCurve = parent->lochhmascbCurve;
auto& locccmasretiCurve = parent->locccmasretiCurve;
auto& locllmasretiCurve = parent->locllmasretiCurve;
auto& lochhmasretiCurve = parent->lochhmasretiCurve;
auto& locccmastmCurve = parent->locccmastmCurve;
auto& locllmastmCurve = parent->locllmastmCurve;
auto& lochhmastmCurve = parent->lochhmastmCurve;
auto& locccmasblCurve = parent->locccmasblCurve;
auto& locllmasblCurve = parent->locllmasblCurve;
auto& lochhmasblCurve = parent->lochhmasblCurve;
auto& locwavCurve = parent->locwavCurve;
auto& loclmasCurveblwav = parent->loclmasCurveblwav;
auto& loclmasCurvecolwav = parent->loclmasCurvecolwav;
auto& loclevwavCurve = parent->loclevwavCurve;
auto& locconwavCurve = parent->locconwavCurve;
auto& loccompwavCurve = parent->loccompwavCurve;
auto& loccomprewavCurve = parent->loccomprewavCurve;
auto& locedgwavCurve = parent->locedgwavCurve;
auto& locwavCurveden = parent->locwavCurveden;
for (int sp = 0; sp < (int)params.locallab.spots.size(); sp++) { for (int sp = 0; sp < (int)params.locallab.spots.size(); sp++) {
locRETgainCurve.Set(params.locallab.spots.at(sp).localTgaincurve); locRETgainCurve.Set(params.locallab.spots.at(sp).localTgaincurve);
locRETtransCurve.Set(params.locallab.spots.at(sp).localTtranscurve); locRETtransCurve.Set(params.locallab.spots.at(sp).localTtranscurve);
loclhCurve.Set(params.locallab.spots.at(sp).LHcurve, LHutili); const bool LHutili = loclhCurve.Set(params.locallab.spots.at(sp).LHcurve);
lochhCurve.Set(params.locallab.spots.at(sp).HHcurve, HHutili); const bool HHutili = lochhCurve.Set(params.locallab.spots.at(sp).HHcurve);
locccmasCurve.Set(params.locallab.spots.at(sp).CCmaskcurve, lcmasutili); const bool lcmasutili = locccmasCurve.Set(params.locallab.spots.at(sp).CCmaskcurve);
locllmasCurve.Set(params.locallab.spots.at(sp).LLmaskcurve, llmasutili); const bool llmasutili = locllmasCurve.Set(params.locallab.spots.at(sp).LLmaskcurve);
lochhmasCurve.Set(params.locallab.spots.at(sp).HHmaskcurve, lhmasutili); const bool lhmasutili = lochhmasCurve.Set(params.locallab.spots.at(sp).HHmaskcurve);
lochhhmasCurve.Set(params.locallab.spots.at(sp).HHhmaskcurve, lhhmasutili); const bool lhhmasutili = lochhhmasCurve.Set(params.locallab.spots.at(sp).HHhmaskcurve);
locccmasexpCurve.Set(params.locallab.spots.at(sp).CCmaskexpcurve, lcmasexputili); const bool lcmasexputili = locccmasexpCurve.Set(params.locallab.spots.at(sp).CCmaskexpcurve);
locllmasexpCurve.Set(params.locallab.spots.at(sp).LLmaskexpcurve, llmasexputili); const bool llmasexputili = locllmasexpCurve.Set(params.locallab.spots.at(sp).LLmaskexpcurve);
lochhmasexpCurve.Set(params.locallab.spots.at(sp).HHmaskexpcurve, lhmasexputili); const bool lhmasexputili = lochhmasexpCurve.Set(params.locallab.spots.at(sp).HHmaskexpcurve);
locccmasSHCurve.Set(params.locallab.spots.at(sp).CCmaskSHcurve, lcmasSHutili); const bool lcmasSHutili = locccmasSHCurve.Set(params.locallab.spots.at(sp).CCmaskSHcurve);
locllmasSHCurve.Set(params.locallab.spots.at(sp).LLmaskSHcurve, llmasSHutili); const bool llmasSHutili = locllmasSHCurve.Set(params.locallab.spots.at(sp).LLmaskSHcurve);
lochhmasSHCurve.Set(params.locallab.spots.at(sp).HHmaskSHcurve, lhmasSHutili); const bool lhmasSHutili = lochhmasSHCurve.Set(params.locallab.spots.at(sp).HHmaskSHcurve);
locccmasvibCurve.Set(params.locallab.spots.at(sp).CCmaskvibcurve, lcmasvibutili); const bool lcmasvibutili = locccmasvibCurve.Set(params.locallab.spots.at(sp).CCmaskvibcurve);
locllmasvibCurve.Set(params.locallab.spots.at(sp).LLmaskvibcurve, llmasvibutili); const bool llmasvibutili = locllmasvibCurve.Set(params.locallab.spots.at(sp).LLmaskvibcurve);
lochhmasvibCurve.Set(params.locallab.spots.at(sp).HHmaskvibcurve, lhmasvibutili); const bool lhmasvibutili = lochhmasvibCurve.Set(params.locallab.spots.at(sp).HHmaskvibcurve);
locccmascbCurve.Set(params.locallab.spots.at(sp).CCmaskcbcurve, lcmascbutili); const bool lcmascbutili = locccmascbCurve.Set(params.locallab.spots.at(sp).CCmaskcbcurve);
locllmascbCurve.Set(params.locallab.spots.at(sp).LLmaskcbcurve, llmascbutili); const bool llmascbutili = locllmascbCurve.Set(params.locallab.spots.at(sp).LLmaskcbcurve);
lochhmascbCurve.Set(params.locallab.spots.at(sp).HHmaskcbcurve, lhmascbutili); const bool lhmascbutili = lochhmascbCurve.Set(params.locallab.spots.at(sp).HHmaskcbcurve);
locccmasretiCurve.Set(params.locallab.spots.at(sp).CCmaskreticurve, lcmasretiutili); const bool lcmasretiutili = locccmasretiCurve.Set(params.locallab.spots.at(sp).CCmaskreticurve);
locllmasretiCurve.Set(params.locallab.spots.at(sp).LLmaskreticurve, llmasretiutili); const bool llmasretiutili = locllmasretiCurve.Set(params.locallab.spots.at(sp).LLmaskreticurve);
lochhmasretiCurve.Set(params.locallab.spots.at(sp).HHmaskreticurve, lhmasretiutili); const bool lhmasretiutili = lochhmasretiCurve.Set(params.locallab.spots.at(sp).HHmaskreticurve);
locccmastmCurve.Set(params.locallab.spots.at(sp).CCmasktmcurve, lcmastmutili); const bool lcmastmutili = locccmastmCurve.Set(params.locallab.spots.at(sp).CCmasktmcurve);
locllmastmCurve.Set(params.locallab.spots.at(sp).LLmasktmcurve, llmastmutili); const bool llmastmutili = locllmastmCurve.Set(params.locallab.spots.at(sp).LLmasktmcurve);
lochhmastmCurve.Set(params.locallab.spots.at(sp).HHmasktmcurve, lhmastmutili); const bool lhmastmutili = lochhmastmCurve.Set(params.locallab.spots.at(sp).HHmasktmcurve);
locccmasblCurve.Set(params.locallab.spots.at(sp).CCmaskblcurve, lcmasblutili); const bool lcmasblutili = locccmasblCurve.Set(params.locallab.spots.at(sp).CCmaskblcurve);
locllmasblCurve.Set(params.locallab.spots.at(sp).LLmaskblcurve, llmasblutili); const bool llmasblutili = locllmasblCurve.Set(params.locallab.spots.at(sp).LLmaskblcurve);
lochhmasblCurve.Set(params.locallab.spots.at(sp).HHmaskblcurve, lhmasblutili); const bool lhmasblutili = lochhmasblCurve.Set(params.locallab.spots.at(sp).HHmaskblcurve);
loclmasCurveblwav.Set(params.locallab.spots.at(sp).LLmaskblcurvewav, lmasutiliblwav); const bool lmasutiliblwav = loclmasCurveblwav.Set(params.locallab.spots.at(sp).LLmaskblcurvewav);
loclmasCurvecolwav.Set(params.locallab.spots.at(sp).LLmaskcolcurvewav, lmasutilicolwav); const bool lmasutilicolwav = loclmasCurvecolwav.Set(params.locallab.spots.at(sp).LLmaskcolcurvewav);
locccmaslcCurve.Set(params.locallab.spots.at(sp).CCmasklccurve, lcmaslcutili); const bool lcmaslcutili = locccmaslcCurve.Set(params.locallab.spots.at(sp).CCmasklccurve);
locllmaslcCurve.Set(params.locallab.spots.at(sp).LLmasklccurve, llmaslcutili); const bool llmaslcutili = locllmaslcCurve.Set(params.locallab.spots.at(sp).LLmasklccurve);
lochhmaslcCurve.Set(params.locallab.spots.at(sp).HHmasklccurve, lhmaslcutili); const bool lhmaslcutili = lochhmaslcCurve.Set(params.locallab.spots.at(sp).HHmasklccurve);
const bool locwavutili = locwavCurve.Set(params.locallab.spots.at(sp).locwavcurve);
locwavCurve.Set(params.locallab.spots.at(sp).locwavcurve, locwavutili); const bool locwavdenutili = locwavCurveden.Set(params.locallab.spots.at(sp).locwavcurveden);
locwavCurveden.Set(params.locallab.spots.at(sp).locwavcurveden, locwavdenutili); const bool loclevwavutili = loclevwavCurve.Set(params.locallab.spots.at(sp).loclevwavcurve);
loclevwavCurve.Set(params.locallab.spots.at(sp).loclevwavcurve, loclevwavutili); const bool locconwavutili = locconwavCurve.Set(params.locallab.spots.at(sp).locconwavcurve);
locconwavCurve.Set(params.locallab.spots.at(sp).locconwavcurve, locconwavutili); const bool loccompwavutili = loccompwavCurve.Set(params.locallab.spots.at(sp).loccompwavcurve);
loccompwavCurve.Set(params.locallab.spots.at(sp).loccompwavcurve, loccompwavutili); const bool loccomprewavutili = loccomprewavCurve.Set(params.locallab.spots.at(sp).loccomprewavcurve);
loccomprewavCurve.Set(params.locallab.spots.at(sp).loccomprewavcurve, loccomprewavutili); const bool locedgwavutili = locedgwavCurve.Set(params.locallab.spots.at(sp).locedgwavcurve);
locedgwavCurve.Set(params.locallab.spots.at(sp).locedgwavcurve, locedgwavutili); const bool locallutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).llcurve, lllocalcurve2, skip);
locallutili = false; const bool localclutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).clcurve, cllocalcurve2, skip);
CurveFactory::curveLocal(locallutili, params.locallab.spots.at(sp).llcurve, lllocalcurve2, sca); const bool locallcutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).lccurve, lclocalcurve2, skip);
localclutili = false; const bool localrgbutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).rgbcurve, rgblocalcurve2, skip);
CurveFactory::curveLocal(localclutili, params.locallab.spots.at(sp).clcurve, cllocalcurve2, sca); const bool localcutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).cccurve, cclocalcurve2, skip);
locallcutili = false; const bool localexutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).excurve, exlocalcurve2, skip);
CurveFactory::curveLocal(locallcutili, params.locallab.spots.at(sp).lccurve, lclocalcurve2, sca); const bool localmaskutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskcurve, lmasklocalcurve2, skip);
localrgbutili = false; const bool localmaskexputili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskexpcurve, lmaskexplocalcurve2, skip);
CurveFactory::curveLocal(localrgbutili, params.locallab.spots.at(sp).rgbcurve, rgblocalcurve2, sca); const bool localmaskSHutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).LmaskSHcurve, lmaskSHlocalcurve2, skip);
localcutili = false; const bool localmaskvibutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskvibcurve, lmaskviblocalcurve2, skip);
CurveFactory::curveCCLocal(localcutili, params.locallab.spots.at(sp).cccurve, cclocalcurve2, sca); const bool localmasktmutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmasktmcurve, lmasktmlocalcurve2, skip);
localexutili = false; const bool localmaskretiutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskreticurve, lmaskretilocalcurve2, skip);
CurveFactory::curveexLocal(localexutili, params.locallab.spots.at(sp).excurve, exlocalcurve2, sca); const bool localmaskcbutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskcbcurve, lmaskcblocalcurve2, skip);
localmaskutili = false; const bool localmasklcutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmasklccurve, lmasklclocalcurve2, skip);
CurveFactory::curvemaskLocal(localmaskutili, params.locallab.spots.at(sp).Lmaskcurve, lmasklocalcurve2, sca); const bool localmaskblutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskblcurve, lmaskbllocalcurve2, skip);
localmaskexputili = false;
CurveFactory::curvemaskLocal(localmaskexputili, params.locallab.spots.at(sp).Lmaskexpcurve, lmaskexplocalcurve2, sca);
localmaskSHutili = false;
CurveFactory::curvemaskLocal(localmaskSHutili, params.locallab.spots.at(sp).LmaskSHcurve, lmaskSHlocalcurve2, sca);
localmaskvibutili = false;
CurveFactory::curvemaskLocal(localmaskvibutili, params.locallab.spots.at(sp).Lmaskvibcurve, lmaskviblocalcurve2, sca);
localmasktmutili = false;
CurveFactory::curvemaskLocal(localmasktmutili, params.locallab.spots.at(sp).Lmasktmcurve, lmasktmlocalcurve2, sca);
localmaskretiutili = false;
CurveFactory::curvemaskLocal(localmaskretiutili, params.locallab.spots.at(sp).Lmaskreticurve, lmaskretilocalcurve2, sca);
localmaskcbutili = false;
CurveFactory::curvemaskLocal(localmaskcbutili, params.locallab.spots.at(sp).Lmaskcbcurve, lmaskcblocalcurve2, sca);
localmasklcutili = false;
CurveFactory::curvemaskLocal(localmasklcutili, params.locallab.spots.at(sp).Lmasklccurve, lmasklclocalcurve2, sca);
localmaskblutili = false;
CurveFactory::curvemaskLocal(localmaskblutili, params.locallab.spots.at(sp).Lmaskblcurve, lmaskbllocalcurve2, sca);
double ecomp = params.locallab.spots.at(sp).expcomp; double ecomp = params.locallab.spots.at(sp).expcomp;
double black = params.locallab.spots.at(sp).black; double black = params.locallab.spots.at(sp).black;
@ -1082,8 +1003,6 @@ void Crop::update(int todo)
double cont = params.locallab.spots.at(sp).contrast; double cont = params.locallab.spots.at(sp).contrast;
double huere, chromare, lumare, huerefblu, chromarefblu, lumarefblu, sobelre; double huere, chromare, lumare, huerefblu, chromarefblu, lumarefblu, sobelre;
int lastsav;
float avge;
huerefblu = parent->huerefblurs[sp]; huerefblu = parent->huerefblurs[sp];
chromarefblu = parent->chromarefblurs[sp]; chromarefblu = parent->chromarefblurs[sp];
lumarefblu = parent->lumarefblurs[sp]; lumarefblu = parent->lumarefblurs[sp];
@ -1091,9 +1010,9 @@ void Crop::update(int todo)
chromare = parent->chromarefs[sp]; chromare = parent->chromarefs[sp];
lumare = parent->lumarefs[sp]; lumare = parent->lumarefs[sp];
sobelre = parent->sobelrefs[sp]; sobelre = parent->sobelrefs[sp];
avge = parent->avgs[sp]; const float avge = parent->avgs[sp];
lastsav = parent->lastsavrests[sp]; int lastsav = parent->lastsavrests[sp];
float minCD; float minCD;
float maxCD; float maxCD;
@ -1105,10 +1024,10 @@ void Crop::update(int todo)
float Tmax; float Tmax;
CurveFactory::complexCurvelocal(ecomp, black / 65535., hlcompr, hlcomprthresh, shcompr, br, cont, lumare, CurveFactory::complexCurvelocal(ecomp, black / 65535., hlcompr, hlcomprthresh, shcompr, br, cont, lumare,
hltonecurveloc2, shtonecurveloc2, tonecurveloc2, lightCurveloc2, avge, hltonecurveloc2, shtonecurveloc2, tonecurveloc2, lightCurveloc2, avge,
sca); skip);
// Locallab mask are only shown for selected spot // Locallab mask are only shown for selected spot
if (sp == params.locallab.selspot) { if (sp == params.locallab.selspot) {
parent->ipf.Lab_Local(1, sp, (float**)shbuffer, labnCrop, labnCrop, reservCrop, lastorigCrop, cropx / skip, cropy / skip, skips(parent->fw, skip), skips(parent->fh, skip), skip, locRETgainCurve, locRETtransCurve, parent->ipf.Lab_Local(1, sp, (float**)shbuffer, labnCrop, labnCrop, reservCrop.get(), lastorigCrop.get(), cropx / skip, cropy / skip, skips(parent->fw, skip), skips(parent->fh, skip), skip, locRETgainCurve, locRETtransCurve,
lllocalcurve2,locallutili, lllocalcurve2,locallutili,
cllocalcurve2, localclutili, cllocalcurve2, localclutili,
lclocalcurve2, locallcutili, lclocalcurve2, locallcutili,
@ -1144,7 +1063,7 @@ void Crop::update(int todo)
parent->previewDeltaE, parent->locallColorMask, parent->locallColorMaskinv, parent->locallExpMask, parent->locallExpMaskinv, parent->locallSHMask, parent->locallSHMaskinv, parent->locallvibMask, parent->localllcMask, parent->locallsharMask, parent->locallcbMask, parent->locallretiMask, parent->locallsoftMask, parent->localltmMask, parent->locallblMask, parent->previewDeltaE, parent->locallColorMask, parent->locallColorMaskinv, parent->locallExpMask, parent->locallExpMaskinv, parent->locallSHMask, parent->locallSHMaskinv, parent->locallvibMask, parent->localllcMask, parent->locallsharMask, parent->locallcbMask, parent->locallretiMask, parent->locallsoftMask, parent->localltmMask, parent->locallblMask,
minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax); minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax);
} else { } else {
parent->ipf.Lab_Local(1, sp, (float**)shbuffer, labnCrop, labnCrop, reservCrop, lastorigCrop, cropx / skip, cropy / skip, skips(parent->fw, skip), skips(parent->fh, skip), skip, locRETgainCurve, locRETtransCurve, parent->ipf.Lab_Local(1, sp, (float**)shbuffer, labnCrop, labnCrop, reservCrop.get(), lastorigCrop.get(), cropx / skip, cropy / skip, skips(parent->fw, skip), skips(parent->fh, skip), skip, locRETgainCurve, locRETtransCurve,
lllocalcurve2,locallutili, lllocalcurve2,locallutili,
cllocalcurve2, localclutili, cllocalcurve2, localclutili,
lclocalcurve2, locallcutili, lclocalcurve2, locallcutili,
@ -1180,65 +1099,67 @@ void Crop::update(int todo)
minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax); minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax);
} }
lastorigCrop->CopyFrom(labnCrop); if (sp + 1u < params.locallab.spots.size()) {
// do not do this for last spot as it is not needed anymore
lllocalcurve2.clear(); lastorigCrop->CopyFrom(labnCrop);
lclocalcurve2.clear(); lllocalcurve2.clear();
cllocalcurve2.clear(); lclocalcurve2.clear();
lightCurveloc2.clear(); cllocalcurve2.clear();
rgblocalcurve2.clear(); lightCurveloc2.clear();
cclocalcurve2.clear(); rgblocalcurve2.clear();
exlocalcurve2.clear(); cclocalcurve2.clear();
lmasklocalcurve2.clear(); exlocalcurve2.clear();
lmaskexplocalcurve2.clear(); lmasklocalcurve2.clear();
lmaskSHlocalcurve2.clear(); lmaskexplocalcurve2.clear();
lmaskviblocalcurve2.clear(); lmaskSHlocalcurve2.clear();
lmasktmlocalcurve2.clear(); lmaskviblocalcurve2.clear();
lmaskretilocalcurve2.clear(); lmasktmlocalcurve2.clear();
lmaskcblocalcurve2.clear(); lmaskretilocalcurve2.clear();
lmaskbllocalcurve2.clear(); lmaskcblocalcurve2.clear();
hltonecurveloc2.clear(); lmaskbllocalcurve2.clear();
shtonecurveloc2.clear(); hltonecurveloc2.clear();
tonecurveloc2.clear(); shtonecurveloc2.clear();
locRETgainCurve.Reset(); tonecurveloc2.clear();
locRETtransCurve.Reset(); locRETgainCurve.Reset();
loclhCurve.Reset(); locRETtransCurve.Reset();
lochhCurve.Reset(); loclhCurve.Reset();
locccmasCurve.Reset(); lochhCurve.Reset();
locllmasCurve.Reset(); locccmasCurve.Reset();
lochhmasCurve.Reset(); locllmasCurve.Reset();
lochhhmasCurve.Reset(); lochhmasCurve.Reset();
locllmasexpCurve.Reset(); lochhhmasCurve.Reset();
locccmasexpCurve.Reset(); locllmasexpCurve.Reset();
lochhmasexpCurve.Reset(); locccmasexpCurve.Reset();
locllmasSHCurve.Reset(); lochhmasexpCurve.Reset();
locccmasSHCurve.Reset(); locllmasSHCurve.Reset();
lochhmasSHCurve.Reset(); locccmasSHCurve.Reset();
locllmasvibCurve.Reset(); lochhmasSHCurve.Reset();
locccmasvibCurve.Reset(); locllmasvibCurve.Reset();
lochhmasvibCurve.Reset(); locccmasvibCurve.Reset();
locllmascbCurve.Reset(); lochhmasvibCurve.Reset();
locccmascbCurve.Reset(); locllmascbCurve.Reset();
lochhmascbCurve.Reset(); locccmascbCurve.Reset();
locllmasretiCurve.Reset(); lochhmascbCurve.Reset();
locccmasretiCurve.Reset(); locllmasretiCurve.Reset();
lochhmasretiCurve.Reset(); locccmasretiCurve.Reset();
locllmastmCurve.Reset(); lochhmasretiCurve.Reset();
locccmastmCurve.Reset(); locllmastmCurve.Reset();
lochhmastmCurve.Reset(); locccmastmCurve.Reset();
locllmasblCurve.Reset(); lochhmastmCurve.Reset();
locccmasblCurve.Reset(); locllmasblCurve.Reset();
lochhmasblCurve.Reset(); locccmasblCurve.Reset();
locllmaslcCurve.Reset(); lochhmasblCurve.Reset();
locccmaslcCurve.Reset(); locllmaslcCurve.Reset();
lochhmaslcCurve.Reset(); locccmaslcCurve.Reset();
locwavCurve.Reset(); lochhmaslcCurve.Reset();
loclevwavCurve.Reset(); locwavCurve.Reset();
locconwavCurve.Reset(); loclevwavCurve.Reset();
locconwavCurve.Reset(); locconwavCurve.Reset();
locwavCurveden.Reset(); locconwavCurve.Reset();
loclmasCurveblwav.Reset(); locwavCurveden.Reset();
loclmasCurvecolwav.Reset(); loclmasCurveblwav.Reset();
loclmasCurvecolwav.Reset();
}
if (skip <= 2) { if (skip <= 2) {
Glib::usleep(settings->cropsleep); //wait to avoid crash when crop 100% and move window Glib::usleep(settings->cropsleep); //wait to avoid crash when crop 100% and move window
@ -1246,7 +1167,7 @@ void Crop::update(int todo)
} }
} }
// int moderetinex; LUTu dummy;
parent->ipf.chromiLuminanceCurve(this, 1, labnCrop, labnCrop, parent->chroma_acurve, parent->chroma_bcurve, parent->satcurve, parent->lhskcurve, parent->clcurve, parent->lumacurve, utili, autili, butili, ccutili, cclutili, clcutili, dummy, dummy); parent->ipf.chromiLuminanceCurve(this, 1, labnCrop, labnCrop, parent->chroma_acurve, parent->chroma_bcurve, parent->satcurve, parent->lhskcurve, parent->clcurve, parent->lumacurve, utili, autili, butili, ccutili, cclutili, clcutili, dummy, dummy);
parent->ipf.vibrance(labnCrop, params.vibrance, params.toneCurve.hrenabled, params.icm.workingProfile); parent->ipf.vibrance(labnCrop, params.vibrance, params.toneCurve.hrenabled, params.icm.workingProfile);
parent->ipf.labColorCorrectionRegions(labnCrop); parent->ipf.labColorCorrectionRegions(labnCrop);
@ -1635,22 +1556,6 @@ void Crop::freeAll()
labnCrop = nullptr; labnCrop = nullptr;
} }
if (reservCrop) {
delete reservCrop;
reservCrop = nullptr;
}
if (lastorigCrop) {
delete lastorigCrop;
lastorigCrop = nullptr;
}
/* if (lablocCrop ) {
delete lablocCrop;
lablocCrop = NULL;
}
*/
if (cropImg) { if (cropImg) {
delete cropImg; delete cropImg;
cropImg = nullptr; cropImg = nullptr;
@ -1826,24 +1731,6 @@ bool Crop::setCropSizes(int rcx, int rcy, int rcw, int rch, int skip, bool inter
labnCrop = new LabImage(cropw, croph); labnCrop = new LabImage(cropw, croph);
if (reservCrop) {
delete reservCrop; // labnCrop can't be resized
}
reservCrop = new LabImage(cropw, croph);
if (lastorigCrop) {
delete lastorigCrop; // labnCrop can't be resized
}
lastorigCrop = new LabImage(cropw, croph);
/* if (lablocCrop) {
delete lablocCrop; // labnCrop can't be resized
}
lablocCrop = new LabImage (cropw, croph);
*/
if (!cropImg) { if (!cropImg) {
cropImg = new Image8; cropImg = new Image8;
} }

2
rtengine/dcrop.h
View File

@ -40,8 +40,6 @@ protected:
Imagefloat* origCrop; // "one chunk" allocation Imagefloat* origCrop; // "one chunk" allocation
LabImage* laboCrop; // "one chunk" allocation LabImage* laboCrop; // "one chunk" allocation
LabImage* labnCrop; // "one chunk" allocation LabImage* labnCrop; // "one chunk" allocation
LabImage* reservCrop; // "one chunk" allocation
LabImage* lastorigCrop; // "one chunk" allocation
Image8* cropImg; // "one chunk" allocation ; displayed image in monitor color space, showing the output profile as well (soft-proofing enabled, which then correspond to workimg) or not Image8* cropImg; // "one chunk" allocation ; displayed image in monitor color space, showing the output profile as well (soft-proofing enabled, which then correspond to workimg) or not
float * shbuf_real; // "one chunk" allocation float * shbuf_real; // "one chunk" allocation

243
rtengine/improccoordinator.cc
View File

@ -187,8 +187,6 @@ ImProcCoordinator::ImProcCoordinator() :
// Locallab // Locallab
locallListener(nullptr), locallListener(nullptr),
reserv(nullptr),
lastorigimp(nullptr),
coordX(0), coordY(0), localX(0), localY(0), coordX(0), coordY(0), localX(0), localY(0),
lllocalcurve(65536, 0), lllocalcurve(65536, 0),
cllocalcurve(65536, 0), cllocalcurve(65536, 0),
@ -209,60 +207,6 @@ ImProcCoordinator::ImProcCoordinator() :
lmaskcblocalcurve(65536, 0), lmaskcblocalcurve(65536, 0),
lmaskbllocalcurve(65536, 0), lmaskbllocalcurve(65536, 0),
lmasklclocalcurve(65536, 0), lmasklclocalcurve(65536, 0),
locallutili(false),
localclutili(false),
locallcutili(false),
localcutili(false),
localrgbutili(false),
localexutili(false),
llmasutili(false),
lhmasutili(false),
lhhmasutili(false),
lcmasutili(false),
localmaskutili(false),
localmaskexputili(false),
localmaskSHutili(false),
localmaskvibutili(false),
localmasktmutili(false),
localmaskretiutili(false),
localmaskcbutili(false),
localmaskblutili(false),
localmasklcutili(false),
lcmasexputili(false),
lhmasexputili(false),
llmasexputili(false),
lcmasSHutili(false),
lhmasSHutili(false),
llmasSHutili(false),
lcmasvibutili(false),
lhmasvibutili(false),
llmasvibutili(false),
lcmaslcutili(false),
lhmaslcutili(false),
llmaslcutili(false),
lcmascbutili(false),
lhmascbutili(false),
llmascbutili(false),
lcmasretiutili(false),
lhmasretiutili(false),
llmasretiutili(false),
lcmastmutili(false),
lhmastmutili(false),
llmastmutili(false),
lcmasblutili(false),
lhmasblutili(false),
llmasblutili(false),
locwavutili(false),
locwavdenutili(false),
loclevwavutili(false),
locconwavutili(false),
loccompwavutili(false),
loccomprewavutili(false),
locedgwavutili(false),
lmasutiliblwav(false),
lmasutilicolwav(false),
LHutili(false),
HHutili(false),
lastsavrests(500, -10000), lastsavrests(500, -10000),
huerefs(500, -100000.f), huerefs(500, -100000.f),
huerefblurs(500, -100000.f), huerefblurs(500, -100000.f),
@ -796,7 +740,7 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
} }
// Encoding log with locallab // Encoding log with locallab
if (params->locallab.enabled) { if (params->locallab.enabled && !params->locallab.spots.empty()) {
const int sizespot = (int)params->locallab.spots.size(); const int sizespot = (int)params->locallab.spots.size();
float *sourceg = nullptr; float *sourceg = nullptr;
@ -1088,15 +1032,13 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
if ((todo & (M_LUMINANCE + M_COLOR)) || (todo & M_AUTOEXP)) { if ((todo & (M_LUMINANCE + M_COLOR)) || (todo & M_AUTOEXP)) {
nprevl->CopyFrom(oprevl); nprevl->CopyFrom(oprevl);
reserv->CopyFrom(oprevl);
lastorigimp->CopyFrom(oprevl);
// int maxspot = 1; // int maxspot = 1;
//************************************************************* //*************************************************************
// locallab // locallab
//************************************************************* //*************************************************************
if (params->locallab.enabled) { if (params->locallab.enabled && !params->locallab.spots.empty()) {
/* /*
* This file is part of RawTherapee. * This file is part of RawTherapee.
* *
@ -1117,7 +1059,10 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
* 2017 2018 Jacques Desmis <jdesmis@gmail.com> * 2017 2018 Jacques Desmis <jdesmis@gmail.com>
* 2019 Pierre Cabrera <pierre.cab@gmail.com> * 2019 Pierre Cabrera <pierre.cab@gmail.com>
*/ */
const std::unique_ptr<LabImage> reserv(new LabImage(oprevl->W, oprevl->H));
reserv->CopyFrom(oprevl);
const std::unique_ptr<LabImage> lastorigimp(new LabImage(oprevl->W, oprevl->H));
lastorigimp->CopyFrom(oprevl);
float **shbuffer = nullptr; float **shbuffer = nullptr;
int sca = 1; int sca = 1;
double huere, chromare, lumare, huerefblu, chromarefblu, lumarefblu, sobelre; double huere, chromare, lumare, huerefblu, chromarefblu, lumarefblu, sobelre;
@ -1127,117 +1072,62 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
for (int sp = 0; sp < (int)params->locallab.spots.size(); sp++) { for (int sp = 0; sp < (int)params->locallab.spots.size(); sp++) {
// Set local curves of current spot to LUT // Set local curves of current spot to LUT
LHutili = false;
HHutili = false;
locallutili = false;
localclutili = false;
locallcutili = false;
localexutili = false;
localrgbutili = false;
localcutili = false;
llmasutili = false;
lhmasutili = false;
lhhmasutili = false;
lcmasutili = false;
localmaskutili = false;
lcmasexputili = false;
lhmasexputili = false;
llmasexputili = false;
localmaskexputili = false;
localmaskSHutili = false;
localmaskvibutili = false;
localmasktmutili = false;
localmaskretiutili = false;
localmaskcbutili = false;
localmaskblutili = false;
localmasklcutili = false;
lcmasSHutili = false;
lhmasSHutili = false;
llmasSHutili = false;
lcmasvibutili = false;
lhmasvibutili = false;
llmasvibutili = false;
lcmascbutili = false;
lhmascbutili = false;
llmascbutili = false;
lcmaslcutili = false;
lhmaslcutili = false;
llmaslcutili = false;
lcmasretiutili = false;
lhmasretiutili = false;
llmasretiutili = false;
lcmastmutili = false;
lhmastmutili = false;
llmastmutili = false;
lcmasblutili = false;
lhmasblutili = false;
llmasblutili = false;
lcmasutili = false;
locwavutili = false;
locwavdenutili = false;
loclevwavutili = false;
locconwavutili = false;
loccompwavutili = false;
loccomprewavutili = false;
locedgwavutili = false;
lmasutiliblwav = false;
lmasutilicolwav = false;
locRETgainCurve.Set(params->locallab.spots.at(sp).localTgaincurve); locRETgainCurve.Set(params->locallab.spots.at(sp).localTgaincurve);
locRETtransCurve.Set(params->locallab.spots.at(sp).localTtranscurve); locRETtransCurve.Set(params->locallab.spots.at(sp).localTtranscurve);
loclhCurve.Set(params->locallab.spots.at(sp).LHcurve, LHutili); const bool LHutili = loclhCurve.Set(params->locallab.spots.at(sp).LHcurve);
lochhCurve.Set(params->locallab.spots.at(sp).HHcurve, HHutili); const bool HHutili = lochhCurve.Set(params->locallab.spots.at(sp).HHcurve);
locccmasCurve.Set(params->locallab.spots.at(sp).CCmaskcurve, lcmasutili); const bool lcmasutili = locccmasCurve.Set(params->locallab.spots.at(sp).CCmaskcurve);
locllmasCurve.Set(params->locallab.spots.at(sp).LLmaskcurve, llmasutili); const bool llmasutili = locllmasCurve.Set(params->locallab.spots.at(sp).LLmaskcurve);
lochhmasCurve.Set(params->locallab.spots.at(sp).HHmaskcurve, lhmasutili); const bool lhmasutili = lochhmasCurve.Set(params->locallab.spots.at(sp).HHmaskcurve);
lochhhmasCurve.Set(params->locallab.spots.at(sp).HHhmaskcurve, lhhmasutili); const bool lhhmasutili = lochhhmasCurve.Set(params->locallab.spots.at(sp).HHhmaskcurve);
locllmasexpCurve.Set(params->locallab.spots.at(sp).LLmaskexpcurve, llmasexputili); const bool llmasexputili = locllmasexpCurve.Set(params->locallab.spots.at(sp).LLmaskexpcurve);
locccmasexpCurve.Set(params->locallab.spots.at(sp).CCmaskexpcurve, lcmasexputili); const bool lcmasexputili = locccmasexpCurve.Set(params->locallab.spots.at(sp).CCmaskexpcurve);
lochhmasexpCurve.Set(params->locallab.spots.at(sp).HHmaskexpcurve, lhmasexputili); const bool lhmasexputili = lochhmasexpCurve.Set(params->locallab.spots.at(sp).HHmaskexpcurve);
locllmasSHCurve.Set(params->locallab.spots.at(sp).LLmaskSHcurve, llmasSHutili); const bool llmasSHutili = locllmasSHCurve.Set(params->locallab.spots.at(sp).LLmaskSHcurve);
locccmasSHCurve.Set(params->locallab.spots.at(sp).CCmaskSHcurve, lcmasSHutili); const bool lcmasSHutili = locccmasSHCurve.Set(params->locallab.spots.at(sp).CCmaskSHcurve);
lochhmasSHCurve.Set(params->locallab.spots.at(sp).HHmaskSHcurve, lhmasSHutili); const bool lhmasSHutili = lochhmasSHCurve.Set(params->locallab.spots.at(sp).HHmaskSHcurve);
locllmasvibCurve.Set(params->locallab.spots.at(sp).LLmaskvibcurve, llmasvibutili); const bool llmasvibutili = locllmasvibCurve.Set(params->locallab.spots.at(sp).LLmaskvibcurve);
locccmasvibCurve.Set(params->locallab.spots.at(sp).CCmaskvibcurve, lcmasvibutili); const bool lcmasvibutili = locccmasvibCurve.Set(params->locallab.spots.at(sp).CCmaskvibcurve);
lochhmasvibCurve.Set(params->locallab.spots.at(sp).HHmaskvibcurve, lhmasvibutili); const bool lhmasvibutili = lochhmasvibCurve.Set(params->locallab.spots.at(sp).HHmaskvibcurve);
locllmascbCurve.Set(params->locallab.spots.at(sp).LLmaskcbcurve, llmascbutili); const bool llmascbutili = locllmascbCurve.Set(params->locallab.spots.at(sp).LLmaskcbcurve);
locccmascbCurve.Set(params->locallab.spots.at(sp).CCmaskcbcurve, lcmascbutili); const bool lcmascbutili = locccmascbCurve.Set(params->locallab.spots.at(sp).CCmaskcbcurve);
lochhmascbCurve.Set(params->locallab.spots.at(sp).HHmaskcbcurve, lhmascbutili); const bool lhmascbutili = lochhmascbCurve.Set(params->locallab.spots.at(sp).HHmaskcbcurve);
locllmaslcCurve.Set(params->locallab.spots.at(sp).LLmasklccurve, llmaslcutili); const bool llmaslcutili = locllmaslcCurve.Set(params->locallab.spots.at(sp).LLmasklccurve);
locccmaslcCurve.Set(params->locallab.spots.at(sp).CCmasklccurve, lcmaslcutili); const bool lcmaslcutili = locccmaslcCurve.Set(params->locallab.spots.at(sp).CCmasklccurve);
lochhmaslcCurve.Set(params->locallab.spots.at(sp).HHmasklccurve, lhmaslcutili); const bool lhmaslcutili = lochhmaslcCurve.Set(params->locallab.spots.at(sp).HHmasklccurve);
locllmasretiCurve.Set(params->locallab.spots.at(sp).LLmaskreticurve, llmasretiutili); const bool llmasretiutili = locllmasretiCurve.Set(params->locallab.spots.at(sp).LLmaskreticurve);
locccmasretiCurve.Set(params->locallab.spots.at(sp).CCmaskreticurve, lcmasretiutili); const bool lcmasretiutili = locccmasretiCurve.Set(params->locallab.spots.at(sp).CCmaskreticurve);
lochhmasretiCurve.Set(params->locallab.spots.at(sp).HHmaskreticurve, lhmasretiutili); const bool lhmasretiutili = lochhmasretiCurve.Set(params->locallab.spots.at(sp).HHmaskreticurve);
locllmastmCurve.Set(params->locallab.spots.at(sp).LLmasktmcurve, llmastmutili); const bool llmastmutili = locllmastmCurve.Set(params->locallab.spots.at(sp).LLmasktmcurve);
locccmastmCurve.Set(params->locallab.spots.at(sp).CCmasktmcurve, lcmastmutili); const bool lcmastmutili = locccmastmCurve.Set(params->locallab.spots.at(sp).CCmasktmcurve);
lochhmastmCurve.Set(params->locallab.spots.at(sp).HHmasktmcurve, lhmastmutili); const bool lhmastmutili = lochhmastmCurve.Set(params->locallab.spots.at(sp).HHmasktmcurve);
locllmasblCurve.Set(params->locallab.spots.at(sp).LLmaskblcurve, llmasblutili); const bool llmasblutili = locllmasblCurve.Set(params->locallab.spots.at(sp).LLmaskblcurve);
locccmasblCurve.Set(params->locallab.spots.at(sp).CCmaskblcurve, lcmasblutili); const bool lcmasblutili = locccmasblCurve.Set(params->locallab.spots.at(sp).CCmaskblcurve);
lochhmasblCurve.Set(params->locallab.spots.at(sp).HHmaskblcurve, lhmasblutili); const bool lhmasblutili = lochhmasblCurve.Set(params->locallab.spots.at(sp).HHmaskblcurve);
loclmasCurveblwav.Set(params->locallab.spots.at(sp).LLmaskblcurvewav, lmasutiliblwav); const bool lmasutiliblwav = loclmasCurveblwav.Set(params->locallab.spots.at(sp).LLmaskblcurvewav);
loclmasCurvecolwav.Set(params->locallab.spots.at(sp).LLmaskcolcurvewav, lmasutilicolwav); const bool lmasutilicolwav = loclmasCurvecolwav.Set(params->locallab.spots.at(sp).LLmaskcolcurvewav);
locwavCurve.Set(params->locallab.spots.at(sp).locwavcurve, locwavutili); const bool locwavutili = locwavCurve.Set(params->locallab.spots.at(sp).locwavcurve);
loclevwavCurve.Set(params->locallab.spots.at(sp).loclevwavcurve, loclevwavutili); const bool loclevwavutili = loclevwavCurve.Set(params->locallab.spots.at(sp).loclevwavcurve);
locconwavCurve.Set(params->locallab.spots.at(sp).locconwavcurve, locconwavutili); const bool locconwavutili = locconwavCurve.Set(params->locallab.spots.at(sp).locconwavcurve);
loccompwavCurve.Set(params->locallab.spots.at(sp).loccompwavcurve, loccompwavutili); const bool loccompwavutili = loccompwavCurve.Set(params->locallab.spots.at(sp).loccompwavcurve);
loccomprewavCurve.Set(params->locallab.spots.at(sp).loccomprewavcurve, loccomprewavutili); const bool loccomprewavutili = loccomprewavCurve.Set(params->locallab.spots.at(sp).loccomprewavcurve);
locwavCurveden.Set(params->locallab.spots.at(sp).locwavcurveden, locwavdenutili); const bool locwavdenutili = locwavCurveden.Set(params->locallab.spots.at(sp).locwavcurveden);
locedgwavCurve.Set(params->locallab.spots.at(sp).locedgwavcurve, locedgwavutili); const bool locedgwavutili = locedgwavCurve.Set(params->locallab.spots.at(sp).locedgwavcurve);
CurveFactory::curveLocal(locallutili, params->locallab.spots.at(sp).llcurve, lllocalcurve, sca); const bool locallutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).llcurve, lllocalcurve, sca);
CurveFactory::curveLocal(localclutili, params->locallab.spots.at(sp).clcurve, cllocalcurve, sca); const bool localclutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).clcurve, cllocalcurve, sca);
CurveFactory::curveLocal(locallcutili, params->locallab.spots.at(sp).lccurve, lclocalcurve, sca); const bool locallcutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).lccurve, lclocalcurve, sca);
CurveFactory::curveCCLocal(localcutili, params->locallab.spots.at(sp).cccurve, cclocalcurve, sca); const bool localcutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).cccurve, cclocalcurve, sca);
CurveFactory::curveLocal(localrgbutili, params->locallab.spots.at(sp).rgbcurve, rgblocalcurve, sca); const bool localrgbutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).rgbcurve, rgblocalcurve, sca);
CurveFactory::curveexLocal(localexutili, params->locallab.spots.at(sp).excurve, exlocalcurve, sca); const bool localexutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).excurve, exlocalcurve, sca);
CurveFactory::curvemaskLocal(localmaskutili, params->locallab.spots.at(sp).Lmaskcurve, lmasklocalcurve, sca); const bool localmaskutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmaskcurve, lmasklocalcurve, sca);
CurveFactory::curvemaskLocal(localmaskexputili, params->locallab.spots.at(sp).Lmaskexpcurve, lmaskexplocalcurve, sca); const bool localmaskexputili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmaskexpcurve, lmaskexplocalcurve, sca);
CurveFactory::curvemaskLocal(localmaskSHutili, params->locallab.spots.at(sp).LmaskSHcurve, lmaskSHlocalcurve, sca); const bool localmaskSHutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).LmaskSHcurve, lmaskSHlocalcurve, sca);
CurveFactory::curvemaskLocal(localmaskvibutili, params->locallab.spots.at(sp).Lmaskvibcurve, lmaskviblocalcurve, sca); const bool localmaskvibutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmaskvibcurve, lmaskviblocalcurve, sca);
CurveFactory::curvemaskLocal(localmasktmutili, params->locallab.spots.at(sp).Lmasktmcurve, lmasktmlocalcurve, sca); const bool localmasktmutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmasktmcurve, lmasktmlocalcurve, sca);
CurveFactory::curvemaskLocal(localmaskretiutili, params->locallab.spots.at(sp).Lmaskreticurve, lmaskretilocalcurve, sca); const bool localmaskretiutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmaskreticurve, lmaskretilocalcurve, sca);
CurveFactory::curvemaskLocal(localmaskcbutili, params->locallab.spots.at(sp).Lmaskcbcurve, lmaskcblocalcurve, sca); const bool localmaskcbutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmaskcbcurve, lmaskcblocalcurve, sca);
CurveFactory::curvemaskLocal(localmaskblutili, params->locallab.spots.at(sp).Lmaskblcurve, lmaskbllocalcurve, sca); const bool localmaskblutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmaskblcurve, lmaskbllocalcurve, sca);
CurveFactory::curvemaskLocal(localmasklcutili, params->locallab.spots.at(sp).Lmasklccurve, lmasklclocalcurve, sca); const bool localmasklcutili = CurveFactory::curveLocal(params->locallab.spots.at(sp).Lmasklccurve, lmasklclocalcurve, sca);
double ecomp = params->locallab.spots.at(sp).expcomp; double ecomp = params->locallab.spots.at(sp).expcomp;
double black = params->locallab.spots.at(sp).black; double black = params->locallab.spots.at(sp).black;
double hlcompr = params->locallab.spots.at(sp).hlcompr; double hlcompr = params->locallab.spots.at(sp).hlcompr;
@ -1252,7 +1142,7 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
// Reference parameters computation // Reference parameters computation
if (params->locallab.spots.at(sp).spotMethod == "exc") { if (params->locallab.spots.at(sp).spotMethod == "exc") {
ipf.calc_ref(sp, reserv, reserv, 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, avge, locwavCurveden, locwavdenutili); ipf.calc_ref(sp, reserv.get(), reserv.get(), 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, avge, locwavCurveden, locwavdenutili);
} else { } else {
ipf.calc_ref(sp, nprevl, nprevl, 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, avge, locwavCurveden, locwavdenutili); ipf.calc_ref(sp, nprevl, nprevl, 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, avge, locwavCurveden, locwavdenutili);
} }
@ -1289,7 +1179,7 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
float Tsigma; float Tsigma;
float Tmin; float Tmin;
float Tmax; float Tmax;
ipf.Lab_Local(3, sp, (float**)shbuffer, nprevl, nprevl, reserv, lastorigimp, 0, 0, pW, pH, scale, locRETgainCurve, locRETtransCurve, ipf.Lab_Local(3, sp, (float**)shbuffer, nprevl, nprevl, reserv.get(), lastorigimp.get(), 0, 0, pW, pH, scale, locRETgainCurve, locRETtransCurve,
lllocalcurve, locallutili, lllocalcurve, locallutili,
cllocalcurve, localclutili, cllocalcurve, localclutili,
lclocalcurve, locallcutili, lclocalcurve, locallcutili,
@ -1340,7 +1230,7 @@ void ImProcCoordinator::updatePreviewImage(int todo, bool panningRelatedChange)
// Recalculate references after // Recalculate references after
if (params->locallab.spots.at(sp).spotMethod == "exc") { if (params->locallab.spots.at(sp).spotMethod == "exc") {
ipf.calc_ref(sp, reserv, reserv, 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huer, chromar, lumar, sobeler, avg, locwavCurveden, locwavdenutili); ipf.calc_ref(sp, reserv.get(), reserv.get(), 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huer, chromar, lumar, sobeler, avg, locwavCurveden, locwavdenutili);
} else { } else {
ipf.calc_ref(sp, nprevl, nprevl, 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huer, chromar, lumar, sobeler, avg, locwavCurveden, locwavdenutili); ipf.calc_ref(sp, nprevl, nprevl, 0, 0, pW, pH, scale, huerefblu, chromarefblu, lumarefblu, huer, chromar, lumar, sobeler, avg, locwavCurveden, locwavdenutili);
} }
@ -1848,10 +1738,6 @@ void ImProcCoordinator::freeAll()
oprevl = nullptr; oprevl = nullptr;
delete nprevl; delete nprevl;
nprevl = nullptr; nprevl = nullptr;
delete reserv;
reserv = nullptr;
delete lastorigimp;
lastorigimp = nullptr;
if (ncie) { if (ncie) {
delete ncie; delete ncie;
@ -1905,10 +1791,7 @@ void ImProcCoordinator::setScale(int prevscale)
oprevi = orig_prev; oprevi = orig_prev;
oprevl = new LabImage(pW, pH); oprevl = new LabImage(pW, pH);
nprevl = new LabImage(pW, pH); nprevl = new LabImage(pW, pH);
reserv = new LabImage(pW, pH);
lastorigimp = new LabImage(pW, pH);
// nprevloc = new LabImage (pW, pH);
//ncie is only used in ImProcCoordinator::updatePreviewImage, it will be allocated on first use and deleted if not used anymore //ncie is only used in ImProcCoordinator::updatePreviewImage, it will be allocated on first use and deleted if not used anymore
previmg = new Image8(pW, pH); previmg = new Image8(pW, pH);
workimg = new Image8(pW, pH); workimg = new Image8(pW, pH);

56
rtengine/improccoordinator.h
View File

@ -235,8 +235,6 @@ protected:
//locallab //locallab
LocallabListener* locallListener; LocallabListener* locallListener;
LabImage *reserv;
LabImage *lastorigimp;
int coordX, coordY, localX, localY; int coordX, coordY, localX, localY;
LUTf lllocalcurve; LUTf lllocalcurve;
LUTf cllocalcurve; LUTf cllocalcurve;
@ -301,60 +299,6 @@ protected:
LocwavCurve locwavCurveden; LocwavCurve locwavCurveden;
LocwavCurve locedgwavCurve; LocwavCurve locedgwavCurve;
bool locallutili;
bool localclutili;
bool locallcutili;
bool localcutili;
bool localrgbutili;
bool localexutili;
bool llmasutili;
bool lhmasutili;
bool lhhmasutili;
bool lcmasutili;
bool localmaskutili;
bool localmaskexputili;
bool localmaskSHutili;
bool localmaskvibutili;
bool localmasktmutili;
bool localmaskretiutili;
bool localmaskcbutili;
bool localmaskblutili;
bool localmasklcutili;
bool lcmasexputili;
bool lhmasexputili;
bool llmasexputili;
bool lcmasSHutili;
bool lhmasSHutili;
bool llmasSHutili;
bool lcmasvibutili;
bool lhmasvibutili;
bool llmasvibutili;
bool lcmaslcutili;
bool lhmaslcutili;
bool llmaslcutili;
bool lcmascbutili;
bool lhmascbutili;
bool llmascbutili;
bool lcmasretiutili;
bool lhmasretiutili;
bool llmasretiutili;
bool lcmastmutili;
bool lhmastmutili;
bool llmastmutili;
bool lcmasblutili;
bool lhmasblutili;
bool llmasblutili;
bool locwavutili;
bool locwavdenutili;
bool loclevwavutili;
bool locconwavutili;
bool loccompwavutili;
bool loccomprewavutili;
bool locedgwavutili;
bool lmasutiliblwav;
bool lmasutilicolwav;
bool LHutili;
bool HHutili;
LUTu lastsavrests; LUTu lastsavrests;
LUTf huerefs; LUTf huerefs;
LUTf huerefblurs; LUTf huerefblurs;

188
rtengine/simpleprocess.cc
View File

@ -1078,7 +1078,7 @@ private:
params.labCurve.lccurve, curve1, curve2, satcurve, lhskcurve, 1); params.labCurve.lccurve, curve1, curve2, satcurve, lhskcurve, 1);
if (params.locallab.enabled) { if (params.locallab.enabled && params.locallab.spots.size() > 0) {
MyTime t1, t2; MyTime t1, t2;
t1.set(); t1.set();
const std::unique_ptr<LabImage> reservView(new LabImage(fw, fh)); const std::unique_ptr<LabImage> reservView(new LabImage(fw, fh));
@ -1150,127 +1150,74 @@ private:
LUTf lmaskbllocalcurve(65536, 0); LUTf lmaskbllocalcurve(65536, 0);
LUTf lmasklclocalcurve(65536, 0); LUTf lmasklclocalcurve(65536, 0);
// int maxspot = 1; bool needsShBuffer = false;
float** shbuffer = nullptr;
for (size_t sp = 0; sp < params.locallab.spots.size(); sp++) { for (size_t sp = 0; sp < params.locallab.spots.size(); sp++) {
if (params.locallab.spots.at(sp).inverssha) { if (params.locallab.spots.at(sp).inverssha) {
shbuffer = new float*[fh]; needsShBuffer = true;
break;
for (int i = 0; i < fh; i++) {
shbuffer[i] = new float[fw];
}
} }
}
std::unique_ptr<array2D<float>> shbuffer(needsShBuffer ? new array2D<float>(fw, fh) : nullptr);
for (size_t sp = 0; sp < params.locallab.spots.size(); sp++) {
// Set local curves of current spot to LUT // Set local curves of current spot to LUT
bool LHutili = false;
bool HHutili = false;
bool locallutili = false;
bool localclutili = false;
bool locallcutili = false;
bool localcutili = false;
bool localrgbutili = false;
bool localexutili = false;
bool llmasutili = false;
bool lhmasutili = false;
bool lhhmasutili = false;
bool lcmasutili = false;
bool localmaskutili = false;
bool localmaskexputili = false;
bool localmaskSHutili = false;
bool localmaskvibutili = false;
bool localmasktmutili = false;
bool localmaskretiutili = false;
bool localmaskcbutili = false;
bool localmaskblutili = false;
bool localmasklcutili = false;
bool lcmasexputili = false;
bool lhmasexputili = false;
bool llmasexputili = false;
bool lcmasSHutili = false;
bool lhmasSHutili = false;
bool llmasSHutili = false;
bool lcmasvibutili = false;
bool lhmasvibutili = false;
bool llmasvibutili = false;
bool lcmaslcutili = false; bool lcmaslcutili = false;
bool lhmaslcutili = false;
bool llmaslcutili = false; bool llmaslcutili = false;
bool lcmascbutili = false;
bool lhmascbutili = false;
bool llmascbutili = false;
bool lcmasretiutili = false;
bool lhmasretiutili = false;
bool llmasretiutili = false;
bool lcmastmutili = false;
bool lhmastmutili = false;
bool llmastmutili = false;
bool lcmasblutili = false;
bool lhmasblutili = false;
bool llmasblutili = false;
bool locwavutili = false;
bool locwavdenutili = false;
bool loclevwavutili = false;
bool locconwavutili = false;
bool loccompwavutili = false;
bool loccomprewavutili = false;
bool locedgwavutili = false;
bool lmasutiliblwav = false;
bool lmasutilicolwav = false;
locRETgainCurve.Set(params.locallab.spots.at(sp).localTgaincurve); locRETgainCurve.Set(params.locallab.spots.at(sp).localTgaincurve);
locRETtransCurve.Set(params.locallab.spots.at(sp).localTtranscurve); locRETtransCurve.Set(params.locallab.spots.at(sp).localTtranscurve);
loclhCurve.Set(params.locallab.spots.at(sp).LHcurve, LHutili); const bool LHutili = loclhCurve.Set(params.locallab.spots.at(sp).LHcurve);
lochhCurve.Set(params.locallab.spots.at(sp).HHcurve, HHutili); const bool HHutili = lochhCurve.Set(params.locallab.spots.at(sp).HHcurve);
locccmasCurve.Set(params.locallab.spots.at(sp).CCmaskcurve, lcmasutili); const bool lcmasutili = locccmasCurve.Set(params.locallab.spots.at(sp).CCmaskcurve);
locllmasCurve.Set(params.locallab.spots.at(sp).LLmaskcurve, llmasutili); const bool llmasutili = locllmasCurve.Set(params.locallab.spots.at(sp).LLmaskcurve);
lochhmasCurve.Set(params.locallab.spots.at(sp).HHmaskcurve, lhmasutili); const bool lhmasutili = lochhmasCurve.Set(params.locallab.spots.at(sp).HHmaskcurve);
lochhhmasCurve.Set(params.locallab.spots.at(sp).HHhmaskcurve, lhhmasutili); const bool lhhmasutili = lochhhmasCurve.Set(params.locallab.spots.at(sp).HHhmaskcurve);
locccmasexpCurve.Set(params.locallab.spots.at(sp).CCmaskexpcurve, lcmasexputili); const bool lcmasexputili = locccmasexpCurve.Set(params.locallab.spots.at(sp).CCmaskexpcurve);
locllmasexpCurve.Set(params.locallab.spots.at(sp).LLmaskexpcurve, llmasexputili); const bool llmasexputili = locllmasexpCurve.Set(params.locallab.spots.at(sp).LLmaskexpcurve);
lochhmasexpCurve.Set(params.locallab.spots.at(sp).HHmaskexpcurve, lhmasexputili); const bool lhmasexputili = lochhmasexpCurve.Set(params.locallab.spots.at(sp).HHmaskexpcurve);
locccmasSHCurve.Set(params.locallab.spots.at(sp).CCmaskSHcurve, lcmasSHutili); const bool lcmasSHutili = locccmasSHCurve.Set(params.locallab.spots.at(sp).CCmaskSHcurve);
locllmasSHCurve.Set(params.locallab.spots.at(sp).LLmaskSHcurve, llmasSHutili); const bool llmasSHutili = locllmasSHCurve.Set(params.locallab.spots.at(sp).LLmaskSHcurve);
lochhmasSHCurve.Set(params.locallab.spots.at(sp).HHmaskSHcurve, lhmasSHutili); const bool lhmasSHutili = lochhmasSHCurve.Set(params.locallab.spots.at(sp).HHmaskSHcurve);
locccmasvibCurve.Set(params.locallab.spots.at(sp).CCmaskvibcurve, lcmasvibutili); const bool lcmasvibutili = locccmasvibCurve.Set(params.locallab.spots.at(sp).CCmaskvibcurve);
locllmasvibCurve.Set(params.locallab.spots.at(sp).LLmaskvibcurve, llmasvibutili); const bool llmasvibutili = locllmasvibCurve.Set(params.locallab.spots.at(sp).LLmaskvibcurve);
lochhmasvibCurve.Set(params.locallab.spots.at(sp).HHmaskvibcurve, lhmasvibutili); const bool lhmasvibutili = lochhmasvibCurve.Set(params.locallab.spots.at(sp).HHmaskvibcurve);
locccmascbCurve.Set(params.locallab.spots.at(sp).CCmaskcbcurve, lcmascbutili); const bool lcmascbutili = locccmascbCurve.Set(params.locallab.spots.at(sp).CCmaskcbcurve);
locllmascbCurve.Set(params.locallab.spots.at(sp).LLmaskcbcurve, llmascbutili); const bool llmascbutili = locllmascbCurve.Set(params.locallab.spots.at(sp).LLmaskcbcurve);
lochhmascbCurve.Set(params.locallab.spots.at(sp).HHmaskcbcurve, lhmascbutili); const bool lhmascbutili = lochhmascbCurve.Set(params.locallab.spots.at(sp).HHmaskcbcurve);
locccmasretiCurve.Set(params.locallab.spots.at(sp).CCmaskreticurve, lcmasretiutili); const bool lcmasretiutili = locccmasretiCurve.Set(params.locallab.spots.at(sp).CCmaskreticurve);
locllmasretiCurve.Set(params.locallab.spots.at(sp).LLmaskreticurve, llmasretiutili); const bool llmasretiutili = locllmasretiCurve.Set(params.locallab.spots.at(sp).LLmaskreticurve);
lochhmasretiCurve.Set(params.locallab.spots.at(sp).HHmaskreticurve, lhmasretiutili); const bool lhmasretiutili = lochhmasretiCurve.Set(params.locallab.spots.at(sp).HHmaskreticurve);
locccmastmCurve.Set(params.locallab.spots.at(sp).CCmasktmcurve, lcmastmutili); const bool lcmastmutili = locccmastmCurve.Set(params.locallab.spots.at(sp).CCmasktmcurve);
locllmastmCurve.Set(params.locallab.spots.at(sp).LLmasktmcurve, llmastmutili); const bool lhmaslcutili = lochhmaslcCurve.Set(params.locallab.spots.at(sp).HHmasklccurve);
lochhmastmCurve.Set(params.locallab.spots.at(sp).HHmasktmcurve, lhmastmutili); const bool llmastmutili = locllmastmCurve.Set(params.locallab.spots.at(sp).LLmasktmcurve);
locccmasblCurve.Set(params.locallab.spots.at(sp).CCmaskblcurve, lcmasblutili); const bool lhmastmutili = lochhmastmCurve.Set(params.locallab.spots.at(sp).HHmasktmcurve);
locllmasblCurve.Set(params.locallab.spots.at(sp).LLmaskblcurve, llmasblutili); const bool lcmasblutili = locccmasblCurve.Set(params.locallab.spots.at(sp).CCmaskblcurve);
lochhmasblCurve.Set(params.locallab.spots.at(sp).HHmaskblcurve, lhmasblutili); const bool llmasblutili = locllmasblCurve.Set(params.locallab.spots.at(sp).LLmaskblcurve);
loclmasCurveblwav.Set(params.locallab.spots.at(sp).LLmaskblcurvewav, lmasutiliblwav); const bool lhmasblutili = lochhmasblCurve.Set(params.locallab.spots.at(sp).HHmaskblcurve);
loclmasCurvecolwav.Set(params.locallab.spots.at(sp).LLmaskcolcurvewav, lmasutilicolwav); const bool lmasutiliblwav = loclmasCurveblwav.Set(params.locallab.spots.at(sp).LLmaskblcurvewav);
const bool lmasutilicolwav = loclmasCurvecolwav.Set(params.locallab.spots.at(sp).LLmaskcolcurvewav);
locwavCurve.Set(params.locallab.spots.at(sp).locwavcurve, locwavutili); const bool locwavutili = locwavCurve.Set(params.locallab.spots.at(sp).locwavcurve);
locwavCurveden.Set(params.locallab.spots.at(sp).locwavcurveden, locwavdenutili); const bool locwavdenutili = locwavCurveden.Set(params.locallab.spots.at(sp).locwavcurveden);
loclevwavCurve.Set(params.locallab.spots.at(sp).loclevwavcurve, loclevwavutili); const bool loclevwavutili = loclevwavCurve.Set(params.locallab.spots.at(sp).loclevwavcurve);
locconwavCurve.Set(params.locallab.spots.at(sp).locconwavcurve, locconwavutili); const bool locconwavutili = locconwavCurve.Set(params.locallab.spots.at(sp).locconwavcurve);
loccompwavCurve.Set(params.locallab.spots.at(sp).loccompwavcurve, loccompwavutili); const bool loccompwavutili = loccompwavCurve.Set(params.locallab.spots.at(sp).loccompwavcurve);
loccomprewavCurve.Set(params.locallab.spots.at(sp).loccomprewavcurve, loccomprewavutili); const bool loccomprewavutili = loccomprewavCurve.Set(params.locallab.spots.at(sp).loccomprewavcurve);
locedgwavCurve.Set(params.locallab.spots.at(sp).locedgwavcurve, locedgwavutili); const bool locedgwavutili = locedgwavCurve.Set(params.locallab.spots.at(sp).locedgwavcurve);
CurveFactory::curveLocal(locallutili, params.locallab.spots.at(sp).llcurve, lllocalcurve, 1); const bool locallutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).llcurve, lllocalcurve, 1);
CurveFactory::curveLocal(localclutili, params.locallab.spots.at(sp).clcurve, cllocalcurve, 1); const bool localclutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).clcurve, cllocalcurve, 1);
CurveFactory::curveLocal(locallcutili, params.locallab.spots.at(sp).lccurve, lclocalcurve, 1); const bool locallcutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).lccurve, lclocalcurve, 1);
CurveFactory::curveCCLocal(localcutili, params.locallab.spots.at(sp).cccurve, cclocalcurve, 1); const bool localcutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).cccurve, cclocalcurve, 1);
CurveFactory::curveLocal(localrgbutili, params.locallab.spots.at(sp).rgbcurve, rgblocalcurve, 1); const bool localrgbutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).rgbcurve, rgblocalcurve, 1);
CurveFactory::curveexLocal(localexutili, params.locallab.spots.at(sp).excurve, exlocalcurve, 1); const bool localexutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).excurve, exlocalcurve, 1);
CurveFactory::curvemaskLocal(localmaskutili, params.locallab.spots.at(sp).Lmaskcurve, lmasklocalcurve, 1); const bool localmaskutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskcurve, lmasklocalcurve, 1);
CurveFactory::curvemaskLocal(localmaskexputili, params.locallab.spots.at(sp).Lmaskexpcurve, lmaskexplocalcurve, 1); const bool localmaskexputili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskexpcurve, lmaskexplocalcurve, 1);
CurveFactory::curvemaskLocal(localmaskSHutili, params.locallab.spots.at(sp).LmaskSHcurve, lmaskSHlocalcurve, 1); const bool localmaskSHutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).LmaskSHcurve, lmaskSHlocalcurve, 1);
CurveFactory::curvemaskLocal(localmaskvibutili, params.locallab.spots.at(sp).Lmaskvibcurve, lmaskviblocalcurve, 1); const bool localmaskvibutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskvibcurve, lmaskviblocalcurve, 1);
CurveFactory::curvemaskLocal(localmasktmutili, params.locallab.spots.at(sp).Lmasktmcurve, lmasktmlocalcurve, 1); const bool localmasktmutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmasktmcurve, lmasktmlocalcurve, 1);
CurveFactory::curvemaskLocal(localmaskretiutili, params.locallab.spots.at(sp).Lmaskreticurve, lmaskretilocalcurve, 1); const bool localmaskretiutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskreticurve, lmaskretilocalcurve, 1);
CurveFactory::curvemaskLocal(localmaskcbutili, params.locallab.spots.at(sp).Lmaskcbcurve, lmaskcblocalcurve, 1); const bool localmaskcbutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskcbcurve, lmaskcblocalcurve, 1);
CurveFactory::curvemaskLocal(localmaskblutili, params.locallab.spots.at(sp).Lmaskblcurve, lmaskbllocalcurve, 1); const bool localmaskblutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmaskblcurve, lmaskbllocalcurve, 1);
CurveFactory::curvemaskLocal(localmasklcutili, params.locallab.spots.at(sp).Lmasklccurve, lmasklclocalcurve, 1); const bool localmasklcutili = CurveFactory::curveLocal(params.locallab.spots.at(sp).Lmasklccurve, lmasklclocalcurve, 1);
//provisory //provisory
double ecomp = params.locallab.spots.at(sp).expcomp; double ecomp = params.locallab.spots.at(sp).expcomp;
double black = params.locallab.spots.at(sp).black; double black = params.locallab.spots.at(sp).black;
@ -1305,7 +1252,7 @@ private:
float Tmax; float Tmax;
// No Locallab mask is shown in exported picture // No Locallab mask is shown in exported picture
ipf.Lab_Local(2, sp, (float**)shbuffer, labView, labView, reservView.get(), lastorigView.get(), 0, 0, fw, fh, 1, locRETgainCurve, locRETtransCurve, ipf.Lab_Local(2, sp, *shbuffer.get(), labView, labView, reservView.get(), lastorigView.get(), 0, 0, fw, fh, 1, locRETgainCurve, locRETtransCurve,
lllocalcurve, locallutili, lllocalcurve, locallutili,
cllocalcurve, localclutili, cllocalcurve, localclutili,
lclocalcurve, locallcutili, lclocalcurve, locallcutili,
@ -1340,7 +1287,10 @@ private:
huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, lastsav, false, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, lastsav, false, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax); minCD, maxCD, mini, maxi, Tmean, Tsigma, Tmin, Tmax);
lastorigView->CopyFrom(labView); if (sp + 1u < params.locallab.spots.size()) {
// do not copy for last spot as it is not needed anymore
lastorigView->CopyFrom(labView);
}
if (params.locallab.spots.at(sp).spotMethod == "exc") { if (params.locallab.spots.at(sp).spotMethod == "exc") {
ipf.calc_ref(sp, reservView.get(), reservView.get(), 0, 0, fw, fh, 1, huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, avge, locwavCurveden, locwavdenutili); ipf.calc_ref(sp, reservView.get(), reservView.get(), 0, 0, fw, fh, 1, huerefblu, chromarefblu, lumarefblu, huere, chromare, lumare, sobelre, avge, locwavCurveden, locwavdenutili);
@ -1367,16 +1317,6 @@ private:
shtonecurveloc.clear(); shtonecurveloc.clear();
tonecurveloc.clear(); tonecurveloc.clear();
lightCurveloc.clear(); lightCurveloc.clear();
if (params.locallab.spots.at(sp).inverssha) {
for (int i = 0; i < fh; i++) {
delete [] shbuffer[i];
}
delete [] shbuffer;
}
} }
t2.set(); t2.set();