// Mirror images processing
// Reflection reMapping
//
// ideas
// . using movie for site instead, switch between analitical and mirror mode
// . time the effect presentation like, basic image, mirrors, analysis, display, and again


// this text goes out to html
/**
press d to display an image * press f to flatten the mirrors 
press i to swap background * press l to swap content
*/


 	
// setup webCam input
//~ import processing.video.*; 
//~ Capture myCapture; 

// image variables
PImage streetImage; 
PImage displayImage;
PImage canvasImage=new PImage(400,300);
int[] imagePixels;
int imageWidth = 400;
int imageHeight = 300;
int imagePixelAmount = imageWidth * imageHeight;
int streetImageSetSize = 6; 		// amont of available images as backgrounds
int currentStreetImage = 0; 		// counter for loading the above
int contentImageSetSize = 5; 	// amont of available images to display
int currentContentImage = 0; 		// counter for loading the above
// displayImage
int displayImageWidth = 40;


// init segments (mirrors)
int mirrorWidth = 10;	// has to be while divideable with imageWidth
int mirrorHeight = 10;	// hes to be whole divideable with imageHeigth
float[][] coloumnBrigthness;  //for storing mirror average brightness, 0-100
float[][] coloumnHue;  //for storing mirror average hue, 0-100
int mirrorView[][]; // where a coloumn / row mirror is looking at, defining its angle, and image offset
int mirrorFlatView[][]; // where a coloumn / row mirror is looking at if reset to zero offset
float[] rowBrigthness;  //  for storing mirror average color
float[][] targetBrightness; // for storing the image brigthness we want to display, 0-100 
float[][] targetHue; // for storing the image hue we want to display, 0-100 
float rotationSpeed = 5;

// flags
int coloumn = 0;
int row = 0;
int flag = 0;
boolean runOnce = false;
boolean analysis = false;
boolean showDisplay = false;
boolean showFlat = true;

// setup global options
void setup(){
	size(400, 300);
	colorMode(HSB, 100); 
	framerate(25);
	// to find out your camera name, uncomment the following line
	// println(Capture.list()); 
	//~ String webCamName = "Labtec WebCam-WDM"; 
	//~ myCapture = new Capture(this, webCamName, width, height, 30);
	
}

// looping main 
void draw(){
	if (!runOnce){
		initArrays();
		initImage();
		loadDisplayImage();
		runOnce = true;
	}
	//~ initImage();
  
	if (analysis){
		//drawAnalisys();
	} else {
		rotateMirrors();
		drawMirrors();
	}
	drawGrid();
	//saveFrame("alephvideomirror-#####.tif"); 
}
// get background image
void initImage(){
	streetImage = loadImage("testimage"+currentStreetImage+".jpg");
	if (currentStreetImage < streetImageSetSize - 1){
		currentStreetImage++;
	} else {
		currentStreetImage = 0;
	}
	//myCapture.read(); 
	//streetImage = myCapture;
	
	for(int i=0; i<imagePixelAmount; i++) {
		imagePixels[i] = streetImage.pixels[i];
	}
	//resetImage();
	analyzeColoumns();
	//resetViewArrayValues();
}


// init Arrays
void initArrays(){
	// new arrays with size
	imagePixels = new int[imagePixelAmount];
	coloumnBrigthness = new float[(imageWidth / mirrorWidth)][imageHeight];
	coloumnHue = new float[(imageWidth / mirrorWidth)][imageHeight];
	targetBrightness = new float[(imageWidth / mirrorWidth)][imageHeight / mirrorHeight];
	targetHue = new float[(imageWidth / mirrorWidth)][imageHeight / mirrorHeight];
	mirrorFlatView = new int[(imageWidth / mirrorWidth)][imageHeight / mirrorHeight];
	mirrorView = new int[(imageWidth / mirrorWidth)][imageHeight / mirrorHeight];
	resetViewArrayValues();
}
void resetViewArrayValues(){
	// place initial array content
	for (coloumn = 0; coloumn < imageWidth / mirrorWidth; coloumn++){
		for (row = 0; row < imageHeight / mirrorHeight; row++){
			mirrorFlatView[coloumn][row] = (mirrorHeight / 2) + (row * mirrorHeight);
			mirrorView[coloumn][row] = (mirrorHeight / 2) + (row * mirrorHeight);
		}
	}
}

// draw Grid
void drawGrid(){
	stroke(0, 20);
	strokeWeight(1); 
	for (int i=0; i<imageWidth / mirrorWidth; i++){
		line(i * mirrorWidth, 0, i * mirrorWidth, height);
	}
	for (int i=0; i<imageHeight / mirrorHeight; i++){
		line(0, i * mirrorHeight, width, i * mirrorHeight);
	}
}



