MANIPULACIN QUADTREES

Quadtrees puede tambin ser clasificado independientemente de la forma que tenga por la
informacin que contiene. Algunos tipos comunes de quadtrees son:
3.1.- Quadtree de Puntos
El quadtree del punto es una adaptacin de un rbol binario usado para representar datos de
dos dimensiones del punto. Comparte las caractersticas de todos los quadtrees pero es un
rbol verdadero mientras que el centro de una subdivisin est siempre en un punto. Se
procesa la forma del rbol depende de los datos de la orden. Es a menudo muy eficiente en
comparar los puntos de referencias pedidos de dos dimensiones, funcionando generalmente
en tiempo de O (log n.
3.1.2.- Estructura del nodo para un quadtree de puntos
4 Punteros: cuadrante [NW], cuadrante [NE], cuadrante[SW], y cuadrante[SE]
Puntos, del tipo DataPoint, que alternadamente contiene:
-Nombre -(x, y) Coordenadas
Una imagen binaria es normalmente representada como una serie de entradas binarias, es
decir; cada una de las entradas de la serie tiene un valor de 0 o 1. Para guardar la imagen
binaria normalmente se usa la conocida particin quadtree. Para una serie N*N, N<=512 y
N=2i para algn entero positivo i, si las entradas no tienen igual valor, entonces se divide en 4
N/2*N/2 series. Si una serie N/2*N/2 no tiene el mismo valor binario, tal como arriba a la
derecha y abajo a la derecha de la serie N/2*N/2, entonces podemos dividirlo en cuatro
N/4*N/4 formas otra vez. Estas N/4*N/4 formas pueden a su vez tambin, si es necesario
dividirse en 4 N/8*N/8 formas, etc. La particin quadtree es completa cuando toda la forma
esta dividida en series de varios tamaos en las cuales cada serie contiene slo un valor
binario. En lugar de guardar la imagen binaria, slo necesitamos guardar el quadtree con el
cdigo que referente a la imagen de la entrada.
3.2.- Quadtree de la Regin
El quadtree de la regin representa una particin del espacio en dos dimensiones
descomponiendo la regin en cuatro cuadrantes iguales, subcuadrantes, y as sucesivamente
con cada nodo de la hoja que contiene los datos que corresponden a un subregion especfico.
Cada nodo en el rbol tiene exactamente cuatro nios, o no tiene ningn nio (un nodo de la
hoja). Un quadtree de la regin con una profundidad de n se puede utilizar para representar
una imagen que consiste en 2n * pixeles 2n, donde est 0 o 1 cada valor del pixel. Esta
estructura de datos es unidimensional y solo se encuentra en memoria principal. Cada nodo
hijo tiene asociado a l cuatro nodos, representando as los diecisis sub-cuadrantes de dicha
imagen. Una vez formado el Quadtree, los nodos hojas representan la caracterstica de dicho
pxel, que puede ser blanco o negro, si son imgenes monocromticas, dependiendo de la
uniformidad del color de los nodos hijos (si todos sus hijos son de color negro, entonces dicho
nodo ser representado por el color negro). Pero si algn nodo posee nodos hijos con colores
no uniformes, entonces es representado por un nodo gris. Un quadtree de la regin se
puede tambin utilizar como representacin variable de la resolucin de una zona de
informaciones. Por ejemplo, las temperaturas en un rea se pueden almacenar como
quadtree, con cada nodo de la hoja almacenando la temperatura media sobre el subregion
que representa. Si un quadtree de la regin se utiliza para representar un sistema de datos
del punto (tales como la latitud y la longitud de un sistema de ciudades), se subdividen las
regiones hasta que cada hoja contiene a lo mximo un solo punto.
MANIPULACIN PUNTO MEDIO
1. Algoritmo para rectas
El algoritmo toma como parmetros dos puntos, si son flotantes haramos un redondeo
para pasarlos a enteros. Se basa en calcular factores de decisin d y la formula
F (x, y) = Ax + By + C
donde,
A
= Ay =
(
yf

y^
) ,

B = -Ax = -(x/ Xj),
C = bAx
Noten el signo de la B, es negativo y eso es muy importante porque de no tomarlo siempre
se escogeran los pixeles arriba y a la derecha.
El primer paso sera calcular A y B como se vio anteriormente, y d
0
mediante la siguiente
expresin:
d
0
= 2A + B.
El pixel inicial es la coordenada inicial, es decir, (x
0
,y
0
) = (x
i
,y
i
). Posteriormente se entra en
un ciclo que terminara cuando la x
k
(x del pixel actual) sea mayor a la x/.
Dentro de la kesima iteracion del ciclo se hace lo siguiente:

2. Algoritmo para circunferencias centradas en el origen
liste algoritmo se basa en la ecuacin
F(x, y) = x
2
+ y
2
+ r
2
,
y se aprovecha el hecho que el crculo es simetrico respecto a ejes separados por 45
o
, por lo
que slo se calculara la primera de ocho secciones (octantes). Se inicia calculando la primer
coordenada, que ser (x
0
,y
0
) = (0,r). Ademas se calculara el primer factor de decision con la
formula
do =
4

- r

En este punto se inicia un ciclo que terminara cuando x
k
>= y
k
; la kesima iteracin
consiste
de:
Si d
k
_i < 0
dk = dfc_i + 2xfc_i + 3
-
k
1
<= 0
x
k
=
xk
1
+
1
d
k
= d
k 1
+
A

2

-
k
1
> 0

xk =
xk
1
+
1
y
k =
y
k1+ 1
d
k
= d
k 1
+
2(A + B)
x
k
x
k_ 1 + 1
Si d
k- 1
>= 0
d
k =
d
k_1 +
2(x
k_1

yk_ 1
)
+
5

x
k
x
k_ 1 +
1

y
k =
y
k_ 1
1

Esto calcula los pixeles de un octante, con estos resultados se pueden graficar los siete
octantes restantes. Slo se tendra que duplicar el comando de poner un pixel en la pantalla,
es decir, para cada pixel k calculado se graficara
di buj aPi xel (x
k
, y
k
); //pri mer
di buj aPi xel (x
k
, y
k
); //octavo
di buj aPi xel (x
k
, y
k
); / /cuarto
di buj aPi xel (x
k
, y
k
); // qui nto
di buj aPi xel (y
k
, x
k
); //segundo
di buj aPi xel (y
k
, x
k
); //septi mo
di buj aPi xel (y
k
, x
k
); //tercer
di buj aPi xel (y
k
, x
k
); //sexto
En esta version del algoritmo, se redujo el calculo flotante a una operacin por ciclo.
Existe una mejora al algoritmo (viene en el Foley), que usa diferencias parciales, con esto
logramos eliminar completamente el clculo flotante.
3. Algoritmo para elipses centradas en el origen, con radio horizontal mayor o igual al
radio vertical
Al igual que el algoritmo para crculos, se hace uso del hecho que una elipse es
simetrica respecto a sus ejes. As, se calcularn slo los pixeles para el primer cuadrante.
Se basa en la siguiente formula:
F (x, y) = a
2
y
2
+ b
2
x
2
a
2
b
2

Se inicia recorriendo la curva desde x = 0 hacia la derecha, por lo que el primer pixel sera
(x
0
, y
0
) = (0,b). El primer factor de decisin d
0
se calcula con la siguiente frmula:
d0 = a
2
^
1
b^ + b
2

El recorrido usando la coordenada x como gua, es decir, incrementando siempre en
1, se terminar cuando a
2
(y 2) > b
2
(x + 1).
La kesima iteracin del PRIMER ciclo tiene los siguientes pasos:
Si d
k1
< 0
dk = dk1 + b
2
(2xk1 + 3)
x
k
= x
k 1
+ 1

Si d
k1
>= 0
d
k =
d
k1 +
b2(2x
k1 +
3)
+
2a2(x
k1

yk1
)

x
k
= x
k 1
+ 1

y
k =
y
k1
1

Cuando se termina de ejecutar el primer ciclo, se calcula un factor de decision inicial
nuevo d
0
siguiendo la formula inicial F(x + 1/2,y 1). Ntese que ahora se est tomando
como coordenada gua a la y, y se ir disminuyendo en uno cada vez.
d
0
= b
2
^x +
1
^ + a
2
(y 1)
2

a
2
b
2
*(x,y) son las coordenada finales del ciclo anterior.
Se inicia un segundo ciclo, usando como coordenadas iniciales las coordenada finales
del ciclo anterior, este ciclo se termina cuando y == 0. Los pasos a seguir para la kesima
iteracion en esta parte del algoritmo sern:
Si d
k1
< 0
dk = dk1 + 2b
2
(xk1 + 1) + a
2
(2yk1 + 3)
y
k =
y
k1
1

x
k
= x
k 1
+ 1

Si d
k1
>= 0
d
k =
d
k1 +
a2( 2
yk 1 +
3)

y
k =
y
k1
1

Finalmente, para graficar los pixeles de la elipse se cuadruplicara la informacion, es decir,
di buj aPi xel (x
k
, y
k
); //pri mer
di buj aPi xel (x
k
, y
k
); //cuarto
di buj aPi xel (x
k
, y
k
); //segundo
di buj aPi xel (x
k
, y
k
); //tercer



ALGORITMOS LINEALES
Un al gori tmo es l a descri pci n unvoca y f i ni ta de l a secuenci a de acci ones a
ej ecutar para resol ver un probl ema.
Esta definicin merece ser analizada detenidamente.
'es l a descri pci n.. . de l a secuenci a de acci ones' : vale decir que el algoritmo no hace,
sino que describe (relata, cuenta) lo que se debe hacer.
' unvoca' : esto significa que luego de ejecutada una determinada accin, la siguiente est
indicada sin ambigedades. Si despus de ejecutada una accin existen dos o ms que
podran ejecutarse y no existe un criterio para seleccionar la que corresponde, no es un
algoritmo.
' f i ni ta' : se refiere a que la secuencia de acciones debe finalizar en algn momento, cuando
el problema est resuelto. Una secuencia de acciones que podra llegar a ejecutarse
indefinidamente, no es un algoritmo.
' para resol ver un probl ema' : o sea que antes de desarrollar un algoritmo, debemos
conocer el problema que se quiere resolver, es decir, debemos haber hecho la especificacin
del mismo.
Los algoritmos pueden expresarse de distintas maneras segn quin vaya a ejecutar las
acciones: una gua de costura, una receta de cocina, una hoja de ruta, son algoritmos
desarrollados utilizando lenguajes escritos y/o grficos orientados a las personas que los
ejecutarn.
Un algoritmo que ser ejecutado en una computadora deber ser escrito en un lenguaje de
programacin, pero en la etapa de desarrollo se dispone de dos alternativas: el pseudocdigo
y los PSD (program structure diagram) tambin llamados estructogramas.
El pseudocdigo (pseudo: que parece) es un subconjunto del lenguaje natural que utiliza muy
pocas palabras, cada una con un significado nico, y una sintaxis estricta seimilar a los
lenguajes de programacin estructurados:



El PSD (program structure diagram), es un modo grfico de representar un algoritmo. En l,
cada accin simple se representa como un rectngulo; una secuencia de acciones ser a su
vez un rectngulo formado por otros menores (las acciones compuestas que veremos ms
Palabra Significado Pascal C
Comienzo
Delimitador que indica que se
inicia una secuencia de acciones
Begin
{

Fin Delimitador que indica que
finaliza una secuencia de
acciones.
End
}

Leer (<ident>) Accin de obtener el valor de una
variable (magnitud simbolizada
con un identificador)
Read
Readln
f

t

e

g

Escribir (<ident>) Accin de enviar a la salida el
valor de una variable.
Write
Writeln
printf
<ident> se reemplaza
por el id
entificador. Ej.: Leer(x);
Existen tambin algunos smbolos especiales:
Smbolo Uso Pascal C
;
Indica la finalizacin de
una accin.
Separa una accin de
la siguiente.
Indica la finalizacin
de una accin.
<ident> <expr> Asigna a la variable de la
izquierda el valor de la
expresin que aparece a
la derecha.
<ident> := <expr> <ident> = <expr>
En Pascal se coloca despus del ltimo end para indicar el fin del
cdigo.
Ejemplo: El problema SupTrian consiste en el clculo de la superficie de un tringulo.
Especificacin Algoritmo
1. SupTrian. Comienzo
2. Calcular la superficie de un tringulo. leer(b);
3. b(base), h(altura): n
os
reales. leer(h);
4. s(superficie): n
o
real. s b h / 2;
5. s = b h / 2 escribir(s);
Fin.

adelante tienen otras representaciones).
leer(b)
leer(h) s b h /
2
escribir(s)
Aparentemente, el PSD no agrega nada al pseudocdigo, pero responde a una norma
internacional (ISO/IEC ....) por lo que pueden ser intepretados por cualquier persona en
cualquier lugar del mundo, la cual podr codificarlo en


Programa en Pascal Programa en C
Program SupTrian; var b, h, s: real;
begin readln(b); readln(h); s := b * h / 2;
write(s); end.
#include <stdio.h> main()
{
float b, h, s;
s = b * h / 2; scanf("%e", b); scanf("%e", h);
prinf("%e\n", s);
}
MANIPULACIN RECTNGULOS

Si ests desarrollando un juego, lo ms probable es que necesites detectar si se produce o no
una colisin. En algunos frameworks(Negro) de programacin de videojuegos existen
mtodos predefinidos para comprobar si [las colisiones] se dan o no (por ejemplo en pygame).
En mi caso, estoy desarrollando un juego para Android (Rojo) y no quiero usar ningn
framework (adems de que no s si existe alguno) por lo tanto, tengo que programar mi
propio mtodo.
Vamos con la teora. Empezaremos viendo como se puede detectar una colisin entre dos
lneas (imaginemos que estamos en una dimensin) .

Bueno, en la imagen superior podemos ver dos lneas que vamos a asumir que estn en una
dimensin y por lo tanto chocan. Esas lneas estn descritas por los puntos A -> B y C->D . A
partir de este dibujo podemos asumir que si A <C < B las lneas chocan. Pero, qu pasa si
el dibujo es as?

Lo que pasa es que la condicin A < C < B no se cumple en este caso y de todas formas
podemos comprobar que s hay una colisin. Por lo tanto, debemos buscar una condicin ms
genrica que extienda a la anterior y fcilmente podemos ver que esa condicin es : A < D <
B . Finalmente la condicin final es :
Si (A<C<B o A<D<B) hay colisin, en cualquier otro caso no hay colisin.
Extendiendo el caso a 2 dimensiones ya no hay mucho que pensar. Obviamente no podemos
usar la condicin anterior porque : 1) hay el doble de puntos y 2) hay el doble de dimensiones
(xD). No hay que ser un genio matemtico para descubrir que lo que hay que hacer es
aplicar la condicin anterior en las dos dimensiones del espacio que usamos.

Hay podemos ver un par de rectngulos (bueno, son cuadrados pero no importa) definidos
por tres puntos, el primero A, B y C y el segundo por tres puntos A, B y C. El otro punto no
importa para determinar una posible colisin. Bueno, lo primero sera comprobar si interfieren
en el eje X . Aqu se usara la condicin anterior : A< A < B o A< B < B. Luego, habra que
comprobar si interfieren en el eje Y, y aqu es donde viene lo nuevo (es lo mismo de antes
solo que cambiando el eje). La condicin final para detectar una colisin entre dos rectngulos
es :
Si ((Ax < Ax < Bx o Ax < Bx < Bx) y ( Ay < Ay < Cy o Ay < Cy < Cy)) hay colisin, en
cualquier otro caso no hay colisin.
Una posible implementacin de esta solucin en java es esta :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Rectangulo {

public int[] A,B,C ; // Aqui son guardados los puntos, A[0] = Ax y A[1] = Ay.

public Rectangulo(int[ ] a, int[ ] b, int[ ] c)

{

A = a;

B = b;

C = c;

}

public Boolean hayColision(Rectangulo R) {

19
20
21
22
23
24
25
26
27
if (((A[0] < R.A[0] && R.A[0]< B[0]) || (A[0] < R.B[0] && R.B[0] < B[0])) && (( A[1] <
R.A[1] && R.A[1] < C[1] ) || (A[1] < R.C[1] && R.B[1] < C[1]))

return true;

return false;

}

}





MANIPULACIN DE VOLMENES
Para el al gori tmo de vol umen que ti ene para programar
el volumen es lo ms sencillo es el de un primas
Volumen=(area de la base )(altura)
pero
area de la base=*r^2
por ser un circulo su base entonces queda volumen=*r^2*altura ahora el area
si deshlosamos el cilindro en 2 dimenciones te fijaras que son 2 circulos con la parte central
del cilindro entonces tendriamos
Area=2(area del circulo)+area del cilindro
pero area del cilindro=area del rectangulo=b*h
pero la base por ser un circulo es 2*r longitud de circuferencia entonces quedaria
Area=2*r^2+2*r
Area=2r(r+1)
volumen=*r^2*altura