//#include<cubes.h>
//#include<windows.h>
//#include<afxwin.h>
#include<fstream>
#include<iostream>
#include"ImageStone.h"		//ImageStone is a free library used for loading images into c++. http://www.codeguru.com/cpp/g-m/bitmap/imagemanipulation/article.php/c12577/
#include<cmath>
#include<GL/glut.h>
using namespace std;

unsigned long*** imagearray;	//hold source image data
unsigned long** viewarray;		//hold desired image data
float** color_data;

int image_width;				//how wide the source images are, in pixels.
int image_height;				//how tall the source images are, in pixels.
int num_cameras;				//how many source images we have.


bool global_debug_test;

float newX, newY, newZ;			//desired viewpoint's coordinates

class Plane{
	//a mathematical plane.
public:
	float a, b, c, d;		//for plane equation: ax + by + cz + d = 0
};

class Ray{
public:
	float x,y,z;		//x, y, z coordinates for starting point of ray
	float xdir, ydir, zdir;		//x, y, z coordinates specificying direction vector

};

class SourceImage{
public:
	int image_number;
	float x, y, z;		//x y and z, values, where object is centered at 0,0,0.
	Plane ImagePlane;
	float r, g, b;		//colors for that camera, used when we shade images by camera color.
	
	unsigned long PixelValue(int x, int y){
		if((image_number-1) < 0){
			cout<<"error code 1 ";
			cout<<image_number;
		}else if (x >= image_width){
			cout<<"error code 2";
		}else if (y >= image_height){
			cout<<"error code 3";
		}
		return imagearray[(image_number - 1)][x][y];	
	}
	
void MakePlane(){
	//creates a plane using the source image's camera data.

	
	//because the camera is pointed at (0,0,0), the plane's normal vector's x, y, and z components will be 
	//the negative x, y, and z values for the camera's center point:
	ImagePlane.a = -x;
	ImagePlane.b = -y;
	ImagePlane.c = -z;
	ImagePlane.d = sqrt((x*x) + (y*y) + (z*z));

}



};



SourceImage* SourceImages;
Plane* image_planes;
float getDistance(float, float, float, float, float, float);
int get_width(int);
int get_desired_width();
int get_height(int, int);
int get_desired_height(int);

RGBQUAD** color_table;
int* widths;		//holds the left-margin for each image, with the last element being that of the source image.
int** heights;

class interval{
public:
	float startx;		//x, y, and z coordinates of the starting position of this interval.
	float starty;
	float startz;

	float endx;			//x,y,and z coordinates of the ending position of this interval.
	float endy;
	float endz;

	float start_length;	//the start and end points of the interval, based on the distance (along the ray) from the ray's starting point.
	float end_length;


	void CalcLength(Ray theRay){
		start_length = sqrt(
			((startx-theRay.x)*(startx-theRay.x)) + 
			((starty-theRay.y)*(starty-theRay.y)) + 
			((startz-theRay.z)*(startz-theRay.z))
			);
		end_length = sqrt(
			((endx-theRay.x)*(endx-theRay.x)) +
			((endy-theRay.y)*(endy-theRay.y)) +
			((endz-theRay.z)*(endz-theRay.z))
			);
        
	}


};
class IntervalList{
public:
	interval* thelist;
	
	int currentlength;
	int maxlength;
	int best_image;		//stores the best image for use in texturing
	float best_val;		//compare to other images to determine which is best.
	unsigned long color;
	unsigned char r;
	unsigned char g;
	unsigned char b;
	

	IntervalList(){
		currentlength = 0;
		maxlength = 10;
		thelist = new interval[maxlength];
	}
	void DoubleMaxSize(){
		interval* templist;
		maxlength = (2 * maxlength);
		templist = new interval[maxlength];
		for(int i = 0; i < currentlength; i++){
			templist[i] = thelist[i];
		}
		delete thelist;
		thelist = new interval[maxlength];
		for(int i = 0; i < currentlength; i++){
			thelist[i] = templist[i];
		}
		delete templist;
	}

	void add(interval x){
		if(currentlength >= maxlength){
			DoubleMaxSize();
		}
		thelist[currentlength] = x;
		currentlength++;
      
	}
	
	IntervalList& operator=(IntervalList& y){
		best_val = y.best_val;
		currentlength = y.currentlength;
		maxlength = y.maxlength;
		best_image = y.best_image;
		delete thelist;
		thelist = new interval[maxlength];
		for(int i = 0; i < currentlength; i++){
			thelist[i] = y.thelist[i];
		}
		return *this;
	}

	 //operator[](int i){
	//	return thelist[i];
	// }

};


class Image{
public:
//created for debugging...so we have some idea of which image is contributing what intervals,
//and what the intersection is, for each pixel.

//holds (image_width * image_height) matrix of lists of interval lists.
//for each element in the matrix, the list of interval lists is :
//first element = intervals for first source image
//second element = intervals for second source image
//etc....
//last element = intersected intervals for all source images


	IntervalList*** the_matrix;

	Image(int width, int height, int images){
		//pass it image width, image height, and number of images.
		the_matrix = new IntervalList**[width];
		for(int i = 0; i < width; i++){
			the_matrix[i] = new IntervalList*[height];
			for(int j = 0; j < height; j++){
				the_matrix[i][j] = new IntervalList[(images+1)];
			}
		}
	}
		

	




};



int sourceimage(0);				//a counter to see which source image we are on.
interval ColorData;		
IntervalList AllIntervals;		//used for color data.
Image* All_Data;

bool debug_mode(true);			//to keep track of if we are drawing draw_image or draw_debug.
int debug_image(0);				//debugging mode:this is used to determine which image to draw.
int debug_x;					//debugging mode:this is used to determine which pixel's ray to draw.
int debug_y;					//debugging mode:this is used to determine which pixel's ray to draw.
Ray debug_ray;					//debugging mode:this is used to draw the ray.
IntervalList debug_intervals;	//debugging mode:this is used to display the intervals on the ray.
IntervalList temp_debug;

interval GetIntervalRange(IntervalList);
void GetDebugInfo(int, int, int);
IntervalList GetDebugInfo2(int,int,int);
int global_i, global_j;	//used to pass info (coordinates) from GetDebugInfo to ReturnIntervals.
//global_i and _j are used in getting color values for texturing.


/*************************************OPENGL STUFF below********************************************************/

#define PIXEL_CENTER(x) ((long)(x) + 0.5)

GLenum rgb, doubleBuffer, windType;
GLint windW, windH;

GLint boxW, boxH;
float color[3];
float angle;

int draw_mode;		//1 for shaded, 2 for camera's color, 3 for textured
int camera_color_counter;	//used to pick a color for each camera.

static void glInit ()
{
    // Clear color
    glPushAttrib(GL_COLOR_BUFFER_BIT);
    glColorMask(1, 1, 1, 1);
    glIndexMask(~0);
    glClearColor(0.0, 0.0, 0.0, 0.0);
    glClear(GL_COLOR_BUFFER_BIT);
    glPopAttrib();

   // Enable Depth testing
    glEnable(GL_DEPTH_TEST);
    glClear(GL_DEPTH_BUFFER_BIT);
}

