doc/src-html/vista/Camaras.pas

   1 <HTML><HEAD>\r
   2 <TITLE>File: camaras.pas </TITLE>\r
   3 <META NAME="GENERATOR" CONTENT="PasToHTML(Bystricky Vladimir)">\r
   4 </HEAD>\r
   5 <BODY BGCOLOR="#FFFFFF">\r
   6 <A NAME=camaras.pas><CENTER><H3>camaras.pas</H3></A><I> from <A HREF=/proyecto/doc/src-html/AlgoWars.html> Project: AlgoWars.dpr</A></I></CENTER>\r
   7 <HR>\r
   8 <PRE>\r
   9 <I><FONT COLOR="Navy">{** Se implementan varias cámaras en diferentes direcciones.<br> \r
  10     <i>Cambios:</i> \r
  11     <PRE> \r
  12     09/12/00: Se agrega la clase cCamaraMapa. \r
  13     </PRE>}</FONT></I> \r
  14 <B>unit</B> Camaras; \r
  15  \r
  16 <B>interface</B> \r
  17  \r
  18 <B>uses</B> \r
  19   SysUtils, \r
  20   Camara, \r
  21   Tipos, \r
  22   Vectores, \r
  23   ObjetoVolador, \r
  24   Lista; \r
  25  \r
  26 <B>type</B> \r
  27   <I><FONT COLOR="Navy">{** Implementa una cámara frontal.}</FONT></I> \r
  28   cCamaraFrontal = <B>class</B>( cCamara ) \r
  29     <B>protected</B> \r
  30       <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y}</FONT></I> \r
  31       <B>procedure</B> <A HREF="#cCamaraFrontal.mProyectar">mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); <B>override</B>; \r
  32     <B>public</B> \r
  33       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  34       <B>constructor</B> create( cameraman: cObjetoVolador; angulo: tAngulo = PI/4; maximo: tLongitud = 5000; distPantalla: tLongitud = 0 ); \r
  35   <B>end</B>; \r
  36  \r
  37   <I><FONT COLOR="Navy">{** Implementa una cámara lateral derecha.}</FONT></I> \r
  38   cCamaraLatDer = <B>class</B>( cCamara ) \r
  39     <B>protected</B> \r
  40       <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y}</FONT></I> \r
  41       <B>procedure</B> <A HREF="#cCamaraLatDer.mProyectar">mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); <B>override</B>; \r
  42       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  43       <B>constructor</B> create( cameraman: cObjetoVolador; angulo: tAngulo = PI/4; maximo: tLongitud = 5000; distPantalla: tLongitud = 0 ); \r
  44   <B>end</B>; \r
  45  \r
  46   <I><FONT COLOR="Navy">{** Implementa una cámara lateral izquierda.}</FONT></I> \r
  47   cCamaraLatIzq = <B>class</B>( cCamara ) \r
  48     <B>protected</B> \r
  49       <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y}</FONT></I> \r
  50       <B>procedure</B> <A HREF="#cCamaraLatIzq.mProyectar">mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); <B>override</B>; \r
  51     <B>public</B> \r
  52       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  53       <B>constructor</B> create( cameraman: cObjetoVolador; angulo: tAngulo = PI/4; maximo: tLongitud = 5000; distPantalla: tLongitud = 0 ); \r
  54   <B>end</B>; \r
  55  \r
  56   <I><FONT COLOR="Navy">{** Implementa una cámara trasera.}</FONT></I> \r
  57   cCamaraTrasera = <B>class</B>( cCamara ) \r
  58     <B>protected</B> \r
  59       <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y}</FONT></I> \r
  60       <B>procedure</B> <A HREF="#cCamaraTrasera.mProyectar">mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); <B>override</B>; \r
  61     <B>public</B> \r
  62       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  63       <B>constructor</B> create( cameraman: cObjetoVolador; angulo: tAngulo = PI/4; maximo: tLongitud = 5000; distPantalla: tLongitud = 0 ); \r
  64   <B>end</B>; \r
  65  \r
  66   <I><FONT COLOR="Navy">{** Implementa una cámara para ver hacia arriba.}</FONT></I> \r
  67   cCamaraArriba = <B>class</B>( cCamara ) \r
  68     <B>protected</B> \r
  69       <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y}</FONT></I> \r
  70       <B>procedure</B> <A HREF="#cCamaraArriba.mProyectar">mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); <B>override</B>; \r
  71     <B>public</B> \r
  72       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  73       <B>constructor</B> create( cameraman: cObjetoVolador; angulo: tAngulo = PI/4; maximo: tLongitud = 5000; distPantalla: tLongitud = 0 ); \r
  74   <B>end</B>; \r
  75  \r
  76   <I><FONT COLOR="Navy">{** Implementa una cámara para ver hacia abajo.}</FONT></I> \r
  77   cCamaraAbajo = <B>class</B>( cCamara ) \r
  78     <B>protected</B> \r
  79       <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y}</FONT></I> \r
  80       <B>procedure</B> <A HREF="#cCamaraAbajo.mProyectar">mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); <B>override</B>; \r
  81     <B>public</B> \r
  82       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  83       <B>constructor</B> create( cameraman: cObjetoVolador; angulo: tAngulo = PI/4; maximo: tLongitud = 5000; distPantalla: tLongitud = 0 ); \r
  84   <B>end</B>; \r
  85  \r
  86   <I><FONT COLOR="Navy">{** Implementa una cámara para ver hacia abajo pero alejado del cameraman. \r
  87       Es como si observara al cameraman desde arriba.}</FONT></I> \r
  88   cCamaraMapa = <B>class</B>( cCamara ) \r
  89     <B>protected</B> \r
  90       <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y}</FONT></I> \r
  91       <B>procedure</B> <A HREF="#cCamaraMapa.mProyectar">mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); <B>override</B>; \r
  92     <B>public</B> \r
  93       <I><FONT COLOR="Navy">{** Constructor}</FONT></I> \r
  94       <B>constructor</B> create( cameraman: cObjetoVolador; angulo: tAngulo = PI/4; maximo: tLongitud = 5000; distPantalla: tLongitud = 0 ); \r
  95   <B>end</B>; \r
  96  \r
  97 <B>implementation</B> \r
  98  \r
  99 <B>uses</B> \r
 100   Filtros; \r
 101  \r
 102 <I><FONT COLOR="Navy">{ cCamaraFrontal }</FONT></I> \r
 103  \r
 104 <I><FONT COLOR="Navy">{** Contructor \r
 105     @param cameraman Objeto Volador en el que estará montada la cámara (obligatorio) \r
 106     @param angulo         Angulo de apertura (visión) de la cámara (default = pi/4) \r
 107     @param maximo         Distancia máxima en la que se considera visible a un objeto (default = 5000) \r
 108     @param distPantalla   Distancia hasta la pantalla de proyección (default = 0). Si tiene el valor por default \r
 109                             o cualquier valor menor o igual a cero, se usa el tamaño del objeto volador}</FONT></I> \r
 110 <B>constructor</B> cCamaraFrontal.create(cameraman: cObjetoVolador; angulo: tAngulo; maximo: tLongitud; distPantalla: tLongitud); \r
 111 <B>begin</B> \r
 112   <B>inherited</B> create(cameraman, angulo, maximo, distPantalla ); \r
 113   mSetFiltro( cFiltroFrontal.create( Cameraman, angulo, maximo, mGetRadioMinimo ) ); \r
 114 <B>end</B>; \r
 115  \r
 116 <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y \r
 117     @param ov  Objeto volador a proyectar. \r
 118     @param x   Valor de la proyección en X. \r
 119     @param x   Valor de la proyección en Y. \r
 120     @param tam Tamaño porcentual del objeto (cuanto mas lejos esta, mas pequeño es). \r
 121                Varia entre 0 y 1}</FONT></I> \r
 122 <B>procedure</B> <A NAME=cCamaraFrontal.mProyectar>cCamaraFrontal.mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); \r
 123 <B>var</B> \r
 124   posCam, \r
 125   i, \r
 126   vX, \r
 127   vY, \r
 128   v, \r
 129   O, \r
 130   OI: cVector; \r
 131   distMax, \r
 132   tmp: tLongitud; \r
 133 <B>begin</B> \r
 134   <I><FONT COLOR="Navy">// Lo primero que hay que hacer es hallar OI, para eso utilizaremos la siguiente formula: </FONT></I>\r
 135   <I><FONT COLOR="Navy">//  OI = O.(d/D.O) </FONT></I>\r
 136   <I><FONT COLOR="Navy">// En nuetro caso seria: </FONT></I>\r
 137   <I><FONT COLOR="Navy">//  OI =   O . aDistPantalla </FONT></I>\r
 138   <I><FONT COLOR="Navy">//        aCameraman.mGetI . 0 </FONT></I>\r
 139   <I><FONT COLOR="Navy">// Donde O = ov.mGetPosicion - aCameraman.mGetPosicion </FONT></I>\r
 140   <B>try</B> <I><FONT COLOR="Navy">// Probamos que el cameraman no este destruido </FONT></I>\r
 141     posCam := mGetCameraman.mGetPosicion; \r
 142   <B>except</B> <I><FONT COLOR="Navy">// Si esta destruido cae en una excepcion </FONT></I>\r
 143     on e: EAccessViolation <B>do</B> <B>raise</B> ECameramanDestruido.create; <I><FONT COLOR="Navy">// Creamos una nueva excepcion especial </FONT></I>\r
 144   <B>end</B>; \r
 145   i := mGetCameraman.mGetI; \r
 146   O := ov.mGetPosicion.mRestar( posCam ); \r
 147   OI := cVector.create( O ).mMultiplicar( mGetDistPantalla / i.mMultiplicarEsc( O ) ); \r
 148   <I><FONT COLOR="Navy">// Ahora hallamos el vector v que pertenece a la pantalla, que nos dara las nuevas coordenadas respecto de ella. </FONT></I>\r
 149   <I><FONT COLOR="Navy">//  v = OI - d.D </FONT></I>\r
 150   <I><FONT COLOR="Navy">// En nuestro caso: </FONT></I>\r
 151   <I><FONT COLOR="Navy">//  v = OI - ( aCameraman.mGetCoordenadas.mGetI . aDistPantalla ) </FONT></I>\r
 152   v := cVector.create( OI ).mRestar( i.mMultiplicar( mGetDistPantalla ) ); \r
 153   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor -j (que sera nuestro X de la pantalla) </FONT></I>\r
 154   <I><FONT COLOR="Navy">//  Es -j porque tomaremos positivo hacia la derecha. </FONT></I>\r
 155   vX := mGetCameraman.mGetJ.mMultiplicar( -1 ); \r
 156   x := v.mMultiplicarEsc( vX ); \r
 157   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor k (que sera nuestro Y de la pantalla) </FONT></I>\r
 158   vY := mGetCameraman.mGetK; \r
 159   y := v.mMultiplicarEsc( vY ); \r
 160   <I><FONT COLOR="Navy">// Ahora hallamos el tamaño proporcional (un numero entre 0 y 1, donde 0 es </FONT></I>\r
 161   <I><FONT COLOR="Navy">//  lo mas lejano y 1 lo mas cercano). Se calcula de la siguiente forma: </FONT></I>\r
 162   <I><FONT COLOR="Navy">// tam = 1  -      |O| - aRadioMinimo </FONT></I>\r
 163   <I><FONT COLOR="Navy">//              aRadioMaximo - aRadioMinimo </FONT></I>\r
 164   <I><FONT COLOR="Navy">// Donde O es el vector posicion respecto de la camara, y el " 1 - xxx ", es porque cuanto mas </FONT></I>\r
 165   <I><FONT COLOR="Navy">//  lejos, menor tiene que ser el tamaño </FONT></I>\r
 166   tmp := O.mGetModulo - mGetRadioMinimo; \r
 167   distMax := mGetRadioMaximo - mGetRadioMinimo; \r
 168   tam := 1 - (tmp / distMax); \r
 169   i.free; \r
 170   posCam.free; \r
 171   v.free; \r
 172   vX.free; \r
 173   vY.free; \r
 174   OI.free; \r
 175   O.free; \r
 176 <B>end</B>; \r
 177  \r
 178 <I><FONT COLOR="Navy">{ cCamaraLatIzq }</FONT></I> \r
 179  \r
 180 <I><FONT COLOR="Navy">{** Contructor \r
 181     @param cameraman Objeto Volador en el que estará montada la cámara (obligatorio) \r
 182     @param angulo         Angulo de apertura (visión) de la cámara (default = pi/4) \r
 183     @param maximo         Distancia máxima en la que se considera visible a un objeto (default = 5000) \r
 184     @param distPantalla   Distancia hasta la pantalla de proyección (default = 0). Si tiene el valor por default \r
 185                             o cualquier valor menor o igual a cero, se usa el tamaño del objeto volador}</FONT></I> \r
 186 <B>constructor</B> cCamaraLatIzq.create(cameraman: cObjetoVolador; angulo: tAngulo; maximo: tLongitud; distPantalla: tLongitud); \r
 187 <B>begin</B> \r
 188   <B>inherited</B> create(cameraman, angulo, maximo, distPantalla ); \r
 189   mSetFiltro( cFiltroLatIzq.create( Cameraman, angulo, maximo, mGetRadioMinimo ) ); \r
 190 <B>end</B>; \r
 191  \r
 192 <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y \r
 193     @param ov  Objeto volador a proyectar. \r
 194     @param x   Valor de la proyección en X. \r
 195     @param x   Valor de la proyección en Y. \r
 196     @param tam Tamaño porcentual del objeto (cuanto mas lejos esta, mas pequeño es). \r
 197                Varia entre 0 y 1}</FONT></I> \r
 198 <B>procedure</B> <A NAME=cCamaraLatIzq.mProyectar>cCamaraLatIzq.mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); \r
 199 <B>var</B> \r
 200   posCam, \r
 201   i, \r
 202   vX, \r
 203   vY, \r
 204   v, \r
 205   O, \r
 206   OI: cVector; \r
 207   distMax, \r
 208   tmp: tLongitud; \r
 209 <B>begin</B> \r
 210   <I><FONT COLOR="Navy">// Lo primero que hay que hacer es hallar OI, para eso utilizaremos la siguiente formula: </FONT></I>\r
 211   <I><FONT COLOR="Navy">//  OI = O.(d/D.O) </FONT></I>\r
 212   <I><FONT COLOR="Navy">// En nuetro caso seria: </FONT></I>\r
 213   <I><FONT COLOR="Navy">//  OI =   O . aDistPantalla </FONT></I>\r
 214   <I><FONT COLOR="Navy">//        aCameraman.mGetI . 0 </FONT></I>\r
 215   <I><FONT COLOR="Navy">// Donde O = ov.mGetPosicion - mGetCameraman.mGetPosicion </FONT></I>\r
 216   <B>try</B> <I><FONT COLOR="Navy">// Probamos que el cameraman no este destruido </FONT></I>\r
 217     posCam := mGetCameraman.mGetPosicion; \r
 218   <B>except</B> <I><FONT COLOR="Navy">// Si esta destruido cae en una excepcion </FONT></I>\r
 219     on e: EAccessViolation <B>do</B> <B>raise</B> ECameramanDestruido.create; <I><FONT COLOR="Navy">// Creamos una nueva excepcion especial </FONT></I>\r
 220   <B>end</B>; \r
 221   i := mGetCameraman.mGetJ; \r
 222   O := ov.mGetPosicion.mRestar( posCam ); \r
 223   OI := cVector.create( O ).mMultiplicar( mGetDistPantalla / i.mMultiplicarEsc( O ) ); \r
 224   <I><FONT COLOR="Navy">// Ahora hallamos el vector v que pertenece a la pantalla, que nos dara las nuevas coordenadas respecto de ella. </FONT></I>\r
 225   <I><FONT COLOR="Navy">//  v = OI - d.D </FONT></I>\r
 226   <I><FONT COLOR="Navy">// En nuestro caso: </FONT></I>\r
 227   <I><FONT COLOR="Navy">//  v = OI - ( aCameraman.mGetCoordenadas.mGetI . aDistPantalla ) </FONT></I>\r
 228   v := cVector.create( OI ).mRestar( i.mMultiplicar( mGetDistPantalla ) ); \r
 229   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor -j (que sera nuestro X de la pantalla) </FONT></I>\r
 230   <I><FONT COLOR="Navy">//  Es -j porque tomaremos positivo hacia la derecha. </FONT></I>\r
 231   vX := mGetCameraman.mGetI; \r
 232   x := v.mMultiplicarEsc( vX ); \r
 233   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor k (que sera nuestro Y de la pantalla) </FONT></I>\r
 234   vY := mGetCameraman.mGetK; \r
 235   y := v.mMultiplicarEsc( vY ); \r
 236   <I><FONT COLOR="Navy">// Ahora hallamos el tamaño proporcional (un numero entre 0 y 1, donde 0 es </FONT></I>\r
 237   <I><FONT COLOR="Navy">//  lo mas lejano y 1 lo mas cercano). Se calcula de la siguiente forma: </FONT></I>\r
 238   <I><FONT COLOR="Navy">// tam = 1  -      |O| - aRadioMinimo </FONT></I>\r
 239   <I><FONT COLOR="Navy">//              aRadioMaximo - aRadioMinimo </FONT></I>\r
 240   <I><FONT COLOR="Navy">// Donde O es el vector posicion respecto de la camara, y el " 1 - xxx ", es porque cuanto mas </FONT></I>\r
 241   <I><FONT COLOR="Navy">//  lejos, menor tiene que ser el tamaño </FONT></I>\r
 242   tmp := O.mGetModulo - mGetRadioMinimo; \r
 243   distMax := mGetRadioMaximo - mGetRadioMinimo; \r
 244   tam := 1 - (tmp / distMax); \r
 245   i.free; \r
 246   posCam.free; \r
 247   v.free; \r
 248   vX.free; \r
 249   vY.free; \r
 250   OI.free; \r
 251   O.free; \r
 252 <B>end</B>; \r
 253  \r
 254 <I><FONT COLOR="Navy">{ cCamaraLatDer }</FONT></I> \r
 255  \r
 256 <I><FONT COLOR="Navy">{** Contructor \r
 257     @param cameraman Objeto Volador en el que estará montada la cámara (obligatorio) \r
 258     @param angulo         Angulo de apertura (visión) de la cámara (default = pi/4) \r
 259     @param maximo         Distancia máxima en la que se considera visible a un objeto (default = 5000) \r
 260     @param distPantalla   Distancia hasta la pantalla de proyección (default = 0). Si tiene el valor por default \r
 261                             o cualquier valor menor o igual a cero, se usa el tamaño del objeto volador}</FONT></I> \r
 262 <B>constructor</B> cCamaraLatDer.create(cameraman: cObjetoVolador; angulo: tAngulo; maximo: tLongitud; distPantalla: tLongitud); \r
 263 <B>begin</B> \r
 264   <B>inherited</B> create(cameraman, angulo, maximo, distPantalla ); \r
 265   mSetFiltro( cFiltroLatDer.create( Cameraman, angulo, maximo, mGetRadioMinimo ) ); \r
 266 <B>end</B>; \r
 267  \r
 268 <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y \r
 269     @param ov  Objeto volador a proyectar. \r
 270     @param x   Valor de la proyección en X. \r
 271     @param x   Valor de la proyección en Y. \r
 272     @param tam Tamaño porcentual del objeto (cuanto mas lejos esta, mas pequeño es). \r
 273                Varia entre 0 y 1}</FONT></I> \r
 274 <B>procedure</B> <A NAME=cCamaraLatDer.mProyectar>cCamaraLatDer.mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); \r
 275 <B>var</B> \r
 276   posCam, \r
 277   i, \r
 278   vX, \r
 279   vY, \r
 280   v, \r
 281   O, \r
 282   OI: cVector; \r
 283   distMax, \r
 284   tmp: tLongitud; \r
 285 <B>begin</B> \r
 286   <I><FONT COLOR="Navy">// Lo primero que hay que hacer es hallar OI, para eso utilizaremos la siguiente formula: </FONT></I>\r
 287   <I><FONT COLOR="Navy">//  OI = O.(d/D.O) </FONT></I>\r
 288   <I><FONT COLOR="Navy">// En nuetro caso seria: </FONT></I>\r
 289   <I><FONT COLOR="Navy">//  OI =   O . aDistPantalla </FONT></I>\r
 290   <I><FONT COLOR="Navy">//        aCameraman.mGetI . 0 </FONT></I>\r
 291   <I><FONT COLOR="Navy">// Donde O = ov.mGetPosicion - mGetCameraman.mGetPosicion </FONT></I>\r
 292   <B>try</B> <I><FONT COLOR="Navy">// Probamos que el cameraman no este destruido </FONT></I>\r
 293     posCam := mGetCameraman.mGetPosicion; \r
 294   <B>except</B> <I><FONT COLOR="Navy">// Si esta destruido cae en una excepcion </FONT></I>\r
 295     on e: EAccessViolation <B>do</B> <B>raise</B> ECameramanDestruido.create; <I><FONT COLOR="Navy">// Creamos una nueva excepcion especial </FONT></I>\r
 296   <B>end</B>; \r
 297   i := mGetCameraman.mGetJ.mMultiplicar(-1); \r
 298   O := ov.mGetPosicion.mRestar( posCam ); \r
 299   OI := cVector.create( O ).mMultiplicar( mGetDistPantalla / i.mMultiplicarEsc( O ) ); \r
 300   <I><FONT COLOR="Navy">// Ahora hallamos el vector v que pertenece a la pantalla, que nos dara las nuevas coordenadas respecto de ella. </FONT></I>\r
 301   <I><FONT COLOR="Navy">//  v = OI - d.D </FONT></I>\r
 302   <I><FONT COLOR="Navy">// En nuestro caso: </FONT></I>\r
 303   <I><FONT COLOR="Navy">//  v = OI - ( aCameraman.mGetCoordenadas.mGetI . aDistPantalla ) </FONT></I>\r
 304   v := cVector.create( OI ).mRestar( i.mMultiplicar( mGetDistPantalla ) ); \r
 305   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor -j (que sera nuestro X de la pantalla) </FONT></I>\r
 306   <I><FONT COLOR="Navy">//  Es -j porque tomaremos positivo hacia la derecha. </FONT></I>\r
 307   vX := mGetCameraman.mGetI.mMultiplicar(-1); \r
 308   x := v.mMultiplicarEsc( vX ); \r
 309   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor k (que sera nuestro Y de la pantalla) </FONT></I>\r
 310   vY := mGetCameraman.mGetK; \r
 311   y := v.mMultiplicarEsc( vY ); \r
 312   <I><FONT COLOR="Navy">// Ahora hallamos el tamaño proporcional (un numero entre 0 y 1, donde 0 es </FONT></I>\r
 313   <I><FONT COLOR="Navy">//  lo mas lejano y 1 lo mas cercano). Se calcula de la siguiente forma: </FONT></I>\r
 314   <I><FONT COLOR="Navy">// tam = 1  -      |O| - aRadioMinimo </FONT></I>\r
 315   <I><FONT COLOR="Navy">//              aRadioMaximo - aRadioMinimo </FONT></I>\r
 316   <I><FONT COLOR="Navy">// Donde O es el vector posicion respecto de la camara, y el " 1 - xxx ", es porque cuanto mas </FONT></I>\r
 317   <I><FONT COLOR="Navy">//  lejos, menor tiene que ser el tamaño </FONT></I>\r
 318   tmp := O.mGetModulo - mGetRadioMinimo; \r
 319   distMax := mGetRadioMaximo - mGetRadioMinimo; \r
 320   tam := 1 - (tmp / distMax); \r
 321   i.free; \r
 322   posCam.free; \r
 323   v.free; \r
 324   vX.free; \r
 325   vY.free; \r
 326   OI.free; \r
 327   O.free; \r
 328 <B>end</B>; \r
 329  \r
 330 <I><FONT COLOR="Navy">{ cCamaraTrasera }</FONT></I> \r
 331  \r
 332 <I><FONT COLOR="Navy">{** Contructor \r
 333     @param cameraman Objeto Volador en el que estará montada la cámara (obligatorio) \r
 334     @param angulo         Angulo de apertura (visión) de la cámara (default = pi/4) \r
 335     @param maximo         Distancia máxima en la que se considera visible a un objeto (default = 5000) \r
 336     @param distPantalla   Distancia hasta la pantalla de proyección (default = 0). Si tiene el valor por default \r
 337                             o cualquier valor menor o igual a cero, se usa el tamaño del objeto volador}</FONT></I> \r
 338 <B>constructor</B> cCamaraTrasera.create(cameraman: cObjetoVolador; angulo: tAngulo; maximo: tLongitud; distPantalla: tLongitud); \r
 339 <B>begin</B> \r
 340   <B>inherited</B> create(cameraman, angulo, maximo, distPantalla ); \r
 341   mSetFiltro( cFiltroTrasero.create( Cameraman, angulo, maximo, mGetRadioMinimo ) ); \r
 342 <B>end</B>; \r
 343  \r
 344 <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y \r
 345     @param ov  Objeto volador a proyectar. \r
 346     @param x   Valor de la proyección en X. \r
 347     @param x   Valor de la proyección en Y. \r
 348     @param tam Tamaño porcentual del objeto (cuanto mas lejos esta, mas pequeño es). \r
 349                Varia entre 0 y 1}</FONT></I> \r
 350 <B>procedure</B> <A NAME=cCamaraTrasera.mProyectar>cCamaraTrasera.mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); \r
 351 <B>var</B> \r
 352   posCam, \r
 353   i, \r
 354   vX, \r
 355   vY, \r
 356   v, \r
 357   O, \r
 358   OI: cVector; \r
 359   distMax, \r
 360   tmp: tLongitud; \r
 361 <B>begin</B> \r
 362   <I><FONT COLOR="Navy">// Lo primero que hay que hacer es hallar OI, para eso utilizaremos la siguiente formula: </FONT></I>\r
 363   <I><FONT COLOR="Navy">//  OI = O.(d/D.O) </FONT></I>\r
 364   <I><FONT COLOR="Navy">// En nuetro caso seria: </FONT></I>\r
 365   <I><FONT COLOR="Navy">//  OI =   O . aDistPantalla </FONT></I>\r
 366   <I><FONT COLOR="Navy">//        aCameraman.mGetI . 0 </FONT></I>\r
 367   <I><FONT COLOR="Navy">// Donde O = ov.mGetPosicion - mGetCameraman.mGetPosicion </FONT></I>\r
 368   <B>try</B> <I><FONT COLOR="Navy">// Probamos que el cameraman no este destruido </FONT></I>\r
 369     posCam := mGetCameraman.mGetPosicion; \r
 370   <B>except</B> <I><FONT COLOR="Navy">// Si esta destruido cae en una excepcion </FONT></I>\r
 371     on e: EAccessViolation <B>do</B> <B>raise</B> ECameramanDestruido.create; <I><FONT COLOR="Navy">// Creamos una nueva excepcion especial </FONT></I>\r
 372   <B>end</B>; \r
 373   i := mGetCameraman.mGetI.mMultiplicar(-1); \r
 374   O := ov.mGetPosicion.mRestar( posCam ); \r
 375   OI := cVector.create( O ).mMultiplicar( mGetDistPantalla / i.mMultiplicarEsc( O ) ); \r
 376   <I><FONT COLOR="Navy">// Ahora hallamos el vector v que pertenece a la pantalla, que nos dara las nuevas coordenadas respecto de ella. </FONT></I>\r
 377   <I><FONT COLOR="Navy">//  v = OI - d.D </FONT></I>\r
 378   <I><FONT COLOR="Navy">// En nuestro caso: </FONT></I>\r
 379   <I><FONT COLOR="Navy">//  v = OI - ( aCameraman.mGetCoordenadas.mGetI . aDistPantalla ) </FONT></I>\r
 380   v := cVector.create( OI ).mRestar( i.mMultiplicar( mGetDistPantalla ) ); \r
 381   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor -j (que sera nuestro X de la pantalla) </FONT></I>\r
 382   <I><FONT COLOR="Navy">//  Es -j porque tomaremos positivo hacia la derecha. </FONT></I>\r
 383   vX := mGetCameraman.mGetJ; \r
 384   x := v.mMultiplicarEsc( vX ); \r
 385   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor k (que sera nuestro Y de la pantalla) </FONT></I>\r
 386   vY := mGetCameraman.mGetK; \r
 387   y := v.mMultiplicarEsc( vY ); \r
 388   <I><FONT COLOR="Navy">// Ahora hallamos el tamaño proporcional (un numero entre 0 y 1, donde 0 es </FONT></I>\r
 389   <I><FONT COLOR="Navy">//  lo mas lejano y 1 lo mas cercano). Se calcula de la siguiente forma: </FONT></I>\r
 390   <I><FONT COLOR="Navy">// tam = 1  -      |O| - aRadioMinimo </FONT></I>\r
 391   <I><FONT COLOR="Navy">//              aRadioMaximo - aRadioMinimo </FONT></I>\r
 392   <I><FONT COLOR="Navy">// Donde O es el vector posicion respecto de la camara, y el " 1 - xxx ", es porque cuanto mas </FONT></I>\r
 393   <I><FONT COLOR="Navy">//  lejos, menor tiene que ser el tamaño </FONT></I>\r
 394   tmp := O.mGetModulo - mGetRadioMinimo; \r
 395   distMax := mGetRadioMaximo - mGetRadioMinimo; \r
 396   tam := 1 - (tmp / distMax); \r
 397   i.free; \r
 398   posCam.free; \r
 399   v.free; \r
 400   vX.free; \r
 401   vY.free; \r
 402   OI.free; \r
 403   O.free; \r
 404 <B>end</B>; \r
 405  \r
 406 <I><FONT COLOR="Navy">{ cCamaraArriba }</FONT></I> \r
 407  \r
 408 <I><FONT COLOR="Navy">{** Contructor \r
 409     @param cameraman Objeto Volador en el que estará montada la cámara (obligatorio) \r
 410     @param angulo         Angulo de apertura (visión) de la cámara (default = pi/4) \r
 411     @param maximo         Distancia máxima en la que se considera visible a un objeto (default = 5000) \r
 412     @param distPantalla   Distancia hasta la pantalla de proyección (default = 0). Si tiene el valor por default \r
 413                             o cualquier valor menor o igual a cero, se usa el tamaño del objeto volador}</FONT></I> \r
 414 <B>constructor</B> cCamaraArriba.create(cameraman: cObjetoVolador; angulo: tAngulo; maximo: tLongitud; distPantalla: tLongitud); \r
 415 <B>begin</B> \r
 416   <B>inherited</B> create(cameraman, angulo, maximo, distPantalla ); \r
 417   mSetFiltro( cFiltroArriba.create( Cameraman, angulo, maximo, mGetRadioMinimo ) ); \r
 418 <B>end</B>; \r
 419  \r
 420 <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y \r
 421     @param ov  Objeto volador a proyectar. \r
 422     @param x   Valor de la proyección en X. \r
 423     @param x   Valor de la proyección en Y. \r
 424     @param tam Tamaño porcentual del objeto (cuanto mas lejos esta, mas pequeño es). \r
 425                Varia entre 0 y 1}</FONT></I> \r
 426 <B>procedure</B> <A NAME=cCamaraArriba.mProyectar>cCamaraArriba.mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); \r
 427 <B>var</B> \r
 428   posCam, \r
 429   i, \r
 430   vX, \r
 431   vY, \r
 432   v, \r
 433   O, \r
 434   OI: cVector; \r
 435   distMax, \r
 436   tmp: tLongitud; \r
 437 <B>begin</B> \r
 438   <I><FONT COLOR="Navy">// Lo primero que hay que hacer es hallar OI, para eso utilizaremos la siguiente formula: </FONT></I>\r
 439   <I><FONT COLOR="Navy">//  OI = O.(d/D.O) </FONT></I>\r
 440   <I><FONT COLOR="Navy">// En nuetro caso seria: </FONT></I>\r
 441   <I><FONT COLOR="Navy">//  OI =   O . aDistPantalla </FONT></I>\r
 442   <I><FONT COLOR="Navy">//        aCameraman.mGetI . 0 </FONT></I>\r
 443   <I><FONT COLOR="Navy">// Donde O = ov.mGetPosicion - mGetCameraman.mGetPosicion </FONT></I>\r
 444   <B>try</B> <I><FONT COLOR="Navy">// Probamos que el cameraman no este destruido </FONT></I>\r
 445     posCam := mGetCameraman.mGetPosicion; \r
 446   <B>except</B> <I><FONT COLOR="Navy">// Si esta destruido cae en una excepcion </FONT></I>\r
 447     on e: EAccessViolation <B>do</B> <B>raise</B> ECameramanDestruido.create; <I><FONT COLOR="Navy">// Creamos una nueva excepcion especial </FONT></I>\r
 448   <B>end</B>; \r
 449   i := mGetCameraman.mGetk; \r
 450   O := ov.mGetPosicion.mRestar( posCam ); \r
 451   OI := cVector.create( O ).mMultiplicar( mGetDistPantalla / i.mMultiplicarEsc( O ) ); \r
 452   <I><FONT COLOR="Navy">// Ahora hallamos el vector v que pertenece a la pantalla, que nos dara las nuevas coordenadas respecto de ella. </FONT></I>\r
 453   <I><FONT COLOR="Navy">//  v = OI - d.D </FONT></I>\r
 454   <I><FONT COLOR="Navy">// En nuestro caso: </FONT></I>\r
 455   <I><FONT COLOR="Navy">//  v = OI - ( aCameraman.mGetCoordenadas.mGetI . aDistPantalla ) </FONT></I>\r
 456   v := cVector.create( OI ).mRestar( i.mMultiplicar( mGetDistPantalla ) ); \r
 457   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor -j (que sera nuestro X de la pantalla) </FONT></I>\r
 458   <I><FONT COLOR="Navy">//  Es -j porque tomaremos positivo hacia la derecha. </FONT></I>\r
 459   vX := mGetCameraman.mGetJ; \r
 460   x := v.mMultiplicarEsc( vX ); \r
 461   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor k (que sera nuestro Y de la pantalla) </FONT></I>\r
 462   vY := mGetCameraman.mGetI.mMultiplicar(-1); \r
 463   y := v.mMultiplicarEsc( vY ); \r
 464   <I><FONT COLOR="Navy">// Ahora hallamos el tamaño proporcional (un numero entre 0 y 1, donde 0 es </FONT></I>\r
 465   <I><FONT COLOR="Navy">//  lo mas lejano y 1 lo mas cercano). Se calcula de la siguiente forma: </FONT></I>\r
 466   <I><FONT COLOR="Navy">// tam = 1  -      |O| - aRadioMinimo </FONT></I>\r
 467   <I><FONT COLOR="Navy">//              aRadioMaximo - aRadioMinimo </FONT></I>\r
 468   <I><FONT COLOR="Navy">// Donde O es el vector posicion respecto de la camara, y el " 1 - xxx ", es porque cuanto mas </FONT></I>\r
 469   <I><FONT COLOR="Navy">//  lejos, menor tiene que ser el tamaño </FONT></I>\r
 470   tmp := O.mGetModulo - mGetRadioMinimo; \r
 471   distMax := mGetRadioMaximo - mGetRadioMinimo; \r
 472   tam := 1 - (tmp / distMax); \r
 473   i.free; \r
 474   posCam.free; \r
 475   v.free; \r
 476   vX.free; \r
 477   vY.free; \r
 478   OI.free; \r
 479   O.free; \r
 480 <B>end</B>; \r
 481  \r
 482 <I><FONT COLOR="Navy">{ cCamaraLatAbajo }</FONT></I> \r
 483  \r
 484 <I><FONT COLOR="Navy">{** Contructor \r
 485     @param cameraman Objeto Volador en el que estará montada la cámara (obligatorio) \r
 486     @param angulo         Angulo de apertura (visión) de la cámara (default = pi/4) \r
 487     @param maximo         Distancia máxima en la que se considera visible a un objeto (default = 5000) \r
 488     @param distPantalla   Distancia hasta la pantalla de proyección (default = 0). Si tiene el valor por default \r
 489                             o cualquier valor menor o igual a cero, se usa el tamaño del objeto volador}</FONT></I> \r
 490 <B>constructor</B> cCamaraAbajo.create(cameraman: cObjetoVolador; angulo: tAngulo; maximo: tLongitud; distPantalla: tLongitud); \r
 491 <B>begin</B> \r
 492   <B>inherited</B> create(cameraman, angulo, maximo, distPantalla ); \r
 493   mSetFiltro( cFiltroAbajo.create( Cameraman, angulo, maximo, mGetRadioMinimo ) ); \r
 494 <B>end</B>; \r
 495  \r
 496 <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y \r
 497     @param ov  Objeto volador a proyectar. \r
 498     @param x   Valor de la proyección en X. \r
 499     @param x   Valor de la proyección en Y. \r
 500     @param tam Tamaño porcentual del objeto (cuanto mas lejos esta, mas pequeño es). \r
 501                Varia entre 0 y 1}</FONT></I> \r
 502 <B>procedure</B> <A NAME=cCamaraAbajo.mProyectar>cCamaraAbajo.mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); \r
 503 <B>var</B> \r
 504   posCam, \r
 505   i, \r
 506   vX, \r
 507   vY, \r
 508   v, \r
 509   O, \r
 510   OI: cVector; \r
 511   distMax, \r
 512   tmp: tLongitud; \r
 513 <B>begin</B> \r
 514   <I><FONT COLOR="Navy">// Lo primero que hay que hacer es hallar OI, para eso utilizaremos la siguiente formula: </FONT></I>\r
 515   <I><FONT COLOR="Navy">//  OI = O.(d/D.O) </FONT></I>\r
 516   <I><FONT COLOR="Navy">// En nuetro caso seria: </FONT></I>\r
 517   <I><FONT COLOR="Navy">//  OI =   O . aDistPantalla </FONT></I>\r
 518   <I><FONT COLOR="Navy">//        aCameraman.mGetI . 0 </FONT></I>\r
 519   <I><FONT COLOR="Navy">// Donde O = ov.mGetPosicion - mGetCameraman.mGetPosicion </FONT></I>\r
 520   <B>try</B> <I><FONT COLOR="Navy">// Probamos que el cameraman no este destruido </FONT></I>\r
 521     posCam := mGetCameraman.mGetPosicion; \r
 522   <B>except</B> <I><FONT COLOR="Navy">// Si esta destruido cae en una excepcion </FONT></I>\r
 523     on e: EAccessViolation <B>do</B> <B>raise</B> ECameramanDestruido.create; <I><FONT COLOR="Navy">// Creamos una nueva excepcion especial </FONT></I>\r
 524   <B>end</B>; \r
 525   i := mGetCameraman.mGetk.mMultiplicar(-1); \r
 526   O := ov.mGetPosicion.mRestar( posCam ); \r
 527   OI := cVector.create( O ).mMultiplicar( mGetDistPantalla / i.mMultiplicarEsc( O ) ); \r
 528   <I><FONT COLOR="Navy">// Ahora hallamos el vector v que pertenece a la pantalla, que nos dara las nuevas coordenadas respecto de ella. </FONT></I>\r
 529   <I><FONT COLOR="Navy">//  v = OI - d.D </FONT></I>\r
 530   <I><FONT COLOR="Navy">// En nuestro caso: </FONT></I>\r
 531   <I><FONT COLOR="Navy">//  v = OI - ( aCameraman.mGetCoordenadas.mGetI . aDistPantalla ) </FONT></I>\r
 532   v := cVector.create( OI ).mRestar( i.mMultiplicar( mGetDistPantalla ) ); \r
 533   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor -j (que sera nuestro X de la pantalla) </FONT></I>\r
 534   <I><FONT COLOR="Navy">//  Es -j porque tomaremos positivo hacia la derecha. </FONT></I>\r
 535   vX := mGetCameraman.mGetj.mMultiplicar(-1); \r
 536   x := v.mMultiplicarEsc( vX ); \r
 537   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor k (que sera nuestro Y de la pantalla) </FONT></I>\r
 538   vY := mGetCameraman.mGetI; \r
 539   y := v.mMultiplicarEsc( vY ); \r
 540   <I><FONT COLOR="Navy">// Ahora hallamos el tamaño proporcional (un numero entre 0 y 1, donde 0 es </FONT></I>\r
 541   <I><FONT COLOR="Navy">//  lo mas lejano y 1 lo mas cercano). Se calcula de la siguiente forma: </FONT></I>\r
 542   <I><FONT COLOR="Navy">// tam = 1  -      |O| - aRadioMinimo </FONT></I>\r
 543   <I><FONT COLOR="Navy">//              aRadioMaximo - aRadioMinimo </FONT></I>\r
 544   <I><FONT COLOR="Navy">// Donde O es el vector posicion respecto de la camara, y el " 1 - xxx ", es porque cuanto mas </FONT></I>\r
 545   <I><FONT COLOR="Navy">//  lejos, menor tiene que ser el tamaño </FONT></I>\r
 546   tmp := O.mGetModulo - mGetRadioMinimo; \r
 547   distMax := mGetRadioMaximo - mGetRadioMinimo; \r
 548   tam := 1 - (tmp / distMax); \r
 549   i.free; \r
 550   posCam.free; \r
 551   v.free; \r
 552   vX.free; \r
 553   vY.free; \r
 554   OI.free; \r
 555   O.free; \r
 556 <B>end</B>; \r
 557  \r
 558 <I><FONT COLOR="Navy">{ cCamaraMapa }</FONT></I> \r
 559  \r
 560 <I><FONT COLOR="Navy">{** Contructor \r
 561     @param cameraman Objeto Volador en el que estará montada la cámara (obligatorio) \r
 562     @param angulo         Angulo de apertura (visión) de la cámara (default = pi/4) \r
 563     @param maximo         Distancia máxima en la que se considera visible a un objeto (default = 5000) \r
 564     @param distPantalla   Distancia hasta la pantalla de proyección (default = 0). Si tiene el valor por default \r
 565                             o cualquier valor menor o igual a cero, se usa el tamaño del objeto volador}</FONT></I> \r
 566 <B>constructor</B> cCamaraMapa.create(cameraman: cObjetoVolador; angulo: tAngulo; maximo: tLongitud; distPantalla: tLongitud); \r
 567 <B>begin</B> \r
 568   <B>inherited</B> create(cameraman, angulo, 5000<I><FONT COLOR="Navy">{max}</FONT></I>, 1000<I><FONT COLOR="Navy">{min}</FONT></I> ); \r
 569   mSetFiltro( cFiltroMapa.create( Cameraman, angulo, 5000<I><FONT COLOR="Navy">{max}</FONT></I>, mGetRadioMinimo ) ); \r
 570 <B>end</B>; \r
 571  \r
 572 <I><FONT COLOR="Navy">{** Obtiene la proyección del objeto volador en X, Y \r
 573     @param ov  Objeto volador a proyectar. \r
 574     @param x   Valor de la proyección en X. \r
 575     @param x   Valor de la proyección en Y. \r
 576     @param tam Tamaño porcentual del objeto (cuanto mas lejos esta, mas pequeño es). \r
 577                Varia entre 0 y 1}</FONT></I> \r
 578 <B>procedure</B> <A NAME=cCamaraMapa.mProyectar>cCamaraMapa.mProyectar</A>(ov: cObjetoVolador; <B>var</B> x, y, tam: tLongitud); \r
 579 <B>var</B> \r
 580   desplazamiento, \r
 581   posCam, \r
 582   i, \r
 583   vX, \r
 584   vY, \r
 585   v, \r
 586   O, \r
 587   OI: cVector; \r
 588   distMax, \r
 589   tmp: tLongitud; \r
 590 <B>begin</B> \r
 591   <I><FONT COLOR="Navy">// Lo primero que hay que hacer es hallar OI, para eso utilizaremos la siguiente formula: </FONT></I>\r
 592   <I><FONT COLOR="Navy">//  OI = O.(d/D.O) </FONT></I>\r
 593   <I><FONT COLOR="Navy">// En nuetro caso seria: </FONT></I>\r
 594   <I><FONT COLOR="Navy">//  OI =   O . aDistPantalla </FONT></I>\r
 595   <I><FONT COLOR="Navy">//        aCameraman.mGetI . 0 </FONT></I>\r
 596   <I><FONT COLOR="Navy">// Donde O = ov.mGetPosicion - mGetCameraman.mGetPosicion </FONT></I>\r
 597   <B>try</B> <I><FONT COLOR="Navy">// Probamos que el cameraman no este destruido </FONT></I>\r
 598     desplazamiento := mGetCameraman.mGetk.mSetModulo( 3000 ); <I><FONT COLOR="Navy">// Esta 3000 metros alejado del cameraman </FONT></I>\r
 599   <B>except</B> <I><FONT COLOR="Navy">// Si esta destruido cae en una excepcion </FONT></I>\r
 600     on e: EAccessViolation <B>do</B> <B>raise</B> ECameramanDestruido.create; <I><FONT COLOR="Navy">// Creamos una nueva excepcion especial </FONT></I>\r
 601   <B>end</B>; \r
 602   posCam := mGetCameraman.mGetPosicion.mSumar( desplazamiento ); \r
 603   desplazamiento.free; \r
 604   i := mGetCameraman.mGetk.mMultiplicar(-1); \r
 605   O := ov.mGetPosicion.mRestar( posCam ); \r
 606   OI := cVector.create( O ).mMultiplicar( mGetDistPantalla / i.mMultiplicarEsc( O ) ); \r
 607   <I><FONT COLOR="Navy">// Ahora hallamos el vector v que pertenece a la pantalla, que nos dara las nuevas coordenadas respecto de ella. </FONT></I>\r
 608   <I><FONT COLOR="Navy">//  v = OI - d.D </FONT></I>\r
 609   <I><FONT COLOR="Navy">// En nuestro caso: </FONT></I>\r
 610   <I><FONT COLOR="Navy">//  v = OI - ( aCameraman.mGetCoordenadas.mGetI . aDistPantalla ) </FONT></I>\r
 611   v := cVector.create( OI ).mRestar( i.mMultiplicar( mGetDistPantalla ) ); \r
 612   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor -j (que sera nuestro X de la pantalla) </FONT></I>\r
 613   <I><FONT COLOR="Navy">//  Es -j porque tomaremos positivo hacia la derecha. </FONT></I>\r
 614   vX := mGetCameraman.mGetj.mMultiplicar(-1); \r
 615   x := v.mMultiplicarEsc( vX ); \r
 616   <I><FONT COLOR="Navy">// Ahora hallamos su proyeccion en el versor k (que sera nuestro Y de la pantalla) </FONT></I>\r
 617   vY := mGetCameraman.mGetI; \r
 618   y := v.mMultiplicarEsc( vY ); \r
 619   <I><FONT COLOR="Navy">// Ahora hallamos el tamaño proporcional (un numero entre 0 y 1, donde 0 es </FONT></I>\r
 620   <I><FONT COLOR="Navy">//  lo mas lejano y 1 lo mas cercano). Se calcula de la siguiente forma: </FONT></I>\r
 621   <I><FONT COLOR="Navy">// tam = 1  -      |O| - aRadioMinimo </FONT></I>\r
 622   <I><FONT COLOR="Navy">//              aRadioMaximo - aRadioMinimo </FONT></I>\r
 623   <I><FONT COLOR="Navy">// Donde O es el vector posicion respecto de la camara, y el " 1 - xxx ", es porque cuanto mas </FONT></I>\r
 624   <I><FONT COLOR="Navy">//  lejos, menor tiene que ser el tamaño </FONT></I>\r
 625   tmp := O.mGetModulo - mGetRadioMinimo; \r
 626   distMax := mGetRadioMaximo - mGetRadioMinimo; \r
 627   tam := 1 - (tmp / distMax); \r
 628   i.free; \r
 629   posCam.free; \r
 630   v.free; \r
 631   vX.free; \r
 632   vY.free; \r
 633   OI.free; \r
 634   O.free; \r
 635 <B>end</B>; \r
 636  \r
 637 <B>end</B>. \r
 638 </PRE>\r
 639 </BODY>\r
 640 </HTML>\r