diff --git a/rtdata/languages/default b/rtdata/languages/default index 00a2f6de5..79d16ca57 100644 --- a/rtdata/languages/default +++ b/rtdata/languages/default @@ -217,6 +217,11 @@ HISTORY_MSG_133;Gamma HISTORY_MSG_134;Gamma Position HISTORY_MSG_135;Gamma Free HISTORY_MSG_136;Gamma Slope +HISTORY_MSG_137;Black level green 1 +HISTORY_MSG_138;Black level red +HISTORY_MSG_139;Black level blue +HISTORY_MSG_140;Black level green 2 +HISTORY_MSG_141;Black level green together HISTORY_MSG_14;Luminance Brightness HISTORY_MSG_15;Luminance Contrast HISTORY_MSG_16;Luminance Black @@ -761,7 +766,7 @@ TP_EQUALIZER_FINEST;finest TP_EQUALIZER_LABEL;Wavelet equalizer TP_EQUALIZER_LARGEST;coarsest TP_EQUALIZER_NEUTRAL;Neutral -TP_EXPOSCORR_LABEL;Raw white point +TP_EXPOSCORR_LABEL;Raw white-black point TP_EXPOSURE_AUTOLEVELS;Auto Levels TP_EXPOSURE_BLACKLEVEL;Black TP_EXPOSURE_BRIGHTNESS;Brightness @@ -848,8 +853,14 @@ TP_PREPROCESS_NO_FOUND;None found TP_RAWCACORR_AUTO;Auto correction TP_RAWCACORR_CABLUE;Blue TP_RAWCACORR_CARED;Red -TP_RAWEXPOS_LINEAR;Linear corr. factor -TP_RAWEXPOS_PRESER;HL preserving corr. (EV) +TP_RAWEXPOS_LINEAR;White Point: Linear corr. factor +TP_RAWEXPOS_PRESER;White Point: HL preserving corr.(EV) +TP_RAWEXPOS_BLACKZERO;Black Level: Green 1 (leader) +TP_RAWEXPOS_BLACKONE;Black Level: Red +TP_RAWEXPOS_BLACKTWO;Black Level: Blue +TP_RAWEXPOS_BLACKTHREE;Black Level: Green 2 +TP_RAWEXPOS_TWOGREEN;Two greens together +TP_EXPO_AFTER; After interpolation (before RGB conversion) TP_RAW_DCBENHANCE;Apply DCB enhancement step TP_RAW_DCBITERATIONS;Number of DCB iterations TP_RAW_DMETHOD;Method diff --git a/rtdata/profiles/crisp.pp3 b/rtdata/profiles/crisp.pp3 index 5c87a2b7e..3f57ad0be 100644 --- a/rtdata/profiles/crisp.pp3 +++ b/rtdata/profiles/crisp.pp3 @@ -182,6 +182,10 @@ LineDenoise=0 GreenEqThreshold=0 PreExposure=1 PrePreserv=0 +PreBlackzero=0 +PreBlackone=0 +PreBlacktwo=0 +PreBlackthree=0 CcSteps=1 Method=amaze DCBIterations=2 diff --git a/rtdata/profiles/default.pp3 b/rtdata/profiles/default.pp3 index 6f21a52a5..f1f43efad 100644 --- a/rtdata/profiles/default.pp3 +++ b/rtdata/profiles/default.pp3 @@ -182,6 +182,10 @@ LineDenoise=0 GreenEqThreshold=0 PreExposure=1 PrePreserv=0 +PreBlackzero=0 +PreBlackone=0 +PreBlacktwo=0 +PreBlackthree=0 CcSteps=1 Method=amaze DCBIterations=2 diff --git a/rtdata/profiles/neutral.pp3 b/rtdata/profiles/neutral.pp3 index a3a6c14a8..ed64c6273 100644 --- a/rtdata/profiles/neutral.pp3 +++ b/rtdata/profiles/neutral.pp3 @@ -182,6 +182,10 @@ LineDenoise=0 GreenEqThreshold=0 PreExposure=1 PrePreserv=0 +PreBlackzero=0 +PreBlackone=0 +PreBlacktwo=0 +PreBlackthree=0 CcSteps=1 Method=amaze DCBIterations=2 diff --git a/rtengine/expo_before_b.cc b/rtengine/expo_before_b.cc index 4a225e990..9c91c80a4 100644 --- a/rtengine/expo_before_b.cc +++ b/rtengine/expo_before_b.cc @@ -31,6 +31,9 @@ // preserve (log) : 0..8 : currently 0.1 1 void RawImageSource::processRawWhitepoint(float expos, float preser) { + MyTime t1e,t2e; + t1e.set(); + int width=W, height=H; // exposure correction inspired from G.Luijk @@ -68,7 +71,7 @@ void RawImageSource::processRawWhitepoint(float expos, float preser) { freeArray(imgd, H); // Find maximum to adjust LUTs. New float engines clips only at the very end - int maxVal=65535; + int maxVal=0; for(int row=0;rowmaxVal) maxVal = rawData[row][col]; @@ -76,9 +79,9 @@ void RawImageSource::processRawWhitepoint(float expos, float preser) { // Exposure correction with highlight preservation LUTf lut(maxVal+1); if(expos>1){ - float K = maxVal / expos*exp(-preser*log(2.0)); + float K = (float) maxVal / expos*exp(-preser*log(2.0)); for (int j=0;j<=maxVal;j++) - lut[(int)j]=((maxVal-K*expos)/(maxVal-K)*(j-maxVal)+maxVal) / j; + lut[(int)j]=(((float)maxVal-K*expos)/((float)maxVal-K)*(j-maxVal)+(float) maxVal) / j; #pragma omp parallel for shared(expos) for(int row=0;rowverbose ) + printf("Exposure before %d usec\n", t2e.etime(t1e)); + } \ No newline at end of file diff --git a/rtengine/procevents.h b/rtengine/procevents.h index 5bca0096d..984337257 100644 --- a/rtengine/procevents.h +++ b/rtengine/procevents.h @@ -158,7 +158,12 @@ enum ProcEvent { EvGAMPOS=133, EvGAMFREE=134, EvSLPOS=135, - NUMOFEVENTS=136 + EvPreProcessExpBlackzero=136, + EvPreProcessExpBlackone=137, + EvPreProcessExpBlacktwo=138, + EvPreProcessExpBlackthree=139, + EvPreProcessExptwoGreen=140, + NUMOFEVENTS=141 }; diff --git a/rtengine/procparams.cc b/rtengine/procparams.cc index c224183e9..3d3ae27f8 100644 --- a/rtengine/procparams.cc +++ b/rtengine/procparams.cc @@ -28,7 +28,7 @@ #include #include - +#include #define APPVERSION VERSION namespace rtengine { @@ -250,8 +250,11 @@ void ProcParams::setDefaults () { // exposure before interpolation raw.expos=1.0; raw.preser=0.0; - - + raw.blackzero=0.0; + raw.blackone=0.0; + raw.blacktwo=0.0; + raw.blackthree=0.0; + raw.twogreen=true; exif.clear (); iptc.clear (); @@ -263,7 +266,6 @@ void ProcParams::setDefaults () { } int ProcParams::save (Glib::ustring fname) const { - SafeKeyFile keyFile; keyFile.set_string ("Version", "AppVersion", APPVERSION); @@ -492,6 +494,11 @@ int ProcParams::save (Glib::ustring fname) const { keyFile.set_boolean ("RAW", "DCBEnhance", raw.dcb_enhance ); keyFile.set_double ("RAW", "PreExposure", raw.expos ); keyFile.set_double ("RAW", "PrePreserv", raw.preser ); + keyFile.set_double ("RAW", "PreBlackzero", raw.blackzero ); + keyFile.set_double ("RAW", "PreBlackone", raw.blackone ); + keyFile.set_double ("RAW", "PreBlacktwo", raw.blacktwo ); + keyFile.set_double ("RAW", "PreBlackthree", raw.blackthree ); + keyFile.set_boolean ("RAW", "PreTwoGreen", raw.twogreen ); // exposition @@ -822,6 +829,12 @@ if (keyFile.has_group ("RAW")) { if (keyFile.has_key ("RAW", "DCBEnhance")) raw.dcb_enhance =keyFile.get_boolean("RAW", "DCBEnhance"); if (keyFile.has_key ("RAW", "PreExposure")) raw.expos =keyFile.get_double("RAW", "PreExposure"); if (keyFile.has_key ("RAW", "PrePreserv")) raw.preser =keyFile.get_double("RAW", "PrePreserv"); + if (keyFile.has_key ("RAW", "PreBlackzero")) raw.blackzero =keyFile.get_double("RAW", "PreBlackzero"); + if (keyFile.has_key ("RAW", "PreBlackone")) raw.blackone =keyFile.get_double("RAW", "PreBlackone"); + if (keyFile.has_key ("RAW", "PreBlacktwo")) raw.blacktwo =keyFile.get_double("RAW", "PreBlacktwo"); + if (keyFile.has_key ("RAW", "PreBlackthree")) raw.blackthree =keyFile.get_double("RAW", "PreBlackthree"); + if (keyFile.has_key ("RAW", "PreTwoGreen")) raw.twogreen =keyFile.get_boolean("RAW", "PreTwoGreen"); + } // load exif change settings @@ -1028,7 +1041,14 @@ bool ProcParams::operator== (const ProcParams& other) { && exif==other.exif && iptc==other.iptc && raw.expos==other.raw.expos - && raw.preser==other.raw.preser; + && raw.preser==other.raw.preser + && raw.preser==other.raw.preser + && raw.blackzero==other.raw.blackzero + && raw.blackone==other.raw.blackone + && raw.blacktwo==other.raw.blacktwo + && raw.blackthree==other.raw.blackthree + && raw.twogreen==other.raw.twogreen; + } bool ProcParams::operator!= (const ProcParams& other) { diff --git a/rtengine/procparams.h b/rtengine/procparams.h index aa68c7dc3..6a0235c4a 100644 --- a/rtengine/procparams.h +++ b/rtengine/procparams.h @@ -419,7 +419,11 @@ class RAWParams { // exposure before interpolation double expos; double preser; - + double blackzero; + double blackone; + double blacktwo; + double blackthree; + bool twogreen; bool hotdeadpix_filt; int hotdeadpix_thresh; int linenoise; diff --git a/rtengine/rawimage.cc b/rtengine/rawimage.cc index 8bcf548a0..8e8f9d5cf 100644 --- a/rtengine/rawimage.cc +++ b/rtengine/rawimage.cc @@ -42,7 +42,8 @@ RawImage::~RawImage() /* Similar to dcraw scale_colors for coeff. calculation, but without actual pixels scaling. * need pixels in data[][] available */ -int RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, int *cblack_ ) +int RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, float *cblack_) + { unsigned row, col, ur, uc, i, x, y, c, sum[8]; unsigned W = this->get_width(); @@ -51,10 +52,9 @@ int RawImage::get_colorsCoeff( float *pre_mul_, float *scale_mul_, int *cblack_ double dsum[8], dmin, dmax; for (int c = 0; c < 4; c++){ - cblack_[c] = this->get_cblack(c) + this->get_black(); + cblack_[c] = (float) this->get_cblack(c) + (float) this->get_black();// I don't modify black and cblack of Dcraw pre_mul_[c] = this->get_pre_mul(c); } - if ( this->get_cam_mul(0) == -1 ) { memset(dsum, 0, sizeof dsum); for (row = 0; row < H; row += 8) @@ -115,7 +115,6 @@ skip_block: ; if (dmax < pre_mul_[c]) dmax = pre_mul_[c]; } - for (c = 0; c < 4; c++) scale_mul_[c] = (pre_mul_[c] /= dmax) * 65535.0 / sat; if (settings->verbose) { diff --git a/rtengine/rawimage.h b/rtengine/rawimage.h index c33d23887..167ee2f46 100644 --- a/rtengine/rawimage.h +++ b/rtengine/rawimage.h @@ -90,7 +90,7 @@ public: ~RawImage(); int loadRaw (bool loadData=true, bool closeFile=true); - int get_colorsCoeff( float *pre_mul, float *scale_mul, int *cblack ); + int get_colorsCoeff( float *pre_mul, float *scale_mul, float *cblack ); void set_prefilters(){ if (isBayer() && get_colors() == 3) { prefilters = filters; diff --git a/rtengine/rawimagesource.cc b/rtengine/rawimagesource.cc index d1bd61b94..7e7f111dc 100644 --- a/rtengine/rawimagesource.cc +++ b/rtengine/rawimagesource.cc @@ -33,7 +33,6 @@ #include #include - #ifdef _OPENMP #include #endif @@ -409,6 +408,7 @@ void RawImageSource::getImage (ColorTemp ctemp, int tran, Imagefloat* image, Pre } } + // Flip if needed if (tran & TR_HFLIP) hflip (image); @@ -536,9 +536,6 @@ int RawImageSource::findHotDeadPixel( PixelsMap &bpMap, float thresh) return counter; } - -//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% - void RawImageSource::rotateLine (float* line, float** channel, int tran, int i, int w, int h) { if ((tran & TR_ROT) == TR_R180) @@ -911,7 +908,7 @@ int RawImageSource::load (Glib::ustring fname, bool batch) { inverse33 (xyz_cam, cam_xyz); float pre_mul[4]; - ri->get_colorsCoeff( pre_mul, scale_mul, cblack ); + ri->get_colorsCoeff( pre_mul, scale_mu_l, c_black);//modify for black level camwb_red = ri->get_pre_mul(0) / pre_mul[0]; camwb_green = ri->get_pre_mul(1) / pre_mul[1]; @@ -1010,7 +1007,7 @@ void RawImageSource::preprocess (const RAWParams &raw) } } - scaleColors( 0,0, W, H); + scaleColors( 0,0, W, H, raw);//+ + raw parameters for black level(raw.blackxx) defGain = 0.0;//log(initialGain) / log(2.0); @@ -1287,16 +1284,56 @@ void RawImageSource::copyOriginalPixels(const RAWParams &raw, RawImage *src, Raw /* Scale original pixels into the range 0 65535 using black offsets and multipliers */ -void RawImageSource::scaleColors(int winx,int winy,int winw,int winh) +void RawImageSource::scaleColors(int winx,int winy,int winw,int winh, const RAWParams &raw) { - // scale image colors +float black_lev[4];//black level + +//adjust black level (eg Canon) +// cblack Bayer +//0 green +//1 red +//2 blue +// cblack no Bayer +//0 red +//1 green +//2 blue +if( ri->isBayer() ) { +black_lev[0]=raw.blackzero;//G1 +black_lev[1]=raw.blackone;//R +black_lev[2]=raw.blacktwo;//B +black_lev[3]=raw.blackthree;//G2 + +} +else { +black_lev[0]=raw.blackone;//R +black_lev[1]=raw.blackzero;//G +black_lev[2]=raw.blacktwo;//B +black_lev[3]= raw.blackzero; +} + for(int i=0; i<4; i++) { + scale_mul[i]=scale_mu_l[i]; + if( c_black[i]+black_lev[i] >0) cblack[i]=c_black[i]+black_lev[i]; else cblack[i]=0;// adjust black level + } + // scale image colors + if( ri->isBayer() ){ for (int row = winy; row < winy+winh; row ++){ for (int col = winx; col < winx+winw; col++) { - float val = rawData[row][col]; + float val = rawData[row][col]; int c = FC(row, col); - val -= cblack[c]; - val *= scale_mul[c]; + if (ri->ISGREEN(row,col)) { + if (row&1) { + val-=cblack[1]; + val *= scale_mul[1]; + } + else { + val-=cblack[3]; + val *= scale_mul[3]; + } + } + else { + val-=cblack[c]; + val*=scale_mul[c];} rawData[row][col] = (val); } } @@ -1951,18 +1988,19 @@ void RawImageSource::getAutoExpHistogram (LUTu & histogram, int& histcompr) { void RawImageSource::getRAWHistogram (LUTu & histRedRaw, LUTu & histGreenRaw, LUTu & histBlueRaw) { histRedRaw.clear(); histGreenRaw.clear(); histBlueRaw.clear(); - float mult = 65535.0 / ri->get_white(); - #pragma omp parallel for for (int i=border; iisBayer()) { for (int j=start; jISGREEN(i,j)) { - idx = CLIP((int)CurveFactory::gamma(mult*(ri->data[i][j]-cblack[0]))); + if(i &1) idx = CLIP((int)CurveFactory::gamma(mult*(ri->data[i][j]-cblack[0])));// green 1 + else + idx = CLIP((int)CurveFactory::gamma(mult*(ri->data[i][j]-cblack[3])));//green 2 histGreenRaw[idx>>8]++; } else if (ri->ISRED(i,j)) { idx = CLIP((int)CurveFactory::gamma(mult*(ri->data[i][j]-cblack[1]))); @@ -2265,6 +2303,8 @@ void RawImageSource::inverse33 (double (*rgb_cam)[3], double (*cam_rgb)[3]) { cam_rgb[2][2] = (rgb_cam[0][1]*rgb_cam[1][0]-rgb_cam[0][0]*rgb_cam[1][1]) / nom; } + + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% diff --git a/rtengine/rawimagesource.h b/rtengine/rawimagesource.h index 41c482eaa..4b4c68f3c 100644 --- a/rtengine/rawimagesource.h +++ b/rtengine/rawimagesource.h @@ -61,7 +61,10 @@ class RawImageSource : public ImageSource { ColorTemp wb; ProgressListener* plistener; float scale_mul[4]; // multiplier for each color - int cblack[4]; // black offsets + float cblack[4];// black + float scale_mu_l[4];// copy of scale_mul, for saturation + float c_black[4]; // copy of cblack Dcraw for black level + double camwb_red; double camwb_green; double camwb_blue; @@ -125,7 +128,8 @@ class RawImageSource : public ImageSource { void demosaic (const RAWParams &raw); void copyOriginalPixels(const RAWParams &raw, RawImage *ri, RawImage *riDark, RawImage *riFlatFile ); void cfaboxblur (RawImage *riFlatFile, float* cfablur, int boxH, int boxW ); - void scaleColors (int winx,int winy,int winw,int winh ); + void scaleColors (int winx,int winy,int winw,int winh, const RAWParams &raw);// raw for cblack + void getImage (ColorTemp ctemp, int tran, Imagefloat* image, PreviewProps pp, HRecParams hrp, ColorManagementParams cmp, RAWParams raw); ColorTemp getWB () { return wb; } ColorTemp getAutoWB (); diff --git a/rtengine/refreshmap.cc b/rtengine/refreshmap.cc index f7edfbb93..1cf81ad2b 100644 --- a/rtengine/refreshmap.cc +++ b/rtengine/refreshmap.cc @@ -155,7 +155,12 @@ DIRPYRDENOISE, // EvDPDNChromCurve, ALL, // EvGAMMA ALL, // EvGAMPOS ALL, //EvGAMFREE -ALL, //EvSLPOS +ALL, //EvSLPOS +DARKFRAME, // EvPreProcessExpBlackzero +DARKFRAME, // EvPreProcessExpBlackone +DARKFRAME, // EvPreProcessExpBlacktwo +DARKFRAME, // EvPreProcessExpBlackthree +DARKFRAME, //EvPreProcessExptwoGreen }; diff --git a/rtgui/paramsedited.cc b/rtgui/paramsedited.cc index 2fffebd62..06f25182e 100644 --- a/rtgui/paramsedited.cc +++ b/rtgui/paramsedited.cc @@ -157,6 +157,11 @@ void ParamsEdited::set (bool v) { raw.exPos = v; raw.exCorrection = v; raw.exPreser = v; + raw.exBlackzero = v; + raw.exBlackone = v; + raw.exBlacktwo = v; + raw.exBlackthree = v; + raw.exTwoGreen=v; raw.greenEq = v; raw.linenoise = v; raw.ff_file = v; @@ -318,6 +323,12 @@ void ParamsEdited::initFrom (const std::vector raw.caBlue = raw.caBlue && p.raw.cablue == other.raw.cablue; raw.exPos = raw.exPos && p.raw.expos == other.raw.expos; raw.exPreser = raw.exPreser && p.raw.preser == other.raw.preser; //exposi + raw.exBlackzero = raw.exBlackzero && p.raw.blackzero == other.raw.blackzero; //black + raw.exBlackone = raw.exBlackone && p.raw.blackone == other.raw.blackone; //black + raw.exBlacktwo = raw.exBlacktwo && p.raw.blacktwo == other.raw.blacktwo; //black + raw.exBlackthree = raw.exBlackthree && p.raw.blackthree == other.raw.blackthree; //black + raw.exTwoGreen = raw.exTwoGreen && p.raw.twogreen == other.raw.twogreen; //black 2 green + raw.darkFrame = raw.darkFrame && p.raw.dark_frame == other.raw.dark_frame; raw.dfAuto = raw.dfAuto && p.raw.df_autoselect == other.raw.df_autoselect; raw.ff_file = raw.ff_file && p.raw.ff_file == other.raw.ff_file; @@ -475,6 +486,12 @@ void ParamsEdited::combine (rtengine::procparams::ProcParams& toEdit, const rten if (raw.caBlue) toEdit.raw.cablue = mods.raw.cablue; if (raw.exPos) toEdit.raw.expos =mods.raw.expos; if (raw.exPreser) toEdit.raw.preser =mods.raw.preser; + if (raw.exBlackzero) toEdit.raw.blackzero =mods.raw.blackzero; + if (raw.exBlackone) toEdit.raw.blackone =mods.raw.blackone; + if (raw.exBlacktwo) toEdit.raw.blacktwo =mods.raw.blacktwo; + if (raw.exBlackthree) toEdit.raw.blackthree =mods.raw.blackthree; + if (raw.exTwoGreen) toEdit.raw.twogreen =mods.raw.twogreen; + if (raw.greenEq) toEdit.raw.greenthresh = mods.raw.greenthresh; if (raw.hotDeadPixel) toEdit.raw.hotdeadpix_filt= mods.raw.hotdeadpix_filt; if (raw.linenoise) toEdit.raw.linenoise = mods.raw.linenoise; diff --git a/rtgui/paramsedited.h b/rtgui/paramsedited.h index 1bdcd42dd..6fa5044d9 100644 --- a/rtgui/paramsedited.h +++ b/rtgui/paramsedited.h @@ -301,6 +301,11 @@ class RAWParamsEdited { bool exCorrection; bool exPos; bool exPreser; + bool exBlackzero; + bool exBlackone; + bool exBlacktwo; + bool exBlackthree; + bool exTwoGreen; }; class ExifPairEdited { diff --git a/rtgui/rawexposure.cc b/rtgui/rawexposure.cc index d56ddc499..df7825468 100644 --- a/rtgui/rawexposure.cc +++ b/rtgui/rawexposure.cc @@ -26,7 +26,7 @@ using namespace rtengine::procparams; RAWExposure::RAWExposure () : Gtk::VBox(), FoldableToolPanel(this) { - PexPos = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_LINEAR"),0.2,16.0,0.01,1)); + PexPos = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_LINEAR"),0.1,16.0,0.01,1)); PexPos->setAdjusterListener (this); if (PexPos->delay < 1000) PexPos->delay = 1000; PexPos->show(); @@ -34,9 +34,36 @@ RAWExposure::RAWExposure () : Gtk::VBox(), FoldableToolPanel(this) PexPreser->setAdjusterListener (this); if (PexPreser->delay < 1000) PexPreser->delay = 1000; PexPreser->show(); + PexBlackone = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_BLACKONE"),-50,50,0.1,0));//black level + PexBlackone->setAdjusterListener (this); + if (PexBlackone->delay < 1000) PexBlackone->delay = 1000; + PexBlackone->show(); + PexBlacktwo = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_BLACKTWO"),-50,50,0.1,0));//black level + PexBlacktwo->setAdjusterListener (this); + if (PexBlacktwo->delay < 1000) PexBlacktwo->delay = 1000; + PexBlacktwo->show(); + PexBlackthree = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_BLACKTHREE"),-50,50,0.1,0));//black level + PexBlackthree->setAdjusterListener (this); + if (PexBlackthree->delay < 1000) PexBlackthree->delay = 1000; + PexBlackthree->show(); + PexBlackzero = Gtk::manage(new Adjuster (M("TP_RAWEXPOS_BLACKZERO"),-50,50,0.1,0));//black level + PexBlackzero->setAdjusterListener (this); + if (PexBlackzero->delay < 1000) PexBlackzero->delay = 1000; + PexBlackzero->show(); + PextwoGreen = Gtk::manage(new Gtk::CheckButton((M("TP_RAWEXPOS_TWOGREEN"))));// two green + PextwoGreen->set_active (true); + greenconn = PextwoGreen->signal_toggled().connect ( sigc::mem_fun(*this, &RAWExposure::GreenChanged)); + + pack_start( *PexPos, Gtk::PACK_SHRINK, 4);//exposi pack_start( *PexPreser, Gtk::PACK_SHRINK, 4); + pack_start( *PexBlackone, Gtk::PACK_SHRINK, 4);//black + pack_start( *PexBlackzero, Gtk::PACK_SHRINK, 4);//black + pack_start( *PexBlacktwo, Gtk::PACK_SHRINK, 4);//black + pack_start( *PexBlackthree, Gtk::PACK_SHRINK, 4);//black + pack_start( *PextwoGreen, Gtk::PACK_SHRINK, 4);//black 2 green + } void RAWExposure::read(const rtengine::procparams::ProcParams* pp, const ParamsEdited* pedited) @@ -46,10 +73,25 @@ void RAWExposure::read(const rtengine::procparams::ProcParams* pp, const ParamsE if(pedited ){ PexPos->setEditedState( pedited->raw.exPos ? Edited : UnEdited ); PexPreser->setEditedState( pedited->raw.exPreser ? Edited : UnEdited ); + PexBlackzero->setEditedState( pedited->raw.exBlackzero ? Edited : UnEdited ); + PexBlackone->setEditedState( pedited->raw.exBlackone ? Edited : UnEdited ); + PexBlacktwo->setEditedState( pedited->raw.exBlacktwo ? Edited : UnEdited ); + PexBlackthree->setEditedState( pedited->raw.exBlackthree ? Edited : UnEdited ); + } - + greenconn.block (true); + PextwoGreen->set_active (pp->raw.twogreen); + greenconn.block (false); + lastPextwoGreen = pp->raw.twogreen; + + PexPos->setValue (pp->raw.expos); PexPreser->setValue (pp->raw.preser);//exposi + PexBlackzero->setValue (pp->raw.blackzero);//black + PexBlackone->setValue (pp->raw.blackone);//black + PexBlacktwo->setValue (pp->raw.blacktwo);//black + + if(!PextwoGreen->get_active())PexBlackthree->setValue (pp->raw.blackthree);else PexBlackthree->setValue (PexBlackzero->getValue()); enableListener (); } @@ -58,10 +100,23 @@ void RAWExposure::write( rtengine::procparams::ProcParams* pp, ParamsEdited* ped { pp->raw.expos = PexPos->getValue(); pp->raw.preser = PexPreser->getValue();//exposi + pp->raw.blackzero = PexBlackzero->getValue();// black + pp->raw.blackone = PexBlackone->getValue();// black + pp->raw.blacktwo = PexBlacktwo->getValue();// black + pp->raw.twogreen=PextwoGreen->get_active(); + if(PextwoGreen->get_active()){pp->raw.blackthree=pp->raw.blackzero;} else {pp->raw.blackthree = PexBlackthree->getValue();}// active or desactive 2 green together + if (pedited) { pedited->raw.exPos = PexPos->getEditedState (); pedited->raw.exPreser = PexPreser->getEditedState ();//exposi + pedited->raw.exBlackzero = PexBlackzero->getEditedState ();//black + pedited->raw.exBlackone = PexBlackone->getEditedState ();//black + pedited->raw.exBlacktwo = PexBlacktwo->getEditedState ();//black + pedited->raw.exBlackthree = PexBlackthree->getEditedState ();//black + pedited->raw.exTwoGreen =!PextwoGreen->get_inconsistent(); + + } } @@ -70,30 +125,87 @@ void RAWExposure::adjusterChanged (Adjuster* a, double newval) { if (listener) { Glib::ustring value = a->getTextValue(); - if (a == PexPos) + { + + if (a == PexPos ) listener->panelChanged (EvPreProcessExpCorrLinear, value ); else if (a == PexPreser && ABS(PexPos->getValue()-1.0)>0.0001) // update takes long, only do it if it would have an effect listener->panelChanged (EvPreProcessExpCorrPH, value ); + else if (a == PexBlackzero) {if(!PextwoGreen->get_active()) + listener->panelChanged (EvPreProcessExpBlackzero, value ); else {listener->panelChanged (EvPreProcessExpBlackzero, value );PexBlackthree->setValue (PexBlackzero->getValue());}} + else if (a == PexBlackone) + listener->panelChanged (EvPreProcessExpBlackone, value ); + else if (a == PexBlacktwo) + listener->panelChanged (EvPreProcessExpBlacktwo, value ); + else if (a == PexBlackthree) {if(!PextwoGreen->get_active()) + listener->panelChanged (EvPreProcessExpBlackthree, value ); else {listener->panelChanged (EvPreProcessExpBlackthree, value );PexBlackzero->setValue (PexBlackthree->getValue());}} + } + } } +void RAWExposure::GreenChanged() { + if (batchMode) { + if (PextwoGreen->get_inconsistent()) { + PextwoGreen->set_inconsistent (false); + greenconn.block (true); + PextwoGreen->set_active (false); + greenconn.block (false); + } + else if (lastPextwoGreen) + PextwoGreen->set_inconsistent (true); + lastPextwoGreen = PextwoGreen->get_active (); + } + + if (listener) { + if (PextwoGreen->get_active()) + { listener->panelChanged (EvPreProcessExptwoGreen, M("GENERAL_ENABLED")); + PexBlackthree->setValue (PexBlackzero->getValue());//two green together + } + + else + { listener->panelChanged (EvPreProcessExptwoGreen, M("GENERAL_DISABLED")); + } + + } + +} void RAWExposure::setBatchMode(bool batchMode) { ToolPanel::setBatchMode (batchMode); PexPos->showEditedCB (); - PexPreser->showEditedCB ();//exposi + PexPreser->showEditedCB ();//exposure + PexBlackzero->showEditedCB ();//black + PexBlackone->showEditedCB ();//black + PexBlacktwo->showEditedCB ();//black + PexBlackthree->showEditedCB ();//black + } void RAWExposure::setDefaults(const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited) { PexPos->setDefault( defParams->raw.expos); PexPreser->setDefault( defParams->raw.preser); + PexBlackzero->setDefault( defParams->raw.blackzero); + PexBlackone->setDefault( defParams->raw.blackone); + PexBlacktwo->setDefault( defParams->raw.blacktwo); + PexBlackthree->setDefault( defParams->raw.blackthree); if (pedited) { PexPos->setDefaultEditedState( pedited->raw.exPos ? Edited : UnEdited); PexPreser->setDefaultEditedState( pedited->raw.exPreser ? Edited : UnEdited); + PexBlackzero->setDefaultEditedState( pedited->raw.exBlackzero ? Edited : UnEdited); + PexBlackone->setDefaultEditedState( pedited->raw.exBlackone ? Edited : UnEdited); + PexBlacktwo->setDefaultEditedState( pedited->raw.exBlacktwo ? Edited : UnEdited); + PexBlackthree->setDefaultEditedState( pedited->raw.exBlackthree ? Edited : UnEdited); + } else { PexPos->setDefaultEditedState( Irrelevant ); PexPreser->setDefaultEditedState( Irrelevant ); + PexBlackzero->setDefaultEditedState( Irrelevant ); + PexBlackone->setDefaultEditedState( Irrelevant ); + PexBlacktwo->setDefaultEditedState( Irrelevant ); + PexBlackthree->setDefaultEditedState( Irrelevant ); + } } diff --git a/rtgui/rawexposure.h b/rtgui/rawexposure.h index ad56b2d7c..452ce96ce 100644 --- a/rtgui/rawexposure.h +++ b/rtgui/rawexposure.h @@ -29,7 +29,16 @@ class RAWExposure : public Gtk::VBox, public AdjusterListener, public FoldableTo protected: Adjuster* PexPos; Adjuster* PexPreser; + Adjuster* PexBlackzero; + Adjuster* PexBlackone; + Adjuster* PexBlacktwo; + Adjuster* PexBlackthree; + bool lastPextwoGreen; + sigc::connection greenconn; + Gtk::CheckButton* PextwoGreen; +private: +// Gtk::CheckButton* PextwoGreen; public: RAWExposure (); @@ -38,8 +47,8 @@ public: void write (rtengine::procparams::ProcParams* pp, ParamsEdited* pedited=NULL); void setBatchMode (bool batchMode); void setDefaults (const rtengine::procparams::ProcParams* defParams, const ParamsEdited* pedited=NULL); - - void adjusterChanged (Adjuster* a, double newval); + void GreenChanged() ; + void adjusterChanged (Adjuster* a, double newval); }; #endif