Форум программистов, компьютерный форум CyberForum.ru

Коллекция алгоритмов от Johna Smith - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Работа с графом (Требуется по заявке клиента предложить способы обмена жилплощади) http://www.cyberforum.ru/cpp-beginners/thread870941.html
В файле записаны предложения по обмену жилплощадью. Имеются варианты размена одной квартиры на две других либо на квартиру и комнату. Требуется по заявке клиента предложить способы обмена. Предусмотреть возможность нахождения обменов, в которых участвуют более двух сторон.
C++ Определить, является ли текст десятичной записью числа, кратного 9 Является ли текст записью десятичного числа,кратного 9 В заданный непустой текст входят только цифры и буквы. Определить. удовлетворяет ли он следующему свойству: 1) текст является десятичной записью числа, кратного 9; http://www.cyberforum.ru/cpp-beginners/thread870934.html
Удаление первых n элементов из vector C++
Почему, к примеру, если k=3 а pop=2, то студия выдаст ошибку(итератор вне допустимого диапазона) при запуске функции erase. По моей логике, необходимо было удалить первый элемент. #include <cstdio> #include <iostream> #include <vector> #define pb push_back #define ull unsigned long long using namespace std; vector<int> t;
Найти сумму квадратов элементов матрицы C++
Помогите пожалуйста!)
C++ Получить целочисленную матрицу http://www.cyberforum.ru/cpp-beginners/thread870928.html
Задание ниже: Nastik23, оформите тему в соответствии с правилами форума: текстовые задания набирайте от руки
C++ Считывание структур из файла #include <stdio.h> #include <string.h> #include <malloc.h> #define Lmax 20 struct student { struct { char name,surname,patronymic; } fio; подробнее

Показать сообщение отдельно
LK
Заблокирован
19.05.2013, 14:32     Коллекция алгоритмов от Johna Smith
Коллекция алгоритмов от Johna Smith
в качестве учебного материала

Источник: http://vingrad.ru
Выложенные здесь алгоритмы преследуют исключительно учебные цели.
Код неоптимизирован, местами морально устарел и показывает только принцип решения той или иной задачи. Однако он вполне рабочий и может быть использован с соответствующей дорботкой под Ваши собственные нужды.
схема, не для копипейста, не проверял
консультации и техническая поддержка не предоставляются


Добавлено через 4 минуты
Перевод из... в...

Градусы, минуты, секунды - в градусы
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
//////////////////////////////////////////////////////////////////////////////
//
//  Translating angle from degrees, minutes, seconds to degrees
//  (c) Johna Smith, 1996
//
//  Method description:
//    Here we just use the following formula:
//      phi=(phi"/60+phi')/60+phiш
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
struct angle
{
  float degrees;
  float minutes;
  float seconds;
};
void print_angle(angle a)
{
  printf("%fш%f'%f\"",a.degrees,a.minutes,a.seconds);
}
float dms_to_d(angle a)
{
  float f;
  f=(a.seconds/60+a.minutes)/60+a.degrees;
  return f;
}
void main(void)
{
  angle a={30,30,30};
  print_angle(a);
  printf("= %fш",dms_to_d(a));
}

Градусы - в градусы, минуты, секунды
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//////////////////////////////////////////////////////////////////////////////
//
//  Translating angle from degrees to degrees, minutes, seconds
//  (c) Johna Smith, 1996
//
//  Method description:
//    degrees is the integer part of angle f
//    minutes is the integer part of the remainder multiplied by 60
//    seconds is the integer part of 60*(phi_in_minutes-phi')
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
struct angle
{
  float degrees;
  float minutes;
  float seconds;
};
void print_angle(angle a)
{
  printf("%fш%f'%f\"",a.degrees,a.minutes,a.seconds);
}
angle d_to_dms(float f)
{
  angle a;
  a.degrees=(int)f;
  a.minutes=(int)((f-a.degrees)*60);
  a.seconds=(int)((f-a.degrees)*60-a.minutes);
  return a;
}
void main(void)
{
  printf("12.3456ш=");
  print_angle(d_to_dms(12.3456));
}

Комплексных величин - в экспоненциальную форму
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//////////////////////////////////////////////////////////////////////////////
//
//  Complex values operations (converting from a+bi form to M*exp(i*phi))
//  (c) Johna Smith, 1996
//
//  Given: z - complex value
//  z=a+i*b
//  z=M*exp(i*phi)
//  M=(a^2+b^2)^(1/2)    phi=arccos(a/|M|)
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
struct complex
{
  float re;
  float im;
};
struct exp_complex
{
  float M;
  float phi;
};
void show_complex(complex c) // this functions displays complex value
{
  printf("%f%+fi",c.re,c.im);
}
void show_exp_complex(exp_complex c) // this functions displays complex value
{
  printf("%f*exp(%f*i)",c.M,c.phi);
}
exp_complex Convert(complex a)
{
  exp_complex b;
  b.M=sqrt(a.re*a.re+a.im*a.im);
  b.phi=(a.im<0?-1:1)*acos(a.re/fabs(b.M));
  return b;
}
complex a={-1,1};
void main(void)
{
  show_complex(a);
  printf(" = ");
  show_exp_complex(Convert(a));
}

Градусы по Фаренгейту - в градусы по Цельсию
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//////////////////////////////////////////////////////////////////////////////
//
//  Translatintg Farengheit degrees to Celsy degrees and in other direction
//  (c) Johna Smith, 1996
//
//  Method description:
//
//    oF = 5/9(n-32) oC     oC = (32+9n/5) oF
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
float Cels2Fareng(float degree)
{
  return (5*(degree-32)/9);
}
float Fareng2Cels(float degree)
{
  return (32+9*degree/5);
}
void main(void)
{
  printf("100oC = %f oF\n",Cels2Fareng(100));
  printf("-50oF = %f oC\n",Fareng2Cels(-50));
}

Декартовы координаты - в полярные (2D)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//////////////////////////////////////////////////////////////////////////////
//
//  Translatintg Decart coordinates to polar coordinates in 2 dimensions
//  (c) Johna Smith, 1996
//
//  Method description:
//
//  r=(x^2+y^2)^(1/2)
//  phi=+/- arccos(x/r)
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
struct decart
{
  float x;
  float y;
};
struct polar
{
  float r;
  float phi;
};
polar Decart2Polar(decart c)
{
  polar p;
  p.r=sqrt(c.x*c.x+c.y*c.y);
  p.phi=acos(c.x/p.r)*(c.y>=0?1:-1);
  return p;
}
decart d={1,1};
polar p;
void main(void)
{
  p=Decart2Polar(d);
  printf("(x,y)=(%f,%f) -> (r,phi)=(%f,%f)\n",d.x,d.y,p.r,p.phi);
}

Полярные - в декартовы
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//////////////////////////////////////////////////////////////////////////////
//
//  Translatintg polar coordinates to Decart coordinates in 2 dimensions
//  (c) Johna Smith, 1996
//
//  Method description:
//
//  x=r*cos(phi)
//  y=r*sin(phi)
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
#define Pi 3.1415926536
struct decart
{
  float x;
  float y;
};
struct polar
{
  float r;
  float phi;
};
decart Polar2Decart(polar p)
{
  decart d;
  d.x=p.r*cos(p.phi);
  d.y=p.r*sin(p.phi);
  return d;
}
polar p={1.4142135624,Pi/4};
decart d;
void main(void)
{
  d=Polar2Decart(p);
  printf("(r,phi)=(%f,%f) -> (x,y)=(%f,%f)\n",p.r,p.phi,d.x,d.y);
}