// Function that gets called when the window is resized.
static void Reshape(int width, int height)
{
    // Define window size.
    windW = (GLint)width;
    windH = (GLint)height;

    // Viewport mapping 
    glViewport(0, 0, windW, windH);
    
    // Define a perspective projection with a 45 degree field of view
    // and looking from the the positive z axis at (0,0,10) towards the origin.
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    //glFrustum(-10.0, 10.0, -10.0, 10.0, 1.0, 20.0);	// Alternate method of specifying viewing paramters.
    gluPerspective (45.0, 1.0, 1.0, 20.0);
    gluLookAt (0.0, 0.0, 2.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
    //glOrtho(0, image_width, 0, image_height, -10.0, 10.0);
    // Switch matrix stack to modelview stack.
    glMatrixMode(GL_MODELVIEW);
}


void draw_image(void){
	if(draw_mode == 0){
		draw_mode = 2;
	}
	//gluLookAt(newX, newY, newZ, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
	glOrtho(0, image_width, 0, image_height, -10.0, 10.0);
	glPointSize(1.0);
	
	glBegin (GL_POINTS);
	
	float depth;
	int g(0);
	if(draw_mode == 1){
			//draw mode is: depth-shading.
		for(int i = 0; i < image_width; i++){
		for(int j = 0; j < image_height; j++){
			
				if((i == debug_x)&&(j == debug_y)){
					glColor3f(1.0,0.0,0.0);
				}else if(viewarray[i][j] == 0){
					glColor3f (0.0, 0.0, 1.0);
				}else if(viewarray[i][j] == 1){
					
					float highest;
					float lowest;
					highest = ColorData.end_length;
					lowest = ColorData.start_length;
					
					//depth = ((AllIntervals.thelist[g].start_length - lowest) / (highest - lowest));
					float temp_color = color_data[i][j];
					if(temp_color > ((highest-lowest)/16)){
						temp_color = ((highest-lowest)/16);
					}
					depth = ((color_data[i][j] - lowest) / ((highest - lowest)/16));
					//depth = 1.0;
					
					glColor3f (0.0, (1-depth), 0.0);
					//glColor3f (1.0-(1/(color_data[i][j])), (1.0/(color_data[i][j])), 0.0);

				}else{
					cout<<"error";
					glColor3f(1.0, 0.0, 0.0);
				}
				g++;
				glVertex2f(i, j);

				

				/*		output a source image.

				if(SourceImages[1].PixelValue(i, j) == 252){
				
					glColor3f (0.0, 0.0, 1.0);
		
				}else{
					glColor3f (0.0, 1.0, 0.0);

				}
				glVertex2f(i, j);
				*/
				
			}
		}		

	}else if(draw_mode == 2){
		//draw mode = per-camera color
		for(int i = 0; i < image_width; i++){
		for(int j = 0; j < image_height; j++){
				if(viewarray[i][j] == 0){
					glColor3f (0.0, 0.0, 1.0);
				}else if(viewarray[i][j] == 1){
					int best_image;
								
				
					best_image = All_Data->the_matrix[i][j][num_cameras].best_image;
					if(best_image == -1){
						best_image = 9;
						cout<<"IMAGE NOT GETTING VALUE";
					}
				
					glColor3f (
						SourceImages[best_image].r,
						SourceImages[best_image].g,
						SourceImages[best_image].b
						);
					//glColor3f (1.0-(1/(color_data[i][j])), (1.0/(color_data[i][j])), 0.0);

				}else{
					cout<<"error in draw_image";
					glColor3f(1.0, 0.0, 0.0);
				}
				g++;
				glVertex2f(i, j);
		}
		}


	}else if(draw_mode == 3){
		//draw mode = textured hull.
		for(int i = 0; i < image_width; i++){
			for(int j = 0; j < image_height; j++){
				glColor3f(0.0, 1.0, 1.0);
				if(All_Data->the_matrix[i][j][num_cameras].color < 256){
					if(All_Data->the_matrix[i][j][num_cameras].color > 0){
						int best_image;
						best_image = All_Data->the_matrix[i][j][num_cameras].best_image;
						int i2;
						int j2;
						j2 = j;
						//uncomment below except, it works with this commented out, now uncomment it /////
						if(i > image_width/2){
						/////	//i2 = (i/2) - widths[num_cameras];
							i2 = (i - image_width/2) + widths[best_image];
						}else{
							i2 = (i + image_width/2) - widths[best_image];
						}
						float draw_r;
						float draw_g;
						float draw_b;
						if(heights[num_cameras][i] == 0){
							j2 = j;
						}else{
							if(j2 > (image_height/2)){
								//j2 = j2 - (image_height/2);
								float temp1 = heights[best_image][i2] + 0.0;
								float temp2 = heights[num_cameras][i] + 0.0;
								float temp3 = temp1/temp2;
								float temp4 = j2 + 0.0;
								float temp5 = temp4 * temp3;
								j2 = (int)temp5;
								//j2 = j2 * (heights[best_image][i2])/(heights[num_cameras][i]);
							//j2 = (((heights[best_image][i2])/(heights[num_cameras][i2]))*j);
							}else{
								float temp1 = heights[best_image][i2] + 0.0;
								float temp2 = heights[num_cameras][i] + 0.0;
								float temp3 = temp2/temp1;
								float temp4 = j2 + 0.0;
								float temp5 = temp4 * temp3;
								j2 = (int)temp5;
							}
						}
						if(i2 >= image_width){
							cout<<"wtf";
						}
						if(j2 >= image_height){
							draw_r = 0.0;
							draw_g = 0.5;
							draw_b = 0.5;
						}else{
							draw_r = color_table[best_image][SourceImages[best_image].PixelValue(i2, j2)].rgbRed;
							draw_g = color_table[best_image][SourceImages[best_image].PixelValue(i2, j2)].rgbGreen;
							draw_b = color_table[best_image][SourceImages[best_image].PixelValue(i2, j2)].rgbBlue;
						}
						//draw_r = All_Data->the_matrix[i][j][num_cameras].r;
						//draw_g = All_Data->the_matrix[i][j][num_cameras].g;
						//draw_b = All_Data->the_matrix[i][j][num_cameras].b;
                        //_color = ((All_Data->the_matrix[i][j][num_cameras].color + 0.0)/255.0);
						glColor3f(draw_r, draw_g, draw_b);
					}
				}
				if(viewarray[i][j] == 0){
					glColor3f(0.0, 0.9, 0.9);
				}
				g++;
				glVertex2f(i, j);
			}
		}



	}
	glEnd ();
  
    
	
}


void draw_debug(int image_number, int somex, int somey){
	//this function outputs a given source image's silhouette, with a given ray projected over it.
	//it is mainly used for debugging.
	
	

	glOrtho(0, image_width, 0, image_height, -10.0, 10.0);
	glPointSize(1.0);
	glBegin (GL_POINTS);
	


	//now, draw the ray:
	int current(0);
	float totalmoved = 0;
	float moveX = debug_ray.zdir-debug_ray.z;
	float moveY = debug_ray.ydir-debug_ray.y;
	float x = debug_ray.z + (image_width/2);
	float y = debug_ray.y + (image_height/2);

	//cout<<"x starts at "<<x<<endl;
	//cout<<"y starts at "<<y<<endl;
	
	//IntervalList intervals;
	//interval temp_interval;	

	//int current_int;
	//bool not_background;

	//divide both the rise and the run by the run.  this makes it so that we can easily increment by 1 in the x direction.
	moveY = moveY/abs(moveX);
	moveX = moveX/abs(moveX);
	//cout<<"moveX and moveY are "<<moveX<<", "<<moveY<<endl;
	//not_background = false;
	//current_int = 0;

	//cout<<"x,y starts at "<<x<<","<<y<<"..";
	bool somevalue = false;
	while(somevalue != true){
		if(((int)moveX == abs((int)moveX)) && x > image_width){
		//x is already past the image, and moving in the positive direciton--this ray won't hit the desired viewpoint.
		//quit the loop.
		somevalue = true;

	}
	if(((int)moveX != abs((int)moveX)) && x < 0){
		//x is is before the image, and moving in the negative direciton--this ray won't hit the desired viewpoint.
		//quit the loop.
		somevalue = true;

	}
	//get x onto the image plane.	
	if((x < 0) | (x >= image_width)){
		x = x + moveX;
		y = y + moveY;
	}else{
		somevalue = true;
	}
}
//cout<<"but then becomes"<<x<<","<<y<<"..";
//cout<<"||";



	//cout<<"x becomes "<<x<<endl;
	//cout<<"y becomes "<<y<<endl<<endl;	
	interval temp;
	temp.endx = -1;
	temp.end_length = -1;
	temp.start_length = -1;
	debug_intervals.add(temp);


while((x < image_width) && (x >= 0)){
	
	//while x is still on the image plane:

	glColor3f (1.0, 0.0, 0.0);
	glPointSize(100.0);
	glVertex2f((int)x, (int)y);
	/*
	if((y < image_height) && (y >= 0)){
		//cout<<"x,y is "<<x<<","<<y<<endl;
		//cout<<"and image number is "<<image_number<<endl;
		if(SourceImages[image_number].PixelValue((int)x, (int)y) != 252){
		//we hit the image.
		
			glVertex2f((int)x+1, (int)y+1);
			glVertex2f((int)x-1, (int)y-1);
			glVertex2f((int)x+1, (int)y-1);
			glVertex2f((int)x-1, (int)y+1);
			glVertex2f((int)x, (int)y+1);
			glVertex2f((int)x, (int)y-1);
			glVertex2f((int)x+1, (int)y);
			glVertex2f((int)x-1, (int)y);
		}
	}
*/

	
	for(int i = 0; i < debug_intervals.currentlength; i++){
		float ax = debug_intervals.thelist[i].startz;
		float ay = debug_intervals.thelist[i].starty;
		float bx = debug_intervals.thelist[i].endz;
		float by = debug_intervals.thelist[i].endy;

	
			glVertex2f((int)ax+1, (int)ay+1);
			glVertex2f((int)ax-1, (int)ay-1);
			glVertex2f((int)ax+1, (int)ay-1);
			glVertex2f((int)ax-1, (int)ay+1);
			glVertex2f((int)ax, (int)ay+1);
			glVertex2f((int)ax, (int)ay-1);
			glVertex2f((int)ax+1, (int)ay);
			glVertex2f((int)ax-1, (int)ay);
	
			glVertex2f((int)bx+1, (int)by+1);
			glVertex2f((int)bx-1, (int)by-1);
			glVertex2f((int)bx+1, (int)by-1);
			glVertex2f((int)bx-1, (int)by+1);
			glVertex2f((int)bx, (int)by+1);
			glVertex2f((int)bx, (int)by-1);
			glVertex2f((int)bx+1, (int)by);
			glVertex2f((int)bx-1, (int)by);


	}

	/*if(debug_intervals.thelist[current].endx != -1){
		cout<<"hit";
		if((totalmoved >= debug_intervals.thelist[current].start_length)&&(totalmoved <= debug_intervals.thelist[current].end_length)){
			
		}
	}*/
	x = x + moveX;
	y = y + moveY;
	totalmoved = totalmoved + sqrt((moveX*moveX) + (moveY*moveY));
}






//draw the source image:

	BYTE draw_r;
	BYTE draw_g;
	BYTE draw_b;

	for(int i = 0; i < image_width; i++){
		for(int j = 0; j < image_height; j++){
			if(SourceImages[image_number].PixelValue(i, j) == 252){
				glColor3f (0.0, 0.0, 1.0);
			}else if(SourceImages[image_number].PixelValue(i, j) < 256){
				draw_r = color_table[image_number][SourceImages[image_number].PixelValue(i, j)].rgbRed;
				draw_g = color_table[image_number][SourceImages[image_number].PixelValue(i, j)].rgbGreen;
				draw_b = color_table[image_number][SourceImages[image_number].PixelValue(i, j)].rgbBlue;
				glColor3f (draw_r, draw_g, draw_b);
			}else{
				glColor3f(1.0, 0.0, 0.0);
			}
			glVertex2f(i, j);
		}
	}


	
	glEnd();

}




// Draws the scene at any point in time.
static void Draw(void)
{
    // Clear color and depth buffers
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity ();

    glPushMatrix ();
     // glRotatef (angle, 0.0, 1, 0.0);	// Rotate box

	if(debug_mode == false){
        draw_image();
	}else{
		draw_debug(debug_image,1,1);
	}
    glPopMatrix ();

    glFlush();

    
   // angle += 1.0;
    //if (angle == 360.0) angle = 0.0;

    if (doubleBuffer) {
	glutSwapBuffers();
    }
}

// Called when a keyboard key is pressed
static void Key(unsigned char key, int x, int y)
{

    switch (key) {
      case 27:
	printf ("exit!\n");
	exit(1);

      default:
	return;
    }

    glutPostRedisplay();
}

// Called when special keys are pressed - arrows and page-up/down
static void SpecialKey(int key, int x, int y)
{

	int x1;
	int x2;
	int y1;
	int y2;
	int z1;
	int z2;
	int CameraCloseness;

	switch (key) {
	case GLUT_KEY_END:
		//toggle debug mode on and off.
		if(debug_mode == false){
            debug_mode = true;
			cout<<"---------------------------------------------------"<<endl;
			cout<<"Debug mode activated. Hit END again to turn it off."<<endl;
			cout<<"Hit Page Up or Page Down to change the Source Image."<<endl;
			cout<<"(Current Source Image is "<<debug_image<<")"<<endl;
			cout<<"The displayed ray is cast from pixel "<<debug_x<<", "<<debug_y<<" in the desired viewpoint."<<endl;
			cout<<"Hit the left/right arrows to change the X value, or the up/down arrows to change the Y value."<<endl;
			cout<<"---------------------------------------------------"<<endl;
			cout<<"some debug info....";
				for(int i = 0; i < debug_intervals.currentlength; i++){
				//	debug_intervals.thelist[i].CalcLength;
					cout<<"Interval from..."<<debug_intervals.thelist[i].startx<<","<<debug_intervals.thelist[i].starty;
					cout<<" to "<<debug_intervals.thelist[i].endx<<","<<debug_intervals.thelist[i].endy;
					cout<<endl<<"this has length from... "<<debug_intervals.thelist[i].start_length<<","<<debug_intervals.thelist[i].end_length;
					cout<<endl<<endl;
				}
		
		}else{
            debug_mode = false;
			cout<<"---------------------------------------------------"<<endl;
			cout<<"Debug mode deactivated.  Hit END again to turn it on."<<endl;
		}
	break;


    case GLUT_KEY_PAGE_UP: 
		//debugging mode: (source image number to display) ++.
		if(debug_image == (num_cameras-1)){
			debug_image = 0;
		}else{
			debug_image++;
		}
		GetDebugInfo(debug_x, debug_y, debug_image);
		cout<<"Debug Mode: Now displaying Source Image #"<<debug_image;
		cout<<" (Ray coordinates are "<<debug_x<<", "<<debug_y<<")"<<endl;
		cout<<"some debug info....";
				for(int i = 0; i < debug_intervals.currentlength; i++){
					
			//		debug_intervals.thelist[i].CalcLength;
					cout<<"Interval from..."<<debug_intervals.thelist[i].startx<<","<<debug_intervals.thelist[i].starty;
					cout<<" to "<<debug_intervals.thelist[i].endx<<","<<debug_intervals.thelist[i].endy;
					cout<<endl<<"this has length from... "<<debug_intervals.thelist[i].start_length<<","<<debug_intervals.thelist[i].end_length;
					cout<<endl<<endl;
				}
				if((debug_intervals.thelist[0].end_length != -1) && (All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[0].end_length == -1)){
					cout<<endl<<"(((((((((((((((((((((((((((Replaced))))))))))))))))))))))))))))"<<endl;
                    All_Data->the_matrix[debug_x][debug_y][debug_image] = debug_intervals;

				}
				cout<<"==========At this point, The Intervals for this image are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][debug_image].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].end_length;
					cout<<endl;

				}
				cout<<"==========At this point, The intersected intervals for all images are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][num_cameras].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].end_length;
					cout<<endl;

				}
				cout<<endl;
				cout<<"COLOR DATA: "<<color_data[debug_x][debug_y]<<endl;
				cout<<"IT IS: ";
				cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;
				cout<<"Also....";
				
						x1 = SourceImages[debug_image].x*image_height;
						y1 = SourceImages[debug_image].y*image_height;
						z1 = SourceImages[debug_image].z*image_height;
						x2 = 3*image_height;
						y2 = ((float)debug_y - (image_height/2));
						z2 = ((float)debug_x - (image_width/2));
						CameraCloseness = getDistance(x1, y1, z1, x2, y2, z2);
				
	break;
    
    case GLUT_KEY_PAGE_DOWN: 
		//debugging mode: (source image number to display) --;
		if(debug_image == 0){
			debug_image = (num_cameras-1);
		}else{
			debug_image--;
		}
		GetDebugInfo(debug_x, debug_y, debug_image);
    	cout<<"Debug Mode: Now displaying Source Image #"<<debug_image;
		cout<<" (Ray coordinates are "<<debug_x<<", "<<debug_y<<")"<<endl;
		cout<<"some debug info....";
				for(int i = 0; i < debug_intervals.currentlength; i++){
			//		debug_intervals.thelist[i].CalcLength;
					cout<<"Interval from..."<<debug_intervals.thelist[i].startx<<","<<debug_intervals.thelist[i].starty;
					cout<<" to "<<debug_intervals.thelist[i].endx<<","<<debug_intervals.thelist[i].endy;
					cout<<endl<<"this has length from... "<<debug_intervals.thelist[i].start_length<<","<<debug_intervals.thelist[i].end_length;
					cout<<endl<<endl;
				}


				cout<<"==========At this point, The Intervals for this image are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][debug_image].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].end_length;
					cout<<endl;

				}
				cout<<"==========At this point, The intersected intervals for all images are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][num_cameras].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].end_length;
					cout<<endl;

				}
				cout<<endl;
				cout<<"COLOR DATA: "<<color_data[debug_x][debug_y]<<endl;
				cout<<"IT IS: ";
				cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;
				cout<<"Also....";
				
				x1 = SourceImages[debug_image].x*image_height;
				y1 = SourceImages[debug_image].y*image_height;
				z1 = SourceImages[debug_image].z*image_height;
				x2 = 3*image_height;
				y2 = ((float)debug_y - (image_height/2));
				z2 = ((float)debug_x - (image_width/2));
				CameraCloseness = getDistance(x1, y1, z1, x2, y2, z2);
				cout<<CameraCloseness;
	break;

    case GLUT_KEY_UP:
		if(debug_y == 0){
			debug_y = (image_height-1);
		}else{
			debug_y--;
		}
		GetDebugInfo(debug_x, debug_y, debug_image);
		cout<<"Debug Mode: Now displaying Ray from:"<<debug_x<<", "<<debug_y<<".";
		cout<<"  (Current Source Image is #"<<debug_image<<")"<<endl;
		cout<<"some debug info....";
				for(int i = 0; i < debug_intervals.currentlength; i++){
			//		debug_intervals.thelist[i].CalcLength;
					cout<<"Interval from..."<<debug_intervals.thelist[i].startx<<","<<debug_intervals.thelist[i].starty;
					cout<<" to "<<debug_intervals.thelist[i].endx<<","<<debug_intervals.thelist[i].endy;
					cout<<endl<<"this has length from... "<<debug_intervals.thelist[i].start_length<<","<<debug_intervals.thelist[i].end_length;
					cout<<endl<<endl;
				}

				cout<<"==========At this point, The Intervals for this image are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][debug_image].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].end_length;
					cout<<endl;

				}
				cout<<"==========At this point, The intersected intervals for all images are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][num_cameras].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].end_length;
					cout<<endl;

				}
				cout<<endl;
				cout<<"COLOR DATA: "<<color_data[debug_x][debug_y]<<endl;
				cout<<"IT IS: ";
				cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;
	break;

    case GLUT_KEY_DOWN: 
		if(debug_y == (image_height-1)){
			debug_y = 0;
		}else{
			debug_y++;
		}
		GetDebugInfo(debug_x, debug_y, debug_image);
		cout<<"Debug Mode: Now displaying Ray from:"<<debug_x<<", "<<debug_y<<".";
		cout<<"  (Current Source Image is #"<<debug_image<<")"<<endl;
		cout<<"some debug info....";
				for(int i = 0; i < debug_intervals.currentlength; i++){
			//		debug_intervals.thelist[i].CalcLength;
					cout<<"Interval from..."<<debug_intervals.thelist[i].startx<<","<<debug_intervals.thelist[i].starty;
					cout<<" to "<<debug_intervals.thelist[i].endx<<","<<debug_intervals.thelist[i].endy;
					cout<<endl<<"this has length from... "<<debug_intervals.thelist[i].start_length<<","<<debug_intervals.thelist[i].end_length;
					cout<<endl<<endl;
				}
				cout<<"==========At this point, The Intervals for this image are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][debug_image].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].end_length;
					cout<<endl;

				}
				cout<<"==========At this point, The intersected intervals for all images are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][num_cameras].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].end_length;
					cout<<endl;

				}
				cout<<endl;
				cout<<"COLOR DATA: "<<color_data[debug_x][debug_y]<<endl;
				cout<<"IT IS: ";
				cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;
    	
	break;

    case GLUT_KEY_LEFT:
		if(debug_x == 0){
			debug_x = (image_width-1);
		}else{
			debug_x--;
		}
		GetDebugInfo(debug_x, debug_y, debug_image);
		cout<<"Debug Mode: Now displaying Ray from:"<<debug_x<<", "<<debug_y<<".";
		cout<<"  (Current Source Image is #"<<debug_image<<")"<<endl;
		cout<<"some debug info....";
				for(int i = 0; i < debug_intervals.currentlength; i++){
			//		debug_intervals.thelist[i].CalcLength;
					cout<<"Interval from..."<<debug_intervals.thelist[i].startx<<","<<debug_intervals.thelist[i].starty;
					cout<<" to "<<debug_intervals.thelist[i].endx<<","<<debug_intervals.thelist[i].endy;
					cout<<endl<<"this has length from... "<<debug_intervals.thelist[i].start_length<<","<<debug_intervals.thelist[i].end_length;
					cout<<endl<<endl;
				}

				cout<<"==========At this point, The Intervals for this image are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][debug_image].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].end_length;
					cout<<endl;

				}
				cout<<"==========At this point, The intersected intervals for all images are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][num_cameras].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].end_length;
					cout<<endl;

				}
				cout<<endl;
				cout<<"COLOR DATA: "<<color_data[debug_x][debug_y]<<endl;
				cout<<"IT IS: ";
				cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;
	break;


	case GLUT_KEY_F1:
		draw_mode = 1;
		cout<<"F1 Pressed: Draw Mode switched to: Shaded."<<endl;
	break;


	case GLUT_KEY_F2:
		draw_mode = 2;
		cout<<"F2 Pressed: Draw Mode switched to: Colored Camera."<<endl;
		
	break;

	case GLUT_KEY_F3:
		draw_mode = 3;
		cout<<"F3 Pressed: Draw Mode switched to: Textured."<<endl;
	break;


    
    case GLUT_KEY_RIGHT: 
		if(debug_x == (image_width-1)){
			debug_x = 0;
		}else{
			debug_x++;
		}
		GetDebugInfo(debug_x, debug_y, debug_image);
		cout<<"Debug Mode: Now displaying Ray from:"<<debug_x<<", "<<debug_y<<".";
		cout<<"  (Current Source Image is #"<<debug_image<<")"<<endl;

		cout<<"some debug info....";
				for(int i = 0; i < debug_intervals.currentlength; i++){
			//		debug_intervals.thelist[i].CalcLength;
					cout<<"Interval from..."<<debug_intervals.thelist[i].startx<<","<<debug_intervals.thelist[i].starty;
					cout<<" to "<<debug_intervals.thelist[i].endx<<","<<debug_intervals.thelist[i].endy;
					cout<<endl<<"this has length from... "<<debug_intervals.thelist[i].start_length<<","<<debug_intervals.thelist[i].end_length;
					cout<<endl<<endl;
				}

				cout<<"==========At this point, The Intervals for this image are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][debug_image].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][debug_image].thelist[i].end_length;
					cout<<endl;

				}
				cout<<"==========At this point, The intersected intervals for all images are:"<<endl;
				for(int i = 0; i < All_Data->the_matrix[debug_x][debug_y][num_cameras].currentlength; i++){
					cout<<"Interval from...";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].start_length;
					cout<<" to ";
					cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].thelist[i].end_length;
					cout<<endl;

				}
				cout<<endl;
				cout<<"COLOR DATA: "<<color_data[debug_x][debug_y]<<endl;
				cout<<"IT IS: ";
				cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;


    	break;
		

    default:
        return;
    }

    glutPostRedisplay();
}

