Rotate a NxN 2D matrix by 90 degrees – C Program Source Code

The below program does the following:

1. Creates a 2D matrix whose size can be input through Command Line arguments.
2. Prints the 2D Matrix.
3. Rotates the matrix by right angle (90 degrees) clockwise.

Source Code:

#include<stdio.h>
#include<stdlib.h>
#define DEFN 6

int** CreateMatrix(int**, int N);
void PrintMatrix(int**, int N);
int** RotateMatrix(int**,int N);

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

 int **matrix = NULL;
 int N;
 if(argc==2)
 N = atoi(argv[1]);
 else
 N = DEFN;
 matrix = CreateMatrix(matrix, N);
 printf("\nInitialMatrix:\n");
 PrintMatrix(matrix,N);
 printf("\n");
 matrix = RotateMatrix(matrix,N);
 printf("\nRotated Matrix:\n");
 PrintMatrix(matrix,N);

 char c = getchar();

 return(0);
}
int** CreateMatrix(int **matrix, int N)
{
 int i,j;
 matrix = (int**) calloc(N,sizeof(int*));
 for(i=0; i<N; i++)
 {
 *(matrix+i) = (int*) calloc(N, sizeof(int));
 for(j=0; j<N; j++)
 *(*(matrix+i)+j) = rand();
 }
 return(matrix);
}
void PrintMatrix(int **matrix, int N)
{
 int i,j;
 for(i=0; i<N; i++)
 {
 for(j=0; j<N; j++)
 printf("%6d ", *(*(matrix+i)+j));
 printf("\n");
 }
} 

int** RotateMatrix(int **matrix, int N)
{
 int i,temp,layer;

 for(layer=0; layer<(N/2); layer++)
 for(i=layer; i<N-layer-1; i++)
 {

 temp = *(*(matrix+N-i-1)+layer);
 *(*(matrix+N-i-1)+layer) = *(*(matrix+N-layer-1)+N-i-1);
 *(*(matrix+N-layer-1)+N-i-1) = *(*(matrix+i)+N-layer-1);
 *(*(matrix+i)+N-layer-1) = *(*(matrix+layer)+i);
 *(*(matrix+layer)+i) = temp;
 }
 return(matrix);
}

OUTPUT:

InitialMatrix:
 41 18467 6334 26500 19169 15724
11478 29358 26962 24464 5705 28145
23281 16827 9961 491 2995 11942
4827 5436 32391 14604 3902 153
292 12382 17421 18716 19718 19895
5447 21726 14771 11538 1869 19912
Rotated Matrix:
 5447 292 4827 23281 11478 41
21726 12382 5436 16827 29358 18467
14771 17421 32391 9961 26962 6334
11538 18716 14604 491 24464 26500
1869 19718 3902 2995 5705 19169
19912 19895 153 11942 28145 15724

Implement a queue with versions to fetch the contents at any version – C++ Program Source Code

The below program performs the following operations:

1. Implements a Queue with standard Enqueue and Dequeue operations to insert and retrieve an element respectively in First In First Out order. The data stored in this case are integers.
2. Implements a versioning system for the Queue to maintain a unique version number of the Queue at every Enqueue and Dequeue operations.
3. Retrieve the contents of the Queue at any given state with the version number.

#include <iostream>
#include <vector>

using namespace std;

void PrintArray(int*);

class The_Queue
{
    vector<int> value;
    vector<float> version_in;
    vector<float> version_out;
    int topIndex, bottomIndex;
    float current_version;

    int getStartIndex(float ver)
    {
        int index;
        for(index=0; index<=topIndex; index++)
        {
            if((version_out[index] > ver) || (version_out[index]==''))
            {
                return(index);
            }
        }
        return(topIndex+1);
    }

    int getEndIndex(float ver)
    {
        int index;
        for(index=0; index<=topIndex; index++)
        {
            if(version_in[index] > ver)
            {
                return(index);
            }
        }
        return(index-1);
    }

    public:
        The_Queue()
        {
            topIndex = -1;
            bottomIndex = 0;
            current_version = 0.9;
        }

