Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
2 views

C Program to Color the Different Figures Drawn on the Console Using OpenGL

Uploaded by

Joseph
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

C Program to Color the Different Figures Drawn on the Console Using OpenGL

Uploaded by

Joseph
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

C program to color the different figures drawn on

the console using OpenGL


Approach:
 In this article, in order to fill the figures with colors, different algorithms are
used, so the filling can be done in the optimized pattern.
 Here, the flood fill and boundary fill algorithm with the implementation in
the C++ program with the concept of sub-windows will be used.
 The mouse() function is used in the program. After running the program, use the
left click to draw the image and then right-click to fill the image.
Below is the C++ program illustrating the use of OpenGL:
C++

// C++ program to illustrate the use


// of OpenGL

#include <GL/glut.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#define xpix 500
#include <cstring>
using namespace std;

// Global variable declaration


float r, g, b, x, y;
bool flag = true;
int x2, y2, x3, y3, x4, y4, x5, y5;
int a1, b1;
int a2, b2;
int a3, b3;
int a4, b4;
int counter = 1;
char buffer[20];

// Function to draw text


void drawBitmapText(
char* string, float x,
float y, float z)
{
char* c;
glRasterPos2f(x, y);
// Traverse the given string
for (c = string; *c != '\0'; c++) {

// Initialize gluBitmap
glutBitmapCharacter(
GLUT_BITMAP_TIMES_ROMAN_24, *c);
}
}

// Function for performing the delay


void delay(float ms)
{

clock_t goal = ms + clock();

// Iterate until goal is greater


// than the clock
while (goal > clock())
;
}

// Function to initialize the figure


void init()
{
glClearColor(1.0, 1.0, 1.0, 0.0);
glColor3f(0.0, 0.0, 0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, 800, 0, 600);
}

// Function to fill the color in the


// figure
void bound_it(int x, int y,
float* fillColor,
float* bc)
{
float color[3];

// Initialize to read the pixels


glReadPixels(x, y, 1.0, 1.0,
GL_RGB, GL_FLOAT, color);

if ((color[0] != bc[0]
|| color[1] != bc[1]
|| color[2] != bc[2])
&& (color[0] != fillColor[0]
|| color[1] != fillColor[1]
|| color[2] != fillColor[2])) {

// Fill the Color


glColor3f(fillColor[0],
fillColor[1],
fillColor[2]);

// Begin the GL Points


glBegin(GL_POINTS);

// Initialize the vertex


glVertex2i(x, y);
glEnd();
glFlush();

// Fill the color


bound_it(x + 1, y, fillColor, bc);
bound_it(x - 2, y, fillColor, bc);
bound_it(x, y + 2, fillColor, bc);
bound_it(x, y - 2, fillColor, bc);
}
}

// Function to fill the figure using


// the mouse click operation
void mouseboundaryfill(int btn, int state,
int x, int y)
{
// Boundary fill algorithm
y = 600 - y;

// If the right button is clicked


if (btn == GLUT_RIGHT_BUTTON) {
if (state == GLUT_DOWN) {

float bCol[] = { 1, 0, 0 };
float color[] = { 0, 1, 1 };
bound_it(x, y, color, bCol);
}
}

// If the left button is clicked


if (btn == GLUT_LEFT_BUTTON) {

if (state == GLUT_DOWN) {
if (counter == 1) {
a1 = x;
b1 = y;
counter++;
}
else if (counter == 2) {

a2 = x;
b2 = y;
counter++;
}
else if (counter == 3) {
a3 = x;
b3 = y;
counter++;
}
else if (counter == 4) {
a4 = x;
b4 = y;
counter = 0;
}
}
}
}

// Function to implement the world()


void world()
{
glLineWidth(3);
glPointSize(2);
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1, 0, 0);
glBegin(GL_LINE_LOOP);

// Initialize a vertices
glVertex2f(a1, b1);
glVertex2f(a2, b2);
glVertex2f(a3, b3);
glVertex2f(a4, b4);
glEnd();

// Fill the color


glColor3f(0, 0, 0);
glFlush();
}

// Function to initialize the figure


void init2()
{
glClearColor(1.0, 1.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
gluOrtho2D(0, 400, 0, 600);
}

// Structure for Points


struct Point {
GLint x;
GLint y;
};

// Structure for Colors


struct Color {
GLfloat r;
GLfloat g;
GLfloat b;
};

// Structure for getting the Pixels


Color getPixelColor(GLint x, GLint y)
{
Color color;
glReadPixels(x, y, 1, 1,
GL_RGB,
GL_FLOAT,
&color);
return color;
}

// Function for setting the pixel color


void setPixelColor(GLint x, GLint y,
Color color)
{
// Fill the Color
glColor3f(color.r, color.g, color.b);

// Begin the GL Points


glBegin(GL_POINTS);

// Initialize the vertex


glVertex2i(x, y);
glEnd();
glFlush();
}

// Function to fill the figure using


// floodfill function
void floodFill(GLint x, GLint y,
Color oldColor,
Color newColor)
{
// Flood fill algorithm
Color color;
color = getPixelColor(x, y);

if (color.r == oldColor.r
&& color.g == oldColor.g
&& color.b == oldColor.b) {
setPixelColor(x, y, newColor);

// Fill the color


floodFill(x + 1, y, oldColor,
newColor);
floodFill(x, y + 1, oldColor,
newColor);
floodFill(x - 1, y, oldColor,
newColor);
floodFill(x, y - 1, oldColor,
newColor);
}
return;
}

// Function to fill the color using


// mouse click operation
void mousefloodfill(int button, int state,
int x, int y)
{
// Left Click
if (button == GLUT_LEFT_BUTTON
&& state == GLUT_DOWN) {
flag = true;
x2 = x;
y2 = 600 - y;
}
// Right Click
else if (button == GLUT_RIGHT_BUTTON
&& state == GLUT_DOWN) {

Color newColor = { 0.0f, 0.0f, 1.0f };


Color oldColor = { 1.0f, 1.0f, 1.0f };

// Fill the color


floodFill(x2, y2, oldColor, newColor);
}
glutPostRedisplay();
}

// Function to draw the circle on


// the plane
void draw_circle(Point pC,
GLfloat radius)
{
if (flag) {
GLfloat step = 1 / radius;
GLfloat x, y;

for (GLfloat theta = 0; theta <= 360;


theta += step) {
x = pC.x + (radius * cos(theta));
y = pC.y + (radius * sin(theta));
glVertex2i(x, y);
}
}
}

// Function to display the figure


void display(void)
{
Point pt = { x2, y2 };
GLfloat radius = 70;

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POINTS);
draw_circle(pt, radius);
glEnd();

glFlush();
}

// Driver Code
int main(int argc, char** argv)
{
glutInit(&argc, argv);

// Function calls
glutInitDisplayMode(
GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(800, 600);
glutInitWindowPosition(100, 100);

int mainWindow
= glutCreateWindow(
"<-- Boundary Fill on left || "
"Flood fill on Right -->");

init();
glutDisplayFunc(display);
glutMouseFunc(mousefloodfill);

int subWindow1
= glutCreateSubWindow(
mainWindow, 0, 0, 400, 600);

glutInitWindowPosition(100, 100);
glutDisplayFunc(world);
glutMouseFunc(mouseboundaryfill);
init2();

glutMainLoop();

return 0;
}

You might also like