martes, 28 de febrero de 2012

PRESENTACION-EXPLICACION

TRANSFORMACIONES GEOMÉTRICAS BASICAS EN LOS SISTEMAS DE GRAFICACIÓN:
Todo cuerpo representado en un plano puede sufrir varios tipos de transformaciones en su estructura. Las transformaciones de tipo básico, como pueden ser la translación, Escalación y rotación de objetos.

Un objeto definido se construye a partir de una serie de puntos coordenados, desde los cuales se pueden aplicar diversas fórmulas para realizar un cambio de la figura.

Traslación, Rotación, Escalación

Traslación
·         Una traslación es el movimiento en línea recta de un objeto de una posición a otra.

·         Movimiento de una figura, sin rotarla ni voltearla. "Deslizar".

·         Se aplica una transformación en un objeto para cambiar su posición a lo largo de la trayectoria de una línea recta de una dirección de coordenadas a otra. Convertimos un punto bidimensional al agregar las distancia de traslación, tx y ty a la posición de coordenadas original (x, y) para mover el punto a una nueva posición (x’, y’) El par de distancia de traslación (tx’ ty’) se llama vector de traslación o vector de cambio.




ROTACION
Se aplica una rotación bidimensional en un objeto al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano de x y. Para generar una rotación especificamos un ángulo de rotación y la posición Xr’ Yr’ del punto de rotación o punto pivote en torno al cual se gira el objeto.




ESCALACION 2D Y 3D
2D
Nos permitirá cambiar las dimensiones de un objeto.
Requiere 2 parámetros:
             x  = Factor de escalación en X
             y  = Factor de escalación en Y
             x,y > 1    Aumenta la dimensión
             x,y < 1    Disminuye la dimensión    
             x,y = 1    Se mantiene la dimensión



3D
Nos permitirá cambiar las dimensiones de un objeto.
Requiere 3 parámetros:
            x  = Factor de escalación en X
            y  = Factor de escalación en Y
            z  = Factor de escalación en Z
     x,y,z > 1    Aumenta la dimensión
     x,y,z < 1    Disminuye la dimensión    
     x,y,z = 1    Se mantiene la dimensión

REPRESENTACION MATRICIAL
  • Facilita el cómputo de las transformaciones a simples multiplicaciones matriciales.
  • Se requiere representar las coordenadas en forma homogénea.
(x,y) se representa como (x,y,1)
(x,y,z) se representa como (x,y,z,1)




COORDENADAS HOMOGENEAS
Las coordenadas homogéneas son un instrumento usado para describir un punto en espacio proyectivo.
En coordenadas homogéneas, todo punto bidimensional está definido por tres coordenadas. De tal modo que un punto de dimensiones x, y, se lo representa por la terna: x / w, y / w, w.
Matemáticamente, las coordenadas x y y se hallan dividiendo los dos primeros números entre el tercero, respectivamente.

2D
En dos dimensiones, su valor se puede encontrar más fácilmente si w = 1, por simplificación.

3D
En tres dimensiones, suele ocurrir lo mismo w = 1.
Básicamente, se trata de ampliar el plano euclídeo (en el caso bidimensional) al plano proyectivo, es decir, incluirle los puntos impropios o del infinito.

RESUMEN


TRANSFORMACIONES GEOMETRICAS
El estudiante conocerá y aplicará las principales transformaciones geométricas sobre objetos en 2D y 3D.

TRANSFORMACIONES BIDIMENCIONALES
Se aplica una traslación en un objeto para cambiar su posición a lo largo de la trayectoria de una línea recta de una dirección de coordenadas a otra.
La traslación es una transformación de cuerpo rígido que mueve objetos sin deformarlos.
Los polígonos se trasladan al sumar el vector de traslación a la posición de coordenadas de cada vértice y se vuelve a generar el polígono utilizando un nuevo conjunto de coordenadas y vértices y las especificaciones actuales de los atributos.

ROTACION
Se aplica una rotación bidimensional en un objeto al cambiar su posición a lo largo de la trayectoria de una circunferencia en el plano de x y. para generar una rotación, especificamos un ángulo de rotación θ y la posición (xr, yr) del punto de rotación (o punto pivote) en torno al cual se gira el objeto.
Los valores positivos para el ángulo de rotación definen rotaciones en sentido opuesto a las manecillas del reloj alrededor del punto pivote y los valores negativos giran los objetos en la dirección del reloj.

