Example #1
0
                render.glClear()

        while not vertex_color_continue:
            print(
                "\nVERTEX COLOR - Ingrese números de tipo flotante entre 0 y 1"
            )
            vertex_color_r = float(input("Ingrese el valor de R: "))
            vertex_color_g = float(input("Ingrese el valor de G: "))
            vertex_color_b = float(input("Ingrese el valor de B: "))

            if vertex_color_r > 1 or vertex_color_r < 0 or vertex_color_g > 1 or vertex_color_g < 0 or vertex_color_b > 1 or vertex_color_b < 0:
                print(
                    "\n Los valores ingresados no son válidos, ingrese números entre 0 y 1"
                )
            else:
                render.glColor(vertex_color_r, vertex_color_g, vertex_color_b)
                vertex_color_continue = True

        while not vertex_continue:
            print("\nVERTEX - Ingrese números de tipo flotante entre -1 y 1")
            vertex_x = float(input("Ingrese el valor para x: "))
            vertex_y = float(input("Ingrese el valor para y: "))

            if vertex_x > 1 or vertex_x < -1 or vertex_y > 1 or vertex_y < -1:
                print(
                    "\n Los valores ingresados no son válidos, ingrese números entre -1 y 1"
                )
            else:
                render.glVertex(vertex_x, vertex_y)
                vertex_continue = True
Example #2
0
18398
"""
from gl import Render, changecolor

posX = 250
posY = 250
width = 1000
height = 1000

bitmap = Render(width, height) #los ultimos tres son los colores son los del background

bitmap.glViewPort(posX, posY, width - 500 , height - 500)
bitmap.glClearColor(0, 0, 0)
bitmap.glclear()

#principales (t)
bitmap.glColor(1, 1, 1) #estos colores son los que se usaran en Vertex
bitmap.glLine(0, -1, 0, 1)
bitmap.glLine(-1, 0, 1, 0)

bitmap.glColor(0, 1, 0) 
bitmap.glLine(1, -1, -1, 1)
bitmap.glLine(-1, -1, 1, 1)
#margen
bitmap.glColor(1, 0, 0) 
bitmap.glLine(-1, 1, 1, 1)
bitmap.glLine(1, -1, 1, 1)
bitmap.glLine(1, -1, -1, -1)
bitmap.glLine(-1, -1, -1, 1)

bitmap.finish('out.bmp')
from gl import Render, color

r = Render(600, 600)

r.glViewport(100, 100, 400, 400)

r.glClearColor(0, 0, 0)
r.glColor(0.45, 0.5, 0)
r.glClear()

r.glLine(-1, 0, 0, 1)
r.glLine(0, 1, 1, 0)
r.glLine(1, 0, 0, -1)
r.glLine(0, -1, -1, 0)
r.glLine(-1, 0, 1, 0)
r.glLine(0, -1, 0, 1)
r.glLine(-1, -1, -1, 1)
r.glLine(-1, 1, 1, 1)
r.glLine(1, 1, 1, -1)
r.glLine(1, -1, -1, -1)
r.glLine(-1, -1, 1, 1)
r.glLine(1, -1, -1, 1)

r.glFinish('output.bmp')
Example #4
0
#Andree Toledo 18439
#Laboratorio Filling polygon

from gl import Render

BLACK = (0, 0, 0)

render = Render()

render.glCreateWindow(900, 500)  # Screen size
render.glClearColor(0, 0, 0)  # Black

# Rendering polygons
render.glColor(0.39, 0.72, 1)  # BLUE
render.glDrawPolygon([(165, 380), (185, 360), (180, 330), (207, 345),
                      (233, 330), (230, 360), (250, 380), (220, 385),
                      (205, 410), (193, 383)])
render.glFillPolygon()
render.glColor(0.39, 0.72, 1)  # BLUE

render.glDrawPolygon([(321, 335), (288, 286), (339, 251), (374, 302)])
render.glFillPolygon()
render.glColor(0.39, 0.72, 1)  # BLUE
render.glDrawPolygon([(377, 249), (411, 197), (436, 249)])
render.glFillPolygon()

render.glColor(0.88, 0.25, 0.01)  # RED
render.glDrawPolygon([(413, 177), (448, 159), (502, 88), (553, 53), (535, 36),
                      (676, 37), (660, 52), (750, 145), (761, 179), (672, 192),
                      (659, 214), (615, 214), (632, 230), (580, 230),
                      (597, 215), (552, 214), (517, 144), (466, 180)])
Example #5
0
from gl import Render, color

r = Render(900, 600)

polygon1 = [(165, 380), (185, 360), (180, 330), (207, 345), (233, 330), (230, 360), (250, 380), (220, 385), (205, 410), (193, 383)]
polygon2 = [(321, 335), (288, 286), (339, 251), (374, 302)]
polygon3 = [(377, 249), (411, 197), (436, 249)]
polygon4 = [(413, 177), (448, 159), (502, 88), (553, 53), (535, 36), (676, 37), (660, 52), (750, 145), (761, 179), (672, 192), (659, 214), (615, 214), (632, 230), (580, 230), (597, 215), (552, 214), (517, 144), (466, 180),]
polygon5 = [(682, 175), (708, 120), (735, 148), (739, 170)]

r.glDrawPolygon(polygon1)
r.glDrawPolygon(polygon2)
r.glDrawPolygon(polygon3)
r.glDrawPolygon(polygon4)
r.glColor(0, 0, 0)
r.glDrawPolygon(polygon5)

r.glFinish()
p2 = [(321, 335), (288, 286), (339, 251), (374, 302)]

p3 = [(377, 249), (411, 197), (436, 249)]

p4 = [(413, 177), (448, 159), (502, 88), (553, 53), (535, 36), (676, 37),
      (660, 52), (750, 145), (761, 179), (672, 192), (659, 214), (615, 214),
      (632, 230), (580, 230), (597, 215), (552, 214), (517, 144), (466, 180)]

p5 = [(682, 175), (708, 120), (735, 148), (739, 170)]

print("A continuación se graficarán y se llenarán polígonos ")

enter = input("Apache ENTER para continuar...")

##  changes the color to yellow
render.glColor(1, 1, 0)
render.glDrawPolygon(p1)

##  changes the color to blue
render.glColor(0, 0, 1)
render.glDrawPolygon(p2)

##  changes the color to green
render.glColor(0, 1, 0)
render.glDrawPolygon(p3)

##  changes the color to red
render.glColor(1, 0, 0)
render.glDrawPolygon(p4)

##  changes the color to white
Maria Ines Vasquez Figueroa
18250
Gráficas
SR1 Points
Main
"""

