segmentation / netmets

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

  //OpenGL includes
  #include <GL/glut.h>
  
  //STIM includes
  #include <stim/visualization/gl_network.h>
  #include <stim/visualization/gl_aabb.h>
  #include <stim/parser/arguments.h>
  #include <stim/visualization/camera.h>
  
  //ANN includes

  #include <ANN/ANN.h>

  
  //BOOST includes

  #include <boost/tuple/tuple.hpp>

  stim::gl_aabb<float> bb;
  stim::camera cam;
  
  stim::gl_network<float> GT;
  stim::gl_network<float> T;
  
  //hard-coded parameters
  float resample_rate = 0.5;
  
  //mouse position tracking
  int mouse_x;
  int mouse_y;
  
  void glut_render(void) {
  
  	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  
  	glMatrixMode(GL_MODELVIEW);
  	glLoadIdentity();
  	stim::vec<float> eye = cam.getPosition();
  	stim::vec<float> focus = cam.getLookAt();
  	stim::vec<float> up = cam.getUp();
  
  	gluLookAt(eye[0], eye[1], eye[2], focus[0], focus[1], focus[2], up[0], up[1], up[2]);
  
  	
  
  	// render the bounding box
  	glColor3f(0.0, 0.0, 1.0);
  	glBegin(GL_LINE_LOOP);
  		bb.glPointsCW();
  	glEnd();
  
  	//render the GT network (red)
  	glColor3f(1.0, 0.0, 0.0);
  	GT.glCenterline();
  
  	//render the T network (green)
  	glColor3f(0.0, 1.0, 0.0);
  	T.glCenterline();
  
  	glutSwapBuffers();
  }
  
  // defines camera motion based on mouse dragging
  void glut_motion(int x, int y){
  	float factor = 0.01;
  
  	float theta = factor * (mouse_x - x);
  	float phi = factor * (y - mouse_y);
  
  	cam.OrbitFocus(theta, phi);
  
  	mouse_x = x;
  	mouse_y = y;
  
  	glutPostRedisplay();
  }
  
  // sets the mouse position when clicked
  void glut_mouse(int button, int state, int x, int y){
  	mouse_x = x;
  	mouse_y = y;
  }
  
  // re-calculates the projection matrix if the window is reshaped
  void glut_reshape(int x, int y){
  
  	glMatrixMode(GL_PROJECTION);
  	glLoadIdentity();
  	glViewport(0, 0, x, y);
  	float aspect = (float)x / (float)y;
  	gluPerspective(60, aspect, 0.1, 1000000);
  
  }
  
  void advertise(){
  	//output advertisement
  	std::cout<<std::endl<<std::endl;
  	std::cout<<"========================================================================="<<std::endl;
  	std::cout<<"Thank you for using the NetMets network comparison tool!"<<std::endl;
  	std::cout<<"Scalable Tissue Imaging and Modeling (STIM) Lab, University of Houston"<<std::endl;
  	std::cout<<"Developers: Pranathi Vemuri, David Mayerich"<<std::endl;
  	std::cout<<"Source: https://git.stim.ee.uh.edu/segmentation/netmets"<<std::endl;
  	std::cout<<"========================================================================="<<std::endl<<std::endl;
  
  	std::cout<<"usage: netmets file1 file2 --sigma 10"<<std::endl;
  	std::cout<<"            compare two files with a tolerance of 10 (units defined by the network)"<<std::endl;
  	std::cout<<"       netmets file1 --gui"<<std::endl<<std::endl;
  	std::cout<<"            load a file and display it using OpenGL"<<std::endl;
  
  }
  
  void compare(float sigma){
  
  	// compare ground truth with truth and viceversa
  	stim::network<float> cGT = GT.compare(T, sigma);
      stim::network<float> cT = T.compare(GT, sigma);
  
  	//calculate the metrics
  	float FPR = cGT.average(1);
  	float FNR = cT.average(1);
  	// print false alarms and misses
  	std::cout << "FNR: " << FPR << std::endl;
  	std::cout << "FPR: " << FNR << std::endl;
  }
  
  void glut_initialize(){
  	float factor = 1.2;
  
  	// init GLUT and create Window
  	int myargc = 1;
  	char* myargv[1];
  	myargv [0]=strdup ("netmets");
  
  	glutInit(&myargc, myargv);
  	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
  	glutInitWindowPosition(100,100);
  	glutInitWindowSize(320,320);
  	glutCreateWindow("Lighthouse3D- GLUT Tutorial");
  
  	
  	// register callbacks
  	glutDisplayFunc(glut_render);
  	glutMouseFunc(glut_mouse);
  	glutMotionFunc(glut_motion);
  	glutReshapeFunc(glut_reshape);
  
  	//set up the camera
  	stim::vec<float> c = bb.center();
  	//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, factor * std::max(bb.size()[0], bb.size()[1])));
  	cam.LookAt(c[0], c[1], c[2]);						//look at the center
  
  }
  
  void display(){
  
  
  	//generate a bounding volume
  	bb = GT.boundingbox();
  
  	std::cout<<bb.str()<<std::endl;
  
  	std::cout<<"center: "<<bb.center().str()<<std::endl;
  	std::cout<<"size:   "<<bb.size().str()<<std::endl;
  
  	//create the GLUT window and set callback functions
  	glut_initialize();
  
  	glut_reshape(glutGet(GLUT_WINDOW_WIDTH), glutGet(GLUT_WINDOW_HEIGHT));
  
  	std::cout<<cam.str()<<std::endl;
  
  	// enter GLUT event processing cycle
  	glutMainLoop();
  }

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

  	//create an instance of arglist
  	stim::arglist args;
  
  	//add arguments
  	args.add("help", "prints this help");
  	args.add("sigma", "force a sigma value to specify the tolerance of the network comparison", "10");
  	args.add("gui", "display the network or network comparison using OpenGL");
  
  	//parse the user arguments
  	args.parse(argc, argv);
  
  	//test for help
  	if(args["help"].is_set() || args.nargs() == 0){
  		advertise();
  		std::cout<<args.str();

  		exit(1);
  	}
  

  	//if one file is specified, load it as the ground truth
  	if(args.nargs() >= 1){
  		GT.load_obj(args.arg(0));
  	}

  	//if two files are provided, compare them
  	if(args.nargs() == 2){
  		float sigma = args["sigma"].as_float();				//get the sigma value from the user
  		T.load_obj(args.arg(1));							//load the second (test) network

  		GT = GT.resample(resample_rate * sigma);			//resample both networks based on the sigma value
  		T = T.resample(resample_rate * sigma);

  		compare(sigma);										//run the comparison algorithm
  	}

  	//if a GUI is requested, display the network using OpenGL
  	if(args["gui"].is_set())
  		display();
  	
  
  	

  }