ESCALACION
Una transformación de escalación altera el tamaño de un objeto. Se puede realizar esta operación para polígonos al multiplicar los valores de coordenadas de cada vértice por los factores de escalación para producir las coordenadas transformadas.
Podemos controlar la localización de unos objetos escalado al seleccionar una posición llamada punto fijo, que debe permanecer sin cambios después de la transformación de escalación.

 COORDENADAS HOMOGENEAS Y REPRESENTACION MATRICIAL
En las aplicaciones de diseño y de creación de imágenes, realizamos traslaciones, rotaciones y escalaciones para ajustar los componentes de la imagen en sus posiciones apropiadas. En este tema consideramos cómo se pueden volver a formular las representaciones de la matriz de modo que se pueden procesar de manera eficiente esas secuencias de transformación.
Es posible expresar cada una de las transformaciones básicas en la forma de matriz general con las posiciones de coordenadas P y P’ representadas como columnas de vector.
Como escalación seguida por rotación y luego traslación, debemos calcular las coordenadas transformadas un paso a la vez. Primero, se escalan las posiciones de coordenadas, después se giran estas coordenadas escaladas y por último se trasladan las coordenadas giradas.
Un planteamiento más eficiente combinaría las transformaciones de manera que se obtengan las coordenadas finales directamente a partir de las coordenadas iniciales para eliminar el cálculo de coordenadas intermedias.
Para transformaciones geométricas bidimensionales, seleccionamos el parámetro homogéneo h como cualquier valor no cero. Así, existe un número finito de representaciones homogéneas equivalentes para cada punto de coordenadas (x, y).
Una opción conveniente consiste en sólo establecer h = 1. Entonces, se representa cada posición bidimensional con las coordenadas homogéneas (x, y, 1).
Las representaciones de matriz o representaciones matriciales son métodos estándar para implementar transformaciones en sistemas de gráficas. En muchos sistemas, las funciones de rotación y escalación producen transformaciones con respecto del origen de las coordenadas.

COMPOCICION DE TRASFORMACIONES BIDIMENSIONALES
Con las representaciones de matriz del tema anterior, podemos establecer una matriz para cualquier secuencia de transformaciones como una matriz de transformación compuesta al calcular el producto de la matriz de las transformaciones individuales. La creación de productos de matrices de transformación a menudo se conoce como concatenación o composición de matrices.

ROTACION PUNTO PIVOTE GENERAL
Con un paquete gráfico que sólo ofrezca una función de rotación para girar objetos con respecto del origen de las coordenadas, podemos generar casi cualquier punto pivote seleccionado (xr, yr) al realizar la siguiente secuencia de operaciones de traslación-rotación-traslación:
1. Traslade el objeto de modo que se mueva la posición del punto pivote al origen de las coordenadas.
2. Gire el objeto con respecto del origen de las coordenadas.
3. Traslade el objeto de manera que se regrese el punto pivote a su posición original.

ESCALACION DEL PUNTO FIJO GENERAL
1. Traslade el objeto de modo que el punto fijo coincida con el origen de lascoordenadas.2.
2. Escale el objeto con respecto del origen de las coordenadas
3. Utilice la traslación inversa del paso 1 para regresar el objeto a su posición original.

