Jiaming Guo / flow3

#include <stdlib.h>
#include <string>
#include <fstream>
#include <algorithm>

// CUDA include
#ifdef __CUDACC__
#include "device_launch_parameters.h"
#include <cuda.h>
#include <cuda_runtime_api.h>
#include "cuda_runtime.h"
#endif

// OPENGL include
#include <GL/glut.h>
#include <GL/freeglut.h>

#include "flow.h"

// STIM include
#include <stim/visualization/gl_aaboundingbox.h>
#include <stim/parser/arguments.h>
#include <stim/visualization/camera.h>
#include <stim/visualization/colormap.h>
#include <stim/cuda/cudatools/error.h>


//********************parameter setting********************
// overall parameters
int vX, vY;
float dx, dy, dz;										// x, y and z image scaling(units/pixel)
std::string stackdir = "";								// directory where image stacks will be stored
stim::arglist args;										// create an instance of arglist
stim::gl_aaboundingbox<float> bb;						// axis-aligned bounding box object
stim::camera cam;										// camera object
unsigned num_edge;										// number of edges in the network
unsigned num_vertex;									// number of vertex in the network
std::vector<unsigned> pendant_vertex;					// list of pendant vertex index in GT
std::vector<std::string> menu_option = { "simulation", "build inlet/outlet", "manufacture" };
stim::flow<float> flow;									// flow object
float move_pace;										// camera moving parameter
float u;												// viscosity
float rou;												// density
float max_v;
float min_v;
int mods;												// special keyboard input
std::vector<unsigned char> color;						// velocity color map
std::vector<int> velocity_bar;							// velocity bar

// hard-coded parameters
float camera_factor = 1.2f;			// start point of the camera as a function of X and Y size
float orbit_factor = 0.01f;			// degrees per pixel used to orbit the camera
float zoom_factor = 10.0f;			// zooming factor
float border_factor = 20.0f;		// border
float radii_factor = 1.0f;			// radii changing factor
GLint subdivision = 20;				// slices and stacks
float default_radius = 5.0f;		// default radii of network vertex
float delta = 0.01f;				// small discrepancy
float eps = 20.0f;					// epsilon threshold
float max_pressure = 0.0f;			// maximum pressure that the channel can bear
float height_threshold = 100.0f;	// connection height constraint
float fragment_ratio = 0.0f;		// fragment ratio

// glut event parameters
int mouse_x;						// window x-coordinate
int mouse_y;						// window y-coordinate
bool LTbutton = false;				// true means down while false means up				

// simulation parameters
bool render_direction = false;		// flag indicates rendering flow direction for one edge
bool simulation = false;			// flag indicates simulation mode
bool color_bound = false;			// flag indicates velocity color map bound
bool to_select_pressure = false;	// flag indicates having selected a vertex to modify pressure
unsigned pressure_index;			// the index of vertex that is clicked
unsigned direction_index = -1;		// the index of edge that is pointed at

// build inlet/outlet parameters
bool build_inlet_outlet = false;	// flag indicates building inlets and outlets
bool modified_bridge = false;		// flag indicates having modified inlet/outlet connection
bool hilbert_curve = false;			// flag indicates enabling hilbert curves constructions
bool change_fragment = false;		// flag indicates changing fragment for square wave connections

// manufacture parameters
bool manufacture = false;			// flag indicates manufacture mode


//********************helper function*********************
// get the network basic information
inline void get_background() {

	pendant_vertex = flow.get_boundary_vertex();
	num_edge = flow.edges();
	num_vertex = flow.vertices();

	// set the initial radii
	flow.init(num_edge, num_vertex);			// initialize flow object
	
	// if no radius information laoded
	if (!flow.get_radius(0, 0))
		for (unsigned i = 0; i < num_edge; i++)
			flow.set_r(i, default_radius);
}

