Programy z ćwiczeń 17.12.2007

No to zaczynamy:

[link widoczny dla zalogowanych] Rozpakować i folder SVGA wrzuć do folderu: x:/BORLANDC/

Kod:

// TO CO ROBILISMY NA CWICZENIACH

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

int gdrv=DETECT, gmode;

int main()
{
initgraph(&gdrv, &gmode, "c:/BORLANDC/BGI");

line(0,0, getmaxx(), getmaxy());
line(0,getmaxy(), getmaxx(), 0);

getch();
closegraph();
return 0;
}

Kod:

// KULA
#include <conio.h>
#include <math.h>
#include <graphics.h>
#include <dos.h>
#define pi M_PI

const float kat=9;
const int sr_pal=48, s_pal=32;
const xo=0, yo=0,zo=0,r=150;
const xeo=500,yeo=350;

const m=40;
const n=20;

struct point
{
float x,y,z;
} pkc[n+1][m+1],pkv[n+1][m+1],*wpkv=&pkv[0][0];

int i,j,x,y;
float alfa=1,beta=1,gama=1.2;
char ch;

float pkm;

int huge DetectVGA256()
{
return 4;
}

int disp_pall(int x, int y)
{
const n=32,szer=11,wys=7,dx=2,dy=2;
for (i=0;i<256;i++)
{
setfillstyle(1,i);
bar(x+(szer+dx)*(i%n),y+(wys+dy)*(i/n),
x+(szer+dx)*(i%n)+szer,y+(wys+dy)*(i/n)+wys);
}
return 0;
}

int ball()
{
for (i=0;i<=n;i++)
{
alfa=0.06+pi*(0.5+i*kat/180);
for (j=0;j<=m;j++)
{
beta=pi*j*kat/180;
pkc[i][j].x=r*cos(alfa)*cos(beta);
pkc[i][j].y=r*cos(alfa)*sin(beta);
pkc[i][j].z=r*sin(alfa);
}
}
return 0;
}

//void rfillpoly(int points[8]);
//int i,j;

int draw_elm(int i, int j)
{
int prost[10];
struct point pa,pb,pc,pd;
float wx,wy,wz,w_len;
int col;

pa=pkv[i-1][j-1]; pb=pkv[i-1][j]; pc=pkv[i][j-1]; pd=pkv[i][j];

wx=((pd.y-pb.y)*(pc.z-pd.z))-((pd.z-pb.z)*(pc.y-pd.y));
wy=((pd.x-pb.x)*(pc.z-pd.z))-((pd.z-pb.z)*(pc.x-pd.x));
wz=((pd.x-pb.x)*(pc.y-pd.y))-((pd.y-pb.y)*(pc.x-pd.x));
w_len=sqrt(wx*wx+wy*wy+wz*wz);
if (wy>0)
{
prost[0]=xeo+pa.x; prost[1]=yeo+pa.z;
prost[2]=xeo+pb.x; prost[3]=yeo+pb.z;
prost[4]=xeo+pd.x; prost[5]=yeo+pd.z;
prost[6]=xeo+pc.x; prost[7]=yeo+pc.z;
// prost[8]=prost[0]; prost[9]=prost[1];

col=sr_pal+s_pal*wz/w_len;
if (!((i*(m+1)+j)%5)) setfillstyle(1,col); else setfillstyle(1,0);
// setcolor(col);
// setfillstyle(1,col);
setcolor(0);
fillpoly(4,prost);
}
return 0;
}

int rotate()
{
float da=0.031, db=0.053, dg=0.043;
float sa,ca,sb,cb,sg,cg;
int i,j, col;

do {
alfa=alfa+da; if (alfa>2*pi) alfa=alfa-2*pi;
beta=beta+db; if (beta>2*pi) beta=beta-2*pi;
gama=gama+dg; if (gama>2*pi) gama=gama-2*pi;
sa=sin(alfa); ca=cos(alfa);
sb=sin(beta); cb=cos(beta);
sg=sin(gama); cg=cos(gama);
for (i=0;i<n;i++)
for (j=0;j<=m;j++) {
//wzgl osi z
pkm=pkc[i][j].x-xo;
pkv[i][j].x=xo+pkm*ca-(pkc[i][j].y-yo)*sa;
pkv[i][j].y=yo+pkm*sa+(pkc[i][j].y-yo)*ca;
//wzgl osi y
pkm=pkv[i][j].x-xo;
pkv[i][j].x=xo+(pkc[i][j].z-zo)*sb+pkm*cb;
pkv[i][j].z=zo+(pkc[i][j].z-zo)*cb-pkm*sb;
//wzgl osi x
pkm=pkv[i][j].y-yo;
pkv[i][j].y=yo+pkm*cg-(pkv[i][j].z-zo)*sg;
pkv[i][j].z=zo+pkm*sg+(pkv[i][j].z-zo)*cg;
if (i*j) draw_elm(i,j);
}
if (kbhit()) ch=getch();
} while (ch!=27);
return 0;
}