from gl import Render

#valores con los que se inicializan la ventana y viewport

width = 1920
height = 1080
posX = width / 4
posY = height / 4
#creacion de Window
#los ultimos 3 parametros es para settear el color del fondo de la ventana con parametros de 0-1 para rojo, verde y azul
r = Render(width, height, 0, 0, 0)

#creacion del viewport
r.glViewPort(posX, posY, width - width / 2, height - height / 2)

#cambio de color con el que se hará el punto con parametros de 0-1 para r, g, b
r.glColor(1, 1, 1)

#se dibuja el punto en relación al viewport
r.glVertex(0, 0)

#se dibuja
r.glFinish('output.bmp')
Example #8
0
#Andres Emilio Quinto Villagran
#carne 18288
#Filling any polygon

from gl import Render

Dark = (0, 0, 0)

render = Render()

render.glCreateWindow(900, 500)  # Screen size
render.glClearColor(0, 0, 0)

render.glColor(0, 0.254, 0.255)
render.glDrawPolygon([(165, 380), (185, 360), (180, 330), (207, 345),
                      (233, 330), (230, 360), (250, 380), (220, 385),
                      (205, 410), (193, 383)])
render.glFillPolygon()
render.glColor(0, 0.255, 0.255)

render.glDrawPolygon([(321, 335), (288, 286), (339, 251), (374, 302)])
render.glFillPolygon()
render.glColor(0, 0.255, 0.255)
render.glDrawPolygon([(377, 249), (411, 197), (436, 249)])
render.glFillPolygon()

render.glColor(0.255, 0.255, 0.1)
render.glDrawPolygon([(413, 177), (448, 159), (502, 88), (553, 53), (535, 36),
                      (676, 37), (660, 52), (750, 145), (761, 179), (672, 192),
                      (659, 214), (615, 214), (632, 230), (580, 230),
                      (597, 215), (552, 214), (517, 144), (466, 180)])
