Beispiel #1
0
R_API void r_cons_canvas_line_square (RConsCanvas *c, int x, int y, int x2, int y2, RCanvasLineStyle *style) {
	int min_x = R_MIN (x, x2);
	int diff_x = R_ABS (x - x2);
	int diff_y = R_ABS (y - y2);

	apply_line_style (c, x, y, x2, y2, style, 1);

	// --
	// TODO: find if there's any collision in this line
	if (y2 - y > 1) {
		int hl = diff_y / 2 - 1;
		int hl2 = diff_y - hl;
		int w = diff_x == 0 ? 0 : diff_x + 1;
		int style = min_x == x ? APEX_DOT : DOT_APEX;
		draw_vertical_line (c, x, y + 1, hl);
		draw_vertical_line (c, x2, y + hl + 1, hl2);
		draw_horizontal_line (c, min_x, y + hl + 1, w, style);
	} else  {
		if (y2 == y) {
			draw_horizontal_line (c, min_x, y, diff_x + 1, DOT_DOT);
		} else {
			if (x != x2) {
				draw_horizontal_line (c, min_x, y, diff_x + 1, REV_APEX_APEX);
			}
			draw_vertical_line (c, x2, y2, diff_y);
		}
	}
	c->attr = Color_RESET;
}
Beispiel #2
0
R_API void r_cons_canvas_line_back_edge (RConsCanvas *c, int x, int y, int x2, int y2, RCanvasLineStyle *style, int ybendpoint1, int xbendpoint, int ybendpoint2, int isvert) {
	int min_x1 = R_MIN (x, xbendpoint);
	int min_x2 = R_MIN (x2, xbendpoint);

	int diff_x1 = R_ABS (x - xbendpoint);
	int diff_x2 = R_ABS (x2 - xbendpoint);

	int diff_y = R_ABS ((y + ybendpoint1 + 1) - (y2 - ybendpoint2- 1));

	int w1 = diff_x1 == 0 ? 0 : diff_x1 + 1;
	int w2 = diff_x2 == 0 ? 0 : diff_x2 + 1;

	apply_line_style (c, x, y, x2, y2, style, isvert);

	if (isvert) {
		draw_vertical_line (c, x, y + 1, ybendpoint1 + 1);
		draw_horizontal_line (c, min_x1, y + ybendpoint1 + 2, w1, REV_APEX_APEX);
		draw_vertical_line (c, xbendpoint, y2 - ybendpoint2 + 1, diff_y - 1);
		draw_horizontal_line (c, min_x2, y2 - ybendpoint2, w2, DOT_DOT);
		draw_vertical_line (c, x2, y2 - ybendpoint2 + 1, ybendpoint2);
	} else {
		int miny1 = R_MIN (y, xbendpoint);
		int miny2 = R_MIN (y2, xbendpoint);
		int diff_y1 = R_ABS (y - xbendpoint);
		int diff_y2 = R_ABS (y2 - xbendpoint);

		draw_horizontal_line (c, x + 1, y, 1 + ybendpoint1 + 1, xbendpoint > y ? NRM_DOT : NRM_APEX);
		draw_vertical_line (c, x + 1 + ybendpoint1 + 1, miny1 + 1, diff_y1 - 1);
		draw_horizontal_line (c, x2 - ybendpoint2, xbendpoint, (x + 1 + ybendpoint1 + 1) - (x2 - ybendpoint2) + 1, xbendpoint > y ? REV_APEX_APEX : DOT_DOT);
		draw_vertical_line (c, x2 - ybendpoint2, miny2 + 1, diff_y2 - 1);
		draw_horizontal_line (c, x2 - ybendpoint2, y2, ybendpoint2 + 1, xbendpoint > y ? DOT_NRM : REV_APEX_NRM);
	}
}
Beispiel #3
0
void
Canvas::fill_roundrect(uint8_t x, uint8_t y,
                       uint8_t width, uint8_t height,
                       uint8_t radius)
{
    int16_t dx = 0, dy = radius;
    int16_t p = 1 - radius;
    uint8_t diameter = 2 * radius;

    // Adjust the position and fill the inner rectangle
    x += radius;
    width -= diameter;
    fill_rect(x, y, width, height + 1);
    height -= diameter;
    y += radius;

    // Draw the outer rectangle and corners
    while (dx <= dy) {
        draw_vertical_line(x + dx + width, y - dy, dy + dy + height);
        draw_vertical_line(x - dx, y - dy, dy + dy + height);
        draw_vertical_line(x + dy + width, y - dx, dx + dx + height);
        draw_vertical_line(x - dy, y - dx, dx + dx + height);
        dx++;
        if (p < 0)
            p = p + (dx << 1) + 1;
        else {
            dy--;
            p = p + ((dx - dy) << 1) + 1;
        }
    }
}
Beispiel #4
0
void
Canvas::draw_rect(uint8_t x, uint8_t y, uint8_t width, uint8_t height)
{
    draw_horizontal_line(x, y, width);
    draw_vertical_line(x + width, y, height);
    draw_vertical_line(x, y, height);
    draw_horizontal_line(x, y + height, width);
}
Beispiel #5
0
R_API void r_cons_canvas_line_square_defined (RConsCanvas *c, int x, int y, int x2, int y2, RCanvasLineStyle *style, int bendpoint, int isvert) {
	int min_x = R_MIN (x, x2);
	int diff_x = R_ABS (x - x2);
	int diff_y = R_ABS (y - y2);
	int min_y = R_MIN (y, y2);

	apply_line_style (c, x, y, x2, y2, style, isvert);

	if (isvert) {
		if (x2 == x) {
			draw_vertical_line (c, x, y + 1, diff_y);
		} else if (y2 - y > 1) {
			int h1 = 1 + bendpoint;
			int h2 = diff_y - h1;
			int w = diff_x == 0 ? 0 : diff_x + 1;
			int style = min_x == x ? APEX_DOT : DOT_APEX;
			draw_vertical_line (c, x, y + 1, h1);
			draw_horizontal_line (c, min_x, y + bendpoint + 2, w, style);
			draw_vertical_line (c, x2, y + h1 + 1 + 1, h2);
		} else {
			//TODO: currently copy-pasted
			if (y2 == y) {
				draw_horizontal_line (c, min_x, y, diff_x + 1, DOT_DOT);
			} else {
				if (x != x2) {
					draw_horizontal_line (c, min_x, y, diff_x + 1, REV_APEX_APEX);
				}
				draw_vertical_line (c, x2, y2, diff_y-2);
			}
		}
	} else {
		if (y2 == y) {
			draw_horizontal_line (c, min_x + 1, y, diff_x, NRM_NRM);
		} else if (x2 - x > 1) {
			int w1 = 1 + bendpoint;
			int w2 = diff_x - w1;
			//int h = diff_x;// == 0 ? 0 : diff_x + 1;
			//int style = min_x == x ? APEX_DOT : DOT_APEX;
			//draw_vertical_line (c, x, y + 1, h1);
			draw_horizontal_line (c, x + 1, y, w1 + 1, y2 > y ? NRM_DOT : NRM_APEX);
			//draw_horizontal_line (c, min_x, y + bendpoint + 2, w, style);
			draw_vertical_line (c, x + 1 + w1, min_y + 1, diff_y - 1);
			//draw_vertical_line (c, x2, y + h1 + 1 + 1, h2);
			draw_horizontal_line (c, x + 1 + w1, y2, w2, y2 < y ? DOT_NRM : REV_APEX_NRM);
		}
	}
	c->attr = Color_RESET;
}
Beispiel #6
0
void
Canvas::draw_roundrect(uint8_t x, uint8_t y,
                       uint8_t width, uint8_t height,
                       uint8_t radius)
{
    uint8_t diameter = 2 * radius;
    int16_t f = 1 - radius;
    int16_t dx = 1;
    int16_t dy = -diameter;
    int8_t rx = 0;
    int8_t ry = radius;

    // Adjust position, width and height
    x += radius;
    y += radius;
    width -= diameter;
    height -= diameter;

    // Draw the boundary rectangle
    draw_horizontal_line(x, y - radius, width + 1);
    draw_vertical_line(x + width + radius, y, height + 1);
    draw_vertical_line(x - radius, y, height + 1);
    draw_horizontal_line(x, y + height + radius, width + 1);

    // Draw the round corners
    while (rx < ry) {
        if (f >= 0) {
            ry--;
            dy += 2;
            f += dy;
        }
        rx++;
        dx += 2;
        f += dx;
        draw_pixel(x + rx + width, y - ry);
        draw_pixel(x + ry + width, y - rx);
        draw_pixel(x + rx + width, y + ry + height);
        draw_pixel(x + ry + width, y + rx + height);
        draw_pixel(x - rx, y + ry + height);
        draw_pixel(x - ry, y + rx + height);
        draw_pixel(x - rx, y - ry);
        draw_pixel(x - ry, y - rx);
    }
}
Beispiel #7
0
void
Canvas::fill_circle(uint8_t x, uint8_t y, uint8_t radius)
{
    int16_t dx = 0, dy = radius;
    int16_t p = 1 - radius;

    while (dx <= dy) {
        draw_vertical_line(x + dx, y - dy, dy + dy);
        draw_vertical_line(x - dx, y - dy, dy + dy);
        draw_vertical_line(x + dy, y - dx, dx + dx);
        draw_vertical_line(x - dy, y - dx, dx + dx);
        dx++;
        if (p < 0)
            p = p + (dx << 1) + 1;
        else {
            dy--;
            p = p + ((dx - dy) << 1) + 1;
        }
    }
}
Beispiel #8
0
void bmp_image::draw_rectangle(int x_min, int y_min, int x_max, int y_max, rgba_color_t color) {
    if ( x_min > x_max ) {
        std::swap( x_min, x_max );
    }
    if ( y_min > y_max ) {
        std::swap( y_min, y_max );
    }
    for ( int col = x_min; col <= x_max; ++col ) {
        draw_vertical_line(col, y_min, y_max, color);
    }
}
Beispiel #9
0
int Leveler::draw() 
{	
	Stroke		(255, 128, 128, 0.5);
	StrokeWidth (2);

	draw_l_title		(  );
	draw_horizontal_tics(  );
	draw_vertical_line  (  );
	draw_x_label	 	(  );
	draw_y_label	 	(  );

	draw_marker(  );
}
/* The following function divides the GLCD display panel into
 * equal number of rows based on the first value passed and
 * equal number of columns based on the second value passed
 * as arguments.
 */
