1. Problema intersectiei,intersectiei a doua drepte.

Program Lab_2_1;
uses crt, Types, Transf, IntersDr, IOGeom;

(****************************************
* Puncte de intersectie:
* Intersectia a doua drepte
****************************************)

var
d1, d2: Dreapta;
p: TPunct;
rel: RelDrepte;

begin
clrscr;

{ Citirea coeficientilor dreptelor de la tastatura }

read_dreapta(d1, 'd1');
read_dreapta(d2, 'd2');

{ Determinarea relatiei dintre d1 si d2 }

rel := inters_dr(d1, d2, p);

{ Afisarea rezultatului }
case rel of
vid:
writeln('Dreptele sunt paralele!');
incident:
writeln('Dreptele coincid!');
inters:
begin
writeln('Dreptele se intersecteaza in punctul cu coordonatele:');
write_punct(p, '');
end;
else
writeln('Erroare la apel inters_dr()');
end;
readkey;
end.

2. Problema intersectiei.Intersectia dreptei cu un segment.

Program Lab_2_2;
uses crt, Types, Transf, IntersDr, IOGeom;

(****************************************
* Puncte de intersectie:
* Intersectia a unei drepte cu un segment
****************************************)
var d: Dreapta;
s: Segment;
p: TPunct;
rel: RelDrepte;

begin
clrscr;

{ Citirea coeficientilor dreptelor de la tastatura }

read_dreapta(d, 'd');
read_segment(s, 's');

{ Determinarea relatiei dintre d1 si d2 }

rel := inters_dr_seg(d, s, p);

{ Afisarea rezultatului }
case rel of
vid:
writeln('Dreapta si segmentul nu se intersecteaza!');
incident:
writeln('Segmentul apartine dreptei!');
inters:
begin
writeln('Dreapta intersecteaza segmentul in punctul cu coordonatele:');
write_punct(p, '');
end;
else
writeln('Erroare la apel inters_dr_seg()');
end;
readkey;
end.

3. Problema intersectiei.Intersectia a 2 segmente.

Program Lab_2_3;
uses crt, Types, Transf, IntersDr, IOGeom;

(****************************************
* Puncte de intersectie:
* Intersectia a doua segmente
****************************************)
var
a, b: Segment;
p: TPunct;
rel: RelDrepte;

begin
clrscr;
{ Citirea coeficientilor dreptelor de la tastatura }
read_segment(a, 'a');
 read_segment(b, 'b');

{ Determinarea relatiei dintre a si b }

rel := inters_seg_seg(a, b, p);

{ Afisarea rezultatului }
case rel of
vid:
writeln('Segmentele nu se intersecteaza!');
inters:
begin
writeln('Segmentele se intersecteaza in punctul cu coordonatele:');
write_punct(p, '');
end;
else
writeln('Erroare la apel inters_seg_seg()');
end;
readkey;
end.

4. Problema infasuratorii convexe.Descrierea generala.Aplicatii.

Program Lab_4_3;
uses crt, Types, Poligon, IOGeom, GrGeom;

(****************************************
* Infasuratoarea convexa:
* Algoritmul Graham, varianda Andrew.
****************************************)

const
filein = 'Infasa.txt';
fileout = 'Lab_4_3.txt';

var
p: TabelPuncte;
S: TabelPuncte;
nr, nr_S: integer;

begin
clrscr;
writeln;

{ Citirea datelor din fisierul <filein>, daca exista }

nr := readf_puncte(filein, p);

{ Citirea datelor de la tastatura }

if nr = 0 then begin
nr := introdu_puncte(p);
{Salvarea punctelor in fisier}
writef_puncte(filein, p, nr);
 end;

{ Afisarea coordonatelor inainte de transformare }

write_puncte(p, nr);

{ Determinarea punctelor infasuratoarei convexe }

nr_S := Andrew(p, S, nr);
writeln('nr_S = ', nr_S);
readkey;
{ Afisarea rezultatului }
clrscr;
writeln;
write_puncte(S, nr_S);