TRANSFORMACION VENTANA AEREA DE VISTA
Algunos paquetes gráficos permiten que el programador especifique coordenadas de primitivas de salida en un sistema de coordenadas de mundo de punto flotante, usando las unidades que sean relevantes para el programa de aplicación: angstroms, micras, metros, millas, años luz, etcétera. Se emplea el término de mundo porque el programa de aplicación representa un mundo que se crea o presenta interactivamente para el usuario:
Como las primitivas de salida se expresan en coordenadas de mundo, hay que indicar al paquete de subrutinas gráficas cómo establecer la correspondencia entre las coordenadas de mundo y las coordenadas de pantalla (usaremos el término específico coordenadas de pantalla para relacionar este análisis específicamente con SRGP, pero podrían usarse dispositivos de impresión, en cuyo caso sería más apropiado el término coordenadas de dispositivo).
El modificador coordenadas de mundo se emplea con ventana para subrayar que no se trata de una ventana de administrador de ventanas, un concepto distinto y más reciente que por desgracia tiene el mismo nombre. Este modificador se omitirá cuando no exista ninguna ambigüedad con respecto al tipo de ventana que se trate.
Un administrador de ventanas podría establecer la correspondencia entre el lienzo 0 de SRGP y una ventana menor que la pantalla completa; en este caso no siempre estará visible todo el lienzo ni toda el área de vista.
La ventana, especificada por sus vértices inferior izquierdo y superior derecho, se traslada primero al origen de las coordenadas de mundo. Después se escala el tamaño de la ventana para que sea igual al tamaño del área de vista. Por último se usa una traslación para colocar un área de vista.

TRANSFORMACIONES DE COMPOSICION GENERAL Y DE EFICIENCIA COMPUTACIONAL
Una transformación bidimensional general, que representa una combinación de traslaciones, rotaciones y escalaciones se puede expresar como Los cuatro elementos rs ij son los términos multiplicativos de rotación -escalación en la transformación que implican sólo ángulos de rotación y factores de escalación. Los elementos trs x y trs  y son los términos de traslación que contienen combinaciones de distancias de traslación, coordenadas de punto pivote y de punto fijo, así como de ángulos de rotación y parámetros de escalación.
Dado que los cálculos de la rotación requieren evaluaciones trigonométricas y varias multiplicaciones para cada punto que se transforma, la eficiencia computacional puede tornarse una consideración importante en las transformaciones de rotación. En animaciones y otras aplicaciones que implican muchas transformaciones repetidas y ángulos de rotación pequeños, podemos utilizar aproximaciones y cálculos repetitivos para reducir los cálculos en las ecuaciones de transformación compuesta.
Cuando el ángulo de rotación es pequeño, se pueden sustituir las funciones trigonométricas con valores de aproximación con base en los primeros términos de sus expansiones de series de potencia.

REPRESENTACION MATRICIAL DE TRANSFORMACIONESTRIDIMENSIONALES
Así como las transformaciones bidimensionales se pueden representar con matrices de3 X 3 usando coordenadas homogéneas, las transformaciones tridimensionales se pueden representar con matrices de 4 X 4, siempre y cuando usemos representaciones de coordenadas homogéneas de los puntos en el espacio tridimensional.
La transformación de un punto a esta forma se denomina homogeneización, igual que antes. Además los puntos cuya coordenada W es cero se llaman puntos en el infinito. También existe una interpretación geométrica. Cada punto en el espacio tridimensional se representa con una línea que pasa por el origen en el espacio de cuatro dimensiones, y las representaciones homogeneizadas de estos puntos forman un sub-espacio tridimensional de un espacio de cuatro dimensiones definido por la ecuación W = 1.

COMPOCICION DE TRANSFORMACIONES TRIDIMENCIONALES
Las transformaciones geométricas básicas son la traslación, la rotación y la escalación. La traslación mueve un objeto con una trayectoria en línea recta de una posición a otra. La rotación mueve un objeto de una posición a otra a lo largo de una trayectoria circular sobre un eje de rotación específico. Para aplicaciones bidimensionales, la trayectoria de rotación se encuentra en el plano xy sobre un eje que es paralelo al eje z.
Las transformaciones de cambio de escala cambian las dimensiones de un objeto con respecto a una posición fija. Podemos expresar las transformaciones bidimensionales como operadores de matrices de 3 por 3 y las transformaciones tridimensionales como operadores de matrices de 4 por4, de tal forma que esas secuencias de transformaciones pueden concatenarse dentro de una matriz compuesta. En general, podemos representar tanto transformaciones bidimensionales como tridimensionales con matrices de 4 por 4.

lunes, 27 de febrero de 2012

GRAFICACION 2D

TRAZO DE LÍNEAS RECTAS

Las líneas en OpenGL son en realidad segmentos acotados, en lugar de la idea matemática de rectas infinitas. Su definición viene dada por la especificación del valor de sus dos vértices extremos.