int palette()
{
int i;
float r;
for (i=0;i<=s_pal;i++)
{
r=10+53*(s_pal-i)/s_pal;
setrgbpalette(sr_pal+i-s_pal,2*r/3,2*r/3,r/2);
setrgbpalette(sr_pal-i+s_pal+1,r,r/2,0);
}
return 0;
}

int main ()
{
int Gd=DETECT, Gm;
int Drv;

installuserdriver("SVGA256",DetectVGA256);
initgraph(&Gd,&Gm,"d:/borlandc/svga");
setcolor(15);
palette();
// disp_pall(200,650);
ball();
rotate();

closegraph();
return 0;
}

Kod:

// REKUR

/* Sample program that initializes the SuperVGA driver */
// rekurencja - rysowanie drzewa

#include <graphics.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

int huge DetectVGA256()
{
return 4;
}

int galaz(int xo, int yo, double dl, double kat)
{
const int kat_var=30, kat_con=30;
const double dl_min=0.7;
int x1,y1,prob=1,prob_l,prob_r,prob_rr,prob_ll,prob_f;
double kat_l,kat_ll, kat_r,kat_rr, kat_f;
double m_r=0.61, m_rr=0.29, m_l=0.57, m_ll=0.25, m_f=0.77;

x1=int (xo+dl*sin(kat)); y1=int (yo+dl*cos(kat));
setcolor(30);
if (dl<15) setcolor(31);
if (dl<10) setcolor(32);
if (dl<5) setcolor(33);
if (dl<2) setcolor(34);

setlinestyle(0,1,1); if (dl<11) setlinestyle(1,0,1);
line(xo,yo,x1,y1);

if (dl<2*dl_min) prob=rand()%20%2;
if (dl>dl_min)
{
kat_l=M_PI*(kat_con+rand()%(kat_var))/180;
kat_ll=M_PI*(2*kat_con+rand()%(kat_var))/180;
kat_r=M_PI*(kat_con+rand()%(kat_var))/180;
kat_rr=M_PI*(2*kat_con+rand()%(kat_var))/180;
kat_f=M_PI*(kat_var-rand()%(2*kat_var))/180;

prob_l=rand()%50%6;
prob_r=rand()%50%5;
prob_ll=rand()%50%4;
prob_rr=rand()%50%3;

if (prob) galaz(x1,y1,dl*m_f,kat+kat_f);
if (prob*prob_r) galaz(x1,y1,dl*m_r,kat+kat_r);
if (prob*prob_l) galaz(x1,y1,dl*m_l,kat-kat_l);
if (prob*prob_rr) galaz(x1,y1,dl*m_rr,kat+kat_rr);
if (prob*prob_ll) galaz(x1,y1,dl*m_ll,kat-kat_ll);
}

return 0;
}

int main()
{
int Gd = DETECT, Gm;
int i,Drv;

installuserdriver("SVGA256",DetectVGA256);
initgraph(&Gd,&Gm,"g:/cpp/svga");
setcolor(15); randomize();

setrgbpalette(30, 12,5,0);
setrgbpalette(31, 1,17,0);
setrgbpalette(32, 10,20,0);
setrgbpalette(33, 16,16,0);
setrgbpalette(34, 18,9,0);

galaz(512,720,150,M_PI);

getch();
closegraph();
return 0;
}

Kod:

// JULIA

/* Sample program that initializes the SuperVGA driver */

#include <graphics.h>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>

const int iteracje=300;
int i, brzeg=2*iteracje/5, pall_off=50;
float granica=0.01;

struct v_window
{
int left,right,top,bottom;
} vw;

struct r_window
{
float left,right,top,bottom;
} rw;

int huge DetectVGA256()
{
return 4;
}

int julia(v_window pole,r_window polef, float cr, float ci)
{

int x,y,licznik;
float v,w,sv;
float dx,dy,g;

g=1/granica;
dx=(polef.right-polef.left)/(pole.right-pole.left);
dy=(polef.top-polef.bottom)/(pole.top-pole.bottom);

for (x=pole.left;x<=pole.right;x++)
for (y=pole.top;y<=pole.bottom;y++)
{
licznik=0;
v=polef.left+(x-pole.left)*dx;
w=polef.bottom+(y-pole.top)*dy;
do {
licznik++;
sv=v;
v=v*v-w*w-cr;
w=2*sv*w-ci;
sv=v*v+w*w;
}
while ((sv<g) && (licznik<iteracje));

if (licznik-iteracje)
{
if (licznik<brzeg)
putpixel(x,y,50+sv*granica);
else putpixel (x,y,50+pall_off+(100-pall_off)*(licznik-brzeg)/(iteracje-brzeg));
}
else
{}
}
return 0;
}

int palette()
{
float b,a;
int i;

for (i=0;i<=99;i++)
{
a=(1+sin(2*M_PI*i/99))/2;
b=(1+sin(5.5*M_PI*i/99))/2;
setrgbpalette(50+i,10+(53*a),(26*a),0);
setrgbpalette(150+i,(40*b),(30*a),(64*(1-a)));
}
return 0;
}

