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

Relax dependency from procparams.h

Browse Source
This commit is contained in:
Flössie 2019-02-28 20:44:50 +01:00
parent 1786731f4a
commit 0cbc4923bc
86 changed files with 1139 additions and 814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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.cc
View File

@ -37,6 +37,7 @@
#include "ciecam02.h"
#include "color.h"
#include "iccstore.h"
#include "procparams.h"
#undef CLIPD
#define CLIPD(a) ((a)>0.0f?((a)<1.0f?(a):1.0f):0.0f)

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"

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/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
{
class 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;
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 };
}

574
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;
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;
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,33 +206,33 @@ 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++) {
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::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++) {
@ -239,7 +240,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);
@ -322,7 +323,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) {
@ -2225,8 +2226,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);
@ -2238,12 +2239,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/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),
@ -2875,13 +2875,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);
@ -3659,13 +3659,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);

133
rtengine/procparams.h
View File

@ -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
@ -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;
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"
@ -768,7 +769,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

6
rtgui/batchqueue.cc
View File

@ -197,7 +197,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 +642,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 +706,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;
std::unique_ptr<rtengine::procparams::ProcParams> params;
Glib::ustring savedParamsFile;
double progress;
Glib::ustring outFileName;

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; }

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;
std::unique_ptr<rtengine::procparams::CropParams> cropParams;
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;

2
rtgui/exifpanel.cc
View File

@ -684,7 +684,7 @@ void ExifPanel::updateChangeList ()
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);
}
}

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;

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;
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;
}

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"

3
rtgui/imagearea.cc
View File

@ -23,6 +23,7 @@
#include "multilangmgr.h"
#include "cropwindow.h"
#include "../rtengine/refreshmap.h"
#include "../rtengine/procparams.h"
#include "options.h"
ImageArea::ImageArea (ImageAreaPanel* p) : parent(p), fullImageWidth(0), fullImageHeight(0)
@ -659,7 +660,7 @@ void ImageArea::initialImageArrived ()
} else {
mainCropWindow->zoomFit();
}
} else if ((options.cropAutoFit || options.bgcolor != 0) && mainCropWindow->cropHandler.cropParams.enabled) {
} else if ((options.cropAutoFit || options.bgcolor != 0) && mainCropWindow->cropHandler.cropParams->enabled) {
mainCropWindow->zoomFitCrop();
}
fullImageWidth = w;

2
rtgui/iptcpanel.cc
View File