// analyzeColoumns
void analyzeColoumns(){
	for (int i=0; i<(imageWidth / mirrorWidth); i++){
		for (int j=0; j<imageHeight - mirrorHeight; j++){
			coloumnBrigthness[i][j] = getMirrorBrigthness((mirrorWidth/2 + (i * mirrorWidth)) + (((mirrorHeight / 2) + j) * imageWidth));
			coloumnHue[i][j] = getMirrorHue((mirrorWidth/2 + (i * mirrorWidth)) + (((mirrorHeight / 2) + j) * imageWidth));
		}
	}
	
	// find min and max values and normalize data for each coloumn

	for (int i=0; i<(imageWidth / mirrorWidth); i++){
		// find minmax
		float maxValue = 0;
		float minValue = 100;
		for (int j=0; j<imageHeight - mirrorHeight; j++){
			maxValue = max(coloumnBrigthness[i][j], maxValue);
			minValue = min(coloumnBrigthness[i][j], minValue);
		}
		
		// normalize (move and scale to 0-100)
		//for (int j=0; j<imageHeight - mirrorHeight; j++){
			//coloumnBrigthness[i][j] = coloumnBrigthness[i][j] - minValue;
			//coloumnBrigthness[i][j] = coloumnBrigthness[i][j] * (100 / (maxValue - minValue));
		//}
	}
}

// get Image to display
void loadDisplayImage(){
	// load the next image
	displayImage = loadImage("content"+currentContentImage+".jpg");
	image(displayImage, 0, 0);
	
	int ratio = (imageWidth / mirrorWidth) / displayImageWidth;
	
	if (currentContentImage < contentImageSetSize - 1){
		currentContentImage++;
	} else {
		currentContentImage = 0;
	}
	
	// place its values
	for (coloumn = 0; coloumn < imageWidth / mirrorWidth; coloumn++){
		for (row = 0; row < imageHeight / mirrorHeight; row++){
			targetBrightness[coloumn][row] = 
			brightness(displayImage.pixels[(coloumn / ratio) + ((row / ratio) * displayImageWidth)]);
			
			targetHue[coloumn][row] = 
			hue(displayImage.pixels[(coloumn / ratio) + ((row / ratio) * displayImageWidth)]);
		}
	}
}




// rotate mirrors
void rotateMirrors(){
	for (coloumn = 0; coloumn < imageWidth / mirrorWidth; coloumn++){
		for (row = 0; row < imageHeight / mirrorHeight; row++){
			
			float target;
			if (showDisplay) {
				// find closest value
				// target = (targetBrightness[coloumn][row] + targetHue[coloumn][row]) / 2;
				target = targetBrightness[coloumn][row];
				int hitPosition = 0;
				float distance = 1000;
				for (int coloumnHeight=0; coloumnHeight<imageHeight - mirrorHeight; coloumnHeight++){
					//~ if (abs((coloumnBrigthness[coloumn][coloumnHeight] 
					//~ + coloumnHue[coloumn][coloumnHeight]) / 2 - target) < distance){
						//~ //distance = abs(coloumnBrigthness[coloumn][coloumnHeight] - target);
						//~ distance = (abs(coloumnHue[coloumn][coloumnHeight] - target) 
						//~ + abs(coloumnHue[coloumn][coloumnHeight] - target)) / 2;
						//~ hitPosition = coloumnHeight;
					//~ };
					
					if (abs(coloumnBrigthness[coloumn][coloumnHeight] - target) < distance){
						distance = abs(coloumnBrigthness[coloumn][coloumnHeight] - target);
						hitPosition = coloumnHeight;
					};
				}
	      
				// iterate to closest value
				int test = abs(mirrorView[coloumn][row] - hitPosition);
				//~ println(test);
				if (abs(mirrorView[coloumn][row] - hitPosition) > rotationSpeed){
					mirrorView[coloumn][row] -= int((mirrorView[coloumn][row] - hitPosition)/rotationSpeed);
				} else {
					mirrorView[coloumn][row] = hitPosition;
				}
			
			} else if (showFlat) {
				if (abs(mirrorView[coloumn][row] - mirrorFlatView[coloumn][row]) > rotationSpeed){
					mirrorView[coloumn][row] -= int((mirrorView[coloumn][row] - mirrorFlatView[coloumn][row])/
					rotationSpeed);
				} else {
					mirrorView[coloumn][row] = mirrorFlatView[coloumn][row];
				}
			}
		}
	}
};

