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

Minor updates, code cleanup.

Browse Source
This commit is contained in:
Emil Martinec
2012-03-08 14:52:57 -06:00
parent 0f21937c02
commit 380728e1f0
4 changed files with 74 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
rtengine/FTblockDNchroma.cc
View File

@@ -184,9 +184,9 @@ namespace rtengine {
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/*if (plistener) {
plistener->setProgressStr ("Denoise...");
plistener->setProgress (0.0);
}*/
plistener->setProgressStr ("Denoise...");
plistener->setProgress (0.0);
}*/
volatile double progress = 0.0;
@@ -207,15 +207,7 @@ namespace rtengine {
}
//const int blkrad=2;
float noisevar_L = SQR((100-dnparams.Ldetail) * TS * 100.0f);
float noisevar_ab = SQR(dnparams.chroma * TS * 150.0f);
// calculation for tiling
const int numblox_W = ceil(((float)(width))/(offset))+2*blkrad;
const int numblox_H = ceil(((float)(height))/(offset))+2*blkrad;
//const int nrtiles = numblox_W*numblox_H;
// end of tiling calc
float noisevar_Ldetail = SQR((100-dnparams.Ldetail) * TS * 100.0f);
array2D<float> tilemask_in(TS,TS);
@@ -240,6 +232,18 @@ namespace rtengine {
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// TODO: begin block processing
const int tilesize = 1000;
const int overlap = 100;
if (width>tilesize and height>tilesize) {
const int numtiles_W = ceil(((float)(width))/(tilesize-overlap));
const int numtiles_H = ceil(((float)(height))/(tilesize-overlap));
int tilewidth = ceil(((float)(width))/(numtiles_W));
int tileheight = ceil(((float)(height))/(numtiles_H));
tilewidth = tilewidth + (tilewidth&1);
tileheight = tileheight + (tileheight&1);
}
LabImage * labin = new LabImage(width,height);
LabImage * labdn = new LabImage(width,height);
@@ -252,15 +256,17 @@ namespace rtengine {
memcpy (labdn->data, labin->data, 3*width*height*sizeof(float));
//initial impulse denoise
impulse_nr (labdn, 50.0f/20.0f);
int datalen = labin->W * labin->H;
//now perform basic wavelet denoise
wavelet_decomposition Ldecomp(labin->data, labin->W, labin->H, 5/*maxlevels*/, 0/*subsampling*/ );
wavelet_decomposition adecomp(labin->data+datalen, labin->W, labin->H, 5, 1 );//last args are maxlevels, subsampling
wavelet_decomposition bdecomp(labin->data+2*datalen, labin->W, labin->H, 5, 1 );//last args are maxlevels, subsampling
float noisevarL = SQR(dnparams.luma/25.0f);//TODO: clean up naming confusion about params
float noisevarL = SQR(dnparams.luma/25.0f);
float noisevarab = SQR(dnparams.chroma/10.0f);
WaveletDenoiseAll_BiShrink(Ldecomp, adecomp, bdecomp, noisevarL, noisevarab);
@@ -269,6 +275,9 @@ namespace rtengine {
adecomp.reconstruct(labdn->data+datalen);
bdecomp.reconstruct(labdn->data+2*datalen);
//TODO: at this point wavelet coefficients storage can be freed
//second impulse denoise
impulse_nr (labdn, 50.0f/20.0f);
//PF_correct_RT(dst, dst, defringe.radius, defringe.threshold);
@@ -281,7 +290,17 @@ namespace rtengine {
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// allocate FT data structures
// now do detail recovery using block DCT to detect patterns
// missed by wavelet denoise
// allocate DCT data structures
// calculation for detail recovery tiling
const int numblox_W = ceil(((float)(width))/(offset))+2*blkrad;
const int numblox_H = ceil(((float)(height))/(offset))+2*blkrad;
//const int nrtiles = numblox_W*numblox_H;
// end of tiling calc
float ** Lblox = new float *[8] ;
@@ -375,12 +394,12 @@ namespace rtengine {
int hblproc = hblk;
RGBtile_denoise (fLblox, vblproc, hblproc, numblox_H, numblox_W, noisevar_L, noisevar_ab );
RGBtile_denoise (fLblox, vblproc, hblproc, numblox_H, numblox_W, noisevar_Ldetail );
if (vblk==(numblox_H-1)) {//denoise last blkrad rows
for (vblproc=(vblk-blkrad+1); vblproc<numblox_H; vblproc++) {
vblprocmod = vblproc%8;
RGBtile_denoise (fLblox, vblproc, hblproc, numblox_H, numblox_W, noisevar_L, noisevar_ab );
RGBtile_denoise (fLblox, vblproc, hblproc, numblox_H, numblox_W, noisevar_Ldetail );
}
}
@@ -457,8 +476,7 @@ namespace rtengine {
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
void ImProcFunctions::RGBtile_denoise (float ** fLblox, int vblproc, int hblproc, int numblox_H, int numblox_W, \
float noisevar_L, float noisevar_ab ) //for DCT
void ImProcFunctions::RGBtile_denoise (float ** fLblox, int vblproc, int hblproc, int numblox_H, int numblox_W, float noisevar_Ldetail ) //for DCT
{
int vblprocmod=vblproc%8;
@@ -469,7 +487,7 @@ namespace rtengine {
boxabsblur(fLblox[vblprocmod]+blkstart, nbrwt, 3, 3, TS, TS);//blur neighbor weights for more robust estimation //for DCT
for (int n=0; n<TS*TS; n++) { //for DCT
fLblox[vblprocmod][blkstart+n] *= (1-expf(-SQR(nbrwt[n])/noisevar_L));
fLblox[vblprocmod][blkstart+n] *= (1-expf(-SQR(nbrwt[n])/noisevar_Ldetail));
}//output neighbor averaged result
delete[] nbrwt;

101
rtengine/cplx_wavelet_level.h
View File

@@ -80,7 +80,7 @@ namespace rtengine {
float *filterLo, float *filterHi, int taps, int offset, int pitch, int dstlen);
void AnalysisFilterSubsampHaar (T * srcbuffer, T * dstLo, T * dstHi, int pitch, int srclen);
void SynthesisFilterSubsampHaar (T * srcLo, T * srcHi, T * dst, T *bufferLo, T *bufferHi, int pitch, int dstlen);
void SynthesisFilterSubsampHaar (T * srcLo, T * srcHi, T * dst, int pitch, int dstlen);
void imp_nr (T* src, int width, int height, double thresh);
@@ -337,71 +337,7 @@ namespace rtengine {
dst[pitch*(i-m_pad)] = (bufferLo[i] + bufferHi[i]);
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
/*
template<typename T>
void wavelet_level<T>::AnalysisFilterLeGall (T * srcbuffer, T * dstLo, T * dstHi, int pitch, int srclen) {
// Basic convolution code
// Applies a LeGall (CDF 5/3) filter
for(size_t i = skip; i < (srclen - 3*skip); i++) {
dstLo[(pitch*(i))] = 0.25*(srcbuffer[i-skip] + 2*srcbuffer[i] + srcbuffer[i+skip]);
dstHi[(pitch*(i))] = -0.125*(srcbuffer[i-skip] + srcbuffer[i+3*skip]) - 0.25*(srcbuffer[i] + srcbuffer[i+2*skip]) + 0.75*srcbuffer[i+skip];
}
for(size_t i = 0; i < skip; i++) {
dstLo[(pitch*(i))] = 0.25*(srcbuffer[MAX(0,i-skip)] + 2*srcbuffer[i] + srcbuffer[i+skip]);
dstHi[(pitch*(i))] = (-0.125*(srcbuffer[MAX(0,i-skip)] + srcbuffer[i+3*skip]) - \
0.25*(srcbuffer[i] + srcbuffer[i+2*skip]) + 0.75*srcbuffer[i+skip]);
}
for(size_t i = (srclen-3*skip); i < (srclen); i++) {
dstLo[(pitch*(i))] = 0.25*(srcbuffer[i-skip] + 2*srcbuffer[i] + srcbuffer[MIN(srclen-1,i+skip)]);
dstHi[(pitch*(i))] = (-0.125*(srcbuffer[i-skip] + srcbuffer[MIN(srclen-1,i+3*skip)]) - \
0.25*(srcbuffer[i] + srcbuffer[MIN(srclen-1,i+2*skip)]) + 0.75*srcbuffer[MIN(srclen-1,i+skip)]);
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
template<typename T>
void wavelet_level<T>::SynthesisFilterLeGall (T * srcLo, T * srcHi, T * dst, T *bufferLo, T *bufferHi, int pitch, int dstlen) {
// Basic convolution code
//Applies a LeGall (CDF 5/3) filter
int srclen = (dstlen==m_w ? m_w2 : m_h2);//length of row/col in src (coarser level)
for (size_t i=0, j=0; i<srclen; i++, j+=pitch) {
bufferLo[i]=srcLo[j];
bufferHi[i]=srcHi[j];
}
for(size_t i = m_pad+2*skip; i < (dstlen+m_pad-2*skip); i++) {
dst[pitch*(i-m_pad)] = (-0.125*(bufferLo[i-2*skip] + bufferLo[i+2*skip]) + 0.25*(bufferLo[i-skip] - bufferLo[i+skip]) + 0.75*bufferLo[skip] + \
-0.25*(bufferHi[i] + bufferHi[i+2*skip]) + 0.5*bufferHi[skip]);
}
for(size_t i = m_pad; i < (m_pad+2*skip); i++) {
dst[pitch*(i-m_pad)] = (-0.125*(bufferLo[MAX(0,i-2*skip)] + bufferLo[i+2*skip]) + 0.25*(bufferLo[MAX(0,i-skip)] - bufferLo[i+skip]) + 0.75*bufferLo[skip] + \
-0.25*(bufferHi[i] + bufferHi[i+2*skip]) + 0.5*bufferHi[i+skip]);
}
for(size_t i = (dstlen+m_pad-2*skip); i < dstlen; i++) {
dst[pitch*(i-m_pad)] = (-0.125*(bufferLo[i-2*skip] + bufferLo[MIN(dstlen-1,i+2*skip)]) + 0.25*(bufferLo[i-skip] - bufferLo[MIN(dstlen-1,i+skip)]) + 0.75*bufferLo[skip] + \
-0.25*(bufferHi[i] + bufferHi[MIN(dstlen-1,i+2*skip)]) + 0.5*bufferHi[MIN(dstlen-1,i+skip)]);
}
}
*/
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -522,23 +458,26 @@ namespace rtengine {
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
template<typename T>
void wavelet_level<T>::SynthesisFilterSubsampHaar (T * srcLo, T * srcHi, T * dst, T *bufferLo, T *bufferHi, int pitch, int dstlen) {
void wavelet_level<T>::SynthesisFilterSubsampHaar (T * srcLo, T * srcHi, T * dst, int pitch, int dstlen) {
/* Basic convolution code
* Applies a Haar filter
* Output was subsampled by two
* Input was subsampled by two
*/
// calculate coefficients
for(size_t i = m_pad; i < (dstlen+m_pad-skip); i+=2) {
dst[pitch*(i-m_pad)] = bufferLo[i/2]+bufferHi[i/2];
dst[pitch*(i+1-m_pad)] = bufferLo[i/2]-bufferHi[i/2];
//TODO: this code is buggy...
for(size_t i = m_pad; i < (dstlen+m_pad-skip); i+=2*skip) {
dst[pitch*(i-m_pad)] = srcLo[i/2]+srcHi[i/2];
dst[pitch*(i+skip-m_pad)] = srcLo[i/2]-srcHi[i/2];
}
if ((dstlen+m_pad)&1) {
dst[pitch*(dstlen-1)] = bufferLo[(dstlen+m_pad-1)/2]+bufferHi[(dstlen+m_pad-1)/2];
if ((dstlen+m_pad-skip)<dstlen-1) {
for (size_t i=(dstlen+m_pad-skip); i<dstlen+m_pad-1; i++) {
dst[pitch*(dstlen-m_pad)] = srcLo[i/2]+srcHi[i/2];
}
}
}
@@ -563,7 +502,8 @@ namespace rtengine {
for (int j=0; j<m_w; j++) {
loadbuffer(src+j, buffer, m_w/*pitch*/, m_h/*srclen*/);//pad a column of data and load it to buffer
if (subsamp_out) {
AnalysisFilterSubsamp (buffer, tmpLo+j, tmpHi+j, filterV, filterV+taps, taps, offset, m_w/*output_pitch*/, m_h/*srclen*/);
//AnalysisFilterSubsamp (buffer, tmpLo+j, tmpHi+j, filterV, filterV+taps, taps, offset, m_w/*output_pitch*/, m_h/*srclen*/);
AnalysisFilterSubsampHaar (buffer, tmpLo+j, tmpHi+j, m_w, m_h);
} else {
//AnalysisFilter (buffer, tmpLo+j, tmpHi+j, filterV, filterV+taps, taps, offset, m_w/*output_pitch*/, m_h/*srclen*/);
AnalysisFilterHaar (buffer, tmpLo+j, tmpHi+j, m_w, m_h);
@@ -574,14 +514,16 @@ namespace rtengine {
for (int i=0; i<m_h2; i++) {
loadbuffer(tmpLo+i*m_w, buffer, 1/*pitch*/, m_w/*srclen*/);//pad a row of data and load it to buffer
if (subsamp_out) {
AnalysisFilterSubsamp (buffer, wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, filterH, filterH+taps, taps, offset, 1/*output_pitch*/, m_w/*srclen*/);
//AnalysisFilterSubsamp (buffer, wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, filterH, filterH+taps, taps, offset, 1/*output_pitch*/, m_w/*srclen*/);
AnalysisFilterSubsampHaar (buffer, wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, 1, m_w);
} else {
//AnalysisFilter (buffer, wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, filterH, filterH+taps, taps, offset, 1/*output_pitch*/, m_w/*srclen*/);
AnalysisFilterHaar (buffer, wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, 1, m_w);
}
loadbuffer(tmpHi+i*m_w, buffer, 1/*pitch*/, m_w/*srclen*/);
if (subsamp_out) {
AnalysisFilterSubsamp (buffer, wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, filterH, filterH+taps, taps, offset, 1/*output_pitch*/, m_w/*srclen*/);
//AnalysisFilterSubsamp (buffer, wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, filterH, filterH+taps, taps, offset, 1/*output_pitch*/, m_w/*srclen*/);
AnalysisFilterSubsampHaar (buffer, wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, 1, m_w);
} else {
//AnalysisFilter (buffer, wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, filterH, filterH+taps, taps, offset, 1/*output_pitch*/, m_w/*srclen*/);
AnalysisFilterHaar (buffer, wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, 1, m_w);
@@ -612,10 +554,12 @@ namespace rtengine {
for (int i=0; i<m_h2; i++) {
if (subsamp_out) {
SynthesisFilterSubsamp (wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, tmpLo+i*m_w, bufferLo, bufferHi,
SynthesisFilterSubsamp (wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, tmpLo+i*m_w, bufferLo, bufferHi, \
filterH, filterH+taps, taps, offset, 1/*pitch*/, m_w/*dstlen*/);
SynthesisFilterSubsamp (wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, tmpHi+i*m_w, bufferLo, bufferHi,
SynthesisFilterSubsamp (wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, tmpHi+i*m_w, bufferLo, bufferHi, \
filterH, filterH+taps, taps, offset, 1/*pitch*/, m_w/*dstlen*/);
//SynthesisFilterSubsampHaar (wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, tmpLo+i*m_w, 1, m_w);
//SynthesisFilterSubsampHaar (wavcoeffs[2]+i*m_w2, wavcoeffs[3]+i*m_w2, tmpHi+i*m_w, 1, m_w);
} else {
//SynthesisFilter (wavcoeffs[0]+i*m_w2, wavcoeffs[1]+i*m_w2, tmpLo+i*m_w, bufferLo, bufferHi, \
filterH, filterH+taps, taps, offset, 1/*pitch*/, m_w/*dstlen*/);
@@ -629,8 +573,9 @@ namespace rtengine {
/* filter along columns */
for (int j=0; j<m_w; j++) {
if (subsamp_out) {
SynthesisFilterSubsamp (tmpLo+j, tmpHi+j, dst+j, bufferLo, bufferHi,
SynthesisFilterSubsamp (tmpLo+j, tmpHi+j, dst+j, bufferLo, bufferHi, \
filterV, filterV+taps, taps, offset, m_w/*pitch*/, m_h/*dstlen*/);
//SynthesisFilterSubsampHaar (tmpLo+j, tmpHi+j, dst+j, m_w, m_h);
} else {
//SynthesisFilter (tmpLo+j, tmpHi+j, dst+j, bufferLo, bufferHi, \
filterV, filterV+taps, taps, offset, m_w/*pitch*/, m_h/*dstlen*/);

13
rtengine/improccoordinator.cc
View File

@@ -145,6 +145,19 @@ void ImProcCoordinator::updatePreviewImage (int todo, Crop* cropCall) {
|| (!params.hlrecovery.enabled && params.hlrecovery.method=="Color" && imgsrc->IsrgbSourceModified())){
if (settings->verbose) printf("Demosaic %s\n",rp.dmethod.c_str());
currWB = ColorTemp (params.wb.temperature, params.wb.green, params.wb.method);
if (params.wb.method=="Camera")
currWB = imgsrc->getWB ();
else if (params.wb.method=="Auto") {
if (!awbComputed) {
autoWB = imgsrc->getAutoWB ();
awbComputed = true;
}
currWB = autoWB;
}
params.wb.temperature = currWB.getTemp ();
params.wb.green = currWB.getGreen ();
imgsrc->demosaic( rp );
}
lastHighDetail=highDetailNeeded;

2
rtengine/improcfun.h
View File

@@ -146,7 +146,7 @@ namespace rtengine {
void RGB_OutputTransf(LabImage * src, Imagefloat * dst, const procparams::DirPyrDenoiseParams & dnparams);
void output_tile_row (float *Lbloxrow, float ** Lhipassdn, float ** tilemask, int height, int width, int top, int blkrad );
void RGB_denoise(Imagefloat * src, Imagefloat * dst, const procparams::DirPyrDenoiseParams & dnparams, const procparams::DefringeParams & defringe);
void RGBtile_denoise (float ** fLblox, int vblproc, int hblproc, int numblox_H, int numblox_W, float noisevar_L, float noisevar_ab ); //for DCT
void RGBtile_denoise (float ** fLblox, int vblproc, int hblproc, int numblox_H, int numblox_W, float noisevar_L ); //for DCT
void RGBoutput_tile_row (float *Lbloxrow, LabImage * labdn, float ** tilemask_out, int height, int width, int top );
void WaveletDenoise(cplx_wavelet_decomposition &DualTreeCoeffs, float noisevar );
void WaveletDenoise(wavelet_decomposition &WaveletCoeffs, float noisevar );