Декартовы координаты - в сферические (3D)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//////////////////////////////////////////////////////////////////////////////
//
//  Translatintg Decart coordinates to spherical coordinates in 3 dimensions
//  (c) Johna Smith, 1996
//
//  Method description:
//
//  r=(x^2+y^2+z^2)^(1/2)
//  phi=+/- arccos(x/(x*x+y*y)^(1/2))
//  theta=arccos(z/r)
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
struct decart
{
  float x;
  float y;
  float z;
};
struct spherical
{
  float r;
  float phi;
  float theta;
};
spherical Decart2Spherical(decart c)
{
  spherical p;
  p.r=sqrt(c.x*c.x+c.y*c.y+c.z*c.z);
  p.phi=acos(c.x/sqrt(c.x*c.x+c.y*c.y))*(c.y>=0?1:-1);
  p.theta=acos(c.z/p.r);
  return p;
}
decart d={1,1,1};
spherical p;
void main(void)
{
  p=Decart2Spherical(d);
  printf("(x,y,z)=(%f,%f,%f) -> (r,phi,theta)=(%f,%f,%f)\n",
         d.x,d.y,d.z,p.r,p.phi,p.theta);
}

Сферические - в декартовы
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//////////////////////////////////////////////////////////////////////////////
//
//  Translatintg spherical coordinates to Decart coordinates in 3 dimensions
//  (c) Johna Smith, 1996
//
//  Method description:
//
//  x=r*cos(phi)*sin(theta)
//  y=r*sin(phi)*sin(theta)
//  z=r*cos(theta)
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
#define Pi 3.1415926536
struct decart
{
  float x;
  float y;
  float z;
};
struct spherical
{
  float r;
  float phi;
  float theta;
};
decart Spherical2Decart(spherical p)
{
  decart d;
  d.x=p.r*cos(p.phi)*sin(p.theta);
  d.y=p.r*sin(p.phi)*sin(p.theta);
  d.z=p.r*cos(p.theta);
  return d;
}
spherical p={1.732051,0.785398,0.955317};
decart d;
void main(void)
{
  d=Spherical2Decart(p);
  printf("(r,phi,theta)=(%f,%f,%f) -> (x,y,z)=(%f,%f,%f)\n",
         p.r,p.phi,p.theta,d.x,d.y,d.z);
}

Число из системы с основанием М - в систему с основанием N
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
//////////////////////////////////////////////////////////////////////////////
//
//  Translating number from M-system to N-system
//  (c) Johna Smith, 1996
//
//  Method description:
//    1) translate number to decimal
//    2) translate from decimal using sequence of divisions by nbase
//       remainders will be digits of the number in the new system
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
enum digit {A=10,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z};
char mbase=16;    // from hex
char nbase=2;  // to binary
digit m[]={F,E,D,C,B,A};  // (FEDCBA)(16)
digit n[255];
void main(void)
{
  unsigned long int decimal=0,tmp=1;
  float tmpf;
  // printing given number
  for (int i=0;i<sizeof(m)/sizeof(digit);i++)
    if (m[i]<10)
       printf("%d",m[i]);
    else printf("%c",m[i]+55);
  
  // translate number to decimal
  for(i=sizeof(m)/sizeof(digit)-1;i>=0;i--)
  {
     decimal+=tmp*m[i];
     tmp*=mbase;
  }
  printf("(%d) = %ld(10) = ",mbase,decimal);
  
  // translating from decimal
  tmpf=(float)log(decimal/(nbase-1))/log(nbase);
  // rounding to nearest integer
  tmp=(int)tmpf;
  
  if (tmpf-tmp>0.5) tmp++;
  
  for (i=tmp;i>=0;i--)
  {
    n[i]=decimal%nbase;
    decimal/=nbase;
  }
  
  // printing converted number
  for (i=0;i<=tmp;i++)
    if (n[i]<10)
      printf("%d",n[i]);
    else printf("%c",n[i]+55);
  printf("(%d)\n",nbase);
}

Приведение периодической дробной части к нормальному виду
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
//////////////////////////////////////////////////////////////////////////////
//
//  Transforming periodical decimal fraction to normal one.
//  (c) Johna Smith, 1996
//
//  Method description:
//    This method uses the fact that periodical fraction can be
//   calculated as a sum of infinite geometr. progression = 1/(1-q).
//    For example: 235.353535353...
//    The period is 35, the base (aperiodical part of the fraction) is 200,
//   number of digits in the period is 2. These parameters are required by
//   function Convert.
//    q=10^(-2)  x0=35   SUM=x0+q*x0+q^2*x0+q^3*x0+...
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <math.h>
struct fraction
{
  long int a;
  long int b;
  long int c;
} f;    // f=a+b/c
fraction Convert(double base, double period, int digits)
{
  fraction f;
  double tmp;
  f.a=0;
  f.b=pow10(digits);
  f.c=f.b-1;
  // calculating 1/(1-q)
  tmp=(double)f.b*period;
  while (floor(tmp)!=tmp)
  {
     tmp*=10;
     f.b*=10;
     f.c*=10;
  }
  f.b*=period;
  // adding base to the fraction
  base*=f.c;
  while (floor(base)!=base)
  {
     base*=10;
     f.b*=10;
     f.c*=10;
  }
  f.b+=base;
  // if this fraction isn't right: b>c we should convert it
  // into the right fraction a+ b1/c, where b1<c1 & a*c+b1=b
  if (f.b/f.c>1)
  {
     f.a+=(int)(f.b/f.c);
     f.b-=((int)(f.b/f.c))*f.c;
  }
  return f;
}
void main(void)
{
  f=Convert(200,35,2);
  printf("235,(35) = %ld %ld/%ld\n",f.a,f.b,f.c);
  f=Convert(0.0783,441e-7,3);
  printf("0.0783(441) = %ld %ld/%ld",f.a,f.b,f.c);
}


Добавлено через 18 минут
Графические алгоритмы