@ -623,7 +623,7 @@ void IPTCPanel::applyChangeList ()
keyword->get_entry()->set_text ("");
suppCategory->get_entry()->set_text ("");
for (rtengine::procparams::IPTCPairs::iterator i = changeList.begin(); i != changeList.end(); ++i) {
for (rtengine::procparams::IPTCPairs::const_iterator i = changeList.begin(); i != changeList.end(); ++i) {
if (i->first == "Caption" && !i->second.empty()) {
captionText->set_text (i->second.at(0));
} else if (i->first == "CaptionWriter" && !i->second.empty()) {

2
rtgui/options.cc
View File

@ -25,6 +25,8 @@
#include "guiutils.h"
#include "version.h"
#include "../rtengine/procparams.h"
#ifdef _OPENMP
#include <omp.h>
#endif

2
rtgui/options.h
View File

@ -363,7 +363,7 @@ public:
Glib::ustring fastexport_icm_input_profile;
Glib::ustring fastexport_icm_working_profile;
Glib::ustring fastexport_icm_output_profile;
rtengine::RenderingIntent fastexport_icm_outputIntent;
int fastexport_icm_outputIntent;
bool fastexport_icm_outputBPC;
Glib::ustring fastexport_icm_custom_output_profile;
bool fastexport_resize_enabled;

2
rtgui/partialpastedlg.h
View File

@ -22,6 +22,8 @@
#include <gtkmm.h>
#include "../rtengine/rtengine.h"
class ParamsEdited;
class PartialPasteDlg : public Gtk::Dialog
{

2
rtgui/preferences.cc
View File

@ -2384,7 +2384,7 @@ void Preferences::workflowUpdate ()
|| moptions.rtSettings.printerBPC != options.rtSettings.printerBPC
|| moptions.rtSettings.printerIntent != options.rtSettings.printerIntent) {
// Update the position of the Histogram
parent->updateProfiles (moptions.rtSettings.printerProfile, moptions.rtSettings.printerIntent, moptions.rtSettings.printerBPC);
parent->updateProfiles (moptions.rtSettings.printerProfile, rtengine::RenderingIntent(moptions.rtSettings.printerIntent), moptions.rtSettings.printerBPC);
}
}

15
rtgui/previewhandler.cc
View File

@ -19,11 +19,15 @@
#include "previewhandler.h"
#include <gtkmm.h>
#include "../rtengine/rtengine.h"
#include "../rtengine/procparams.h"
using namespace rtengine;
using namespace rtengine::procparams;
PreviewHandler::PreviewHandler () : image(nullptr), previewScale(1.)
PreviewHandler::PreviewHandler () :
image(nullptr),
cropParams(new procparams::CropParams),
previewScale(1.)
{
pih = new PreviewHandlerIdleHelper;
@ -72,7 +76,7 @@ void PreviewHandler::setImage(rtengine::IImage8* i, double scale, const rtengine
pih->phandler->image = i;
}
pih->phandler->cropParams = cp;
*pih->phandler->cropParams = cp;
pih->phandler->previewScale = scale;
--pih->pending;
@ -139,7 +143,7 @@ void PreviewHandler::imageReady(const rtengine::procparams::CropParams& cp)
pih->phandler->previewImg = Gdk::Pixbuf::create_from_data(pih->phandler->image->getData(), Gdk::COLORSPACE_RGB, false, 8, pih->phandler->image->getWidth(), pih->phandler->image->getHeight(), 3 * pih->phandler->image->getWidth());
pih->phandler->previewImgMutex.unlock ();
pih->phandler->cropParams = cp;
*pih->phandler->cropParams = cp;
pih->phandler->previewImageChanged ();
--pih->pending;
@ -204,3 +208,8 @@ void PreviewHandler::previewImageChanged ()
(*i)->previewImageChanged ();
}
}
rtengine::procparams::CropParams PreviewHandler::getCropParams()
{
return *cropParams;
}

8
rtgui/previewhandler.h
View File

@ -20,6 +20,7 @@
#define _PREVIEWHANDLER_
#include <list>
#include <memory>
#include <gtkmm.h>
@ -54,7 +55,7 @@ private:
protected:
rtengine::IImage8* image;
rtengine::procparams::CropParams cropParams;
std::unique_ptr<rtengine::procparams::CropParams> cropParams;
double previewScale;
PreviewHandlerIdleHelper* pih;
std::list<PreviewListener*> listeners;
@ -82,10 +83,7 @@ public:
// with this function it is possible to ask for a rough approximation of a (possibly zoomed) crop of the image
Glib::RefPtr<Gdk::Pixbuf> getRoughImage (int x, int y, int w, int h, double zoom);
Glib::RefPtr<Gdk::Pixbuf> getRoughImage (int desiredW, int desiredH, double& zoom);
rtengine::procparams::CropParams getCropParams ()
{
return cropParams;
}
rtengine::procparams::CropParams getCropParams ();
};
#endif

2
rtgui/previewwindow.cc
View File

@ -21,6 +21,8 @@
#include "imagearea.h"
#include "cursormanager.h"
#include "../rtengine/procparams.h"
PreviewWindow::PreviewWindow () : previewHandler(nullptr), mainCropWin(nullptr), imageArea(nullptr), imgX(0), imgY(0), imgW(0), imgH(0),
zoom(0.0), press_x(0), press_y(0), isMoving(false), needsUpdate(false), cursor_type(CSUndefined)

2
rtgui/thumbimageupdater.cc
View File

@ -27,6 +27,8 @@
#include "guiutils.h"
#include "threadutils.h"
#include "../rtengine/procparams.h"
#ifdef _OPENMP
#include <omp.h>
#endif

158
rtgui/thumbnail.cc
View File