        void Enqueue(int val)
        {
            current_version += 0.1;
            value.push_back(val);
            version_in.push_back(current_version);
            version_out.push_back('');
            topIndex++;
        }

        int Dequeue()
        {
            if(topIndex == bottomIndex-1)
            {
                return('');
            }
            else
            {
                current_version+=0.1;
                version_out[bottomIndex] = current_version;
                bottomIndex++;
                return(value[bottomIndex-1]);
            }
        }

        int* GetAtVersion(float ver)
        {
            int index, startIndex=0, endIndex=topIndex;
            int size;
            startIndex = getStartIndex(ver);
            endIndex = getEndIndex(ver);

            if(startIndex == (endIndex+1))
            {
                size = 0;
            }
            else
            {
                size = endIndex - startIndex + 1;
            }
            int *Result;
            Result = new int[size+1];
            for(index=startIndex; index<=endIndex; index++)
            {
                Result[index-startIndex] = value[index];
            }
            Result[index-startIndex] = '';
            return(Result);
        }

        float getCurrentVersion()
        {
            return(current_version);
        }

        void PrintAll()
        {
            int index;
            for(index=0; index<=topIndex; index++)
            {
                cout<<value[index]<<"  ";
            }
            cout<<endl;
        }

        void PrintAllIn()
        {
            int index;
            for(index=0; index<=topIndex; index++)
            {
                cout<<version_in[index]<<"  ";
            }
            cout<<endl;
        }

        void PrintAllOut()
        {
            int index;
            for(index=0; index<=topIndex; index++)
            {
                cout<<version_out[index]<<"  ";
            }
            cout<<endl;
        }
};

void PrintArray(int *arr)
{
     int i;
     for(i=0; arr[i]!=''; i++)
     {
         cout<<arr[i]<<"  ";
     }
     cout<<endl;
}

int main(void)
{
    The_Queue q = The_Queue();

    int option,val;
    float ver;
    int *Res;

    while(1)
    {
        cout<<"Enter option:"<<endl<<"1.Enqueue"<<endl<<"2.Dequeue"<<endl<<"3.Print at Version"<<endl<<"Q.Quit"<<endl;
        cin>>option;
        if(option == 1)
        {
             cout<<"Enter the value to Enqueue :"<<endl;
             cin>>val;
             q.Enqueue(val);
        }
        else if(option == 2)
        {
             val = q.Dequeue();
             if(val == '')
             {
                 cout<<"Cannot deque. Queue is empty"<<endl;
             }
             else
             {
                 cout<<"The Dequeued value was : "<<val<<endl;
             }

        }
        else if(option == 3)
        {
             cout<<"Enter the version number for getting the state of Queue :"<<endl;
             cin>>ver;
             if(ver<1.0)
             {
                 cout<<"No such version present."<<endl;
             }
             else
             {
                 if(ver > q.getCurrentVersion())
                 {
                     cout<<"No such version present.Returning results for latest version "<<q.getCurrentVersion()<<" instead."<<endl;
                 }
                 Res = q.GetAtVersion(ver);
                 PrintArray(Res);
             }
        }
        else
        {
            return 0;
        }

    }

    return(0);
}

INPUT / OUTPUT

Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
5
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
12
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
19
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
2
The Dequeued value was : 5
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
212
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
14
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
2
The Dequeued value was : 12
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
299
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
2
The Dequeued value was : 19
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
1000
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
2949
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
1
Enter the value to Enqueue :
789
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
2
The Dequeued value was : 212
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
2
The Dequeued value was : 14
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
2
The Dequeued value was : 299
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
3
Enter the version number for getting the state of Queue :
2.1
212  14  299  1000  2949  789
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
3
Enter the version number for getting the state of Queue :
1.5
12  19  212  14
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
3
Enter the version number for getting the state of Queue :
1.1
5  12  19
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit
3
Enter the version number for getting the state of Queue :
2.2
14  299  1000  2949  789
Enter option:
1.Enqueue
2.Dequeue
3.Print at Version
Q.Quit