drow_set_puncte(p, nr, GREEN);

delay(1000);
drow_poligon(S, nr_S);
drow_set_puncte(S, nr_S, RED);

{ Salvarea rezultatului in fisierul <fileout> }

writef_puncte(fileout, S, nr_S);
readkey;
end.

5. Problema celei mai apropiate perechi de puncte.Descrierea generala.Aplicatii

Program Lab_5_1;
uses crt, Types, Poligon, IOGeom, GrGeom;

(****************************************
* Cea mai apropiata pereche de puncte:
* Algoritmul direct
****************************************)

const
filein = 'Puncte.txt';

var
p: TabelPuncte;
nr, p1, p2: integer;
ro: real;

begin
clrscr;

{ Citirea coordonatelor punctelor de la tastatura }

if nr = 0 then nr := introdu_puncte(p);

{ Afisarea coordonatelor }
clrscr;
 write_puncte(p, nr);

{Determinarea perechii celei mai apropiate de puncte si a distantei dintre acestea}

ro := aproape(p, nr, p1, p2);

{ Afisarea rezultatului }
writeln;
writeln('Punctele cele mai apropiate sunt:');
write('p', p1); write_punct(p[p1], '');
writeln;
write('p', p2); write_punct(p[p2], '');
writeln;
writeln('ro = ', ro:5:2);
readkey;

drow_set_puncte(p, nr, GREEN);

drow_segment(p[p1], p[p2]);
readkey;
end.

6. Problema determinarii ariei unui poligon simplu.

Program Lab_3_1;
uses crt, Types, Poligon, IOGeom, Transf;

(****************************************
* Aria poligonului simplu
****************************************)

const
filein = 'Poligon.txt';

var
p: TabelPuncte;
nr: integer;
aria: real;

begin
clrscr;
writeln;

{ Citirea coordonatelor punctelor de la tastatura }

nr := introdu_puncte(p);

{ Afisarea coordonatelor inainte de transformare }

write_puncte(p, nr);

{ Calcularea ariei poligonului simplu }

aria := aria_polig_simplu(p, nr);
 { Afisarea rezultatului }
writeln;
writeln('Aria poligonului este: ', aria:8:2);
readkey;
end.

7. Problema apartenentei punctului la un domeniu.Descrierea.

Program Lab_6_3;
uses crt, Types, Poligon, IOGeom, GrGeom, Punct;

(****************************************
* Apartenenta la domeniu:
* Poligon simplu
****************************************)
const
filein = 'Simplu.txt';

var
Polig: TPoligon;
t: TPunct;

begin with Polig do begin

clrscr;
writeln;

{ Citirea datelor din fisierul <filein>, daca exista }

nr := readf_puncte(filein, p);

{ Citirea coordonatelor punctelor de la tastatura }

if nr = 0 then begin
writeln('Introdu nr de puncte: ');
readln(nr);
writeln('Sa incerc sa generez un poligon convex? (D/N)');
if UpCase(ReadKey) = 'D' then nr := gen_polig_conv(p, nr, ZeroP)
else begin
writeln('Introdu coordonatele varfurilor poligonului convex: ');
read_puncte(p, nr);
end;

{Salvarea punctelor in fisier}

writef_puncte(filein, p, nr);
end;

{ Afisarea coordonatelor }
clrscr;
write_puncte(p, nr);
 {Punctul de verificat}
writeln;
writeln('Scrie coordonatele punctului de verifica la apartenenta:');
read_punct(t, 'p');

{ Afisarea rezultatului }
if apart_polig(p, nr, t) then writeln('Apartine!')
else writeln('Nu apartine!');
readkey;

InitGr(0);
graph.setcolor(WHITE);
drow_poligon(p, nr);
drow_set_puncte(p, nr, GREEN);
drow_punct(t, WHITE);
drow_cerc(t, 5);

