C++ Programming Blog

 
 
 
 # include <iostream.h>
 # include <graphics.h>
 # include    <conio.h>
 # include     <math.h>

 void show_screen( );

 void apply_reflection_about_line_yex(const int,int []);
 void apply_reflection_about_line_yemx(const int,int []);
 void apply_reflection_along_x_axis(const int,int []);
 void apply_reflection_along_y_axis(const int,int []);
 void apply_rotation(const int,int [],float);
 void multiply_matrices(const float[3],const float[3][3],float[3]);

 void Polygon(const int,const int []);
 void Line(const int,const int,const int,const int);
 void Dashed_line(const int,const int,const int,const int,const int=0);


 int main( )
    {
       int driver=VGA;
       int mode=VGAHI;

       initgraph(&driver,&mode,\"..\\\\Bgi\");

       show_screen( );

       setcolor(15);
      Line(320,100,320,400);

      Line(315,105,320,100);
      Line(320,100,325,105);

      Line(315,395,320,400);
      Line(320,400,325,395);

      Line(150,240,500,240);

      Line(150,240,155,235);
      Line(150,240,155,245);

      Line(500,240,495,235);
      Line(500,240,495,245);

      Dashed_line(160,400,460,100,0);
      Dashed_line(180,100,480,400,0);

       settextstyle(2,0,4);
     outtextxy(305,85,\"y-axis\");
     outtextxy(305,402,\"y\'-axis\");

     outtextxy(505,233,\"x-axis\");
     outtextxy(105,233,\"x\'-axis\");

     outtextxy(350,100,\"Reflection about the line y=x\");
     outtextxy(115,100,\"Reflection about the line y=-x\");

       int x_polygon[8]={ 340,200, 420,120, 370,120, 340,200 };
       int y_polygon[8]={ 300,200, 220,120, 270,120, 300,200 };

       setcolor(15);
     Polygon(4,x_polygon);
     Polygon(4,y_polygon);

       apply_reflection_about_line_yex(4,x_polygon);
       apply_reflection_about_line_yemx(4,y_polygon);

       setcolor(7);
     Polygon(4,x_polygon);
     Polygon(4,y_polygon);

       getch( );
       return 0;
    }


 //----------------  apply_reflection_about_line_yex( )  -----------------//


 void apply_reflection_about_line_yex(const int n,int coordinates[])
    {
       apply_rotation(n,coordinates,45);
       apply_reflection_along_x_axis(n,coordinates);
       apply_rotation(n,coordinates,-45);
    }


 //---------------  apply_reflection_about_line_yemx( )  -----------------//


 void apply_reflection_about_line_yemx(const int n,int coordinates[])
    {
       apply_rotation(n,coordinates,45);
       apply_reflection_along_y_axis(n,coordinates);
       apply_rotation(n,coordinates,-45);
    }


 //-------------------------  apply_rotation( )  -------------------------//


 void apply_rotation(const int n,int coordinates[],float angle)
    {
       float xr=320;
       float yr=240;

       angle*=(M_PI/180);

       for(int count_1=0;count_1<n;count_1++)
      {
         float matrix_a[3]={coordinates[(count_1*2)],
                         coordinates[((count_1*2)+1)],1};

         float temp_1=(((1-cos(angle))*xr)+(yr*sin(angle)));
         float temp_2=(((1-cos(angle))*yr)-(xr*sin(angle)));

         float matrix_b[3][3]={ { cos(angle),sin(angle),0 } ,
                    { -sin(angle),cos(angle),0 } ,
                        { temp_1,temp_2,1 } };
         float matrix_c[3]={0};

         multiply_matrices(matrix_a,matrix_b,matrix_c);

         coordinates[(count_1*2)]=(int)(matrix_c[0]+0.5);
         coordinates[((count_1*2)+1)]=(int)(matrix_c[1]+0.5);
      }
    }


 //------------------  apply_reflection_along_x_axis( )  -----------------//


 void apply_reflection_along_x_axis(const int n,int coordinates[])
    {
       for(int count=0;count<n;count++)
      {
         float matrix_a[3]={coordinates[(count*2)],
                         coordinates[((count*2)+1)],1};
         float matrix_b[3][3]={ {1,0,0} , {0,-1,0} ,{ 0,0,1} };
         float matrix_c[3]={0};

         multiply_matrices(matrix_a,matrix_b,matrix_c);

         coordinates[(count*2)]=matrix_c[0];
         coordinates[((count*2)+1)]=(480+matrix_c[1]);
      }
    }


 //------------------  apply_reflection_along_y_axis( )  -----------------//


 void apply_reflection_along_y_axis(const int n,int coordinates[])
    {
       for(int count=0;count<n;count++)
      {
         float matrix_a[3]={coordinates[(count*2)],
                         coordinates[((count*2)+1)],1};
         float matrix_b[3][3]={ {-1,0,0} , {0,1,0} ,{ 0,0,1} };
         float matrix_c[3]={0};

         multiply_matrices(matrix_a,matrix_b,matrix_c);

         coordinates[(count*2)]=(640+matrix_c[0]);
         coordinates[((count*2)+1)]=matrix_c[1];
      }
    }

 /************************************************************************/
 //----------------------  multiply_matrices( )  ------------------------//
 /************************************************************************/

 void multiply_matrices(const float matrix_1[3],
                   const float matrix_2[3][3],float matrix_3[3])
    {
       for(int count_1=0;count_1<3;count_1++)
      {
         for(int count_2=0;count_2<3;count_2++)
        matrix_3[count_1]+=
               (matrix_1[count_2]*matrix_2[count_2][count_1]);
      }
    }


 //-----------------------------  Polygon( )  ----------------------------//


 void Polygon(const int n,const int coordinates[])
    {
       if(n>=2)
      {
         Line(coordinates[0],coordinates[1],
                         coordinates[2],coordinates[3]);

         for(int count=1;count<(n-1);count++)
        Line(coordinates[(count*2)],coordinates[((count*2)+1)],
                        coordinates[((count+1)*2)],
                        coordinates[(((count+1)*2)+1)]);
      }
    }


 //-------------------------------  Line( )  -----------------------------//


 void Line(const int x_1,const int y_1,const int x_2,const int y_2)
    {
       int color=getcolor( );

       int x1=x_1;
       int y1=y_1;

       int x2=x_2;
       int y2=y_2;

       if(x_1>x_2)
      {
         x1=x_2;
         y1=y_2;

         x2=x_1;
         y2=y_1;
      }

       int dx=abs(x2-x1);
       int dy=abs(y2-y1);
       int inc_dec=((y2>=y1)?1:-1);

       if(dx>dy)
      {
         int two_dy=(2*dy);
         int two_dy_dx=(2*(dy-dx));
         int p=((2*dy)-dx);

         int x=x1;
         int y=y1;

         putpixel(x,y,color);

         while(x<x2)
        {
           x++;

           if(p<0)
              p+=two_dy;

           else
              {
             y+=inc_dec;
             p+=two_dy_dx;
              }

           putpixel(x,y,color);
        }
      }

       else
      {
         int two_dx=(2*dx);
         int two_dx_dy=(2*(dx-dy));
         int p=((2*dx)-dy);

         int x=x1;
         int y=y1;

         putpixel(x,y,color);

         while(y!=y2)
        {
           y+=inc_dec;

           if(p<0)
              p+=two_dx;

           else
              {
             x++;
             p+=two_dx_dy;
              }

           putpixel(x,y,color);
        }
      }
    }


 //---------------------------  Dashed_line( )  --------------------------//


 void Dashed_line(const int x_1,const int y_1,const int x_2,
                      const int y_2,const int line_type)
    {
       int count=0;
       int color=getcolor( );

       int x1=x_1;
       int y1=y_1;

       int x2=x_2;
       int y2=y_2;

       if(x_1>x_2)
      {
         x1=x_2;
         y1=y_2;

         x2=x_1;
         y2=y_1;
      }

       int dx=abs(x2-x1);
       int dy=abs(y2-y1);
       int inc_dec=((y2>=y1)?1:-1);

       if(dx>dy)
      {
         int two_dy=(2*dy);
         int two_dy_dx=(2*(dy-dx));
         int p=((2*dy)-dx);

         int x=x1;
         int y=y1;

         putpixel(x,y,color);

         while(x<x2)
        {
           x++;

           if(p<0)
              p+=two_dy;

           else
              {
             y+=inc_dec;
             p+=two_dy_dx;
              }

           if((count%2)!=0 && line_type==0)
              putpixel(x,y,color);

           else if((count%5)!=4 && line_type==1)
              putpixel(x,y,color);

           else if((count%10)!=8 && (count%10)!=9 && line_type==2)
              putpixel(x,y,color);

           else if((count%20)!=18 && (count%20)!=19 && line_type==3)
              putpixel(x,y,color);

           else if((count%12)!=7 && (count%12)!=8 &&
                (count%12)!=10 && (count%12)!=11 && line_type==4)
              putpixel(x,y,color);

           count++;
        }
      }

       else
      {
         int two_dx=(2*dx);
         int two_dx_dy=(2*(dx-dy));
         int p=((2*dx)-dy);

         int x=x1;
         int y=y1;

         putpixel(x,y,color);

         while(y!=y2)
        {
           y+=inc_dec;

           if(p<0)
              p+=two_dx;

           else
              {
             x++;
             p+=two_dx_dy;
              }

           if((count%2)!=0 && line_type==0)
              putpixel(x,y,color);

           else if((count%5)!=4 && line_type==1)
              putpixel(x,y,color);

           else if((count%10)!=8 && (count%10)!=9 && line_type==2)
              putpixel(x,y,color);

           else if((count%20)!=18 && (count%20)!=19 && line_type==3)
              putpixel(x,y,color);

           else if((count%12)!=7 && (count%12)!=8 &&
                (count%12)!=10 && (count%12)!=11 && line_type==4)
              putpixel(x,y,color);

           count++;
        }
      }
    }


 //--------------------------  show_screen( )  ---------------------------//


 void show_screen( )
    {
       setfillstyle(1,1);
     bar(208,26,430,38);

       settextstyle(0,0,1);
     setcolor(15);
       outtextxy(5,5,\"******************************************************************************\");
       outtextxy(5,17,\"*-**************************************************************************-*\");
       outtextxy(5,29,\"*-----------------------                              -----------------------*\");
       outtextxy(5,41,\"*-**************************************************************************-*\");
       outtextxy(5,53,\"*-**************************************************************************-*\");

     setcolor(11);
       outtextxy(218,29,\"Reflection Transformation\");

     setcolor(15);

       for(int count=0;count<=30;count++)
          outtextxy(5,(65+(count*12)),\"*-*                                                                        *-*\");

       outtextxy(5,438,\"*-**************************************************************************-*\");
       outtextxy(5,450,\"*-------------------------                          -------------------------*\");
       outtextxy(5,462,\"******************************************************************************\");

     setcolor(12);
       outtextxy(229,450,\"Press any Key to exit.\");
    }

    Related Post:
  1. Program to estimate the Integral value of the function at the given points from the given data using Simpsons 1/3 Rule

  2. Program of displaying product inventory by converting one class to another class

  3. Program of circular link list

  4. Program to show the projection of 3D objects using Orthographics Projection Parallel onto xy-plane

  5. Program to show the implementation of Cohen-Sutherland Line Clipping Algorithm

  6. Program that takes input of vector elements and performs multiplication operation, and input/output (&gt;&gt;, &lt;&lt;) using operator overloading

  7. Program to draw different kinds of Dashed Lines

  8. Program to illustrate strings as member of classes

  9. Program to show the implementation of None-or-All Character Clipping Strategy (Text Clipping Example)

  10. Program to draw an Ellipsoid using Parametric Equations

  11. Program that provides an example of function returning object

  12. Program to illustrate the Bubble Sort

  13. Program to illustrate static class data

  14. Program to illustrate an example of structures

  15. Program that provides an example of binary files

  16. Program to read a Non-Linear equation in one variable, then evaluate it using Modified False-Position Method and display its kD accurate root

  17. To parse a string using First and Follow algorithm and LL-1 parser

  18. Program to reverse the sequence of the words in the sentence and display the result

  19. Program that computes the n_th term of the fibonacci series and also print the series upto the n_th term using recursion

  20. Program to implement the Prims Algorithm to solve Minimum Spanning Tree Problem (MST) using Graphics