RANDOMIZE TIMER

horp = .5
hany = 512
helyfinomsag2 = 6

DIM x(hany): DIM y(hany)
DIM x1(hany): DIM y1(hany)
DIM s(hany): DIM t(hany)
DIM vx(hany): DIM vy(hany)
DIM fx(hany): DIM fy(hany)
DIM ex(hany): DIM ey(hany)
DIM px(hany): DIM py(hany)
DIM ujx(hany): DIM ujy(hany)
DIM ux(hany): DIM uy(hany)
DIM beszuras(2 * hany)

eleje:
szin = 1
n = 12
SCREEN 12: CLS
pi = 3.1415925#
FOR i = 1 TO n
x(i) = i * 50: y(i) = RND * 200 + 200
x1(i) = x(i): y1(i) = y(i)
n1 = n
NEXT i

'x(1) = 300
'y(1) = 200
'FOR i = 2 TO n
'x(i) = x(i - 1) + (RND + 1) * 50 * COS(RND * 2 * pi)
'y(i) = y(i - 1) + (RND + 1) * 50 * SIN(RND * 2 * pi)
'NEXT i

FOR i = 2 TO n
LINE (x(i - 1), y(i - 1))-(x(i), y(i)), 5
NEXT i

elore:
FOR i = 2 TO n
PSET (x(i), y(i)), 14
NEXT i

IF n < hany / 2 THEN szin = szin + 1: GOTO yy
PRINT "Tovabb? (szokoz)"
dd: d$ = INKEY$: IF d$ = "" THEN GOTO dd
IF d$ = " " THEN GOTO masikmodszer
GOTO eleje
yy:

' felezomeroleges egyenlete fx(i) * x + fy(i) * y = s(i)
' f(i) vektor az i-edik pont elotti elmozdulas vektora

FOR i = 2 TO n
fx(i) = x(i) - x(i - 1): fy(i) = y(i) - y(i - 1)
x0 = (x(i) + x(i - 1)) / 2: y0 = (y(i) + y(i - 1)) / 2
s(i) = fx(i) * x0 + fy(i) * y0
NEXT i

' szogfelezok szerkesztese
' sarok-egysegvektorok: v(i) az i-edik pontba balrol mutat.

FOR i = 2 TO n
vx(i) = fx(i) / SQR(fx(i) ^ 2 + fy(i) ^ 2)
vy(i) = fy(i) / SQR(fx(i) ^ 2 + fy(i) ^ 2)
NEXT i

' e(i) vektor az i-edik szogfelezo iranyvektora
' p(i) az i-edik pont melle rakott segedpont a szogfelezohoz
' a szogfelezok egyenlete ey(i) * x - ex(i) * y = t(i)

FOR i = 2 TO n - 1
ex(i) = vx(i) + vx(i + 1): ey(i) = vy(i) + vy(i + 1)
px(i) = x(i) + 20 * vx(i) + 20 * vx(i + 1)
py(i) = y(i) + 20 * vy(i) + 20 * vy(i + 1)
t(i) = ey(i) * x(i) - ex(i) * y(i)
NEXT i

' az i-edik felezomerolegest (amely az i-edik pont elotti
' szakaszhoz tartozik) elmetsszuk az i-1-edik ill. az i-edik
' ponthoz tartozo szogfelezovel. A mtp-ok: g es h
' Az uj pont (u) ezek felezopontjanak az osszekoto szakasz
' felezopontja iranyaba valo horpasztottja.

FOR i = 3 TO n - 1
k = fx(i) * ex(i) + fy(i) * ey(i)
l = fx(i) * ex(i - 1) + fy(i) * ey(i - 1)

gx = (s(i) * ex(i) + fy(i) * t(i)) / k
gy = (s(i) * ey(i) - fx(i) * t(i)) / k
hx = (s(i) * ex(i - 1) + fy(i) * t(i - 1)) / l
hy = (s(i) * ey(i - 1) - fx(i) * t(i - 1)) / l
ux(i) = (gx + hx) / 2: uy(i) = (gy + hy) / 2
x0 = (x(i) + x(i - 1)) / 2: y0 = (y(i) + y(i - 1)) / 2
ux(i) = ux(i) * (1 - horp) + x0 * horp
uy(i) = uy(i) * (1 - horp) + y0 * horp
PSET (ux, 400 - uy)
NEXT i

' ***********  uj pontok  ****************

ujx(1) = x(1): ujx(2) = x(2)
ujy(1) = y(1): ujy(2) = y(2)

FOR i = 3 TO n - 1
ujx(2 * i - 3) = ux(i): ujx(2 * i - 2) = x(i)
ujy(2 * i - 3) = uy(i): ujy(2 * i - 2) = y(i)
NEXT i

ujx(2 * n - 3) = x(n): ujy(2 * n - 3) = y(n)

FOR j = 1 TO 2 * n - 3
x(j) = ujx(j): y(j) = ujy(j)
NEXT j

n = 2 * n - 3
GOTO elore

masikmodszer:
n = n1
FOR i = 1 TO n
x(i) = x1(i): y(i) = y1(i)
NEXT i

FinomitasiLepes: ' ********* kirajzolja az eppen legfinomabb pontsort **********
finomitasszam = 0

' ********* felezomerolegesek szerkesztese **********
' felezomeroleges egyenlete fx * x + fy * y = s
' Az (fx,fy) vektor az elmozdulas vektora a megfelelo pontok kozott.
' A "bal" es "jobb" a ket szogfelezot jelenti.