// convert from window coordinates to world coordinates
inline void window_to_world(GLdouble &x, GLdouble &y, GLdouble &z) {

	GLint    viewport[4];
	GLdouble modelview[16];
	GLdouble projection[16];
	GLdouble winX, winY;
	GLfloat  winZ;

	glGetIntegerv(GL_VIEWPORT, viewport);
	glGetDoublev(GL_MODELVIEW_MATRIX, modelview);
	glGetDoublev(GL_PROJECTION_MATRIX, projection);

	winX = (GLdouble)mouse_x;
	winY = viewport[3] - (GLdouble)mouse_y;
	glReadPixels((GLint)winX, (GLint)winY, (GLsizei)1, (GLsizei)1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
	gluUnProject(winX, winY, winZ, modelview, projection, viewport, &x, &y, &z);
}


//********************simulation function**********************
// initialize flow object
void flow_initialize() {

	flow.set = true;
	stim::vec3<float> center = bb.center();

	for (unsigned i = 0; i < pendant_vertex.size(); i++) {
		if (flow.get_vertex(pendant_vertex[i])[0] <= center[0])
			flow.P[pendant_vertex[i]] = max_pressure - i * delta;	// should set minor discrepancy
		else
			flow.P[pendant_vertex[i]] = (i + 1) * delta;			// algorithm treat 0 as no initial pressure
	}
}

// find the stable flow state
void flow_stable_state() {
	
	flow.solve_flow(u);
	flow.get_color_map(max_v, min_v, color, pendant_vertex);
	color_bound = true;

	velocity_bar.resize(num_edge);
	for (unsigned i = 0; i < num_edge; i++)
		velocity_bar[i] = i;
	std::sort(velocity_bar.begin(), velocity_bar.end(), [&](int x, int y) {return abs(flow.v[x]) < abs(flow.v[y]); });
}


//********************glut function********************
// dynamically set menu
// @param num: number of current menu options
// @param range: range of option to be set from menu_option list
void glut_set_menu(int num, int range) {

	// remove last time menu options
	for (int i = 1; i < num + 1; i++)
		glutRemoveMenuItem(1);

	// set new menu options
	std::string menu_name;
	for (int i = 1; i < range + 1; i++) {
		menu_name = menu_option[i - 1];
		glutAddMenuEntry(menu_name.c_str(), i);
	}
}

// set up the squash transform to whole screen
void glut_projection() {

	glMatrixMode(GL_PROJECTION);					// load the projection matrix for editing
	glLoadIdentity();								// start with the identity matrix
	vX = glutGet(GLUT_WINDOW_WIDTH);				// use the whole screen for rendering
	vY = glutGet(GLUT_WINDOW_HEIGHT);
	glViewport(0, 0, vX, vY);						// specify a viewport for the entire window
	float aspect = (float)vX / (float)vY;			// calculate the aspect ratio
	gluPerspective(60, aspect, 0.1, 1000000);		// set up a perspective projection
}

// translate camera to origin
void glut_modelview() {

	glMatrixMode(GL_MODELVIEW);						// load the modelview matrix for editing
	glLoadIdentity();								// start with the identity matrix
	stim::vec3<float> eye = cam.getPosition();		// get the camera position (eye point)
	stim::vec3<float> focus = cam.getLookAt();		// get the camera focal point
	stim::vec3<float> up = cam.getUp();				// get the camera "up" orientation

	gluLookAt(eye[0], eye[1], eye[2], focus[0], focus[1], focus[2], up[0], up[1], up[2]);	// set up the OpenGL camera
}

// glut render function
void glut_render() {

	glEnable(GL_DEPTH_TEST);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
	glut_projection();
	glut_modelview();

	if (!simulation && !build_inlet_outlet || manufacture) {
		glColor3f(0.0f, 0.0f, 0.0f);
		flow.glCylinder0();
	}
	else {
		flow.bounding_box();
		flow.glSolidSphere(max_pressure, subdivision);
		flow.mark_vertex();
		//flow.glSolidCone(subdivision);
		flow.glSolidCylinder(direction_index, color, subdivision);
		flow.glSolidCuboid();
		if (render_direction)
			flow.glSolidCone(direction_index, subdivision);
	}

	if (build_inlet_outlet) {
		flow.line_bridge();
	}
	
	if (manufacture) {
		flow.glSolidCuboid();
		flow.tube_bridge(subdivision);
	}
	
	// render bars
	// bring up a pressure bar on left
	if (to_select_pressure) {
		
		glMatrixMode(GL_PROJECTION);									// set up the 2d viewport for mode text printing
		glPushMatrix();
		glLoadIdentity();
		vX = glutGet(GLUT_WINDOW_WIDTH);								// get the current window width
		vY = glutGet(GLUT_WINDOW_HEIGHT);								// get the current window height
		glViewport(0, 0, vX, vY);										// locate to left bottom corner
		gluOrtho2D(0, vX, 0, vY);										// define othogonal aspect

		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glLoadIdentity();

		glLineWidth(border_factor);
		glBegin(GL_LINES);
		glColor3f(0.0, 0.0, 1.0);										// blue to red
		glVertex2f(border_factor, border_factor);
		glColor3f(1.0, 0.0, 0.0);
		glVertex2f(border_factor, (vY - 2.0f * border_factor));
		glEnd();
		glFlush();

		// pressure bar text
		glColor3f(0.0f, 0.0f, 0.0f);
		glRasterPos2f(0.0f, vY - border_factor);
		std::stringstream ss_p;
		ss_p << "Pressure Bar";
		glutBitmapString(GLUT_BITMAP_HELVETICA_18, (const unsigned char*)(ss_p.str().c_str()));

		// pressure range text
		float step = vY - 3.0f * border_factor;
		step /= 10;
		for (unsigned i = 0; i < 11; i++) {
			glRasterPos2f((border_factor * 1.5f), (border_factor + i * step));
			std::stringstream ss_n;
			ss_n << (float)i * max_pressure / 10;
			glutBitmapString(GLUT_BITMAP_HELVETICA_18, (const unsigned char*)(ss_n.str().c_str()));
		}
		glPopMatrix();
		glMatrixMode(GL_PROJECTION);
		glPopMatrix();
	}

	// bring up a velocity bar on left
	if (simulation && !to_select_pressure) {
		
		glMatrixMode(GL_PROJECTION);									// set up the 2d viewport for mode text printing
		glPushMatrix();
		glLoadIdentity();
		vX = glutGet(GLUT_WINDOW_WIDTH);								// get the current window width
		vY = glutGet(GLUT_WINDOW_HEIGHT);								// get the current window height
		glViewport(0, 0, vX, vY);										// locate to left bottom corner
		gluOrtho2D(0, vX, 0, vY);										// define othogonal aspect

		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glLoadIdentity();

		float step = (vY - 3 * border_factor);
		step /= num_edge;
		for (unsigned i = 0; i < num_edge; i++) {
			glLineWidth(border_factor);
			glBegin(GL_LINES);
			glColor3f((float)color[velocity_bar[i] * 3 + 0] / 255, (float)color[velocity_bar[i] * 3 + 1] / 255, (float)color[velocity_bar[i] * 3 + 2] / 255);
			glVertex2f(border_factor, border_factor + i * step);
			glVertex2f(border_factor, border_factor + (i + 1) * step);
			glEnd();
		}
		glFlush();

		// pressure bar text
		glColor3f(0.0f, 0.0f, 0.0f);
		glRasterPos2f(0.0f, vY - border_factor);
		std::stringstream ss_p;
		ss_p << "Velocity range";
		glutBitmapString(GLUT_BITMAP_HELVETICA_18, (const unsigned char*)(ss_p.str().c_str()));

		// pressure range text
		step = vY - 3 * border_factor;
		step /= 10;
		for (unsigned i = 0; i < 11; i++) {
			glRasterPos2f(border_factor * 1.5f, border_factor + i * step);
			std::stringstream ss_n;
			ss_n << min_v + i * (max_v - min_v) / 10;
			glutBitmapString(GLUT_BITMAP_HELVETICA_18, (const unsigned char*)(ss_n.str().c_str()));
		}
		glPopMatrix();
		glMatrixMode(GL_PROJECTION);
		glPopMatrix();
	}

	// bring up a ratio bar on the left
	if (change_fragment) {
		
		glMatrixMode(GL_PROJECTION);									// set up the 2d viewport for mode text printing
		glPushMatrix();
		glLoadIdentity();
		vX = glutGet(GLUT_WINDOW_WIDTH);								// get the current window width
		vY = glutGet(GLUT_WINDOW_HEIGHT);								// get the current window height
		glViewport(0, 0, vX, vY);										// locate to left bottom corner
		gluOrtho2D(0, vX, 0, vY);										// define othogonal aspect

		glMatrixMode(GL_MODELVIEW);
		glPushMatrix();
		glLoadIdentity();

		glLineWidth(border_factor);
		glBegin(GL_LINES);
		glColor3f(0.0, 0.0, 1.0);										// blue to red
		glVertex2f(border_factor, border_factor);
		glColor3f(1.0, 0.0, 0.0);
		glVertex2f(border_factor, (vY - 2.0f * border_factor));
		glEnd();
		glFlush();

		// pressure bar text
		glColor3f(0.0f, 0.0f, 0.0f);
		glRasterPos2f(0.0f, vY - border_factor);
		std::stringstream ss_p;
		ss_p << "Ratio bar";
		glutBitmapString(GLUT_BITMAP_HELVETICA_18, (const unsigned char*)(ss_p.str().c_str()));

		// pressure range text
		float step = vY - 3.0f * border_factor;
		step /= 10;
		for (unsigned i = 0; i < 11; i++) {
			glRasterPos2f((border_factor * 1.5f), (border_factor + i * step));
			std::stringstream ss_n;
			ss_n << (float)i * 1.0f / 10;
			glutBitmapString(GLUT_BITMAP_HELVETICA_18, (const unsigned char*)(ss_n.str().c_str()));
		}
		glPopMatrix();
		glMatrixMode(GL_PROJECTION);
		glPopMatrix();
	}

	glutSwapBuffers();
}

// register glut menu options
void glut_menu(int value) {

	int num = glutGet(GLUT_MENU_NUM_ITEMS);
	if (value == 1) {
		simulation = true;
		build_inlet_outlet = false;
		manufacture = false;
		modified_bridge = false;
		if (!flow.set)
			flow_initialize();
		flow_stable_state();					// main function of solving the linear system
		flow.print_flow();
		
		glut_set_menu(num, 2);
	}

	if (value == 2) {
		simulation = false;
		build_inlet_outlet = true;
		manufacture = false;
		if (!modified_bridge) {
			flow.set_main_feeder();
			flow.build_synthetic_connection(u, default_radius);
		}

		glut_set_menu(num, 3);
	}

	if (value == 3) {
		simulation = false;
		build_inlet_outlet = false;
		manufacture = true;
		flow.check_synthetic_connection(u, default_radius);
	}

	glutPostRedisplay();
}

// defines camera motion based on mouse dragging
void glut_motion(int x, int y) {

	mods = glutGetModifiers();
	if (LTbutton && mods == 0) {

		float theta = orbit_factor * (mouse_x - x);		// determine the number of degrees along the x-axis to rotate
		float phi = orbit_factor * (y - mouse_y);		// number of degrees along the y-axis to rotate

		cam.OrbitFocus(theta, phi);						// rotate the camera around the focal point
	}
	mouse_x = x;										// update the mouse position
	mouse_y = y;

	glutPostRedisplay();								// re-draw the visualization
}

// defines passive mouse motion function
void glut_passive_motion(int x, int y) {

	mouse_x = x;
	mouse_y = y;

	// check whether the mouse point near to an edge
	GLdouble posX, posY, posZ;
	window_to_world(posX, posY, posZ);			// get the world coordinates

	if (simulation || build_inlet_outlet) {
		bool flag = flow.epsilon_edge((float)posX, (float)posY, (float)posZ, eps, direction_index);
		if (flag)
			render_direction = true;
		else {
			if (render_direction)				// if the direction is displaying currently, do a short delay
				Sleep(1000);
			render_direction = false;
			direction_index = -1;
		}
	}

	glutPostRedisplay();								// re-draw the visualization
}

// get click window coordinates
void glut_mouse(int button, int state, int x, int y) {

	mouse_x = x;
	mouse_y = y;
	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
		LTbutton = true;
	else if (button == GLUT_LEFT_BUTTON && state == GLUT_UP)
		LTbutton = false;

	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN && simulation && !to_select_pressure) {

		GLdouble posX, posY, posZ;
		window_to_world(posX, posY, posZ);			// get the world coordinates

		bool flag = flow.epsilon_vertex((float)posX, (float)posY, (float)posZ, eps, pressure_index);
		if (flag) {
			std::vector<unsigned>::iterator it = std::find(pendant_vertex.begin(), pendant_vertex.end(), pressure_index);
			if (it != pendant_vertex.end()) 		// if it is dangle vertex
				to_select_pressure = true;
		}
	}
	else if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN && simulation && to_select_pressure) {
		if (y > 2 * border_factor || y < vY - border_factor) {		// within the pressure bar range
			to_select_pressure = false;
			float tmp_pressure = (float)(vY - y - border_factor) / ((float)vY - border_factor) * max_pressure;
			flow.set_pressure(pressure_index, tmp_pressure);

			flow_stable_state();									// main function of solving the linear system
			flow.print_flow();
		}
	}
	else if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN && modified_bridge && change_fragment) {
		if (y > 2 * border_factor || y < vY - border_factor) {		// within the ratio bar range
			fragment_ratio = (float)(vY - y - border_factor) / ((float)vY - border_factor) * 1.0f;
			flow.modify_synthetic_connection(u, rou, hilbert_curve, height_threshold, fragment_ratio, default_radius);
			change_fragment = false;
		}
	}
}

