figura Gato

#include<GL/glut.h>

//float x,y;
int tam_ln=10, ancho=480, alto=480;

void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT);
    //x=40;
    //y=40;
    glLineWidth(tam_ln);
    glPointSize(10);
    /*glPointSize(40);
    glBegin(GL_POINTS);
        glVertex2i(x,y);
    glEnd();
    glFlush();*/
    //glEnable(GL_LINE_SMOOTH);
    glColor3f(0.0,0.0,1.0);
   
    /*glBegin(GL_LINES);
    glVertex2f(30,30);glVertex2f(0,240);
    glEnd();
   
    //glEnable(GL_LINE_SMOOTH);
    glBegin(GL_LINES);
    glVertex2f(0,240);glVertex2f(0,360);
    glEnd();
   
    glBegin(GL_LINES);
    glVertex2f(0,360);glVertex2f(90,450);
    glEnd();*/
    creaLinea(30,60,0,240);
    creaLinea(0,240,0,360);
    creaLinea(0,360,90,450);
    creaLinea(90,450,150,450);
    creaLinea(150,450,150,420);
    creaLinea(150,420,90,360);
    creaLinea(90,360,60,360);
    creaLinea(60,360,60,270);
    creaLinea(60,270,120,330);
    creaLinea(120,330,180,330);
   
    creaLinea(180,330,240,270);
    creaLinea(240,270,240,390);
    creaLinea(240,390,300,330);
    creaLinea(300,330,420,330);
    creaLinea(420,330,480,390);
    creaLinea(480,390,480,210);
    creaLinea(480,210,450,180);
    creaLinea(450,180,390,150);
    creaLinea(390,150,330,150);
    creaLinea(330,150,270,180);
    creaLinea(270,180,240,210);
   
    creaLinea(240,210,240,120);
    creaLinea(240,120,270,120);
    creaLinea(270,120,270,60);
    creaLinea(270,60,180,60);
    creaLinea(180,60,180,180);
    creaLinea(180,180,120,180);
    creaLinea(120,180,90,150);
    creaLinea(90,150,90,120);
    creaLinea(90,120,150,120);
    creaLinea(150,120,150,60);
    creaLinea(150,60,30,60);
   
    creaLinea(270,300,330,300);
    creaLinea(330,300,330,240);
    creaLinea(330,240,270,240);
    creaLinea(270,240,270,300);
    creaLinea(360,240,390,210);
    creaLinea(390,210,330,210);
    creaLinea(330,210,360,240);
    creaLinea(390,300,450,300);
    creaLinea(450,300,450,240);
    creaLinea(450,240,390,240);
    creaLinea(390,240,390,300);
   
    glFlush();
}

int creaLinea(int a, int b, int c, int d)
{
glEnable(GL_LINE_SMOOTH);
glBegin(GL_LINES);
    glVertex2f(a,b);glVertex2f(c,d);
    glEnd();
    glEnable(GL_POINT_SMOOTH);
    glBegin(GL_POINTS);
    glColor3f(0,0,1);
    glVertex2i(a,b);
    glEnd();
}

void Init()
{
glClearColor(1,1,1,1);
gluOrtho2D(0,ancho,0,alto);
}

int main (int argc, char **arg)
{
        glutInit(&argc, arg);
        glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
        glutInitWindowPosition(100,100);
        glutInitWindowSize(ancho,alto);

        glutCreateWindow("Primera Ventana");
        Init();
        //glClearColor(0.0,0.0,0.0,0);  //define el color de la vemtana R,G,B,alpha
        //glColor3f(1.0,1.0,1.0);       //color de la figura
        //gluOrtho2D(0,640,0,480);        //dimenciones de lo que se quiere ver
        glutDisplayFunc(display);       //lo que se va a poner
        glutMainLoop();                 //se pone indefinidamente
        return 0;
}


Imagen del gato

Figura 1 tipo Flor

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <windows.h>
#include <GL/glut.h>
#endif
#include <stdlib.h>
#include <math.h>
#include <stdio.h>

int tam_px=4, ancho =640, alto=480;
float cx=320,cy=240,radio;
float r,g,b = 0.15;
float dx,dy,pi=3.141592653;