Reverse Single Linked List – C Program Source Code

The below program performs the following:

1. Takes input of the size of the Linked List as Command Line argument.
2. Creates a Singly Linked List of input size (default: 20 members) filled with random numbers.
3. Prints the members of the Linked List.
4. Reverses the Linked List and prints it again.

Source Code:

#include<stdio.h>
#define NELEMENTS 20
struct node
{
 int value;
 struct node *next;
};
struct node* CreateLinkedList(int, struct node*);
void printList(struct node*);
struct node* Reverse(struct node*);
int main(int argc, char *argv[])
{
 struct node *head;
 int NofElements;
 if(argc == 2)
 NofElements = atoi(argv[1]);
 else
 NofElements = NELEMENTS;
 head = CreateLinkedList(NofElements, head);
 printList(head);
 head = Reverse(head);
 printList(head);

 char c;
 c = getchar();
 return(0);
}
struct node* CreateLinkedList(int NElements, struct node *head)
{ 
 struct node *temp = NULL;
 temp = (struct node*) malloc(sizeof(struct node));
 head = temp;

 for( ; NElements>0; NElements--, temp=temp->next)
 {
 temp->value = rand();
 temp->next = (struct node*) malloc(sizeof(struct node));

 }
 temp->value = '';
 temp->next = NULL;

 return(head);
}
void printList(struct node *head)
{
 struct node *temp;

 for(temp=head; (temp->value)!=''; temp=temp->next)
 printf("%8d", temp->value);
printf("\n");
}
struct node* Reverse(struct node *head)
{
 struct node *temp_prev, *temp, *temp_post;

 for(temp_prev=head,temp=head->next; (temp_prev->next)!=NULL && (temp->next)!= NULL; )
 {
 temp_post = temp->next;
 temp->next = temp_prev;
 temp_prev = temp;
 temp = temp_post;
 }
 head->next = temp;
 head = temp_prev;

 return(head);
}

Polygon Filling (Seedfill) using OpenGL – Program Source Code

#include <GL/glut.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int x1,Y1,x2,y2;
void seedfill(int,int,int,int);
void square(void);
void Axes(void);
void display(void)
 {
 glClear (GL_COLOR_BUFFER_BIT);
 glColor3f (1.0, 0.0, 0.0);
 glBegin(GL_POINTS);
 square();
 glEnd();
 glFlush();
 }
void square(void)
{
 seedfill(x1 , Y1 , 0 , 0);
 Axes();
} 
void seedfill(int x , int y , int flagx , int flagy)
{

 if(x<x2 && y<y2)
 {
 if(flagx==0 && flagy==0)
 {
 seedfill(x+1,y,1,0);
 seedfill(x,y+1,0,1);
 }
 if(flagx==1 && flagy ==0)
 {
 seedfill(x+1,y,1,0);
 seedfill(x,y+1,0,1);

 }
 if(flagx==0 && flagy ==1)
 {
 seedfill(x,y+1,0,1);
 }
 glVertex2s(x,y);
 } 
}

 void Axes(void)
{
 int i;
 glColor3f (1.0, 1.0, 1.0);
 for(i=-100 ; i<=100 ; i++)
 {
 glVertex2s(i,0);
 glVertex2s(0,i);
 }
 for(i=-2; i<=2 ; i++)
 {
 glVertex2s(95+i,4+i);
 glVertex2s(95-i,4+i);
 } 
 for(i=0; i<=2 ; i++)
 {
 glVertex2s(4+i,95+i);
 glVertex2s(4-i,95+i);
 glVertex2s(4,95-i);
 }
}
 void init(void)
 {
 glClearColor (0.0, 0.0, 0.0, 0.0);
 glOrtho(-100.0, 100.0, -100.0, 100.0, -1.0, 1.0);
 }
int main(int argc, char** argv)
{
 printf("Enter the bottom left co-ordinates of rectangle:\n");
 scanf("%d %d",&x1,&Y1);
 printf("Enter the top right co-ordinates of rectangle:\n");
 scanf("%d %d",&x2,&y2);
 glutInit(&argc, argv);
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
 glutInitWindowSize (500, 500);
 glutInitWindowPosition (100, 100);
 glutCreateWindow ("Square : Seed Fill Method ");
 init ();
 glutDisplayFunc(display);
 glutMainLoop(); 
 return 0;
}

OUTPUT:

2D Transformations using OpenGL – Program Source Code

The following Source code performs the following 2 dimensional transformations:

• Translations
• Scaling
• Rotation
• Shearing
• Reflection
• Composite Transformations

Source Code:

#include 
#include 
#include 
#include 

typedef float Matrix3x3 [3][3];
Matrix3x3 theMatrix;
int NEdges;
float ptsIni[20][2];
float ptsFin[20][2];
float refpt[2];
float RotAngle;
float TransDistX,TransDistY;
float ScaleX,ScaleY;
int choice,choiceRef,choiceShear;
float slope,yIntercept;
float shearValue;

void matrixSetIdentity(Matrix3x3 m)
// Initialises the matrix as Unit Matrix
{
   int i, j;
   for (i=0; i<3; i++)
   for (j=0; j<3; j++)
   m[i][j] = (i == j);
}

void matrixPreMultiply(Matrix3x3 a , Matrix3x3 b)
// Multiplies matrix a times b, putting result in b
{
   int i,j;
   Matrix3x3 tmp;
   for (i = 0; i < 3; i++)
     for (j = 0; j < 3; j++)
       tmp[i][j] = a[i][0]*b[0][j] + a[i][1]*b[1][j] + a[i][2]*b[2][j];
   for (i = 0; i < 3; i++)
     for (j = 0; j < 3; j++)
       theMatrix[i][j] = tmp[i][j];
}

void Translate(int tx, int ty)
{
   Matrix3x3 m;
   matrixSetIdentity(m);
   m[0][2] = tx;
   m[1][2] = ty;
   matrixPreMultiply(m, theMatrix);
}

void Scale(float sx , float sy)
{
   Matrix3x3 m;
   matrixSetIdentity(m);
   m[0][0] = sx;
   m[0][2] = (1 - sx)*refpt[0];
   m[1][1] = sy;
   m[1][2] = (1 - sy)*refpt[1];
   matrixPreMultiply(m , theMatrix);
}

void Rotate(float a)
{
   Matrix3x3 m;
   matrixSetIdentity(m);
   a = a*22/1260;
   m[0][0] = cos(a);
   m[0][1] = -sin(a) ;
   m[0][2] = refpt[0]*(1 - cos(a)) + refpt[1]*sin(a);
   m[1][0] = sin(a);
   m[1][1] = cos(a);
   m[1][2] = refpt[1]*(1 - cos(a)) - refpt[0]*sin(a);
   matrixPreMultiply(m , theMatrix);
}

void Reflect(int xy)
{
   Matrix3x3 m;
   matrixSetIdentity(m);
   if(xy == 2)
   m[1][1] = -1;
   if(xy == 3)
   m[0][0] = -1;
   matrixPreMultiply(m , theMatrix);
}

