#include "dxstdafx.h"
#include ".\hdrisampler.h"
#include "Vector.hpp"
#include "color.h"
#include "resolu.h"

#define M_PI       3.14159265358979323846
#define M_PI_2     1.57079632679489661923
#define M_PI_4     0.785398163397448309616


HdriSampler::HdriSampler(void)
{
	h2.SetBase(2);
	h3.SetBase(3);
	h5.SetBase(5);
	hdriMap = NULL;
}

HdriSampler::~HdriSampler(void)
{
}


Vector HdriSampler::getRadianceAt(const Vector& dir) const
{
	bool edge = false;
	float xval, yval;
	int upper, left;
	float fx, fy, fz;
	fx = fabsf(dir.x);
	fy = fabsf(dir.y);
	fz = fabsf(dir.z);
	if(dir.z > 0.0 && fz >= fy && fz >= fx)
	{
		upper = resolutiony / 4;
		left = resolutionx / 3;
		xval = dir.x / dir.z;
		yval = dir.y / dir.z;
	}
	else
	if(dir.z < 0.0 && fz >= fy && fz >= fx)
	{
		upper = 3 * resolutiony / 4;
		left = resolutionx / 3;
		xval = - dir.x / dir.z;
		yval = dir.y / dir.z;
	}
	else
	if(dir.x > 0.0 && fx >= fy && fx >= fz)
	{
		upper = resolutiony / 4;
		left = 2 * resolutionx / 3;
		xval = - dir.z / dir.x;
		yval = dir.y / dir.x;
	}
	else
	if(dir.x < 0.0 && fx >= fy && fx >= fz)
	{
		upper = resolutiony / 4;
		left = 0;
		xval = - dir.z / dir.x;
		yval = - dir.y / dir.x;
	}
	else
	if(dir.y > 0.0 && fy >= fx && fy >= fz)
	{
		upper = 0;
		left = resolutionx / 3;
		xval = dir.x / dir.y;
		yval = - dir.z / dir.y;
	}
	else
	if(dir.y < 0.0 && fy >= fx && fy >= fz)
	{
		upper = resolutiony / 2;
		left = resolutionx / 3;
		xval = - dir.x / dir.y;
		yval = - dir.z / dir.y;
	}
	else
		edge = true;

	if(!edge)
	{
		upper += ((-yval + 1.0f) * resolutiony) / 8.0;
		left += ((xval + 1.0f) * resolutionx) / 6.0;
		return hdriMap[left + upper * resolutionx];
	}
	else
		return Vector::RGBBLACK;
}

double HdriSampler::getImportance(const Vector& px)
{
//	return 1.0;
	Vector rad = getRadianceAt(px);
	return rad.sum();
}
// HdriSampler commands


void HdriSampler::findMaxImportance()
{
	maxImportance = 0.0;
	for(int k=0; k<resolutionx; k++)
		for(int j=0; j<resolutiony; j++)
		{
			double c = hdriMap[k + j * resolutionx].sum();
			if(c > maxImportance)
				maxImportance = c;
		}
}