@ -25,6 +25,7 @@
#include <cstdlib>
#include <glibmm.h>
#include "../rtengine/imagedata.h"
#include "../rtengine/procparams.h"
#include <glib/gstdio.h>
#include "../rtengine/dynamicprofile.h"
@ -38,7 +39,7 @@ using namespace rtengine::procparams;
Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, CacheImageData* cf)
: fname(fname), cfs(*cf), cachemgr(cm), ref(1), enqueueNumber(0), tpp(nullptr),
pparamsValid(false), imageLoading(false), lastImg(nullptr),
pparamsValid(false), pparams(new ProcParams), imageLoading(false), lastImg(nullptr),
lastW(0), lastH(0), lastScale(0), initial_(false)
{
@ -66,7 +67,7 @@ Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, CacheImageDa
Thumbnail::Thumbnail (CacheManager* cm, const Glib::ustring& fname, const std::string& md5)
: fname(fname), cachemgr(cm), ref(1), enqueueNumber(0), tpp(nullptr), pparamsValid(false),
imageLoading(false), lastImg(nullptr),
pparams(new ProcParams), imageLoading(false), lastImg(nullptr),
lastW(0), lastH(0), lastScale(0.0), initial_(true)
{
@ -107,20 +108,20 @@ void Thumbnail::_generateThumbnailImage ()
if (ext.lowercase() == "jpg" || ext.lowercase() == "jpeg") {
infoFromImage (fname);
tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams.wb.equal);
tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams->wb.equal);
if (tpp) {
cfs.format = FT_Jpeg;
}
} else if (ext.lowercase() == "png") {
tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams.wb.equal);
tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams->wb.equal);
if (tpp) {
cfs.format = FT_Png;
}
} else if (ext.lowercase() == "tif" || ext.lowercase() == "tiff") {
infoFromImage (fname);
tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams.wb.equal);
tpp = rtengine::Thumbnail::loadFromImage (fname, tw, th, 1, pparams->wb.equal);
if (tpp) {
cfs.format = FT_Tiff;
@ -141,7 +142,7 @@ void Thumbnail::_generateThumbnailImage ()
if ( tpp == nullptr ) {
quick = false;
tpp = rtengine::Thumbnail::loadFromRaw (fname, ri, sensorType, tw, th, 1, pparams.wb.equal, TRUE);
tpp = rtengine::Thumbnail::loadFromRaw (fname, ri, sensorType, tw, th, 1, pparams->wb.equal, TRUE);
}
cfs.sensortype = sensorType;
@ -178,22 +179,22 @@ const ProcParams& Thumbnail::getProcParams ()
const ProcParams& Thumbnail::getProcParamsU ()
{
if (pparamsValid) {
return pparams;
return *pparams;
} else {
pparams = *(ProfileStore::getInstance()->getDefaultProcParams (getType() == FT_Raw));
*pparams = *(ProfileStore::getInstance()->getDefaultProcParams (getType() == FT_Raw));
if (pparams.wb.method == "Camera") {
if (pparams->wb.method == "Camera") {
double ct;
getCamWB (ct, pparams.wb.green);
pparams.wb.temperature = ct;
} else if (pparams.wb.method == "Auto") {
getCamWB (ct, pparams->wb.green);
pparams->wb.temperature = ct;
} else if (pparams->wb.method == "Auto") {
double ct;
getAutoWB (ct, pparams.wb.green, pparams.wb.equal, pparams.wb.tempBias);
pparams.wb.temperature = ct;
getAutoWB (ct, pparams->wb.green, pparams->wb.equal, pparams->wb.tempBias);
pparams->wb.temperature = ct;
}
}
return pparams; // there is no valid pp to return, but we have to return something
return *pparams; // there is no valid pp to return, but we have to return something
}
/** @brief Create default params on demand and returns a new updatable object
@ -320,27 +321,27 @@ void Thumbnail::loadProcParams ()
MyMutex::MyLock lock(mutex);
pparamsValid = false;
pparams.setDefaults();
pparams->setDefaults();
const PartialProfile *defaultPP = ProfileStore::getInstance()->getDefaultPartialProfile(getType() == FT_Raw);
defaultPP->applyTo(&pparams);
defaultPP->applyTo(pparams.get());
if (options.paramsLoadLocation == PLL_Input) {
// try to load it from params file next to the image file
int ppres = pparams.load (fname + paramFileExtension);
pparamsValid = !ppres && pparams.ppVersion >= 220;
int ppres = pparams->load (fname + paramFileExtension);
pparamsValid = !ppres && pparams->ppVersion >= 220;
// if no success, try to load the cached version of the procparams
if (!pparamsValid) {
pparamsValid = !pparams.load (getCacheFileName ("profiles", paramFileExtension));
pparamsValid = !pparams->load (getCacheFileName ("profiles", paramFileExtension));
}
} else {
// try to load it from cache
pparamsValid = !pparams.load (getCacheFileName ("profiles", paramFileExtension));
pparamsValid = !pparams->load (getCacheFileName ("profiles", paramFileExtension));
// if no success, try to load it from params file next to the image file
if (!pparamsValid) {
int ppres = pparams.load (fname + paramFileExtension);
pparamsValid = !ppres && pparams.ppVersion >= 220;
int ppres = pparams->load (fname + paramFileExtension);
pparamsValid = !ppres && pparams->ppVersion >= 220;
}
}
}
@ -373,7 +374,7 @@ void Thumbnail::clearProcParams (int whoClearedIt)
// probably not as this is the only option to set param values to default
// reset the params to defaults
pparams.setDefaults();
pparams->setDefaults();
// and restore rank and inTrash
setRank(rank);
@ -422,42 +423,42 @@ void Thumbnail::setProcParams (const ProcParams& pp, ParamsEdited* pe, int whoCh
{
const bool needsReprocessing =
resetToDefault
|| pparams.toneCurve != pp.toneCurve
|| pparams.labCurve != pp.labCurve
|| pparams.localContrast != pp.localContrast
|| pparams.rgbCurves != pp.rgbCurves
|| pparams.colorToning != pp.colorToning
|| pparams.vibrance != pp.vibrance
|| pparams.wb != pp.wb
|| pparams.colorappearance != pp.colorappearance
|| pparams.epd != pp.epd
|| pparams.fattal != pp.fattal
|| pparams.sh != pp.sh
|| pparams.crop != pp.crop
|| pparams.coarse != pp.coarse
|| pparams.commonTrans != pp.commonTrans
|| pparams.rotate != pp.rotate
|| pparams.distortion != pp.distortion
|| pparams.lensProf != pp.lensProf
|| pparams.perspective != pp.perspective
|| pparams.gradient != pp.gradient
|| pparams.pcvignette != pp.pcvignette
|| pparams.cacorrection != pp.cacorrection
|| pparams.vignetting != pp.vignetting
|| pparams.chmixer != pp.chmixer
|| pparams.blackwhite != pp.blackwhite
|| pparams.icm != pp.icm
|| pparams.hsvequalizer != pp.hsvequalizer
|| pparams.filmSimulation != pp.filmSimulation
|| pparams.softlight != pp.softlight
|| pparams.dehaze != pp.dehaze
|| pparams->toneCurve != pp.toneCurve
|| pparams->labCurve != pp.labCurve
|| pparams->localContrast != pp.localContrast
|| pparams->rgbCurves != pp.rgbCurves
|| pparams->colorToning != pp.colorToning
|| pparams->vibrance != pp.vibrance
|| pparams->wb != pp.wb
|| pparams->colorappearance != pp.colorappearance
|| pparams->epd != pp.epd
|| pparams->fattal != pp.fattal
|| pparams->sh != pp.sh
|| pparams->crop != pp.crop
|| pparams->coarse != pp.coarse
|| pparams->commonTrans != pp.commonTrans
|| pparams->rotate != pp.rotate
|| pparams->distortion != pp.distortion
|| pparams->lensProf != pp.lensProf
|| pparams->perspective != pp.perspective
|| pparams->gradient != pp.gradient
|| pparams->pcvignette != pp.pcvignette
|| pparams->cacorrection != pp.cacorrection
|| pparams->vignetting != pp.vignetting
|| pparams->chmixer != pp.chmixer
|| pparams->blackwhite != pp.blackwhite
|| pparams->icm != pp.icm
|| pparams->hsvequalizer != pp.hsvequalizer
|| pparams->filmSimulation != pp.filmSimulation
|| pparams->softlight != pp.softlight
|| pparams->dehaze != pp.dehaze
|| whoChangedIt == FILEBROWSER
|| whoChangedIt == BATCHEDITOR;
{
MyMutex::MyLock lock(mutex);
if (pparams != pp) {
if (*pparams != pp) {
cfs.recentlySaved = false;
} else if (pparamsValid && !updateCacheNow) {
// nothing to do
@ -470,9 +471,9 @@ void Thumbnail::setProcParams (const ProcParams& pp, ParamsEdited* pe, int whoCh
const int inTrash = getStage();
if (pe) {
pe->combine(pparams, pp, true);
pe->combine(*pparams, pp, true);
} else {
pparams = pp;
*pparams = pp;
}
pparamsValid = true;
@ -506,7 +507,7 @@ void Thumbnail::imageDeveloped ()
cfs.save (getCacheFileName ("data", ".txt"));
if (options.saveParamsCache) {
pparams.save (getCacheFileName ("profiles", paramFileExtension));
pparams->save (getCacheFileName ("profiles", paramFileExtension));
}
}
@ -574,7 +575,7 @@ void Thumbnail::getThumbnailSize (int &w, int &h, const rtengine::procparams::Pr
ppCoarse -= 180;
}
int thisCoarse = this->pparams.coarse.rotate;
int thisCoarse = this->pparams->coarse.rotate;
if (thisCoarse >= 180) {
thisCoarse -= 180;
@ -948,7 +949,7 @@ void Thumbnail::updateCache (bool updatePParams, bool updateCacheImageData)
{
if (updatePParams && pparamsValid) {
pparams.save (
pparams->save (
options.saveParamsFile ? fname + paramFileExtension : "",
options.saveParamsCache ? getCacheFileName ("profiles", paramFileExtension) : "",
true
@ -981,6 +982,45 @@ void Thumbnail::setFileName (const Glib::ustring &fn)
cfs.md5 = cachemgr->getMD5 (fname);
}
int Thumbnail::getRank () const
{
return pparams->rank;
}
void Thumbnail::setRank (int rank)
{
if (pparams->rank != rank) {
pparams->rank = rank;
pparamsValid = true;
}
}
int Thumbnail::getColorLabel () const
{
return pparams->colorlabel;
}
void Thumbnail::setColorLabel (int colorlabel)
{
if (pparams->colorlabel != colorlabel) {
pparams->colorlabel = colorlabel;
pparamsValid = true;
}
}
int Thumbnail::getStage () const
{
return pparams->inTrash;
}
void Thumbnail::setStage (bool stage)
{
if (pparams->inTrash != stage) {
pparams->inTrash = stage;
pparamsValid = true;
}
}
void Thumbnail::addThumbnailListener (ThumbnailListener* tnl)
{

45
rtgui/thumbnail.h
View File

@ -19,7 +19,9 @@
#ifndef _THUMBNAIL_
#define _THUMBNAIL_
#include <memory>
#include <string>
#include <glibmm.h>
#include "cachemanager.h"
#include "options.h"
@ -30,6 +32,8 @@
#include "threadutils.h"
class CacheManager;
class ParamsEdited;
class Thumbnail
{
@ -47,7 +51,7 @@ class Thumbnail
float imgRatio; // hack to avoid rounding error
// double scale; // portion of the sizes of the processed thumbnail image and the full scale image
rtengine::procparams::ProcParams pparams;
std::unique_ptr<rtengine::procparams::ProcParams> pparams;
bool pparamsValid;
bool imageLoading;
@ -160,41 +164,14 @@ public:
return cfs.md5;
}
int getRank () const
{
return pparams.rank;
}
void setRank (int rank)
{
if (pparams.rank != rank) {
pparams.rank = rank;
pparamsValid = true;
}
}
int getRank () const;
void setRank (int rank);
int getColorLabel () const
{
return pparams.colorlabel;
}
void setColorLabel (int colorlabel)
{
if (pparams.colorlabel != colorlabel) {
pparams.colorlabel = colorlabel;
pparamsValid = true;
}
}
int getColorLabel () const;
void setColorLabel (int colorlabel);
int getStage () const
{
return pparams.inTrash;
}
void setStage (bool stage)
{
if (pparams.inTrash != stage) {
pparams.inTrash = stage;
pparamsValid = true;
}
}
int getStage () const;
void setStage (bool stage);
void addThumbnailListener (ThumbnailListener* tnl);
void removeThumbnailListener (ThumbnailListener* tnl);

26
rtgui/tonecurve.cc
View File

@ -347,33 +347,33 @@ void ToneCurve::write (ProcParams* pp, ParamsEdited* pedited)
int tcMode = toneCurveMode->get_active_row_number();
if (tcMode == 0) {
pp->toneCurve.curveMode = ToneCurveParams::TcMode::STD;
pp->toneCurve.curveMode = ToneCurveMode::STD;
} else if (tcMode == 1) {
pp->toneCurve.curveMode = ToneCurveParams::TcMode::WEIGHTEDSTD;
pp->toneCurve.curveMode = ToneCurveMode::WEIGHTEDSTD;
} else if (tcMode == 2) {
pp->toneCurve.curveMode = ToneCurveParams::TcMode::FILMLIKE;
pp->toneCurve.curveMode = ToneCurveMode::FILMLIKE;
} else if (tcMode == 3) {
pp->toneCurve.curveMode = ToneCurveParams::TcMode::SATANDVALBLENDING;
pp->toneCurve.curveMode = ToneCurveMode::SATANDVALBLENDING;
} else if (tcMode == 4) {
pp->toneCurve.curveMode = ToneCurveParams::TcMode::LUMINANCE;
pp->toneCurve.curveMode = ToneCurveMode::LUMINANCE;
} else if (tcMode == 5) {
pp->toneCurve.curveMode = ToneCurveParams::TcMode::PERCEPTUAL;
pp->toneCurve.curveMode = ToneCurveMode::PERCEPTUAL;
}
tcMode = toneCurveMode2->get_active_row_number();
if (tcMode == 0) {
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::STD;
pp->toneCurve.curveMode2 = ToneCurveMode::STD;
} else if (tcMode == 1) {
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::WEIGHTEDSTD;
pp->toneCurve.curveMode2 = ToneCurveMode::WEIGHTEDSTD;
} else if (tcMode == 2) {
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::FILMLIKE;
pp->toneCurve.curveMode2 = ToneCurveMode::FILMLIKE;
} else if (tcMode == 3) {
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::SATANDVALBLENDING;
pp->toneCurve.curveMode2 = ToneCurveMode::SATANDVALBLENDING;
} else if (tcMode == 4) {
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::LUMINANCE;
pp->toneCurve.curveMode2 = ToneCurveMode::LUMINANCE;
} else if (tcMode == 5) {
pp->toneCurve.curveMode2 = ToneCurveParams::TcMode::PERCEPTUAL;
pp->toneCurve.curveMode2 = ToneCurveMode::PERCEPTUAL;
}
pp->toneCurve.histmatching = histmatching->get_active();
@ -979,7 +979,7 @@ void ToneCurve::autoExpChanged(double expcomp, int bright, int contr, int black,
);
}
void ToneCurve::autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveParams::TcMode curveMode, const std::vector<double>& curve)
void ToneCurve::autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveMode curveMode, const std::vector<double>& curve)
{
nextToneCurveMode = curveMode;
nextToneCurve = curve;

4
rtgui/tonecurve.h
View File

@ -81,7 +81,7 @@ protected:
int nextHlcompr;
int nextHlcomprthresh;
bool nextHLRecons;
rtengine::procparams::ToneCurveParams::TcMode nextToneCurveMode;
rtengine::procparams::ToneCurveMode nextToneCurveMode;
std::vector<double> nextToneCurve;
void setHistmatching(bool enabled);
@ -132,7 +132,7 @@ public:
void histmatchingToggled();
void autoExpChanged(double expcomp, int bright, int contr, int black, int hlcompr, int hlcomprthresh, bool hlrecons) override;
void autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveParams::TcMode curveMode, const std::vector<double>& curve) override;
void autoMatchedToneCurveChanged(rtengine::procparams::ToneCurveMode curveMode, const std::vector<double>& curve) override;
void setRaw (bool raw);