// define camera move based on mouse wheel move
void glut_wheel(int wheel, int direction, int x, int y) {
	
	mouse_x = x;
	mouse_y = y;

	GLdouble posX, posY, posZ;
	window_to_world(posX, posY, posZ);			// get the world coordinates

	if (!to_select_pressure) {
		bool flag = flow.epsilon_vertex((float)posX, (float)posY, (float)posZ, eps, pressure_index);
		if (flag && simulation) {
			float tmp_r;
			if (direction > 0) {				// increase radii
				tmp_r = flow.get_radius(pressure_index);
				tmp_r += radii_factor;
			}
			else {
				tmp_r = flow.get_radius(pressure_index);
				tmp_r -= radii_factor;
				if (tmp_r <= 0)
					tmp_r = default_radius;
			}
			flow.set_radius(pressure_index, tmp_r);
			flow_stable_state();
			flow.print_flow();
		}
		else {
			if (direction > 0)								// if it is button 3(up), move closer
				move_pace = zoom_factor;
			else											// if it is button 4(down), leave farther
				move_pace = -zoom_factor;

			cam.Push(move_pace);
		}
	}
	
	glutPostRedisplay();
}

// define keyboard inputs
void glut_keyboard(unsigned char key, int x, int y) {

	// register different keyboard operation
	switch (key) {

		// zooming
	case 'w':						// if keyboard 'w' is pressed, then move closer
		move_pace = zoom_factor;
		cam.Push(move_pace);
		break;
	case 's':						// if keyboard 's' is pressed, then leave farther
		move_pace = -zoom_factor;
		cam.Push(move_pace);
		break;

		// output image stack
	case 'm':
		if (manufacture) {
#ifdef __CUDACC__
			flow.make_image_stack(dx, dy, dz, stackdir);
#else
			std::cout << "You need to have a gpu to make image stack, sorry." << std::endl;
#endif
		}
		else if (build_inlet_outlet && !modified_bridge) {
			modified_bridge = true;

			if (hilbert_curve)
				flow.modify_synthetic_connection(u, rou, hilbert_curve, height_threshold);
			else
				change_fragment = true;
		}
		break;
	}
	
	glutPostRedisplay();
}

