rawTherapee/rtengine/PF_correct_RT.cc

////////////////////////////////////////////////////////////////
//
//		Chromatic Aberration Auto-correction
//
//		copyright (c) 2008-2010  Emil Martinec <ejmartin@uchicago.edu>
//
//
// code dated: November 24, 2010
//
//	PF_correct_RT.cc is free software: you can redistribute it and/or modify
//	it under the terms of the GNU General Public License as published by
//	the Free Software Foundation, either version 3 of the License, or
//	(at your option) any later version.
//
//	This program is distributed in the hope that it will be useful,
//	but WITHOUT ANY WARRANTY; without even the implied warranty of
//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//	GNU General Public License for more details.
//
//	You should have received a copy of the GNU General Public License
//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
////////////////////////////////////////////////////////////////
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

#include "gauss.h"
#include "improcfun.h"

#ifdef _OPENMP
#include <omp.h>
#endif

#include "rt_math.h"

using namespace std;

namespace rtengine {

void ImProcFunctions::PF_correct_RT(LabImage * src, LabImage * dst, double radius, int thresh) {
	int halfwin = ceil(2*radius)+1;

#include "rt_math.h"

	// local variables
	int width=src->W, height=src->H;
	//temporary array to store chromaticity
	int (*fringe);
	fringe = (int (*)) calloc ((height)*(width), sizeof *fringe);

	LabImage * tmp1;
	tmp1 = new LabImage(width, height);

#ifdef _OPENMP
#pragma omp parallel
#endif
	{
		AlignedBufferMP<double> buffer(max(src->W,src->H));

		gaussHorizontal<float> (src->a, tmp1->a, buffer, src->W, src->H, radius);
		gaussHorizontal<float> (src->b, tmp1->b, buffer, src->W, src->H, radius);
		gaussVertical<float>   (tmp1->a, tmp1->a, buffer, src->W, src->H, radius);
		gaussVertical<float>   (tmp1->b, tmp1->b, buffer, src->W, src->H, radius);

//		gaussHorizontal<float> (src->L, tmp1->L, buffer, src->W, src->H, radius);
//		gaussVertical<float>   (tmp1->L, tmp1->L, buffer, src->W, src->H, radius);
	}

float chromave=0;
#ifdef _OPENMP
#pragma omp parallel for reduction(+:chromave)
#endif
	for(int i = 0; i < height; i++ ) {
		for(int j = 0; j < width; j++) {
			float chroma = SQR(src->a[i][j]-tmp1->a[i][j])+SQR(src->b[i][j]-tmp1->b[i][j]);
			chromave += chroma;
			fringe[i*width+j]=chroma;
		}
	}
	chromave /= (height*width);
	float threshfactor = (thresh*chromave)/33.f;      // Calculated once to eliminate mult inside the next loop
//	printf("Chro %f \n",chromave);

// Issue 1674:
// often, CA isn't evenly distributed, e.g. a lot in contrasty regions and none in the sky.
// so it's better to schedule dynamic and let every thread only process 16 rows, to avoid running big threads out of work
// Measured it and in fact gives better performance than without schedule(dynamic,16). Of course, there could be a better
// choice for the chunk_size than 16
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic,16)
#endif
	for(int i = 0; i < height; i++ ) {
		for(int j = 0; j < width; j++) {
			tmp1->a[i][j] = src->a[i][j];
			tmp1->b[i][j] = src->b[i][j];
			//test for pixel darker than some fraction of neighborhood ave, near an edge, more saturated than average
			/*if (100*tmp1->L[i][j]>50*src->L[i][j] && \*/
				/*1000*abs(tmp1->L[i][j]-src->L[i][j])>thresh*(tmp1->L[i][j]+src->L[i][j]) && \*/
			if (fringe[i*width+j]>threshfactor) {
				float atot=0.f;
				float btot=0.f;
				float norm=0.f;
				float wt;
				for (int i1=max(0,i-halfwin+1); i1<min(height,i+halfwin); i1++)
					for (int j1=max(0,j-halfwin+1); j1<min(width,j+halfwin); j1++) {
						//neighborhood average of pixels weighted by chrominance
						wt = 1.f/(fringe[i1*width+j1]+chromave);
						atot += wt*src->a[i1][j1];
						btot += wt*src->b[i1][j1];
						norm += wt;
					}
				tmp1->a[i][j] = (int)(atot/norm);
				tmp1->b[i][j] = (int)(btot/norm);
			}//end of ab channel averaging
		}
	}

#ifdef _OPENMP
#pragma omp parallel for
#endif

	for(int i = 0; i < height; i++ ) {
		for(int j = 0; j < width; j++) {
			dst->L[i][j] = src->L[i][j];
			dst->a[i][j] = tmp1->a[i][j];
			dst->b[i][j] = tmp1->b[i][j];
		}
	}