FOR i = 3 TO n - 1
IF (x(i - 1) - x(i)) ^ 2 + (y(i - 1) - y(i)) ^ 2 < helyfinomsag2 THEN GOTO MarTulFinom
fx1bal = x(i) - x(i - 2): fy1bal = y(i) - y(i - 2)
fx2bal = x(i - 1) - x(i - 2): fy2bal = y(i - 1) - y(i - 2)
fx1jobb = x(i - 1) - x(i + 1): fy1jobb = y(i - 1) - y(i + 1)
fx2jobb = x(i) - x(i + 1): fy2jobb = y(i) - y(i + 1)
fx = x(i) - x(i - 1): fy = y(i) - y(i - 1)
x0 = (x(i) + x(i - 1)) / 2: y0 = (y(i) + y(i - 1)) / 2
ss = fx * x0 + fy * y0: 'a normalvektoros egyenlet konstans oldala

' ********* szogfelezok szerkesztese **********
' e vektor az i-edik szogfelezo iranyvektora
' a szogfelezok egyenlete ey * x - ex * y = t

exbal = fx1bal / SQR(fx1bal ^ 2 + fy1bal ^ 2) + fx2bal / SQR(fx2bal ^ 2 + fy2bal ^ 2)
eybal = fy1bal / SQR(fx1bal ^ 2 + fy1bal ^ 2) + fy2bal / SQR(fx2bal ^ 2 + fy2bal ^ 2)
exjobb = fx1jobb / SQR(fx1jobb ^ 2 + fy1jobb ^ 2) + fx2jobb / SQR(fx2jobb ^ 2 + fy2jobb ^ 2)
eyjobb = fy1jobb / SQR(fx1jobb ^ 2 + fy1jobb ^ 2) + fy2jobb / SQR(fx2jobb ^ 2 + fy2jobb ^ 2)
tbal = eybal * x(i - 2) - exbal * y(i - 2)
tjobb = eyjobb * x(i + 1) - exjobb * y(i + 1)

' az i-edik felezomerolegest (amely az i-edik pont elotti
' szakaszhoz tartozik) elmetsszuk az i-2-edik ill. az i+1-edik
' ponthoz tartozo szogfelezovel. A mtp-ok: g es h, egy nevezetes
' tetel szerint a korulirt korokon vannak. Az ilyen modon szerkesztett
' metszespont akkor nem egyertelmu, ha a haromszog, ami kore a kort
' irjuk, egyenlo szaru. Ezert erdemes megtiltani, hogy az utvazlat
' harom szomszedos alappontja derekszognel elesebb szoget hatarozzon meg.
' Az uj pont (u) a ket korivfelezo pont kozt van ugy, hogy az uj gorbulet
' a ket regi gorbulet atlaga legyen. Igy jon letre a finomitas.

k = fx * exbal + fy * eybal: l = fx * exjobb + fy * eyjobb
gx = (ss * exbal + fy * tbal) / k: gy = (ss * eybal - fx * tbal) / k
hx = (ss * exjobb + fy * tjobb) / l: hy = (ss * eyjobb - fx * tjobb) / l
p1 = SQR((gx - x0) ^ 2 + (gy - y0) ^ 2) * SGN((gx - x0) * fy - (gy - y0) * fx)
p2 = SQR((hx - x0) ^ 2 + (hy - y0) ^ 2) * SGN((hx - x0) * fy - (hy - y0) * fx)
tav = SQR(fx ^ 2 + fy ^ 2) / 2
IF p1 + p2 = 0 THEN finomitasszam = finomitasszam + 1: beszuras(finomitasszam) = i: ux(finomitasszam) = x0: uy(finomitasszam) = y0: GOTO FinomitoPontKiirasa
tenyezo = (p1 ^ 2 + tav ^ 2) * (p2 ^ 2 + tav ^ 2) / (p1 * p2 + tav ^ 2) / (p1 + p2)
IF tenyezo < 0 THEN pe = tenyezo + SQR(tenyezo ^ 2 - tav ^ 2)
IF tenyezo >= 0 THEN pe = tenyezo - SQR(tenyezo ^ 2 - tav ^ 2)
finomitasszam = finomitasszam + 1
ux(finomitasszam) = x0 + fy * pe / tav / 2
uy(finomitasszam) = y0 - fx * pe / tav / 2
beszuras(finomitasszam) = i
'azaz az i-edik regi pont ele a "finomitasszam"-adik uj pontot kell beszurni.

FinomitoPontKiirasa:
PSET (ux(finomitasszam), uy(finomitasszam)), 12
MarTulFinom: NEXT i
IF finomitasszam = 0 THEN END

' ***********  uj pontok besorolasa ****************
hany = n + finomitasszam
REDIM ujx(hany): REDIM ujy(hany)
marbeszurt = 0
ujx(1) = x(1): ujy(1) = y(1): ujx(2) = x(2): ujy(2) = y(2)

FOR i = 3 TO n - 1
IF marbeszurt >= finomitasszam THEN GOTO EzNemBeszuras

VanMegBeszuras:
IF beszuras(marbeszurt + 1) <> i THEN GOTO EzNemBeszuras
ujx(i + marbeszurt) = ux(marbeszurt + 1)
ujy(i + marbeszurt) = uy(marbeszurt + 1)
marbeszurt = marbeszurt + 1

EzNemBeszuras:
ujx(i + marbeszurt) = x(i): ujy(i + marbeszurt) = y(i)
ujproba: NEXT i

NincsTobbBeszuras:
ujx(hany - 1) = x(n - 1): ujy(hany - 1) = y(n - 1)
ujx(hany) = x(n): ujy(hany) = y(n)
REDIM x(hany): REDIM y(hany): REDIM ux(hany): REDIM uy(hany): REDIM beszuras(hany)
n = hany
FOR j = 1 TO n: x(j) = ujx(j): y(j) = ujy(j): NEXT j
GOTO FinomitasiLepes