Example #9
0
                red = float(red)
                green = input(
                    "Ingrese el valor g del color deseado (de 0 a 1): ")
                green = float(green)
                blue = input(
                    "Ingrese el valor b del color deseado (de 0 a 1): ")
                blue = float(blue)

                if ((red < 0 or red > 1) or (green < 0 or green > 1)
                        or (blue < 0 or blue > 1)):
                    print("\nPor favor escoger valores entre 0 y 1\n")
                else:
                    is_values_ok = True

                    ##  uses this function to change the default color of the point drawn
                    render.glColor(red, green, blue)

        elif (point_option == 2):
            is_values_ok = False

            ##  asks the coordinates in which the user wants the point to be drawn
            while (is_values_ok == False):
                point_x = input(
                    "Ingrese un valor en x relativo al  ViewPort (entre -1 y 1): "
                )
                point_x = float(point_x)
                point_y = input(
                    "Ingrese un valor en x relativo al  ViewPort (entre -1 y 1): "
                )
                point_y = float(point_y)
Example #10
0
from gl import Render
from gl import color

bmpFile = Render()
bmpFile.glCreateWindow(800, 600)  # Screen size
bmpFile.glViewport(20, 20, 50, 150)
bmpFile.glClear()
bmpFile.glClearColor(0, 0, 0)  # Black
bmpFile.glColor(0.53, 0.80, 0.92)  # Added random color
bmpFile.glVertex(-1, -1)  # Point on left lower corner
bmpFile.glVertex(0, 0)  # Point on center
bmpFile.glVertex(1, 1)  # Point on right upper corner
bmpFile.glFinish()
Example #11
0
from gl import Render, color

r = Render()
r.glCreateWindow(20,10)

r.glColor(0,1,1)

r.glClearColor(1,0,0)
    
r.glClear()

r.glViewPort(3,1,10, 4)


r.glVertex(-1,-1)
r.glVertex(1,1)
r.glVertex(-1,1)
r.glVertex(0,0)
r.glVertex(1,-1)
r.glVertex(-1,0)
r.glVertex(1,0)

r.glFinish('output.bmp')

Example #12
0
#valores con los que se inicializan la ventana y viewport

width=1920
height=1080
posX = width/4
posY = height/4
#creacion de Window
#los ultimos 3 parametros es para settear el color del fondo de la ventana con parametros de 0-1 para rojo, verde y azul
r = Render(width,height,0,0,0)

#creacion del viewport
r.glViewPort(posX, posY, width - width/2 , height - height/2)

#cambio de color con el que se hará el punto con parametros de 0-1 para r, g, b
r.glColor(1,0,0)


#dibujo de estrella verde
r.glColor(0,1,0)
##algoritmo para dibujar linea modificado en base al algoritmo de Bersenham extraido de : https://www.geeksforgeeks.org/bresenhams-line-generation-algorithm/
r.glLine(-1, -1, 0,1)
r.glLine(0, 1,1, -1)
r.glLine(1, -1, -1,0.5)
r.glLine(-1, 0.5, 1,0.5)
r.glLine(1, 0.5, -1,-1)

#asterisco desde el centro rojo
r.glColor(1,0,0)
r.glLine(0, 0, 0,1)
r.glLine(0, 0, 0,-1)
Example #13
0
#Andree Toledo 18439

from gl import Render, color

r = Render(800, 800)

#Size of the vp
r.glViewport(200, 200, 1000, 1000)

#Color picker
r.glClearColor(0, 0, 0.25)
r.glColor(0.55, 0, 0)
r.glClear()

#Create Lines
r.glLine(1, -1, 1, 0)
r.glLine(1, -1, 0, 1)
r.glLine(1, 1, -1, 0)
r.glLine(1, 1, 1, 1)

r.glLine(0, 0, -1, 1)
r.glLine(0, 1, -1, 0)
r.glLine(0, 0, 1, 1)
r.glLine(-1, -1, -1, 0)

#Imagen de salida
r.glFinish('output.bmp')
from gl import Render, color

from obj import Obj

r = Render(1000, 800)


poly1 = [(165, 380), (185, 360), (180, 330), (207, 345), (233, 330), (230, 360), (250, 380), (220, 385), (205, 410), (193, 383)]
poly2 = [(321, 335),  (288, 286),  (339, 251),  (374, 302)]
poly3 = [(377, 249),  (411, 197),  (436, 249)]
poly4 = [(413, 177), (448, 159), (502, 88), (553, 53), (535, 36), (676, 37), (660, 52),
        (750, 145), (761, 179), (672, 192), (659, 214), (615, 214), (632, 230), (580, 230),
        (597, 215), (552, 214), (517, 144), (466, 180)]