	delete tmp1;
	free(fringe);
}
void ImProcFunctions::PF_correct_RTcam(CieImage * src, CieImage * dst, double radius, int thresh) {
	int halfwin = ceil(2*radius)+1;

#include "rt_math.h"

	// local variables
	int width=src->W, height=src->H;
	float piid=3.14159265f/180.f;
	//temporary array to store chromaticity
	int (*fringe);
	fringe = (int (*)) calloc ((height)*(width), sizeof *fringe);

	float** sraa;
		sraa = new float*[height];
		for (int i=0; i<height; i++)
			sraa[i] = new float[width];

#ifdef _OPENMP
#pragma omp parallel for
#endif
		for (int i=0; i<height; i++)
			for (int j=0; j<width; j++) {
				sraa[i][j]=src->C_p[i][j]*cos(piid*src->h_p[i][j]);
			}
	float** tmaa;
		tmaa = new float*[height];
		for (int i=0; i<height; i++)
			tmaa[i] = new float[width];

	float** srbb;
	srbb = new float*[height];
		for (int i=0; i<height; i++)
			srbb[i] = new float[width];

#ifdef _OPENMP
#pragma omp parallel for
#endif
		for (int i=0; i<height; i++)
			for (int j=0; j<width; j++) {
				srbb[i][j]=src->C_p[i][j]*sin(piid*src->h_p[i][j]);
			}
	float** tmbb;
		tmbb = new float*[height];
	for (int i=0; i<height; i++)
			tmbb[i] = new float[width];

	/*float** tmL;
		tmL = new float*[height];
	for (int i=0; i<height; i++)
			tmL[i] = new float[width];
*/

#ifdef _OPENMP
#pragma omp parallel
#endif
	{
		AlignedBufferMP<double> buffer(max(src->W,src->H));
		gaussHorizontal<float> (sraa, tmaa, buffer, src->W, src->H, radius);
		gaussHorizontal<float> (srbb, tmbb, buffer, src->W, src->H, radius);
		gaussVertical<float>   (tmaa, tmaa, buffer, src->W, src->H, radius);
		gaussVertical<float>   (tmbb, tmbb, buffer, src->W, src->H, radius);
	//	gaussHorizontal<float> (src->sh_p, tmL, buffer, src->W, src->H, radius);
	//	gaussVertical<float>   (tmL, tmL, buffer, src->W, src->H, radius);

	}

float chromave=0;
#ifdef _OPENMP
#pragma omp parallel for reduction(+:chromave)
#endif
	for(int i = 0; i < height; i++ ) {
		for(int j = 0; j < width; j++) {
			float chroma =SQR(sraa[i][j]-tmaa[i][j])+SQR(srbb[i][j]-tmbb[i][j]);
			chromave += chroma;
			fringe[i*width+j]=chroma;
		}
	}
	chromave /= (height*width);
	float threshfactor = (thresh*chromave)/33.f;      // Calculated once to eliminate mult inside the next loop
	//	printf("Chromave CAM %f \n",chromave);

// Issue 1674:
// often, CA isn't evenly distributed, e.g. a lot in contrasty regions and none in the sky.
// so it's better to schedule dynamic and let every thread only process 16 rows, to avoid running big threads out of work
// Measured it and in fact gives better performance than without schedule(dynamic,16). Of course, there could be a better
// choice for the chunk_size than 16
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic,16)
#endif
	for(int i = 0; i < height; i++ ) {
		for(int j = 0; j < width; j++) {
			tmaa[i][j] = sraa[i][j];
			tmbb[i][j] = srbb[i][j];

			//test for pixel darker than some fraction of neighborhood ave, near an edge, more saturated than average
			/*if (100*tmp1->L[i][j]>50*src->L[i][j] && \*/
				/*1000*abs(tmp1->L[i][j]-src->L[i][j])>thresh*(tmp1->L[i][j]+src->L[i][j]) && \*/
			if (fringe[i*width+j]>threshfactor) {
				float atot=0.f;
				float btot=0.f;
				float norm=0.f;
				float wt;
				for (int i1=max(0,i-halfwin+1); i1<min(height,i+halfwin); i1++)
					for (int j1=max(0,j-halfwin+1); j1<min(width,j+halfwin); j1++) {
						//neighborhood average of pixels weighted by chrominance
						wt = 1.f/(fringe[i1*width+j1]+chromave);
						atot += wt*sraa[i1][j1];
						btot += wt*srbb[i1][j1];
						norm += wt;
					}
				tmaa[i][j] = (int)(atot/norm);
				tmbb[i][j] = (int)(btot/norm);
			}//end of ab channel averaging
		}
	}

#ifdef _OPENMP
#pragma omp parallel for
#endif

	for(int i = 0; i < height; i++ ) {
		for(int j = 0; j < width; j++) {
			dst->sh_p[i][j] = src->sh_p[i][j];
			float intera = tmaa[i][j];
			float interb = tmbb[i][j];
			dst->h_p[i][j]=(atan2(interb,intera))/piid;
			dst->C_p[i][j]=sqrt(SQR(interb)+SQR(intera));
		}
	}
                for (int i=0; i<height; i++)
                    delete [] sraa[i];
                delete [] sraa;
                for (int i=0; i<height; i++)
                    delete [] srbb[i];
                delete [] srbb;
                for (int i=0; i<height; i++)
                    delete [] tmaa[i];
                delete [] tmaa;
                for (int i=0; i<height; i++)
                    delete [] tmbb[i];
                delete [] tmbb;
           /*     for (int i=0; i<height; i++)
                    delete [] tmL[i];
                delete [] tmL;
			*/
	free(fringe);
}


}