void Shear(int xy)
{
   Matrix3x3 m;
   matrixSetIdentity(m);
   if(xy == 1)
     m[0][1] = shearValue;
   if(xy == 2)
     m[1][0] = shearValue;
   matrixPreMultiply(m , theMatrix);
}void TransformPoints(void)
{
   int k;
   float tmp ;
   for (k = 0 ; k ");
  scanf("%d",&NEdges);
  printf("Enter %d Co-ordinate pairs \n",NEdges);
  int PlotCt;
  for(PlotCt=0 ; PlotCt");
  scanf("%d",&choice);
  switch(choice)
  {
    case 1:     printf("Enter reference point Co-ordinates:\n=>");
      scanf("%f %f",&refpt[0],&refpt[1]);
      printf("Enter Angle of Rotation\n=>");
      scanf("%f",&RotAngle);
      printf("Enter translation along X & Y\n=>");
      scanf("%f%f",&TransDistX , &TransDistY);
      printf("Enter Scaling ratios along X & Y\n=>");
      scanf("%f%f",&ScaleX , &ScaleY);
      break;
    case 2:     printf("Enter translation along X & Y\n=>");
      scanf("%f%f",&TransDistX , &TransDistY);
      break;
    case 3:     printf("Enter Angle of Rotation\n=>");
      scanf("%f",&RotAngle);
      printf("Enter reference point Co-ordinates:\n=>");
      scanf("%f %f",&refpt[0],&refpt[1]);
      break;
    case 4:     printf("Enter Scaling ratios along X & Y\n=>");
      scanf("%f%f",&ScaleX , &ScaleY);
      break;
    case 5:     printf("Enter your choice number for Reflection about:\n
                    1.Origin\n 2.X-axis\n 3.Y-axis\n 4.y = mx+c\n=>");
      scanf("%d",&choiceRef);
      if(choiceRef == 4)
      {
        printf("Enter m & c: \n=>");
        scanf("%f %f",&slope,&yIntercept);
      }
      break;      
    case 6:     printf("Enter your choice number to shear about:\n
                    1.x-axis\n 2.y-axis\n=>");
      scanf("%d",&choiceShear);
      printf("Enter shear value:\n=>");
      scanf("%f",&shearValue);
      break;
    default:    printf("Please enter a valid choice!!!\n");
      return 0;
  }
  glutDisplayFunc(display);
  glutMainLoop();
  return 0;
}

OUTPUT:

1 . Translation

INPUT :

4                                  // No. of vertices of Polygon
20      20                         //(x,y) Co-ordinates of Vertices
100     20
100     100
20      100
2                                  // Selected option 2 for Translation
-50      -140                      //  Translation along X & Y

OUTPUT :

2 . Rotation

INPUT :

4                                 // No. of vertices of Polygon
20      20                        // (x,y) Co-ordinates of Vertices
100     20
100     100
20      100
3                                 // Choice no. for Rotation
60                                // Angle of Rotation in Degrees
-50      -50                      // Reference point Co-ordinates

OUTPUT :

3 . Scaling

INPUT :

4                                  // No. of vertices of Polygon
20      20                         // (x,y) Co-ordinates of Vertices
100     20
100     100
20      100
4                                  // Choice no. for Scaling
0.5      0.5                       // Scaling factors along X & Y

OUTPUT :

4 . Reflection

About arbitrary line y=mx+c

INPUT :

4                                 // No. of vertices of Polygon
20      20                        // (x,y) Co-ordinates of Vertices
100     20
100     100
20      100
5                                 // Choice no. for Reflection
4                                 // Choice for Reflection about y=mx+c
1        -30                      //  m  &  c values

OUTPUT :

5 . Shearing

X-direction Shear

INPUT :

4                                  // No. of vertices of Polygon
20      20                         // (x,y) Co-ordinates of Vertices
100     20
100     100
20      100
6                                  // Choice no. for Shearing
1                                  // Choice no. for Shear about X axis
1.5                                // Shear Coefficient

OUTPUT :

6 . Composite Transformation

INPUT :

4                                   // No. of vertices of Polygon
20      20                          // (x,y) Co-ordinates of Vertices
100     20
100     100
20      100
1                                   // Choice no. for Comp. Transf.
-50     -50                         // Reference Point Co-ordinates
60                                  // Angle of Rotation in Degrees
-40      -80                        // Translation along X & Y
1.5      1.5                        // Scaling factors along X & Y

OUTPUT :

Polygon Filling (Scanline) using OpenGL – Program Source Code

#include <GL/glut.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int h,k,r;
void scanline(int,int);
void circle(void);
void Axes(void);
 void display(void)
 {
 glClear (GL_COLOR_BUFFER_BIT);
 glColor3f (1.0, 0.0, 0.0);
 glBegin(GL_POINTS);
 circle();
 glEnd();
 glFlush();
 }
 void scanline(int ax, int by)
{
 int varx;
 for(varx=h+ax ; varx>=(h-ax) ; varx--)
 glVertex2s(varx,by);
} 
void circle(void)
{
 double XEnd,J;
 int i,j; 
 XEnd=(r/1.414);
 for( i=0 ; i<=XEnd ; i++)
 { 
 J=sqrt(r*r - i*i);
 j=(int)(J);
 scanline(i, j);
 scanline(j, i);
 scanline(j,-i);
 scanline(i,-j);
 }
 Axes();
 glVertex3s(h,k,-25);
} 
 void Axes(void)
{
 int i;
 glColor3f (1.0, 1.0, 1.0);
 for(i=-100 ; i<=100 ; i++)
 {
 glVertex2s(i,0);
 glVertex2s(0,i);
 }
 for(i=-2; i<=2 ; i++)
 {
 glVertex2s(95+i,4+i);
 glVertex2s(95-i,4+i);
 } 
 for(i=0; i<=2 ; i++)
 {
 glVertex2s(4+i,95+i);
 glVertex2s(4-i,95+i);
 glVertex2s(4,95-i);
 }
}
 void init(void)
 {
 glClearColor (0.0, 0.0, 0.0, 0.0);
 glOrtho(-100.0, 100.0, -100.0, 100.0, -1.0, 1.0);
 }
int main(int argc, char** argv)
{
 glutInit(&argc, argv);
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
 glutInitWindowSize (500, 500);
 glutInitWindowPosition (100, 100);
 printf("Enter the center of circle:\n");
 scanf("%d %d",&h,&k);
 printf("Enter the radius:\n");
 scanf("%d",&r);
 glutCreateWindow ("Circle : Scanline Filling Method ");
 init ();
 glutDisplayFunc(display);
 glutMainLoop(); 
 return 0;
}

OUTPUT:

Ellipse Generation (Trigonometric) using OpenGL – Program Source Code

#include <GL/glut.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int h,k;
float a,b;

 void display(void)
 {
 double I,J,A;
 int i,j;
 float theta; 
 glClear (GL_COLOR_BUFFER_BIT);
 glColor3f (1.0, 0.0, 0.0);
 glBegin(GL_POINTS);
 glVertex2s(h,k);
 for( theta=0 ; theta<=90 ; theta++)
 { 
 A=theta*11/630;
 J=b*sin(A);
 I=a*cos(A);
 i=(int)(I);
 j=(int)(J);
 glVertex2s(h+i,k+j);
 glVertex2s(h-i,k+j);
 glVertex2s(h-i,k-j);
 glVertex2s(h+i,k-j);
 }
 glColor3f (1.0, 1.0, 1.0);
 for(int i=-100 ; i<=100 ; i++)
 {
 glVertex2s(i,0);
 glVertex2s(0,i);
 }
 for(int i=-2; i<=2 ; i++)
 {
 glVertex2s(95+i,4+i);
 glVertex2s(95-i,4+i);
 } 
 for(int i=0; i<=2 ; i++)
 {
 glVertex2s(4+i,95+i);
 glVertex2s(4-i,95+i);
 glVertex2s(4,95-i);
 }
 glEnd();
 glFlush();
 }
void init(void)
 {
 glClearColor (0.0, 0.0, 0.0, 0.0);
 glOrtho(-100.0, 100.0, -100.0, 100.0, -1.0, 1.0);
 }
int main(int argc, char** argv)
{
 printf("Enter the center of ellipse:\n");
 scanf("%d %d",&h,&k);
 printf("Enter the parameters a & b:\n");
 scanf("%f %f",&a,&b);
 glutInit(&argc, argv);
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
 glutInitWindowSize (500, 500);
 glutInitWindowPosition (100, 100);
 glutCreateWindow ("Ellipse : Trignometric Method ");
 init ();
 glutDisplayFunc(display);
 glutMainLoop();
 return 0;
}

Ellipse Generation (Polynomial) using OpenGL – Program Source Code

#include <GL/glut.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
int h,k;
float a,b;
 void display(void)
 {
 double I,J;
 int i,j;
 glClear (GL_COLOR_BUFFER_BIT);
 glColor3f (1.0, 0.0, 0.0);
 glBegin(GL_POINTS);
 glVertex2s(h,k);
 for( i=0 ; i<=a ; i+=1)
 { 
 J=sqrt(1 - (i*i)/(a*a))*b;
 j=(int)(J);
 glVertex2s(h+i,k+j);
 glVertex2s(h-i,k+j);
 glVertex2s(h-i,k-j);
 glVertex2s(h+i,k-j);
 }
 glColor3f (1.0, 1.0, 1.0);
 for(int i=-100 ; i<=100 ; i++)
 {
 glVertex2s(i,0);
 glVertex2s(0,i);
 }
 for(int i=-2; i<=2 ; i++)
 {
 glVertex2s(95+i,4+i);
 glVertex2s(95-i,4+i);
 } 
 for(int i=0; i<=2 ; i++)
 {
 glVertex2s(4+i,95+i);
 glVertex2s(4-i,95+i);
 glVertex2s(4,95-i);
 }
 glEnd();
 glFlush();
 }
void init(void)
 {
 glClearColor (0.0, 0.0, 0.0, 0.0);
 glOrtho(-100.0, 100.0, -100.0, 100.0, -1.0, 1.0);
 }
int main(int argc, char** argv)
{
 printf("Enter the center of ellipse:\n");
 scanf("%d %d",&h,&k);
 printf("Enter the parameters a & b:\n");
 scanf("%f %f",&a,&b);
 glutInit(&argc, argv);
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
 glutInitWindowSize (500, 500);
 glutInitWindowPosition (100, 100);
 glutCreateWindow ("Ellipse : Polynomial Method ");
 init ();
 glutDisplayFunc(display);
 glutMainLoop();
 return 0;
}

Dashed Line Generation (DDA) using OpenGL – Program Source Code

#include <GL/glut.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int x1,x2,y1,y2;
float gap;
void display(void)
 {
int DelX,DelY,Max;
 int n=0,Total=1,j=0;
 double Sigma=1,XIncr,YIncr,x,y,slope;
 double gapX,gapY;
 glClear (GL_COLOR_BUFFER_BIT);
 glColor3f (1.0, 0.0, 0.0);
 if(x2<x1 && y2<y1)
 {
 int var;
 var=x1; x1=x2; x2=var;
 var=y1; y1=y2; y2=var;
 }
 DelX = x2 - x1;
 DelY = y2 - y1; 
 Max = ((DelX > DelY) ? DelX:DelY); 

 for( n=0 ; Total<=Max ; n++)
 {
 Total=Total*2;
 }
 for( int i=n ; i>0 ; i--)
 {
 Sigma = Sigma/2;
 }
 XIncr = Sigma*DelX;
 YIncr = Sigma*DelY; 
 x=x1; y=y1;

 glBegin(GL_POINTS);
 glVertex2s(x1,y1);
 slope = DelY/DelX; 
 gapX = gap/sqrt(1+slope*slope);
 // gapX = gap/.5;
 while(x!=x2 || y!=y2)
 {
 x = x+XIncr;
 y = y+YIncr;
 j = x/gapX;

 if((j%2)==0)
 {
 glVertex2s(x,y);
 printf("%lf %lf\n ",x,y);
 }
 } 
 glColor3f (1.0, 1.0, 1.0);
 for(int i=-100 ; i<=100 ; i++)
 {
 glVertex2s(i,0);
 glVertex2s(0,i);
 } 
 for(int i=-2; i<=2 ; i++)
 {
 glVertex2s(95+i,4+i);
 glVertex2s(95-i,4+i);
 } 
 for(int i=0; i<=2 ; i++)
 {
 glVertex2s(4+i,95+i);
 glVertex2s(4-i,95+i);
 glVertex2s(4,95-i);
 } 
 glEnd();
 glFlush();
}
 void init(void) 
 {
 glClearColor (0.0, 0.0, 0.0, 0.0);
 glOrtho(-100.0, 100.0, -100.0, 100.0, -1.0, 1.0);
 }
int main(int argc, char **argv)
 { 
 printf("Enter Initial points:\n"); 
 scanf("%d%d", &x1 , & y1);
 printf("Enter Final points:\n");
 scanf("%d%d", &x2 , & y2);
 printf("Enter Gapping:\n");
 scanf("%f", &gap); 

 glutInit(&argc, argv);
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
 glutInitWindowSize (500, 500); 
 glutInitWindowPosition (100, 100);
 glutCreateWindow ("DDA");
 init ();
 glutDisplayFunc(display);
 glutMainLoop ();
 return 0;
 }

OUTPUT:

Line Generation (Bresenhams) using OpenGL – Program Source Code

#include<stdlib.h>
#include<GL/glut.h>
#include<math.h>
#include<stdio.h>
void init()
{
 glMatrixMode(GL_PROJECTION);
 gluOrtho2D(0.0,300.0,0.0,300.0);
 glClearColor(0.0,0.0,0.0,0.0);
}
void setpixel(int x,int y)
{
 glBegin(GL_POINTS);
 glVertex2i(x,y);
 glEnd();
 glFlush();
}
void lineBressenham(int xa,int ya,int xb,int yb)
{
 int x,y,xEnd,yEnd;
int dx=abs(xa-xb);
 int dy=abs(ya-yb);
int p=2*dy-dx;
 int twody=2*dy;
 int twodydx=2*(dy-dx);
float m=(float)(yb-ya)/(float)(xb-xa);
if((m>=0) && (m<=1))
 { 
 if(xa>xb)
 {
 x=xb;
 y=yb;
 xEnd=xa;
 }
 else
 {
 x=xa;
 y=ya;
 xEnd=xb;
 }

 setpixel(x,y);
while(x<xEnd)
 {
 x++;
 if(p<0)
 p+=twody;
 else
 {
 y++; 
 p+=twodydx;
 }

 setpixel(x,y);
 }
 }

 else if(m>1)
 {
 if(ya>yb)
 {
 x=xb;
 y=yb;
 yEnd=ya;
 }
 else
 {
 x=xa;
 y=ya;
 yEnd=yb;
 }

 setpixel(x,y);
while(y<yEnd)
 {
 y++;
 if(p<0)
 p+=2*dx;
 else
 {
 x++; 
 p+=2*(dx-dy);
 }

 setpixel(x,y);
 }
 }
else if(m<-1)
 {
 if(ya>yb)
 {
 x=xb;
 y=yb;
 yEnd=ya;
 }
 else
 {
 x=xa;
 y=ya;
 yEnd=yb;
 }

 setpixel(x,y);
while(y<yEnd)
 {
 y--;
 if(p<0)
 p+=2*dx;
 else
 {
 x++; 
 p+=2*(dx-dy);
 }

 setpixel(x,y);
 }
 }
else if((m>=-1) && (m<=0))
 {
 if(xa>xb)
 {
 x=xb;
 y=yb;
 xEnd=xa;
 }
 else
 {
 x=xa;
 y=ya;
 xEnd=xb;
 }

 setpixel(x,y);
while(x<xEnd)
 {
 x++;
 if(p<0)
 p+=twody;
 else
 {
 y--; 
 p+=twodydx;
 }

 setpixel(x,y);
 }
 }

}
void setdata()
{
 int xa,xb,ya,yb; 
 glClear(GL_COLOR_BUFFER_BIT);
 glColor3f(1.0,0.0,0.0);
 glPointSize(4.0);
 printf("Enter the points : ");
 scanf("%d %d %d %d",&xa,&ya,&xb,&yb);
 lineBressenham(xa,ya,xb,yb);
}
int main(int argc,char**argv)
{
 glutInit(&argc,argv);
 glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
 glutInitWindowSize(400,400);
 glutInitWindowPosition(0,0);
 glutCreateWindow("Bressenham Line Algorithm");
 init();
 glutDisplayFunc(setdata);
 glutMainLoop();
 return 0;
}

OUTPUT: