GRAFICACION --- Benjamin Cruz Pineda ---

domingo, 26 de mayo de 2013

viernes, 24 de mayo de 2013

jueves, 18 de abril de 2013

Unidad II - Graficos 2D

ACTIVIDAD *

- circunferencia: Linea cerrada de formato curvo y apariencia plana en la cual los puntos resultan equidistantes del punto central que se localiza en el mismo plano.

ACTIVIDAD *
Algoritmo DDA para generación de líneas

Este algoritmo es más eficaz que el uso directo de la ecuación de la recta, ya que en etapas unitarias de 'x' o de 'y' y vamos calculando el valor del siguiente pixel asociado a un punto de la recta.

El algoritmo consiste en:

- Para m<1
Podemos eliminar la multiplicación de la siguiente manera:
Sabemos que yi= mxi + b Entonces yi+1= mxi+1 + b = … ⇒yi+1= yi+ m ∆x
Por lo tanto, como ∆x=1, llegamos a la fórmula final: yi+1= yi+ m

Cada pixel se calcula en función del anterior y no hace falta calcular b.

- Para m>1
Si m>1 falla pues quedan huecos entonces intercambiamos las variables x e :
Sabemos que xi= (1/m) (yi –b) . Entonces: xi+1= (1/m)yi+1 -b/m = … ⇒xi+1= xi+ ∆y/m
Por lo tanto, como ∆y=1, llegamos a la fórmula final: xi+1= xi+ 1/m

Algoritmo de Bresenham para trazar líneas

Partamos del pixel (x k, yk) con pendiente 0<m<1, y hay que decidir entre dos pixeles: (xk+1, yk) o (xk+1, yk+1). El algoritmo debe decidir cuál de los dos pintar y se hace de la siguiente manera:

- Calculamos la distancia vertical entre el centro de cada pixel y la línea real:
d2= (yk + 1 –y) = yk + 1 -m (xk+ 1) -b
d1= y –yk= m (xk+ 1) + b -yk

- La diferencia entre ambas constantes nos ayudará a decidir qué pixel pintar:
d1–d 2= 2m (xk+ 1) –2yk+ 2b –1

- Multiplicando por ∆x eliminamos el parámetro m, que no es entero:
pk= ∆x (d1–d 2) = 2 ∆y xk–2 ∆x yk+ C, donde C = 2 ∆y + ∆x (2b –1)

- Como ∆x > 0, el signo de pk coincide con el de la diferencia (d1–d 2), y por tanto:

Si p k> 0 y d1> d2 entonces hay que pintar el pixel (xk+1, yk+1)
Si p k< 0 y d1< d2 entonces hay que pintar el pixel (xk+1, yk)

- La gran ventaja es que puede calcularse pk+1a partir del anterior pk, utilizando solamente aritmética entera:
pk+1= … = pk+ 2 ∆y –2 ∆x (yk+1–y k) ... donde (yk+1–y k) es 0 ó 1 dependiendo del signo de pk

ACTIVIDAD *

BRESENHAM

  #include "stdafx.h"

  #include <GL/glut.h>

  #include <stdlib.h>

  #include <math.h>

  typedef line {

      float x, y;

  }Punto;

  Punto vertices[2];

  int numP=0;

  int screen[640][480];

  void inicializar () {

      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

      //numP = 0;

  int my_round (float n) {

      return floor(n + 0.5);

  void limpiaScreen() {

      int i, j;

      for (i = 0; i < 640; i++) {

          for (j = 0; j < 480; j++) {

              screen[i][j] = 0;

  void dimensn (int ancho, int alto) {

      glViewport(0, 0, ancho, alto);

      glMatrixMode(GL_PROJECTION);

      glLoadIdentity();

      gluOrtho2D(0.0, (double)ancho, 0.0, (double)alto);

  void teclado (unsigned char key, int cx, int cy) {

      switch (key) {

      case 27:

          exit(0);

          break;

      default: break;

      glutPostRedisplay();

  void raton (int boton, int estado, int cx, int cy) {

      if (boton == GLUT_LEFT_BUTTON && estado == GLUT_DOWN) {

          if (numP == 2) numP = 0;

          vertices[numP].x = cx;

          vertices[numP].y = 480 - cy;

          numP++;

      glutPostRedisplay();

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

  { int x, y, dx, dy, p, incE, incNE, stepx, stepy;

    dx = (x1 - x0);

    dy = (y1 - y0);

   /* determinar que punto usar para empezar, cual para terminar */

    if (dy < 0) {

      dy = -dy; stepy = -1;

    else

      stepy = 1;

    if (dx < 0) {

      dx = -dx; stepx = -1;

    else

      stepx = 1;

    x = x0;

    y = y0;

    screen[x0][y0]=1;

   /* se cicla hasta llegar al extremo de la línea */

    if(dx>dy){

      p = 2*dy - dx;

      incE = 2*dy;

      incNE = 2*(dy-dx);

      while (x != x1){

        x = x + stepx;

        if (p < 0){

          p = p + incE;

        else {

          y = y + stepy;

          p = p + incNE;

        screen[x][y]=1;

    else{

      p = 2*dx - dy;

      incE = 2*dx;

      incNE = 2*(dx-dy);

      while (y != y1){

        y = y + stepy;

        if (p < 0){

          p = p + incE;

        else {

          x = x + stepx;

          p = p + incNE;

        screen[x][y]=1;

  void paint (void) {

      int i, j;

      glClear(GL_COLOR_BUFFER_BIT);

      glMatrixMode(GL_MODELVIEW);

      glLoadIdentity();

      limpiaScreen();

      if (numP == 2) Bresenham((int)vertices[0].x, (int)vertices[0].y, (int)vertices[1].x, (int)vertices[1].y);

      glPointSize(1.0);

      glColor3f(1.0, 1.0, 0.0);

      glBegin(GL_POINTS);

      for(i = 0; i < 640; i++) {

          for(j = 0; j < 480; j++) {

              if (screen[i][j]) {

                  glVertex2i(i, j);

      glEnd();

      glPointSize(4.0);

      glColor3f(1.0, 0.0, 0.0);

      glBegin(GL_POINTS);

      for (i = 0; i < numP; i++) {

          glVertex2f(vertices[i].x, vertices[i].y);

      glEnd();

      glFlush();

  int main(int argc, char* argv[]) {

      glutInit(&argc, argv);

      glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

      glutInitWindowSize (640, 480);

      glutInitWindowPosition (100, 105);

      glutCreateWindow ("Algoitmo Bresenham");

      inicializar();

      glutDisplayFunc(paint);

      glutReshapeFunc(dimensn);

      glutKeyboardFunc(teclado);

      glutMouseFunc(raton);

      glutMainLoop();

      return 0;

TRANSFORMACIONES GEOMETRICAS

ACTIVIDAD *

TRASLACION

Se aplica una taslacion en un objeto para cambiar su posicion a lo largo de la trayectoria de una linea recta de una direccion de coordenadas a otra. Convertimos un punto bidimensional al agregar las distancias de traslacion, Tx y Ty a la posicion de coordenadas original (x,y) para mover el punto a una nueva posicion (x",y").

x" = x + Tx y" = y + Ty

El par de distancia de traslación (Tx , Ty) se llama vector de traslación o vector de cambio.se puede expresar las ecuaciones anteriores en una sola ecuación matricial de utilizar vectores de columna para representar las posiciones de coordenadas y el vector de traslación.
Estos nos permite expresar las dos ecuaciones de traslacion bidimensional en la forma de matriz:

P' = P + T

ROTACION

Se aplica una rotacion bidimensional en un objeto al cambiar s posicion a lo largo de la trayectoria de una circunferencia en el plano de xy. para generar una rotacion. especificamos un angulo de
rotacion θ y la posicion (Xr, Yr) del punto de rotacion (o punto pivote) en tomo al cual se gir el objeto.

Los valores positivos para ek angulo de rotacion definen rotaciones en sentido opuesto a las manecillas del reloj alrededor del punto pivote y los valores negativos giran los objetos en la direccion del reloj. Tambien es posible describir esta transformacion como una rotacion sobre el eje de rotacion que es perpendicular al plano de xy y pasa a traves del punto pivote.

ESCALACION

Es alterar el tamaño de un objeto. Se usa el producto de los valores de coordenadas (x,y) por los factores sx y sy para producir las coordenadas (x’,y’). Se le puede asignar valores positivos reales a los factores. Así pues si el factor es mayo a 1 produce una ampliación, si es menor a 1 se reduce, si es igual a 1 no hay modificación, si ambos factores son iguales la escalación es uniforme y si son
diferentes se produce una escalación diferida. Además de la escalación desde el origen también se puede escalar mediante un punto fijo.

TRANSFORMACIONES VENTANA-AREA DE VISTA

Como las primitivas de salida se expresan en coordenadas de mundo, hay que indicar al paquete de cubrutinas graficas como establecer la correspondencia entre las coordenadas de mundo y las coordenadas de pantalla (usaremos el termino especifico coordenadas de pantalla para relacionar este analisis especificamente con SRGP, pero podrian usarse dispositivos de impresion, en cuyo caso seria mas apropiado al termino coordenadas de dispositivo).
Esta correspondencia se puede afectuar si el programador de la aplicacion proporciona al paquete grafico una matriz de transformacion para la correspondencia.Otra forma es que el programador de la aplicaicon especifique una region rectangular en coordenadas de mundo, llamada ventana de coordenadas mundiales y una region rectangular correspondencia de la ventana de coordenadas mundiales. La transformacion que establece la correspondencia ente la ventana y el area de cista se aplica a todas las primitivas de salida en coordenadas de mundo para que correspondadn a coordenadas de pantalla.
Como se puede ver, si la entana y el area no tienen la misma razon altura-anchura, ocurre un esclamiento no uniforme. Si el progrma de aplicacion cambia la ventana o el area de vista, las nuevas primitivas de salida que se dibujen en la pantalla veran afectadas por el cambio, no asi las primitivas existentes.
Si SRGP proporcionara primitivas de salida en coordenadas de muncod, el area de vista se hallara en el lienzo actual, que por omision es el lienzo 0, la pantalla. El programa de aplicacion podrian cambiar en cualquier instante la ventana o el area de vista, en cuyo caso las primitivas de salida que se especifican subsecuentemente estarian sujetas a una nueva transformacion. Si el cambio incluyera una area de vusta distinta, las nuevas primitivas de salida se colocarian en el lienzo en posicion distintas a las anteriores.

ACTIVIDAD *

TRAZO DE LINEAS RECTAS

Para dibujar linea, habra que calcular las posiciones intermedias entre los dos extremos. Este problema no existiria en las pantallas vectoriales o plotters. Sin embargo, las posiciones de los pixeles son valores enteros, y los puntos obtenidos de la ecuacion son reales --> existe un error(aliasing).

consideraciones para el dibujo de rectas
hay que calcula las coordenadas de los pixels que estén lo mas cerca posible de una linea recta ideal, infinitamente delgada, superpuesta sobre la matriz de pixels.

REPRESENTACIÓN Y TRAZO DE POLÍGONOS

- ALGORITMO DDA PARA GENERACIÓN DE LINEAS

Es un algoritmo de lineas de conversion de rastreo que se basa en el calculo, ya sea en el incremento de X o en el incremento de Y. La finalidad de este algoritmo es determinar los valores enteros correspondientes mas proximos a la trayectoria de la linea para la otra coordenada.

Y(k+1) = Y(k) + mX(k+1) = X(k)+1/m

El subindice K toma valores enteros a partir de 1 y aumenta a razon de 1 hasta que se alcanse el valor final.

ACTIVIDAD *

ALGORITMOS PARA DIBUJAR CURVAS

- Curvas de Bezier:

Es un tipo de linea curva ideada por un ingeniero de Renault en los años 60 por medio de un metodo de descripcion matematica que conseguia definir las transiciones suaves de las curvaturas.

- Curvas de Bezier: Lineales (Grado 1):

Resultan extraordinariamente sencillas para crear trayectorias curvas entre dos puntos. Para construirlas, se interpola entre los extremos uno o mas puntos. Cuantos mas puntos interpolemos, de mas grado (y posibilidades de control) sera la curva. Por este motivo, los puntos interpolados se denominan puntos de control de la curva.

- Curvas de Bezier: Cuadráticas (Grado 2):

Tres puntos de control (P0, P1 y P2).

Se construyen dos curvas lineales de Bezier entre P0-P1 y P1-P2.

Se contruye una tercera curva lineal de Bezier entre las dos anteriores.

- Curvas de Bezier: Cúbicas (Grado 3):

Cuatro puntos de control (P0, P1, P2 y P3).

Son las mas utilizadas.

Se aplica el mismo principio de induccion, partiendo inicialemente de tres curvas de Bezier lineales.

- B-Splines:

Caso mas general que Bezier. Las curvas de Bezier son un tipo de B-Splines.

Ventajas sobre Bezier: los puntos de control no se alejan tanto de la forma que queremos modelo, por lo que podemos asemejarnos mas al modelo sin necesidad de utilizar muchos puntos de control.

Propiedades:

- Envolvente convexa

- Invarianza afin.

- Control local.

- Curvas racionales (NURBS):

NURBS = Non Uniform Rational B-Splines.

caso mas general: los B-Splines y las curvas de Bezier son casos particulares de NURBS.

No son simples polinomios, si no cocientes de polinomios.

ACTIVIDAD *

PUERTO DE VISION

Puerto de visión (Viewport)

Es el área de la ventana gráfica en la que se colocan las fotografías de la cámara virtual. Normalmente el ìertp de visión coincide con toda el área de la ventana gráfica, pero es posible tener varios piertos de visión en una sola ventana. Se utiliza la funció :
void glViewport(GLint x, GLint y, GLsizei w, GLsizei h)
dónde (x,y) es la esquina inferior izquierda del rectangulo o viewport. Esta coordenada debe especificarse con relación a la esquina inferior izquierda de la ventana. Claro está que w, h son la anchura y altura de nuestro viewport dentro de la ventana. Todos los valores son enteros ya que se tratan de pixels.

Ventanas

Para lograr un efecto de visualización particular en un programa de aplicación, podriamos diseñar nuestr propia ventana de recorte con uanquier forma, tamaño y orientación que queramos. Sin enbargo, las arista de ventana más simples para recortar son laas lineas rectas que son paralelas a los ejes de coordenadas. Por lo tanto, los paquetes gráficos habitualmente sólo permiten ventanas de recirte rectangulares aloneadas con los ejes x e y. Para crear una ventana se usan estos comandos de la libreria GLUT:

glutlnit (&argc, argv);
glutlnitWindowPosition (xTopLeft, yTopLeft);
glutlnitWindowSize (dwWidth, dwHeight) ;
glutCreateWindow ("Title of Display Window");

Proyecciones ortográficas

Una proyección ortografica es cuadrada en todas sus caras. Esto produce una proyección paralela, util para aplicaciones de tipo CAD o dibujos aquitectonicos, o tambien para tomar medidas, ya que las dimensiones de lo que representan no se ven alteradas por la proyección.
Para definir la matriz de proyección ortográfica y multiplicarla por la matriz activa, se utiliza la función glOrtho, que se define de la siguiente manera:

glOrtho(limiteIzquierdo, limiteDerecho, limiteAbajo, limiteArriba, znear, zfar)

Siendo todos flotantes. Los valores de znear y zfar no son las posiciones de esos planos en el espacio 3D. Representan la distancia desde el centro de proyección, con valor positivo hacia delante y negativo hacia atrás. Con esto simplemente se acota lo que será el volumen de visualización (un cubo).

Proyecciones perspectivas

Una proyección en perspectiva reduce y estira los pbjetos más alejados del observador. Es importante saber que las medidas de la proyección de un objeto no tienen por qué coincidir con las del objeto real, ya que han sido deformadas.
El volumen de visualización creado por una perspectiva se llama frustum. Un frustum es una sección piramidal, vista desde la parte afilada hasta la base.

Se puede definir esta proyección utilizando la función glFrustum. Pero existe otra función de la librería GLU llamadagluPerspective que hace el proceso más sencillo. Se define de la siguiente forma:

void gluPerspective(angulo, aspecto, znear, zfar);

Los parámetros de gluPerspective son flotantes y definen las características mostradas en la ilustración 4.7, el ángulo para el campo de visión en sentido vertical, el aspecto que es la relación entre la altura (h) y la anchura (w) y las distancias znear y zfar de los planos que acotan el fustrum al observador. Los valores de znear y zfar no son las posiciones de esos planos en el espacio 3D, representan la distancia desde el centro de proyección, con valor positivo hacia delante y negativo hacia atrás.

PROYECTO TRIANGULO

#include "stdafx.h"

#include <GL/glut.h>

typedef float point3[3];

point3 v[]={{0.0,0.0,0.0}, {7.0,0.0,0.0}, {7.0,0.0,-7.0}, {0.0,0.0,-7.0}, {3.5,8,-3.5}};/* vertices*/

static GLfloat theta[] = {0.0,0.0,0.0};
static GLint axis = 1;

void display(void)
{

    glShadeModel(GL_FLAT);
    glBegin(GL_TRIANGLE_FAN);

    glColor3f(1.0,0.0,1.0);//cara 1
    glVertex3fv(v[0]);
    glVertex3fv(v[1]);
    glVertex3fv(v[4]);

    glColor3f(1.0,0.0,0.0);//cara 2
    glVertex3fv(v[1]);
    glVertex3fv(v[2]);
    glVertex3fv(v[4]);

    glColor3f(1.0,1.0,0.0);//cara 3
    glVertex3fv(v[2]);
    glVertex3fv(v[3]);
    glVertex3fv(v[4]);

    glColor3f(0.0,0.0,1.0);//cara 4
    glVertex3fv(v[3]);
    glVertex3fv(v[0]);
    glVertex3fv(v[4]);
    glEnd();

    glBegin(GL_POLYGON);//base
    glColor3f(0.0,1.0,0.0);
    glVertex4fv(v[0]);
    glVertex4fv(v[1]);
    glVertex4fv(v[2]);
    glVertex4fv(v[3]);

    glEnd();
    glFlush();

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
    glRotatef(theta[0], 1.0, 0.0, 0.0);
    glRotatef(theta[1], 0.0, 1.0, 0.0);
    glRotatef(theta[2], 0.0, 0.0, 1.0);

    /*glutSwapBuffers();*/
        glFlush();
}

void myinit()
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-15.0, 15.0, -15.0, 15.0,15.0,-15.0);
    glMatrixMode(GL_MODELVIEW);
    glClearColor (0.0, 0.0, 0.0, 1.0);

}

void spinTriangle()
{
    //giro del triangulo
    theta[axis] += 1.0;
    if( theta[axis] > 360.0 ) theta[axis] -= 360.0;
    glutPostRedisplay();
}

void mouse(int btn, int state, int x, int y)
{
    //se selecciona un eje para girar
    if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis = 0;
    if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis = 1;
}

void key(unsigned char k, int x, int y)
{
    if(k == '9') glutIdleFunc(spinTriangle);
}

void main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB );
    glutInitWindowSize(500, 500);
    glutCreateWindow("Benjaz");
    glutDisplayFunc(display);
    glutMouseFunc(mouse);
    glutKeyboardFunc(key);
    glutIdleFunc(spinTriangle);
    myinit();
    glEnable(GL_DEPTH_TEST);
    glutMainLoop();
}

martes, 5 de febrero de 2013

Unidad 1

Glosario. Actividad 1.

metaformato: Es un término general para los sistemas de grabación de datos que permite guardar contenidos de varios tipos en un mismo fichero.

bit: un bit es un digito del sistema de numeración binario.

pixel: es la menor unidad homogénea en color que forma parte de una imagen digital, ya sea esta una fotografía, un fotograma de vídeo o un gráfico.

vector: es una herramienta geométrica utilizada para representar una magnitud física definida por su módulo (o longitud), su dirección (u orientación) y su sentido (que distingue el origen del extremo).

cabecera: En informática es la parte inicial de un programa.

algoritmo: es un conjunto preescrito de instrucciones o reglas bien definidas, ordenadas y finitas que permite realizar una actividad mediante pasos sucesivos que no generen dudas a quien deba realizar dicha actividad.

indexado: es el nombre que se le da al proceso de recolectar y almacenar páginas web por parte de un buscador de internet.

binario: Que está compuesto por dos elementos o unidades: el sistema de numeración que utilizan los ordenadores es binario, solamente utiliza los dígitos 0 y 1.

fichero: es un conjunto de bits almacenado en un dispositivo.

formato: la estructura usada para grabar datos en un fichero (docx, ZIP, MP3, txt, etc.).

codificador: Dispositivo que efectúa automáticamente la codificación de un mensaje literal en otro código.

procesador: un circuito integrado que contiene todos los elementos de la CPU. También es un sistema que procesa datos.

bidimensional: Algo es bidimensional si tiene dos dimensiones, por ejemplo, ancho y largo, pero no profundidad.

estático: Que permanece en un mismo estado y no experimenta cambios.

navegador: es una aplicación que opera a través de Internet, interpretando la información de archivos y sitios web para que éstos puedan ser leídos.

anidado: que esta dentro de o que se despliega de cierto objeto.

usuario: es aquel que usa ordinariamente algo.

encapsulamiento: se denomina encapsulamiento al ocultamiento del estado, es decir, de los datos miembro, de un objeto de manera que sólo se puede cambiar mediante las operaciones definidas para ese objeto.

redundancia: es una propiedad de los mensajes, consistente en tener partes predictibles a partir del resto del mensaje y que por tanto en sí mismo no aportan nueva información o "repiten" parte de la información.

etiquetas: Marca o marcas que se dejan en un texto para que luego sean interpretadas, generalmente para realizar alguna acción sobre el mismo texto marcado.

Investigacion. Actividad 2.

Aplicacion de graficos de computadora:

- animacion por computador

- diseño y manufactura asistidos por computador (CAD/CAM)

- video - juegos

- visualizacion cientifica: medicina, industria, educacion (laboratorios vistuales)

- artes graficos

- turismo digital

- en el cine

- simulacion

- arquitectura

- realidad vistual

Sistemas de graficos:

- procesador: procesamiento para la formacion o generacion de la imagen. procesamiento para la presentacion de la imagen.

- memoria: se refiere a parte de los componentes que forman parte de una computadora. Son dispositivos que retienen datos informáticos durante algún intervalo de tiempo. Las memorias de computadora proporcionan una de las principales funciones de la computación moderna, la retención o almacenamiento de información.

- frame buffer: El dispositivo frame buffer proporciona una capa de abstracción para el hardware gráfico. Esto representa la memoria intermedia del hardware de vídeo y permite al software acceder al hardware gráfico a través de una interfaz bien definida. Por eso el software no necesita conocer nada en absoluto acerca de las características de bajo nivel del hardware.

Al dispositivo se accede a través de los nodos especiales del dispositivo, generalmente localizados en el directorio /dev (/dev/fb*)

- dispositivos de salida: Son los dispositivos que reciben información que es procesada por la computadora y la reproducen para que sea perceptible para la persona. Monitor, Altavoz, Auriculares, Impresora, Plotter, Proyector

- dispositivos de entrada: Son los que envían información a la unidad de procesamiento, en código binario. Teclado, Ratón, Joystick, Lápiz óptico, Micrófono, Webcam, Escáner, Escáner de código de barras

Disparidad Binocular: es la diferencia entre las imagenes percibidas por las retinas izquierda y derecha del ojo. La disparidad binocular es la forma de percibir profundidad y relieve más utilizada por el cerebro humano, y es la que permite ser más manipulada, convirtiéndose en la base para la creación de imágenes 3D en superficies llanas.

Informacion monocular:

- interposicion

- perspectiva atmosferica

- gradiente de textura

- perspectiva lineal

- tamaño

- altitud

fuentes:

http://www.slideshare.net/AlonsoAlvarez/graficos-por-computadora-1

http://es.wikipedia.org/wiki/Memoria_(inform%C3%A1tica)

http://www.monografias.com/trabajos14/dispositivos/dispositivos.shtml

Actividad 3.

- Que es openGL?

Open Graphics Library. es una especificación estándar que define una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La interfaz consiste en más de 250 funciones diferentes que pueden usarse para dibujar escenas tridimensionales complejas a partir de primitivas geométricas simples, tales como puntos, líneas y triángulos.

Serpinski

Definiciones. Actividad 5.

- Fractal: es un objeto geométrico cuya estructura básica, fragmentada o irregular, se repite a diferentes escalas.

- Geometria Fractal: es geometría que no distingue entre conjunto matemático y objeto natural. Este nuevo paradigma engulle paradigmas anteriores proyectando un modelo que inagura una nueva zona o región de lo real.

- Conjuntos de Julia: son una familia de conjuntos fractales que se obtienen al estudiar el comportamiento de los números complejos al ser iterados por una función holomorfa.

- Conjunto de Mandelbrot: El conjunto de mandelbrot es el conjunto de todos los valores de "c" para los cuales z no diverge (puesto en términos más complicados, es el conjunto tal que el cero no está en la base o cuenca de atracción del infinito). Gráficamente el conjunto de mandelbrot se representa con el color negro, todos los valores complejos que están dentro del conjunto negro se mantienen siempre adentro.
- Fractales en la naturaleza: Las formas de la naturaleza son fractales y múltiples procesos de la misma se rigen por comportamientos fractales.Esto quiere decir que una nube o una costa pueden definirse por un modelo matemático fractal que se aproxime satisfactoriamente al objeto real. Esta aproximación se realiza en toda una franja de escalas , limitadas por valores mínimos y máximos. EJEMPLOS DE MODELOS FRACTALES: lorenz turbulencias atmosféricas y corrientes marinas. henon oscilaciones sufridas por cuerpos celestes que hacen que su trayectoria no sea completamente elíptica. curvas de koch aleatoria fronteras de un país, trazado de una costa, trazado de un río. fractales tipo arbol sistema arteriales y venosos.
- El triangulo de Serpinski: es un fractal que se puede construir a partir de cualquier triángulo.

CuboSpin

Proyecto: TRIANGULO 3D