Consideremos una línea recta que pasa por dos puntos P1=[20, 20] y [25,20]. Podemos calcular la línea recta que pasa por estos puntos como

(y-y1) = (y2-y1)*(x-x1)/(x2-x1)

Sustituyendo los valores tenemos

(y-20) = (21-20)*(x-20)/(25-20)

Finalmente tenemos

y = 0.2 x + 16

Podemos calcular los valores utilizando el siguiente código

void linea(int x0, int y0, int x1, int y1)

{           int x;

            float dy, dx, y, m;

            dy = y1 - y0;

            dx = x1 - x0;

            m = dy/dx;

            y = y0;

            for(x = x0; x <= x1; x++)

            {           escribir_pixel(x, (int) floor(y+0.5) );

                        y +=m;            }  }

Note que se suma 0.5 y se calcula la parte entera para redondear la solución.

REPRESENTACION Y TRAZO DE POLIGONOS

OpenGL maneja polígonos correctamente siempre y cuando sean simples y convexos. Si ese no es el caso, OpenGL dibuja cosas raras.

Además en algunas ocasiones se quiere especificar el vector normal del plano en el cual se encuentra el polígono. Dicho vector normal se necesita p.e. para algoritmos de visualización avanzada (``Phong shading'').

Cuando se escriben aplicaciones gráficas nos enfrentamos con el problema siguiente: desde alguna fuente ``vienen'' listas de puntos (o bien de otro programa, o bien de un fichero, o bien de modo interactivo) y hay que interpretar las listas como polígonos, es decir, hay que verificar si las listas cumplen la definición de especificar polígonos simples y convexos. Si ese no es el caso, a lo mejor se pueden ``corregir'' las listas. (Programas con tal propiedades se llama robustos y tolerantes.)

Entonces (en el caso de mera visualización con OpenGL):

Se puede eliminar puntos múltiples consecutivos en la lista.

Se puede intentar calcular el plano en el cual se encuentran más o menos los puntos del polígono (eso no es tan trivial).

En dicho plano, es decir, una vez corregidos los puntos hasta que se encuentren exactamente en el plano, se puede verificar si el polígono es simple y convexo (eso es algo bastante fácil).

Si no es así, se podría subdividir el polígono en partes simples y convexos para seguir trabajando después con las partes sin problemas (este paso no lo vamos a realizar en estas prácticas).

Antes de dedicarnos a los detalles, dibujamos polígonos con OpenGL asumiendo que la lista de puntos cumple la definición.

Siempre que se quiera dibujar un objeto de OpenGL (en este caso unos polígonos, antes vimos puntos y segmentos), hay que decírselo de antemano con la función

glBegin()

La lista de puntos se define con consecutivas llamadas a

glVertex*()

y se termina el trabajo con

glEnd()

En lugar de dibujar polígonos rellenados, OpenGL puede dibujar, o bien solo las esquinas o bien solo los segmentos del borde. Eso se realiza con la función

glPolygonMode()

a la cual hay que pasar también cuál de las dos posibles caras del polígono se quiere pintar.

Además se pueden llenar los polígonos con patrones que no detallamos por el momento.

glEnable()

glPolygonStipple()



ALGORITMO DDA PARA GENERACIÓN DE LÍNEAS

El algoritmo de Bresenham es un algoritmo creado para dibujar rectas en los dispositivos de gráficos rasterizados, como por ejemplo un monitor de ordenador, que determina qué pixeles se rellenarán, en función de la inclinación del ángulo de la recta a dibujar.

Este Algoritmo sirve para Generar Una Línea Recta , y Para eso Hace Uso de La pendiente Y de los Incrementos en X, Y

El Código es el Siguiente:

