Scribd Logo
Cargar

¡Te damos la bienvenida a Scribd!

  • Resolver Los Siguientes Ejercicios Propuestos

    Cargado por

    YESICA GOMEZ COAPAZA
    19 vistas9 páginas
    1. Se proponen 6 ejercicios que involucran el uso de líneas, polígonos, imágenes y efectos de segmentación y rotación sobre estas. Los ejercicios incluyen: insertar pelotas rebotantes de diferentes radios, crear cubos cayendo, dibujar un polígono de líneas, construir un triángulo de Sierpinski, aplicar efectos de canales RGB a segmentos rotados de una imagen.

    Descripción original:

    Derechos de autor

    © © All Rights Reserved

    Formatos disponibles

    PDF, TXT o lea en línea desde Scribd

    ¿Le pareció útil este documento?

    ¿Este contenido es inapropiado?

    Denunciar este documento
    1. Se proponen 6 ejercicios que involucran el uso de líneas, polígonos, imágenes y efectos de segmentación y rotación sobre estas. Los ejercicios incluyen: insertar pelotas rebotantes de diferentes radios, crear cubos cayendo, dibujar un polígono de líneas, construir un triángulo de Sierpinski, aplicar efectos de canales RGB a segmentos rotados de una imagen.

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Marcar por contenido inapropiado
    Descargar como pdf o txt
    19 vistas9 páginas

    Resolver Los Siguientes Ejercicios Propuestos

    Cargado por

    YESICA GOMEZ COAPAZA
    1. Se proponen 6 ejercicios que involucran el uso de líneas, polígonos, imágenes y efectos de segmentación y rotación sobre estas. Los ejercicios incluyen: insertar pelotas rebotantes de diferentes radios, crear cubos cayendo, dibujar un polígono de líneas, construir un triángulo de Sierpinski, aplicar efectos de canales RGB a segmentos rotados de una imagen.

    Copyright:

    © All Rights Reserved
    Descargue como PDF, TXT o lea en línea desde Scribd
    Marcar por contenido inapropiado
    Descargar como pdf o txt
    de 9

    Resolver los siguientes ejercicios propuestos

    1. Insertar 4 pelo tas con diferentes longitudes de radio (4r, 2r, r y r/2). Las pelo tas
    deben estar rebotando dentro de la pantalla, si llegan a colisionar, estas deben reducir
    su radio a la mitad. cuando su radio es r/2 y colisiona, la pelo ta desaparece.

    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-
    scale=1.0">
    <title>Juegos Artificiales | Computación Gráfica</title>
    <link rel="stylesheet" href="css/style.css">
    </head>
    <body>
    <script src="js/fnc.js"></script>
    </body>
    </html>

    var gravedad = .3;


    var numHijos = 50;

    var numParticulas = 20;


    var particulasCreadas = 0;

    function crearParticula() {
    var particula = document.createElement("div");
    particula.className = "particula";

    var x = Math.random() * window.innerWidth;


    var y = window.innerHeight;

    particula.style.top = y + "px";
    particula.style.left = x + "px";

    var velocidadY = -10 - (Math.random() * 10);

    particula.setAttribute("data-velocidad-y", velocidadY);
    particula.setAttribute("data-velocidad-x", "0");
    particula.setAttribute("data-padre", "true");
    particula.style.background = getRandomColor();

    document.getElementsByTagName("body")[0].append(particula);
    particulasCreadas++;

    if(particulasCreadas < numParticulas) {


    setTimeout(crearParticula, 50 + (Math.random() * 450));
    }
    }
    function iniciar() {
    crearParticula();
    }
    function actualizar() {
    var particulas = document.getElementsByClassName("particula");
    for(let p=0; p<particulas.length; p++) {
    var particula = particulas[p];

    var velocidadY = parseFloat(particula.getAttribute("data-


    velocidad-y"));
    velocidadY += gravedad;

    particula.setAttribute("data-velocidad-y", velocidadY);
    var top = particula.style.top ? particula.style.top : "0";
    top = parseFloat(top.replace("px", ""));
    top += velocidadY;
    particula.style.top = top + "px";

    var velocidadX = parseFloat(particula.getAttribute("data-


    velocidad-x"));
    var left = particula.style.left ? particula.style.left : "0";
    left = parseFloat(left.replace("px", ""));
    left += velocidadX;
    particula.style.left = left + "px";

    var padre = particula.getAttribute("data-padre");


    if(velocidadY >=0 && padre === "true") {
    explotar(particula);
    }

    if(top > window.innerHeight) {


    particula.remove();
    }
    }
    setTimeout(actualizar, 26);
    }
    function explotar(particula) {
    for(let h=0; h<numHijos; h++) {
    var hijo = document.createElement("div");
    hijo.className = "particula";

    hijo.style.top = particula.style.top;
    hijo.style.left = particula.style.left;
    hijo.style.background = particula.style.background;

    var velocidadY = (Math.random() * 7) - 5;


    hijo.setAttribute("data-velocidad-y", velocidadY);
    var velocidadX = (Math.random() * 10) - 5;
    hijo.setAttribute("data-velocidad-x", velocidadX);

    hijo.setAttribute("data-padre", false);

    document.getElementsByTagName("body")[0].append(hijo);
    }
    particula.remove();
    }
    function getRandomColor() {
    var letras = "0123456789ABCDEF";
    var color = "#";
    for(let i=0; i<6; i++) {
    color += letras[Math.floor(Math.random() * 16)];
    }
    return color;
    }
    window.onload = function() {
    iniciar();
    actualizar();
    }

    html, body {
    margin: 0; padding: 0;
    overflow-y: hidden;
    overflow-x: hidden;
    background: #000;
    }
    .fondo {
    width: 100%;
    height: 100%;
    }

    .particula {
    width: 50px;
    height: 50px;
    background: #000;
    border-radius: 50%;
    position: absolute;
    }
    .particula[data-padre = "false"] {
    width: 5px;
    height: 5px;
    }
    2. Catarata de cubos: Crear 50 cubos y los cuales deben caer desde la parte superior de la
    pantalla hacia abajo, el origen de los cubos deben ser de forma aleatoria y en
    diferentes empos.

    from OpenGL.GL import *


    from OpenGL.GLU import *

    import pygame
    import random
    from pygame.locals import *

    aristas = (
    (0, 1),
    (0, 3),
    (0, 4),
    (2, 1),
    (2, 3),
    (2, 6),
    (5, 1),
    (5, 4),
    (5, 6),
    (7, 3),
    (7, 4),
    (7, 6),
    )

    ListaAristas=[]

    def createAristas():
    y= 25

    for i in range(0,50,1):
    arista_x=random.randint(-25,25)
    arista_y=random.randint(25,500)
    vertices = [
    # X Y Z
    [-1+arista_x, 1+arista_y, -1], # 0
    [ 1+arista_x, 1+arista_y, -1], # 1
    [ 1+arista_x, 1+arista_y, 1], # 2
    [-1+arista_x, 1+arista_y, 1], # 3
    [-1+arista_x, -1+arista_y, -1], # 4
    [ 1+arista_x, -1+arista_y, -1], # 5
    [ 1+arista_x, -1+arista_y, 1], # 6
    [-1+arista_x, -1+arista_y, 1], # 7
    ]
    ListaAristas.append(vertices)

    def Cubo(v):
    glBegin(GL_LINES)
    glColor3fv((1, 1, 0))

    for arista in aristas:


    for vertice in arista:
    v[vertice][0]
    glVertex3fv(v[vertice])

    glEnd()
    def drawCubo():
    for i in range(0,50,1):
    Cubo(ListaAristas[i])
    pantalla = [600, 600]
    Cerrar = False

    pygame.init()
    pygame.display.set_mode(pantalla, DOUBLEBUF | OPENGL)
    pygame.display.set_caption("Cubo - Computación Gráfica")

    gluPerspective(60, pantalla[0]/pantalla[1], 0.1, 50.0)


    glTranslatef(0., 0., -50)
    glRotatef(0, 1, 0, -7)

    createAristas()
    print(ListaAristas)

    while not Cerrar:


    for event in pygame.event.get():
    if event.type == QUIT:
    Cerrar = True
    if event.type == KEYDOWN:
    if event.key == K_ESCAPE:
    Cerrar = True

    glRotatef(0, 0, 0, -3)
    glTranslatef(0., -1, 0.)
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

    drawCubo()

    pygame.display.flip()
    pygame.time.wait(60)

    pygame.quit()

    3. U lizando lineas, construir el siguiente polígono de lineas.

    4. U lizando lineas, construir el triangulo de de Sierpinsky.

    import turtle
    def dibujarTriangulo(puntos,color,miTortuga):
    miTortuga.fillcolor(color)
    miTortuga.up()
    miTortuga.goto(puntos[0][0],puntos[0][1])
    miTortuga.down()
    miTortuga.begin_fill()
    miTortuga.goto(puntos[1][0],puntos[1][1])
    miTortuga.goto(puntos[2][0],puntos[2][1])
    miTortuga.goto(puntos[0][0],puntos[0][1])
    miTortuga.end_fill()

    def obtenerMitad(p1,p2):
    return ( (p1[0]+p2[0]) / 2, (p1[1] + p2[1]) / 2)

    def sierpinski(puntos,grado,miTortuga):
    colormap = ['blue','red','green','white','yellow',
    'violet','orange']
    dibujarTriangulo(puntos,colormap[grado],miTortuga)
    if grado > 0:
    sierpinski([puntos[0],
    obtenerMitad(puntos[0], puntos[1]),
    obtenerMitad(puntos[0], puntos[2])],
    grado-1, miTortuga)
    sierpinski([puntos[1],
    obtenerMitad(puntos[0], puntos[1]),
    obtenerMitad(puntos[1], puntos[2])],
    grado-1, miTortuga)
    sierpinski([puntos[2],
    obtenerMitad(puntos[2], puntos[1]),
    obtenerMitad(puntos[0], puntos[2])],
    grado-1, miTortuga)

    def main():
    miTortuga = turtle.Turtle()
    miVentana = turtle.Screen()
    misPuntos = [[-100,-50],[0,100],[100,-50]]
    sierpinski(misPuntos,4,miTortuga)
    miVentana.exitonclick()

    main()
    5. U lizando javascript o python, insertar una imágen y establecer las franjas a 60 grados
    de inclinación bajo la siguiente configuración: (color original, canal R(rojo), canal
    G(verde), canal B(azul, grises y blanco y negro).

    from PIL import Image

    def six_segment_effects_rotated(image_path):
    # Abre la imagen original
    original = Image.open(image_path).convert('RGB')
    width, height = original.size

    # Divide la imagen en seis partes


    segments = [original.crop((0, i * height // 6, width, (i + 1) *
    height // 6)) for i in range(6)]

    # El primer segmento se queda como está (color original)

    # Convierte el segundo segmento al canal rojo


    r, _, _ = segments[1].split()
    segments[1] = Image.merge("RGB", (r, Image.new("L", r.size),
    Image.new("L", r.size)))

    # Convierte el tercer segmento al canal verde


    _, g, _ = segments[2].split()
    segments[2] = Image.merge("RGB", (Image.new("L", g.size), g,
    Image.new("L", g.size)))

    # Convierte el cuarto segmento al canal azul


    _, _, b = segments[3].split()
    segments[3] = Image.merge("RGB", (Image.new("L", b.size),
    Image.new("L", b.size), b))

    # Convierte el quinto segmento a escala de grises


    segments[4] = segments[4].convert('L').convert('RGB')
    # Convierte el sexto segmento a blanco y negro
    segments[5] = segments[5].convert('1').convert('RGB')

    # Combina los segmentos de nuevo en una sola imagen


    new_image = Image.new('RGB', (width, height))
    for i, segment in enumerate(segments):
    new_image.paste(segment, (0, i * height // 6))

    # Rota la imagen completa


    new_image = new_image.rotate(60, expand=True)

    # Guarda y muestra la nueva imagen


    new_image.save('images.jpg')
    new_image.show()

    # Usa la función en la imagen que desees


    six_segment_effects_rotated('image.jpg')
    6.

    También podría gustarte