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

Merge pull request #5197 from Beep6581/relax-procparam-dependency

Browse Source 
Relax dependency from `procparams.h`
This commit is contained in:
Floessie 2019-03-11 15:14:00 +01:00 committed by GitHub
commit 17bec0a2e5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
146 changed files with 1750 additions and 1344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CONTRIBUTING.md
View File

@ -17,6 +17,7 @@ The most useful feedback is based on the latest development code, and in the cas
- Work in a new branch. Fork if necessary.
- Keep branches small so that completed and working features can be merged into the "dev" branch often, and so that they can be abandoned if they head in the wrong direction.
- Use C++11.
- To break header dependencies use forward declarations as much as possible. See [#5197](https://github.com/Beep6581/RawTherapee/pull/5197#issuecomment-468938190) for some tips.
- The naming isn't homogeneous throughout the code but here is a rough guideline:
- *Identifiers* (variables, functions, methods, keys, enums, etc.) should be clear and unambiguous. Make them as long as necessary to ensure that your code is understandable to others.
- *Types* (classes, structs, enums, typedefs...) should be named with `UpperCamelCase`.

1
rtengine/FTblockDN.cc
View File

@ -38,6 +38,7 @@
#include "cplx_wavelet_dec.h"
#include "median.h"
#include "iccstore.h"
#include "procparams.h"
#ifdef _OPENMP
#include <omp.h>
#endif

1
rtengine/PF_correct_RT.cc
View File

@ -36,6 +36,7 @@
#include "median.h"
#include "jaggedarray.h"
#include "StopWatch.h"
#include "procparams.h"
namespace rtengine
{

3
rtengine/ahd_demosaic_RT.cc
View File

@ -27,6 +27,7 @@
#include "rtengine.h"
#include "rawimagesource.h"
#include "rt_math.h"
#include "procparams.h"
#include "../rtgui/multilangmgr.h"
#include "median.h"
//#define BENCHMARK
@ -223,4 +224,4 @@ void RawImageSource::ahd_demosaic()
}
#undef TS
}
}

1
rtengine/amaze_demosaic_RT.cc
View File

@ -33,6 +33,7 @@
#include "sleef.c"
#include "opthelper.h"
#include "median.h"
#include "procparams.h"
#include "StopWatch.h"
namespace rtengine

1
rtengine/clutstore.cc
View File

@ -5,6 +5,7 @@
#include "iccstore.h"
#include "imagefloat.h"
#include "opthelper.h"
#include "procparams.h"
#include "rt_math.h"
#include "stdimagesource.h"

1
rtengine/curves.h
View File

@ -30,7 +30,6 @@
#include "../rtgui/myflatcurve.h"
#include "../rtgui/mydiagonalcurve.h"
#include "color.h"
#include "procparams.h"
#include "pipettebuffer.h"
#include "LUT.h"

2
rtengine/dcp.h
View File

@ -48,7 +48,7 @@ public:
private:
struct Data;
std::unique_ptr<Data> data;
const std::unique_ptr<Data> data;
friend class DCPProfile;
};

9
rtengine/dcrop.cc
View File