// Read input.
static GLenum Args(int argc, char **argv)
{
    GLint i, inputfile_count;

    rgb = GL_TRUE;
    doubleBuffer = GL_TRUE;
    inputfile_count = 0;

    for (i = 1; i < argc; i++) {
	if (strcmp(argv[i], "-ci") == 0) {
	    rgb = GL_FALSE;
	} else if (strcmp(argv[i], "-rgb") == 0) {
	    rgb = GL_TRUE;
	} else if (strcmp(argv[i], "-sb") == 0) {
	    doubleBuffer = GL_FALSE;
	} else if (strcmp(argv[i], "-db") == 0) {
	    doubleBuffer = GL_TRUE;
	} 
	else {
	    //printf("%s (Bad option).\n", argv[i]);
	    //return GL_FALSE;
	} 
    }
    return GL_TRUE;
}

/***********************************OPENGL STUFF above****************************************************/


//function prototypes:
void FillSourceArray(char*);					//populates the array of pixel values of the source images
unsigned long GetThePixel(int, int, int);		//returns the value at one pixel of some image.
Ray translate3dray(Ray,Plane);
float getDistance(float, float, float, float, float, float);
float angleAround(float, float);
float angleUp(float, float, float);
IntervalList ReturnIntervals(Ray, int, float, float, float);
IntervalList CheckOnInterval(float, float, IntervalList);
IntervalList intersect_intervals(IntervalList, IntervalList);
Ray rotate3dray(Ray, float, float, float);
float GetRedValue();
float GetGreenValue();
float GetBlueValue();



int main(int argc, char **argv){
	

//FCObjImage* source_images;


ifstream cameradata("cameras.txt");
//camera input data should be in "cameras.txt"
//--the first number in the file is the number of source images. 
//--the second and third numbers are image width and height.
//--next should be a list of X,Y,Z coordinates of each image's camera
//--(given that the object is centered at 0,0,0), in order.
//--the cameras should point at 0,0,0.

//an example cameras.txt file with 4 images of size 200x100 and camera
//coordinates (1,0,0), (0,1,0), (-1,0,0), and (0,-1,0) would be:
//4 200 100 1 0 0 0 1 0 -1 0 0 0 -1 0

//you also need to call FillSourceArray once in the program for each image that you have.

int total_pixels;
newX = 50.0; 
newY = 0.0; 
newZ = 0.0;


cout<<"Loading camera data from file..."<<endl;
cameradata>>num_cameras;
cameradata>>image_width;
cameradata>>image_height;
All_Data = new Image(image_width, image_height, num_cameras);
total_pixels = (image_width * image_height);
SourceImages = new SourceImage[num_cameras];
camera_color_counter = 0;
color_table = new RGBQUAD*[num_cameras];


for(int the_x = 0; the_x < image_width; the_x++){
	for(int the_y = 0; the_y < image_height; the_y++){
        All_Data->the_matrix[the_x][the_y][num_cameras].best_image = -1;
		All_Data->the_matrix[the_x][the_y][num_cameras].best_val = 9999999;
	}
}



for(int i = 0; i < num_cameras; i++){
	SourceImages[i].image_number = (i + 1);		//set the image number
	cameradata>>SourceImages[i].x;				//get the camera's x value
	cameradata>>SourceImages[i].z;				//get the camera's z value
	cameradata>>SourceImages[i].y;				//get the camera's y value
	SourceImages[i].r = GetRedValue();
	SourceImages[i].g = GetGreenValue();
	SourceImages[i].b = GetBlueValue();
	camera_color_counter++;
	cout<<"vals are:"<<SourceImages[i].r<<","<<SourceImages[i].g<<","<<SourceImages[i].b<<endl;


}

Ray someRay;
Plane somePlane;
someRay.x = 2.0;
someRay.y = 0.0;
someRay.z = 0.0;
someRay.xdir = 1.0;
someRay.ydir = 1.0;
someRay.zdir = 0.0;
somePlane.a = 0.0;
somePlane.b = -2.0;
somePlane.c = -2.0;
somePlane.d = 2.0;
cout<<"plane is"<<(180*angleUp(-somePlane.a, -somePlane.b, -somePlane.c))/3.14159;
cout<<"anglearound"<<(180*angleAround(-somePlane.a, -somePlane.c))/3.14159;
float somevalue = getDistance(0,0,0,someRay.x, someRay.y, someRay.z);
cout<<"point is this far from the origin:"<<somevalue;
float someothervalue = getDistance(0,0,0,someRay.xdir, someRay.ydir, someRay.zdir);
cout<<"point dir is this far from the origin:"<<somevalue;

someRay = translate3dray(someRay, somePlane);
cout<<"after translating, ";
somevalue = getDistance(0,0,0,someRay.x, someRay.y, someRay.z);
cout<<"point is this far from the origin:"<<somevalue;
someothervalue = getDistance(0,0,0,someRay.xdir, someRay.ydir, someRay.zdir);
cout<<"point dir is this far from the origin:"<<somevalue;


cout<<"-----------------test values--------------"<<endl;
cout<<"x: "<<someRay.x<<endl;
cout<<"y: "<<someRay.y<<endl;
cout<<"z: "<<someRay.z<<endl;
cout<<"xdir: "<<someRay.xdir<<endl;
cout<<"ydir: "<<someRay.ydir<<endl;
cout<<"zdir: "<<someRay.zdir<<endl;

//source_images = new FCObjImage[num_cameras];
	
	imagearray = new unsigned long**[num_cameras];
	sourceimage = 0;
    
	//here, you can edit the source image filenames.  to add a source image, call FillSourceArray:
		FillSourceArray("01.bmp");
		//FillSourceArray("02.bmp");
		FillSourceArray("03.bmp");
		FillSourceArray("04.bmp");
		cout<<"we got here";
		//FillSourceArray("05.bmp");
		//FillSourceArray("06.bmp");
		//FillSourceArray("07.bmp");
		// FillSourceArray("08.bmp");
	//(The number of FillSourceArray calls should match the number of cameras listed in the cameras.txt file)
	
	//note that you must also specify the exact number of source images in the cameras.txt file.

//all of the images are now loaded into the array source_images.
	
	
		//color_table

////////////testing interval intersection, seems to work...
		/*
	IntervalList ii1;
	IntervalList ii2;
	IntervalList ii3;

	interval ii_temp;
	//		ii_temp.start_length = 0;
	//		ii_temp.end_length = (image_width*image_height);
	//		ii_temp.startx = 0;
	//		ii_temp.endx = image_width*image_height;
	//		ii1.add(ii_temp);
			
	
			ii_temp.start_length = 900.14;
			ii_temp.end_length = 1200.23;
			ii_temp.endx = 5;
			ii1.add(ii_temp);

			ii_temp.start_length = 402.21;
			ii_temp.end_length = 1187.2144;
			ii2.add(ii_temp);


			ii_temp.start_length = 576.54;
			ii_temp.end_length = 1573.2;
			ii3.add(ii_temp);

			
			ii_temp.start_length = -1;
			ii_temp.end_length = -1;
			ii_temp.endx = -1;
			ii1.add(ii_temp);
			ii2.add(ii_temp);
			ii3.add(ii_temp);
			cout<<"ii1: ";
	for(int i = 0; i < ii1.currentlength; i++){
		cout<<ii1.thelist[i].start_length<<","<<ii1.thelist[i].end_length;
		cout<<"...";
	}
	cout<<endl;
	cout<<"ii2: "; 
	for(int i = 0; i < ii2.currentlength; i++){
		cout<<ii2.thelist[i].start_length<<","<<ii2.thelist[i].end_length;
		cout<<"...";
	}
	cout<<endl;
	cout<<"ii3: ";
	for(int i = 0; i < ii3.currentlength; i++){
		cout<<ii3.thelist[i].start_length<<","<<ii3.thelist[i].end_length;
		cout<<"...";
	}
	cout<<endl;
	
	IntervalList ii4;


	ii4 = intersect_intervals(ii2, ii3);
	cout<<"ii2 intersect ii3: ";
	for(int i = 0; i < ii4.currentlength; i++){
		cout<<ii4.thelist[i].start_length<<","<<ii4.thelist[i].end_length;
		cout<<"...";
	}
	cout<<endl;
	
	
	ii4 = intersect_intervals(ii1, ii2);
	cout<<"ii1 intersect ii2: ";
	for(int i = 0; i < ii4.currentlength; i++){
		cout<<ii4.thelist[i].start_length<<","<<ii4.thelist[i].end_length;
		cout<<"...";
	}
	cout<<endl;



	ii4 = intersect_intervals(ii4, ii3);
	cout<<"(ii1, ii2) intersect ii3: ";
	for(int i = 0; i < ii4.currentlength; i++){
		cout<<ii4.thelist[i].start_length<<","<<ii4.thelist[i].end_length;
		cout<<"...";
	}
	cout<<endl;

*/cout<<"we got here2222";
	//fill in the margin info...
	widths = new int[num_cameras+1];
	for(int i = 0; i < num_cameras; i++){
		widths[i] = get_width(i);
	}
	cout<<"we got here333";
	heights = new int*[num_cameras+1];
	for(int i = 0; i < num_cameras; i++){
		heights[i] = new int[image_width];
		for(int j = 0; j < image_width; j++){
			heights[i][j] = get_height(i, j);
		}
	}
	heights[num_cameras] = new int[image_width];
	cout<<"we got here44444";
	
	viewarray = new unsigned long*[image_width];
	for(int i = 0; i < image_width; i++){
		viewarray[i] = new unsigned long[image_height];
	}
	color_data = new float*[image_width];
	for(int i = 0; i < image_width; i++){
		color_data[i] = new float[image_height];
	}

	image_planes = new Plane[num_cameras];
	for(int i = 0; i < num_cameras; i++){
		image_planes[i].a = -SourceImages[i].x;
		image_planes[i].b = -SourceImages[i].y;
		image_planes[i].c = -SourceImages[i].z;
		image_planes[i].d = sqrt(((SourceImages[i].x)*(SourceImages[i].x)) + ((SourceImages[i].y)*(SourceImages[i].y)) + ((SourceImages[i].z)*(SourceImages[i].z)));
		cout<<"image "<<(i+1)<<" has plane values "<<image_planes[i].a<<","<<image_planes[i].b<<","<<image_planes[i].c<<","<<image_planes[i].d<<endl;
	}
    
	

	Ray new_view_ray;
/*here and end of this line.	Ray tempray; */
	

	new_view_ray.x = newX;
	new_view_ray.y = newY;
	new_view_ray.z = newZ;
	
	//cout<<"you forgot to uncomment the below stuff, or the stuff in draw_image.";

/*here

	cout<<"Desired View--Processing Scanline#";
	for(int j = 0; j < image_height; j++){
		cout<<".."<<j;
		for(int i = 0; i < image_width; i++){
			//cout<<"debug1"<<endl;
			IntervalList the_intervals;
			IntervalList temp_intervals;
			interval temp_interval;
//cout<<"debug2"<<endl;
			//the_intervals = new interval[image_width];
			//temp_intervals = new interval[image_width];
			
			//fill intervals array with {0...inf}:
			
			temp_interval.start_length = 0;
			temp_interval.end_length = (image_width*image_height);
			temp_interval.startx = 0;
			temp_interval.endx = image_width*image_height;
			the_intervals.add(temp_interval);
			
			temp_interval.start_length = -1;
			temp_interval.end_length = -1;
			temp_interval.endx = -1;
			the_intervals.add(temp_interval);
//cout<<"debug3"<<endl;
			//the_intervals[0].start_length = 0;
			//the_intervals[0].end_length = image_width;
			//the_intervals[1].start_length = -1;
			//the_intervals[1].end_length = -1;
			//the_intervals[1].endx = -1;
			new_view_ray.zdir = ((float)i-(image_width/2));//((((float)i / (float)image_width) * 2.0) - 1.0);
			new_view_ray.ydir = ((float)j-(image_height/2));//((((float)j / (float)image_height) * 2.0) - 1.0);
			new_view_ray.xdir = (0.0);

			//cout<<"viewing ray starts at camera location "<<newX<<","<<newY<<","<<newZ<<endl;
			//cout<<"   before rotating, it ends at "<<new_view_ray.xdir<<","<<new_view_ray.ydir<<","<<new_view_ray.zdir;

			//newZ = newZ + (image_width/2);
			//newY = newY + (image_height/2);
//here maybe
	//uncomment below line
			//new_view_ray = rotate3dray(new_view_ray, newX, newY, newZ);
			new_view_ray.z = ((float)i-(image_width/2));//((((float)i / (float)image_width) * 2.0) - 1.0);
			new_view_ray.y = ((float)j-(image_height/2));//((((float)j / (float)image_height) * 2.0) - 1.0);
			new_view_ray.x = newX;
			//new_view_ray.z = newZ;
			//new_view_ray.y = newY;
		
			//cout<<"<<i<<","<<j<<endl;
			//cout<<"   after rotating, it ends at "<<new_view_ray.xdir<<","<<new_view_ray.ydir<<","<<new_view_ray.zdir;
			//cout<<"debug4"<<endl;
		
			
			//testing new_view_rays
			//cout<<"--------Viewing ray---"<<endl;
			//cout<<"|Starts: "<<new_view_ray.x<<","<<new_view_ray.y<<","<<new_view_ray.z<<"|"<<endl;
			//cout<<"|Ends:   "<<new_view_ray.xdir<<","<<new_view_ray.ydir<<","<<new_view_ray.zdir<<endl;
			
		
			//cout<<".."<<i<<".."<<endl;

			bool image_hit = true;
			
		
			for(int k = 0; k < num_cameras; k++){
				
				//cout<<"for the pixel "<<i<<","<<j<<" we are looking at source image #"<<k<<" of "<<num_cameras;
		/*		cout<<"The camera is "<<image_planes[k].a<<","<<image_planes[k].b<<","<<image_planes[k].c<<endl;
				cout<<"about to translate..."<<endl;
				cout<<new_view_ray.x<<",";
				cout<<new_view_ray.y<<",";
				cout<<new_view_ray.z<<",";
				cout<<new_view_ray.xdir<<",";
				cout<<new_view_ray.ydir<<",";
				cout<<new_view_ray.zdir<<endl;
		*/		/*here
				tempray = translate3dray(new_view_ray, image_planes[k]);
//maybe put this line back//temp_intervals = ReturnIntervals(tempray, k, ((new_view_ray.xdir - new_view_ray.x)/(new_view_ray.zdir - new_view_ray.z)));
				temp_intervals = GetDebugInfo2(new_view_ray.z, new_view_ray.y, k);
				All_Data->the_matrix[i][j][k] = temp_intervals;

				/*	
				cout<<"translated..."<<endl;
				cout<<tempray.x<<",";
				cout<<tempray.y<<",";
				cout<<tempray.z<<",";
				cout<<tempray.xdir<<",";
				cout<<tempray.ydir<<",";
				cout<<tempray.zdir<<endl;

*/
/*here
				if(temp_intervals.thelist[0].endx == -1){
					image_hit = false;
					}


			/*	if(the_intervals.thelist[0].end_length != -1){
				cout<<"intersecting..."<<endl;
				for(int i = 0; i < the_intervals.currentlength; i++){
					
					cout<<the_intervals.thelist[i].start_length<<","<<the_intervals.thelist[i].end_length<<"..";
					}
                }
				if(temp_intervals.thelist[0].end_length != -1){
				cout<<endl<<"with.."<<endl;
				for(int i = 0; i < temp_intervals.currentlength; i++){
				
					cout<<temp_intervals.thelist[i].start_length<<","<<temp_intervals.thelist[i].end_length<<"..";
					}
                }*/
		/*here	

		the_intervals = intersect_intervals(the_intervals, temp_intervals);



		/*		if(the_intervals.currentlength != 0){
					if(the_intervals.thelist[0].end_length != -1){
						cout<<endl<<"resulting in..."<<endl;
					for(int i = 0; i < the_intervals.currentlength; i++){
					
					cout<<the_intervals.thelist[i].start_length<<","<<the_intervals.thelist[i].end_length<<"..";
					}
                }
				}
				cout<<endl<<endl;
		*/
		/*here				for(int i = 0; i < the_intervals.currentlength; i++){
					if(the_intervals.thelist[i].start_length > the_intervals.thelist[i].end_length){
						cout<<"Returned a bad value from intersect_intervals..."<<endl;
						cout<<"values were..."<<the_intervals.thelist[i].start_length<<","<<the_intervals.thelist[i].end_length<<endl;
					/*	float tempx, tempy, tempz, templength;		
						tempx = the_intervals.thelist[i].startx;
						tempy = the_intervals.thelist[i].starty;
						tempz = the_intervals.thelist[i].startz;
						templength = the_intervals.thelist[i].start_length;
						the_intervals.thelist[i].startx = the_intervals.thelist[i].endx;
						the_intervals.thelist[i].starty = the_intervals.thelist[i].endy;
						the_intervals.thelist[i].startz = the_intervals.thelist[i].endz;
						the_intervals.thelist[i].start_length = the_intervals.thelist[i].end_length;
						the_intervals.thelist[i].endx = tempx;
						the_intervals.thelist[i].endy = tempy;
						the_intervals.thelist[i].endz = tempz;
						the_intervals.thelist[i].end_length = templength;

					*/   /*here
					}
				}	///	cout<<"...";
					///	cout<<the_intervals.thelist[i].start_length;
					///	cout<<",";
					///	cout<<the_intervals.thelist[i].end_length;
					///		cout<<"...";

			/*	if(the_intervals.thelist[0].endx != -1){
					cout<<"the_intervals is nonempty...";
				}else{
					cout<<"the_intervals is empty...";
				}
				if(temp_intervals.thelist[0].endx != -1){
					cout<<"temp_intervals is nonempty...";
				}else{
					cout<<"temp_ints is empty...";
				}
				*/
				//the_intervals = temp_intervals;
				
				/*if(the_intervals.thelist[0].endx != -1){
					cout<<"...now there are no intervals....";
				}*/

				//cout<<"----after fixing it for the camera---"<<endl;
					//cout<<"|Starts: "<<tempray.x<<","<<tempray.y<<","<<tempray.z<<"    |"<<endl;
					//cout<<"|Ends:   "<<tempray.xdir<<","<<tempray.ydir<<","<<tempray.zdir<<endl;
					//cout<<"----------------------"<<endl;
				//		if(temp_intervals.thelist[0].endx != -1){
		//			cout<<"we have found at least one interval."<<endl;
		//		}
		/*here				
			}

			All_Data->the_matrix[i][j][num_cameras] = the_intervals;

			}}

			*/
			/////re-doing everything.
			cout<<"vertical scanline ";
			for(int debug_x = 0; debug_x < image_width; debug_x++){
				cout<<debug_x<<","<<endl;
				for(int debug_y = 0; debug_y < image_height; debug_y++){
					IntervalList a_temp_list;
					interval atemp_interval;
					atemp_interval.start_length = 0;
					atemp_interval.end_length = (image_width*image_height);
					atemp_interval.startx = 0;
					atemp_interval.endx = (image_width*image_height);
					a_temp_list.add(atemp_interval);
					int the_best_image;
					for(int debug_image = 0; debug_image < num_cameras; debug_image++){
						int CameraCloseness;
						int x1 = SourceImages[debug_image].x*image_height;
						int y1 = SourceImages[debug_image].y*image_height;
						int z1 = SourceImages[debug_image].z*image_height;
						int x2 = 3*image_height;
						int y2 = ((float)debug_y - (image_height/2));
						int z2 = ((float)debug_x - (image_width/2));
						CameraCloseness = getDistance(x1, y1, z1, x2, y2, z2);
						//cout<<"CAMERA CLOSENESS: ";
						//cout<<CameraCloseness;
						//cout<<endl;
						if(CameraCloseness < All_Data->the_matrix[debug_x][debug_y][num_cameras].best_val){
						//	if(debug_image != 0){
						//		cout<<"WE DID SOMETHING RIGHT"<<endl;
						//	}
							//cout<<"WE DID SOMETHING HERE"<<endl;
							All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image = debug_image;
							All_Data->the_matrix[debug_x][debug_y][num_cameras].best_val = CameraCloseness;
						}

						
						
						GetDebugInfo(debug_x, debug_y, debug_image);
						All_Data->the_matrix[debug_x][debug_y][debug_image] = debug_intervals;
						a_temp_list = intersect_intervals(a_temp_list, debug_intervals);

					
					

					}
					//if(All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image == 0){
					//	cout<<"THERE IS A NONZERO ARRAY VALUE..."<<debug_x<<","<<debug_y<<endl;
					//	cout<<All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;
                    //}
	
					the_best_image = All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image;
					All_Data->the_matrix[debug_x][debug_y][num_cameras] = a_temp_list;
				
					AllIntervals.add(a_temp_list.thelist[0]);
					if(a_temp_list.thelist[0].end_length != -1){
						viewarray[debug_x][debug_y] = 1;
						color_data[debug_x][debug_y] = a_temp_list.thelist[0].start_length;
					}else{
						viewarray[debug_x][debug_y] = 0;
						color_data[debug_x][debug_y] = 0;
					}
					All_Data->the_matrix[debug_x][debug_y][num_cameras].best_image = the_best_image;
					
						
				}
			}
				


			//now we have the desired image's bit-map stored...get the margin for the desired img:
			global_debug_test = false;
			widths[num_cameras] = get_desired_width();
			for(int i = 0; i < image_width; i++){
               heights[num_cameras][i] = get_desired_height(i);
			//	heights[num_cameras][i] = 10;
			}
			//if(global_debug_test == false){
				//cout<<"ok, so we never hit image..closing";
				//return 0;
			//}
			














/* uncomment this all later, perhaps.
			//AllIntervals.add(the_intervals.thelist[0]);
			AllIntervals.add(the_intervals.thelist[0]);
		//here i could choose to store the interval for each pixel in desired img.
  			if(the_intervals.thelist[0].end_length == -1){
		//	if(image_hit == false){  //still doesn't work :(
		//there are no intervals--the object does not exist at this point. don't draw!
				viewarray[i][j] = 0;
			}else{
				//cout<<"!231231231231"<<endl;
				viewarray[i][j] = 1;
				
				//here we have the closest interval for each pixel in one large array. we can then use 
				//this to compute shading info.
			}
		}
	}

	*/
	//done with pre-processing.  now display the image!

	ColorData = GetIntervalRange(AllIntervals);
	//cout<<"highest is..."<<ColorData.end_length;
	//cout<<"lowest is..."<<ColorData.start_length;
	
	cout<<endl<<"END key activates debug mode."<<endl;
	cout<<"To change rendering type, hit F1(shaded), F2(camera's color), or F3(textured)."<<endl;
	cout<<"(currently: F1)";
/*
	for(int i = 0; i < image_width; i++){
		for(int j = 0; j < image_height; j++){
			
				if(All_Data->the_matrix[i][j][num_cameras].color != 0){
					cout<<All_Data->the_matrix[i][j][num_cameras].color<<"...";
				}
			
		}
	}*/
	

	/**************************************OPENGL STUFF below***************************************************/
	glutInit(&argc, argv);

    if (Args(argc, argv) == GL_FALSE) {
	exit(1);
    }

    // Initialize window size.
    windW = image_width - 1;
    windH = image_height - 1;
	//windW = 512;
   // windH = 512;
    glutInitWindowPosition(0, 0); glutInitWindowSize(windW, windH);

    // Enable frame buffer for double buffering and z-buffering.
    windType = (rgb) ? GLUT_RGB : GLUT_INDEX;
    windType |= (doubleBuffer) ? GLUT_DOUBLE : GLUT_SINGLE;
    glutInitDisplayMode(windType | GLUT_DEPTH);

    if (glutCreateWindow("Visual Hull") == GL_FALSE) {
	exit(1);
    }

    angle = 0.0;		// Initialize rotation to 0.0
    glInit ();			
    glutReshapeFunc(Reshape);	// Set reshape function
    glutIdleFunc(Draw);   	// Even if no events, redraw to animate
    glutKeyboardFunc(Key);	// Set keyboard function
    glutSpecialFunc(SpecialKey);   // Set special keyboard function (arrow keys)
    glutDisplayFunc(Draw);	// Set Display function
    glutMainLoop();

	/*************************************OPENGL STUFF above****************************************************/




	/*
		for(int i = 0; i < image_width; i++){
			for(int j = 0; j < image_height; j++){
				if(viewarray[i][j] == 0){
					cout<<".";
				}else if(viewarray[i][j] == 1){
					cout<<"X";
				}else{
					cout<<"error";
				}
			}
		}		
*/



//cout<<"image outputted";


//cout<<source_images[0].GetPixelData(1,1)<<endl;

/*cout<<"first pixel is "<<imagearray[0][0][0];
cout<<"second pixel is "<<imagearray[0][1][0];
cout<<"first pixel is "<<imagearray[1][0][0];
cout<<"second pixel is "<<imagearray[1][1][0];
cout<<"first pixel is "<<imagearray[2][0][0];
cout<<"second pixel is "<<imagearray[2][1][0];
cout<<"first pixel is "<<imagearray[3][0][0];
cout<<"second pixel is "<<imagearray[3][1][0];
cout<<"first pixel is "<<imagearray[4][0][0];
cout<<"second pixel is "<<imagearray[4][1][0];
cout<<"first pixel is "<<imagearray[5][0][0];
cout<<"second pixel is "<<imagearray[5][1][0];
cout<<"first pixel is "<<imagearray[6][0][0];
cout<<"second pixel is "<<imagearray[6][1][0];
cout<<"first pixel is "<<imagearray[7][0][0];
cout<<"second pixel is "<<imagearray[7][1][0];
*/


//delete imagearray;
//delete viewarray;

if(image_planes != NULL){
	delete image_planes;
}
if(SourceImages != NULL){
	delete SourceImages;
}


return 0;


}

unsigned long GetThePixel(int image_number, int x, int y){

	return SourceImages[(image_number - 1)].PixelValue(x, y);

}


void FillSourceArray(char* filename){

	FCObjImage temp;
    temp.Load(filename);
	cout<<"Processing Image #"<<sourceimage<<endl;
	imagearray[sourceimage] = new unsigned long*[image_width];
	for(int z = 0; z < image_width; z++){
		imagearray[sourceimage][z] = new unsigned long[image_height];
		int y_inverse = image_height;
		for(int y = 0; y < image_height; y++){
			y_inverse--;
            //cout<<"visiting X value "<<z<<" and y value "<<y<<endl;
			//when images are read, it is from the bottom left. to flip the image and make it upright, 
			//get the value from (image_height minus y) rather than just y.
		//	cout<<"here:"<<sourceimage<<endl;
			imagearray[sourceimage][z][y] = temp.GetPixelData(z,y_inverse);
			color_table[sourceimage] = new RGBQUAD[256];
			if(temp.GetColorTable(0, 256, color_table[sourceimage]) == false){
				cout<<"error in GetColorTable call in FillSourceArray";
			}

			
		}
	}
	sourceimage++;

}

Ray translate3dray(Ray theRay, Plane thePlane){
	
	//given a 3d ray and a plane, this function projects the ray onto that plane.
	//given the ray (which is made up of two points), this is done by first rotating each point back to 
	//(1,0,0), then rotating to the original position PLUS the angle that the plane is off of that axis.
		
	float RadiansToRotateAround = -angleAround(-(thePlane.a), -(thePlane.c));
	float RadiansToRotateUp = -angleUp(-(thePlane.a), -(thePlane.b), -(thePlane.c));
	float RayHyp = getDistance(0,0,0,theRay.x, theRay.y, theRay.z);
	float XZRayHyp = getDistance(0,0,0,theRay.x, theRay.z,0);
	float RayHypD = getDistance(0,0,0,theRay.xdir, theRay.ydir, theRay.zdir);
	float XZRayHypD = getDistance(0,0,0,theRay.xdir, theRay.zdir,0);
	
	//now, the ray is made up of two points. a starting point and a point elsewhere indicating direction.
	//take each of these points and put them on the +x axis at 1.0.
	float xtemp = 1.0;
	float ztemp = 0.0;
	float ytemp = 0.0;
	float xdtemp = 1.0;
	float zdtemp = 0.0;
	float ydtemp = 0.0;
	//now rotate up or down however many degrees we need to rotate, plus the number of degrees it was already rotated.
	//also, make the point as far out from the origin as it was before, by multiplying by the ray's old hypotenuse.
	ytemp = sin(angleUp(theRay.x, theRay.y, theRay.z)+RadiansToRotateUp)*RayHyp;
	xtemp = cos(angleUp(theRay.x, theRay.y, theRay.z)+RadiansToRotateUp)*RayHyp;
	ydtemp = sin(angleUp(theRay.xdir, theRay.ydir, theRay.zdir)+RadiansToRotateUp)*RayHypD;
	xdtemp = cos(angleUp(theRay.xdir, theRay.ydir, theRay.zdir)+RadiansToRotateUp)*RayHypD;
	//now that each point is rotated up, 
	//rotate them back to original angle-around position, plus the amount of degrees to rotate.
	XZRayHyp = xtemp;	//returns value of X at this point.
	XZRayHypD = xdtemp;//returns value of Xd at this point.
	//so, RayHyp gets the X-distance from the center.  this is the radius of the circle to rotate around.
	//the Y value will be unchanged, but the X and Z values will be on this circle.
	xtemp = cos(angleAround(theRay.x, theRay.z) + RadiansToRotateAround) * XZRayHyp;
	ztemp = sin(angleAround(theRay.x, theRay.z) + RadiansToRotateAround) * XZRayHyp;
	xdtemp = cos(angleAround(theRay.xdir, theRay.zdir) + RadiansToRotateAround) * XZRayHypD;
	zdtemp = sin(angleAround(theRay.xdir, theRay.zdir) + RadiansToRotateAround) * XZRayHypD;
	theRay.x = xtemp;
	theRay.y = ytemp;
	theRay.z = ztemp;
	theRay.xdir = xdtemp;
	theRay.ydir = ydtemp;
	theRay.zdir = zdtemp;
	//now we have rotated the ray so that it is as if the image plane was on the YZ plane.  we can ignore the X value and just 
	//deal with the 2d ray.
	return theRay;


}
	
float getDistance(float x1, float y1, float z1, float x2, float y2, float z2){
	//returns distance between two points.
	return sqrt(((x2-x1)*(x2-x1)) + ((y2-y1)*(y2-y1)) + ((z2-z1)*(z2-z1)));
}
float angleAround(float x, float z){
	if(z == 0){
		if(x == (abs(x))){
			//if Z is zero and X is positive, there is no rotation.
			return 0;
		}else{
			//if Z is zero and X is negative, there is actually 180 deg. rotation.
			return 3.14159;
		}
	}else{
		//otherwse, it's just tan^-1 z/x.
        return atan(z/x);
	}
	
}
float angleUp(float x, float y, float z){
	return atan(y/sqrt(((x*x)+(z*z))));
	
}




IntervalList ReturnIntervals(Ray theRay, int image_number, float xchange, float zchange, float ychange){
	//cout<<"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@THE RATIO IS:";
	//cout<<ratio<<"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"<<endl;
//this function first finds intervals on the 2d ray where the object exists,
//and then translates those intervals back to the 3d ray.
	

	bool ReturnValue;	//if this is true, we need to get the source image's color at given pixel.
	ReturnValue = false;
	if(All_Data->the_matrix[global_i][global_j][num_cameras].best_image == image_number){
		ReturnValue = true;
	}
		
	
	

	float moveX = theRay.zdir-theRay.z;
	float moveY = theRay.ydir-theRay.y;
	///comment one. two lines below..
	float x = theRay.z + (image_width/2);
	float y = theRay.y + (image_height/2);



	IntervalList intervals;
	interval temp_interval;
	//intervals = new interval[image_width];
	int current_int;
	bool not_background;

	//divide both the rise and the run by the run.  this makes it so that we can easily increment by 1 in the x direction.
	if(moveX != 0){
		

		moveY = moveY/abs(moveX);
		moveX = moveX/abs(moveX);

		//cout<<"moveX and moveY are "<<moveX<<", "<<moveY<<endl;
		not_background = false;
		current_int = 0;

		//cout<<"x,y starts at "<<x<<","<<y<<"..";
		bool somevalue = false;

		while(somevalue != true){
		if(((int)moveX == abs((int)moveX)) && x > image_width){
			//x is already past the image, and moving in the positive direciton--this ray won't hit the desired viewpoint.
			//quit the loop.
			somevalue = true;

		}
		if(((int)moveX != abs((int)moveX)) && x < 0){
			//x is is before the image, and moving in the negative direciton--this ray won't hit the desired viewpoint.
			//quit the loop.
			somevalue = true;

		}
		//get x onto the image plane.	
		if((x < 0) | (x >= image_width)){
			x = x + moveX;
			y = y + moveY;
		}else{
			somevalue = true;
		}
	}

		


	//cout<<"but then becomes"<<x<<","<<y<<"..";
	//cout<<"||";


	while((x < image_width)&&(x >= 0)){
		//while x is still on the image plane:
	if((y >= image_height) | (y < 0)){
		//if the Y value is off the image plane, we can't check that pixel, so just do nothing.
	}else{
		//cout<<"at least we are in the image plane somewhere."<<endl;
		//cout<<"x,y are "<<x<<","<<y<<".."<<endl;
		//cout<<"moveX and moveY are "<<moveX<<", "<<moveY<<endl;
		if(SourceImages[image_number].PixelValue((int)x, (int)y) != 252){
			//cout<<"ReturnIntervals: we hit the image at "<<x<<","<<y<<endl;
			//if we reach a pixel that isn't background
			//cout<<"<hit>";
			if(ReturnValue == true){
				All_Data->the_matrix[global_i][global_j][num_cameras].color = SourceImages[image_number].PixelValue((int)x, (int)y);
				All_Data->the_matrix[global_i][global_j][num_cameras].r = color_table[image_number][SourceImages[image_number].PixelValue((int)x, (int)y)].rgbRed;
				All_Data->the_matrix[global_i][global_j][num_cameras].g = color_table[image_number][SourceImages[image_number].PixelValue((int)x, (int)y)].rgbGreen;
				All_Data->the_matrix[global_i][global_j][num_cameras].b = color_table[image_number][SourceImages[image_number].PixelValue((int)x, (int)y)].rgbBlue;



				ReturnValue = false;
			}



			if(not_background == false){
			//we aren't currently in an interval. create one.
				temp_interval.startz = x;
				temp_interval.starty = y;
				
			}else{
			//we are already in an interval. just move on to the next pixel.
			}
			not_background = true;
		}else{
		//we reach a pixel that is background.
			if(not_background == true){
			//we were in an interval, but now it is over.
				temp_interval.endz = (x - moveX);
				temp_interval.endy = (y - moveY);
				intervals.add(temp_interval);	
				//cout<<"interval from: "<<temp_interval.startz<<","<<temp_interval.starty<<","<<temp_interval.endz<<","<<temp_interval.endy<<endl;
				
				current_int++;
			}else{
			//we aren't in an interval. just move on to the next pixel.
			}
			not_background = false;
		}
	}
	//move on to the next pixel:
	
	//cout<<" visited pixels: "<<(int)x<<", "<<(int)y<<"...";
	x = x + moveX;
	y = y + moveY;
}

}else{
	//moveX is zero, so we have a vertical ray...

	moveY = moveY/abs(moveY);
	

	//cout<<"moveX and moveY are "<<moveX<<", "<<moveY<<endl;
	not_background = false;
	current_int = 0;

	//cout<<"x,y starts at "<<x<<","<<y<<"..";
	bool somevalue = false;
	while(somevalue != true){
	if(((int)moveY == abs((int)moveY)) && y > image_height){
		//x is already past the image, and moving in the positive direciton--this ray won't hit the desired viewpoint.
		//quit the loop.
		somevalue = true;

	}
	if(((int)moveY != abs((int)moveY)) && y < 0){
		//x is is before the image, and moving in the negative direciton--this ray won't hit the desired viewpoint.
		//quit the loop.
		somevalue = true;

	}
	//get y onto the image plane.	
	if((y < 0) | (y >= image_width)){
		y = y + moveY;
	}else{
		somevalue = true;
	}
}

	


	//cout<<"but then becomes"<<x<<","<<y<<"..";
	//cout<<"||";


	while((y < image_height)&&(y >= 0)){
		//while y is still on the image plane:
	
		//cout<<"at least we are in the image plane somewhere."<<endl;
		//cout<<"x,y are "<<x<<","<<y<<".."<<endl;
		//cout<<"moveX and moveY are "<<moveX<<", "<<moveY<<endl;
		if(SourceImages[image_number].PixelValue((int)x, (int)y) != 252){
			//cout<<"ReturnIntervals: we hit the image at "<<x<<","<<y<<endl;
			//if we reach a pixel that isn't background
			//cout<<"<hit>";
			if(not_background == false){
			//we aren't currently in an interval. create one.
				temp_interval.startz = x;
				temp_interval.starty = y;
				
			}else{
			//we are already in an interval. just move on to the next pixel.
			}
			not_background = true;
		}else{
		//we reach a pixel that is background.
			if(not_background == true){
			//we were in an interval, but now it is over.
				temp_interval.endz = x;
				temp_interval.endy = (y - moveY);
				intervals.add(temp_interval);	
				//cout<<"interval from: "<<temp_interval.startz<<","<<temp_interval.starty<<","<<temp_interval.endz<<","<<temp_interval.endy<<endl;
				
				current_int++;
			}else{
			//we aren't in an interval. just move on to the next pixel.
			}
			not_background = false;
		}
	//move on to the next pixel:
	y = y + moveY;
}
	
	
	//cout<<" visited pixels: "<<(int)x<<", "<<(int)y<<"...";
	
	

}

if(not_background == true){
	//if we are in the middle of calculating an interval, and reach end of image, end the interval.
	temp_interval.endz = (x - moveX);
	temp_interval.endy = (y - moveY);
	intervals.add(temp_interval);

	//intervals[current_int].endy = x-1;
//	intervals[current_int].endz = y-moveY;
	current_int++;
}
//cout<<"...length is..."<<intervals.currentlength<<"..";
for(int i = 0; i < intervals.currentlength; i++){
	//here.
	Ray some_temp_ray;
	if(zchange != 0){
		intervals.thelist[i].endx = (xchange/zchange)*intervals.thelist[i].endz;
		intervals.thelist[i].startx = (xchange/zchange)*intervals.thelist[i].startz;
	}else if(ychange != 0){
		intervals.thelist[i].endx = (xchange/ychange)*intervals.thelist[i].endy;
		intervals.thelist[i].startx = (xchange/ychange)*intervals.thelist[i].starty;
	}else{
		cout<<"...should this be happening??!"<<endl;
		intervals.thelist[i].endx = 0;
		intervals.thelist[i].startx = 0;
	}

	intervals.thelist[i].CalcLength(theRay);	
	//transform intervals back into 3d:
	some_temp_ray.x = intervals.thelist[i].startx;
	some_temp_ray.y = intervals.thelist[i].starty;
	some_temp_ray.z = intervals.thelist[i].startz;
	some_temp_ray.xdir = intervals.thelist[i].endx;
	some_temp_ray.ydir = intervals.thelist[i].endy;
	some_temp_ray.zdir = intervals.thelist[i].endz;


	
	if(some_temp_ray.x > some_temp_ray.xdir){
		float tempx, tempy, tempz;		
		tempx = some_temp_ray.x;
		tempy = some_temp_ray.y;
		tempz = some_temp_ray.z;
		some_temp_ray.x = some_temp_ray.xdir;
		some_temp_ray.y = some_temp_ray.ydir;
		some_temp_ray.z = some_temp_ray.zdir;
		some_temp_ray.xdir = tempx;
		some_temp_ray.ydir = tempy;
		some_temp_ray.zdir = tempz;
	}


//	some_temp_ray = rotate3dray(some_temp_ray, -(image_planes[image_number].a), -(image_planes[image_number].b), -(image_planes[image_number].c));
/*	cout<<"Before rotating..."<<endl;
	cout<<"X,Y,Z, and endX, endY, endZ are..."<<endl;
	cout<<some_temp_ray.x<<",";
	cout<<some_temp_ray.y<<",";
	cout<<some_temp_ray.z<<",";
	cout<<some_temp_ray.xdir<<",";
	cout<<some_temp_ray.ydir<<",";
	cout<<some_temp_ray.zdir<<endl;
	*/
//here maybe
	some_temp_ray = rotate3dray(some_temp_ray, newX, newY, newZ);
/*	cout<<"And after rotating..."<<endl;
	cout<<some_temp_ray.x<<",";
	cout<<some_temp_ray.y<<",";
	cout<<some_temp_ray.z<<",";
	cout<<some_temp_ray.xdir<<",";
	cout<<some_temp_ray.ydir<<",";
	cout<<some_temp_ray.zdir<<endl<<endl;
*/

	intervals.thelist[i].startx = some_temp_ray.x;
	intervals.thelist[i].starty = some_temp_ray.y;
	intervals.thelist[i].startz = some_temp_ray.z;
	intervals.thelist[i].endx = some_temp_ray.xdir;
	intervals.thelist[i].endy = some_temp_ray.ydir;
	intervals.thelist[i].endz = some_temp_ray.zdir;
	intervals.thelist[i].CalcLength(theRay);

	
	if(intervals.thelist[i].start_length > intervals.thelist[i].end_length){
		float tempx, tempy, tempz, templen;		
		tempx = intervals.thelist[i].startx;
		tempy = intervals.thelist[i].starty;
		tempz = intervals.thelist[i].startz;
		templen = intervals.thelist[i].start_length;
		intervals.thelist[i].startx = intervals.thelist[i].endx;
		intervals.thelist[i].starty = intervals.thelist[i].endy;
		intervals.thelist[i].startz = intervals.thelist[i].endz;
		intervals.thelist[i].start_length = intervals.thelist[i].end_length;
		intervals.thelist[i].endx = tempx;
		intervals.thelist[i].endy = tempy;
		intervals.thelist[i].endz = tempz;
		intervals.thelist[i].end_length = templen;
	}


	

}

//here, we add a "-1" interval to the end of the interval list.
//this will signal to other parts of the program that there are no more intervals in the list.

temp_interval.startx = -1;
temp_interval.starty = -1;
temp_interval.startz = -1;
temp_interval.endx = -1;
temp_interval.endy = -1;
temp_interval.endz = -1;
temp_interval.start_length = -1;
temp_interval.end_length = -1;

intervals.add(temp_interval);


return intervals;

}


IntervalList intersect_intervals(IntervalList previouslist, IntervalList toadd){
	for(int i = 0; i < previouslist.currentlength; i++){
	if(previouslist.thelist[i].start_length > previouslist.thelist[i].end_length){
		cout<<"passed a bad previouslist value to intersect";
		cout<<previouslist.thelist[i].start_length<<","<<previouslist.thelist[i].end_length<<endl;
	/*	float tempx, tempy, tempz, templength;		
		tempx = previouslist.thelist[i].startx;
		tempy = previouslist.thelist[i].starty;
		tempz = previouslist.thelist[i].startz;
		templength = previouslist.thelist[i].start_length;
		previouslist.thelist[i].startx = previouslist.thelist[i].endx;
		previouslist.thelist[i].starty = previouslist.thelist[i].endy;
		previouslist.thelist[i].startz = previouslist.thelist[i].endz;
		previouslist.thelist[i].start_length = previouslist.thelist[i].end_length;
		previouslist.thelist[i].endx = tempx;
		previouslist.thelist[i].endy = tempy;
		previouslist.thelist[i].endz = tempz;
		previouslist.thelist[i].end_length = templength;*/
		
	}
	}
	for(int i = 0; i < toadd.currentlength; i++){

		if(toadd.thelist[i].start_length > toadd.thelist[i].end_length){
			cout<<"passed a bad toadd value to intersect";
			cout<<toadd.thelist[i].start_length<<","<<toadd.thelist[i].end_length;
		/*float tempx, tempy, tempz, templength;		
		tempx = toadd.thelist[i].startx;
		tempy = toadd.thelist[i].starty;
		tempz = toadd.thelist[i].startz;
		templength = toadd.thelist[i].start_length;
		toadd.thelist[i].startx = toadd.thelist[i].endx;
		toadd.thelist[i].starty = toadd.thelist[i].endy;
		toadd.thelist[i].startz = toadd.thelist[i].endz;
		toadd.thelist[i].start_length = toadd.thelist[i].end_length;
		toadd.thelist[i].endx = tempx;
		toadd.thelist[i].endy = tempy;
		toadd.thelist[i].endz = tempz;
		toadd.thelist[i].end_length = templength;
		*/
	}

	}



	//because of the way we get the intervals, they are already in increasing order.
	IntervalList intervals;
	intervals.currentlength = 0;
	IntervalList temp_intervals_to_add;
	interval temp_interval;
	
	//cout<<"running intersect_intervals..."<<endl;
	/*if(previouslist.thelist[0].endx != -1){
		cout<<"   List A is not empty"<<endl;	
	}else{
		cout<<"   List A is empty"<<endl;
	}
	if(toadd.thelist[0].endx != -1){
		cout<<"   List B is not empty."<<endl;
	}else{
		cout<<"   List B is empty."<<endl;
	}
	*/
	int prev_count = 0;	//keeps track of where we are in the first int. list.
	int add_count = 0;	//keeps track of where we are in the second int. list.
	int current = 0;		//keeps track of where we are in the intersection of the two lists.
	int g = 0;				//counter
	//intervals = new interval[image_width];
	//temp_intervals_to_add = new interval[image_width];

   //cout<<"debug45"<<endl;
	
	

	for(int i = 0; i < previouslist.currentlength; i++){
		
		//cout<<"debug31"<<endl;
		//first, get the intervals from the second list that fall within an interval from the first list.
		if(previouslist.thelist[i].endx != -1){
			temp_intervals_to_add = CheckOnInterval(previouslist.thelist[i].start_length, previouslist.thelist[i].end_length, toadd);
		
		//cout<<"length is"<<temp_intervals_to_add.currentlength;
	//	for(int i = 0; i < temp_intervals_to_add.currentlength; i++){
	//		cout<<"item"<<i<<"is"<<temp_intervals_to_add.thelist[i].end_length;
	//	}
		
		//now, add those intervals to the final list of intervals:
		//cout<<"debug32"<<endl;
		for(int j = 0; j < temp_intervals_to_add.currentlength; j++){
			
			if(temp_intervals_to_add.thelist[j].endx != -1){
			////cout<<"debug33"<<endl;
				intervals.add(temp_intervals_to_add.thelist[j]);
			}
			//intervals[current].start_length = temp_intervals_to_add[g].start_length;
			//intervals[current].end_length = temp_intervals_to_add[g].end_length;
			//current++;
		}
		}
		//cout<<"debug34"<<endl;
		prev_count++;
	}
	//cout<<"debug46"<<endl;
	temp_interval.startx = -1;
	temp_interval.starty = -1;
	temp_interval.startz = -1;
	temp_interval.start_length = -1;
	temp_interval.endx = -1;
	temp_interval.endy = -1;
	temp_interval.endz = -1;
	temp_interval.end_length = -1;
	intervals.add(temp_interval);	
	//cout<<"debug46"<<endl;
	
	//if(intervals.thelist[0].endx != -1){
	//	cout<<"   We are returning a non-empty list."<<endl;
	//}else{
		//cout<<"   We are returning an empty list."<<endl;
	//}
	
	for(int i = 0; i < intervals.currentlength; i++){
		if(intervals.thelist[i].start_length > intervals.thelist[i].end_length){
			cout<<"**************&&&&&&&&&&&&&";
			cout<<"**************&&&&&&&&&&&&&";
			cout<<"**************&&&&&&&&&&&&&";
				cout<<"intersect is returning backwards stuff"<<endl;
				cout<<"**************&&&&&&&&&&&&&";
				cout<<"**************&&&&&&&&&&&&&";
				cout<<"**************&&&&&&&&&&&&&";
		}
	}

	return intervals;

		

}

IntervalList CheckOnInterval(float start, float end, IntervalList list){
	//given a single interval, and a list of intervals, this function returns
	//the list intersected with the single interval.
	if(start > end){
		float ftemp = start;
		start = end;
		end = ftemp;
		
	}
	IntervalList intervals;
	interval temp_interval;
	//intervals = new interval[image_width];
	int i = 0;
	int current = 0;

	for(int g = 0; g < list.currentlength; g++){
		if(list.thelist[g].start_length > list.thelist[g].end_length){
			float gtemp = list.thelist[g].start_length;
			list.thelist[g].start_length = list.thelist[g].end_length;
			list.thelist[g].end_length = gtemp;
		}
	}
	
	while(list.thelist[i].endx != -1){
		if((list.thelist[i].start_length >= start) && (list.thelist[i].start_length <= end)){
			//the case where an interval starts within the bounds.
			if(list.thelist[i].end_length <= end){
				//the end of the interval is within the bounds.
				intervals.add(list.thelist[i]);
				//intervals[current].start_length = list[i].start_length;
				//intervals[current].end_length = list[i].end_length;
				current++;
			}else{
				//the end of the interval is outside of the bounds.
				
				temp_interval.start_length = list.thelist[i].start_length;
				temp_interval.end_length = end;
				intervals.add(temp_interval);
				current++;
			}
		}else if(list.thelist[i].start_length <= start){
			//the case where an interval starts before the bounds
			if((list.thelist[i].end_length >= start) && (list.thelist[i].end_length <= end)){
				//the interval ends within the bounds
				temp_interval.start_length = start;
				temp_interval.end_length = list.thelist[i].end_length;
				intervals.add(temp_interval);
				current++;
			}else if(list.thelist[i].end_length >= end){
				//the interval ends past the bounds
				temp_interval.start_length = start;
				temp_interval.end_length = end;
				intervals.add(temp_interval);
				current++;
			}else{
				//the interval ends before the bounds. do nothing.
			}
		}else{
			//the interval starts after the bounds. do nothing.
		}

		i++;
			
	}
	
	temp_interval.endx = -1;
	temp_interval.endy = -1;
	temp_interval.endz = -1;
	temp_interval.starty = -1;
	temp_interval.startx = -1;
	temp_interval.startz = -1;
	temp_interval.end_length = -1;
	temp_interval.start_length = -1;
	intervals.add(temp_interval);		

	return intervals;

}
	/*
Ray rotate3dray(Ray theRay, float x, float y, float z){
	
	//given a 3d ray and a point to rotate to, this function rotates the ray.
	
	double RadiansToRotateAround = angleAround(x,y);
	double RadiansToRotateUp = angleUp(x, y, z);
	double RayHyp = getDistance(0,0,0,theRay.x, theRay.y, theRay.z);
	double XYRayHyp = getDistance(0,0,0,theRay.x, theRay.y,0);
	double RayHypD = getDistance(0,0,0,theRay.xdir, theRay.ydir, theRay.zdir);
	double XYRayHypD = getDistance(0,0,0,theRay.xdir, theRay.ydir,0);
	

	//rotate ray so that it is on the X axis
	double xtemp = 1.0 * XYRayHyp;
	double ytemp = 0.0 * XYRayHyp;
	double ztemp = theRay.z;
	double xdtemp = 1.0 * XYRayHypD;
	double ydtemp = 0.0 * XYRayHypD;
	double zdtemp = theRay.zdir;
	//then rotate it up or down the right amount of degrees
	ztemp = sin(angleUp(theRay.x, theRay.y, theRay.z)+RadiansToRotateUp)*RayHyp;
	xtemp = cos(angleUp(theRay.x, theRay.y, theRay.z)+RadiansToRotateUp)*RayHyp;
	zdtemp = sin(angleUp(theRay.xdir, theRay.ydir, theRay.zdir)+RadiansToRotateUp)*RayHypD;
	xdtemp = cos(angleUp(theRay.xdir, theRay.ydir, theRay.zdir)+RadiansToRotateUp)*RayHypD;
	//now rotate it back to original angle around position, plus the amount of degrees to rotate.
	XYRayHyp = getDistance(0,0,0,xtemp, ytemp,0);
	XYRayHypD = getDistance(0,0,0,xdtemp, ydtemp,0);
	xtemp = cos(angleAround(theRay.x, theRay.y) + RadiansToRotateAround) * XYRayHyp;
	ytemp = sin(angleAround(theRay.x, theRay.y) + RadiansToRotateAround) * XYRayHyp;
	xdtemp = cos(angleAround(theRay.xdir, theRay.ydir) + RadiansToRotateAround) * XYRayHypD;
	ydtemp = sin(angleAround(theRay.xdir, theRay.ydir) + RadiansToRotateAround) * XYRayHypD;
	theRay.x = xtemp;
	theRay.y = ytemp;
	theRay.z = ztemp;
	theRay.xdir = xdtemp;
	theRay.ydir = ydtemp;
	theRay.zdir = zdtemp;

	return theRay;


}*/


Ray rotate3dray(Ray theRay, float x, float y, float z){
	
	//given a 3d ray and a point to rotate to, this function rotates the ray.
		
	float RadiansToRotateAround = angleAround(x,z);
	float RadiansToRotateUp = angleUp(x,y,z);
	float RayHyp = getDistance(0,0,0,theRay.x, theRay.y, theRay.z);
	float XZRayHyp = getDistance(0,0,0,theRay.x, theRay.z,0);
	float RayHypD = getDistance(0,0,0,theRay.xdir, theRay.ydir, theRay.zdir);
	float XZRayHypD = getDistance(0,0,0,theRay.xdir, theRay.zdir,0);
	
	//now, the ray is made up of two points. a starting point and a point elsewhere indicating direction.
	//take each of these points and put them on the +x axis at 1.0.
	float xtemp = 1.0;
	float ztemp = 0.0;
	float ytemp = 0.0;
	float xdtemp = 1.0;
	float zdtemp = 0.0;
	float ydtemp = 0.0;
	//now rotate up or down however many degrees we need to rotate
	//also, make the point as far out from the origin as it was before, by multiplying by the ray's old hypotenuse.
	ytemp = sin(angleUp(theRay.x, theRay.y, theRay.z)+RadiansToRotateUp)*RayHyp;
	xtemp = cos(angleUp(theRay.x, theRay.y, theRay.z)+RadiansToRotateUp)*RayHyp;
	ydtemp = sin(angleUp(theRay.xdir, theRay.ydir, theRay.zdir)+RadiansToRotateUp)*RayHypD;
	xdtemp = cos(angleUp(theRay.xdir, theRay.ydir, theRay.zdir)+RadiansToRotateUp)*RayHypD;
	//now that each point is rotated up, 
	//rotate them back to original angle-around position, plus the amount of degrees to rotate.
	XZRayHyp = xtemp;	//returns value of X at this point.
	XZRayHypD = xdtemp;//returns value of Xd at this point.
	//so, RayHyp gets the X-distance from the center.  this is the radius of the circle to rotate around.
	//the Y value will be unchanged, but the X and Z values will be on this circle.
	xtemp = cos(angleAround(theRay.x, theRay.z) + RadiansToRotateAround) * XZRayHyp;
	ztemp = sin(angleAround(theRay.x, theRay.z) + RadiansToRotateAround) * XZRayHyp;
	xdtemp = cos(angleAround(theRay.xdir, theRay.zdir) + RadiansToRotateAround) * XZRayHypD;
	zdtemp = sin(angleAround(theRay.xdir, theRay.zdir) + RadiansToRotateAround) * XZRayHypD;
	theRay.x = xtemp;
	theRay.y = ytemp;
	theRay.z = ztemp;
	theRay.xdir = xdtemp;
	theRay.ydir = ydtemp;
	theRay.zdir = zdtemp;

	return theRay;


}
	

interval GetIntervalRange(IntervalList list){
	//given a list of intervals, this function returns a single interval, where the start_length value is the lowest 
	//first interval starting point in the list, and the end_length value is the highest first interval starting point in the list.
	interval x;
	float highest = 0;
	float lowest = 999999;

	for(int i = 0; i < list.currentlength; i++){
		if(list.thelist[i].endx != -1){
			if(list.thelist[i].start_length < lowest){
				lowest = list.thelist[i].start_length;
			}
			if(list.thelist[i].start_length > highest){
				highest = list.thelist[i].start_length;
			}
		}
	}

	x.start_length = lowest;
	x.end_length = highest;
	cout<<"lowest is "<<lowest<<endl;
	cout<<"higest is "<<highest<<endl;
	return x;

}


void GetDebugInfo(int i, int j, int image_number){
	//when passed an x,y value and an image number, this function finds the ray from that pixel in the desired viewpoint,
	//and the intervals on that ray where the image is hit.
	//these are stored into global variables debug_ray and debug_intervals.
		//cout<<"debug1"<<endl;

	

			Ray new_view_ray;
			new_view_ray.x = newX;
			new_view_ray.y = newY;
			new_view_ray.z = newZ;
	


			IntervalList the_intervals;
			IntervalList temp_intervals;
			interval temp_interval;

			
			temp_interval.start_length = 0;
			temp_interval.end_length = image_width*image_height;
			temp_interval.startx = 0;
			temp_interval.endx = image_width;
			the_intervals.add(temp_interval);
			
			temp_interval.start_length = -1;
			temp_interval.end_length = -1;
			temp_interval.endx = -1;

			

			new_view_ray.zdir = ((float)i-(image_width/2));//((((((float)i / (float)image_width) * 2.0) - 1.0))*image_width);
			new_view_ray.ydir = ((float)j-(image_height/2));//((((((float)j / (float)image_height) * 2.0) - 1.0))*image_height);
			new_view_ray.xdir = (0.1);

			Ray view_ray2 = new_view_ray;
		
			new_view_ray = rotate3dray(new_view_ray, newX, newY, newZ);
			new_view_ray.x = newX;
			new_view_ray.y = newY;
			new_view_ray.z = newZ;
			new_view_ray.z = ((float)i-(image_width/2));//((((((float)i / (float)image_width) * 2.0) - 1.0))*image_width);
			new_view_ray.y = ((float)j-(image_height/2));//((((((float)j / (float)image_height) * 2.0) - 1.0))*image_height);
			
			//cout<<"X, y, and xdir, ydir, are: "<<debug_ray.x<<","debug_ray.y<<","debug_ray.xdir<<","debug_ray.ydir<<",";
		//	cout<<"X, y, and xdir, ydir, are: "<<new_view_ray.z<<","<<new_view_ray.y<<","<<new_view_ray.zdir<<","<<new_view_ray.ydir<<",";
		//	cout<<"then we translate ray"<<endl;
			debug_ray = translate3dray(new_view_ray, image_planes[image_number]);
		//	cout<<"X, y, and xdir, ydir, are: "<<debug_ray.z<<","<<debug_ray.y<<","<<debug_ray.zdir<<","<<debug_ray.ydir<<",";
			//temp_intervals = ReturnIntervals(debug_ray, image_number, ((debug_ray.xdir - debug_ray.x)/(debug_ray.zdir - debug_ray.z)));

			//debug_intervals = intersect_intervals(the_intervals, temp_intervals);
			if((view_ray2.zdir - view_ray2.z) == 0){
			//cout<<"*************************************************"<<endl;
			//cout<<(view_ray2.xdir - view_ray2.x)<<" and "<<(view_ray2.zdir - view_ray2.z)<<endl;
			//cout<<"*************************************************"<<endl;
			}
			global_i = i;
			global_j = j;
//			debug_intervals = ReturnIntervals(debug_ray, image_number, ((view_ray2.xdir - view_ray2.x)/(view_ray2.zdir - view_ray2.z)));
			debug_intervals = ReturnIntervals(debug_ray, image_number, (view_ray2.xdir - view_ray2.x), (view_ray2.zdir - view_ray2.z), (view_ray2.ydir - view_ray2.y));

			temp_debug = intersect_intervals(temp_debug, debug_intervals);


}


IntervalList GetDebugInfo2(int i, int j, int image_number){
	//when passed an x,y value and an image number, this function finds the ray from that pixel in the desired viewpoint,
	//and the intervals on that ray where the image is hit.
	//these are stored into global variables debug_ray and debug_intervals.
		//cout<<"debug1"<<endl;
	IntervalList debug2_intervals;
			Ray new_view_ray;
			new_view_ray.x = newX;
			new_view_ray.y = newY;
			new_view_ray.z = newZ;
	


			IntervalList the_intervals;
			IntervalList temp_intervals;
			interval temp_interval;

			
			temp_interval.start_length = 0;
			temp_interval.end_length = image_width*image_height;
			temp_interval.startx = 0;
			temp_interval.endx = image_width;
			the_intervals.add(temp_interval);
			
			temp_interval.start_length = -1;
			temp_interval.end_length = -1;
			temp_interval.endx = -1;

			

			new_view_ray.zdir = ((float)i-(image_width/2));//((((((float)i / (float)image_width) * 2.0) - 1.0))*image_width);
			new_view_ray.ydir = ((float)j-(image_height/2));//((((((float)j / (float)image_height) * 2.0) - 1.0))*image_height);
			new_view_ray.xdir = (0.1);

			Ray view_ray2 = new_view_ray;
		
			new_view_ray = rotate3dray(new_view_ray, newX, newY, newZ);
			new_view_ray.x = newX;
			new_view_ray.y = newY;
			new_view_ray.z = newZ;
			new_view_ray.z = ((float)i-(image_width/2));//((((((float)i / (float)image_width) * 2.0) - 1.0))*image_width);
			new_view_ray.y = ((float)j-(image_height/2));//((((((float)j / (float)image_height) * 2.0) - 1.0))*image_height);
			
			//cout<<"X, y, and xdir, ydir, are: "<<debug_ray.x<<","debug_ray.y<<","debug_ray.xdir<<","debug_ray.ydir<<",";
		//	cout<<"X, y, and xdir, ydir, are: "<<new_view_ray.z<<","<<new_view_ray.y<<","<<new_view_ray.zdir<<","<<new_view_ray.ydir<<",";
		//	cout<<"then we translate ray"<<endl;
			debug_ray = translate3dray(new_view_ray, image_planes[image_number]);
		//	cout<<"X, y, and xdir, ydir, are: "<<debug_ray.z<<","<<debug_ray.y<<","<<debug_ray.zdir<<","<<debug_ray.ydir<<",";
			//temp_intervals = ReturnIntervals(debug_ray, image_number, ((debug_ray.xdir - debug_ray.x)/(debug_ray.zdir - debug_ray.z)));

			//debug_intervals = intersect_intervals(the_intervals, temp_intervals);
			debug2_intervals = ReturnIntervals(debug_ray, image_number, (view_ray2.xdir - view_ray2.x), (view_ray2.zdir - view_ray2.z), (view_ray2.ydir - view_ray2.y));
			return debug2_intervals;
			//temp_debug = intersect_intervals(temp_debug, debug_intervals);


}


float GetRedValue(){
	int x = camera_color_counter;
	if((x == 0) | (x == 4) | (x == 5) | (x == 10) | (x == 11)){
		return 1.0;
	}else if((x == 1) | (x == 2) | (x == 3) | (x == 7) | (x == 8)){
		return 0.0;
	}else{
		return 0.5;
	}
}
float GetGreenValue(){
	int x = camera_color_counter;
	if((x == 0) | (x == 2) | (x == 4) | (x == 6) | (x == 8)){
		return 0.0;
	}else if((x == 1) | (x == 3) | (x == 5) | (x == 9) | (x == 11)){
		return 1.0;
	}else{
		return 0.5;
	}
}
float GetBlueValue(){
	int x = camera_color_counter;
	if((x == 0) | (x == 1) | (x == 5) | (x == 6) | (x == 7)){
		return 0.0;
	}else if((x == 2) | (x == 3) | (x == 4) | (x == 9) | (x == 10)){
		return 1.0;
	}else{
		return 0.5;
	}

}

int get_width(int image_num){
	//given an image number, this function takes that source image,
	//and returns the left margin, that is, the number of pixels between the left edge of the 
	//image, and the left edge of the actual object (not background).
	//used for texturing
	int closest_i;
	int i;
	closest_i = -1;
	i = 0;
	while(closest_i == -1){
	 	for(int j = 0; j < image_height; j++){
			if(SourceImages[image_num].PixelValue(i, j) != 252){
				closest_i = i;
			}
		}
		i++;
		if(i > image_width){
			closest_i = 1;
			cout<<"error in get_width, probably because the source image is empty"<<endl;
		}
	}
	return closest_i;
		
}
int get_desired_width(){
	//similar to get_width, but finds the margin for the desired viewpoint, once we have computed
	//the silhouette.
	int closest_i;
	int i;
	closest_i = -1;
	i = 0;
	while(closest_i == -1){
	 	for(int j = 0; j < image_height; j++){
			if(viewarray[i][j] != 252){
				closest_i = i;
			}
		}
		i++;
		if(i > image_width){
			closest_i = 1;
			cout<<"error in get_width, probably because the source image is empty"<<endl;
		}
	}
	return closest_i;

}
		
int get_height(int image_num, int i){
	//given an image number, and column, this function takes that source image,
	//and returns the left margin, that is, the number of pixels between the left edge of the 
	//image, and the left edge of the actual object (not background).
	//used for texturing
	int top_j;
	int bottom_j;
	top_j = -1;
	for(int j = 0; j < image_height; j++){
		if(SourceImages[image_num].PixelValue(i, j) != 252){
			bottom_j = j;
			if(top_j == -1){
				top_j = j;
			}
		}
	}
	if(top_j == -1){
		return 0;
	}else{
		return bottom_j - top_j;
	}
}

int get_desired_height(int i){
	//used for texturing
	int top_j;
	int bottom_j;
	top_j = -1;
	if(i >= image_width){
		cout<<"error in G D H"<<endl;
	}
	
	for(int j = 0; j < image_height; j++){
		if(viewarray[i][j] != 0){
			bottom_j = j;
			if(top_j == -1){
				top_j = j;
			}
		}	
	}

	
	if(top_j == -1){
		return 0;
	}else{
		global_debug_test = true;
		if((bottom_j - top_j) != 0){
			

		}
		return bottom_j - top_j;
	}
}