Рисование 3D объекта
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
//////////////////////////////////////////////////////////////////////////////
//
//  Drawing 3D object
//  (c) Johna Smith, 1996
//
//  Method description:
//    Function draw3Dobject recieves the following parameters:
//     object - reference to array of points of the drawn object
//     N - number of points in this array
//     rho     \
//     phi     |- spherical coordinates of point of view
//     theta   /
//     dist_to_screen - distance from viewpoint to screen
//     xshift, yshift - picture will be shifted by this values
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
#define Pi 3.1415926536
enum Action{move,draw};
struct Point3D
{
  int x;
  int y;
  int z;
  Action action;
};
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
        /* request autodetection */
        int gdriver = DETECT, gmode, errorcode;
        /* initialize graphics mode */
        initgraph(&gdriver, &gmode, "");
        /* read result of initialization */
        errorcode = graphresult();
        if (errorcode != grOk)    /* an error occurred */
      {
                printf("Graphics error: %s\n", grapherrormsg(errorcode));
                printf("Press any key to halt:");
                                         getch();
                exit(1);               /* return with error code */
        }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function moves CP to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void MoveTo(int x, int y)
{
  moveto(x,y);
}
// this function draws a line to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void LineTo(int x, int y)
{
  lineto(x,y);
}
void draw3Dobject(Point3D *object, int N, float rho, float theta,
                  float phi, float dist_to_screen, int xshift, int yshift)
{
  int x,y;
  float xe,ye,ze,costh,sinph,cosph,sinth,v11,v12,v13,v21,v22,v32,v33,v23,v43;
  // calculating coefficients
  costh=cos(theta);
  sinth=sin(theta);
  cosph=cos(phi);
  sinph=sin(phi);
  v11=-sinth; v12=-cosph*costh; v13=-sinph*costh;
  v21=costh;  v22=-cosph*sinth; v23=-sinph*sinth;
                                  v32=sinph;        v33=-cosph;
                                v43=rho;
  for (int i=0;i<N;i++)
  {
      // calculating eye coordinates
      xe=v11*(object+i)->x+v21*(object+i)->y;
      ye=v12*(object+i)->x+v22*(object+i)->y+v32*(object+i)->z;
      ze=v13*(object+i)->x+v23*(object+i)->y+v33*(object+i)->z+v43;
      // calculating screen coordinates
      x=dist_to_screen*xe/ze+xshift;
      y=dist_to_screen*ye/ze+yshift;
      // drawing
      if((object+i)->action==move)
          MoveTo(x,y);
      else
          LineTo(x,y);
  }
}
int main(void)
{
  Point3D thetr[]={{100,100,100,move},
                              {100,200,100,draw},
                              {200,100,100,draw},
                              {100,100,100,draw},
                              {100,100,200,draw},
                              {200,100,100,draw},
                              {100,100,200,move},
                              {100,200,100,draw}};
  int N=sizeof(thetr)/sizeof(Point3D);
  float rho=700,theta=Pi/4,phi=Pi/4,dist_to_screen=300;
  int xshift=300, yshift=150;
  // initializing graphics mode
  init_gr();
  /* examples */
  while (!kbhit())
  {
      theta+=0.05;
      // rotating viewpoint
      if (phi>2*Pi) phi-=2*Pi;
      setcolor(11);
      draw3Dobject(thetr,N,rho,theta,phi,dist_to_screen,xshift,yshift);
      setcolor(0);
      delay(15);
      draw3Dobject(thetr,N,rho,theta,phi,dist_to_screen,xshift,yshift);
  }
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Вращение 3D объекта
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
//////////////////////////////////////////////////////////////////////////////
//
//  Rotating 3D object
//  (c) Johna Smith, 1996
//
//  Method description:
//   Given: vector X, angle a
//   To rotate this vector about axe X we should apply the following
//   operation:  X'=X*Rx, where Rx - is matrix of rotation
//        [ 1 0      0     0 ]
//        [ 0 cos a  sin a 0 ]
//     Rx=[ 0 -sin a cos a 0 ]
//        [ 0 0      0     1 ]
//   Applying this operation to every point of the given object we
//   rotate it.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
#define Pi 3.1415926536
enum Action{move,draw};
struct Point3D
{
  float x;
  float y;
  float z;
  Action action;
};
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
        /* request autodetection */
        int gdriver = DETECT, gmode, errorcode;
        /* initialize graphics mode */
        initgraph(&gdriver, &gmode, "");
        /* read result of initialization */
        errorcode = graphresult();
        if (errorcode != grOk)    /* an error occurred */
        {
               printf("Graphics error: %s\n", grapherrormsg(errorcode));
               printf("Press any key to halt:");
               getch();
               exit(1);               /* return with error code */
        }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function moves CP to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void MoveTo(int x, int y)
{
  moveto(x,y);
}
// this function draws a line to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void LineTo(int x, int y)
{
  lineto(x,y);
}
void draw3Dobject(Point3D *object, int N, float rho, float theta,
                  float phi, float dist_to_screen, int xshift, int yshift)
{
  int x,y;
  float xe,ye,ze,costh,sinph,cosph,sinth,v11,v12,v13,v21,v22,v32,v33,v23,v43;
  // calculating coefficients
  costh=cos(theta);
  sinth=sin(theta);
  cosph=cos(phi);
  sinph=sin(phi);
  v11=-sinth; v12=-cosph*costh; v13=-sinph*costh;
  v21=costh;  v22=-cosph*sinth; v23=-sinph*sinth;
                      v32=sinph;             v33=-cosph;
                                                     v43=rho;
  for (int i=0;i<N;i++)
  {
         // calculating eye coordinates
         xe=v11*(object+i)->x+v21*(object+i)->y;
         ye=v12*(object+i)->x+v22*(object+i)->y+v32*(object+i)->z;
         ze=v13*(object+i)->x+v23*(object+i)->y+v33*(object+i)->z+v43;
         // calculating screen coordinates
         x=dist_to_screen*xe/ze+xshift;
         y=dist_to_screen*ye/ze+yshift;
 
        // drawing
         if((object+i)->action==move)
              MoveTo(x,y);
         else
              LineTo(x,y);
  }
}
void RotateX(Point3D *object, int n, float angle)
{
  float cosa,sina,y,z;
  cosa=cos(angle);
  sina=sin(angle);
  for(int i=0;i<n;i++)
  {
         y=(object+i)->y*cosa-(object+i)->z*sina;
         z=(object+i)->y*sina+(object+i)->z*cosa;
         (object+i)->y=y;
         (object+i)->z=z;
  }
}
void RotateY(Point3D *object, int n, float angle)
{
  float cosa,sina,x,z;
  cosa=cos(angle);
  sina=sin(angle);
  for(int i=0;i<n;i++)
  {
         x=(object+i)->x*cosa+(object+i)->z*sina;
         z=-(object+i)->x*sina+(object+i)->z*cosa;
         (object+i)->x=x;
         (object+i)->z=z;
  }
}
void RotateZ(Point3D *object, int n, float angle)
{
  float cosa,sina,x,y;
  cosa=cos(angle);
  sina=sin(angle);
  for(int i=0;i<n;i++)
  {
         x=(object+i)->x*cosa-(object+i)->y*sina;
         y=(object+i)->x*sina+(object+i)->y*cosa;
         (object+i)->x=x;
         (object+i)->y=y;
  }
}
int main(void)
{
  Point3D thetr[]={{100,100,100,move},
                              {100,200,100,draw},
                              {200,100,100,draw},
                              {100,100,100,draw},
                              {100,100,200,draw},
                              {200,100,100,draw},
                              {100,100,200,move},
                              {100,200,100,draw}};
  Point3D cube[]={{-50,-50,-50,move},
                              {-50,50,-50,draw},
                              {-50,50,50,draw},
                              {50,50,50,draw},
                              {50,50,-50,draw},
                              {50,-50,-50,draw},
                              {50,-50,50,draw},
                              {-50,-50,50,draw},
                              {-50,50,50,draw},
                              {-50,-50,50,move},
                              {-50,-50,-50,draw},
                              {50,-50,-50,draw},
                              {50,50,-50,move},
                              {-50,50,-50,draw},
                              {50,-50,50,move},
                              {50,50,50,draw}};
  int N=sizeof(thetr)/sizeof(Point3D);
  int M=sizeof(cube)/sizeof(Point3D);
  float rho=1500,theta=Pi/4,phi=-3*Pi/4,dist_to_screen=700;
  int xshift=300, yshift=150,xshift1=200,yshift1=200;
  // initializing graphics mode
  init_gr();
  /* examples */
  while (!kbhit())
  {
          RotateX(cube,M,Pi/24);
          RotateY(cube,M,Pi/24);
          RotateZ(cube,M,Pi/24);
          RotateY(thetr,N,Pi/30);
          setcolor(12);
          draw3Dobject(thetr,N,rho,theta,phi,dist_to_screen,xshift,yshift);
          draw3Dobject(cube,M,rho,theta,phi,dist_to_screen,xshift1,yshift1);
          setcolor(0);
          delay(35);
          draw3Dobject(thetr,N,rho,theta,phi,dist_to_screen,xshift,yshift);
          draw3Dobject(cube,M,rho,theta,phi,dist_to_screen,xshift1,yshift1);
  }
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Рисование куба
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
//////////////////////////////////////////////////////////////////////////////
//
//  Generating and drawing cube
//  (c) Johna Smith, 1996
//
//  Method description:
//    Cube is one of simplest figures in stereometry.
//    We just need to generate 'n' squares parallel to X,Y and Z axes
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
#define Pi 3.1415926536
enum Action{move,draw};
struct Point3D
{
  int x;
  int y;
  int z;
  Action action;
};
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
  /* request autodetection */
  int gdriver = DETECT, gmode, errorcode;
  /* initialize graphics mode */
  initgraph(&gdriver, &gmode, "");
  /* read result of initialization */
  errorcode = graphresult();
  if (errorcode != grOk)    /* an error occurred */
  {
     printf("Graphics error: %s\n", grapherrormsg(errorcode));
     printf("Press any key to halt:");
     getch();
     exit(1);               /* return with error code */
  }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function moves CP to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void MoveTo(int x, int y)
{
  moveto(x,y);
}
// this function draws a line to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void LineTo(int x, int y)
{
  lineto(x,y);
}
void draw3Dobject(Point3D *object, int N, float rho, float theta,
                  float phi, float dist_to_screen, int xshift, int yshift)
{
  int x,y;
  float xe,ye,ze,costh,sinph,cosph,sinth,v11,v12,v13,v21,v22,v32,v33,v23,v43;
  // calculating coefficients
  costh=cos(theta);
  sinth=sin(theta);
  cosph=cos(phi);
  sinph=sin(phi);
  v11=-sinth; v12=-cosph*costh; v13=-sinph*costh;
  v21=costh;  v22=-cosph*sinth; v23=-sinph*sinth;
              v32=sinph;        v33=-cosph;
                                v43=rho;
  for (int i=0;i<N;i++)
  {
     // calculating eye coordinates
     xe=v11*(object+i)->x+v21*(object+i)->y;
     ye=v12*(object+i)->x+v22*(object+i)->y+v32*(object+i)->z;
     ze=v13*(object+i)->x+v23*(object+i)->y+v33*(object+i)->z+v43;
   
     // calculating screen coordinates
     x=dist_to_screen*xe/ze+xshift;
     y=dist_to_screen*ye/ze+yshift;
     // drawing
     if((object+i)->action==move)
       MoveTo(x,y);
     else
       LineTo(x,y);
  }
}
int main(void)
{
  const int n=4; // number of cubes segments +1
  Point3D cube[15*n]; // coordinates for cubes points
  float rho=1900,theta=Pi/3,phi=2*Pi/3,dist_to_screen=600; // view point
  int xshift=300, yshift=140; // picture offset
  float side=300; // cubes parameters
  float delta;// auxulary variable
  // initializing graphics mode
  init_gr();
  // generating cube
  delta=side/(n-1);
  for (int i=0;i<n;i++)
  {
    for(int j=i*5;j<i*5+5;j++)
    {
      cube[j].x=i*delta;
      cube[j].action=draw;
    }
    cube[i*5].y=0;
    cube[i*5].z=0;
    cube[i*5].action=move;
    cube[i*5+1].y=side;
    cube[i*5+1].z=0;
    cube[i*5+2].y=side;
    cube[i*5+2].z=side;
    cube[i*5+3].y=0;
    cube[i*5+3].z=side;
    cube[i*5+4].y=0;
    cube[i*5+4].z=0;
  }
  int c=5*n;
  for (i=0;i<n;i++)
  {
    for(int j=i*5;j<i*5+5;j++)
    {
      cube[c+j].y=i*delta;
      cube[c+j].action=draw;
    }
    cube[c+i*5].x=0;
    cube[c+i*5].z=0;
    cube[c+i*5].action=move;
    cube[c+i*5+1].x=side;
    cube[c+i*5+1].z=0;
    cube[c+i*5+2].x=side;
    cube[c+i*5+2].z=side;
    cube[c+i*5+3].x=0;
    cube[c+i*5+3].z=side;
    cube[c+i*5+4].x=0;
    cube[c+i*5+4].z=0;
  }
  c=10*n;
  for (i=0;i<n;i++)
  {
    for(int j=i*5;j<i*5+5;j++)
    {
       cube[c+j].z=i*delta;
       cube[c+j].action=draw;
    }
    cube[c+i*5].y=0;
    cube[c+i*5].x=0;
    cube[c+i*5].action=move;
    cube[c+i*5+1].y=side;
    cube[c+i*5+1].x=0;
    cube[c+i*5+2].y=side;
    cube[c+i*5+2].x=side;
    cube[c+i*5+3].y=0;
    cube[c+i*5+3].x=side;
    cube[c+i*5+4].y=0;
    cube[c+i*5+4].x=0;
  }
  // drawing
  draw3Dobject(cube,15*n,rho,theta,phi,dist_to_screen,xshift,yshift);
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Рисование тора
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
//////////////////////////////////////////////////////////////////////////////
//
//  Generating and drawing torus
//  (c) Johna Smith, 1996
//
//  Method description:
//    Torus has two main circles, which are described by
//   two systems of eqations:
//    x=Rcos(a)     x=R+rcos(b)
//    y=Rsin(a)     y=0
//    z=0           z=rsin(b)
//    By generating this circles (approximating by polygons) we can get torus
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
#define Pi 3.1415926536
enum Action{move,draw};
struct Point3D
{
  int x;
  int y;
  int z;
  Action action;
};
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function moves CP to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void MoveTo(int x, int y)
{
  moveto(x,y);
}
// this function draws a line to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void LineTo(int x, int y)
{
  lineto(x,y);
}
void draw3Dobject(Point3D *object, int N, float rho, float theta,
                  float phi, float dist_to_screen, int xshift, int yshift)
{
  int x,y;
  float xe,ye,ze,costh,sinph,cosph,sinth,v11,v12,v13,v21,v22,v32,v33,v23,v43;
  // calculating coefficients
  costh=cos(theta);
  sinth=sin(theta);
  cosph=cos(phi);
  sinph=sin(phi);
  v11=-sinth; v12=-cosph*costh; v13=-sinph*costh;
  v21=costh;  v22=-cosph*sinth; v23=-sinph*sinth;
              v32=sinph;        v33=-cosph;
                                v43=rho;
  for (int i=0;i<N;i++)
  {
      // calculating eye coordinates
      xe=v11*(object+i)->x+v21*(object+i)->y;
      ye=v12*(object+i)->x+v22*(object+i)->y+v32*(object+i)->z;
      ze=v13*(object+i)->x+v23*(object+i)->y+v33*(object+i)->z+v43;
 
      // calculating screen coordinates
      x=dist_to_screen*xe/ze+xshift;
      y=dist_to_screen*ye/ze+yshift;
   
      // drawing
      if((object+i)->action==move)
        MoveTo(x,y);
      else
        LineTo(x,y);
  }
}
int main(void)
{
  const int n=20;  // number of torus' segments
  Point3D torus[2*n*(n+1)]; // coordinates for torus' points
  float rho=1800,theta=0,phi=3*Pi/4,dist_to_screen=600; // view point
  int xshift=300, yshift=250; // picture offset
  float delta=2.0*Pi/n, r=75, R=300; // torus' parameters
  float alpha,cosa,sina,beta,x; // auxulary variables
  // initializing graphics mode
  init_gr();
  // generating torus
  for (int i=0;i<n;i++)
  {
     alpha=i*delta;
     cosa=cos(alpha);
     sina=sin(alpha);
     for (int j=0;j<n+1;j++)
     {
       beta=j*delta;
       x=R+r*cos(beta);
       torus[i*(n+1)+j].x=cosa*x;
       torus[i*(n+1)+j].y=sina*x;
       torus[i*(n+1)+j].z=r*sin(beta);
       torus[i*(n+1)+j].action=((i==0 && j==0)?move:draw);
     }
  }
  int c=n*n+n;
  for (i=0;i<n;i++)
  {
     beta=i*delta;
     x=R+r*cos(beta);
     for (int j=0;j<n+1;j++)
     {
       alpha=j*delta;
       cosa=cos(alpha);
       sina=sin(alpha);
       torus[c+i*(n+1)+j].x=cosa*x;
       torus[c+i*(n+1)+j].y=sina*x;
       torus[c+i*(n+1)+j].z=r*sin(beta);
       torus[c+i*(n+1)+j].action=draw;
     }
  }
  // drawing
  draw3Dobject(torus,2*n*(n+1),rho,theta,phi,dist_to_screen,xshift,yshift);
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Рисование полусферы
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
//////////////////////////////////////////////////////////////////////////////
//
//  Generating and drawing semisphere
//  (c) Johna Smith, 1996
//
//  Method description:
//    Hemisphere is described by following eqation:
//       2    2    2
//      x  + y  + z  = 1,    -1<=z<=0
//
//    By generating this points with step 'delta' we can approximate hemisphere
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
#define Pi 3.1415926536
enum Action{move,draw};
struct Point3D
{
  int x;
  int y;
  int z;
  Action action;
};
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function moves CP to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void MoveTo(int x, int y)
{
  moveto(x,y);
}
// this function draws a line to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void LineTo(int x, int y)
{
  lineto(x,y);
}
void draw3Dobject(Point3D *object, int N, float rho, float theta,
                    float phi, float dist_to_screen, int xshift, int yshift)
{
  int x,y;
  float xe,ye,ze,costh,sinph,cosph,sinth,v11,v12,v13,v21,v22,v32,v33,v23,v43;
  // calculating coefficients
  costh=cos(theta);
  sinth=sin(theta);
  cosph=cos(phi);
  sinph=sin(phi);
  v11=-sinth; v12=-cosph*costh; v13=-sinph*costh;
  v21=costh;  v22=-cosph*sinth; v23=-sinph*sinth;
              v32=sinph;        v33=-cosph;
                                v43=rho;
  for (int i=0;i<N;i++)
  {
     // calculating eye coordinates
     xe=v11*(object+i)->x+v21*(object+i)->y;
     ye=v12*(object+i)->x+v22*(object+i)->y+v32*(object+i)->z;
     ze=v13*(object+i)->x+v23*(object+i)->y+v33*(object+i)->z+v43;
    
     // calculating screen coordinates
     x=dist_to_screen*xe/ze+xshift;
     y=dist_to_screen*ye/ze+yshift;
     // drawing
     if((object+i)->action==move)
       MoveTo(x,y);
     else
       LineTo(x,y);
  }
}
int main(void)
{
  const int n=10;  // number of hemispheres segments
  Point3D hemisphere[8*n*n+n]; // coordinates for hemispheres points
  float rho=1800,theta=Pi,phi=3*Pi/4,dist_to_screen=600; // view point
  int xshift=300, yshift=250; // picture offset
  float delta=Pi/(2*n), R=300; // hemisphere parameters
  float alpha,cosa,sina,beta,cosb,sinb; // auxulary variables
  // initializing graphics mode
  init_gr();
  // generating semisphere
  for (int i=0;i<4*n;i++)
  {
     alpha=i*delta;
     cosa=cos(alpha);
     sina=sin(alpha);
     for (int j=0;j<n;j++)
     {
       beta=j*delta;
       sinb=sin(beta);
       cosb=cos(beta);
       hemisphere[i*n+j].x=R*cosa*sinb;
       hemisphere[i*n+j].y=R*sina*sinb;
       hemisphere[i*n+j].z=-R*cosb;
       hemisphere[i*n+j].action=(j==0?move:draw);
     }
  }
  int c=4*n*n;
  for (i=0;i<n;i++)
  {
     beta=i*delta;
     sinb=sin(beta);
     cosb=cos(beta);
     for (int j=0;j<4*n+1;j++)
     {
       alpha=j*delta;
       cosa=cos(alpha);
       sina=sin(alpha);
       hemisphere[c+i*(4*n+1)+j].x=R*cosa*sinb;
       hemisphere[c+i*(4*n+1)+j].y=R*sina*sinb;
       hemisphere[c+i*(4*n+1)+j].z=-R*cosb;
       hemisphere[c+i*(4*n+1)+j].action=(j==0?move:draw);
     }
  }
  // drawing
  draw3Dobject(hemisphere,8*n*n+n,rho,theta,phi,dist_to_screen,xshift,yshift);
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Вращение фигуры в плоскости
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
//////////////////////////////////////////////////////////////////////////////
//
//  Rotations in 2 dimensions
//  (c) Johna Smith, 1996
//
//  Method description:
//    There is the following formulas for rotating in 2 dimensions:
//      x'=x0+(x-x0)*cos(phi)-(y-y0)*sin(phi)
//      y'=y0+(x-x0)*sin(phi)+(y-y0)*cos(phi)
//    To rotate the figure we should rotate each of its points
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#define Pi 3.1415926536
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function moves CP to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void MoveTo(int x, int y)
{
  moveto(x,y);
}
// this function draws a line to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void LineTo(int x, int y)
{
  lineto(x,y);
}
const N=6; // number of points in the figure
// coordinates of all given points
enum actions {MOVE,DRAW};
struct
{
  actions action;
  int x;
  int y;
} figure[N]={{MOVE,360,270},{DRAW,360,260},{DRAW,355,260},{DRAW,360,250},
     {DRAW,365,260},{DRAW,360,260}};
int x0,y0,dx,dy;
float phi;
int main(void)
{
  // initializing graphics mode
  init_gr();
  // rotating about (x0,y0)
  x0=300;
  y0=260;
  // by 10 degrees
  phi=45.0*Pi/180.0;
  // main loop
  for(int i=0;i<8;i++)
  {
    // rotating the figure
    for (int j=0;j<N;j++)
    {
      dx=figure[j].x-x0;
      dy=figure[j].y-y0;
      figure[j].x=x0+dx*cos(phi)-dy*sin(phi);
      figure[j].y=y0+dx*sin(phi)+dy*cos(phi);
    }
    // drawing rotated figure
  for (j=0;j<N;j++)
      if (figure[j].action==MOVE)
        MoveTo(figure[j].x,figure[j].y);
      else
        LineTo(figure[j].x,figure[j].y);
  }
  // clean up
  getch();
  end_gr();
  return 0;
}

Рисование линии (по Брезенхэму)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
//////////////////////////////////////////////////////////////////////////////
//
//  Bresengham line drawing
//  (c) Johna Smith, 1996
//
//  Method description:
//    Determine  dy=(y2-y1), dx=(x2-x1)
//    We plot first point of the line and increase errors of plotting
//    (xerr and yerr) by dx and dy respectively. If the error is greater
//    than largest from dx and dy then we should correct next point and
//    shift it to 1 pixel by that axe where error was too big.
//
//  ! This program is NOT optimized for best performance !
//  To do so don't use putpixel function - change bytes in video memory directly.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
       printf("Graphics error: %s\n", grapherrormsg(errorcode));
       printf("Press any key to halt:");
       getch();
       exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function puts pixel on the screen in (x,y) position using color 'color'
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void PutPixel(int x, int y, int color)
{
  putpixel(x,y,color);
}
void BLine(int x1,int y1,int x2, int y2, int color)
{
  int delta_x,delta_y,incx,incy,t,distance;
  int xerr=0,yerr=0;
  // determine dx and dy
  delta_x=x2-x1;
  delta_y=y2-y1;
  // determine steps by x and y axes (it will be +1 if we move in forward
  // direction and -1 if we move in backward direction
  if (delta_x>0) incx=1;
  else if (delta_x==0) incx=0;
  else incx=-1;
  if (delta_y>0) incy=1;
  else if (delta_y==0) incy=0;
  else incy=-1;
  delta_x=abs(delta_x);
  delta_y=abs(delta_y);
  // select largest from deltas and use it as a main distance
  if (delta_x>delta_y) distance=delta_x;
  else distance=delta_y;
  for (t=0;t<=distance+1;t++)
  {
    PutPixel(x1,y1,color);
    // increasing error
    xerr+=delta_x;
    yerr+=delta_y;
    // if error is too big then we should decrease it by changing
    // coordinates of the next plotting point to make it closer
    // to the true line
    if(xerr>distance)
    {
      xerr-=distance;
      x1+=incx;
    }
    if (yerr>distance)
    {
      yerr-=distance;
      y1+=incy;
    }
  }
}
int main(void)
{
  // initializing graphics mode
  init_gr();
  /* examples */
  BLine(0, 0, 640, 480,15);
  BLine(320, 0, 320, 480,10);
  BLine(0, 240, 640, 240,11);
  BLine(0, 480, 640, 0,12);
  BLine(320, 11, 10, 5,13);
  BLine(320, 11, 630, 5,13);
  /* clean up */
  getch();
  end_gr();
  
  return 0;
}

Рисование окружности (по Брезенхэму)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
//////////////////////////////////////////////////////////////////////////////
//
//  Bresengham circle drawing
//  (c) Johna Smith, 1996
//
//  Method description:
//    In this algorithm all floating point math changed to sequences
//  of additions and substractions. The main idea of this algorithm
//  is to increase x and y by the value of the error between them.
//
//  ! This program is NOT optimized for best performance !
//  To do so don't use putpixel function - change bytes in video memory directly.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function puts pixel on the screen in (x,y) position using color 'color'
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void PutPixel(int x, int y, int color)
{
  putpixel(x,y,color);
}
float const ratio=1.0; // you can change this to draw ellipses
// This function plots points that belongs to the circle
// It recieves offsets from center for the fist quadrant
// and plots symmetrical points in all four quadrants
void plot_circle(int x,int y, int x_center, int y_center, int color)
{
  int x_start,y_start,x_end,y_end,x1,y1;
  // the distanse between start and end can be greater than 1 if ratio!=1
  y_start=y*ratio;
  y_end=(y+1)*ratio;
  x_start=x*ratio;
  x_end=(x+1)*ratio;
  for (x1=x_start;x1<x_end;++x1)
  {
    // plot points in all four quadrants
    PutPixel(x1+x_center,y+y_center,color);
    PutPixel(x1+x_center,y_center-y,color);
    PutPixel(x_center-x1,y+y_center,color);
    PutPixel(x_center-x1,y_center-y,color);
  }
  for (y1=y_start;y1<y_end;++y1)
  {
    // plot points in all four quadrants
    PutPixel(y1+x_center,x+y_center,color);
    PutPixel(y1+x_center,y_center-x,color);
    PutPixel(x_center-y1,x+y_center,color);
    PutPixel(x_center-y1,y_center-x,color);
  }
}
// This is main function that draws circle using function
void Circle(int x1,int y1,int radius, int color)
{
  int x,y,delta;
//     Y    *              we start from * and increase x step by step
//          |              decreasing y when needed
//          |
//          |
// --------------------
//          |         X
//          |
//          |
//          |
  y=radius;
  delta=3-2*radius; // delta is an error
  // calculate values for first quadrant
  for (x=0;x<y;x++) // x is a main axe
  {
    // plot points symmetrically in all quadrants
    plot_circle(x,y,x1,y1,color);
    if (delta<0) delta+=4*x+6;
    else
    {
      delta+=4*(x-y)+10;
      y--; // it's time to decrease y
    }
  }
  x=y;
  if (y!=0) plot_circle(x,y,x1,y1,color);
}
int main(void)
{
  // initializing graphics mode
  init_gr();
  /* examples */
  Circle(200,200,100,14);
  Circle(300,200,100,15);
  Circle(400,200,100,13);
  Circle(250,100,100,12);
  Circle(350,100,100,11);
  Circle(50,400,25,2);
  Circle(500,400,25,2);
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Сглаживание кривой В-сплайном
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
//////////////////////////////////////////////////////////////////////////////
//
//  Curve fitting using B-splines
//  (c) Johna Smith, 1996
//
//  Method description:
//    We are drawing lines between points using the following formulas:
//    x(t)=((a3*t+a2)*t+a1)*t+a0
//    y(t)=((b3*t+b2)*t+b1)*t+b0
//    t=0..1
//    Look program for formulas for coefficients ai,bi
//    These coefficients depends on coordinates of current point,
//    previous one, next and next-next ones.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function moves CP to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void MoveTo(int x, int y)
{
  moveto(x,y);
}
// this function draws a line to (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void LineTo(int x, int y)
{
  lineto(x,y);
}
// this function draws a line from (x1,y1) to (x2,y2)
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void Line(int x1, int y1, int x2, int y2)
{
  line(x1,y1,x2,y2);
}
const N=21; // number of points
const M=300.0; // number of steps between two points
// coordinates of all given points
int x[N]={50,25,50,125,200,225,275,475,590,615,615,615,600,475,275,225,200,125,50,25,50};
int y[N]={140,100,60,40,70,90,85,75,80,85,100,115,120,125,115,110,130,160,140,100,60};
// coefficients
float t,xA,xB,xC,xD,yA,yB,yC,yD,a0,a1,a2,a3,b0,b1,b2,b3;
int n,i,j,first;
int main(void)
{
  // initializing graphics mode
  init_gr();
   /* mark the given points */
   for (i=0;i<N;i++)
   {
     Line(x[i]-4,y[i]-4,x[i]+4,y[i]+4);
     Line(x[i]+4,y[i]-4,x[i]-4,y[i]+4);
   }
   /* main loop */
   first=1;
   for(i=1;i<N-2;i++)
   {
     // calculating coefficients
     xA=x[i-1]; xB=x[i]; xC=x[i+1]; xD=x[i+2];
     yA=y[i-1]; yB=y[i]; yC=y[i+1]; yD=y[i+2];
     a3=(-xA+3*(xB-xC)+xD)/6.0;  b3=(-yA+3*(yB-yC)+yD)/6.0;
     a2=(xA-2*xB+xC)/2.0;        b2=(yA-2*yB+yC)/2.0;
     a1=(xC-xA)/2.0;             b1=(yC-yA)/2.0;
     a0=(xA+4*xB+xC)/6.0;        b0=(yA+4*yB+yC)/6.0;
     for (j=0;j<M;j++) // drawing curve between two given points
     {
       t=(float)j/(float)M;
       if (first)
       {
         first=0;
         MoveTo(((a3*t+a2)*t+a1)*t+a0,((b3*t+b2)*t+b1)*t+b0);
       } else LineTo(((a3*t+a2)*t+a1)*t+a0,((b3*t+b2)*t+b1)*t+b0);
     }
   }
   /* clean up */
   getch();
   end_gr();
   
   return 0;
}

Постепенное затемнение
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
//////////////////////////////////////////////////////////////////////////////
//
//  Fade to black (slowly turning the light off)
//  (c) Johna Smith, 1996
//
//  Method description:
//    We need only to decrease Red, Green and Blue components for each color
//    in palette. For example, if Red component of the first color was
//    initially 60 and we want to turn the light off in 30 steps we should
//    decrease Red component by 60/30=2 by step.
//  To increase productivity of this program you shouldn't use standart
//  BGI functions. Use direct methods instead.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <dos.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function set filling style
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void SetFillStyle(int pattern,int color)
{
  setfillstyle(pattern,color);
}
// this function draws a bar
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void Bar(int x1, int y1, int x2, int y2)
{
  bar(x1,y1,x2,y2);
}
// this function sets palette entry using RGB color coding
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void SetRGBPalette(int colornum, int red, int green, int blue)
{
  setrgbpalette(colornum,red,green,blue);
}
// this function reads palette
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void GetPalette(struct palettetype far *palette)
{
  getpalette(palette);
}
#define N   30 // steps of fading to black
struct palettetype pal;
struct {int R;int G;int B;} colors[16];
int main(void)
{
  // initializing graphics mode
  init_gr();
  // creating palette
  GetPalette(&pal);
  for(int i=0;i<pal.size-1;i++)
  {
     colors[i+1].R=0;
     colors[i+1].G=30-2*i;
     colors[i+1].B=15+i*2;
     SetRGBPalette(pal.colors[i+1],colors[i+1].R,colors[i+1].G,colors[i+1].B);
  }
  // drawing picture
  for (i=1;i<16;i++)
  {
     SetFillStyle(SOLID_FILL,i);
     Bar((i-1)*43,0,i*43,479);
  }
  // fading to balck
  for (int j=0;j<N;j++)
  {
     //delay(50);
     for (i=1;i<pal.size;i++)
        SetRGBPalette(pal.colors[i],
   colors[i].R*(1-(float)j/N),
          colors[i].G*(1-(float)j/N),
          colors[i].B*(1-(float)j/N));
  }
  // and back to the light
  for (j=0;j<N;j++)
  {
     //delay(50);
     for (i=1;i<pal.size;i++)
        SetRGBPalette(pal.colors[i],
          colors[i].R*(float)j/N,
          colors[i].G*(float)j/N,
          colors[i].B*(float)j/N);
  }
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Заливка замкнутой области
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
//////////////////////////////////////////////////////////////////////////////
//
//  Filling closed area using given color
//  (c) Johna Smith, 1996
//
//  Method description:
//    1) Fill all pixels on the current line
//    2) Call FloodFill recursively for two remote points to reduce
//       the depth of the recursion
//    3) Call FloodFill recursively for all points on two nearest
//       horizontal lines
//  ! This program is NOT optimized for best performance !
//  To do so don't use PutPixel & GetPixel function -
//  change bytes in video memory directly.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function puts pixel on the screen in (x,y) position using color 'color'
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void PutPixel(int x, int y, int color)
{
  putpixel(x,y,color);
}
// this function gets color of pixel in (x,y) position
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
int GetPixel(int x, int y)
{
  return getpixel(x,y);
}
// this function gets maximum horizontal coordinate
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
int GetMaxX(void)
{
  return getmaxx();
}
// this function gets maximum vertical coordinate
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
int GetMaxY(void)
{
  return getmaxy();
}
void FloodFill(int x, int y,int fill_color, int border_color)
{
  int x_left,x_right,YY,i;
  int XMAX,YMAX;
  XMAX=GetMaxX();
  YMAX=GetMaxY();
  // Light as many pixels as possible on line y
  // and determine x_left and x_right
  x_left=x_right=x;
  while (GetPixel(x_left,y)!=border_color && x_left>0)
  {
     PutPixel(x_left,y,fill_color);
     x_left--;
  }
  x_right++;
  while (GetPixel(x_right,y)!=border_color && x_right<XMAX)
  {
     PutPixel(x_right,y,fill_color);
     x_right++;
  }
  // Recursive calls of FloodFill for two remote points
  x=(x_right+x_left)>>1; //shifting means division by 2
  for(i=-1;i<=1;i+=2)
  {
     YY=y;
     while (GetPixel(x,YY)!=border_color && YY<YMAX && YY>0) YY+=i;
     YY=(y+YY)>>1;
     if (GetPixel(x,YY)!=border_color && GetPixel(x,YY)!=fill_color) FloodFill(x,YY,fill_color,border_color);
  }
  // Recursive calls for all "dark" (not filled) pixels next
  // to the line y (with x values between x_left and x_right
  for(YY=y-1;YY<=y+1;YY+=2)
  {
    x=x_left+1;
    while (x<x_right && YY>0 && YY<YMAX)
    {
      if (GetPixel(x,YY)!=border_color && GetPixel(x,YY)!=fill_color) FloodFill(x,YY,fill_color,border_color);
      x++;
    }
  }
}
int main(void)
{
   // initializing graphics mode
   init_gr();
   // drawing area to fill
   moveto(520,90); lineto(520,190); lineto(470,240);
   lineto(520,290); lineto(520,390);
   lineto(320,315); lineto(120,390);
   lineto(120,290); lineto(170,240);
   lineto(120,190); lineto(120, 90);
   lineto(270,90); lineto(270,120);
   lineto(170,120); lineto(170,150);
   lineto(470,150); lineto(470,120);
   lineto(370,120); lineto(370,90); lineto(520,90);
   moveto(370,240); lineto(320,290); lineto(270,240);
   lineto(320,190); lineto(370,240);
   /* example */
   FloodFill(121,91,1,15);
   FloodFill(320,240,9,15);
   FloodFill(100,20,3,15);
   /* clean up */
   getch();
   end_gr();
   return 0;
}

Рисование линии
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
//////////////////////////////////////////////////////////////////////////////
//
//  Line drawing
//  (c) Johna Smith, 1996
//
//  Method description:
//    Determine k=dy/dx, dy=(y2-y1), dx=(x2-x1)
//    Line equation is: y(x)=y1+x*k so we need only to plot all
//    these points. This algorithm is very slow, because it use
//    floating point math (requires coprocessor for best productivity)
//  ! This program is NOT optimized for best performance !
//  To do so don't use putpixel function - change bytes in video memory directly.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function puts pixel on the screen in (x,y) position using color 'color'
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void PutPixel(int x, int y, int color)
{
  putpixel(x,y,color);
}
void Line(int x1,int y1,int x2, int y2, int color)
{
  int delta_x,delta_y,incx,incy;
  float k;
  // determine dx and dy
  delta_x=x2-x1;
  delta_y=y2-y1;
  // determine steps by x and y axes (it will be +1 if we move in forward
  // direction and -1 if we move in backward direction
  if (delta_x>0) incx=1;
  else if (delta_x==0) incx=0;
  else incx=-1;
  if (delta_y>0) incy=1;
  else if (delta_y==0) incy=0;
  else incy=-1;
  delta_x=abs(delta_x);
  delta_y=abs(delta_y);
  // select greatest from deltas and use it as a main axe
  if (delta_x>delta_y && delta_x!=0)
  {
     k=(float)delta_y/delta_x;
     for (int i=0;i<delta_x;i++) PutPixel(x1+incx*i,y1+incy*floor(k*i),color);
  }
  else
  {
     k=(float)delta_x/delta_y;
     for (int i=0;i<delta_y;i++) PutPixel(x1+incx*floor(k*i),y1+incy*i,color);
  }
}
int main(void)
{
  // initializing graphics mode
  init_gr();
  /* examples */
  Line(0, 0, 640, 480,15);
  Line(320, 0, 320, 480,10);
  Line(0, 240, 640, 240,11);
  Line(0, 480, 640, 0,12);
  Line(320, 11, 10, 5,13);
  Line(320, 11, 630, 5,13);
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Рисование прямоугольника
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
//////////////////////////////////////////////////////////////////////////////
//
//  Rectangle drawing
//  (c) Johna Smith, 1996
//
//  Method description:
//  Draw four lines, using simplified line drawing method, cause we know
//  that only vertical and horizontal lines will be drawn.
//  ! This program is NOT optimized for best performance !
//  To do so don't use putpixel function - change bytes in video memory directly.
//
//////////////////////////////////////////////////////////////////////////////
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function puts pixel on the screen in (x,y) position using color 'color'
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void PutPixel(int x, int y, int color)
{
  putpixel(x,y,color);
}
void Line(int x1,int y1,int x2, int y2, int color)
{
  int delta_x,delta_y,incx,incy;
  // determine dx and dy
  delta_x=x2-x1;
  delta_y=y2-y1;
  // determine steps by x and y axes (it will be +1 if we move in forward
  // direction and -1 if we move in backward direction
  if (delta_x>0) incx=1;
  else if (delta_x==0) incx=0;
  else incx=-1;
  if (delta_y>0) incy=1;
  else if (delta_y==0) incy=0;
  else incy=-1;
  delta_x=abs(delta_x);
  delta_y=abs(delta_y);
  // select greatest from deltas and use it as a main axe
  if (delta_x!=0)
     for (int i=0;i<delta_x;i++) PutPixel(x1+incx*i,y1,color);
  else
     for (int i=0;i<delta_y;i++) PutPixel(x1,y1+incy*i,color);
}
// this function draws a rectangle
void Rectangle(int x1, int y1, int x2, int y2, int color)
{
  Line(x1,y1,x1,y2,color);
  Line(x1,y2,x2,y2,color);
  Line(x2,y2,x2,y1,color);
  Line(x2,y1,x1,y1,color);
}
int main(void)
{
  // initializing graphics mode
  init_gr();
  /* examples */
  Rectangle(0,0,639,479,10);
  Rectangle(100,200,300,400,11);
  Rectangle(600,100,20,11,12);
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Фрактал (листья папоротника)
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
//////////////////////////////////////////////////////////////////////////////
//
//  Leafs drawing
//  (c) Johna Smith, 1996
//
//  Method description:
//    We take a closed area, which will be main leaf. We want to generate
//  four fractal leafs from this one. To make it we need to scale, move and
//  rotate main leaf. These transformations described by the following
//  equations:
//          x'=ax+by+c, y'=dx+ey+f
//    So we need 6 coefficients for each leaf (24 coefficients at all).
//  These coefficients are calculated with special mathematical method
//  (here are already calculated coefficients)
//    To draw whole picture we need an iterational process:
//   1) Take any point within main leaf borders
//   2) Call function iterate for one of 4 leafs (its nuber we select
//      randomly but than the larger is leaf's area the higher is probability
//      that we call 'iterate' for this leaf
//   3) Then we take transformed point as (x,y) and repeat iterations
//
//  ! This program is NOT optimized for best performance !
//  To do so don't use putpixel function - change bytes in video memory directly.
//
//////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <graphics.h>
#include <conio.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
    /* request autodetection */
    int gdriver = DETECT, gmode, errorcode;
    /* initialize graphics mode */
    initgraph(&gdriver, &gmode, "");
    /* read result of initialization */
    errorcode = graphresult();
    if (errorcode != grOk)    /* an error occurred */
    {
       printf("Graphics error: %s\n", grapherrormsg(errorcode));
       printf("Press any key to halt:");
       getch();
       exit(1);               /* return with error code */
    }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function puts pixel on the screen in (x,y) position using color 'color'
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void PutPixel(int x, int y, int color)
{
  putpixel(x,y,color);
}
#define N       200000L // number of points
float x=0, y=0; // iteration variables (are global)
//                       a     b     c    d    e    f        probability
float coeff[4][6] = {{ 0.00, 0.00, 0.00,0.16,0.00,0.00,},   // 01%
                     { 0.85, 0.04,-0.04,0.85,0.00,1.60,},   // 85%
                     { 0.05,-0.26, 0.23,0.22,0.00,1.60,},   // 07%
                     {-0.15, 0.30, 0.26,0.24,0.00,0.44,},}; // 07%
int colors[5]={10,11,2,3,2};
void iterate(char i,int c)
{
  float x1,y1;
  x1=x*coeff[i][0]+y*coeff[i][1]+coeff[i][4];
  y1=x*coeff[i][2]+y*coeff[i][3]+coeff[i][5];
  x=x1;
  y=y1;
  putpixel ((int)(y*64),240-(int)(x*48),c);
}
int main (void)
{
  int leaf,color;
  // initializing graphics mode
  init_gr();
  // drawing leafs
  for (long int i=0;i<N;i++)
  {
     color=colors[random(5)];  // random color
     leaf=random(1000);  // selecting leaf to draw
     if (leaf<=10) iterate(0,color);
     else if (leaf<=860) iterate(1,color);
     else if (leaf<=930) iterate(2,color);
     else iterate(3,color);
  }
  /* clean up */
  getch();
  end_gr();
  return 0;
}

Множество Мандельброта
Кликните здесь для просмотра всего текста
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
//////////////////////////////////////////////////////////////////////////////
//
//  Mandelbrot set drawing
//  (c) Johna Smith, 1996
//
//  Method description:
//    1) Assume z(0)=0
//    2) Organize two loops by X and Y axes
//    3) Determine constant C=X+iY
//    4) Using iterative formula z(i)=z(i-1)*z(i-1)+c calculate Z(DEPTH),
//       where DEPTH is max depth of iterations
//    5) If Z(DEPTH) is near Z(0) then point (X,Y) belongs to Mandelbrot set
//
//  ! This program is NOT optimized for best performance !
//  To do so don't use putpixel function - change bytes in video memory directly.
//
//////////////////////////////////////////////////////////////////////////////
#define DEPTH 100 // iterations depth
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
// this function initializes graphics mode
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void init_gr(void)
{
   /* request autodetection */
   int gdriver = DETECT, gmode, errorcode;
   /* initialize graphics mode */
   initgraph(&gdriver, &gmode, "");
   /* read result of initialization */
   errorcode = graphresult();
   if (errorcode != grOk)    /* an error occurred */
   {
      printf("Graphics error: %s\n", grapherrormsg(errorcode));
      printf("Press any key to halt:");
      getch();
      exit(1);               /* return with error code */
   }
}
// this function shuts graphics mode down
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void end_gr(void)
{
  closegraph();
}
// this function puts pixel on the screen in (x,y) position using color 'color'
// it will work only if you're using Borland C++ compiler & BGI drivers
// if you're using another compiler you should overwrite body of this function
void PutPixel(int x, int y, int color)
{
  putpixel(x,y,color);
}
void Mandelbrot(void)
{
  float zi, zr, ci, cr, tmp;
  // assuming graphics mode 640x480 16 colors
  for(int i=-320;i<320;i++)  // for all pixels on the X axe
  {
     ci=((float)i)/320.0; // setting Im c = i/320
     for(int j=-380;j<160;j++)  // for all pixels on the Y axe
     {
        cr=((float)j)/240.0; // setting Re c = j/240
        zi=zr=0.0; // fixing z=0 we'll change c - it's Mandelbrot set
        for(int k=0;k<DEPTH;k++)
        {
   // z=z*z+c
   //(zr+i*zi)*(zr+i*zi)=(zr*zr-zi*zi)+i*(2*zr*zi)
   // zi=zr*zr-zi*zi+cr
   //
   tmp=zr*zr-zi*zi;
   zi=2*zr*zi+ci;
   zr=tmp+cr;
   if (zr*zr+zi*zi>1.0E16) break; // break if |z| is very big
    }
    if (k<DEPTH)
   PutPixel(i+320,j+380,k%3+1); // z was very big => it is external point
    else PutPixel(i+320,j+380,11); // internal point
     }
     if(kbhit()) break;
  }
}
int main(void)
{
  // initializing graphics mode
  init_gr();
  /* example */
  Mandelbrot();
  /* clean up */
  getch();
  end_gr();
  return 0;
}
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
 
Текущее время: 07:12. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru