src/vista/Camaras.pas

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