void display(void){
    glClear(GL_COLOR_BUFFER_BIT);
    glPointSize(tam_px); //define el tamaño del pixel
    glBegin(GL_POLYGON); //con estaa instrucion cre poligonos pequeños uqe van rellenando el circulo dando la sensacionde que esta solido

    r=(float)rand()/RAND_MAX; // genera numeros aleatorios
    g=(float)rand()/RAND_MAX;
    b=(float)rand()/RAND_MAX;
    radio=55;
    glColor3f(0,0,1);
        for (float i =0.0;i<2*pi;i+=0.01)//poner el valor de PI sobre 2 o 4 divide los grados del circulo
        {
            dx=radio*cos(i)+cx;
            dy=radio*sin(i)+cy;
            glVertex2f(dx,dy);
        }
    glEnd();

    glBegin(GL_POLYGON);
   
    glColor3b(0,0,0);
    glEnd();

    glBegin(GL_POLYGON);
    radio=22;
    glColor3f(1,1,1);
        for (float i =0.0;i<2*pi;i+=0.01)//poner el valor de PI sobre 2 o 4 divide los grados del circulo
        {
            dx=radio*cos(i)+cx;
            dy=radio*sin(i)+cy;
            glVertex2f(dx,dy);
        }
    glEnd();

    glBegin(GL_POLYGON);
    radio=30;
    glColor3f(0,0,1);
        for (float i =0.0;i<2*pi;i+=0.01)//poner el valor de PI sobre 2 o 4 divide los grados del circulo
        {
            dx=radio*cos(i)+(cx-62);
            dy=radio*sin(i)+(cy);
            glVertex2f(dx,dy);
        }
    glEnd();

    glBegin(GL_POLYGON);
    radio=30;
    glColor3f(0,0,1);
        for (float i =0.0;i<2*pi;i+=0.01)//poner el valor de PI sobre 2 o 4 divide los grados del circulo
        {
            dx=radio*cos(i)+(cx+62);
            dy=radio*sin(i)+(cy);
            glVertex2f(dx,dy);
        }
    glEnd();

    glBegin(GL_POLYGON);
    radio=30;
    glColor3f(0,0,1);
        for (float i =0.0;i<2*pi;i+=0.01)//poner el valor de PI sobre 2 o 4 divide los grados del circulo
        {
            dx=radio*cos(i)+(cx);
            dy=radio*sin(i)+(cy+62);
            glVertex2f(dx,dy);
        }
    glEnd();

    glBegin(GL_POLYGON);
    radio=30;
    glColor3f(0,0,1);
        for (float i =0.0;i<2*pi;i+=0.01)//poner el valor de PI sobre 2 o 4 divide los grados del circulo
        {
            dx=radio*cos(i)+(cx);
            dy=radio*sin(i)+(cy-62);
            glVertex2f(dx,dy);
        }
    glEnd();

    glFlush(); //libera memoria

}

void Init(){
    glClearColor(0.0,0.0,0.0,0);
    gluOrtho2D(0,ancho,0,alto);
    glEnable(GL_POINT_SMOOTH);
}

int main(int argc, char **argv){
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_SINGLE  |GLUT_RGB);
    glutInitWindowPosition(100,100);
    glutInitWindowSize(ancho,alto);
    glutCreateWindow("Linea smooth");
    Init();
    glClearColor(1.0,1.0,1.0,0.0);

    glutDisplayFunc(display);
    //radio=90;
    //glColor3f(0,0,0);
    //glutDisplayFunc(display);

//sive para decir que la mostrara indefnidamente
glutMainLoop();
return 0;
}

Bresenham y (DDA) Analizador Diferencial Digital

Algoritmos de dibujo de lineas.

Los primitivos de salida son funciones que ofrecen las bibliotecas gráficas para describir estructuras geométricas básicas. Cada primitivo de salida se especifica con los datos de las coordenadas de entrada y otra información referente a la manera en que se debe desplegar un objeto.
Los puntos y segmentos de línea recta son los componentes geométricos mas simples.

Algoritmo para el trazo de lineas.

Paso de mensajes con python

PVM (Parallel Virtual Machine Máquina Virtual Paralela)

Es una biblioteca para el cómputo paralelo en un sistema distribuido de computadoras. Está diseñado para permitir que una red de computadoras heterogénea comparta sus recursos de cómputo (como el procesador y la memoria RAM) con el fin de aprovechar esto para disminuir el tiempo de ejecución de un programa al distribuir la carga de trabajo en varias computadoras.

MPI ("Message Passing Interface”)

El paso de mensajes es una técnica empleada en programación concurrente para aportar sincronización entre procesos y permitir la exclusión mutua. Define la sintaxis y la semántica de las funciones contenidas en una biblioteca de paso de mensajes diseñada para ser usada en programas que exploten la existencia de múltiples procesadores.

hoy en dia es requerido el aprendizaje autonomo.

un estudiente en línea es dueño de su tiempo y de como genera conocimiento?

“El estudiante en línea tiene ante sí la oportunidad de marcar su propio ritmo de aprendizaje y de trazar sus horizontes de estudio de acuerdo con sus metas académicas.”

¿Qué es ser un estudiante en línea?

Al hablar sobre un estudiante en línea, nos referimos a que hace uso de la modalidad de estudios en línea, es decir a través de Internet, haciendo uso de las Tecnologías de la Información y la Comunicación (TIC´s).

Dicho proceso de aprendizaje en la modalidad de estudios en línea se lleva a cabo en un Ambiente Virtual de Aprendizaje (AVA) el cual es un espacio pensado y diseñado que engloba una visión conjunta del cómo se enseña, pero sobre todo del cómo se aprende y se elabora a partir del establecimiento de objetivos de aprendizaje, incorporando actividades y experiencias de aprendizaje estimulantes

circula un correo que puede tal vez robar tu identidad de facebook?

MUCHO CUIDADO SI RECIBES UN CORREO SIMILAR. ES COMPLETAMENTE FALSO. En su rapido analisis observamos que precticamente...
Posted by Erick Alvarez on lunes, 7 de marzo de 2016