Ja.

Na ennyit a bevezetőről.

nagyító effekt (vagy valami hasonló)
Mindenki sejti miről van szó. A kép egy részét (egy kör alakú részét) úgy kell torzítani, ahogy körülbelül egy nagyító csinálná. Az világos, hogy ezt nem realtime fogjuk megtenni. Mivel a torzítás állandó, a nagyítóhoz hozzárendelhetünk egy maszkot. Ez egy olyan mátrix lesz, amelynek minden eleme megadja annak a pontnak a koordinátáit, aminek ezen a mátrixpozíción látszania kell. Azt hiszem ez elég ködösre sikerült. Nézzünk egy példát:
Ebben a példában egy olyan mátrixot használtunk, ami a széleket nem piszkálja, a többi helyre, pedig a középső elemet rendeli. Ez egy elég egyszerű nagyítás.

Tehát a képernyő egy nagyító alatti pontja megkapható:   screen[x,y]:=bitmap[matr[x,y].x,matr[x,y].y];

És még csak most jön a java. Ugye egy ilyen a mátrixot a program elején egyszer kell kiszámolni. De ez nem olyan könnyű.

Egy módszer:
Mivel kör alakot akarunk nagyítani, ami a körön kívül esik a mátrixban, azt nem kell bolygatni. Tehát a mátrixelem, saját pozícióját fogja tartalmazni. (mint a példában a szélek)

if (x*x+y*y>r*r)
{
  matr[x][y].x=x;
  matr[x][y].y=y;
}

A probléma ott kezdődik, amikor a pont a körön belül van. Egy sík által félbevágott gömbbel egész jól lehet közelíteni a lencse torzítását:

P(x,y) : bitmap egy pontja
I(x,y) : Az a pont, amit a matrixban hozza kell rendelnünk.
Q(x,y,z) : P merőleges felvetítése a gömbre.

Tehát , ha ki akarjuk számolni, hogy P pontban a nagyítón keresztül melyik pont fog látszani, akkor fel kell vetítenünk a gömbre, (Q pont) innen pedig egy egyenest kell húzni a gömb közepébe. Ahol az egyenes metszi a síkot, ott lesz a keresett pont. Hogy miért? Mert így működik!

Megkímélek mindenkit a képletek matamatikai levezetésétől, de ezen ábrák alapján le lehet.

Ix=x*d/(z+d);
Iy=y*d(z+d);
z=1+sqrt(d*d-x*x-y*y+r*r);

Ahol:

z : a felvetített pont magassága
d : a gömb középpontjának távolsáaga a síktól.
r : a lencse sugara
x,y : P pont koordinátái
Ix,Iy : I pont koordinátái
Ennek megfelelően:

void tabfill(int d,int r)
{
  int x,y,z;
  for(x=-LENRAD;x<LENRAD;x++)
  for(y=-LENRAD;y<LENRAD;y++)
  {
    if (x*x+y*y=r*r) //bent van e a korben
    {
      z=sqrt(d*d-x*x-y*y+r*r)/3+1;
      transtab[x+LENRAD][y+LENRAD].x=(x*d)/(z+d)+LENRAD;
      transtab[x+LENRAD][y+LENRAD].y=(y*d)/(z+d)+LENRAD;
    }
    else //ha nincs, akkor marad
    {
      transtab[x+LENRAD][y+LENRAD].x=x+LENRAD;
      transtab[x+LENRAD][y+LENRAD].y=y+LENRAD;
    }
  }
}

A cuccos ki van számolva.

Ennyi maga az effekt:

void len(int x, int y)
{
  int n,m;
  x-=LENRAD;
  y-=LENRAD;
  for(n=0;n<2*LENRAD;n++)
  for(m=0;m<2*LENRAD;m++)
  {
    if(x+n>0 && x+n<320 && y+m>0 && y+m<200)
    screen[x+n+(y+m)*320]=pic[x+transtab[n][m].x+(y+transtab[n][m].y)*320];
  }
}

Na ennyi.

A forráskód Watcom C-ben sikerült.
 

 Kimmel Tamás
eMail:PC-XUser@FREEMAIL.C3.HU, Subject: "ABC"