void DDA(int x_0,int y_0, int x_fin, int y_fin){

glClear ( GL_COLOR_BUFFER_BIT );
glPointSize(3.0);
glScalef(4.0, 4.0, 2.0);

glBegin(GL_POINTS);
glVertex2i(x_0,y_0);

int vx=(int)fabs(x_fin-x_0);
int vy=(int)fabs(y_fin-y_0);
int dx,dy;
int m = (int)(y_fin-y_0)/(x_fin-x_0);

if(m==1)m++;
if(m==0)m=-1;

if(m>0&&m<1){
if(x_0<x_fin){
dx=1;
dy=m;
}else{
dx=-1;
dy=-m;
}
}
else
if(m>0&&m>1){
if(m>1){
if(x_0<x_fin){
dy=1;
dx=(int)1/m;

}else{
dy=-1;
dx=(int)-1/m;

}

}else

if(m<0&&fabs(m)<1){

if(x_0>x_fin)
{
dx=-1;
dy=-m;

}else
{
dx=1;
dy=-m;
}

}

else{

if(x_0>x_fin){
dy=1;
dx=-1/m;

}
else {
dy=-1;
dx=1/m;

}

}

if(m>0&&m<1){
for(int i=1;i<=vx;i++)
{
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;

}
}
else
if(m>0&&m>1){
for(int i=1;i<=vy;i++){
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;}

}else

if(m<0&&fabs(m)<1){

for(int i=1;i<=vx;i++)
{
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;

}

}

else{

for(int i=1;i<=vy;i++){
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;
}
}
}
glEnd();
glFlush();
}

ALGORITMO DE BRESENHAM PARA TRAZAR LÍNEAS

El algoritmo de Bresenham es un algoritmo que determina los puntos en un mapa de bits de n dimensiones que deben ser trazados con el fin de formar una aproximación a una línea recta entre dos puntos dados.

Es comúnmente usado para dibujar líneas en una pantalla de ordenador, ya que utiliza sólo adición de enteros, la resta y desplazamiento de bits, que son operaciones muy barato en las arquitecturas de ordenador estándar. Es uno de los primeros algoritmos desarrollados en el campo de gráficos por ordenador. Una extensión menor a la del algoritmo original también se ocupa de dibujar círculos.



ALGORITMO DE BRESENHAM PARA TRAZAR CIRCUNFERENCIAS

En graficación, el algoritmo de “mid point circle” es un algoritmo utilizado para determinar los puntos necesarios para dibujar un círculo.

El algoritmo es una variante del algoritmo de la línea Bresenham, por lo que es a veces conocido como algoritmo de círculo Bresenham, aunque en realidad no inventada por Bresenham. El algoritmo comienza en consecuencia con el círculo de la ecuación

x2+y 2=r2.

Así, el centro del círculo se encuentra en (0,0). Consideramos que sólo la primera el octante primera y trazar una curva que comienza en el punto (r,0) y hacia arriba los ingresos ya la izquierda, llegando al ángulo de 45 °. La dirección “rápida” aquí es la dirección vertical. El algoritmo hace siempre un paso en la dirección positiva (hacia arriba), y de vez en cuando también tiene que hacer un paso en la "lenta" la dirección, la dirección x negativa. De la ecuación de un círculo se obtiene la ecuación transformada

x2+y 2-r2= 0, donde r2 se calcula sólo una sola vez durante la inicialización

jueves, 23 de febrero de 2012

CUBO 2D

CALCULOS PARA REALIZAR EL CUBO
 
CODIGO
#include <GL/glut.h>
#include <stdlib.h>
void myinit(void)
{

glClearColor(0.0, 1.0, 0.0, 1.0);
glColor3f(0.0, 0.0, 1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 400.0, 0.0, 400.0);
glMatrixMode(GL_MODELVIEW);
}

void display( void )
{
typedef GLfloat point2[2];
point2 vertices[8]={{100.0,100.0},{200.0,100.0},{200.0,200.0},{100.0,200.0},{150.0,186.6025},{250.0,186.6025},{250.0,286.6025},{150.0,286.6025}};
glClearColor(1.0, 1.0, 1.0, 0.0);

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_LINES);
glVertex2fv(vertices[0]);
glVertex2fv(vertices[1]);
glVertex2fv(vertices[0]);
glVertex2fv(vertices[3]);
glVertex2fv(vertices[1]);
glVertex2fv(vertices[2]);
glVertex2fv(vertices[2]);
glVertex2fv(vertices[3]);
glVertex2fv(vertices[4]);
glVertex2fv(vertices[5]);
glVertex2fv(vertices[5]);
glVertex2fv(vertices[6]);
glVertex2fv(vertices[6]);
glVertex2fv(vertices[7]);
glVertex2fv(vertices[4]);
glVertex2fv(vertices[7]);
glVertex2fv(vertices[3]);
glVertex2fv(vertices[7]);
glVertex2fv(vertices[2]);
glVertex2fv(vertices[6]);
glVertex2fv(vertices[0]);
glVertex2fv(vertices[4]);
glVertex2fv(vertices[1]);
glVertex2fv(vertices[5]);
glEnd();
glFlush();
}
void main(int argc, char** argv)
{

glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Cubo en 2 Dimensiones <60");
glutDisplayFunc(display);
myinit();
glutMainLoop(); }