// glut initialization
void glut_initialize() {

	int myargc = 1;
	char* myargv[1];
	myargv[0] = strdup("generate_network_network");

	glutInit(&myargc, myargv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100, 100);							// set the initial window position
	glutInitWindowSize(1000, 1000);
	glutCreateWindow("3D flow simulation");

	glutDisplayFunc(glut_render);
	glutMouseFunc(glut_mouse);
	glutMotionFunc(glut_motion);
	glutPassiveMotionFunc(glut_passive_motion);
	glutMouseWheelFunc(glut_wheel);
	glutKeyboardFunc(glut_keyboard);

	glutCreateMenu(glut_menu);					// create a menu object 
	glut_set_menu(0, 1);
	glutAttachMenu(GLUT_RIGHT_BUTTON);			// register right mouse to open menu option

	stim::vec3<float> c = bb.center();			// get the center of the network bounding box
	// place the camera along the z-axis at a distance determined by the network size along x and y
	cam.setPosition(c + stim::vec<float>(0, 0, camera_factor * std::max(bb.size()[0], bb.size()[1])));
	cam.LookAt(c[0], c[1], c[2]);
}

// output an advertisement for the lab, authors and usage information
void advertise() {
	std::cout << std::endl << std::endl;
	std::cout << " =======================================================================================" << std::endl;
	std::cout << "|Thank you for using the synthetic microvascular model generator for microfluidics tool!|" << std::endl;
	std::cout << "|Scalable Tissue Imaging and Modeling (STIM) Lab, University of Houston                 |" << std::endl;
	std::cout << "|Developers: Jiaming Guo, David Mayerich                                                |" << std::endl;
	std::cout << "|Source: https://git.stim.ee.uh.edu/Jack/flow3.git									  |" << std::endl;
	std::cout << " =======================================================================================" << std::endl << std::endl;

	std::cout << args.str();
}