poly5 = [(682, 175),  (708, 120),  (735, 148),  (739, 170)]

r.glColor(0,1,1)
r.glDrawPolygon(poly1)
r.glFillPolygon(poly1)

r.glColor(1,0,0)
r.glDrawPolygon(poly2)
r.glFillPolygon(poly2)

r.glColor(1,0,1)
r.glDrawPolygon(poly3)
r.glFillPolygon(poly3)

r.glColor(0.5,1,0)
r.glDrawPolygon(poly4)
r.glFillPolygon(poly4)
Example #15
0
from gl import Render

render = Render()
render.glColor(0.130, 0.240, 0.750)  #Color Azul Mustang

render.load('./cuerpo.obj', translate=[600, 300], scale=[100, 100])
render.glFinish()
Example #16
0
from gl import Render, color

r = Render()

r.glCreateWindow(800, 800)
r.glClearColor(0, 0, 0)
r.glColor(1, 0, 0.9843)
r.glClear()

r.glLine(0, 0, 1, 1)
r.glLine(0, 0, 1, 0.5)
r.glLine(0, 0, 1, 0)
r.glLine(0, 0, 1, -0.5)
r.glLine(0, 0, 1, -1)
r.glLine(0, 0, 0.5, -1)
r.glLine(0, 0, 0, -1)
r.glLine(0, 0, -0.5, -1)
r.glLine(0, 0, -1, -1)
r.glLine(0, 0, -1, -0.5)
r.glLine(0, 0, -1, 0)
r.glLine(0, 0, -1, 0.5)
r.glLine(0, 0, -1, 1)
r.glLine(0, 0, -0.5, 1)
r.glLine(0, 0, 0, 1)
r.glLine(0, 0, 0.5, 1)

r.glFinish()
Example #17
0
"""
Paula Camila Gonzalez Ortega
18398
"""
from gl import Render

width = 1000
height = 1000

bitmap = Render(width, height) 

bitmap.glClearColor(0, 0, 0) #este es background color
bitmap.glclear()
bitmap.glColor(1, 0.5, 0) #estos colores son los que se usaran para pintar 

#POLY 1
poly = [(165, 380), (185, 360), 
(185, 360), (180, 330),
(180, 330), (207, 345),
(207, 345), (233, 330), 
(233, 330), (230, 360),
(230, 360), (250, 380),
(250, 380), (220, 385),
(220, 385), (205, 410),
(205, 410), (193, 383),
(193, 383), (165, 380)]
bitmap.drawPolygon(poly)
bitmap.filling(poly)

#POLY 2
bitmap.glColor(0.5, 0, 1)
# Andrea Abril Palencia Gutierrez, 18198
# Lab1: Filling any Polygon --- Graficas por computadora, seccion 20
# 20/07/2020 - 27/07/2020

from gl import Render, color, convertir

imagen = Render(800, 460)
print("Esto suele tardar un poco!!!")
pol1 = [(165, 380), (185, 360), (180, 330), (207, 345), (233, 330), (230, 360), (250, 380), (220, 385), (205, 410), (193, 383)]
imagen.glColor(color(215, 189, 226))
imagen.Poligonos(pol1)
pol2 = [(321, 335), (288, 286), (339, 251), (374, 302)]
imagen.glColor(color(171, 235, 198))
imagen.Poligonos(pol2)
pol3 = [(377, 249), (411, 197), (436, 249)]
imagen.glColor(color(249, 231, 159))
imagen.Poligonos(pol3)
pol4 = [(413, 177), (448, 159), (502, 88), (553, 53), (535, 36), (676, 37), (660, 52), (750, 145), (761, 179), (672, 192), (659, 214), (615, 214), (632, 230), (580, 230), (597, 215), (552, 214), (517, 144), (466, 180)]
imagen.glColor(color(248, 201, 251))
imagen.Poligonos(pol4)
pol5 = [(682, 175), (708, 120), (735, 148), (739, 170)]
imagen.glColor(color(248,249,249))
imagen.Poligonos(pol5)
imagen.glFinish('poligonos.bmp')
print("¡Listo! La imagen esta creada con el nombre de 'poligonos.bmp'.")