draw_grid(int x, int y)
{
	int horizontal_lines, vertical_lines;
	int i;
	horizontal_lines = GLCD_ROWS/x;
	for(i=0; i<(x+1); i++)
	{
		draw_horizontal_line(horizontal_lines*i);
	}
	vertical_lines = GLCD_COLUMNS/y;
	for(i=0; i<(x+1); i++)
	{
		draw_vertical_line(vertical_lines*i);
	}
}
Beispiel #11
0
int Leveler::draw() 
{	
	if (!Visible) return 0;
	
	Stroke		(255, 128, 128, 0.5);
	StrokeWidth (2); 
 
	draw_l_title		(  );
	draw_horizontal_tics(  );
	draw_vertical_line  (  );
	draw_x_label	 	(  );
	draw_y_label	 	(  );

	draw_marker			(  );
	return 1;	
}
Beispiel #12
0
void draw_grid(){
	int hpos;							//счётчик
	int ypos;							//счётчик


	int grid_height=(cell_height+1)*row_num+1;
	int grid_width=(cell_width+1)*col_num+1;

	for (ypos=0;ypos<grid_width;ypos++){
		if (ypos % (cell_width+1) == 0){
			draw_vertical_line(pimg,ypos, grid_height);
		}
	}

	for (hpos=0;hpos<grid_height;hpos++){
		if (hpos % (cell_height+1) == 0){			//+1 т.к. 1 пиксель между ячейками (граница)
			draw_horizontal_line(pimg,hpos, grid_width);
		}
	}
}
Beispiel #13
0
void			draw(t_env *e)
{
	e->x = 0;
	while (e->x < SCREEN_W)
	{
		draw_init(e);
		calculate_step_and_initial_side_dist(e);
		perform_dda(e);
		calculate_dist_projected(e);
		calculate_wall(e);
		if (e->textured_wall)
			texturing_calculations(e);
		else
			wall_color(e);
		draw_vertical_line(e);
		e->x++;
	}
	if (e->textured_wall && e->map.max_x > 25 && e->map.y > 25)
		draw_sprite(e);
}
Beispiel #14
0
void reset_terminal(void){
	clear_terminal();
	
	set_display_attribute(BAR_COLOUR);
	draw_horizontal_line(1,1,WIDTH);
	set_display_attribute(BAR_COLOUR);
	draw_vertical_line(40,1,HEIGHT);
	
	move_cursor(TITLE_X,TITLE_Y);
	printf_P(PSTR("FROGGER"));
	
	draw_lives();
	draw_score();
	draw_level();
	draw_time(16);
	display_scores();
	draw_status(0);
	draw_frog();
	
	set_display_attribute(8);
}
Beispiel #15
0
void bmp_image::draw_filled_circle(int x0, int y0, int radius, rgba_color_t color) {

    assert(radius >= 0);    

    //Midpoint circle algorithm

    //std::cout << x0 << ", " << y0 << ", " << radius << ", " << std::hex << color << std::endl;

    int f = 1 - radius;
    int ddF_x = 1;
    int ddF_y = -2 * radius;
    int x = 0;
    int y = radius;
 

    draw_horizontal_line(y0, x0 - radius, x0 + radius, color);
    draw_vertical_line(x0, y0 - radius, y0 + radius, color);
 
    while(x < y) {

        if(f >= 0)  {
            y--;
            ddF_y += 2;
            f += ddF_y;
        }

        x++;
        ddF_x += 2;
        f += ddF_x; 

        draw_horizontal_line(y0 + y, x0 - x, x0 + x, color);
        draw_horizontal_line(y0 - y, x0 - x, x0 + x, color);
        draw_horizontal_line(y0 + x, x0 - y, x0 + y, color);
        draw_horizontal_line(y0 - x, x0 - y, x0 + y, color);
    }    
}
Beispiel #16
0
void
Gradient::resize(float width, float height)
{
    float w;
    if(direction == LEFT_RIGHT)
        w = width;
    else if(direction == TOP_BOTTOM)
        w = height;
    else
        assert(false);
    
    float dr = ((float) to.r - (float) from.r) / w;
    float dg = ((float) to.g - (float) from.g) / w;
    float db = ((float) to.b - (float) from.b) / w;
    float da = ((float) to.a - (float) from.a) / w;

#if SDL_BYTEORDER == SDL_BIG_ENDIAN
    SDL_Surface* surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                                (int) width, (int) height,
                                                32, 0xff000000,
                                                0x00ff0000,
                                                0x0000ff00,
                                                0x000000ff);
