/* 

intersect.cpp

Laura Toma

What it does:  

Draws a set of horizontal and vertical line segments in the default 2D
projection. Then it pretends to compute their intersections using the
line sweep algorithm, and simulates the sweep line moving from left to
right.

*/

#include "geom.h"
#include "rtimer.h"

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <unistd.h> //for usleep()


#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif



#include <vector> 
#include <algorithm> 

using namespace std; 



GLfloat red[3] = {1.0, 0.0, 0.0};
GLfloat green[3] = {0.0, 1.0, 0.0};
GLfloat blue[3] = {0.0, 0.0, 1.0};
GLfloat black[3] = {0.0, 0.0, 0.0};
GLfloat white[3] = {1.0, 1.0, 1.0};
GLfloat gray[3] = {0.5, 0.5, 0.5};
GLfloat yellow[3] = {1.0, 1.0, 0.0};
GLfloat magenta[3] = {1.0, 0.0, 1.0};
GLfloat cyan[3] = {0.0, 1.0, 1.0};





/* forward declarations of functions */
void display(void);
void keypress(unsigned char key, int x, int y);
void timerfunc(); 

void initialize_segments_random(); 
void initialize_segments_horizontal(); 
void print_segments(); 

//renders the sweep line 
void draw_sweep_line();

//renders the active structure
void draw_active_structure();

//renders the intersection points 
void draw_intersection_points();





/* global variables */
const int WINDOWSIZE = 500; 

//we got two test cases so far: random and horizontal; add more!
int init_case = 0; 
const int NB_TEST_CASES = 2; 

//NOTE: all the structures below need to be global so that they can be rendered

//number of segments requested by user. This is entered on the command
//line.
int n; 

//the array of  segments. Its size should match n 
vector<segment2D>  segments;

//the active structure that stores the segments intersecting the sweep line 
//this should be a BBST
vector<segment2D> as;

//the intersections points of the segments 
vector<point2D> intpoints; 


//current position of sweep line; this is used to animate the sweep line moving 
int sweep_line_x = 0; 


//event types 
const int START = 1; 
const int END = 2; 
const int VERT = 3; 

struct event {
  point2D p; //the point corresponding to the event
  int type;  //event type, START, END or VERT
  point2D op; // the other endpoint of the segment 

  bool operator<(const event& a) const
    {
      return ((p.x < a.p.x) || 
	      //START before VERTICAL
	      ((p.x == a.p.x) && (type == START) && (a.type == VERT)) || 
	      //VERTICAL before END
	      ((p.x == a.p.x) && (type == VERT) && (a.type == END)));
    }
}; 


vector<event> events; 

int current_event = 0; 



/* ************************************************** */
//fills global variable "segments" with n segments 
void initialize_segments() {

  switch (init_case)  {
      
    case 0: 
      initialize_segments_random(); 
      break;
      
    case 1: 
      initialize_segments_horizontal(); 
      break; 
      
    default: 
      initialize_segments_random(); 
    }

  init_case = (init_case+1) % NB_TEST_CASES;
  return; 
}




/* ************************************************** */
//fills global variable "segments" with a long horizontal segment and
//n-1 vertical segments
void initialize_segments_horizontal() {

  int i; 
  point2D a,b;
  segment2D s; 

  //clear the vector of segments 
  segments.clear(); 

  //a long horizontal segment 
  a.x = 1; 
  a.y = WINDOWSIZE/2; 
  b.x = WINDOWSIZE - 10; 
  b.y = a.y; 

  s.start = a; s.end = b; 
  segments.push_back(s);  

  //n-1 vertical segments 
  for (i=0; i<n-1; i++) {
    
    a.x = i*WINDOWSIZE/n; 
    a.y = WINDOWSIZE/2 - random() % ((int)(.4*WINDOWSIZE)); 
    b.x = a.x; 
    b.y = WINDOWSIZE/2 + random() % ((int)(.4*WINDOWSIZE)); 
    s.start = a; s.end = b; 
    segments.push_back(s); 
  }

}


/* ****************************** */
//fills global variable "segments" with n random segments, half horizontal and half vertical 
void initialize_segments_random() {
  
  //clear the vector 
  segments.clear(); 

  int i; 
  point2D a, b; 
  segment2D s; 
  for (i=0; i<n; i++) {
    if (random()%2 == 0) {
      //horizontal segment
      a.x = (int)(.3*WINDOWSIZE)/2 + random() % ((int)(.7*WINDOWSIZE)); 
      a.y =  (int)(.3*WINDOWSIZE)/2 + random() % ((int)(.7*WINDOWSIZE));
      b.y = a.y; 
      b.x = (int)(.3*WINDOWSIZE)/2 + random() % ((int)(.7*WINDOWSIZE)); 

      if (a.x < b.x) {
	s.start = a; s.end = b; 
      } else {
	s.start = b; s.end = a; 
      } 
 
    } else {
      //vertical segment 
      a.x = (int)(.3*WINDOWSIZE)/2 + random() % ((int)(.7*WINDOWSIZE)); 
      b.x = a.x; 
      a.y = (int)(.3*WINDOWSIZE)/2 + random() % ((int)(.7*WINDOWSIZE)); 
      b.y = (int)(.3*WINDOWSIZE)/2 + random() % ((int)(.7*WINDOWSIZE)); 

      if (a.y < b.y) {
	s.start = a; s.end = b; 
      } else {
	s.start = b; s.end = a; 
      }
    }

    //insert the segment in the array of segments 
    segments.push_back (s); 
  } //for i
}