void HdriSampler::calculatePowers()
{
	powers.clear();
	calculateRadii();
	for(int i=0; i<samplePoints.size(); i++)
	{
		Vector bpower = getRadianceAt( samplePoints[i] );
		bpower *= 3.14 * voronoiRadii[i] * voronoiRadii[i];
		powers.push_back(bpower);
	}
	return;
	int kbase = resolutionx/3;
	int jbase = 0;
	for(int k=0; k<resolutionx/3; k++)
		for(int j=0; j<resolutiony/4; j++)
		{
			Vector pixdir;
			pixdir.y = 1.0;
			pixdir.x = ((double)k / resolutionx) * 6.0 - 1.0;
			pixdir.z = (((double)j / resolutiony) * 8.0 - 1.0);
			double formfactor = 1.0 / pixdir.norm2();
			pixdir.normalize();
			formfactor *= pixdir.y;
			int di = voro.getNearestDirIndex(pixdir);
			powers[di] += hdriMap[k + kbase + (j + jbase) * resolutionx] * formfactor;
		}
	kbase = resolutionx/3;
	jbase = resolutiony/2;
	for(int k=0; k<resolutionx/3; k++)
		for(int j=0; j<resolutiony/4; j++)
		{
			Vector pixdir;
			pixdir.y = -1.0;
			pixdir.x = (((double)k / resolutionx) * 6.0 - 1.0);
			pixdir.z = -(((double)j / resolutiony) * 8.0 - 1.0);
			double formfactor = 1.0 / pixdir.norm2();
			pixdir.normalize();
			formfactor *= -pixdir.y;
			int di = voro.getNearestDirIndex(pixdir);
			powers[di] += hdriMap[k + kbase + (j + jbase) * resolutionx] * formfactor;
		}
	kbase = resolutionx/3;
	jbase = resolutiony/4;
	for(int k=0; k<resolutionx/3; k++)
		for(int j=0; j<resolutiony/4; j++)
		{
			Vector pixdir;
			pixdir.z = 1.0;
			pixdir.x = ((double)k / resolutionx) * 6.0 - 1.0;
			pixdir.y = -(((double)j / resolutiony) * 8.0 - 1.0);
			double formfactor = 1.0 / pixdir.norm2();
			pixdir.normalize();
			formfactor *= pixdir.z;
			int di = voro.getNearestDirIndex(pixdir);
			powers[di] += hdriMap[k + kbase + (j + jbase) * resolutionx] * formfactor;
		}
	kbase = resolutionx/3;
	jbase = resolutiony/4*3;
	for(int k=0; k<resolutionx/3; k++)
		for(int j=0; j<resolutiony/4; j++)

		{
			Vector pixdir;
			pixdir.z = -1.0;
			pixdir.x = (((double)k / resolutionx) * 6.0 - 1.0);
			pixdir.y = ((double)j / resolutiony) * 8.0 - 1.0;
			double formfactor = 1.0 / pixdir.norm2();
			pixdir.normalize();
			formfactor *= -pixdir.z;
			int di = voro.getNearestDirIndex(pixdir);
			powers[di] += hdriMap[k + kbase + (j + jbase) * resolutionx] * formfactor;
		}
	kbase = resolutionx/3*2;
	jbase = resolutiony/4;
	for(int k=0; k<resolutionx/3; k++)
		for(int j=0; j<resolutiony/4; j++)
		{
			Vector pixdir;
			pixdir.x = 1.0;
			pixdir.z = -(((double)k / resolutionx) * 6.0 - 1.0);
			pixdir.y = -(((double)j / resolutiony) * 8.0 - 1.0);
			double formfactor = 1.0 / pixdir.norm2();
			pixdir.normalize();
			formfactor *= pixdir.x;
			int di = voro.getNearestDirIndex(pixdir);
			powers[di] += hdriMap[k + kbase + (j + jbase) * resolutionx] * formfactor;
		}
	kbase = 0;
	jbase = resolutiony/4;
	for(int k=0; k<resolutionx/3; k++)
		for(int j=0; j<resolutiony/4; j++)
		{
			Vector pixdir;
			pixdir.x = -1.0;
			pixdir.z = (((double)k / resolutionx) * 6.0 - 1.0);
			pixdir.y = -(((double)j / resolutiony) * 8.0 - 1.0);
			double formfactor = 1.0 / pixdir.norm2();
			pixdir.normalize();
			formfactor *= -pixdir.x;
			int di = voro.getNearestDirIndex(pixdir);
			powers[di] += hdriMap[k + kbase + (j + jbase) * resolutionx] * formfactor;
		}
}

bool HdriSampler::loadHdrFile(char* filename)
{
	FILE* file = fopen(filename, "r+b");
	if(!file)
		return false;
	getheader(file, NULL, NULL);
	RESOLU rs;
	fgetsresolu(&rs, file);
	resolutionx = scanlen(&rs);
	resolutiony = numscans(&rs);
	hdriMap = new Vector[resolutionx * resolutiony];
	COLOR* loadhere = (COLOR*)hdriMap;
	while(!feof(file))
	{
		freadscan(loadhere, resolutionx, file);
		loadhere += resolutionx;
	}
	findMaxImportance();
	return true;
}

void HdriSampler::generatePoints(int nSamples)
{
	//ASSERT(nSamples >= 4);
	for(int i=0; i<nSamples; i++)
	{
		double fi = h2.Next() * 2.0 * M_PI;
		double theta = asin(h3.Next() * 2.0 - 1);

		Vector np(cos(fi) * cos(theta), sin(fi) * cos(theta), sin(theta));
		while(getImportance(np) / maxImportance < h5.Next())
		{
			rejectedPoints.push_back(np);
			fi = h2.Next() * 2.0 * M_PI;
			theta = asin(h3.Next() * 2.0 - 1);
			np = Vector(cos(fi) * cos(theta), sin(fi) * cos(theta), sin(theta));
		}
		samplePoints.push_back(np);
		voro.addDir(np);
	}
//	calculatePowers();

}

void HdriSampler::relax(int nSteps)
{
	for(int i=0; i < nSteps; i++)
		voro.relaxLloyd();
	calculatePowers();
}

void HdriSampler::calculateRadii()
{
	voronoiRadii.clear();
	for(int i=0; i<samplePoints.size(); i++)
		voronoiRadii.push_back(0.0f);

	std::vector<VoronoiGenerator::Tri>::iterator a = voro.tris.begin();
	std::vector<VoronoiGenerator::Tri>::iterator end = voro.tris.end();
	while(a != end)
	{
		Vector la = (voro.dirs[a->bi] - voro.dirs[a->ai]);
		Vector lb = (voro.dirs[a->ci] - voro.dirs[a->ai]);
		double lcos = la * lb;
		if(lcos >= 1.0)
			lcos = 1.0;
		double triArea = 
			sqrt(la.norm2() * la.norm2() * (1.0 - lcos * lcos)) / 4.0;
		voronoiRadii[a->ai] += triArea;
		voronoiRadii[a->bi] += triArea;
		voronoiRadii[a->ci] += triArea;
		a++;
	}
	float xx;
	for(int g=0; g < samplePoints.size(); g++)
	{	
		xx = sqrt(voronoiRadii[g] / 3.14);
		voronoiRadii[g] = xx;
	}
	return;
}