int disp_pall(int x0, int y0, int wys)
{
for (i=0;i<256;i++)
{
setcolor(i);
line(x0+2*i,y0+wys,x0+2*i,y0);
}
return 0;
}

int main()
{
int Gd = DETECT, Gm;
int Drv;
installuserdriver("SVGA256",DetectVGA256);

initgraph(&Gd,&Gm,"d:/borlandc/svga");
setcolor(15);

palette();
// disp_pall(1,700,10);

vw.left=0; vw.right=getmaxx(); vw.top=0; vw.bottom=getmaxy();

// rw.left=-0.015; rw.right=0.04; rw.top=-0.021; rw.bottom=-0.091;
rw.left=0.2; rw.right=0.4; rw.top=-0.1; rw.bottom=-0.35;

// 0.745 0.113
julia(vw,rw,0.745,0.113);
getch();
closegraph();
return 0;
}

Kod:

// SNIEG640

// rekurencja - rysowanie sniezki

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

int i;
float col_r,col_g,col_b;
const int platki=6, odrosty=7;
const float pi2=M_PI/180;
int acol[10];

int snieg(float xo, float yo, float dl, float kat, int poziom)
{
const float dl_min=1.1;
float kat_b=90;
float m_b=0.52, m_f=0.79;
float x1,y1;

x1=xo+dl*sin(pi2*kat); y1=yo+dl*cos(pi2*kat);
if (poziom>13)
{
putpixel(x1,y1,acol[poziom-9]);
}
if (dl>dl_min)
{
if (!(poziom%odrosty)) {
snieg(x1,y1,dl,kat+kat_b,poziom+1);
snieg(x1,y1,dl,kat-kat_b,poziom+1);
snieg(x1,y1,dl,kat,poziom+1);
}
else {
snieg(x1,y1,dl*m_f,kat,poziom+1);
snieg(x1,y1,dl*m_b,kat+kat_b,poziom+1);
snieg(x1,y1,dl*m_b,kat-kat_b,poziom+1);
}
}
return 0;
}

void palette()
{
for (i=0;i<16;i++)
{
col_g=30+33*sin(M_PI/2*i/16);
col_r=63*sin(M_PI/3*i/16);
col_b=63;
setrgbpalette(i+1,col_r,col_g,col_b);
setfillstyle(1,i+1); setcolor(i+1);
acol[i]=i;
}
acol[0]=9; acol[6]=acol[7]; acol[7]=11;
acol[8]=15; acol[9]=acol[7]; acol[10]=acol[6];
acol[11]=5; acol[12]=acol[4]; acol[13]=acol[3];

for (i=0;i<16;i++)
{
setfillstyle(1,acol[i]); setcolor(1);
bar(5*i+1,getmaxy()-20,5*i+4,getmaxy()-30);
setfillstyle(1,i+1); setcolor(1);
bar(5*i+1,getmaxy(),5*i+4,getmaxy()-10);
}
}

int main()
{
int Gd = DETECT, Gm;
initgraph(&Gd,&Gm,"d:/borlandc/bgi");

palette();

for (i=0;i<platki;i++)
snieg(getmaxx()/2,getmaxy()/2,55,30+360/platki*i,1);

getch();
closegraph();
return 0;
}

Kod:

// SPIRALA

// rekurencja

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

// REKURENCJA - funkcja wywoluje sie sama bezposrednio (1-go rodzaju)
// lub przez inna funkcje czyli posrednio (2-go rodzaju).

// Ten program rysuje spirale

int element(int xo, int yo, double dl, double kat, int poziom, int bok)
{
const int kat_skr=16; // o ile st. zakreca nastepny element w stos. do pop.

const float dl_min=5.6; // bardzo wazny parametr minimalna dl galezi,
// okresla koniec wywolania rekurencyjnego
int i,j,x1,y1;
float m_f=0.96; // wspolczynnik skrocenia dlugosci

// rysowanie elementu spirali
x1=(xo+dl*sin(M_PI*kat/180)); y1=(yo+dl*cos(M_PI*kat/180));
setcolor(1+poziom%2);
line(xo,yo,x1,y1);

if (dl>dl_min) // rysowanie galezi nastepnego poziomu
{

// to jest REKURENCJA 1-go rodzaju
// funkcja wywoluje siebie sama, ale z innymi parametrami

if (bok) // rysowanie spirali glownej
{
element(x1,y1,dl*m_f,kat+kat_skr,poziom+1,bok);

// inicjowanie spirali bocznej
// if (!(poziom%5)) element(x1,y1,2*dl/3,kat-kat_skr,poziom+1,0);
}
else // rysowanie spirali bocznej
element(x1,y1,dl*m_f,kat-kat_skr,poziom+1,0);
}
return 0;
}

int main()
{
int Gd = DETECT, Gm;
int i,Drv;
initgraph(&Gd,&Gm,"g:/cpp/bgi");

// zmiana kolor˘w palety standardowej
setrgbpalette(1,55,33,0);
setrgbpalette(2,55,0,20);

// wywolanie funkcji rysujacej spirale
element(2*getmaxx()/3,getmaxy()-50,60,180,0,1);

getch();
closegraph();
return 0;

}