#include <stdlib.h>
#include <math.h>
#include <GL/glut.h>
#include <iostream>
#include <stdio.h>
#include "biMap.h"

using namespace std;

#define PI 3.141592f
#define FSIZE	600

#define KEYSTEPS 10
#define N_SEG 15 // the number of segments defining the circle
#define DIA 4.787  // BASED ON A SQUARE SIZE OF 6.0

#define KEYCELL 15.0
#define KEYXOFFSET 450.0
#define KEYYOFFSET 50.0

biMap::biMap()
{
	int i;
	float angle;

	field1 = new float*[FSIZE];
	field2 = new float*[FSIZE];
	for (i=0;i<FSIZE;++i)
	{
		field1[i] = new float[FSIZE];
		field2[i] = new float[FSIZE];
	}	

	xpts = new float[N_SEG];
	ypts = new float[N_SEG];

	for ( i = 0; i < N_SEG; ++i )
	{
		angle = 2.0 * PI * i / N_SEG;
		xpts[i] = DIA * cos(angle)/2.0;
		ypts[i] = DIA * sin(angle)/2.0;
	}
}

void biMap::clear()
{
	int i,j;
	for(i=0;i<FSIZE;++i)
		for(j=0;j<FSIZE;++j)
		{
			field1[i][j] = 0.0;
			field2[i][j] = 0.0;
		}
}

void biMap::drawTarget(float x, float y)
{

	glBegin(GL_LINES);
		glVertex2f(x+5.0,y);
		glVertex2f(x+10.0,y);
		glVertex2f(x-5.0,y);
		glVertex2f(x-10.0,y);
		glVertex2f(x,y+5.0);
		glVertex2f(x,y+10.0);
		glVertex2f(x,y-5.0);
		glVertex2f(x,y-10.0);
	glEnd();
}

void biMap::getMapValues(float x, float y, float &m1, float &m2)
{
	// only the middle part of the data field is exposed
	int r,c;

	r = FSIZE*(0.5*x/M_WID + 0.25);
	c = FSIZE*(0.5*y/M_WID + 0.25);

	m1 = field1[r][c];
	m2 = field2[r][c];	
}

int biMap::readKey(float x, float y, float &a)
{
	int kx, ky;
	int ret;
	float bin = 1.0/KEYSTEPS;

	kx = (x-KEYXOFFSET)/KEYCELL;
	ky = (y-KEYYOFFSET)/KEYCELL;
	ret = -1;

	cerr << "K X Y " << kx << " " << ky << "\n";
	a = kx/10.0 + 0.05;

	if(ky == 5){
		cerr << "Key  1 " << a << "\n";
		ret = 0;
	}
	if(ky == 7){
		cerr << "Key  2 " << a << "\n";
		ret = 1;
	}
	return ret;
}

void biMap::drawKeyWoven()
{
	int i,j;
	float r,g,b,v,Mid;
	float bin;
	float x,y,hh,hue;

	glPushMatrix();

	glTranslatef(KEYXOFFSET,KEYYOFFSET,0.0);
	bin = 1.0/KEYSTEPS;
	Mid = KEYSTEPS/2;
	for(i=0;i<KEYSTEPS;++i)
	{
		for(j=Mid;j<Mid+1;++j)
		{
            x = i*KEYCELL;
			y = j*KEYCELL;
			v = bin*(i+0.5);
			hsvToRgb(0.7,v,1.0,r,g,b);
			glColor3f(r,g,b);
			glRectf(x,y, x+KEYCELL,y+KEYCELL);
		}
	}
	Mid = KEYSTEPS/2 + 2;
	for(i=0;i<KEYSTEPS;++i)
	{
		for(j=Mid;j<Mid+1;++j)
		{
            x = (i+0.5)*KEYCELL;
			y = (j+0.5)*KEYCELL;
			v = bin*(i+0.5);
			drawCircle(x,y,1.333,v); 
		}
	}
	glPopMatrix();
}

void biMap::drawKeyRG()
{
	int i,j;
	float r,g,v;
	float bin,Mid;
	float x,y;

	glPushMatrix();
	glTranslatef(KEYXOFFSET,KEYYOFFSET,0.0);

	bin = 1.0/KEYSTEPS;
	Mid = KEYSTEPS/2;
	for(i=0;i<KEYSTEPS;++i)
	{
		for(j=Mid;j<Mid+1;++j)
		{
            x = i*KEYCELL;
			y = j*KEYCELL;
			g = bin*(i + 0.5);
			r = bin*(0.5);
			glColor3f(r,g,0.0);
			glRectf(x,y, x+KEYCELL,y+KEYCELL);
		}
	}

	Mid = KEYSTEPS/2 + 2;
	for(i=0;i<KEYSTEPS;++i)
	{
		for(j=Mid;j<Mid+1;++j)
		{
            x = i*KEYCELL;
			y = j*KEYCELL;
			g = bin*(0.5);
			r = bin*(i+0.5);
			glColor3f(r,g,0.0);
			glRectf(x,y, x+KEYCELL,y+KEYCELL);
		}
	}
	glPopMatrix();
}

void biMap::drawRG()
{
	int i,j;
	int start,end;
	float r,g,b;
	drawKeyRG();

	start= FSIZE/4;
	end = FSIZE*3/4;

	glPushMatrix();
	glColor3f(1.0,0.0,0.0);

	glScalef(1.333,1.333,1.0);
	glTranslatef(-start,-start,0.0);
	for(i=start;i<=end;++i)
	{
		glBegin(GL_QUAD_STRIP);
		for(j=start;j<=end;++j)
		{
			g = field1[i][j];
			r = field2[i][j];
			b = 0.4;

			glColor3f(r,g,b);

			glVertex2f(float(i),float(j));
			glVertex2f(float(i+1),float(j));
		}
		glEnd();
	}
	glPopMatrix();
}

void biMap::drawSpect()
{
	int i,j;
	int start,end;
	float f1, r,g,b;
	float hue;
	drawKeyWoven();

	start= FSIZE/4;
	end = FSIZE*3/4;

	glPushMatrix();
	glColor3f(1.0,0.0,0.0);

	glScalef(1.333,1.333,1.0);
	glTranslatef(-start,-start,0.0);
	for(i=start;i<=end;++i)
	{
		glBegin(GL_QUAD_STRIP);
		for(j=start;j<=end;++j)
		{
			f1 = field1[i][j];		
			if(f1 >1.0) f1 = 1.0;
			hue = 0.7;
			hsvToRgb(hue,f1,1.0,r,g,b);
			glColor3f(r,g,b);
			glVertex2f(float(i),float(j));
			glVertex2f(float(i+1),float(j));
		}
		glEnd();
	}
	glPopMatrix();
}

void biMap::drawCircle(float x, float y, float s, float v)
{ // Design a better color scheme here.
	float r,g,b,hue;	
	int i;
	
	if(v >1.0) v = 1.0;
	hue = 0.0;
	hsvToRgb(hue,v,1.0,r,g,b);
	glColor3f(r,g,b);

	glBegin( GL_TRIANGLE_FAN );
	glVertex2f( x,  y );
	for ( i = 0; i < N_SEG; ++i )
	{
		glVertex2f(x+ xpts[i]*s,y+  ypts[i]*s );
	}
	glVertex2f(x+ xpts[0]*s, y+ ypts[0]*s );
	glEnd();
}

void biMap::drawCircleField()
{
	int i,j;
	int start,end;

	float r,g,b;
	float x,y;

	start= FSIZE/4;
	end = FSIZE*3/4;

	glPushMatrix();
	glColor3f(1.0,0.0,0.0);

	glScalef(1.333,1.333,1.0);
	glTranslatef(-start,-start,0.0);
	for(i=start+2;i<=end;i=i+6)
	{	
		for(j=start+2;j<=end;j=j+6)
		{		
			x = i;
			y = j;
			drawCircle(x, y,1.0, field2[i][j]);
		}		
	}
	glPopMatrix();
}

void biMap::mkMaps()
{
	clear();
	mkDataMap(field1);
	mkDataMap(field2);
}

void biMap:: mkDataMap(float **t)
{	
	int k,kx,ky;
	float sz,angle;
	float lx,ly;

	lx = 0.5*float(FSIZE);
	ly = 0.5*float(FSIZE);

   for (k = 0; k < 40; ++k)
   {
		kx =  int(lx + MRand()*lx);
		ky =  int(ly + MRand()*ly);
		sz = 90.0f + MRand()*32.0f;  // 32-64;

		angle = (MRand()+0.5f)*180.0f;
		gabor(t, kx, ky, angle, sz, 0.1f*sz, 0.4f);
   }  
   for (k = 0; k < 300; ++k)
   {
		kx =  int(lx + MRand()*lx);
		ky =  int(ly + MRand()*ly);
		sz = 40.0f + MRand()*16.0f;  // 16-32;

		angle = (MRand()+0.5f)*180.0f;
		gabor(t, kx, ky, angle, sz, 0.06f*sz, 0.4f);
   }
   int i,j;
	for(i=0;i<FSIZE;++i)
		for(j=0;j<FSIZE;++j)
		{
			t[i][j] = t[i][j]*.026 + .25;
			if(t[i][j] > 1.0) t[i][j] = 1.0;	
		}
		
}


void biMap :: gabor(float **t, int cx, int cy, float r, float size,float contrast,float rat)
{
    //const int TPATCH = 50;
    float freq, prod;
    float cosr,sinr;
    float halfx,halfy;
    float	x,y,gx,gy;
    int ix, iy, ccx, ccy;
	int TPATCH;

	TPATCH = size*2;

    ccx = cx - TPATCH/2;
    ccy = cy - TPATCH/2;
    r = r*PI/180.0f;

    sinr = float(sin(r));
    cosr = float(-cos(r));

    halfx = float(TPATCH)/2.0f;
    halfy = float(TPATCH)/2.0f;

    freq = 2.0f*PI/size;
    rat = 1.0f/(rat*2.0f*PI);
    rat = -rat*rat;

    for (ix=0;ix<TPATCH;++ix)
	for(iy=0;iy<TPATCH;++iy)
	{
		x = (ix-halfx)*freq;
		y = (iy-halfy)*freq;
		/* rotate x and y */
		gx = cosr*x + sinr*y;
		gy = cosr*y  - sinr*x;
		prod = (cosr*x + sinr*y) ;

		t[ix + ccx][iy + ccy] += float(contrast*cos(prod)*exp((gx*gx +gy*gy)*rat));
	}
}

float biMap :: MRand()
{
    return float (rand()%1000)/1000.0f -0.5f;
}


void biMap ::hsvToRgb(float h,float s,float v, float &r,float &g, float &b)
{
 
    int i = int(h * 6.0);
    float f = h * 6 - i;
    float p = v * (1 - s);
    float q = v * (1 - f * s);
    float t = v * (1 - (1 - f) * s);
 
    switch(i)
    {
        case 0: r = v, g = t, b = p; break;
        case 1: r = q, g = v, b = p; break;
        case 2: r = p, g = v, b = t; break;
        case 3: r = p, g = q, b = v; break;
        case 4: r = t, g = p, b = v; break;
        case 5: r = v, g = p, b = q; break;
    }
}