@ -17,9 +17,10 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "dcrop.h"
#include "curves.h"
#include "dcrop.h"
#include "mytime.h"
#include "procparams.h"
#include "refreshmap.h"
#include "rt_math.h"
@ -131,7 +132,7 @@ void Crop::update(int todo)
{
MyMutex::MyLock cropLock(cropMutex);
ProcParams& params = parent->params;
ProcParams& params = *parent->params;
// CropGUIListener* cropgl;
// No need to update todo here, since it has already been changed in ImprocCoordinator::updatePreviewImage,
@ -1116,7 +1117,7 @@ void Crop::freeAll()
namespace
{
bool check_need_larger_crop_for_lcp_distortion(int fw, int fh, int x, int y, int w, int h, const ProcParams &params)
bool check_need_larger_crop_for_lcp_distortion(int fw, int fh, int x, int y, int w, int h, const procparams::ProcParams &params)
{
if (x == 0 && y == 0 && w == fw && h == fh) {
return false;
@ -1177,7 +1178,7 @@ bool Crop::setCropSizes(int rcx, int rcy, int rcw, int rch, int skip, bool inter
parent->ipf.transCoord(parent->fw, parent->fh, bx1, by1, bw, bh, orx, ory, orw, orh);
if (check_need_larger_crop_for_lcp_distortion(parent->fw, parent->fh, orx, ory, orw, orh, parent->params)) {
if (check_need_larger_crop_for_lcp_distortion(parent->fw, parent->fh, orx, ory, orw, orh, *parent->params)) {
// TODO - this is an estimate of the max distortion relative to the image size. ATM it is hardcoded to be 15%, which seems enough. If not, need to revise
int dW = int (double (parent->fw) * 0.15 / (2 * skip));
int dH = int (double (parent->fh) * 0.15 / (2 * skip));

1
rtengine/dual_demosaic_RT.cc
View File

@ -27,6 +27,7 @@
#include "rtengine.h"
#include "rawimagesource.h"
#include "rt_math.h"
#include "procparams.h"
//#define BENCHMARK
#include "StopWatch.h"
#include "rt_algo.h"

2
rtengine/gamutwarning.h
View File

@ -31,6 +31,8 @@
namespace rtengine {
enum RenderingIntent : int;
class GamutWarning: public NonCopyable {
public:
GamutWarning(cmsHPROFILE iprof, cmsHPROFILE gamutprof, RenderingIntent intent, bool bpc);

11
rtengine/histmatching.cc
View File

@ -24,6 +24,7 @@
#include "color.h"
#include "rt_math.h"
#include "iccstore.h"
#include "procparams.h"
#include "../rtgui/mydiagonalcurve.h"
#include "improcfun.h"
//#define BENCHMARK
@ -248,7 +249,7 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
&& a.dcpIlluminant == b.dcpIlluminant);
};
if (!histMatchingCache.empty() && same_profile(histMatchingParams, cp)) {
if (!histMatchingCache.empty() && same_profile(*histMatchingParams, cp)) {
if (settings->verbose) {
std::cout << "tone curve found in cache" << std::endl;
}
@ -286,14 +287,14 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
std::cout << "histogram matching: no thumbnail found, generating a neutral curve" << std::endl;
}
histMatchingCache = outCurve;
histMatchingParams = cp;
*histMatchingParams = cp;
return;
} else if (w * 10 < fw) {
if (settings->verbose) {
std::cout << "histogram matching: the embedded thumbnail is too small: " << w << "x" << h << std::endl;
}
histMatchingCache = outCurve;
histMatchingParams = cp;
*histMatchingParams = cp;
return;
}
skip = LIM(skip * fh / h, 6, 10); // adjust the skip factor -- the larger the thumbnail, the less we should skip to get a good match
@ -316,7 +317,7 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
std::cout << "histogram matching: raw decoding failed, generating a neutral curve" << std::endl;
}
histMatchingCache = outCurve;
histMatchingParams = cp;
*histMatchingParams = cp;
return;
}
target.reset(thumb->processImage(neutral, sensor_type, fh / skip, TI_Nearest, getMetaData(), scale, false, true));
@ -388,7 +389,7 @@ void RawImageSource::getAutoMatchedToneCurve(const ColorManagementParams &cp, st
}
histMatchingCache = outCurve;
histMatchingParams = cp;
*histMatchingParams = cp;
}
} // namespace rtengine

1
rtengine/hphd_demosaic_RT.cc
View File

@ -23,6 +23,7 @@
#include "jaggedarray.h"
#include "rawimage.h"
#include "rt_math.h"
#include "procparams.h"
#include "../rtgui/multilangmgr.h"
#include "opthelper.h"
//#define BENCHMARK

1
rtengine/iccstore.cc
View File

@ -32,7 +32,6 @@
#include "iccstore.h"
#include "iccmatrices.h"
#include "procparams.h"
#include "../rtgui/options.h"
#include "../rtgui/threadutils.h"

1
rtengine/iimage.cc
View File

@ -17,6 +17,7 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "procparams.h"
#include "rtengine.h"
const char rtengine::sImage8[] = "Image8";

16
rtengine/iimage.h
View File

@ -26,7 +26,6 @@
#include "imagedimensions.h"
#include "LUT.h"
#include "coord2d.h"
#include "procparams.h"
#include "color.h"
#include "../rtgui/threadutils.h"
@ -43,12 +42,21 @@
namespace rtengine
{
namespace procparams
{
struct CoarseTransformParams;
}
class ProgressListener;
class Color;
extern const char sImage8[];
extern const char sImage16[];
extern const char sImagefloat[];
int getCoarseBitMask( const procparams::CoarseTransformParams &coarse);
class ProgressListener;
class Color;
int getCoarseBitMask(const procparams::CoarseTransformParams& coarse);
enum TypeInterpolation { TI_Nearest, TI_Bilinear };

2
rtengine/imagedata.cc
View File

@ -25,6 +25,8 @@
#include "iptcpairs.h"
#include "imagesource.h"
#include "rt_math.h"
#include "procparams.h"
#pragma GCC diagnostic warning "-Wextra"
#define PRINT_HDR_PS_DETECTION 0

1
rtengine/imagedata.h
View File

@ -25,7 +25,6 @@
#include <string>
#include <glibmm.h>
#include "../rtexif/rtexif.h"
#include "procparams.h"
#include <libiptcdata/iptc-data.h>
#include "rtengine.h"

1
rtengine/imagefloat.cc
View File

@ -27,6 +27,7 @@
#include "alignedbuffer.h"
#include "rt_math.h"
#include "color.h"
#include "procparams.h"
using namespace rtengine;

27
rtengine/imageio.cc
View File

@ -26,6 +26,7 @@
#include <fcntl.h>
#include <libiptcdata/iptc-jpeg.h>
#include "rt_math.h"
#include "procparams.h"
#include "../rtgui/options.h"
#include "../rtgui/version.h"
@ -103,8 +104,8 @@ void ImageIO::setMetadata (const rtexif::TagDirectory* eroot, const rtengine::pr
{
// store exif info
exifChange.clear();
exifChange = exif;
exifChange->clear();
*exifChange = exif;
if (exifRoot != nullptr) {
delete exifRoot;
@ -185,6 +186,22 @@ void ImageIO::setOutputProfile (const char* pdata, int plen)
profileLength = plen;
}
ImageIO::ImageIO() :
pl(nullptr),
embProfile(nullptr),
profileData(nullptr),
profileLength(0),
loadedProfileData(nullptr),
loadedProfileDataJpg(false),
loadedProfileLength(0),
exifChange(new procparams::ExifPairs),
iptc(nullptr),
exifRoot(nullptr),
sampleFormat(IIOSF_UNKNOWN),
sampleArrangement(IIOSA_UNKNOWN)
{
}
ImageIO::~ImageIO ()
{
@ -1055,7 +1072,7 @@ int ImageIO::savePNG (const Glib::ustring &fname, int bps) const
iptcdata = nullptr;
}
int size = rtexif::ExifManager::createPNGMarker(exifRoot, exifChange, width, height, bps, (char*)iptcdata, iptclen, buffer, bufferSize);
int size = rtexif::ExifManager::createPNGMarker(exifRoot, *exifChange, width, height, bps, (char*)iptcdata, iptclen, buffer, bufferSize);
if (iptcdata) {
iptc_data_free_buf (iptc, iptcdata);
@ -1205,7 +1222,7 @@ int ImageIO::saveJPEG (const Glib::ustring &fname, int quality, int subSamp) con
// assemble and write exif marker
if (exifRoot) {
int size = rtexif::ExifManager::createJPEGMarker (exifRoot, exifChange, cinfo.image_width, cinfo.image_height, buffer);
int size = rtexif::ExifManager::createJPEGMarker (exifRoot, *exifChange, cinfo.image_width, cinfo.image_height, buffer);
if (size > 0 && size < 65530) {
jpeg_write_marker(&cinfo, JPEG_APP0 + 1, buffer, size);
@ -1361,7 +1378,7 @@ int ImageIO::saveTIFF (const Glib::ustring &fname, int bps, bool isFloat, bool u
// ------------------ Apply list of change -----------------
for (auto currExifChange : exifChange) {
for (auto currExifChange : *exifChange) {
cl->applyChange (currExifChange.first, currExifChange.second);
}

12
rtengine/imageio.h
View File

@ -28,11 +28,12 @@
#define IMIO_FILETYPENOTSUPPORTED 6
#define IMIO_CANNOTWRITEFILE 7
#include <memory>
#include <glibmm.h>
#include <libiptcdata/iptc-data.h>
#include "rtengine.h"
#include "imageformat.h"
#include "procparams.h"
#include "../rtexif/rtexif.h"
#include "imagedimensions.h"
#include "iimage.h"
@ -55,7 +56,7 @@ protected:
char* loadedProfileData;
bool loadedProfileDataJpg;
int loadedProfileLength;
procparams::ExifPairs exifChange;
const std::unique_ptr<procparams::ExifPairs> exifChange;
IptcData* iptc;
const rtexif::TagDirectory* exifRoot;
MyMutex imutex;
@ -68,11 +69,8 @@ private:
public:
static Glib::ustring errorMsg[6];
ImageIO () : pl (nullptr), embProfile(nullptr), profileData(nullptr), profileLength(0), loadedProfileData(nullptr), loadedProfileDataJpg(false),
loadedProfileLength(0), iptc(nullptr), exifRoot (nullptr), sampleFormat(IIOSF_UNKNOWN),
sampleArrangement(IIOSA_UNKNOWN) {}
~ImageIO () override;
ImageIO();
~ImageIO() override;
void setProgressListener (ProgressListener* l);
void setSampleFormat(IIOSampleFormat sFormat);

31
rtengine/imagesource.h
View File

@ -23,7 +23,6 @@
#include <vector>
#include "rtengine.h"
#include "colortemp.h"
#include "procparams.h"
#include "coord2d.h"
#include "dcp.h"
#include "LUT.h"
@ -35,7 +34,17 @@
namespace rtengine
{
using namespace procparams;
namespace procparams
{
struct CoarseTransformParams;
struct ColorManagementParams;
struct LensProfParams;
struct RAWParams;
struct RetinexParams;
struct ToneCurveParams;
}
class ImageMatrices
{
@ -67,14 +76,14 @@ public:
~ImageSource () override {}
virtual int load (const Glib::ustring &fname) = 0;
virtual void preprocess (const RAWParams &raw, const LensProfParams &lensProf, const CoarseTransformParams& coarse, bool prepareDenoise = true) {};
virtual void demosaic (const RAWParams &raw, bool autoContrast, double &contrastThreshold) {};
virtual void retinex (const ColorManagementParams& cmp, const RetinexParams &deh, const 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 RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) {};
virtual void retinexPrepareBuffers (const ColorManagementParams& cmp, const RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) {};
virtual void preprocess (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) {};
virtual void demosaic (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold) {};
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 flushRawData () {};
virtual void flushRGB () {};
virtual void HLRecovery_Global (const ToneCurveParams &hrp) {};
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
@ -86,7 +95,7 @@ public:
// 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 ToneCurveParams &hlp, const RAWParams &raw) = 0;
virtual void getImage (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const procparams::ToneCurveParams &hlp, const 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
@ -111,7 +120,7 @@ public:
virtual ImageMatrices* getImageMatrices () = 0;
virtual bool isRAW () const = 0;
virtual DCPProfile* getDCP (const ColorManagementParams &cmp, DCPProfile::ApplyState &as)
virtual DCPProfile* getDCP (const procparams::ColorManagementParams &cmp, DCPProfile::ApplyState &as)
{
return nullptr;
};
@ -140,7 +149,7 @@ public:
}
// for RAW files, compute a tone curve using histogram matching on the embedded thumbnail
virtual void getAutoMatchedToneCurve(const ColorManagementParams &cp, std::vector<double> &outCurve)
virtual void getAutoMatchedToneCurve(const procparams::ColorManagementParams &cp, std::vector<double> &outCurve)
{
outCurve = { 0.0 };
}

578
rtengine/improccoordinator.cc
View File

File diff suppressed because it is too large Load Diff

16
rtengine/improccoordinator.h
View File

@ -19,6 +19,8 @@
#ifndef _IMPROCCOORDINATOR_H_
#define _IMPROCCOORDINATOR_H_
#include <memory>
#include "rtengine.h"
#include "improcfun.h"
#include "image8.h"
@ -70,8 +72,6 @@ protected:
double lastAwbEqual;
double lastAwbTempBias;
ImProcFunctions ipf;
Glib::ustring monitorProfile;
RenderingIntent monitorIntent;
bool softProof;
@ -185,7 +185,7 @@ protected:
void updatePreviewImage (int todo, bool panningRelatedChange);
MyMutex mProcessing;
ProcParams params;
const std::unique_ptr<ProcParams> params;
// for optimization purpose, the output profile, output rendering intent and
// output BPC will trigger a regeneration of the profile on parameter change only
@ -200,7 +200,7 @@ protected:
MyMutex paramsUpdateMutex;
int changeSinceLast;
bool updaterRunning;
ProcParams nextParams;
const std::unique_ptr<ProcParams> nextParams;
bool destroying;
bool utili;
bool autili;
@ -217,16 +217,16 @@ protected:
bool highQualityComputed;
cmsHTRANSFORM customTransformIn;
cmsHTRANSFORM customTransformOut;
ImProcFunctions ipf;
public:
ImProcCoordinator ();
~ImProcCoordinator () override;
void assign (ImageSource* imgsrc);
void getParams (procparams::ProcParams* dst) override
{
*dst = params;
}
void getParams (procparams::ProcParams* dst) override;
void startProcessing (int changeCode) override;
ProcParams* beginUpdateParams () override;

25
rtengine/improcfun.cc
View File

@ -41,6 +41,7 @@
#include "clutstore.h"
#include "ciecam02.h"
#include "StopWatch.h"
#include "procparams.h"
#include "../rtgui/ppversion.h"
#include "../rtgui/guiutils.h"
@ -205,31 +206,31 @@ void proPhotoBlue(float *rtemp, float *gtemp, float *btemp, int istart, int tH,
}
}
void customToneCurve(const ToneCurve &customToneCurve, ToneCurveParams::TcMode curveMode, float *rtemp, float *gtemp, float *btemp, int istart, int tH, int jstart, int tW, int tileSize, PerceptualToneCurveState ptcApplyState) {
void customToneCurve(const ToneCurve &customToneCurve, ToneCurveMode curveMode, float *rtemp, float *gtemp, float *btemp, int istart, int tH, int jstart, int tW, int tileSize, PerceptualToneCurveState ptcApplyState) {
if (curveMode == ToneCurveParams::TcMode::STD) { // Standard
if (curveMode == ToneCurveMode::STD) { // Standard
const StandardToneCurve& userToneCurve = static_cast<const StandardToneCurve&> (customToneCurve);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
userToneCurve.BatchApply(0, tW - jstart, &rtemp[ti * tileSize], &gtemp[ti * tileSize], &btemp[ti * tileSize]);
}
} else if (curveMode == ToneCurveParams::TcMode::FILMLIKE) { // Adobe like
} else if (curveMode == ToneCurveMode::FILMLIKE) { // Adobe like
const AdobeToneCurve& userToneCurve = static_cast<const AdobeToneCurve&> (customToneCurve);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
userToneCurve.BatchApply(0, tW - jstart, &rtemp[ti * tileSize], &gtemp[ti * tileSize], &btemp[ti * tileSize]);
}
} else if (curveMode == ToneCurveParams::TcMode::SATANDVALBLENDING) { // apply the curve on the saturation and value channels
} else if (curveMode == ToneCurveMode::SATANDVALBLENDING) { // apply the curve on the saturation and value channels
const SatAndValueBlendingToneCurve& userToneCurve = static_cast<const SatAndValueBlendingToneCurve&> (customToneCurve);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
for (int j = jstart, tj = 0; j < tW; j++, tj++) {
userToneCurve.Apply(rtemp[ti * tileSize + tj], gtemp[ti * tileSize + tj], btemp[ti * tileSize + tj]);
}
}
} else if (curveMode == ToneCurveParams::TcMode::WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
} else if (curveMode == ToneCurveMode::WEIGHTEDSTD) { // apply the curve to the rgb channels, weighted
const WeightedStdToneCurve& userToneCurve = static_cast<const WeightedStdToneCurve&> (customToneCurve);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
userToneCurve.BatchApply(0, tW - jstart, &rtemp[ti * tileSize], &gtemp[ti * tileSize], &btemp[ti * tileSize]);
}
} else if (curveMode == ToneCurveParams::TcMode::LUMINANCE) { // apply the curve to the luminance channel
} else if (curveMode == ToneCurveMode::LUMINANCE) { // apply the curve to the luminance channel
const LuminanceToneCurve& userToneCurve = static_cast<const LuminanceToneCurve&> (customToneCurve);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
@ -237,7 +238,7 @@ void customToneCurve(const ToneCurve &customToneCurve, ToneCurveParams::TcMode c
userToneCurve.Apply(rtemp[ti * tileSize + tj], gtemp[ti * tileSize + tj], btemp[ti * tileSize + tj]);
}
}
} else if (curveMode == ToneCurveParams::TcMode::PERCEPTUAL) { // apply curve while keeping color appearance constant
} else if (curveMode == ToneCurveMode::PERCEPTUAL) { // apply curve while keeping color appearance constant
const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve);
for (int i = istart, ti = 0; i < tH; i++, ti++) {
userToneCurve.BatchApply(0, tW - jstart, &rtemp[ti * tileSize], &gtemp[ti * tileSize], &btemp[ti * tileSize], ptcApplyState);
@ -320,7 +321,7 @@ void ImProcFunctions::updateColorProfiles (const Glib::ustring& monitorProfile,
if (settings->printerBPC) {
flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
}
outIntent = settings->printerIntent;
outIntent = RenderingIntent(settings->printerIntent);
} else {
oprof = ICCStore::getInstance()->getProfile(params->icm.outputProfile);
if (params->icm.outputBPC) {
@ -2230,8 +2231,8 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
const float hlrange = 65536.0 - shoulder;
const bool isProPhoto = (params->icm.workingProfile == "ProPhoto");
// extracting datas from 'params' to avoid cache flush (to be confirmed)
ToneCurveParams::TcMode curveMode = params->toneCurve.curveMode;
ToneCurveParams::TcMode curveMode2 = params->toneCurve.curveMode2;
ToneCurveMode curveMode = params->toneCurve.curveMode;
ToneCurveMode curveMode2 = params->toneCurve.curveMode2;
bool highlight = params->toneCurve.hrenabled;//Get the value if "highlight reconstruction" is activated
bool hasToneCurve1 = bool (customToneCurve1);
bool hasToneCurve2 = bool (customToneCurve2);
@ -2243,12 +2244,12 @@ void ImProcFunctions::rgbProc (Imagefloat* working, LabImage* lab, PipetteBuffer
PerceptualToneCurveState ptc1ApplyState, ptc2ApplyState;
if (hasToneCurve1 && curveMode == ToneCurveParams::TcMode::PERCEPTUAL) {
if (hasToneCurve1 && curveMode == ToneCurveMode::PERCEPTUAL) {
const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve1);
userToneCurve.initApplyState (ptc1ApplyState, params->icm.workingProfile);
}
if (hasToneCurve2 && curveMode2 == ToneCurveParams::TcMode::PERCEPTUAL) {
if (hasToneCurve2 && curveMode2 == ToneCurveMode::PERCEPTUAL) {
const PerceptualToneCurve& userToneCurve = static_cast<const PerceptualToneCurve&> (customToneCurve2);
userToneCurve.initApplyState (ptc2ApplyState, params->icm.workingProfile);
}

27
rtengine/improcfun.h
View File

@ -22,7 +22,6 @@
#include "imagefloat.h"
#include "image16.h"
#include "image8.h"
#include "procparams.h"
#include "shmap.h"
#include "coord2d.h"
#include "color.h"
@ -39,12 +38,22 @@
namespace rtengine
{
using namespace procparams;
namespace procparams
{
class ProcParams;
struct DirPyrDenoiseParams;
struct SharpeningParams;
struct VignettingParams;
struct WaveletParams;
}
enum RenderingIntent : int;
class ImProcFunctions
{
cmsHTRANSFORM monitorTransform;
std::unique_ptr<GamutWarning> gamutWarning;
@ -52,7 +61,7 @@ class ImProcFunctions
double scale;
bool multiThread;
void calcVignettingParams(int oW, int oH, const VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul);
void calcVignettingParams(int oW, int oH, const procparams::VignettingParams& vignetting, double &w2, double &h2, double& maxRadius, double &v, double &b, double &mul);
void transformLuminanceOnly(Imagefloat* original, Imagefloat* transformed, int cx, int cy, int oW, int oH, int fW, int fH);
void transformGeneral(bool highQuality, Imagefloat *original, Imagefloat *transformed, int cx, int cy, int sx, int sy, int oW, int oH, int fW, int fH, const LensCorrection *pLCPMap);
@ -203,7 +212,7 @@ public:
bool needsTransform();
bool needsPCVignetting();
void firstAnalysis(const Imagefloat* const working, const ProcParams &params, LUTu & vhist16);
void firstAnalysis(const Imagefloat* const working, const procparams::ProcParams &params, LUTu & vhist16);
void updateColorProfiles(const Glib::ustring& monitorProfile, RenderingIntent monitorIntent, bool softProof, bool gamutCheck);
void rgbProc(Imagefloat* working, LabImage* lab, PipetteBuffer *pipetteBuffer, LUTf & hltonecurve, LUTf & shtonecurve, LUTf & tonecurve,
int sat, LUTf & rCurve, LUTf & gCurve, LUTf & bCurve, float satLimit, float satLimitOpacity, const ColorGradientCurve & ctColorCurve, const OpacityCurve & ctOpacityCurve, bool opautili, LUTf & clcurve, LUTf & cl2curve, const ToneCurve & customToneCurve1, const ToneCurve & customToneCurve2,
@ -230,7 +239,7 @@ public:
void chromiLuminanceCurve(PipetteBuffer *pipetteBuffer, int pW, LabImage* lold, LabImage* lnew, LUTf &acurve, LUTf &bcurve, LUTf & satcurve, LUTf & satclcurve, LUTf &clcurve, LUTf &curve, bool utili, bool autili, bool butili, bool ccutili, bool cclutili, bool clcutili, LUTu &histCCurve, LUTu &histLurve);
void vibrance(LabImage* lab); //Jacques' vibrance
// void colorCurve (LabImage* lold, LabImage* lnew);
void sharpening(LabImage* lab, const SharpeningParams &sharpenParam, bool showMask = false);
void sharpening(LabImage* lab, const procparams::SharpeningParams &sharpenParam, bool showMask = false);
void sharpeningcam(CieImage* ncie, float** buffer, bool showMask = false);
void transform(Imagefloat* original, Imagefloat* transformed, int cx, int cy, int sx, int sy, int oW, int oH, int fW, int fH, const FramesMetaData *metadata, int rawRotationDeg, bool fullImage);
float resizeScale(const ProcParams* params, int fw, int fh, int &imw, int &imh);
@ -239,7 +248,7 @@ public:
void Lanczos(const LabImage* src, LabImage* dst, float scale);
void Lanczos(const Imagefloat* src, Imagefloat* dst, float scale);
void deconvsharpening(float** luminance, float** buffer, int W, int H, const SharpeningParams &sharpenParam);
void deconvsharpening(float** luminance, float** buffer, int W, int H, const procparams::SharpeningParams &sharpenParam);
void MLsharpen(LabImage* lab); // Manuel's clarity / sharpening
void MLmicrocontrast(float** luminance, int W, int H); //Manuel's microcontrast
void MLmicrocontrast(LabImage* lab); //Manuel's microcontrast
@ -262,7 +271,7 @@ public:
void EPDToneMapCIE(CieImage *ncie, float a_w, float c_, int Wid, int Hei, float minQ, float maxQ, unsigned int Iterates = 0, int skip = 1);
// pyramid denoise
procparams::DirPyrDenoiseParams dnparams;
// procparams::DirPyrDenoiseParams dnparams;
void dirpyr(LabImage* data_fine, LabImage* data_coarse, int level, LUTf &rangefn_L, LUTf &rangefn_ab,
int pitch, int scale, const int luma, int chroma);
void idirpyr(LabImage* data_coarse, LabImage* data_fine, int level, LUTf &rangefn_L, LUTf & nrwt_l, LUTf & nrwt_ab,

1
rtengine/init.cc
View File

@ -32,6 +32,7 @@
#include "profilestore.h"
#include "../rtgui/threadutils.h"
#include "rtlensfun.h"
#include "procparams.h"
namespace rtengine
{

10
rtengine/ipdehaze.cc
View File

@ -28,13 +28,15 @@
*
*/
#include "improcfun.h"
#include "guidedfilter.h"
#include "rt_math.h"
#include "rt_algo.h"
#include <iostream>
#include <queue>
#include "guidedfilter.h"
#include "improcfun.h"
#include "procparams.h"
#include "rt_algo.h"
#include "rt_math.h"
extern Options options;
namespace rtengine {

2
rtengine/iplab2rgb.cc
View File

@ -26,6 +26,8 @@
#include "curves.h"
#include "alignedbuffer.h"
#include "color.h"
#include "procparams.h"
namespace rtengine
{

1
rtengine/iplabregions.cc
View File

@ -24,6 +24,7 @@
#include "improcfun.h"
#include "guidedfilter.h"
#include "procparams.h"
//#define BENCHMARK
#include "StopWatch.h"
#include "sleef.c"

5
rtengine/iplocalcontrast.cc
View File

@ -26,9 +26,10 @@
#include <omp.h>
#endif
#include "improcfun.h"
#include "gauss.h"
#include "array2D.h"
#include "gauss.h"
#include "improcfun.h"
#include "procparams.h"
namespace rtengine {

1
rtengine/ipresize.cc
View File

@ -22,6 +22,7 @@
#include "alignedbuffer.h"
#include "opthelper.h"
#include "rt_math.h"
#include "procparams.h"
#include "sleef.c"
//#define PROFILE

12
rtengine/ipretinex.cc
View File

@ -36,16 +36,18 @@
*/
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include "rtengine.h"
#include "gauss.h"
#include "rawimagesource.h"
#include "improcfun.h"
#include "opthelper.h"
#include "median.h"
#include "opthelper.h"
#include "procparams.h"
#include "rawimagesource.h"
#include "rtengine.h"
#include "StopWatch.h"
#define clipretinex( val, minv, maxv ) (( val = (val < minv ? minv : val ) ) > maxv ? maxv : val )

6
rtengine/ipshadowshighlights.cc
View File

@ -19,10 +19,12 @@
*/
#include "improcfun.h"
#include "gauss.h"
#include "sleef.c"
#include "opthelper.h"
#include "guidedfilter.h"
#include "opthelper.h"
#include "procparams.h"
#include "sleef.c"
namespace rtengine {

1
rtengine/ipsharpen.cc
View File

@ -22,6 +22,7 @@
#include "bilateral2.h"
#include "jaggedarray.h"
#include "rt_math.h"
#include "procparams.h"
#include "sleef.c"
#include "opthelper.h"
//#define BENCHMARK

2
rtengine/ipsoftlight.cc
View File

@ -24,6 +24,8 @@
#include "improcfun.h"
#include "procparams.h"
namespace rtengine {
namespace {

1
rtengine/iptransform.cc
View File

@ -18,6 +18,7 @@
*/
#include "rtengine.h"
#include "improcfun.h"
#include "procparams.h"
#ifdef _OPENMP
#include <omp.h>
#endif

1
rtengine/ipvibrance.cc
View File

@ -27,6 +27,7 @@
#include "../rtgui/thresholdselector.h"
#include "curves.h"
#include "color.h"
#include "procparams.h"
#include "StopWatch.h"
#ifdef _OPENMP
#include <omp.h>

1
rtengine/ipwavelet.cc
View File

@ -40,6 +40,7 @@
#include "median.h"
#include "EdgePreservingDecomposition.h"
#include "iccstore.h"
#include "procparams.h"
#ifdef _OPENMP
#include <omp.h>

1
rtengine/lcp.cc
View File

@ -29,6 +29,7 @@
#include "lcp.h"
#include "procparams.h"
#include "settings.h"
namespace rtengine

6
rtengine/previewimage.cc
View File

@ -18,11 +18,13 @@
*/
#include "previewimage.h"
#include "iimage.h"
#include "utils.h"
#include "iimage.h"
#include "rtthumbnail.h"
#include "procparams.h"
#include "rawimagesource.h"
#include "rtthumbnail.h"
#include "utils.h"
using namespace rtengine;
using namespace procparams;

1
rtengine/processingjob.h
View File

@ -20,6 +20,7 @@
#define _PROCESSINGJOB_
#include "rtengine.h"
#include "procparams.h"
namespace rtengine
{

32
rtengine/procparams.cc
View File

@ -315,8 +315,8 @@ ToneCurveParams::ToneCurveParams() :
curve2{
DCT_Linear
},
curveMode(ToneCurveParams::TcMode::STD),
curveMode2(ToneCurveParams::TcMode::STD),
curveMode(ToneCurveMode::STD),
curveMode2(ToneCurveMode::STD),
brightness(0),
black(0),
contrast(0),
@ -2877,13 +2877,13 @@ int ProcParams::save(const Glib::ustring& fname, const Glib::ustring& fname2, bo
saveToKeyfile(!pedited || pedited->toneCurve.hrenabled, "HLRecovery", "Enabled", toneCurve.hrenabled, keyFile);
saveToKeyfile(!pedited || pedited->toneCurve.method, "HLRecovery", "Method", toneCurve.method, keyFile);
const std::map<ToneCurveParams::TcMode, const char*> tc_mapping = {
{ToneCurveParams::TcMode::STD, "Standard"},
{ToneCurveParams::TcMode::FILMLIKE, "FilmLike"},
{ToneCurveParams::TcMode::SATANDVALBLENDING, "SatAndValueBlending"},
{ToneCurveParams::TcMode::WEIGHTEDSTD, "WeightedStd"},
{ToneCurveParams::TcMode::LUMINANCE, "Luminance"},
{ToneCurveParams::TcMode::PERCEPTUAL, "Perceptual"}
const std::map<ToneCurveMode, const char*> tc_mapping = {
{ToneCurveMode::STD, "Standard"},
{ToneCurveMode::FILMLIKE, "FilmLike"},
{ToneCurveMode::SATANDVALBLENDING, "SatAndValueBlending"},
{ToneCurveMode::WEIGHTEDSTD, "WeightedStd"},
{ToneCurveMode::LUMINANCE, "Luminance"},
{ToneCurveMode::PERCEPTUAL, "Perceptual"}
};
saveToKeyfile(!pedited || pedited->toneCurve.curveMode, "Exposure", "CurveMode", tc_mapping, toneCurve.curveMode, keyFile);
@ -3662,13 +3662,13 @@ int ProcParams::load(const Glib::ustring& fname, ParamsEdited* pedited)
toneCurve.shcompr = 100; // older pp3 files can have values above 100.
}
const std::map<std::string, ToneCurveParams::TcMode> tc_mapping = {
{"Standard", ToneCurveParams::TcMode::STD},
{"FilmLike", ToneCurveParams::TcMode::FILMLIKE},
{"SatAndValueBlending", ToneCurveParams::TcMode::SATANDVALBLENDING},
{"WeightedStd", ToneCurveParams::TcMode::WEIGHTEDSTD},
{"Luminance", ToneCurveParams::TcMode::LUMINANCE},
{"Perceptual", ToneCurveParams::TcMode::PERCEPTUAL}
const std::map<std::string, ToneCurveMode> tc_mapping = {
{"Standard", ToneCurveMode::STD},
{"FilmLike", ToneCurveMode::FILMLIKE},
{"SatAndValueBlending", ToneCurveMode::SATANDVALBLENDING},
{"WeightedStd", ToneCurveMode::WEIGHTEDSTD},
{"Luminance", ToneCurveMode::LUMINANCE},
{"Perceptual", ToneCurveMode::PERCEPTUAL}
};
assignFromKeyfile(keyFile, "Exposure", "CurveMode", pedited, tc_mapping, toneCurve.curveMode, pedited->toneCurve.curveMode);

137
rtengine/procparams.h
View File

@ -28,7 +28,7 @@
#include "noncopyable.h"
class ParamsEdited;
struct ParamsEdited;
namespace rtengine
{
@ -44,7 +44,7 @@ class WavOpacityCurveRG;
class WavOpacityCurveW;
class WavOpacityCurveWL;
enum RenderingIntent {
enum RenderingIntent : int {
RI_PERCEPTUAL = INTENT_PERCEPTUAL,
RI_RELATIVE = INTENT_RELATIVE_COLORIMETRIC,
RI_SATURATION = INTENT_SATURATION,
@ -249,35 +249,35 @@ private:
bool is_double;
};
enum class ToneCurveMode : int {
STD, // Standard modes, the curve is applied on all component individually
WEIGHTEDSTD, // Weighted standard mode
FILMLIKE, // Film-like mode, as defined in Adobe's reference code
SATANDVALBLENDING, // Modify the Saturation and Value channel
LUMINANCE, // Modify the Luminance channel with coefficients from Rec 709's
PERCEPTUAL // Keep color appearance constant using perceptual modeling
};
/**
* Parameters of the tone curve
*/
struct ToneCurveParams {
enum class TcMode {
STD, // Standard modes, the curve is applied on all component individually
WEIGHTEDSTD, // Weighted standard mode
FILMLIKE, // Film-like mode, as defined in Adobe's reference code
SATANDVALBLENDING, // Modify the Saturation and Value channel
LUMINANCE, // Modify the Luminance channel with coefficients from Rec 709's
PERCEPTUAL // Keep color appearance constant using perceptual modeling
};
bool autoexp;
double clip;
bool hrenabled; // Highlight Reconstruction enabled
Glib::ustring method; // Highlight Reconstruction's method
double expcomp;
std::vector<double> curve;
std::vector<double> curve2;
TcMode curveMode;
TcMode curveMode2;
int brightness;
int black;
int contrast;
int saturation;
int shcompr;
int hlcompr; // Highlight Recovery's compression
int hlcomprthresh; // Highlight Recovery's threshold
bool autoexp;
double clip;
bool hrenabled; // Highlight Reconstruction enabled
Glib::ustring method; // Highlight Reconstruction's method
double expcomp;
std::vector<double> curve;
std::vector<double> curve2;
ToneCurveMode curveMode;
ToneCurveMode curveMode2;
int brightness;
int black;
int contrast;
int saturation;
int shcompr;
int hlcompr; // Highlight Recovery's compression
int hlcomprthresh; // Highlight Recovery's threshold
bool histmatching; // histogram matching
bool fromHistMatching;
bool clampOOG; // clamp out of gamut colours
@ -473,7 +473,7 @@ struct ColorToningParams {
};
std::vector<LabCorrectionRegion> labregions;
int labregionsShowMask;
ColorToningParams();
bool operator ==(const ColorToningParams& other) const;
@ -1076,14 +1076,89 @@ struct MetaDataParams {
/**
* Typedef for representing a key/value for the exif metadata information
* Minimal wrapper allowing forward declaration for representing a key/value for the exif metadata information
*/
typedef std::map<Glib::ustring, Glib::ustring> ExifPairs;
class ExifPairs final
{
public:
using const_iterator = std::map<Glib::ustring, Glib::ustring>::const_iterator;
const_iterator begin() const
{
return pairs.begin();
}
const_iterator end() const
{
return pairs.end();
}
void clear()
{
pairs.clear();
}
Glib::ustring& operator[](const Glib::ustring& key)
{
return pairs[key];
}
bool operator ==(const ExifPairs& other) const
{
return pairs == other.pairs;
}
private:
std::map<Glib::ustring, Glib::ustring> pairs;
};
/**
* The IPTC key/value pairs
*/
typedef std::map<Glib::ustring, std::vector<Glib::ustring>> IPTCPairs;
class IPTCPairs final
{
public:
using iterator = std::map<Glib::ustring, std::vector<Glib::ustring>>::iterator;
using const_iterator = std::map<Glib::ustring, std::vector<Glib::ustring>>::const_iterator;
iterator find(const Glib::ustring& key)
{
return pairs.find(key);
}
const_iterator begin() const
{
return pairs.begin();
}
const_iterator end() const
{
return pairs.end();
}
bool empty() const
{
return pairs.empty();
}
void clear()
{
pairs.clear();
}
std::vector<Glib::ustring>& operator[](const Glib::ustring& key)
{
return pairs[key];
}
bool operator ==(const IPTCPairs& other) const
{
return pairs == other.pairs;
}
private:
std::map<Glib::ustring, std::vector<Glib::ustring>> pairs;
};
struct WaveletParams {
std::vector<double> ccwcurve;

2
rtengine/profilestore.cc
View File

@ -19,6 +19,8 @@
#include "profilestore.h"
#include "dynamicprofile.h"
#include "procparams.h"
#include "../rtgui/options.h"
#include "../rtgui/multilangmgr.h"

14
rtengine/profilestore.h
View File

@ -27,8 +27,20 @@
#include "noncopyable.h"
#include "dynamicprofile.h"
// forward decl
namespace rtengine
{
namespace procparams
{
class AutoPartialProfile;
class PartialProfile;
}
}
class DynamicProfileRule;
class DynamicProfileRules;

2
rtengine/rawimagesource.cc
View File

@ -36,6 +36,7 @@
#include "rtlensfun.h"
#include "pdaflinesfilter.h"
#include "camconst.h"
#include "procparams.h"
#ifdef _OPENMP
#include <omp.h>
#endif
@ -452,6 +453,7 @@ RawImageSource::RawImageSource ()
, red(0, 0)
, blue(0, 0)
, rawDirty(true)
, histMatchingParams(new procparams::ColorManagementParams)
{
camProfile = nullptr;
embProfile = nullptr;

39
rtengine/rawimagesource.h
View File

@ -19,13 +19,16 @@
#ifndef _RAWIMAGESOURCE_
#define _RAWIMAGESOURCE_
#include "imagesource.h"
#include "dcp.h"
#include "array2D.h"
#include "curves.h"
#include "color.h"
#include "iimage.h"
#include <iostream>
#include <memory>
#include "array2D.h"
#include "color.h"
#include "curves.h"
#include "dcp.h"
#include "iimage.h"
#include "imagesource.h"
#define HR_SCALE 2
namespace rtengine
@ -39,7 +42,7 @@ private:
static DiagonalCurve *phaseOneIccCurveInv;
static LUTf invGrad; // for fast_demosaic
static LUTf initInvGrad ();
static void colorSpaceConversion_ (Imagefloat* im, const ColorManagementParams& cmp, const ColorTemp &wb, double pre_mul[3], cmsHPROFILE embedded, cmsHPROFILE camprofile, double cam[3][3], const std::string &camName);
static void colorSpaceConversion_ (Imagefloat* im, const procparams::ColorManagementParams& cmp, const ColorTemp &wb, double pre_mul[3], cmsHPROFILE embedded, cmsHPROFILE camprofile, double cam[3][3], const std::string &camName);
int defTransform (int tran);
protected:
@ -91,7 +94,7 @@ protected:
float psBlueBrightness[4];
std::vector<double> histMatchingCache;
ColorManagementParams histMatchingParams;
const std::unique_ptr<procparams::ColorManagementParams> histMatchingParams;
void processFalseColorCorrectionThread (Imagefloat* im, array2D<float> &rbconv_Y, array2D<float> &rbconv_I, array2D<float> &rbconv_Q, array2D<float> &rbout_I, array2D<float> &rbout_Q, const int row_from, const int row_to);
void hlRecovery (const std::string &method, float* red, float* green, float* blue, int width, float* hlmax);
@ -112,14 +115,14 @@ public:
int load(const Glib::ustring &fname) override { return load(fname, false); }
int load(const Glib::ustring &fname, bool firstFrameOnly);
void preprocess (const RAWParams &raw, const LensProfParams &lensProf, const CoarseTransformParams& coarse, bool prepareDenoise = true) override;
void demosaic (const RAWParams &raw, bool autoContrast, double &contrastThreshold) override;
void retinex (const ColorManagementParams& cmp, const RetinexParams &deh, const 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) override;
void retinexPrepareCurves (const RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) override;
void retinexPrepareBuffers (const ColorManagementParams& cmp, const RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) override;
void preprocess (const procparams::RAWParams &raw, const procparams::LensProfParams &lensProf, const procparams::CoarseTransformParams& coarse, bool prepareDenoise = true) override;
void demosaic (const procparams::RAWParams &raw, bool autoContrast, double &contrastThreshold) override;
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) override;
void retinexPrepareCurves (const procparams::RetinexParams &retinexParams, LUTf &cdcurve, LUTf &mapcurve, RetinextransmissionCurve &retinextransmissionCurve, RetinexgaintransmissionCurve &retinexgaintransmissionCurve, bool &retinexcontlutili, bool &mapcontlutili, bool &useHsl, LUTu & lhist16RETI, LUTu & histLRETI) override;
void retinexPrepareBuffers (const procparams::ColorManagementParams& cmp, const procparams::RetinexParams &retinexParams, multi_array2D<float, 4> &conversionBuffer, LUTu &lhist16RETI) override;
void flushRawData () override;
void flushRGB () override;
void HLRecovery_Global (const ToneCurveParams &hrp) override;
void HLRecovery_Global (const procparams::ToneCurveParams &hrp) override;
void refinement_lassus (int PassCount);
void refinement(int PassCount);
void setBorder(unsigned int rawBorder) override {border = rawBorder;}
@ -133,7 +136,7 @@ public:
void cfaboxblur (RawImage *riFlatFile, float* cfablur, int boxH, int boxW);
void scaleColors (int winx, int winy, int winw, int winh, const RAWParams &raw, array2D<float> &rawData); // raw for cblack
void getImage (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const ToneCurveParams &hrp, const RAWParams &raw) override;
void getImage (const ColorTemp &ctemp, int tran, Imagefloat* image, const PreviewProps &pp, const procparams::ToneCurveParams &hrp, const procparams::RAWParams &raw) override;
eSensorType getSensorType () const override
{
return ri != nullptr ? ri->getSensorType() : ST_NONE;
@ -180,10 +183,10 @@ public:
}
void getAutoExpHistogram (LUTu & histogram, int& histcompr) override;
void getRAWHistogram (LUTu & histRedRaw, LUTu & histGreenRaw, LUTu & histBlueRaw) override;
void getAutoMatchedToneCurve(const ColorManagementParams &cp, std::vector<double> &outCurve) override;
DCPProfile *getDCP(const ColorManagementParams &cmp, DCPProfile::ApplyState &as) override;
void getAutoMatchedToneCurve(const procparams::ColorManagementParams &cp, std::vector<double> &outCurve) override;
DCPProfile *getDCP(const procparams::ColorManagementParams &cmp, DCPProfile::ApplyState &as) override;
void convertColorSpace(Imagefloat* image, const ColorManagementParams &cmp, const ColorTemp &wb) override;
void convertColorSpace(Imagefloat* image, const procparams::ColorManagementParams &cmp, const ColorTemp &wb) override;
static bool findInputProfile(Glib::ustring inProfile, cmsHPROFILE embedded, std::string camName, DCPProfile **dcpProf, cmsHPROFILE& in);
static void colorSpaceConversion (Imagefloat* im, const ColorManagementParams& cmp, const ColorTemp &wb, double pre_mul[3], cmsHPROFILE embedded, cmsHPROFILE camprofile, double cam[3][3], const std::string &camName)
{

1
rtengine/rcd_demosaic.cc
View File

@ -20,6 +20,7 @@
#include "rawimagesource.h"
#include "rt_math.h"
#include "procparams.h"
#include "../rtgui/multilangmgr.h"
#include "opthelper.h"
#include "StopWatch.h"

19
rtengine/rtengine.h
View File

@ -21,7 +21,6 @@
#include "imageformat.h"
#include "rt_math.h"
#include "procparams.h"
#include "procevents.h"
#include <lcms2.h>
#include <string>
@ -45,6 +44,22 @@ class EditDataProvider;
namespace rtengine
{
enum RenderingIntent : int;
namespace procparams
{
class ProcParams;
class IPTCPairs;
struct RAWParams;
struct ColorManagementParams;
struct CropParams;
enum class ToneCurveMode : int;
}
class IImage8;
class IImage16;
class IImagefloat;
@ -315,7 +330,7 @@ public:
* @param hlrecons set to true if HighLight Reconstruction is enabled */
virtual void autoExpChanged(double brightness, int bright, int contrast, int black, int hlcompr, int hlcomprthresh, bool hlrecons) = 0;
virtual void autoMatchedToneCurveChanged(procparams::ToneCurveParams::TcMode curveMode, const std::vector<double>& curve) = 0;
virtual void autoMatchedToneCurveChanged(procparams::ToneCurveMode curveMode, const std::vector<double>& curve) = 0;
};
class AutoCamListener

1
rtengine/rtlensfun.cc
View File

@ -19,6 +19,7 @@
*/
#include "rtlensfun.h"
#include "procparams.h"
#include "settings.h"
#include <iostream>

10
rtengine/rtlensfun.h
View File

@ -29,10 +29,16 @@
#include "lcp.h"
#include "noncopyable.h"
#include "procparams.h"
namespace rtengine {
namespace procparams
{
struct LensProfParams;
}
class LFModifier final :
public LensCorrection,
public NonCopyable
@ -113,7 +119,7 @@ public:
LFCamera findCamera(const Glib::ustring &make, const Glib::ustring &model) const;
LFLens findLens(const LFCamera &camera, const Glib::ustring &name) const;
static std::unique_ptr<LFModifier> findModifier(const LensProfParams &lensProf, const FramesMetaData *idata, int width, int height, const CoarseTransformParams &coarse, int rawRotationDeg);
static std::unique_ptr<LFModifier> findModifier(const procparams::LensProfParams &lensProf, const FramesMetaData *idata, int width, int height, const CoarseTransformParams &coarse, int rawRotationDeg);
private:
std::unique_ptr<LFModifier> getModifier(const LFCamera &camera, const LFLens &lens,

3
rtengine/rtthumbnail.cc
View File

@ -37,6 +37,7 @@
#include "../rtgui/ppversion.h"
#include "improccoordinator.h"
#include "settings.h"
#include "procparams.h"
#include <locale.h>
#include "StopWatch.h"
#include "median.h"
@ -1220,7 +1221,7 @@ IImage8* Thumbnail::processImage (const procparams::ProcParams& params, eSensorT
ImProcFunctions ipf (&params, forHistogramMatching); // enable multithreading when forHistogramMatching is true
ipf.setScale (sqrt (double (fw * fw + fh * fh)) / sqrt (double (thumbImg->getWidth() * thumbImg->getWidth() + thumbImg->getHeight() * thumbImg->getHeight()))*scale);
ipf.updateColorProfiles (ICCStore::getInstance()->getDefaultMonitorProfileName(), options.rtSettings.monitorIntent, false, false);
ipf.updateColorProfiles (ICCStore::getInstance()->getDefaultMonitorProfileName(), RenderingIntent(options.rtSettings.monitorIntent), false, false);
LUTu hist16 (65536);

1
rtengine/rtthumbnail.h
View File

@ -20,7 +20,6 @@
#define _THUMBPROCESSINGPARAMETERS_
#include "rawmetadatalocation.h"
#include "procparams.h"
#include <glibmm.h>
#include <lcms2.h>
#include "image8.h"

6
rtengine/settings.h
View File

@ -19,8 +19,6 @@
#ifndef _RTSETTINGS_
#define _RTSETTINGS_
#include "procparams.h"
namespace rtengine
{
@ -39,10 +37,10 @@ public:
int leveldnautsimpl; // STD or EXPERT
Glib::ustring printerProfile; ///< ICC profile name used for soft-proofing a printer output
RenderingIntent printerIntent; ///< Colorimetric intent used with the above profile
int printerIntent; ///< Colorimetric intent used with the above profile
bool printerBPC; ///< Black Point Compensation for the Labimage->Printer->Monitor transform
Glib::ustring monitorProfile; ///< ICC profile name used for the monitor
RenderingIntent monitorIntent; ///< Colorimetric intent used with the above profile
int monitorIntent; ///< Colorimetric intent used with the above profile
bool monitorBPC; ///< Black Point Compensation for the Labimage->Monitor transform (directly, i.e. not soft-proofing and no WCS in between)
bool autoMonitorProfile; ///< Try to auto-determine the correct monitor color profile
bool autocielab;

3
rtengine/simpleprocess.cc
View File

@ -24,6 +24,7 @@
#include "iccstore.h"
#include "clutstore.h"
#include "processingjob.h"
#include "procparams.h"
#include <glibmm.h>
#include "../rtgui/options.h"
#include "rawimagesource.h"
@ -770,7 +771,7 @@ private:
}
params.toneCurve.autoexp = false;
params.toneCurve.curveMode = ToneCurveParams::TcMode::FILMLIKE;
params.toneCurve.curveMode = ToneCurveMode::FILMLIKE;
params.toneCurve.curve2 = { 0 };
params.toneCurve.brightness = 0;
params.toneCurve.contrast = 0;

8
rtengine/stdimagesource.cc
View File

@ -17,11 +17,13 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "stdimagesource.h"
#include "mytime.h"
#include "color.h"
#include "curves.h"
#include "iccstore.h"
#include "imageio.h"
#include "curves.h"
#include "color.h"
#include "mytime.h"
#include "procparams.h"
#undef THREAD_PRIORITY_NORMAL

1
rtengine/tmo_fattal02.cc
View File

@ -74,6 +74,7 @@
#include "opthelper.h"
#include "rt_algo.h"
#include "rescale.h"
#include "procparams.h"
namespace rtengine
{

1
rtengine/vng4_demosaic_RT.cc
View File

@ -22,6 +22,7 @@
#include "rtengine.h"
#include "rawimagesource.h"
#include "procparams.h"
#include "../rtgui/multilangmgr.h"
//#define BENCHMARK
#include "StopWatch.h"

2
rtexif/rtexif.cc
View File

@ -32,6 +32,8 @@
#include "rtexif.h"
#include "../rtengine/procparams.h"
#include "../rtgui/cacheimagedata.h"
#include "../rtgui/version.h"
#include "../rtgui/ppversion.h"

11
rtexif/rtexif.h
View File

@ -32,10 +32,19 @@
#include <glibmm.h>
#include "../rtengine/procparams.h"
#include "../rtengine/noncopyable.h"
#include "../rtengine/rawmetadatalocation.h"
namespace rtengine
{
namespace procparams
{
class ExifPairs;
}
}
class CacheImageData;
namespace rtexif

7
rtgui/batchqueue.cc
View File

@ -21,6 +21,7 @@
#include <cstring>
#include <functional>
#include "../rtengine/rt_math.h"
#include "../rtengine/procparams.h"
#include <fstream>
#include <iomanip>
@ -197,7 +198,7 @@ void BatchQueue::addEntries (const std::vector<BatchQueueEntry*>& entries, bool
// recovery save
const auto tempFile = getTempFilenameForParams (entry->filename);
if (!entry->params.save (tempFile))
if (!entry->params->save (tempFile))
entry->savedParamsFile = tempFile;
entry->selected = false;
@ -642,7 +643,7 @@ void BatchQueue::error(const Glib::ustring& descr)
bqbs->setButtonListener (this);
processing->addButtonSet (bqbs);
processing->processing = false;
processing->job = rtengine::ProcessingJob::create(processing->filename, processing->thumbnail->getType() == FT_Raw, processing->params);
processing->job = rtengine::ProcessingJob::create(processing->filename, processing->thumbnail->getType() == FT_Raw, *processing->params);
processing = nullptr;
redraw ();
}
@ -706,7 +707,7 @@ rtengine::ProcessingJob* BatchQueue::imageReady(rtengine::IImagefloat* img)
// We keep the extension to avoid overwriting the profile when we have
// the same output filename with different extension
//processing->params.save (removeExtension(fname) + paramFileExtension);
processing->params.save (fname + ".out" + paramFileExtension);
processing->params->save (fname + ".out" + paramFileExtension);
}
if (processing->thumbnail) {

6
rtgui/batchqueueentry.cc
View File

@ -26,6 +26,8 @@
#include "multilangmgr.h"
#include "thumbbrowserbase.h"
#include "../rtengine/procparams.h"
bool BatchQueueEntry::iconsLoaded(false);
Glib::RefPtr<Gdk::Pixbuf> BatchQueueEntry::savedAsIcon;
@ -36,7 +38,7 @@ BatchQueueEntry::BatchQueueEntry (rtengine::ProcessingJob* pjob, const rtengine:
origph(prevh),
opreviewDone(false),
job(pjob),
params(pparams),
params(new rtengine::procparams::ProcParams(pparams)),
progress(0),
outFileName(""),
sequence(0),
@ -93,7 +95,7 @@ void BatchQueueEntry::refreshThumbnailImage ()
// creating the image buffer first
//if (!opreview) opreview = new guint8[(origpw+1) * origph * 3];
// this will asynchronously compute the original preview and land at this.updateImage
batchQueueEntryUpdater.process (nullptr, origpw, origph, preh, this, &params, thumbnail);
batchQueueEntryUpdater.process (nullptr, origpw, origph, preh, this, params.get(), thumbnail);
} else {
// this will asynchronously land at this.updateImage
batchQueueEntryUpdater.process (opreview, origpw, origph, preh, this);

4
rtgui/batchqueueentry.h
View File

@ -19,6 +19,8 @@
#ifndef _BATCHQUEUEENTRY_
#define _BATCHQUEUEENTRY_
#include <memory>
#include <gtkmm.h>
#include "../rtengine/rtengine.h"
#include "thumbbrowserentrybase.h"
@ -46,7 +48,7 @@ public:
static Glib::RefPtr<Gdk::Pixbuf> savedAsIcon;
rtengine::ProcessingJob* job;
rtengine::procparams::ProcParams params;
const std::unique_ptr<rtengine::procparams::ProcParams> params;
Glib::ustring savedParamsFile;
double progress;
Glib::ustring outFileName;

9
rtgui/bayerpreprocess.cc
View File

@ -16,11 +16,14 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bayerpreprocess.h"
#include "guiutils.h"
#include "eventmapper.h"
#include <sstream>
#include "bayerpreprocess.h"
#include "eventmapper.h"
#include "guiutils.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

6
rtgui/bayerprocess.cc
View File

@ -17,9 +17,13 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bayerprocess.h"
#include "eventmapper.h"
#include "options.h"
#include "guiutils.h"
#include "options.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

3
rtgui/bayerrawexposure.cc
View File

@ -17,8 +17,11 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "bayerrawexposure.h"
#include "guiutils.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

12
rtgui/blackwhite.cc
View File

@ -16,13 +16,17 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "blackwhite.h"
#include "rtimage.h"
#include "../rtengine/color.h"
#include <iomanip>
#include <cmath>
#include "guiutils.h"
#include "blackwhite.h"
#include "edit.h"
#include "guiutils.h"
#include "rtimage.h"
#include "../rtengine/color.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

6
rtgui/cacheimagedata.cc
View File

@ -22,6 +22,8 @@
#include "version.h"
#include <locale.h>
#include "../rtengine/procparams.h"
CacheImageData::CacheImageData ()
: md5(""), supported(false), format(FT_Invalid), rankOld(-1), inTrashOld(false), recentlySaved(false),
timeValid(false), year(0), month(0), day(0), hour(0), min(0), sec(0), exifValid(false), frameCount(1),
@ -301,3 +303,7 @@ int CacheImageData::save (const Glib::ustring& fname)
}
}
rtengine::procparams::IPTCPairs CacheImageData::getIPTCData(unsigned int frame) const
{
return {};
}

2
rtgui/cacheimagedata.h
View File

@ -94,7 +94,7 @@ public:
rtexif::TagDirectory* getFrameExifData (unsigned int frame = 0) const override { return nullptr; }
rtexif::TagDirectory* getBestExifData (rtengine::ImageSource *imgSource, rtengine::procparams::RAWParams *rawParams) const override { return nullptr; }
bool hasIPTC (unsigned int frame = 0) const override { return false; }
rtengine::procparams::IPTCPairs getIPTCData (unsigned int frame = 0) const override { return rtengine::procparams::IPTCPairs(); }
rtengine::procparams::IPTCPairs getIPTCData (unsigned int frame = 0) const override;
tm getDateTime (unsigned int frame = 0) const override { return tm{}; }
time_t getDateTimeAsTS(unsigned int frame = 0) const override { return time_t(-1); }
int getISOSpeed (unsigned int frame = 0) const override { return iso; }

6
rtgui/cacorrection.cc
View File

@ -16,10 +16,14 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "cacorrection.h"
#include <iomanip>
#include "cacorrection.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

3
rtgui/chmixer.cc
View File

@ -17,8 +17,11 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "chmixer.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

128
rtgui/clipboard.cc
View File

@ -18,62 +18,146 @@
*/
#include "clipboard.h"
#include "../rtengine/procparams.h"
Clipboard clipboard;
Clipboard::Clipboard () : _hasIPTC(false), partProfile (false), hasDiagonalCurveDataType(DCT_Empty), hasFlatCurveDataType(FCT_Empty) {}
Clipboard::Clipboard () :
_hasIPTC(false),
iptc(new rtengine::procparams::IPTCPairs),
partProfile(new rtengine::procparams::PartialProfile(false)),
hasDiagonalCurveDataType(DCT_Empty),
hasFlatCurveDataType(FCT_Empty)
{
}
Clipboard::~Clipboard ()
{
partProfile.deleteInstance();
partProfile->deleteInstance();
}
bool Clipboard::hasIPTC() const
{
return _hasIPTC;
}
const rtengine::procparams::IPTCPairs& Clipboard::getIPTC() const
{
return *iptc;
}
void Clipboard::setIPTC(const rtengine::procparams::IPTCPairs& iptcc)
{
*iptc = iptcc;
_hasIPTC = true;
}
const rtengine::procparams::PartialProfile& Clipboard::getPartialProfile() const
{
return *partProfile;
}
/*
* set both the "pparams" and "pedited" field of the PartialProfile; each one can be NULL
*/
void Clipboard::setPartialProfile (const rtengine::procparams::PartialProfile& pprofile)
void Clipboard::setPartialProfile(const rtengine::procparams::PartialProfile& pprofile)
{
if (pprofile.pparams) {
if (!partProfile.pparams) {
partProfile.pparams = new rtengine::procparams::ProcParams();
if (!partProfile->pparams) {
partProfile->pparams = new rtengine::procparams::ProcParams();
}
*partProfile.pparams = *pprofile.pparams;
*partProfile->pparams = *pprofile.pparams;
} else {
if (partProfile.pparams) {
delete partProfile.pparams;
partProfile.pparams = nullptr;
if (partProfile->pparams) {
delete partProfile->pparams;
partProfile->pparams = nullptr;
}
}
if (pprofile.pedited) {
if (!partProfile.pedited) {
partProfile.pedited = new ParamsEdited();
if (!partProfile->pedited) {
partProfile->pedited = new ParamsEdited();
}
*partProfile.pedited = *pprofile.pedited;
*partProfile->pedited = *pprofile.pedited;
} else {
if (partProfile.pedited) {
delete partProfile.pedited;
partProfile.pedited = nullptr;
if (partProfile->pedited) {
delete partProfile->pedited;
partProfile->pedited = nullptr;
}
}
}
const rtengine::procparams::ProcParams& Clipboard::getProcParams() const
{
return *partProfile->pparams;
}
/*
* this method copy the procparams to "pparams" and delete "pedited"
*/
void Clipboard::setProcParams (const rtengine::procparams::ProcParams& pparams)
void Clipboard::setProcParams(const rtengine::procparams::ProcParams& pparams)
{
// copy procparams
if (!partProfile.pparams) {
partProfile.pparams = new rtengine::procparams::ProcParams();
if (!partProfile->pparams) {
partProfile->pparams = new rtengine::procparams::ProcParams();
}
*partProfile.pparams = pparams;
*partProfile->pparams = pparams;
// delete pedited
if (partProfile.pedited) {
delete partProfile.pedited;
partProfile.pedited = nullptr;
if (partProfile->pedited) {
delete partProfile->pedited;
partProfile->pedited = nullptr;
}
}
const ParamsEdited& Clipboard::getParamsEdited() const
{
return *partProfile->pedited;
}
bool Clipboard::hasProcParams() const
{
return partProfile->pparams;
}
bool Clipboard::hasPEdited() const
{
return partProfile->pedited;
}
DiagonalCurveType Clipboard::hasDiagonalCurveData() const
{
return hasDiagonalCurveDataType;
}
const std::vector<double>& Clipboard::getDiagonalCurveData() const
{
return diagonalCurve;
}
void Clipboard::setDiagonalCurveData(const std::vector<double>& p, DiagonalCurveType type)
{
diagonalCurve = p;
hasDiagonalCurveDataType = type;
return;
}
FlatCurveType Clipboard::hasFlatCurveData() const
{
return hasFlatCurveDataType;
}
const std::vector<double>& Clipboard:: getFlatCurveData() const
{
return flatCurve;
}
void Clipboard::setFlatCurveData(const std::vector<double>& p, FlatCurveType type)
{
flatCurve = p;
hasFlatCurveDataType = type;
return;
}

126
rtgui/clipboard.h
View File

@ -19,96 +19,64 @@
#ifndef _CLIPBOARD_
#define _CLIPBOARD_
#include <memory>
#include <vector>
#include "../rtengine/rtengine.h"
#include "../rtengine/procparams.h"
#include "paramsedited.h"
#include "myflatcurve.h"
#include "mydiagonalcurve.h"
#include "myflatcurve.h"
#include "paramsedited.h"
#include "../rtengine/rtengine.h"
namespace rtengine
{
namespace procparams
{
class PartialProfile;
}
}
class Clipboard
{
public:
Clipboard ();
~Clipboard ();
bool hasIPTC() const;
const rtengine::procparams::IPTCPairs& getIPTC() const;
void setIPTC(const rtengine::procparams::IPTCPairs& iptcc);
const rtengine::procparams::PartialProfile& getPartialProfile() const;
void setPartialProfile(const rtengine::procparams::PartialProfile& pprofile);
const rtengine::procparams::ProcParams& getProcParams() const;
void setProcParams(const rtengine::procparams::ProcParams& pparams);
const ParamsEdited& getParamsEdited() const;
bool hasProcParams() const;
bool hasPEdited() const;
DiagonalCurveType hasDiagonalCurveData() const;
const std::vector<double>& getDiagonalCurveData() const;
void setDiagonalCurveData(const std::vector<double>& p, DiagonalCurveType type);
void setFlatCurveData(const std::vector<double>& p, FlatCurveType type);
const std::vector<double>& getFlatCurveData() const;
FlatCurveType hasFlatCurveData() const;
private:
bool _hasIPTC;
rtengine::procparams::IPTCPairs iptc;
rtengine::procparams::PartialProfile partProfile;
const std::unique_ptr<rtengine::procparams::IPTCPairs> iptc;
const std::unique_ptr<rtengine::procparams::PartialProfile> partProfile;
DiagonalCurveType hasDiagonalCurveDataType;
FlatCurveType hasFlatCurveDataType;
std::vector<double> diagonalCurve;
std::vector<double> flatCurve;
public:
void setIPTC (const rtengine::procparams::IPTCPairs& iptcc)
{
iptc = iptcc;
_hasIPTC = true;
}
const rtengine::procparams::IPTCPairs& getIPTC ()
{
return iptc;
}
bool hasIPTC ()
{
return _hasIPTC;
}
void setPartialProfile (const rtengine::procparams::PartialProfile& pprofile);
const rtengine::procparams::PartialProfile& getPartialProfile ()
{
return partProfile;
};
void setProcParams (const rtengine::procparams::ProcParams& pparams);
const rtengine::procparams::ProcParams& getProcParams ()
{
return *partProfile.pparams;
}
const ParamsEdited& getParamsEdited ()
{
return *partProfile.pedited;
}
bool hasProcParams ()
{
return partProfile.pparams;
}
bool hasPEdited ()
{
return partProfile.pedited;
}
void setDiagonalCurveData (std::vector<double>& p, DiagonalCurveType type )
{
diagonalCurve = p;
hasDiagonalCurveDataType = type;
return;
}
const std::vector<double> & getDiagonalCurveData ()
{
return diagonalCurve;
}
DiagonalCurveType hasDiagonalCurveData ()
{
return hasDiagonalCurveDataType;
}
void setFlatCurveData (std::vector<double>& p, FlatCurveType type )
{
flatCurve = p;
hasFlatCurveDataType = type;
return;
}
const std::vector<double> & getFlatCurveData ()
{
return flatCurve;
}
FlatCurveType hasFlatCurveData ()
{
return hasFlatCurveDataType;
}
Clipboard ();
~Clipboard ();
};
extern Clipboard clipboard;

3
rtgui/coarsepanel.cc
View File

@ -17,8 +17,11 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "coarsepanel.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

6
rtgui/colorappearance.cc
View File

@ -16,10 +16,14 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "colorappearance.h"
#include <cmath>
#include "colorappearance.h"
#include "guiutils.h"
#include "../rtengine/color.h"
#include "../rtengine/procparams.h"
#define MINTEMP0 2000 //1200
#define MAXTEMP0 12000 //12000

3
rtgui/crop.cc
View File

@ -17,9 +17,12 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "crop.h"
#include "options.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

12
rtgui/crophandler.cc
View File

@ -23,13 +23,17 @@
#include "guiutils.h"
#include "cropwindow.h"
#include "imagearea.h"
#include "../rtengine/dcrop.h"
#include "../rtengine/procparams.h"
#include "../rtengine/refreshmap.h"
#include "../rtengine/rt_math.h"
using namespace rtengine;
CropHandler::CropHandler() :
cropParams(new procparams::CropParams),
colorParams(new procparams::ColorManagementParams),
zoom(100),
ww(0),
wh(0),
@ -123,8 +127,8 @@ bool CropHandler::isFullDisplay ()
double CropHandler::getFitCropZoom ()
{
double z1 = (double) wh / cropParams.h;
double z2 = (double) ww / cropParams.w;
double z1 = (double) wh / cropParams->h;
double z2 = (double) ww / cropParams->w;
return z1 < z2 ? z1 : z2;
}
@ -312,8 +316,8 @@ void CropHandler::setDetailedCrop(
cimg.lock ();
cropParams = cp;
colorParams = cmp;
*cropParams = cp;
*colorParams = cmp;
if (!cropimg.empty()) {
cropimg.clear();

5
rtgui/crophandler.h
View File

@ -21,6 +21,7 @@
#include <atomic>
#include <vector>
#include <memory>
#include <gtkmm.h>
@ -105,8 +106,8 @@ public:
void update ();
rtengine::procparams::CropParams cropParams;
rtengine::procparams::ColorManagementParams colorParams;
const std::unique_ptr<rtengine::procparams::CropParams> cropParams;
const std::unique_ptr<rtengine::procparams::ColorManagementParams> colorParams;
Glib::RefPtr<Gdk::Pixbuf> cropPixbuf; // image displayed on monitor, using the monitor profile (i.e. lab to monitor profile)
Glib::RefPtr<Gdk::Pixbuf> cropPixbuftrue; // internal image in output color space for analysis (i.e. lab to either Working profile or Output profile, depending on options.rtSettings.HistogramWorking)

287
rtgui/cropwindow.cc
View File

@ -16,21 +16,22 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "cropwindow.h"
#include <iomanip>
#include "../rtengine/mytime.h"
#include "../rtengine/rt_math.h"
#include "../rtengine/dcrop.h"
#include "cropwindow.h"
#include "guiutils.h"
#include "threadutils.h"
#include "rtimage.h"
#include "cursormanager.h"
#include "options.h"
#include "guiutils.h"
#include "imagearea.h"
#include "lockablecolorpicker.h"
#include "options.h"
#include "rtimage.h"
#include "threadutils.h"
#include "../rtengine/dcrop.h"
#include "../rtengine/mytime.h"
#include "../rtengine/procparams.h"
#include "../rtengine/rt_math.h"
using namespace rtengine;
@ -352,8 +353,8 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
} else {
if (onArea (CropImage, x, y)) { // events inside of the image domain
crop_custom_ratio = 0.f;
if ((bstate & GDK_SHIFT_MASK) && cropHandler.cropParams.w > 0 && cropHandler.cropParams.h > 0) {
crop_custom_ratio = float(cropHandler.cropParams.w) / float(cropHandler.cropParams.h);
if ((bstate & GDK_SHIFT_MASK) && cropHandler.cropParams->w > 0 && cropHandler.cropParams->h > 0) {
crop_custom_ratio = float(cropHandler.cropParams->w) / float(cropHandler.cropParams->h);
}
if (iarea->getToolMode () == TMColorPicker) {
@ -373,7 +374,7 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
// Add a new Color Picker
rtengine::Coord imgPos;
screenCoordToImage(x, y, imgPos.x, imgPos.y);
LockableColorPicker *newPicker = new LockableColorPicker(this, &cropHandler.colorParams.outputProfile, &cropHandler.colorParams.workingProfile);
LockableColorPicker *newPicker = new LockableColorPicker(this, &cropHandler.colorParams->outputProfile, &cropHandler.colorParams->workingProfile);
colorPickers.push_back(newPicker);
hoveredPicker = newPicker;
updateHoveredPicker(&imgPos);
@ -387,49 +388,49 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
} else if (onArea (CropTopLeft, x, y)) {
state = SResizeTL;
press_x = x;
action_x = cropHandler.cropParams.x;
action_x = cropHandler.cropParams->x;
press_y = y;
action_y = cropHandler.cropParams.y;
action_y = cropHandler.cropParams->y;
} else if (onArea (CropTopRight, x, y)) {
state = SResizeTR;
press_x = x;
action_x = cropHandler.cropParams.w;
action_x = cropHandler.cropParams->w;
press_y = y;
action_y = cropHandler.cropParams.y;
action_y = cropHandler.cropParams->y;
} else if (onArea (CropBottomLeft, x, y)) {
state = SResizeBL;
press_x = x;
action_x = cropHandler.cropParams.x;
action_x = cropHandler.cropParams->x;
press_y = y;
action_y = cropHandler.cropParams.h;
action_y = cropHandler.cropParams->h;
} else if (onArea (CropBottomRight, x, y)) {
state = SResizeBR;
press_x = x;
action_x = cropHandler.cropParams.w;
action_x = cropHandler.cropParams->w;
press_y = y;
action_y = cropHandler.cropParams.h;
action_y = cropHandler.cropParams->h;
} else if (onArea (CropTop, x, y)) {
state = SResizeH1;
press_y = y;
action_y = cropHandler.cropParams.y;
action_y = cropHandler.cropParams->y;
} else if (onArea (CropBottom, x, y)) {
state = SResizeH2;
press_y = y;
action_y = cropHandler.cropParams.h;
action_y = cropHandler.cropParams->h;
} else if (onArea (CropLeft, x, y)) {
state = SResizeW1;
press_x = x;
action_x = cropHandler.cropParams.x;
action_x = cropHandler.cropParams->x;
} else if (onArea (CropRight, x, y)) {
state = SResizeW2;
press_x = x;
action_x = cropHandler.cropParams.w;
action_x = cropHandler.cropParams->w;
} else if ((bstate & GDK_SHIFT_MASK) && onArea (CropInside, x, y)) {
state = SCropMove;
press_x = x;
press_y = y;
action_x = cropHandler.cropParams.x;
action_y = cropHandler.cropParams.y;
action_x = cropHandler.cropParams->x;
action_y = cropHandler.cropParams->y;
} else if (onArea (CropObserved, x, y)) {
state = SObservedMove;
press_x = x;
@ -450,11 +451,11 @@ void CropWindow::buttonPress (int button, int type, int bstate, int x, int y)
} else if (iarea->getToolMode () == TMCropSelect && cropgl) {
state = SCropSelecting;
screenCoordToImage (x, y, press_x, press_y);
cropHandler.cropParams.enabled = true;
cropHandler.cropParams.x = press_x;
cropHandler.cropParams.y = press_y;
cropHandler.cropParams.w = cropHandler.cropParams.h = 1;
cropgl->cropInit (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h);
cropHandler.cropParams->enabled = true;
cropHandler.cropParams->x = press_x;
cropHandler.cropParams->y = press_y;
cropHandler.cropParams->w = cropHandler.cropParams->h = 1;
cropgl->cropInit (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h);
} else if (iarea->getToolMode () == TMHand) {
if (editSubscriber) {
if ((cropgl && cropgl->inImageArea(iarea->posImage.x, iarea->posImage.y) && (editSubscriber->getEditingType() == ET_PIPETTE && (bstate & GDK_CONTROL_MASK))) || editSubscriber->getEditingType() == ET_OBJECTS) {
@ -827,57 +828,57 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
action_y = y;
iarea->redraw ();
} else if (state == SResizeH1 && cropgl) {
int oy = cropHandler.cropParams.y;
cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.h += oy - cropHandler.cropParams.y;
cropgl->cropHeight1Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
int oy = cropHandler.cropParams->y;
cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->h += oy - cropHandler.cropParams->y;
cropgl->cropHeight1Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SResizeH2 && cropgl) {
cropHandler.cropParams.h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropHeight2Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
cropHandler.cropParams->h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropHeight2Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SResizeW1 && cropgl) {
int ox = cropHandler.cropParams.x;
cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.w += ox - cropHandler.cropParams.x;
cropgl->cropWidth1Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
int ox = cropHandler.cropParams->x;
cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->w += ox - cropHandler.cropParams->x;
cropgl->cropWidth1Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SResizeW2 && cropgl) {
cropHandler.cropParams.w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropgl->cropWidth2Resized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
cropHandler.cropParams->w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropgl->cropWidth2Resized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SResizeTL && cropgl) {
int ox = cropHandler.cropParams.x;
cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.w += ox - cropHandler.cropParams.x;
int oy = cropHandler.cropParams.y;
cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.h += oy - cropHandler.cropParams.y;
cropgl->cropTopLeftResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
int ox = cropHandler.cropParams->x;
cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->w += ox - cropHandler.cropParams->x;
int oy = cropHandler.cropParams->y;
cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->h += oy - cropHandler.cropParams->y;
cropgl->cropTopLeftResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SResizeTR && cropgl) {
cropHandler.cropParams.w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
int oy = cropHandler.cropParams.y;
cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.h += oy - cropHandler.cropParams.y;
cropgl->cropTopRightResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
cropHandler.cropParams->w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
int oy = cropHandler.cropParams->y;
cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->h += oy - cropHandler.cropParams->y;
cropgl->cropTopRightResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SResizeBL && cropgl) {
int ox = cropHandler.cropParams.x;
cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.w += ox - cropHandler.cropParams.x;
cropHandler.cropParams.h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropBottomLeftResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
int ox = cropHandler.cropParams->x;
cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->w += ox - cropHandler.cropParams->x;
cropHandler.cropParams->h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropBottomLeftResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SResizeBR && cropgl) {
cropHandler.cropParams.w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropBottomRightResized (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h, crop_custom_ratio);
cropHandler.cropParams->w = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->h = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropBottomRightResized (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h, crop_custom_ratio);
iarea->redraw ();
} else if (state == SCropMove && cropgl) {
cropHandler.cropParams.x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams.y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropMoved (cropHandler.cropParams.x, cropHandler.cropParams.y, cropHandler.cropParams.w, cropHandler.cropParams.h);
cropHandler.cropParams->x = action_x + (x - press_x) / zoomSteps[cropZoom].zoom;
cropHandler.cropParams->y = action_y + (y - press_y) / zoomSteps[cropZoom].zoom;
cropgl->cropMoved (cropHandler.cropParams->x, cropHandler.cropParams->y, cropHandler.cropParams->w, cropHandler.cropParams->h);
iarea->redraw ();
} else if (state == SCropSelecting && cropgl) {
screenCoordToImage (x, y, action_x, action_y);
@ -886,19 +887,19 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
cropgl->cropResized (cx1, cy1, cx2, cy2);
if (cx2 > cx1) {
cropHandler.cropParams.x = cx1;
cropHandler.cropParams.w = cx2 - cx1 + 1;
cropHandler.cropParams->x = cx1;
cropHandler.cropParams->w = cx2 - cx1 + 1;
} else {
cropHandler.cropParams.x = cx2;
cropHandler.cropParams.w = cx1 - cx2 + 1;
cropHandler.cropParams->x = cx2;
cropHandler.cropParams->w = cx1 - cx2 + 1;
}
if (cy2 > cy1) {
cropHandler.cropParams.y = cy1;
cropHandler.cropParams.h = cy2 - cy1 + 1;
cropHandler.cropParams->y = cy1;
cropHandler.cropParams->h = cy2 - cy1 + 1;
} else {
cropHandler.cropParams.y = cy2;
cropHandler.cropParams.h = cy1 - cy2 + 1;
cropHandler.cropParams->y = cy2;
cropHandler.cropParams->h = cy1 - cy2 + 1;
}
iarea->redraw ();
@ -1018,17 +1019,17 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
if (!onArea (CropImage, x, y) || !cropHandler.cropPixbuftrue) {
cropHandler.getFullImageSize(mx, my);
// pmlistener->pointerMoved (false, cropHandler.colorParams.working, mx, my, -1, -1, -1);
// if (pmhlistener) pmhlistener->pointerMoved (false, cropHandler.colorParams.working, mx, my, -1, -1, -1);
// pmlistener->pointerMoved (false, cropHandler.colorParams->working, mx, my, -1, -1, -1);
// if (pmhlistener) pmhlistener->pointerMoved (false, cropHandler.colorParams->working, mx, my, -1, -1, -1);
/* Glib::ustring outputProfile;
outputProfile =cropHandler.colorParams.output ;
outputProfile =cropHandler.colorParams->output ;
printf("Using \"%s\" output\n", outputProfile.c_str());
if(outputProfile==options.rtSettings.srgb) printf("OK SRGB2");
*/
pmlistener->pointerMoved (false, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, -1, -1, -1);
pmlistener->pointerMoved (false, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, -1, -1, -1);
if (pmhlistener) {
pmhlistener->pointerMoved (false, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, -1, -1, -1);
pmhlistener->pointerMoved (false, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, -1, -1, -1);
}
} else {
@ -1075,11 +1076,11 @@ void CropWindow::pointerMoved (int bstate, int x, int y)
// Updates the Navigator
// TODO: possible double color conversion if rval, gval, bval come from cropHandler.cropPixbuftrue ? see issue #4583
pmlistener->pointerMoved (true, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, rval, gval, bval, isRaw);
pmlistener->pointerMoved (true, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, rval, gval, bval, isRaw);
if (pmhlistener) {
// Updates the HistogramRGBArea
pmhlistener->pointerMoved (true, cropHandler.colorParams.outputProfile, cropHandler.colorParams.workingProfile, mx, my, rval, gval, bval);
pmhlistener->pointerMoved (true, cropHandler.colorParams->outputProfile, cropHandler.colorParams->workingProfile, mx, my, rval, gval, bval);
}
}
}
@ -1119,87 +1120,87 @@ bool CropWindow::onArea (CursorArea a, int x, int y)
case CropTopLeft:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
y1 >= cropHandler.cropParams.y - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams.y + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
y1 >= cropHandler.cropParams->y - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams->y + CROPRESIZEBORDER &&
y >= ypos + imgY &&
x1 >= cropHandler.cropParams.x - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams.x + CROPRESIZEBORDER &&
x1 >= cropHandler.cropParams->x - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams->x + CROPRESIZEBORDER &&
x >= xpos + imgX;
case CropTopRight:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
y1 >= cropHandler.cropParams.y - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams.y + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
y1 >= cropHandler.cropParams->y - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams->y + CROPRESIZEBORDER &&
y >= ypos + imgY &&
x1 >= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 + CROPRESIZEBORDER &&
x1 >= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 + CROPRESIZEBORDER &&
x < xpos + imgX + imgW;
case CropBottomLeft:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
y1 >= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
y1 >= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 + CROPRESIZEBORDER &&
y < ypos + imgY + imgH &&
x1 >= cropHandler.cropParams.x - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams.x + CROPRESIZEBORDER &&
x1 >= cropHandler.cropParams->x - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams->x + CROPRESIZEBORDER &&
x >= xpos + imgX;
case CropBottomRight:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
y1 >= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams.y + cropHandler.cropParams.h - 1 + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
y1 >= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
y1 <= cropHandler.cropParams->y + cropHandler.cropParams->h - 1 + CROPRESIZEBORDER &&
y < ypos + imgY + imgH &&
x1 >= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams.x + cropHandler.cropParams.w - 1 + CROPRESIZEBORDER &&
x1 >= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
x1 <= cropHandler.cropParams->x + cropHandler.cropParams->w - 1 + CROPRESIZEBORDER &&
x < xpos + imgX + imgW;
case CropTop:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
x1 > cropHandler.cropParams.x + CROPRESIZEBORDER &&
x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
y1 > cropHandler.cropParams.y - CROPRESIZEBORDER &&
y1 < cropHandler.cropParams.y + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
x1 > cropHandler.cropParams->x + CROPRESIZEBORDER &&
x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
y1 > cropHandler.cropParams->y - CROPRESIZEBORDER &&
y1 < cropHandler.cropParams->y + CROPRESIZEBORDER &&
y >= ypos + imgY;
case CropBottom:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
x1 > cropHandler.cropParams.x + CROPRESIZEBORDER &&
x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
y1 > cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
x1 > cropHandler.cropParams->x + CROPRESIZEBORDER &&
x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
y1 > cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 + CROPRESIZEBORDER &&
y < ypos + imgY + imgH;
case CropLeft:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
y1 > cropHandler.cropParams.y + CROPRESIZEBORDER &&
y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
x1 > cropHandler.cropParams.x - CROPRESIZEBORDER &&
x1 < cropHandler.cropParams.x + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
y1 > cropHandler.cropParams->y + CROPRESIZEBORDER &&
y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
x1 > cropHandler.cropParams->x - CROPRESIZEBORDER &&
x1 < cropHandler.cropParams->x + CROPRESIZEBORDER &&
x >= xpos + imgX;
case CropRight:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
y1 > cropHandler.cropParams.y + CROPRESIZEBORDER &&
y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 - CROPRESIZEBORDER &&
x1 > cropHandler.cropParams.x + cropHandler.cropParams.w - 1 - CROPRESIZEBORDER &&
x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1 + CROPRESIZEBORDER &&
return cropHandler.cropParams->enabled &&
y1 > cropHandler.cropParams->y + CROPRESIZEBORDER &&
y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 - CROPRESIZEBORDER &&
x1 > cropHandler.cropParams->x + cropHandler.cropParams->w - 1 - CROPRESIZEBORDER &&
x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1 + CROPRESIZEBORDER &&
x < xpos + imgX + imgW;
case CropInside:
screenCoordToImage (x, y, x1, y1);
return cropHandler.cropParams.enabled &&
y1 > cropHandler.cropParams.y &&
y1 < cropHandler.cropParams.y + cropHandler.cropParams.h - 1 &&
x1 > cropHandler.cropParams.x &&
x1 < cropHandler.cropParams.x + cropHandler.cropParams.w - 1;
return cropHandler.cropParams->enabled &&
y1 > cropHandler.cropParams->y &&
y1 < cropHandler.cropParams->y + cropHandler.cropParams->h - 1 &&
x1 > cropHandler.cropParams->x &&
x1 < cropHandler.cropParams->x + cropHandler.cropParams->w - 1;
case CropResize:
return decorated && x >= xpos + width - 16 && y >= ypos + height - 16 && x < xpos + width && y < ypos + height;
@ -1367,7 +1368,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
Gdk::Cairo::set_source_pixbuf(cr, rough, posX, posY);
cr->rectangle(posX, posY, rtengine::min (rough->get_width (), imgAreaW-imgX), rtengine::min (rough->get_height (), imgAreaH-imgY));
cr->fill();
// if (cropHandler.cropParams.enabled)
// if (cropHandler.cropParams->enabled)
// drawCrop (cr, x+imgX, y+imgY, imgW, imgH, cropX, cropY, zoomSteps[cropZoom].zoom, cropHandler.cropParams);
}
@ -1375,7 +1376,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
drawObservedFrame (cr);
}
} else {
CropParams cropParams = cropHandler.cropParams;
CropParams cropParams = *cropHandler.cropParams;
if (state == SNormal) {
switch (options.cropGuides) {
case Options::CROP_GUIDE_NONE:
@ -1805,7 +1806,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
cr->fill();
}
if (cropHandler.cropParams.enabled) {
if (cropHandler.cropParams->enabled) {
int cropX, cropY;
cropHandler.getPosition (cropX, cropY);
drawCrop (cr, x + imgAreaX + imgX, y + imgAreaY + imgY, imgW, imgH, cropX, cropY, zoomSteps[cropZoom].zoom, cropParams, (this == iarea->mainCropWindow), useBgColor, cropHandler.isFullDisplay ());
@ -1888,7 +1889,7 @@ void CropWindow::expose (Cairo::RefPtr<Cairo::Context> cr)
cr->rectangle(posX, posY, rtengine::min (rough->get_width (), imgAreaW-imgX), rtengine::min (rough->get_height (), imgAreaH-imgY));
cr->fill();
if (cropHandler.cropParams.enabled) {
if (cropHandler.cropParams->enabled) {
drawCrop (cr, x + imgAreaX + imgX, y + imgAreaY + imgY, rough->get_width(), rough->get_height(), cropX, cropY, zoomSteps[cropZoom].zoom, cropParams, (this == iarea->mainCropWindow), useBgColor, cropHandler.isFullDisplay ());
}
@ -1947,9 +1948,9 @@ void CropWindow::zoomIn (bool toCursor, int cursorX, int cursorY)
y = cursorY;
} else {
if (zoomSteps[cropZoom].zoom <= cropHandler.getFitZoom()) {
if (cropHandler.cropParams.enabled) {
x = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
y = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
if (cropHandler.cropParams->enabled) {
x = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
y = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
} else {
int fw, fh;
cropHandler.getFullImageSize(fw, fh);
@ -1961,11 +1962,11 @@ void CropWindow::zoomIn (bool toCursor, int cursorX, int cursorY)
} else if (zoomVersion != exposeVersion) {
screenCoordToImage(xpos + imgX + imgW / 2, ypos + imgY + imgH / 2, x, y);
if (cropHandler.cropParams.enabled) {
if (cropHandler.cropParams->enabled) {
// add some gravity towards crop center
int x1 = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
int y1 = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
double cropd = sqrt(cropHandler.cropParams.h * cropHandler.cropParams.h + cropHandler.cropParams.w * cropHandler.cropParams.w) * zoomSteps[cropZoom].zoom;
int x1 = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
int y1 = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
double cropd = sqrt(cropHandler.cropParams->h * cropHandler.cropParams->h + cropHandler.cropParams->w * cropHandler.cropParams->w) * zoomSteps[cropZoom].zoom;
double imd = sqrt(imgW * imgW + imgH * imgH);
double d;
@ -2023,9 +2024,9 @@ void CropWindow::zoom11 (bool notify)
int y = -1;
if (zoomSteps[cropZoom].zoom <= cropHandler.getFitZoom()) {
if (cropHandler.cropParams.enabled) {
x = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
y = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
if (cropHandler.cropParams->enabled) {
x = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
y = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
} else {
int fw, fh;
cropHandler.getFullImageSize(fw, fh);
@ -2114,7 +2115,7 @@ void CropWindow::zoomFit ()
void CropWindow::zoomFitCrop ()
{
if(cropHandler.cropParams.enabled) {
if(cropHandler.cropParams->enabled) {
double z = cropHandler.getFitCropZoom ();
int cz = int(zoomSteps.size())-1;
@ -2129,8 +2130,8 @@ void CropWindow::zoomFitCrop ()
zoomVersion = exposeVersion;
int centerX, centerY;
centerX = cropHandler.cropParams.x + cropHandler.cropParams.w / 2;
centerY = cropHandler.cropParams.y + cropHandler.cropParams.h / 2;
centerX = cropHandler.cropParams->x + cropHandler.cropParams->w / 2;
centerY = cropHandler.cropParams->y + cropHandler.cropParams->h / 2;
setCropAnchorPosition(centerX, centerY);
changeZoom (cz, true, centerX, centerY);
fitZoom = options.cropAutoFit;

10
rtgui/darkframe.cc
View File

@ -16,12 +16,16 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "darkframe.h"
#include "options.h"
#include "guiutils.h"
#include <sstream>
#include "darkframe.h"
#include "guiutils.h"
#include "options.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

7
rtgui/defringe.cc
View File

@ -16,9 +16,12 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "defringe.h"
#include <iomanip>
#include <cmath>
#include <iomanip>
#include "defringe.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

10
rtgui/dehaze.cc
View File

@ -17,10 +17,14 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "dehaze.h"
#include "eventmapper.h"
#include <iomanip>
#include <cmath>
#include <iomanip>
#include "dehaze.h"
#include "eventmapper.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

8
rtgui/dirpyrdenoise.cc
View File

@ -16,12 +16,16 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "dirpyrdenoise.h"
#include <iomanip>
#include <cmath>
#include <iomanip>
#include "dirpyrdenoise.h"
#include "edit.h"
#include "guiutils.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;
extern Options options;

6
rtgui/distortion.cc
View File

@ -16,10 +16,14 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "distortion.h"
#include <iomanip>
#include "distortion.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

7
rtgui/epd.cc
View File

@ -16,9 +16,12 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "epd.h"
#include <iomanip>
#include <cmath>
#include <iomanip>
#include "epd.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

26
rtgui/exifpanel.cc
View File

@ -21,13 +21,17 @@
#include "guiutils.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;
using namespace rtexif;
ExifPanel::ExifPanel () : idata (nullptr)
ExifPanel::ExifPanel() :
idata(nullptr),
changeList(new rtengine::procparams::ExifPairs),
defChangeList(new rtengine::procparams::ExifPairs)
{
recursiveOp = true;
exifTree = Gtk::manage (new Gtk::TreeView());
@ -166,7 +170,7 @@ void ExifPanel::read (const ProcParams* pp, const ParamsEdited* pedited)
disableListener ();
changeList = pp->exif;
*changeList = pp->exif;
setImageData (idata);
applyChangeList ();
exifSelectionChanged ();
@ -178,13 +182,13 @@ void ExifPanel::write (ProcParams* pp, ParamsEdited* pedited)
{
// updateChangeList ();
pp->exif = changeList;
pp->exif = *changeList;
}
void ExifPanel::setDefaults (const ProcParams* defParams, const ParamsEdited* pedited)
{
defChangeList = defParams->exif;
*defChangeList = defParams->exif;
}
void ExifPanel::setImageData (const FramesMetaData* id)
@ -457,7 +461,7 @@ void ExifPanel::resetAllPressed ()
{
setImageData (idata);
changeList = defChangeList;
*changeList = *defChangeList;
applyChangeList ();
exifSelectionChanged ();
notifyListener ();
@ -661,11 +665,11 @@ void ExifPanel::updateChangeList (Gtk::TreeModel::Children root, std::string pre
for (iter = root.begin(); iter != root.end(); ++iter) {
if (iter->get_value (exifColumns.edited)) {
changeList[ prefix + iter->get_value (exifColumns.field_nopango) ] = iter->get_value (exifColumns.value_nopango);
(*changeList)[ prefix + iter->get_value (exifColumns.field_nopango) ] = iter->get_value (exifColumns.value_nopango);
} else if (iter->get_value (exifColumns.action) == AC_WRITE && iter->get_value (exifColumns.icon) == delicon) {
changeList[ prefix + iter->get_value (exifColumns.field_nopango) ] = "#delete";
(*changeList)[ prefix + iter->get_value (exifColumns.field_nopango) ] = "#delete";
} else if (iter->get_value (exifColumns.action) == AC_DONTWRITE && iter->get_value (exifColumns.icon) == keepicon) {
changeList[ prefix + iter->get_value (exifColumns.field_nopango) ] = "#keep";
(*changeList)[ prefix + iter->get_value (exifColumns.field_nopango) ] = "#keep";
}
if (iter->get_value (exifColumns.icon) == keepicon) {
@ -677,14 +681,14 @@ void ExifPanel::updateChangeList (Gtk::TreeModel::Children root, std::string pre
void ExifPanel::updateChangeList ()
{
changeList.clear ();
changeList->clear ();
updateChangeList (exifTreeModel->children(), "");
}
void ExifPanel::applyChangeList ()
{
for (rtengine::procparams::ExifPairs::iterator i = changeList.begin(); i != changeList.end(); ++i) {
for (rtengine::procparams::ExifPairs::const_iterator i = changeList->begin(); i != changeList->end(); ++i) {
editTag (exifTreeModel->children(), i->first, i->second);
}
}

7
rtgui/exifpanel.h
View File

@ -19,7 +19,10 @@
#ifndef _EXIFPANEL_
#define _EXIFPANEL_
#include <memory>
#include <gtkmm.h>
#include "toolpanel.h"
class ExifPanel : public Gtk::VBox, public ToolPanel
@ -27,8 +30,8 @@ class ExifPanel : public Gtk::VBox, public ToolPanel
private:
const rtengine::FramesMetaData* idata;
rtengine::procparams::ExifPairs changeList;
rtengine::procparams::ExifPairs defChangeList;
const std::unique_ptr<rtengine::procparams::ExifPairs> changeList;
const std::unique_ptr<rtengine::procparams::ExifPairs> defChangeList;
bool recursiveOp;
class ExifColumns : public Gtk::TreeModelColumnRecord

2
rtgui/exportpanel.cc
View File

@ -22,6 +22,8 @@
#include "options.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

11
rtgui/fattaltonemap.cc
View File

@ -17,10 +17,15 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "fattaltonemap.h"
#include "eventmapper.h"
#include <iomanip>
#include <cmath>
#include <iomanip>
#include "fattaltonemap.h"
#include "eventmapper.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

19
rtgui/filebrowser.cc
View File

@ -18,19 +18,24 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "filebrowser.h"
#include <map>
#include <glibmm.h>
#include "options.h"
#include "multilangmgr.h"
#include "clipboard.h"
#include "procparamchangers.h"
#include "filebrowser.h"
#include "batchqueue.h"
#include "../rtengine/dfmanager.h"
#include "../rtengine/ffmanager.h"
#include "clipboard.h"
#include "multilangmgr.h"
#include "options.h"
#include "procparamchangers.h"
#include "rtimage.h"
#include "threadutils.h"
#include "../rtengine/dfmanager.h"
#include "../rtengine/ffmanager.h"
#include "../rtengine/procparams.h"
extern Options options;
namespace

236
rtgui/filebrowserentry.cc
View File

@ -18,15 +18,17 @@
*/
#include "filebrowserentry.h"
#include <iomanip>
#include <cstring>
#include <iomanip>
#include "guiutils.h"
#include "threadutils.h"
#include "rtimage.h"
#include "cursormanager.h"
#include "thumbbrowserbase.h"
#include "guiutils.h"
#include "inspector.h"
#include "rtimage.h"
#include "threadutils.h"
#include "thumbbrowserbase.h"
#include "../rtengine/procparams.h"
#define CROPRESIZEBORDER 4
@ -40,7 +42,7 @@ Glib::RefPtr<Gdk::Pixbuf> FileBrowserEntry::hdr;
Glib::RefPtr<Gdk::Pixbuf> FileBrowserEntry::ps;
FileBrowserEntry::FileBrowserEntry (Thumbnail* thm, const Glib::ustring& fname)
: ThumbBrowserEntryBase (fname), wasInside(false), iatlistener(nullptr), press_x(0), press_y(0), action_x(0), action_y(0), rot_deg(0.0), landscape(true), cropgl(nullptr), state(SNormal), crop_custom_ratio(0.f)
: ThumbBrowserEntryBase (fname), wasInside(false), iatlistener(nullptr), press_x(0), press_y(0), action_x(0), action_y(0), rot_deg(0.0), landscape(true), cropParams(new rtengine::procparams::CropParams), cropgl(nullptr), state(SNormal), crop_custom_ratio(0.f)
{
thumbnail = thm;
@ -163,9 +165,9 @@ std::vector<Glib::RefPtr<Gdk::Pixbuf> > FileBrowserEntry::getSpecificityIconsOnI
void FileBrowserEntry::customBackBufferUpdate (Cairo::RefPtr<Cairo::Context> c)
{
if(scale != 1.0 && cropParams.enabled) { // somewhere in pipeline customBackBufferUpdate is called when scale == 1.0, which is nonsense for a thumb
if(scale != 1.0 && cropParams->enabled) { // somewhere in pipeline customBackBufferUpdate is called when scale == 1.0, which is nonsense for a thumb
if (state == SCropSelecting || state == SResizeH1 || state == SResizeH2 || state == SResizeW1 || state == SResizeW2 || state == SResizeTL || state == SResizeTR || state == SResizeBL || state == SResizeBR || state == SCropMove) {
drawCrop (c, prex, prey, prew, preh, 0, 0, scale, cropParams, true, false);
drawCrop (c, prex, prey, prew, preh, 0, 0, scale, *cropParams, true, false);
} else {
rtengine::procparams::CropParams cparams = thumbnail->getProcParams().crop;
switch (options.cropGuides) {
@ -246,7 +248,7 @@ void FileBrowserEntry::_updateImage(rtengine::IImage8* img, double s, const rten
redrawRequests--;
scale = s;
this->cropParams = cropParams;
*this->cropParams = cropParams;
bool newLandscape = img->getWidth() > img->getHeight();
bool rotated = false;
@ -319,65 +321,65 @@ bool FileBrowserEntry::motionNotify (int x, int y)
action_y = y;
parent->redrawNeeded (this);
} else if (state == SResizeH1 && cropgl) {
int oy = cropParams.y;
cropParams.y = action_y + (y - press_y) / scale;
cropParams.h += oy - cropParams.y;
cropgl->cropHeight1Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
int oy = cropParams->y;
cropParams->y = action_y + (y - press_y) / scale;
cropParams->h += oy - cropParams->y;
cropgl->cropHeight1Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SResizeH2 && cropgl) {
cropParams.h = action_y + (y - press_y) / scale;
cropgl->cropHeight2Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
cropParams->h = action_y + (y - press_y) / scale;
cropgl->cropHeight2Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SResizeW1 && cropgl) {
int ox = cropParams.x;
cropParams.x = action_x + (x - press_x) / scale;
cropParams.w += ox - cropParams.x;
cropgl->cropWidth1Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
int ox = cropParams->x;
cropParams->x = action_x + (x - press_x) / scale;
cropParams->w += ox - cropParams->x;
cropgl->cropWidth1Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SResizeW2 && cropgl) {
cropParams.w = action_x + (x - press_x) / scale;
cropgl->cropWidth2Resized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
cropParams->w = action_x + (x - press_x) / scale;
cropgl->cropWidth2Resized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SResizeTL && cropgl) {
int ox = cropParams.x;
cropParams.x = action_x + (x - press_x) / scale;
cropParams.w += ox - cropParams.x;
int oy = cropParams.y;
cropParams.y = action_y + (y - press_y) / scale;
cropParams.h += oy - cropParams.y;
cropgl->cropTopLeftResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
int ox = cropParams->x;
cropParams->x = action_x + (x - press_x) / scale;
cropParams->w += ox - cropParams->x;
int oy = cropParams->y;
cropParams->y = action_y + (y - press_y) / scale;
cropParams->h += oy - cropParams->y;
cropgl->cropTopLeftResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SResizeTR && cropgl) {
cropParams.w = action_x + (x - press_x) / scale;
int oy = cropParams.y;
cropParams.y = action_y + (y - press_y) / scale;
cropParams.h += oy - cropParams.y;
cropgl->cropTopRightResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
cropParams->w = action_x + (x - press_x) / scale;
int oy = cropParams->y;
cropParams->y = action_y + (y - press_y) / scale;
cropParams->h += oy - cropParams->y;
cropgl->cropTopRightResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SResizeBL && cropgl) {
int ox = cropParams.x;
cropParams.x = action_x + (x - press_x) / scale;
cropParams.w += ox - cropParams.x;
cropParams.h = action_y + (y - press_y) / scale;
cropgl->cropBottomLeftResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
int ox = cropParams->x;
cropParams->x = action_x + (x - press_x) / scale;
cropParams->w += ox - cropParams->x;
cropParams->h = action_y + (y - press_y) / scale;
cropgl->cropBottomLeftResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SResizeBR && cropgl) {
cropParams.w = action_x + (x - press_x) / scale;
cropParams.h = action_y + (y - press_y) / scale;
cropgl->cropBottomRightResized (cropParams.x, cropParams.y, cropParams.w, cropParams.h, crop_custom_ratio);
cropParams->w = action_x + (x - press_x) / scale;
cropParams->h = action_y + (y - press_y) / scale;
cropgl->cropBottomRightResized (cropParams->x, cropParams->y, cropParams->w, cropParams->h, crop_custom_ratio);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SCropMove && cropgl) {
cropParams.x = action_x + (x - press_x) / scale;
cropParams.y = action_y + (y - press_y) / scale;
cropgl->cropMoved (cropParams.x, cropParams.y, cropParams.w, cropParams.h);
cropParams->x = action_x + (x - press_x) / scale;
cropParams->y = action_y + (y - press_y) / scale;
cropgl->cropMoved (cropParams->x, cropParams->y, cropParams->w, cropParams->h);
updateBackBuffer ();
parent->redrawNeeded (this);
} else if (state == SCropSelecting && cropgl) {
@ -386,19 +388,19 @@ bool FileBrowserEntry::motionNotify (int x, int y)
cropgl->cropResized (cx1, cy1, cx2, cy2);
if (cx2 > cx1) {
cropParams.x = cx1;
cropParams.w = cx2 - cx1 + 1;
cropParams->x = cx1;
cropParams->w = cx2 - cx1 + 1;
} else {
cropParams.x = cx2;
cropParams.w = cx1 - cx2 + 1;
cropParams->x = cx2;
cropParams->w = cx1 - cx2 + 1;
}
if (cy2 > cy1) {
cropParams.y = cy1;
cropParams.h = cy2 - cy1 + 1;
cropParams->y = cy1;
cropParams->h = cy2 - cy1 + 1;
} else {
cropParams.y = cy2;
cropParams.h = cy1 - cy2 + 1;
cropParams->y = cy2;
cropParams->h = cy1 - cy2 + 1;
}
updateBackBuffer ();
@ -429,71 +431,71 @@ bool FileBrowserEntry::pressNotify (int button, int type, int bstate, int x, i
if (!b && selected && inside (x, y)) {
if (button == 1 && type == GDK_BUTTON_PRESS && state == SNormal) {
if ((bstate & GDK_SHIFT_MASK) && cropParams.w > 0 && cropParams.h > 0) {
crop_custom_ratio = float(cropParams.w) / float(cropParams.h);
if ((bstate & GDK_SHIFT_MASK) && cropParams->w > 0 && cropParams->h > 0) {
crop_custom_ratio = float(cropParams->w) / float(cropParams->h);
}
if (onArea (CropTopLeft, ix, iy)) {
state = SResizeTL;
press_x = x;
action_x = cropParams.x;
action_x = cropParams->x;
press_y = y;
action_y = cropParams.y;
action_y = cropParams->y;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropTopRight, ix, iy)) {
state = SResizeTR;
press_x = x;
action_x = cropParams.w;
action_x = cropParams->w;
press_y = y;
action_y = cropParams.y;
action_y = cropParams->y;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropBottomLeft, ix, iy)) {
state = SResizeBL;
press_x = x;
action_x = cropParams.x;
action_x = cropParams->x;
press_y = y;
action_y = cropParams.h;
action_y = cropParams->h;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropBottomRight, ix, iy)) {
state = SResizeBR;
press_x = x;
action_x = cropParams.w;
action_x = cropParams->w;
press_y = y;
action_y = cropParams.h;
action_y = cropParams->h;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropTop, ix, iy)) {
state = SResizeH1;
press_y = y;
action_y = cropParams.y;
action_y = cropParams->y;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropBottom, ix, iy)) {
state = SResizeH2;
press_y = y;
action_y = cropParams.h;
action_y = cropParams->h;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropLeft, ix, iy)) {
state = SResizeW1;
press_x = x;
action_x = cropParams.x;
action_x = cropParams->x;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropRight, ix, iy)) {
state = SResizeW2;
press_x = x;
action_x = cropParams.w;
action_x = cropParams->w;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if ((bstate & GDK_SHIFT_MASK) && onArea (CropInside, ix, iy)) {
state = SCropMove;
press_x = x;
press_y = y;
action_x = cropParams.x;
action_y = cropParams.y;
action_x = cropParams->x;
action_y = cropParams->y;
cropgl = iatlistener->startCropEditing (thumbnail);
b = true;
} else if (onArea (CropImage, ix, iy)) {
@ -513,10 +515,10 @@ bool FileBrowserEntry::pressNotify (int button, int type, int bstate, int x, i
if (cropgl) {
state = SCropSelecting;
press_x = cropParams.x = (ix - prex) / scale;
press_y = cropParams.y = (iy - prey) / scale;
cropParams.w = cropParams.h = 1;
cropgl->cropInit (cropParams.x, cropParams.y, cropParams.w, cropParams.h);
press_x = cropParams->x = (ix - prex) / scale;
press_y = cropParams->y = (iy - prey) / scale;
cropParams->w = cropParams->h = 1;
cropgl->cropInit (cropParams->x, cropParams->y, cropParams->w, cropParams->h);
b = true;
}
}
@ -582,67 +584,67 @@ bool FileBrowserEntry::onArea (CursorArea a, int x, int y)
return x >= prex && x < prex + prew && y >= prey && y < prey + preh;
case CropTopLeft:
return cropParams.enabled &&
y1 >= cropParams.y - cropResizeBorder &&
y1 <= cropParams.y + cropResizeBorder &&
x1 >= cropParams.x - cropResizeBorder &&
x1 <= cropParams.x + cropResizeBorder;
return cropParams->enabled &&
y1 >= cropParams->y - cropResizeBorder &&
y1 <= cropParams->y + cropResizeBorder &&
x1 >= cropParams->x - cropResizeBorder &&
x1 <= cropParams->x + cropResizeBorder;
case CropTopRight:
return cropParams.enabled &&
y1 >= cropParams.y - cropResizeBorder &&
y1 <= cropParams.y + cropResizeBorder &&
x1 >= cropParams.x + cropParams.w - 1 - cropResizeBorder &&
x1 <= cropParams.x + cropParams.w - 1 + cropResizeBorder;
return cropParams->enabled &&
y1 >= cropParams->y - cropResizeBorder &&
y1 <= cropParams->y + cropResizeBorder &&
x1 >= cropParams->x + cropParams->w - 1 - cropResizeBorder &&
x1 <= cropParams->x + cropParams->w - 1 + cropResizeBorder;
case CropBottomLeft:
return cropParams.enabled &&
y1 >= cropParams.y + cropParams.h - 1 - cropResizeBorder &&
y1 <= cropParams.y + cropParams.h - 1 + cropResizeBorder &&
x1 >= cropParams.x - cropResizeBorder &&
x1 <= cropParams.x + cropResizeBorder;
return cropParams->enabled &&
y1 >= cropParams->y + cropParams->h - 1 - cropResizeBorder &&
y1 <= cropParams->y + cropParams->h - 1 + cropResizeBorder &&
x1 >= cropParams->x - cropResizeBorder &&
x1 <= cropParams->x + cropResizeBorder;
case CropBottomRight:
return cropParams.enabled &&
y1 >= cropParams.y + cropParams.h - 1 - cropResizeBorder &&
y1 <= cropParams.y + cropParams.h - 1 + cropResizeBorder &&
x1 >= cropParams.x + cropParams.w - 1 - cropResizeBorder &&
x1 <= cropParams.x + cropParams.w - 1 + cropResizeBorder;
return cropParams->enabled &&
y1 >= cropParams->y + cropParams->h - 1 - cropResizeBorder &&
y1 <= cropParams->y + cropParams->h - 1 + cropResizeBorder &&
x1 >= cropParams->x + cropParams->w - 1 - cropResizeBorder &&
x1 <= cropParams->x + cropParams->w - 1 + cropResizeBorder;
case CropTop:
return cropParams.enabled &&
x1 > cropParams.x + cropResizeBorder &&
x1 < cropParams.x + cropParams.w - 1 - cropResizeBorder &&
y1 > cropParams.y - cropResizeBorder &&
y1 < cropParams.y + cropResizeBorder;
return cropParams->enabled &&
x1 > cropParams->x + cropResizeBorder &&
x1 < cropParams->x + cropParams->w - 1 - cropResizeBorder &&
y1 > cropParams->y - cropResizeBorder &&
y1 < cropParams->y + cropResizeBorder;
case CropBottom:
return cropParams.enabled &&
x1 > cropParams.x + cropResizeBorder &&
x1 < cropParams.x + cropParams.w - 1 - cropResizeBorder &&
y1 > cropParams.y + cropParams.h - 1 - cropResizeBorder &&
y1 < cropParams.y + cropParams.h - 1 + cropResizeBorder;
return cropParams->enabled &&
x1 > cropParams->x + cropResizeBorder &&
x1 < cropParams->x + cropParams->w - 1 - cropResizeBorder &&
y1 > cropParams->y + cropParams->h - 1 - cropResizeBorder &&
y1 < cropParams->y + cropParams->h - 1 + cropResizeBorder;
case CropLeft:
return cropParams.enabled &&
y1 > cropParams.y + cropResizeBorder &&
y1 < cropParams.y + cropParams.h - 1 - cropResizeBorder &&
x1 > cropParams.x - cropResizeBorder &&
x1 < cropParams.x + cropResizeBorder;
return cropParams->enabled &&
y1 > cropParams->y + cropResizeBorder &&
y1 < cropParams->y + cropParams->h - 1 - cropResizeBorder &&
x1 > cropParams->x - cropResizeBorder &&
x1 < cropParams->x + cropResizeBorder;
case CropRight:
return cropParams.enabled &&
y1 > cropParams.y + cropResizeBorder &&
y1 < cropParams.y + cropParams.h - 1 - cropResizeBorder &&
x1 > cropParams.x + cropParams.w - 1 - cropResizeBorder &&
x1 < cropParams.x + cropParams.w - 1 + cropResizeBorder;
return cropParams->enabled &&
y1 > cropParams->y + cropResizeBorder &&
y1 < cropParams->y + cropParams->h - 1 - cropResizeBorder &&
x1 > cropParams->x + cropParams->w - 1 - cropResizeBorder &&
x1 < cropParams->x + cropParams->w - 1 + cropResizeBorder;
case CropInside:
return cropParams.enabled &&
y1 > cropParams.y &&
y1 < cropParams.y + cropParams.h - 1 &&
x1 > cropParams.x &&
x1 < cropParams.x + cropParams.w - 1;
return cropParams->enabled &&
y1 > cropParams->y &&
y1 < cropParams->y + cropParams->h - 1 &&
x1 > cropParams->x &&
x1 < cropParams->x + cropParams->w - 1;
default: /* do nothing */ ;
}

3
rtgui/filebrowserentry.h
View File

@ -20,6 +20,7 @@
#define _FILEBROWSERENTRY_
#include <atomic>
#include <memory>
#include <gtkmm.h>
@ -55,7 +56,7 @@ class FileBrowserEntry : public ThumbBrowserEntryBase,
int press_x, press_y, action_x, action_y;
double rot_deg;
bool landscape;
rtengine::procparams::CropParams cropParams;
const std::unique_ptr<rtengine::procparams::CropParams> cropParams;
CropGUIListener* cropgl;
FileBrowserEntryIdleHelper* feih;

2
rtgui/filecatalog.cc
View File

@ -1187,7 +1187,7 @@ void FileCatalog::developRequested(const std::vector<FileBrowserEntry*>& tbe, bo
params.icm.inputProfile = options.fastexport_icm_input_profile;
params.icm.workingProfile = options.fastexport_icm_working_profile;
params.icm.outputProfile = options.fastexport_icm_output_profile;
params.icm.outputIntent = options.fastexport_icm_outputIntent;
params.icm.outputIntent = rtengine::RenderingIntent(options.fastexport_icm_outputIntent);
params.icm.outputBPC = options.fastexport_icm_outputBPC;
}

5
rtgui/filmsimulation.cc
View File

@ -1,12 +1,13 @@
#include <chrono>
#include <map>
#include <set>
#include "filmsimulation.h"
#include <chrono>
#include "options.h"
#include "../rtengine/clutstore.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

10
rtgui/flatfield.cc
View File

@ -16,12 +16,16 @@
* You should have received a copy of the GNU General Public License
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "flatfield.h"
#include "options.h"
#include "guiutils.h"
#include <sstream>
#include "flatfield.h"
#include "guiutils.h"
#include "options.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

3
rtgui/gradient.cc
View File

@ -2,7 +2,10 @@
* This file is part of RawTherapee.
*/
#include "gradient.h"
#include "rtimage.h"
#include "../rtengine/procparams.h"
#include "../rtengine/rt_math.h"
using namespace rtengine;

1
rtgui/guiutils.cc
View File

@ -23,6 +23,7 @@
#include "../rtengine/rt_math.h"
#include "../rtengine/utils.h"
#include "../rtengine/icons.h"
#include "../rtengine/procparams.h"
#include "rtimage.h"
#include "multilangmgr.h"

7
rtgui/history.cc
View File

@ -17,10 +17,13 @@
* along with RawTherapee. If not, see <http://www.gnu.org/licenses/>.
*/
#include "history.h"
#include "eventmapper.h"
#include "guiutils.h"
#include "multilangmgr.h"
#include "rtimage.h"
#include "guiutils.h"
#include "eventmapper.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

3
rtgui/hsvequalizer.cc
View File

@ -16,9 +16,10 @@
*
* 2010 Ilya Popov <ilia_popov@rambler.ru>
*/
#include "hsvequalizer.h"
#include "../rtengine/color.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;

Some files were not shown because too many files have changed in this diff Show More