#else
    SDL_Surface* surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                                (int) width, (int) height,
                                                32, 0x000000ff,
                                                0x0000ff00,
                                                0x00ff0000,
                                                0xff000000);
#endif
    if(surface == 0)
        throw std::runtime_error("Couldn't create SDL_Surface for gradient. "
                                 "(Out of memory?");

    float r = from.r;
    float g = from.g;
    float b = from.b;
    float a = from.a;
    if(direction == LEFT_RIGHT) {
        for(int x = 0; x < (int) width; ++x) {
            draw_vertical_line(surface, x, 0, (int) height,
                               lrintf(r), lrintf(g),
                               lrintf(b), lrintf(a));
            r += dr;
            g += dg;
            b += db;
            a += da;
        }
    } else {
        for(int y = 0; y < (int) height; ++y) {
            draw_horizontal_line(surface, 0, y, (int) width,
                                 lrintf(r), lrintf(g),
                                 lrintf(b), lrintf(a));
            r += dr;
            g += dg;
            b += db;
            a += da;
        }
    }

    texture.reset(texture_manager->create(surface));
    this->width = width;
    this->height = height;
}
Beispiel #17
0
void clip_n_draw_vertical_line(PPM_Image &I, const PPM_Color &c,
        const int x, const int y1, const int y2) {
    const int h {I.height() - 1};
    draw_vertical_line(I, c, x, std::min(std::max(0, y1), h),
            std::min(std::max(0, y2), h));
}
Beispiel #18
0
void Rectangle::doDraw(PPM_Image &I, const PPM_Color &c) const {
    const int x1 = p_.x(), x2 = x1 + w_, y1 = p_.y(), y2 = y1 + h_;
    const int w {I.width() - 1}, h {I.height() - 1};
    const int xmin {std::min(std::max(0, x1), w)};
    const int xmax {std::min(std::max(0, x2), w)};
    const int ymin {std::min(std::max(0, y1), h)};
    const int ymax {std::min(std::max(0, y2), h)};
    const uint clr {c.color()};

    /* drawing all sides: if the rectangle goes beyond the image size, then
     * drawing lines on the image border
     */
    //for (auto x = xmin; x <= xmax; ++x) {
    //    I[x][ymin] = clr;
    //    I[x][ymax] = clr;
    //}
    //for (auto y = ymin; y <= ymax; ++y) {
    //    I[xmin][y] = clr;
    //    I[xmax][y] = clr;
    //}

    // avoid drawing lines on the border
    if (y1 >= 0) {
        if (y2 < h)
            for (auto x = xmin; x <= xmax; ++x) {
                I[x][y1] = clr;
                I[x][y2] = clr;
            }
        else if (y1 <= h)
            draw_horizontal_line(I, c, xmin, xmax, y1);
        //for (auto x = xmin; x <= xmax; ++x)
        //    I[x][y1] = clr;
    } else if (y2 >= 0 && y2 < h)
        draw_horizontal_line(I, c, xmin, xmax, y2);
    //for (auto x = xmin; x <= xmax; ++x)
    //    I[x][y2] = clr;

    if (x1 >= 0) {
        if (x2 < w)
            for (auto y = ymin; y <= ymax; ++y) {
                I[x1][y] = clr;
                I[x2][y] = clr;
            }
        else if (x1 <= w)
            draw_vertical_line(I, c, x1, ymin, ymax);
        //for (auto y = ymin; y <= ymax; ++y)
        //    I[x1][y] = clr;
    } else if (x2 >= 0 && x2 < w)
        draw_vertical_line(I, c, x2, ymin, ymax);
    //for (auto y = ymin; y <= ymax; ++y)
    //    I[x2][y] = clr;

    // the code below is shorter than above, but, perhaps, less efficient
    //if (y1 >= 0 && y1 < h)
    //    draw_horizontal_line(I, c, xmin, xmax, y1);
    //if (y2 >= 0 && y2 < h)
    //    draw_horizontal_line(I, c, xmin, xmax, y2);
    //if (x1 >= 0 && x1 < w)
    //    draw_vertical_line(I, c, x1, ymin, ymax);
    //if (x2 >= 0 && x2 < w)
    //    draw_vertical_line(I, c, x2, ymin, ymax);
}
Beispiel #19
0
int main(int argv, char **argc) {
	robot_if_t ri;
	int major, minor, x_dist_diff, square_count, prev_square_area_1 = 0, prev_square_area_2 = 0;
	IplImage *image = NULL, *hsv = NULL, *threshold_1 = NULL, *threshold_2 = NULL, *final_threshold = NULL;
	squares_t *squares, *biggest_1, *biggest_2, , *pair_square_1, *pair_square_2, *sq_idx;
	bool same_square;
	bool hasPair = 0;
	
	square_count = 0;
	
	// Make sure we have a valid command line argument
	if(argv <= 1) {
		printf("Usage: robot_test <address of robot>\n");	
		exit(-1);
	}

	ri_api_version(&major, &minor);
	printf("Robot API Test: API Version v%i.%i\n", major, minor);

	// Setup the robot with the address passed in
	if(ri_setup(&ri, argc[1], 0)) {
		printf("Failed to setup the robot!\n");
		exit(-1);
	}

	// Setup the camera
	if(ri_cfg_camera(&ri, RI_CAMERA_DEFAULT_BRIGHTNESS, RI_CAMERA_DEFAULT_CONTRAST, 5, RI_CAMERA_RES_640, RI_CAMERA_QUALITY_LOW)) {
		printf("Failed to configure the camera!\n");
		exit(-1);
	}

	// Create a window to display the output
	//cvNamedWindow("Rovio Camera", CV_WINDOW_AUTOSIZE);
	cvNamedWindow("Biggest Square", CV_WINDOW_AUTOSIZE);
	cvNamedWindow("Thresholded", CV_WINDOW_AUTOSIZE);

	// Create an image to store the image from the camera
	image = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);

	// Create an image to store the HSV version in
	// We configured the camera for 640x480 above, so use that size here
	hsv = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 3);

	// And an image for each thresholded version
	threshold_1 = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 1);
	threshold_2 = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 1);
	final_threshold = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 1);

	// Move the head up to the middle position
	ri_move(&ri, RI_HEAD_MIDDLE, RI_FASTEST);
	
	// Action loop
	do {
		// Update the robot's sensor information
		if(ri_update(&ri) != RI_RESP_SUCCESS) {
			printf("Failed to update sensor information!\n");
			continue;
		}

		// Get the current camera image and display it
		if(ri_get_image(&ri, image) != RI_RESP_SUCCESS) {
			printf("Unable to capture an image!\n");
			continue;
		}
		//cvShowImage("Rovio Camera", image);

		// Convert the image from RGB to HSV
		cvCvtColor(image, hsv, CV_BGR2HSV);

		// Pick out the first range of pink color from the image
		cvInRangeS(hsv, RC_PINK_LOW_1, RC_PINK_HIGH_1, threshold_1);
		
		// Pick out the second range of pink color from the image
		cvInRangeS(hsv, RC_PINK_LOW_2, RC_PINK_HIGH_2, threshold_2);
		
		// compute the final threshold image by using cvOr
		cvOr(threshold_1, threshold_2, final_threshold, NULL);
		

		cvShowImage("Thresholded", final_threshold);
		
		// Find the squares in the image
		squares = ri_find_squares(final_threshold, RI_DEFAULT_SQUARE_SIZE);
		
		if( squares != NULL ) {
			printf("Sorting squares!\n");
			sort_squares(squares);
			printf("Sort Complete!\n");
			printAreas(squares);
			printf("Done printing");
		
			//find biggest pair (if it exists)
			sq_idx = squares;
			
			while(sq_idx != NULL){
				if(sq_idx->next == NULL) break;
				else if(isPair(sq_idx, sq_idx->next, 0.75)){
					hasPair = 1;
					break;
				}
				sq_idx = sq_idx->next;
			}
		
			printf("Pair ID complete!\n");
			
			if(hasPair){
				printf("Pair found.\n");
				//draw_green_X(sq_idx, image);
				//draw_green_X(sq_idx->next, image);
				biggest_1 = sq_idx;
				biggest_2 = sq_idx->next;
				
				
				
			}
			else {
				printf("Pair not found.  Marking largest.\n");
				draw_red_X(squares, image);
				
				//temporary:
				biggest_1 = squares;
				biggest_2 = squares;
			}
			hasPair = 0;
		}
		else {
			printf("No squares found.\n");
		}
		
		hasPair = 0;
		
		if(biggest_1 != NULL){
			draw_green_X(biggest_1, image);
			printf("Area 1 = %d", biggest_1->area);
		}
		
		//we only see the last pair of squares, go straight ahead until IR_Detect stops the robot
		if (square_count == 3){	
			ri_move(&ri, RI_MOVE_FORWARD, 1);
			if (ri_IR_Detected(&ri)) {
				square_count++;
				printf("Object detected, square_count = %d\n", square_count);
			}		
	
		}
		//once the robot is at the intersection, rotate right until it detects a pair of squares
		else if(square_count == 4){
			printf("Rotating\n");
			
			if (biggest_1 != NULL && biggest_2 != NULL && (biggest_1->area - biggest_2->area) < 500){
				square_count++;
				printf("New Path Found\n");
			}
			ri_move(&ri, RI_TURN_RIGHT, 7); 
			
		}
		else{
			/*
			 * 	If we only find a single usable largest square:
			 * 		if square is on left of screen, turn right, strafe right
			 * 		if square is on right of screen, turn left, strafe left
			 */	
			
			
			
			if(biggest_1 != NULL && biggest_2 != NULL ) {
				draw_red_X(biggest_2, image);
				printf("\tArea 2 = %d\n", biggest_2->area);
				
				//get the difference in distance between the two biggest squares and the center vertical line
				x_dist_diff = get_square_diffence(biggest_1, biggest_2, image);
				get_diff_in_y(biggest_1, biggest_2);
				
				//when the camera can't detect a pair of squares, which means now the second biggest square
				//is much smaller than the first biggest square
				if ((biggest_1->area - biggest_2->area) > 500){
					//if both squares are at the left side of the center line
					if (biggest_1->center.x < image->width/2 && biggest_2->center.x < image->width/2){
						printf("rotate right at speed = 6\n");
						ri_move(&ri, RI_TURN_RIGHT, 6); 
					}
					//if both squares are at the right side of the center line
					else if (biggest_1->center.x > image->width/2 && biggest_2->center.x > image->width/2){
						printf("rotate left at speed = 6\n");
						ri_move(&ri, RI_TURN_LEFT, 6); 
					}
					//if the center line is in the middle of the two biggest squares
					else if (biggest_1->center.x < image->width/2 && biggest_2->center.x > image->width/2 ){
						printf("rotate right at speed = 2\n");
						ri_move(&ri, RI_TURN_RIGHT, 2); 
						
					}
					else{
						printf("rotate left at speed = 2\n");
						ri_move(&ri, RI_TURN_LEFT, 2); 
					}
					
				}
				else{
					//increment square_count whenever the robot pass by a pair of squares
					if (prev_square_area_1 != 0 && prev_square_area_2 != 0 && 
						biggest_1->area < prev_square_area_1  && biggest_2->area < prev_square_area_2 ){
						square_count++;
						printf("square count = %d\n", square_count);
					}
					//rotate to the left
					if (x_dist_diff < -40){
						printf("rotate left at speed = 6\n");
						ri_move(&ri, RI_TURN_LEFT, 6); 
					}
					//rotate to the right
					else if (x_dist_diff > 40){
						printf("rotate right at speed = 6\n");
						ri_move(&ri, RI_TURN_RIGHT, 6);
					}
					prev_square_area_1 = biggest_1->area;
					prev_square_area_2 = biggest_2->area;
					
				}
				ri_move(&ri, RI_MOVE_FORWARD, 5);
			}
			//once the camera can't detect any squares, make the robot go backwards
			else if (biggest_1 == NULL && biggest_2 == NULL){
				printf("Move Backwards\n");
				ri_move(&ri, RI_MOVE_BACKWARD , 1); 
			}
		}

		// display a straight vertical line
		draw_vertical_line(image);
		
		// Display the image with the drawing oon ito
		cvShowImage("Biggest Square", image);
		
		// Update the UI (10ms wait)
		cvWaitKey(10);
	
		// Release the square data
		while(squares != NULL) {
			
			sq_idx = squares->next;
			free(squares);
			squares = sq_idx;	
		}
		biggest_1 = NULL;
		biggest_2 = NULL;

		// Move forward unless there's something in front of the robot
		/*if(!ri_IR_Detected(&ri))
			ri_move(&ri, RI_MOVE_FORWARD, RI_SLOWEST);*/
		//printf("Loop Complete\n");
		//getc(stdin);
	} while(1);

	// Clean up (although we'll never get here...)
	//cvDestroyWindow("Rovio Camera");
	cvDestroyWindow("Biggest Square");
	cvDestroyWindow("Thresholded");
	
	// Free the images
	cvReleaseImage(&threshold_1);
	cvReleaseImage(&threshold_2);
	cvReleaseImage(&final_threshold);
	cvReleaseImage(&hsv);
	cvReleaseImage(&image);

	return 0;
}