// main function: parse arguments and initialize GLUT
int main(int argc, char* argv[]) {
	
	// add arguments
	args.add("help", "prints the help");
	args.add("network", "load network from .obj or .swc file");
	args.add("maxpress", "maximum allowed pressure in g / units / s^2, default 2 is for blood when units = um", "2", "real value > 0");
	args.add("viscosity", "set the viscosity of the fluid (in g / units / s), default .00001 is for blood when units = um", ".00001", "real value > 0");
	args.add("rou", "set the desity of the fluid (in g / units^3), default 1.06*10^-12 is for blood when units = um", ".00000000000106", "real value > 0");
	args.add("hilbert", "activate hilbert curves connections", "0", "value 1 for enablement");
	args.add("stackres", "spacing between pixel samples in each dimension(in units/pixel)", "1 1 1", "real value > 0");
	args.add("stackdir", "set the directory of the output image stack", "", "any existing directory (ex. /home/name/network)");
	
	args.parse(argc, argv);								// parse the command line

	if (args["help"].is_set()) {
		advertise();
		std::exit(1);
	}

	// load network
	if (args["network"].is_set()) {						// load network from user 
		std::vector<std::string> tmp = stim::parser::split(args["network"].as_string(), '.');
		if ("obj" == tmp[1])
			flow.load_obj(args["network"].as_string());
		else if ("swc" == tmp[1])
			flow.load_swc(args["network"].as_string());
		else {
			std::cout << "Invalid file type" << std::endl;
			std::exit(1);
		}
	}
	get_background();

	// blood pressure in capillaries range from 15 - 35 torr
	// 1 torr = 133.3 Pa
	max_pressure = args["maxpress"].as_float();

	// normal blood viscosity range from 4 - 15 mPa·s(cP)
	// 1 Pa·s = 1 g / mm / s
	u = args["viscosity"].as_float();			// g / units / s

	// normally the blood density in capillaries: 1060 kg/m^3 = 1.06*10^-12 g/um^3
	rou = args["rou"].as_float();

	// check whether to enable hilbert curves or not
	hilbert_curve = args["hilbert"].as_int();

	// get the vexel and image stack size
	dx = args["stackres"].as_float(0);
	dy = args["stackres"].as_float(1);
	dz = args["stackres"].as_float(2);

	// get the save directory of image stack
	if (args["stackdir"].is_set())
		stackdir = args["stackdir"].as_string();

	// glut main loop
	bb = flow.boundingbox();
	glut_initialize();
	glutMainLoop();
}