def render_scene(self,objects,lights,res):
#create a viewport and image
v = ViewPort(res[0],res[1])
im = Image.new("RGB",(v.w,v.h))
pix = im.load()
#define a ray
#FIX BUG -- STILL ORTHO
ray = Ray(np.array([0,0,0]),np.array([0,0,-1]))
# Perform perspective ray-tracing
print("...generating "+str(v)+" image")
for col in range(v.w):
for row in range(v.h):
color = np.zeros(3)
print(color)
ray.o = v.getPixelCenter(col,row)
for s in objects:
t = s.intersectRay(ray)
if (t != None):
xp = ray.getPoint(t)
for light in lights:
color+= phongShader(xp,s.getNormal(xp),s.material,light,self.eye)
print(color)
#pix[col,v.h-1-row] = color
pix[col,v.h-1-row]=(1,1,1)
# Show the image in a window
im.show()
def render_scene(self, objects, lights, res):
#create a viewport and image
v = ViewPort(res[0], res[1])
im = Image.new("RGB", (v.w, v.h))
pix = im.load()
#define a ray
#FIX BUG -- STILL ORTHO
ray = Ray(np.array([0, 0, 0]), np.array([0, 0, -1]))
# Perform perspective ray-tracing
print("...generating " + str(v) + " image")
for col in range(v.w):
for row in range(v.h):
color = np.zeros(3)
print(color)
ray.o = v.getPixelCenter(col, row)
for s in objects:
t = s.intersectRay(ray)
if (t != None):
xp = ray.getPoint(t)
for light in lights:
color += phongShader(xp, s.getNormal(xp),
s.material, light, self.eye)
print(color)
#pix[col,v.h-1-row] = color
pix[col, v.h - 1 - row] = (1, 1, 1)
# Show the image in a window
im.show()
def mouse_button_event(self, event):
print("Mouse button", event)
if event.button == MouseButton.RIGHT:
if event.action == "release":
self._movement = None
self._mousepos = None
else:
self._movement = "camera_yx"
self._mousepos = event
elif event.button == MouseButton.MIDDLE:
if event.action == "release":
self._movement = None
self._mousepos = None
else:
action = self._MIDDLE_MOUSE_ACTIONS[self._middle_mouse_actionidx]
self._movement = action
self._mousepos = event
elif event.button == MouseButton.LEFT:
if event.action == "press":
piece = self._getpieceat(event.world)
if piece is not None:
self._game.clickpiece(piece)
self._display.mark_dirty()
elif event.button == MouseButton.WHEEL_DOWN:
# Zoom out
self._display.viewport = ViewPort(anglex = self._display.viewport.anglex, angley = self._display.viewport.angley, distance = self._display.viewport.distance + self._ZOOM_DISTANCE)
elif event.button == MouseButton.WHEEL_UP:
# Zoom in
self._display.viewport = ViewPort(anglex = self._display.viewport.anglex, angley = self._display.viewport.angley, distance = self._display.viewport.distance - self._ZOOM_DISTANCE)
def __init__(self, root, stockReader):
'''
Constructor
'''
self.canvas = Canvas(root)
self.canvas.pack(side="top", fill="both", expand=True)
self.init()
#The size of the canvas is (vr - vl) = 500 x (vb - vt) = 500
vl = 100
vr = 600
vt = 80
vb = 580
period = stockReader.getLDate() - stockReader.getEDate()
#the x-coordinates of the world view is the number of days between the latest date and earliest date
wl = 0
wr = period.days
#the y-coordinates of the world view is the range between the largest high and smallest low from stockReader
wt = stockReader.getLHigh()
wb = stockReader.getSLow()
self.viewPort = ViewPort(wl, wr, wt, wb,
vl, vr, vt, vb)
self.initDraw(vl, vr, vt, vb, stockReader)
self.drawGraph(stockReader)
self.canvas.pack(fill=BOTH, expand=1)
def set_child (self, child=None):
"""B.set_child (...) -> None
Sets the child to display in the ScrolledList.
Creates a parent-child relationship from the ScrolledList to a
widget. If the widget does not support native scrolling, it will
be packed into a ViewPort.
"""
self.lock ()
if child and not isinstance (child, ViewPort):
self.vscrollbar.value = 0
self.hscrollbar.value = 0
child = ViewPort (child)
child.minsize = self.minsize
Bin.set_child (self, child)
self.unlock ()
def render_scene(objects,res):
#create a viewport and image
v = ViewPort(res[0],res[1])
im = Image.new("RGB",(v.w,v.h))
pix = im.load()
#define a ray
ray = Ray(np.array([0,0,0]),np.array([0,0,-1]))
# Perform perspective ray-tracing
for col in range(v.w):
for row in range(v.h):
ray.o = v.getPixelCenter(col,row)
t = s.intersectRay(ray)
if (t != None):
xp = ray.getPoint(t)
pix[col,(v.h-1)-row] = phongShader(xp,s.getNormal(xp),s.material,light,eye)
# Show the image in a window
im.show()
def render_scene(objects, res):
#create a viewport and image
v = ViewPort(res[0], res[1])
im = Image.new("RGB", (v.w, v.h))
pix = im.load()
#define a ray
ray = Ray(np.array([0, 0, 0]), np.array([0, 0, -1]))
# Perform perspective ray-tracing
for col in range(v.w):
for row in range(v.h):
ray.o = v.getPixelCenter(col, row)
t = s.intersectRay(ray)
if (t != None):
xp = ray.getPoint(t)
pix[col,
(v.h - 1) - row] = phongShader(xp, s.getNormal(xp),
s.material, light, eye)
# Show the image in a window
im.show()
def __init__(self):
# GameObjects
self.sprites = None # A Pygame Group of all the sprites to draw
self.moving_sprites = None # A Pygame Group of all the movable sprites
self.bullet_sprites = None
self.platforms = None # A Pygame Group of platforms
self.player = None #The Player
# Physics
self.gravity = 0.21875
# Viewport
self.viewport = ViewPort(350, 450, 100, 450)
self.limit = 15000
def mouse_drag_event(self, event):
print("Mouse drag", event)
if self._movement is not None:
if self._mousepos is not None:
movementu = (event.x - self._mousepos.x) * self._MOUSESPEED
movementv = (event.y - self._mousepos.y) * self._MOUSESPEED
if self._movement == "camera_yx":
self._display.viewport = ViewPort(anglex = self._display.viewport.anglex + movementv, angley = self._display.viewport.angley + movementu, distance = self._display.viewport.distance)
elif self._movement == "lightpos_xz":
self._display.set_uniform("lightPos_WorldSpace", self._display.get_uniform("lightPos_WorldSpace").affect("xz", movementu * 0.25, movementv * 0.25))
elif self._movement == "lightpos_y":
self._display.set_uniform("lightPos_WorldSpace", self._display.get_uniform("lightPos_WorldSpace").affect("y", movementv * 0.25))
elif self._movement == "lightpower":
self._display.set_uniform("SpecularExp", self._display.get_uniform("SpecularExp") + movementu * 0.25)
self._display.set_uniform("LightPower", self._display.get_uniform("LightPower") * (1 - (movementv * 0.01)))
print("Power %4.0f Specular %5.3f" % (self._display.get_uniform("LightPower"), self._display.get_uniform("SpecularExp")))
else:
print("Unknown movement direction", self._movement)
self._display.mark_dirty()
self._mousepos = event
class Level(State):
def __init__(self):
# GameObjects
self.sprites = None # A Pygame Group of all the sprites to draw
self.moving_sprites = None # A Pygame Group of all the movable sprites
self.bullet_sprites = None
self.platforms = None # A Pygame Group of platforms
self.player = None #The Player
# Physics
self.gravity = 0.21875
# Viewport
self.viewport = ViewPort(350, 450, 100, 450)
self.limit = 15000
def init(self, engine):
engine.log("Init Level 2")
self.player = Mercenario()
self.sprites = pygame.sprite.Group()
self.platforms = pygame.sprite.Group()
self.moving_sprites = pygame.sprite.Group()
self.bullet_sprites = pygame.sprite.Group()
self.moving_sprites.add(self.player)
# WALL AND PLATFORM PLACEMENTS
wall = Platform(0, 550, self.limit, 50)
self.platforms.add(wall)
self.sprites.add(wall)
wall = Platform(0, 250, 150, 50)
self.platforms.add(wall)
self.sprites.add(wall)
wall = Platform(500, 450, 150, 50)
self.platforms.add(wall)
self.sprites.add(wall)
wall = Platform(252, 176, 490-252, 50)
self.platforms.add(wall)
self.sprites.add(wall)
wall = Platform(38, 430, 290-38, 50)
self.platforms.add(wall)
self.sprites.add(wall)
wall = Platform(578, 320, 994-578, 50)
self.platforms.add(wall)
self.sprites.add(wall)
self.sprites.add(self.player)
def handleEvents(self, engine, events):
for event in events:
if event.type == pygame.QUIT:
engine.exit()
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 1:
mousex, mousey = pygame.mouse.get_pos()
angle = getAngle(self.player.rect.x, self.player.rect.y, mousex, mousey)
p = self.player.shoot(angle)
if p:
self.bullet_sprites.add(p)
self.sprites.add(p)
self.player.control(event)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
engine.addState(PauseGameState(self.sprites))
if event.key == pygame.K_r:
engine.changeState(Level())
def update(self, engine):
self.player.update(self.platforms)
# Gravity
self.applyGravity(self.player)
# Bullets
for s in self.bullet_sprites:
s.update(self.moving_sprites)
#SHIFTING THE WORLD
self.viewport.update(self, self.player)
def shiftWorld(self, shift_x, shift_y):
for platform in self.platforms:
platform.rect.x += shift_x
platform.rect.y += shift_y
for s in self.bullet_sprites:
s.rect.x += shift_x
s.rect.y += shift_y
def applyGravity(self, sprite):
""" Calculate effect of gravity and applies it to the sprite. """
if not sprite.isGrounded:
sprite.velocity_y *= 0.99
sprite.velocity_y += self.gravity # Progressive incrmenting of the velocity (acceleration)
sprite.isGrounded = False
def draw(self, engine):
engine.screen.fill(Colors.BLUE)
self.sprites.draw(engine.screen)
class ChartingCanvas():
'''
paints the x-y plot (graph) based on the data
'''
def __init__(self, root, stockReader):
'''
Constructor
'''
self.canvas = Canvas(root)
self.canvas.pack(side="top", fill="both", expand=True)
self.init()
#The size of the canvas is (vr - vl) = 500 x (vb - vt) = 500
vl = 100
vr = 600
vt = 80
vb = 580
period = stockReader.getLDate() - stockReader.getEDate()
#the x-coordinates of the world view is the number of days between the latest date and earliest date
wl = 0
wr = period.days
#the y-coordinates of the world view is the range between the largest high and smallest low from stockReader
wt = stockReader.getLHigh()
wb = stockReader.getSLow()
self.viewPort = ViewPort(wl, wr, wt, wb,
vl, vr, vt, vb)
self.initDraw(vl, vr, vt, vb, stockReader)
self.drawGraph(stockReader)
self.canvas.pack(fill=BOTH, expand=1)
def initDraw(self, vl, vr, vt, vb, stockReader):
period = stockReader.getLDate() - stockReader.getEDate()
priceRange = stockReader.getLHigh() - stockReader.getSLow()
#draw grid lines. 11 for each sides. Also set dates and prices for the grid
for i in range(11):
#Get the whole range for date and price
dateText = (stockReader.getEDate() + i * period / 10).date()
priceText = (stockReader.getLHigh() - i * priceRange / 10)
#reformat to 2 decimal points
p = float("{0:.2f}".format(priceText))
#Drawing vertical grid and set text for each grid
x = vl + i * self.verGrid
self.drawVerticalLine(x, vt-10, (vb-vt)+20)
self.canvas.create_text(x, vb+10, text = str(dateText), font=("Arial", 5))
#Drawing horizontal grid and set text for each grid
y = vt + i * self.horGrid
self.drawHorizontalLine(vl-10, y, (vr - vl)+20)
self.canvas.create_text(vl-25, y, text = str(p), font=("Arial", 5))
#set the chart name
self.canvas.create_text(700/2, 700 / 15, text = (str(stockReader.symbol) + " Stock Prices"), font=("Arial", 20))
#set title for horizontal
self.canvas.create_text(700/2, 700 - 50, text = "Dates", font=("Arial", 9))
#Plot the graph based on the data from stock reader
def drawGraph(self, stockReader):
for stock in stockReader.stock_list:
wx = (stock.date - stockReader.getEDate()).days
wy = stock.op
#Get vx, vy from wx, wy based on viewPort
vx, vy = self.viewPort.toPixels(wx, wy)
#Draw the point on the graph
x1, y1 = ( vx - 1 ), ( vy - 1 )
x2, y2 = ( vx + 1 ), ( vy + 1 )
self.canvas.create_oval( x1, y1, x2, y2, fill = "#A8FDA0" )
def init(self):
self.verGrid = 50
self.horGrid = 50
self.chartTitle = "Stock Graph"
self.horTitle = ""
self.verTitle = ""
#Getters and setters
def getVerGrid(self):
return self.verGrid
def setVerGrid(self, verGrid):
self.verGrid = verGrid
def getHorGrid(self):
return self.horGrid
def setHorGrid(self,horGrid):
self.horGrid = horGrid
def getVerTitle(self):
return self.verTitle
def setVerTitle(self, verTitle):
self.verTitle = verTitle
def getHorTitle(self):
return self.horTitle
def setHorTitle(self, horTitle):
self.horTitle = horTitle
def getChartTitle(self):
return self.chartTitle
def setChartTitle(self, chartTitle):
self.chartTitle = chartTitle
def getData(self):
return self.data
def setData(self, data):
self.data = data
def drawVerticalLine(self,x1,y1,length):
self.canvas.create_line(x1,y1,x1,y1+length)
def drawHorizontalLine(self,x1,y1,length):
self.canvas.create_line(x1,y1,x1+length,y1)
def reset_viewport(self):
self.viewport = ViewPort(anglex=65, angley=0, distance=18)
def run():
timeStart = time.time()
perspective = True
jittering = False
numJitters = 8
jitterArray = Halton.halton_sequence(numJitters, 2)
o = AccelStruct()
lights = []
# OBJ file
# m = Parser.parse("meshes/dragon.obj", transform=np.dot(Helper.scaleMatrix(0.7, 0.7, 0.7),
# Helper.translationMatrix(1.25, 1.25, 1.75)))
# print(m.min)
# print(m.max)
# o.add(m)
# Cornell Box
# o.add(RectFace([0, 0, 0], [550, 0, 0], [0, 0, 550], mat=[250, 250, 250])) # floor
# o.add(RectFace([0, 550, 0], [0, 550, 550], [550, 550, 0], mat=[250, 250, 250])) # ceiling
# o.add(RectFace([0, 0, 550], [550, 0, 550], [0, 550, 550], mat=[250, 250, 250])) # back wall
# o.add(RectFace([0, 0, 0], [0, 0, 550], [0, 550, 0], mat=[0, 250, 0])) # right wall
# o.add(RectFace([550, 0, 0], [550, 550, 0], [550, 0, 550], mat=[250, 0, 0])) # left wall
# o.add(Box([130, 0, 65], [160, 0, 49], [-49, 0, 160], [0, 165, 0], mat=[255, 255, 255])) # short box
# o.add(Box([265, 0, 296], [158, 0, -49], [49, 0, 158], [0, 330, 0], mat=[255, 255, 255])) # tall box
# # lights.append(AreaLight([213, 549, 227], [343, 549, 227], [213, 549, 332], o))
# lights.append(PointLight([300, 540, 200]))
# viewPt = np.array([278.0, 273.0, -800.0])
# viewDir = Helper.normalize(np.array([0.0, 0.0, 1.0]))
# viewUp = Helper.normalize(np.array([0.0, 1.0, 0.0]))
# viewPortDist = 1.0
# viewZoom = 1.5
# Blobby
# BlobbyParticles(o, [255, 0, 0], 0.1, *particles)
# for p in particles:
# o.add(Sphere(2.0, p, mat=[255, 0, 0]))
# Textures
# o.add(Plane([0, 0, 0], [0, 1, 0], mat=[250, 250, 250], minimum=[-10, -10, -10], maximum=[10, 10, 10], matfunc=grid))
# o.add(
# Plane([0, 0, -3], [0, 0, 1], mat=[250, 250, 250], minimum=[-10, -10, -10], maximum=[10, 10, 10], matfunc=grid))
o.add(Sphere(2.0, [-3, 1, -1], mat=[50, 130, 250], matfunc=marbleTexture))
# CSG
c = CSG(Sphere(3.0, [0, 3, 0], mat=[250, 0, 0], matfunc=grid))
c.add(Sphere(3.0, [1, 3, 0]), 1)
# c.add(Sphere(3.0, [0.5, 0, 0]), 1)
o.add(c)
lights.append(PointLight([0, 10, 2]))
viewPt = [0, 2, 6]
viewDir = [0, 0, -1]
viewUp = [0, 1, 0]
viewPortDist = 1.0
viewZoom = 0.5
# create a viewport and image
v = ViewPort(resolution, resolution, viewPt, viewDir, viewUp, viewPortDist,
viewZoom)
a = np.zeros((v.h, v.w, 3))
o.calculate()
print("Total time to setup objects: {:.3}s".format(time.time() -
timeStart))
timeStart = time.time()
with concurrent.futures.ThreadPoolExecutor() as e:
futures = []
for row in tqdm(range(v.h)):
for col in range(v.w):
if jittering:
for n in range(numJitters):
ray = Ray(
v.getPixelCenterJittered(col, row, jitterArray, n),
viewDir)
if perspective:
ray.d = Helper.normalize(ray.o - viewPt)
futures.append(
e.submit(Helper.rayTrace, ray, o, lights, row, col,
0))
else:
ray = Ray(v.getPixelCenter(col, row), viewDir)
if perspective:
ray.d = Helper.normalize(ray.o - viewPt)
futures.append(
e.submit(Helper.rayTrace, ray, o, lights, row, col, 0))
with tqdm(total=v.h * v.w * numJitters if jittering else v.h *
v.w) as pbar:
for future in concurrent.futures.as_completed(futures):
(row, col, color) = future.result()
pbar.update()
if color is not None:
if jittering:
a[row, col] += color / numJitters
else:
a[row, col] = color
timeEnd = time.time()
time.sleep(0.1)
print("Total time to compute ray trace on {:} pixels: {:.4}s".format(
v.w * v.h, timeEnd - timeStart))
print("Average time to compute each pixel: {:.3}ms".format(
1000.0 * (timeEnd - timeStart) / (v.w * v.h)))
# a *= 255.0/a.max()
im = Image.new("RGB", (v.w, v.h))
pix = im.load()
for row in range(v.h):
for col in range(v.w):
pix[row, (v.w - 1) - col] = tuple(a[row, col].astype(int))
im.save('out.bmp')
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS WITH THE SOFTWARE.
"""
import numpy as np
import matplotlib.pyplot as pt
import random
from PIL import Image
from Sphere import Sphere
from Ray import Ray
from ViewPort import ViewPort
#create a viewport and image
v = ViewPort(500,500)
im = Image.new("RGB",(v.w,v.h))
pix = im.load()
#define a sphere
radius = 1.0
center = np.array([0,0, -2.5])
s = Sphere(radius,center,np.array([255,0,0]))
#define a ray
ray = Ray(np.array([0,0,0]),np.array([0,0,-1]))
# define a light direction
ldir = np.array([0,0,1]) #light direction
kd = 0.75 #reflectivity
illum = 1.0 #light luminosity
def __init__(self, scrolledlist):
self._scrolledlist = scrolledlist
self._images = {}
self._realwidth = 0
self._realheight = 0
ViewPort.__init__(self, None)
def __init__ (self, scrolledlist):
self._scrolledlist = scrolledlist
self._images = {}
self._realwidth = 0
self._realheight = 0
ViewPort.__init__ (self, None)
from Ray import Ray
from ViewPort import ViewPort
from Reflect import Reflect
from Plane import Plane
from Triangle import Triangle
from operator import itemgetter
from PhongShading import PhongShading
from math import *
from ObjReader import objRead
from Octree import Onode, Octree
from SoftShading import SoftShading
from Trans import Transparency
from glossy import Glossy
#create a viewport and image
v = ViewPort(np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, -10.0]),
np.array([0.0, 1.0, 0.0]), 5.0, 10.0, 500)
im = Image.new("RGB", (v.w, v.h))
pix = im.load()
tree = Octree()
#define a point light
light = SoftShading(np.array([-1.0, 10.0, 0.0]), np.array([1.0, 10.0, 0.0]),
np.array([-1.0, 12.0, 0.0]), np.array([1.0, 12.0, 0.0]),
np.array([1.0, 1.0, 1.0]), 0.8)
#define a sphere
radius = 1.0
#materialS = np.array([1.0,0.0,0.0])
#for j in range(-5, 5, 5):
# for i in range(-5, 5, 5):
CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS WITH THE SOFTWARE.
"""
import numpy as np
import matplotlib.pyplot as pt
import random
from PIL import Image
from Sphere import Sphere
from Ray import Ray
from ViewPort import ViewPort
#create a viewport and image
v = ViewPort(500, 500)
im = Image.new("RGB", (v.w, v.h))
pix = im.load()
#define a sphere
radius = 1.0
center = np.array([0, 0, -2.5])
s = Sphere(radius, center, np.array([255, 0, 0]))
#define a ray
ray = Ray(np.array([0, 0, 0]), np.array([0, 0, -1]))
# define a light direction
ldir = np.array([0, 0, 1]) #light direction
kd = 0.75 #reflectivity
illum = 1.0 #light luminosity