// draw Mirrors
void drawMirrors(){
	//loadPixels();
/*
	for(int i=0; i<imagePixelAmount; i++) {
		imagePixels[i] = streetImage.pixels[i];
	}
  */  
	for (coloumn = 0; coloumn < imageWidth / mirrorWidth - 1; coloumn++){
		for (row = 0; row < imageHeight / mirrorHeight - 1; row++){
                        canvasImage.copy(streetImage,coloumn*mirrorWidth,mirrorView[coloumn][row],mirrorWidth,mirrorHeight,
                                         coloumn*mirrorWidth,row*mirrorHeight,mirrorWidth,mirrorHeight);
/*
			for (int mirrorHeightPixel = 0; mirrorHeightPixel < mirrorHeight; mirrorHeightPixel++){
				for (int mirrorWidthPixel = 0; mirrorWidthPixel < mirrorWidth; mirrorWidthPixel++){
					
					imagePixels[(coloumn * mirrorWidth) + (row * imageWidth * mirrorHeight) + 
					(mirrorHeightPixel * imageWidth) + mirrorWidthPixel] = 
					
					imagePixels[(coloumn * mirrorWidth) + 
					(mirrorHeightPixel * imageWidth) + mirrorWidthPixel + 
					(mirrorView[coloumn][row] * imageWidth)];
				}
			}
*/
		}
	}
  background(canvasImage);
  /*
        int[]ÊimagePixels=canvasImage.pixels;
	for (int i=0; i<imagePixelAmount; i++) { 
		pixels[i] = imagePixels[i];  
	}
*/
	//updatePixels();  
}

// get brigthness for a mirror sized area
float getMirrorBrigthness(int position){
	position -= (mirrorWidth / 2) + (imageWidth * (mirrorHeight / 2));
	float addedBrigthness = 0;
	for (int i=0; i<mirrorHeight; i++){
		for (int j=0; j<mirrorWidth; j++){
			int scanPos = position + j + (i * imageWidth);
			addedBrigthness += brightness(imagePixels[scanPos]);
		}
	}
	return addedBrigthness / (mirrorWidth * mirrorHeight);
}

// get hue for a mirror sized area
float getMirrorHue(int position){
	position -= (mirrorWidth / 2) + (imageWidth * (mirrorHeight / 2));
	float addedHue = 0;
	for (int i=0; i<mirrorHeight; i++){
		for (int j=0; j<mirrorWidth; j++){
			int scanPos = position + j + (i * imageWidth);
			addedHue += hue(imagePixels[scanPos]);
		}
	}
	return addedHue / (mirrorWidth * mirrorHeight);
}

// get hue for a mirror sized area
float getMirrorSaturation(int position){
	position -= (mirrorWidth / 2) + (imageWidth * (mirrorHeight / 2));
	float addedSaturation = 0;
	for (int i=0; i<mirrorHeight; i++){
		for (int j=0; j<mirrorWidth; j++){
			int scanPos = position + j + (i * imageWidth);
			addedSaturation += saturation(imagePixels[scanPos]);
		}
	}
	return addedSaturation / (mirrorWidth * mirrorHeight);
}

//NBS distance, color smilarity for 2 pixel
//~ NBS distance Feeling for the human eye
//~ 0.0~1.50 Homogenous
//~ 1.5~3.0 Slight difference
//~ 3.0~6.0 Appreciable difference
//~ Above 6.0 Much difference
float nbsDistancePix(int pix1, int pix2){
	return 1.2 * pow( 
	2 * saturation(pix1) * saturation(pix2) * (1 - cos(2 * PI * (hue(pix1)-hue(pix2)) / 100)) 
	+ pow(2, saturation(pix1)-saturation(pix2) + pow(2, (brightness(pix1)-brightness(pix2)) * 4)), 0.5);
}

float nbsDistance(float hue1, float sat1, float bright1, float hue2, float sat2, float bright2){
	return 1.2 * pow( 2 * sat1 * sat2 * (1 - cos(2 * PI * (hue1 - hue2) / 100)) 
	+ pow(2, sat1 - sat2 + pow(2, (bright1 - bright2) * 4)), 0.5);
}


// reset to image
void resetImage(){
	loadPixels();
	for(int i=0; i<imagePixelAmount; i++) {
		imagePixels[i] = streetImage.pixels[i];
	}
	for (int i=0; i<imagePixelAmount; i++) { 
		pixels[i] = imagePixels[i];  
	}
	updatePixels();  
}


// keyboard listener
void keyReleased(){
	if(key == 'd' || key == 'D'){
		analysis = false;
		showDisplay = true;
		showFlat = false;
	} else if(key == 'f' || key == 'F'){  
		analysis = false;
		showDisplay = false;
		showFlat = true;
	} else if(key == 'i' || key == 'I'){  
		initImage();
		analysis = false;
		showDisplay = false;
		showFlat = true;
	} else if(key == 'l' || key == 'L'){  
		loadDisplayImage();
		analysis = false;
		showDisplay = false;
		showFlat = true;
	} 
}