/* ************************************************** */
void print_segments() {

  for (int i=0; i<segments.size(); i++) {
    printf("segment %d: [(%d,%d), (%d,%d)]\n",
	   i, segments[i].start.x, segments[i].start.y, 
	   segments[i].end.x, segments[i].end.y);

  }
}


/* ************************************************** */
void print_intpoints() {

  printf("\n\nintersection points: \n"); 
  for (int i=0; i<intpoints.size(); i++) {
    printf("%d: (%d,%d)\n",
	   i, intpoints[i].x, intpoints[i].y);
    
  }
}




//implemented as a linear search. NEEDS TO BE CHANGED TO WORK IN LG N + K TIME
void range_and_report(int x, int y1, int y2) {

  for (int i=0; i< as.size(); i++) {
    //if segment is in y range, report its intersection
    if ((as[i].start.y >= y1) && (as[i].start.y <= y2)) {
      point2D p; 
      p.x = x; 
      p.y = as[i].start.y; 
      intpoints.push_back (p); 
      printf("intersection point (%d,%d)\n", p.x, p.y); 
    }
  }
  
} 

/* ************************************************** */
void print_events(vector<event> ev) {

  for (int i=0; i<ev.size(); i++) {
    printf("event %d: %d (%d,%d) (other=(%d,%d))\n",
	   i, ev[i].type, ev[i].p.x, ev[i].p.y, 
	   ev[i].op.x, ev[i].op.y);

  }
}



/* ****************************** */
void initialize_events() {

  //create the events: endpoints of all segments 
  events.clear(); 
  struct event e; 
  for (int i=0; i< n; i++) {
    //if horizontal segment, insert both 
    if (segments[i].start.x != segments[i].end.x) {
      e.p = segments[i].start; 
      e.type = START; 
      e.op = segments[i].end;
      events.push_back(e); 

      e.p = segments[i].end; 
      e.type = END; 
      e.op = segments[i].start;
      events.push_back(e); 
    } else { 
      //vertical segment
      e.p = segments[i].start; 
      e.op = segments[i].end;
      e.type = VERT; 
      events.push_back(e); 
    }
  }
  // print_events(events); 

  //sort events 
  std::sort(events.begin(), events.end()); 
  //print_events(events); 
}



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

  //read number of points from user
  if (argc!=2) {
    printf("usage: viewPoints <nbPoints>\n");
    exit(1); 
  }
  n = atoi(argv[1]); 
  printf("you entered n=%d\n", n);
  assert(n >0); 

  //the default is to initialize the segments randomly 
  initialize_segments_random();
  //print_segments();
  initialize_events(); 
  
  //print the timing 
  //  char buf [1024]; 
  //rt_sprint(buf,rt1);
  //printf("run time:  %s\n\n", buf);
  //fflush(stdout); 

 
  

  /* initialize GLUT  */
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
  glutInitWindowSize(WINDOWSIZE, WINDOWSIZE);
  glutInitWindowPosition(100,100);
  glutCreateWindow(argv[0]);

  /* register callback functions */
  glutDisplayFunc(display); 
  glutKeyboardFunc(keypress);
  glutIdleFunc(timerfunc);  //<-------- we'll use it to animate

  /* init GL */
  /* set background color black*/
  glClearColor(0, 0, 0, 0);   

  
  /* give control to event handler */
  glutMainLoop();
  return 0;
}



/* ****************************** */
/* draw the segments stored in global variable segments
   NOTE: We draw in the local coordinate system (0,0) to (WINSIZE,WINSIZE)
*/
void draw_segments(){

  //set color 
  glColor3fv(yellow);   
  
  int i;
  for (i=0; i<segments.size(); i++) {
    glBegin(GL_LINES);
    glVertex2f(segments[i].start.x, segments[i].start.y); 
    glVertex2f(segments[i].end.x,   segments[i].end.y);
    glEnd();
  }
}


/* ****************************** */
/* 
   draw the sweep line
   NOTE: We draw in the local coordinate system (0,0) to (WINSIZE,WINSIZE)
*/
void draw_sweep_line() {
  
  //sweep line color 
  glColor3fv(red); 
  
  //the current position of sweep line is sweep_line_x; assume it's a
  //segment from y=0 to y=windowsize;
  glBegin(GL_LINES); 
  glVertex2f(sweep_line_x, 0); 
  glVertex2f(sweep_line_x, WINDOWSIZE); 
  glEnd();
}





