/***************************************************************************

 *   Copyright (C) 1998-2008 by authors (see AUTHORS.txt )                 *

 *                                                                         *

 *   This file is part of LuxRender.                                       *

 *                                                                         *

 *   Lux Renderer 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.                                   *

 *                                                                         *

 *   Lux Renderer 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/>. *

 *                                                                         *

 *   This project is based on PBRT ; see http://www.pbrt.org               *

 *   Lux Renderer website : http://www.luxrender.net                       *

 ***************************************************************************/

 // film.cpp*

 #include "film.h"

 #include "randomgen.h"

 #include "dynload.h"

 #include "paramset.h"

 #include "tonemap.h"

 #include "cameraresponse.h"

 #include "filter.h"

 #include "contribution.h"

 #include "blackbodyspd.h"

 #include "osfunc.h"

 #include "streamio.h"

 #include <iostream>

 #include <fstream>

 #include <boost/archive/text_oarchive.hpp>

 #include <boost/archive/text_iarchive.hpp>

 #include <boost/archive/binary_oarchive.hpp>

 #include <boost/archive/binary_iarchive.hpp>

 #include <boost/serialization/split_member.hpp>

 #include <boost/iostreams/filtering_stream.hpp>

 #include <boost/iostreams/filtering_streambuf.hpp>

 #include <boost/iostreams/copy.hpp>

 #include <boost/iostreams/filter/zlib.hpp>

 #include <boost/iostreams/filter/bzip2.hpp>

 #include <boost/iostreams/filter/gzip.hpp>

 #include <boost/filesystem.hpp>

 #include <boost/thread.hpp>

 #define cimg_display_type  0

 #ifdef LUX_USE_CONFIG_H

 #include "config.h"

 #ifdef PNG_FOUND

 #define cimg_use_png 1

 #endif

 #ifdef JPEG_FOUND

 #define cimg_use_jpeg 1

 #endif

 #ifdef TIFF_FOUND

 #define cimg_use_tiff 1

 #endif

 #else //LUX_USE_CONFIG_H

 #define cimg_use_png 1

 #define cimg_use_tiff 1

 #define cimg_use_jpeg 1

 #endif //LUX_USE_CONFIG_H

 #define cimg_debug 0     // Disable modal window in CImg exceptions.

 // Include the CImg Library, with the GREYCstoration plugin included

 #define cimg_plugin "greycstoration.h"

 #include "cimg.h"

 using namespace cimg_library;

 #if cimg_OS!=2

 #include <pthread.h>

 #endif

 using namespace boost::iostreams;

 using namespace lux;

 template<typename T> 

 static T bilinearSampleImage(const vector<T> &pixels,

 	const u_int xResolution, const u_int yResolution, 

 	const float x, const float y)

 {

 	u_int x1 = Clamp(Floor2UInt(x), 0U, xResolution - 1);

 	u_int y1 = Clamp(Floor2UInt(y), 0U, yResolution - 1);

 	u_int x2 = Clamp(x1 + 1, 0U, xResolution - 1);

 	u_int y2 = Clamp(y1 + 1, 0U, yResolution - 1);

 	float tx = Clamp(x - static_cast<float>(x1), 0.f, 1.f);

 	float ty = Clamp(y - static_cast<float>(y1), 0.f, 1.f);

 	T c(0.f);

 	c.AddWeighted((1.f - tx) * (1.f - ty), pixels[y1 * xResolution + x1]);

 	c.AddWeighted(tx         * (1.f - ty), pixels[y1 * xResolution + x2]);

 	c.AddWeighted((1.f - tx) * ty,         pixels[y2 * xResolution + x1]);

 	c.AddWeighted(tx         * ty,         pixels[y2 * xResolution + x2]);

 	return c;

 }

 // horizontal blur

 static void horizontalGaussianBlur(const vector<XYZColor> &in, vector<XYZColor> &out,

 	const u_int xResolution, const u_int yResolution, float std_dev)

 {

 	u_int rad_needed = Ceil2UInt(std_dev * 4.f);//kernel_radius;

 	const u_int lookup_size = rad_needed + 1;

 	//build filter lookup table

 	std::vector<float> filter_weights(lookup_size);

 	float sweight = 0.f;

 	for(u_int x = 0; x < lookup_size; ++x) {

 		filter_weights[x] = expf(-static_cast<float>(x) * static_cast<float>(x) / (std_dev * std_dev));

 		if (x > 0) {

 			if (filter_weights[x] < 1e-12f) {

 				rad_needed = x;

 				break;

 			}

 			sweight += 2.f * filter_weights[x];

 		} else

 			sweight += filter_weights[x];

 	}

 	//normalise filter kernel

 	sweight = 1.f / sweight;

 	const u_int pixel_rad = rad_needed;

 	//------------------------------------------------------------------

 	//blur in x direction

 	//------------------------------------------------------------------

 	for(u_int y = 0; y < yResolution; ++y) {

 		for(u_int x = 0; x < xResolution; ++x) {

 			const u_int a = y * xResolution + x;

 			out[a] = XYZColor(0.f);

 			for (u_int i = max(x, pixel_rad) - pixel_rad; i <= min(x + pixel_rad, xResolution - 1); ++i) {

 				if (i < x)

 					out[a].AddWeighted(filter_weights[x - i], in[a + i - x]);

 				else

 					out[a].AddWeighted(filter_weights[i - x], in[a + i - x]);

 			}

 		}

 	}

 }

 static void rotateImage(const vector<XYZColor> &in, vector<XYZColor> &out,

 	const u_int xResolution, const u_int yResolution, float angle)

 {

 	const u_int maxRes = max(xResolution, yResolution);

 	const float s = sinf(-angle);

 	const float c = cosf(-angle);

 	const float cx = xResolution * 0.5f;

 	const float cy = yResolution * 0.5f;

 	for(u_int y = 0; y < maxRes; ++y) {

 		float px = 0.f - maxRes * 0.5f;

 		float py = y - maxRes * 0.5f;

 		float rx = px * c - py * s + cx;

 		float ry = px * s + py * c + cy;

 		for(u_int x = 0; x < maxRes; ++x) {

 			out[y*maxRes + x] = bilinearSampleImage<XYZColor>(in, xResolution, yResolution, rx, ry);

 			// x = x + dx

 			rx += c;

 			ry += s;

 		}

 	}

 }

 namespace lux {

 // Image Pipeline Function Definitions

 void ApplyImagingPipeline(vector<XYZColor> &xyzpixels,

 	u_int xResolution, u_int yResolution,

 	const GREYCStorationParams &GREYCParams, const ChiuParams &chiuParams,

 	const ColorSystem &colorSpace, Histogram *histogram, bool HistogramEnabled,

 	bool &haveBloomImage, XYZColor *&bloomImage, bool bloomUpdate,

 	float bloomRadius, float bloomWeight,

 	bool VignettingEnabled, float VignetScale,

 	bool aberrationEnabled, float aberrationAmount,

 	bool &haveGlareImage, XYZColor *&glareImage, bool glareUpdate,

 	float glareAmount, float glareRadius, u_int glareBlades, float glareThreshold,

 	const char *toneMapName, const ParamSet *toneMapParams,

 	const CameraResponse *response, float dither)

 {

 	const u_int nPix = xResolution * yResolution;

 	// Clamp input

 	for (u_int i = 0; i < nPix; ++i)

 		xyzpixels[i] = xyzpixels[i].Clamp();

 	// Possibly apply bloom effect to image

 	if (bloomRadius > 0.f && bloomWeight > 0.f) {

 		if(bloomUpdate) {

 			// Compute image-space extent of bloom effect

 			const u_int bloomSupport = Float2UInt(bloomRadius *

 				max(xResolution, yResolution));

 			const u_int bloomWidth = bloomSupport / 2;

 			// Initialize bloom filter table

 			vector<float> bloomFilter(bloomWidth * bloomWidth);

 			for (u_int i = 0; i < bloomWidth * bloomWidth; ++i) {

 				float dist = sqrtf(i) / bloomWidth;

 				bloomFilter[i] = powf(max(0.f, 1.f - dist), 4.f);

 			}

 			// Allocate persisting bloom image layer if unallocated

 			if(!haveBloomImage) {

 				bloomImage = new XYZColor[nPix];

 				haveBloomImage = true;

 			}

 			// Apply bloom filter to image pixels

 			//			vector<Color> bloomImage(nPix);

 //			ProgressReporter prog(yResolution, "Bloom filter"); //NOBOOK //intermediate crashfix until imagepipelinerefactor is done - Jens

 			for (u_int y = 0; y < yResolution; ++y) {

 				for (u_int x = 0; x < xResolution; ++x) {

 					// Compute bloom for pixel _(x,y)_

 					// Compute extent of pixels contributing bloom

 					const u_int x0 = max(x, bloomWidth) - bloomWidth;

 					const u_int x1 = min(x + bloomWidth, xResolution - 1);

 					const u_int y0 = max(y, bloomWidth) - bloomWidth;

 					const u_int y1 = min(y + bloomWidth, yResolution - 1);

 					const u_int offset = y * xResolution + x;

 					float sumWt = 0.f;

 					for (u_int by = y0; by <= y1; ++by) {

 						for (u_int bx = x0; bx <= x1; ++bx) {

 							if (bx == x && by == y)

 								continue;

 							// Accumulate bloom from pixel $(bx,by)$

 							const u_int dist2 = (x - bx) * (x - bx) + (y - by) * (y - by);

 							if (dist2 < bloomWidth * bloomWidth) {

 								u_int bloomOffset = bx + by * xResolution;

 								float wt = bloomFilter[dist2];

 								sumWt += wt;

 								bloomImage[offset].AddWeighted(wt, xyzpixels[bloomOffset]);

 							}

 						}

 					}

 					bloomImage[offset] /= sumWt;

 				}

 //				prog.Update(); //NOBOOK //intermediate crashfix until imagepipelinerefactor is done - Jens

 			}

 //			prog.Done(); //NOBOOK //intermediate crashfix until imagepipelinerefactor is done - Jens

 		}

 		// Mix bloom effect into each pixel

 		if(haveBloomImage && bloomImage != NULL)

 			for (u_int i = 0; i < nPix; ++i)

 				xyzpixels[i] = Lerp(bloomWeight, xyzpixels[i], bloomImage[i]);

 	}

 	if (glareRadius > 0.f && glareAmount > 0.f) {

 		if (glareUpdate) {

 			// Allocate persisting glare image layer if unallocated

 			if(!haveGlareImage) {

 				glareImage = new XYZColor[nPix];

 				haveGlareImage = true;

 			}

 			u_int maxRes = max(xResolution, yResolution);

 			u_int nPix2 = maxRes * maxRes;

 			std::vector<XYZColor> rotatedImage(nPix2);

 			std::vector<XYZColor> blurredImage(nPix2);

 			std::vector<XYZColor> darkenedImage(nPix);

 			for(u_int i = 0; i < nPix; ++i)

 				glareImage[i] = XYZColor(0.f);

 			// Search for the brightest pixel in the image

 			u_int max = 0;

 			for(u_int i = 1; i < nPix; ++i) {

 				if (xyzpixels[i].c[1] > xyzpixels[max].c[1])

 					max = i;

 			}

 			// glareThreshold ranges between 0-1,

 			// but this relative value has to be converted to

 			//an absolute value fitting the image being processed

 			float glareAbsoluteThreshold = xyzpixels[max].c[1] *

 				glareThreshold;

 			// Every pixel that is not bright enough is made black

 			for(u_int i = 0; i < nPix; ++i) {

 				if(xyzpixels[i].c[1] < glareAbsoluteThreshold)

 					darkenedImage[i] = XYZColor(0.f);

 				else

 					darkenedImage[i] = xyzpixels[i];

 			}

 			const float radius = maxRes * glareRadius;

 			// add rotated versions of the blurred image

 			const float invBlades = 1.f / glareBlades;

 			float angle = 0.f;

 			for (u_int i = 0; i < glareBlades; ++i) {

 				rotateImage(darkenedImage, rotatedImage, xResolution, yResolution, angle);

 				horizontalGaussianBlur(rotatedImage, blurredImage, maxRes, maxRes, radius);

 				rotateImage(blurredImage, rotatedImage, maxRes, maxRes, -angle);

 				// add to output

 				for(u_int y = 0; y < yResolution; ++y) {

 					for(u_int x = 0; x < xResolution; ++x) {

 						const u_int sx = x + (maxRes - xResolution) / 2;

 						const u_int sy = y + (maxRes - yResolution) / 2;

 						glareImage[y * xResolution + x] += rotatedImage[sy * maxRes + sx];

 					}

 				}

 				angle += 2.f * M_PI * invBlades;

 			}

 			// normalize

 			for(u_int i = 0; i < nPix; ++i)

 				glareImage[i] *= invBlades;

 			rotatedImage.clear();

 			blurredImage.clear();

 			darkenedImage.clear();

 		}

 		if (haveGlareImage && glareImage != NULL) {

 			for(u_int i = 0; i < nPix; ++i) {

 				xyzpixels[i] += glareAmount * glareImage[i];

 			}

 		}

 	}

 	// Apply tone reproduction to image

 	if (toneMapName) {

 		ToneMap *toneMap = MakeToneMap(toneMapName,

 			toneMapParams ? *toneMapParams : ParamSet());

 		if (toneMap)

 			toneMap->Map(xyzpixels, xResolution, yResolution, 100.f);

 		delete toneMap;

 	}

 	// Convert to RGB

 	vector<RGBColor> &rgbpixels = reinterpret_cast<vector<RGBColor> &>(xyzpixels);

 	for (u_int i = 0; i < nPix; ++i)

 		rgbpixels[i] = colorSpace.ToRGBConstrained(xyzpixels[i]);

 	// DO NOT USE xyzpixels ANYMORE AFTER THIS POINT

 	if (response && response->validFile) {

 		for (u_int i = 0; i < nPix; ++i)

 			response->Map(rgbpixels[i]);

 	}

 	// Add vignetting & chromatic aberration effect

 	// These are paired in 1 loop as they can share quite a few calculations

 	if ((VignettingEnabled && VignetScale != 0.0f) ||

 		(aberrationEnabled && aberrationAmount > 0.f)) {

 		RGBColor *outp = &rgbpixels[0];

 		std::vector<RGBColor> aberrationImage;

 		if (aberrationEnabled) {

 			aberrationImage.resize(nPix, RGBColor(0.f));

 			outp = &aberrationImage[0];

 		}

 		const float invxRes = 1.f / xResolution;

 		const float invyRes = 1.f / yResolution;

 		//for each pixel in the source image

 		for(u_int y = 0; y < yResolution; ++y) {

 			for(u_int x = 0; x < xResolution; ++x) {

 				const float nPx = x * invxRes;

 				const float nPy = y * invyRes;

 				const float xOffset = nPx - 0.5f;

 				const float yOffset = nPy - 0.5f;

 				const float tOffset = sqrtf(xOffset * xOffset + yOffset * yOffset);

 				if (aberrationEnabled && aberrationAmount > 0.f) {

 					const float rb_x = (0.5f + xOffset * (1.f + tOffset * aberrationAmount)) * xResolution;

 					const float rb_y = (0.5f + yOffset * (1.f + tOffset * aberrationAmount)) * yResolution;

 					const float g_x =  (0.5f + xOffset * (1.f - tOffset * aberrationAmount)) * xResolution;

 					const float g_y =  (0.5f + yOffset * (1.f - tOffset * aberrationAmount)) * yResolution;

 					const float redblue[] = {1.f, 0.f, 1.f};

 					const float green[] = {0.f, 1.f, 0.f};

 					outp[xResolution * y + x] += RGBColor(redblue) * bilinearSampleImage<RGBColor>(rgbpixels, xResolution, yResolution, rb_x, rb_y);

 					outp[xResolution * y + x] += RGBColor(green) * bilinearSampleImage<RGBColor>(rgbpixels, xResolution, yResolution, g_x, g_y);

 				}

 				// Vignetting

 				if(VignettingEnabled && VignetScale != 0.0f) {

 					// normalize to range [0.f - 1.f]

 					const float invNtOffset = 1.f - (fabsf(tOffset) * 1.42f);

 					float vWeight = Lerp(invNtOffset, 1.f - VignetScale, 1.f);

 					for (u_int i = 0; i < 3; ++i)

 						outp[xResolution*y + x].c[i] *= vWeight;

 				}

 			}

 		}

 		if (aberrationEnabled) {

 			for(u_int i = 0; i < nPix; ++i)

 				rgbpixels[i] = aberrationImage[i];

 		}

 		aberrationImage.clear();

 	}

 	// Calculate histogram (if it is enabled and exists)

 	if (HistogramEnabled && histogram)

 		histogram->Calculate(rgbpixels, xResolution, yResolution);

 	// Apply Chiu Noise Reduction Filter

 	if(chiuParams.enabled) {

 		std::vector<RGBColor> chiuImage(nPix, RGBColor(0.f));

 		// NOTE - lordcrc - if includecenter is false, make sure radius 

 		// is a tad higher than 1 to include other pixels

 		const float radius = max(chiuParams.radius, 1.f + (chiuParams.includecenter ? 0.f : 1e-6f));

 		const u_int pixel_rad = Ceil2UInt(radius);

 		const u_int lookup_size = 2 * pixel_rad + 1;

 		//build filter lookup table

 		std::vector<float> weights(lookup_size * lookup_size);

 		float sumweight = 0.f;

 		u_int offset = 0;

 		for(int y = -static_cast<int>(pixel_rad); y <= static_cast<int>(pixel_rad); ++y) {

 			for(int x = -static_cast<int>(pixel_rad); x <= static_cast<int>(pixel_rad); ++x) {

 				if(x == 0 && y == 0)

 					weights[offset] = chiuParams.includecenter ? 1.0f : 0.0f;

 				else {

 					const float dx = x;

 					const float dy = y;

 					const float dist = sqrtf(dx * dx + dy * dy);

 					const float weight = powf(max(0.0f, 1.0f - dist / radius), 4.0f);

 					weights[offset] = weight;

 				}

 				sumweight += weights[offset++];

 			}

 		}

 		//normalise filter kernel

 		for(u_int y = 0; y < lookup_size; ++y)

 			for(u_int x = 0; x < lookup_size; ++x)

 				weights[lookup_size*y + x] /= sumweight;

 		//for each pixel in the source image

 		for (u_int y = 0; y < yResolution; ++y) {

 			//get min and max of current filter rect along y axis

 			const u_int miny = max(y, pixel_rad) - pixel_rad;

 			const u_int maxy = min(yResolution - 1, y + pixel_rad);

 			for (u_int x = 0; x < xResolution; ++x) {

 				//get min and max of current filter rect along x axis

 				const u_int minx = max(x, pixel_rad) - pixel_rad;

 				const u_int maxx = min(xResolution - 1, x + pixel_rad);

 				// For each pixel in the out image, in the filter radius

 				for(u_int ty = miny; ty < maxy; ++ty) {

 					for(u_int tx = minx; tx < maxx; ++tx) {

 						const u_int dx = x - tx + pixel_rad;

 						const u_int dy = y - ty + pixel_rad;

 						const float factor = weights[lookup_size*dy + dx];

 						chiuImage[xResolution*ty + tx].AddWeighted(factor, rgbpixels[xResolution*y + x]);

 					}

 				}

 			}

 		}

 		// Copyback

 		for(u_int i = 0; i < nPix; ++i)

 			rgbpixels[i] = chiuImage[i];

 		// remove used intermediate memory

 		chiuImage.clear();

 		weights.clear();

 	}

 	// Apply GREYCStoration noise reduction filter

 	if(GREYCParams.enabled) {

 		// Define Cimg image buffer and copy data

 		CImg<float> img(xResolution, yResolution, 1, 3);

 		for(u_int y = 0; y < yResolution; ++y) {

 			for(u_int x = 0; x < xResolution; ++x) {

 				const u_int index = xResolution * y + x;

 				// Note - Cimg float data must be in range [0,255] for GREYCStoration to work %100

 				for(u_int j = 0; j < 3; ++j)

 					img(x, y, 0, j) = rgbpixels[index].c[j] * 255;

 			}

 		}

 		for (unsigned int iter=0; iter<GREYCParams.nb_iter; iter++) {

 			img.blur_anisotropic(GREYCParams.amplitude,

 				GREYCParams.sharpness,

 				GREYCParams.anisotropy,

 				GREYCParams.alpha,

 				GREYCParams.sigma,

 				GREYCParams.dl,

 				GREYCParams.da,

 				GREYCParams.gauss_prec,

 				GREYCParams.interp,

 				GREYCParams.fast_approx,

 				1.0f); // gfact

 		}

 		// Copy data from cimg buffer back to pixels vector

 		const float inv_byte = 1.f/255;

 		for(u_int y = 0; y < yResolution; ++y) {

 			for(u_int x = 0; x < xResolution; ++x) {

 				const u_int index = xResolution * y + x;

 				for(u_int j = 0; j < 3; ++j)

 					rgbpixels[index].c[j] = img(x, y, 0, j) * inv_byte;

 			}

 		}

 	}

 	// Dither image

 	if (dither > 0.f)

 		for (u_int i = 0; i < nPix; ++i)

 			rgbpixels[i] += 2.f * dither * (lux::random::floatValueP() - .5f);

 }

 // Filter Look Up Table Definitions

 FilterLUT::FilterLUT(Filter *filter, const float offsetX, const float offsetY) {

 	const int x0 = Ceil2Int(offsetX - filter->xWidth);

 	const int x1 = Floor2Int(offsetX + filter->xWidth);

 	const int y0 = Ceil2Int(offsetY - filter->yWidth);

 	const int y1 = Floor2Int(offsetY + filter->yWidth);

 	lutWidth = x1 - x0 + 1;

 	lutHeight = y1 - y0 + 1;

 	//lut = new float[lutWidth * lutHeight];

 	lut.resize(lutWidth * lutHeight);

 	float totalWeight = 0.f;

 	unsigned int index = 0;

 	for (int iy = y0; iy <= y1; ++iy) {

 		for (int ix = x0; ix <= x1; ++ix) {

 			const float filterVal = filter->Evaluate(fabsf(ix - offsetX), fabsf(iy - offsetY));

 			totalWeight += filterVal;

 			lut[index++] = filterVal;

 		}

 	}

 	// Normalize LUT

 	index = 0;

 	for (int iy = y0; iy <= y1; ++iy) {

 		for (int ix = x0; ix <= x1; ++ix)

 			lut[index++] /= totalWeight;

 	}

 }

 FilterLUTs::FilterLUTs(Filter *filter, const unsigned int size) {		

 	lutsSize = size + 1;

 	step = 1.f / float(size);

 	luts.resize(lutsSize * lutsSize);

 	for (unsigned int iy = 0; iy < lutsSize; ++iy) {

 		for (unsigned int ix = 0; ix < lutsSize; ++ix) {

 			const float x = ix * step - 0.5f + step / 2.f;

 			const float y = iy * step - 0.5f + step / 2.f;

 			luts[ix + iy * lutsSize] = FilterLUT(filter, x, y);

 		}

 	}

 }

 // OutlierData Definitions

 ColorSystem OutlierData::cs(0.63f, 0.34f, 0.31f, 0.595f, 0.155f, 0.07f, 0.314275f, 0.329411f);

 // Film Function Definitions

 u_int Film::GetXResolution()

 {

 	return xResolution;

 }

 u_int Film::GetYResolution()

 {

 	return yResolution;

 }

 Film::Film(u_int xres, u_int yres, Filter *filt, u_int filtRes, const float crop[4], 

 		   const string &filename1, bool premult, bool useZbuffer,

 		   bool w_resume_FLM, bool restart_resume_FLM, bool write_FLM_direct, int haltspp, int halttime,

 		   bool debugmode, int outlierk, int tilec) :

 	Queryable("film"),

 	xResolution(xres), yResolution(yres),

 	EV(0.f), averageLuminance(0.f),

 	numberOfSamplesFromNetwork(0), numberOfLocalSamples(0), numberOfResumedSamples(0),

 	contribPool(NULL), filter(filt), filterTable(NULL), filterLUTs(NULL),

 	filename(filename1),

 	colorSpace(0.63f, 0.34f, 0.31f, 0.595f, 0.155f, 0.07f, 0.314275f, 0.329411f), // default is SMPTE

 	ZBuffer(NULL), use_Zbuf(useZbuffer),

 	debug_mode(debugmode), premultiplyAlpha(premult),

 	writeResumeFlm(w_resume_FLM), restartResumeFlm(restart_resume_FLM), writeFlmDirect(write_FLM_direct),

 	outlierRejection_k(outlierk), haltSamplesPerPixel(haltspp),

 	haltTime(halttime), histogram(NULL), enoughSamplesPerPixel(false)

 {

 	// Compute film image extent

 	memcpy(cropWindow, crop, 4 * sizeof(float));

 	xPixelStart = Ceil2UInt(xResolution * cropWindow[0]);

 	xPixelCount = max(1U, Ceil2UInt(xResolution * cropWindow[1]) - xPixelStart);

 	yPixelStart = Ceil2UInt(yResolution * cropWindow[2]);

 	yPixelCount = max(1U, Ceil2UInt(yResolution * cropWindow[3]) - yPixelStart);

 	int xRealWidth = Floor2Int(xPixelStart + .5f + xPixelCount + filter->xWidth) - Floor2Int(xPixelStart + .5f - filter->xWidth);

 	int yRealHeight = Floor2Int(yPixelStart + .5f + yPixelCount + filter->yWidth) - Floor2Int(yPixelStart + .5f - filter->yWidth);

 	samplePerPass = xRealWidth * yRealHeight;

 	boost::xtime_get(&creationTime, boost::TIME_UTC);

 	//Queryable parameters

 	AddIntAttribute(*this, "xResolution", "Horizontal resolution (pixels)", &Film::GetXResolution);

 	AddIntAttribute(*this, "yResolution", "Vertical resolution (pixels)", &Film::GetYResolution);

 	AddBoolAttribute(*this, "premultiplyAlpha", "Premultiplied alpha enabled", &Film::premultiplyAlpha);

 	AddStringAttribute(*this, "filename", "Output filename", filename, &Film::filename, Queryable::ReadWriteAccess);

 	AddFloatAttribute(*this, "EV", "Exposure value", &Film::EV);

 	AddFloatAttribute(*this, "averageLuminance", "Average Image Luminance", &Film::averageLuminance);

 	AddDoubleAttribute(*this, "numberOfLocalSamples", "Number of samples contributed to film on the local machine", &Film::numberOfLocalSamples);

 	AddDoubleAttribute(*this, "numberOfSamplesFromNetwork", "Number of samples contributed from network slaves", &Film::numberOfSamplesFromNetwork);

 	AddDoubleAttribute(*this, "numberOfResumedSamples", "Number of samples loaded from saved film", &Film::numberOfResumedSamples);

 	AddBoolAttribute(*this, "enoughSamples", "Indicates if the halt condition been reached", &Film::enoughSamplesPerPixel);

 	AddIntAttribute(*this, "haltSamplesPerPixel", "Halt Samples per Pixel", haltSamplesPerPixel, &Film::haltSamplesPerPixel, Queryable::ReadWriteAccess);

 	AddIntAttribute(*this, "haltTime", "Halt time in seconds", haltTime, &Film::haltTime, Queryable::ReadWriteAccess);

 	AddBoolAttribute(*this, "writeResumeFlm", "Write resume file", writeResumeFlm, &Film::writeResumeFlm, Queryable::ReadWriteAccess);

 	AddBoolAttribute(*this, "restartResumeFlm", "Restart (overwrite) resume file", restartResumeFlm, &Film::restartResumeFlm, Queryable::ReadWriteAccess);

 	AddBoolAttribute(*this, "writeFlmDirect", "Write resume file directly to disk", writeFlmDirect, &Film::writeFlmDirect, Queryable::ReadWriteAccess);	

 	// Precompute filter tables

 	filterLUTs = new FilterLUTs(filt, max(min(filtRes, 64u), 2u));

 	outlierCellWidth = Floor2UInt(2 * filter->xWidth);

 	outlierInvCellWidth = 1.f / outlierCellWidth;

 	outlierCellHeight = Floor2UInt(2 * filter->yWidth);

 	outlierInvCellHeight = 1.f / outlierCellHeight;

 	const u_int thread_count = boost::thread::hardware_concurrency();

 	// base min tile size on outlier cell height, as it's a good measure anyway

 	const u_int minTileHeight = outlierCellHeight;

 	if (tilec > 0)

 		tileCount = tilec;

 	else

 		// TODO - thread_count * 2 is fairly arbitrary, find better choice?

 		tileCount = thread_count * (tilec < 0 ? -tilec : 2);

 	LOG(LUX_DEBUG, LUX_NOERROR) << "Requested film tile count: " << tileCount;

 	tileCount = Clamp(tileCount, 1u, yRealHeight / minTileHeight);

 	//tileCount = 2;

 	tileHeight = max(Ceil2UInt(static_cast<float>(yRealHeight) / tileCount), minTileHeight);

 	if (outlierRejection_k > 0) {

 		// if outlier rejection is enabled, tileHeight must be multiple of outlierCellHeight

 		// increase tileHeight to ensure this

 		tileHeight = outlierCellHeight * max(Ceil2UInt(static_cast<float>(tileHeight) / outlierCellHeight), 1u);

 		tileCount = max(Ceil2UInt(static_cast<float>(yRealHeight) / tileHeight), 1u);

 	}

 	LOG(LUX_DEBUG, LUX_NOERROR) << "Actual film tile count: " << tileCount;

 	invTileHeight = 1.f / tileHeight;

 	tileOffset = -0.5f - filter->yWidth - yPixelStart;

 	tileOffset2 = 2 * filter->yWidth * invTileHeight;

 	if (outlierRejection_k > 0) {

 		const u_int outliers_width = xRealWidth / outlierCellWidth;

 		const u_int outliers_height = yRealHeight / outlierCellHeight;

 		outliers.resize(outliers_height);

 		for (size_t i = 0; i < outliers.size(); ++i)

 			outliers[i].resize(outliers_width);

 		// tiles need duplicate data for row above and below tile

 		tileborder_outliers.resize(2 * tileCount);

 		for (size_t i = 0; i < tileborder_outliers.size(); ++i)

 			tileborder_outliers[i].resize(outliers_width);

 	}

 }

 Film::~Film()

 {

 	delete filterLUTs;

 	delete filter;

 	delete ZBuffer;

 	delete histogram;

 	delete contribPool;

 }

 void Film::RequestBufferGroups(const vector<string> &bg)

 {

 	for (u_int i = 0; i < bg.size(); ++i)

 		bufferGroups.push_back(BufferGroup(bg[i]));

 }

 u_int Film::RequestBuffer(BufferType type, BufferOutputConfig output,

 	const string& filePostfix)

 {

 	bufferConfigs.push_back(BufferConfig(type, output, filePostfix));

 	return bufferConfigs.size() - 1;

 }

 void Film::CreateBuffers()

 {

 	if (bufferGroups.size() == 0)

 		bufferGroups.push_back(BufferGroup("default"));

 	for (u_int i = 0; i < bufferGroups.size(); ++i)

 		bufferGroups[i].CreateBuffers(bufferConfigs,xPixelCount,yPixelCount);

 	// Allocate ZBuf buffer if needed

 	if(use_Zbuf)

 		ZBuffer = new PerPixelNormalizedFloatBuffer(xPixelCount,yPixelCount);

     // Dade - check if we have to resume a rendering and restore the buffers

     if(writeResumeFlm) {

 		const string fname = filename+".flm";

 		if (restartResumeFlm) {

 			const string oldfname = fname + "1";

 			if (boost::filesystem::exists(fname)) {

 				if (boost::filesystem::exists(oldfname))

 					remove(oldfname.c_str());

 				rename(fname.c_str(), oldfname.c_str());

 			}

 		} else {

 			// Dade - check if the film file exists

 			std::ifstream ifs(fname.c_str(), std::ios_base::in | std::ios_base::binary);

 			if(ifs.good()) {

 				// Dade - read the data

 				LOG(LUX_INFO,LUX_NOERROR)<< "Reading film status from file " << fname;

 				numberOfResumedSamples = UpdateFilm(ifs);

 			}

 			ifs.close();

 		}

     }

 	// initialize the contribution pool

 	contribPool = new ContributionPool(this);

 }

 void Film::ClearBuffers()

 {

 	for (u_int i = 0; i < bufferGroups.size(); ++i) {

 		BufferGroup& bufferGroup = bufferGroups[i];

 		for (u_int j = 0; j < bufferConfigs.size(); ++j) {

 			Buffer* buffer = bufferGroup.getBuffer(j);

 			buffer->Clear();

 		}

 		bufferGroup.numberOfSamples = 0;

 	}

 }

 void Film::SetGroupName(u_int index, const string& name) 

 {

 	if( index >= bufferGroups.size())

 		return;

 	bufferGroups[index].name = name;

 }

 string Film::GetGroupName(u_int index) const

 {

 	if (index >= bufferGroups.size())

 		return "";

 	return bufferGroups[index].name;

 }

 void Film::SetGroupEnable(u_int index, bool status)

 {

 	if (index >= bufferGroups.size())

 		return;

 	bufferGroups[index].enable = status;

 }

 bool Film::GetGroupEnable(u_int index) const

 {

 	if (index >= bufferGroups.size())

 		return false;

 	return bufferGroups[index].enable;

 }

 void Film::SetGroupScale(u_int index, float value)

 {

 	if (index >= bufferGroups.size())

 		return;

 	bufferGroups[index].globalScale = value;

 	ComputeGroupScale(index);

 }

 float Film::GetGroupScale(u_int index) const

 {

 	if (index >= bufferGroups.size())

 		return 0.f;

 	return bufferGroups[index].globalScale;

 }

 void Film::SetGroupRGBScale(u_int index, const RGBColor &value)

 {

 	if (index >= bufferGroups.size())

 		return;

 	bufferGroups[index].rgbScale = value;

 	ComputeGroupScale(index);

 }

 RGBColor Film::GetGroupRGBScale(u_int index) const

 {

 	if (index >= bufferGroups.size())

 		return 0.f;

 	return bufferGroups[index].rgbScale;

 }

 void Film::SetGroupTemperature(u_int index, float value)

 {

 	if (index >= bufferGroups.size())

 		return;

 	bufferGroups[index].temperature = value;

 	ComputeGroupScale(index);

 }

 float Film::GetGroupTemperature(u_int index) const

 {

 	if (index >= bufferGroups.size())

 		return 0.f;

 	return bufferGroups[index].temperature;

 }

 void Film::ComputeGroupScale(u_int index)

 {

 	const XYZColor white(colorSpace.ToXYZ(RGBColor(1.f)));

 	if (bufferGroups[index].temperature > 0.f) {

 		XYZColor colorTemp(BlackbodySPD(bufferGroups[index].temperature));

 		colorTemp /= colorTemp.Y();

 		bufferGroups[index].convert = ColorAdaptator(white,

 			colorSpace.ToXYZ(bufferGroups[index].rgbScale)) *

 			ColorAdaptator(white, colorTemp);

 	} else {

 		bufferGroups[index].convert = ColorAdaptator(white,

 			colorSpace.ToXYZ(bufferGroups[index].rgbScale));

 	}

 	bufferGroups[index].convert *= bufferGroups[index].globalScale;

 }

 void Film::GetSampleExtent(int *xstart, int *xend,

 	int *ystart, int *yend) const

 {

 	*xstart = Floor2Int(xPixelStart + .5f - filter->xWidth);

 	*xend   = Floor2Int(xPixelStart + .5f + xPixelCount + filter->xWidth);

 	*ystart = Floor2Int(yPixelStart + .5f - filter->yWidth);

 	*yend   = Floor2Int(yPixelStart + .5f + yPixelCount + filter->yWidth);

 }

 void Film::AddSampleCount(float count) {

 	if (haltTime > 0) {

 		// Check if we have met the enough rendering time condition

 		boost::xtime t;

 		boost::xtime_get(&t, boost::TIME_UTC);

 		if (t.sec - creationTime.sec > haltTime)

 			enoughSamplesPerPixel = true;

 	}

 	numberOfLocalSamples += count;

 	for (u_int i = 0; i < bufferGroups.size(); ++i) {

 		bufferGroups[i].numberOfSamples += count;

 		// Dade - check if we have enough samples per pixel. The rendering stop

 		// when one of the buffer groups has enough samples (at the moment all

 		// buffer groups have always the same samples count; in the future

 		// it could be better to stop when all buffer groups have enough samples)

 		if ((haltSamplesPerPixel > 0) &&

 			(bufferGroups[i].numberOfSamples  >= haltSamplesPerPixel * samplePerPass))

 			enoughSamplesPerPixel = true;