RESULTADO

martes, 14 de febrero de 2012

EJEMPLOS DE FRACTALES

INTRODUCCION
En alguna ocasión he comentado sobre los fractales que son usado por los artistas gráficos para generar espectaculares ilustraciones, de gran belleza. Su uso entre los  diseñadores es cada vez más popular, y tienen una buena razón para entrar en este tema tan interesante, ya que gracias a la existencia de programas como Apophysis, ese tipo de diseño resulta más sencillo
(cosas sencillas )

Ejemplos de fractales
Hay multitud de objetos que presentan comportamiento fractal; son muy variados, muy diferentes entre sí. Es difícil clasificarlos, pero podemos hacer una clasificación de los mecanismos que los generan. Algunos fractales pueden ser generados mediante varios de los métodos descritos, pero tras todos esas formas siempre se esconde la realimentación y la iteración:


1.   ESCAPE
Es un fractal de Mandelbrot, y se genera mediante un algoritmo de escape. Para cada punto se calculan una serie de valores mediante la repetición de una formula hasta que se cumple una condición, momento en el cual se asigna al punto un color relacionado con el número de repeticiones. Los fractales de este tipo precisan de millones de operaciones, por lo cual sólo pueden dibujarse con la inestimable ayuda del ordenador.
Una característica especial del fractal Mandelbrot (y de otros tipos afines) es la de generar un infinito conjunto de fractales, ya que por cada punto se puede generar un fractal tipo Julia, que no es sino una ligera modificación en la fórmula del Mandelbrot.



2.   FUNCION ITERADA
El sistema de funciones iteradas (IFS) es un método creado por M. Barnsley, basándose en el principio de auto semejanza. En un fractal IFS siempre se puede encontrar una parte de la figura que guarda una relación de semejanza con la figura completa. Esa relación es a menudo muy difícil de apreciar, pero en el caso del helecho es bastante clara: cualquier hoja es una réplica exacta de la figura completa.


3.   LINDENMAYER Y SIERPINSKI
La idea es sencilla y antigua. Un triángulo en el que se aloja otro, uniendo los puntos medios de cada uno de sus lados. Esto se repite con todos y cada uno de los triángulos formados que tengan la misma orientación que el original, y así sucesivamente.
El triángulo de Sierpinski es uno de los pocos fractales que se puede dibujar con exactitud sin ayuda de un ordenador, siguiendo las instrucciones anteriores. En área fractal, el artículo Koch y Sierpinski detalla más aspectos de este tipo de curvas.


4.   ORBITAS CAOTICAS
Cuando estudiamos en el colegio el sistema solar nos dijeron que los planetas describían órbitas elípticas. Como en todo, eso es cierto sólo hasta cierto nivel. El atractor de Lorenz se consigue llevando esa incertidumbre hasta el extremo. Básicamente está formada por un hilo infinitamente largo que va describiendo una trayectoria tridimensional acercándose y alejándose de dos puntos de atracción.


5.   ALEATORIOS Y CELULARES
Estructuras como el plasma o las imágenes de difusión dependen en cierta medida del azar, por lo cual son únicas e irrepetibles.
Los autómatas celulares están en el otro extremo. Funcionan con sencillas reglas que colorean zonas a partir del color de las adyacentes. Pese a que en principio pueda parecer que las imágenes conseguidas con este método vayan a ser sencillas y simétricas. 


(ARRAKIS, 1999)


PROCESOS ESTOCASTICOS
Es un concepto matematico que sirve para caracterizar una sucesion de variables aleatorias que evolucionan en funcion de otra variable.
ENLACE DEL BLOG