/* draw all the elements in the active structure 
   NOTE: we draw in the local coordinate system [0,WINSIZE] x [0,WINSIZE]
*/
void draw_active_structure() {

  // printf("Boo!\n");  
   //set color 
  glColor3fv(magenta);   
  
  int i;
  for (i=0; i<as.size(); i++) {
    glBegin(GL_LINES);
    glVertex2f(as[i].start.x, as[i].start.y); 
    glVertex2f(as[i].end.x,   as[i].end.y);
    glEnd();
  }
}



/* draw all the elements in intpoints 
   NOTE: we draw in the local coordinate system [0,WINSIZE] x [0,WINSIZE]
*/
void draw_intersection_points() {

  //printf("Boo!\n"); 
  //set color 
  glColor3fv(blue);  
  //set line width to 3 so that the lines are thicker
  glLineWidth(3); 
  int i;
  for (i=0; i<intpoints.size(); i++) {
    glBegin(GL_LINES);
    glVertex2f(intpoints[i].x-2, intpoints[i].y-2); 
    glVertex2f(intpoints[i].x+2,   intpoints[i].y+2);
    glEnd();
  }
  //set line width back to 1
  glLineWidth(1); 
}




/* ****************************** */
void display(void) {

  //clear everything, start from scratch 
  glClear(GL_COLOR_BUFFER_BIT);
  glMatrixMode(GL_MODELVIEW); 
  glLoadIdentity(); 


  /* The default GL window is [-1,1]x[-1,1] with the origin in the center. 
     
     The points are in the range [0,WINSIZE] x [0,WINSIZE]. This is
     our local coordinate system.

     We first transform our local coordinate system to [-1,1] x [-1,1]
  */
  glScalef(2.0/WINDOWSIZE, 2.0/WINDOWSIZE, 1.0);  
  glTranslatef(-WINDOWSIZE/2, -WINDOWSIZE/2, 0); 


  //since we mapped our local coordinate system to the GL window, now
  //we can draw our scene in the local coordinate system [0,WINSIZE] x
  //[0,WINSIZE]
  draw_segments();
  draw_active_structure(); 
  draw_intersection_points(); 
  draw_sweep_line(); 



  /* execute the drawing commands */
  glFlush();
}



/* ****************************** */
void keypress(unsigned char key, int x, int y) {
  switch(key) {
  case 'q':
    exit(0);
    break;

  case 'i': 
    //clear global structures
    segments.clear(); 
    as.clear(); 
    intpoints.clear(); 
    
    //re-initialize 
    initialize_segments(); 
    initialize_events();
   
    glutPostRedisplay();
    break; 
  } 
}

/* ****************************** */
void timerfunc() {
  
 //if we reached the end, start over 
  if  (current_event >= events.size()) {
    current_event = 0; 
    intpoints.clear(); 
    as.clear(); 
  }
  
  //advance sweep line to next event 
  sweep_line_x =  events[current_event].p.x; 
  printf("sweepline at %d\n", sweep_line_x); 

  //process next event
  switch (events[current_event].type) {
  case START: 
    //insert segment in AS
    segment2D s; 
    s.start = events[current_event].p; 
    s.end = events[current_event].op; 
    as.push_back(s);
    printf("\tinsert segment [(%d,%d),(%d,%d)]\n", 
	   events[current_event].p.x, events[current_event].p.y, 
	   events[current_event].op.x, events[current_event].op.y);
    break; 
  case END:
    //delete segment from AS
    //to do 
    printf("\tdelete segment [(%d,%d),(%d,%d)]\n", 
	   events[current_event].p.x, events[current_event].p.y, 
	   events[current_event].op.x, events[current_event].op.y); 
      break; 
  case VERT: 
    //rangequery the AS and add intersections 
    range_and_report(events[current_event].p.x, events[current_event].p.y, 
		     events[current_event].op.y); 
    printf("\tvertical query segment [(%d,%d),(%d,%d)]\n", 
	   events[current_event].p.x, events[current_event].p.y, 
	   events[current_event].op.x, events[current_event].op.y); 
    break; 
  }
  
  current_event++; 
 
  glutPostRedisplay(); 
}




/* Handler for window re-size event. Called back when the window first appears and
   whenever the window is re-sized with its new width and height */
void reshape(GLsizei width, GLsizei height) {  // GLsizei for non-negative integer
     
   // Set the viewport to cover the new window
   glViewport(0, 0, width, height);
 
   glMatrixMode(GL_PROJECTION);  // To operate on the Projection matrix
   glLoadIdentity();             // Reset
   gluOrtho2D(0.0, (GLdouble) width, 0.0, (GLdouble) height); 
}