delay(1000);
t.x := -MidX/Ratio;
with t do while (x < MidX/Ratio) do begin
y := -MidY/Ratio;
while (y < MidY/Ratio) do begin
if apart_polig(p, nr, t) then drow_punct(t, YELLOW) else drow_punct(t, RED);
y := y + 1/Ratio;
end;
x := x + 1/Ratio;
end;
readkey;
end.

8. Problema triangularizarii.Descrierea generala.Aplicatii.

uses crt, graphABC;
type point=record x,y : real; end;
s=record p1,p2: integer; l: real; end;
tab=array[1..100] of s;
var segm, tr : tab;
puncte : array[1..10] of point;
f : text;
i,j,n,k,m : integer;
tmp:s;
intersect : boolean;
function sarrus(p1,p2,p3:point ): real;
begin sarrus:= p1.x*p2.y+p2.x*p3.y+p1.y*p3.x
-p3.x*p2.y-p3.y*p1.x-p1.y*p2.x;
end;
begin
SetWindowSize(640,480);
SetWindowTitle('Triangularizare');
Clearwindow;
{citire date}
writeln('Citire date fisier (F) , tastatura (T), generare aleatoare (A)');
c:=readkey;
if upcase(c)='F' then
begin
clearwindow;
assign(f,'tr2.in'); reset(f);
readln(f,n);
for i:=1 to n do
readln(f,puncte[i].x, puncte[i].y);
close(f);
end
else if upcase(c)='T' then
begin
clearwindow;
write('numarul de puncte :'); readln(n);
for i:=1 to n do
begin
write ('Coordonatele punctului',' ', i);
readln(puncte[i].x, puncte[i].y);
end;
end
else
begin
randomize;
n:= 20+ random (50);
for i:=1 to n do
begin
puncte[i].x:=10 + random (600);
puncte[i].y:=10+random(400);
end;
end;

{formare segmente}
k:=0;
for i:=1 to m-1 do
for j:=i+1 to m do
begin
inc(k);
segm[k].p1:=i; segm[k].p2:=j;
segm[k].l:= sqrt(sqr(puncte[i].x -puncte[j].x)+sqr(puncte[i].y -puncte[j].y));
end;
{sortare}
for i:=1 to k-1 do
for j:=1 to k-1 do
if segm[j].l>segm[j+1].l then begin
tmp:=segm[j]; segm[j]:=segm[j+1];
segm[j+1]:=tmp; end; {formare triangularizare}
tr[1]:=segm[1]; n:=1;
for i:=2 to k do
begin
intersect:=false;
for j:=1 to n do
if (sarrus(puncte[tr[j].p1], puncte[tr[j].p2], puncte[segm[i].p1])*
sarrus(puncte[tr[j].p1], puncte[tr[j].p2], puncte[segm[i].p2])<0)
and ( sarrus(puncte[segm[i].p1], puncte[segm[i].p2], puncte[tr[j].p1])*
sarrus(puncte[segm[i].p1], puncte[segm[i].p2], puncte[tr[j].p2])<0)
then intersect:=true;
if not intersect then begin
inc(n);
tr[n]:=segm[i];
end;
end;

for i:=1 to n do
writeln(tr[i].p1, ' ', tr[i].p2, ' ', tr[i].l:0:3);
end.
tr[1]:=segm[1]; n:=1;
for i:=2 to k do
begin
intersect:=false;
for j:=1 to n do
if (sarrus(puncte[tr[j].p1], puncte[tr[j].p2], puncte[segm[i].p1])*
sarrus(puncte[tr[j].p1], puncte[tr[j].p2], puncte[segm[i].p2])<0)
and ( sarrus(puncte[segm[i].p1], puncte[segm[i].p2], puncte[tr[j].p1])*
sarrus(puncte[segm[i].p1], puncte[segm[i].p2], puncte[tr[j].p2])<0)
then intersect:=true;
if not intersect then begin
inc(n);
tr[n]:=segm[i];
end;

end;
for i:=1 to n do
writeln(tr[i].p1, ' ', tr[i].p2, ' ', tr[i].l:0:3);
end.