def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material([0.2, 0.2, 0.2])
mat_s1 = Material(colors.P_Brass3, finish=Finish(transparent=True, ior=1.1))
mat_s2 = Material(colors.CornflowerBlue, finish=Finish(reflection=0.1))
mat_s3 = Material(colors.ForestGreen, finish=Finish(reflection=0.1))
mat_s4 = Material(colors.GreenCopper, finish=Finish(reflection=0.1))
# Scene Elements + Scene
se_ls = LightSourcePoint([-5., 10., 20.], intensity=1000.)
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([0., 0., 20.], 4.), mat_s1)
se_s2 = SceneElement(Sphere([5.0, -1., 15.], 2.), mat_s2)
se_s3 = SceneElement(Sphere([5.0, 0, 25.], 3.), mat_s3)
se_s4 = SceneElement(Sphere([-5.5, 0, 15.], 3.), mat_s4)
scene = Scene([se_ls, se_base, se_s1, se_s2, se_s3, se_s4])
# Render
rt = RayTracer(camera, scene)
traced = rt.render()
plt.imshow(traced); plt.show()
def set_scene():
cameras = [set_camera()]
light = set_light()
# Objects
objects = []
# Metallic sphere
mtl = Material(kr=0.7, specular=0.8)
shader_type = shaders.TYPE_DIFF_SPECULAR
radius = 0.2
pos = np.array([0.6, radius, 1])
sphere = Sphere(pos, mtl, shader_type, radius)
# normal_map = ImageTexture(NORMAL_MAP_FILENAME)
# normal_map.prepare_for_sphere()
# sphere.add_normal_map(normal_map)
objects.append(sphere)
# Mickey sphere
radius = 0.4
pos = np.array([-0.4, radius, 1.5])
mtl = Material(material_type=material.TYPE_TEXTURED, specular=0.5)
shader_type = shaders.TYPE_DIFF_SPECULAR
texture = ImageTexture(MICKEY_FILENAME)
box_size = 1.8 * radius
box = Box(pos, box_size, box_size, box_size)
mtl.add_texture(SolidImageTexture(texture, box))
sphere = Sphere(pos, mtl, shader_type, radius)
objects.append(sphere)
create_cube(objects)
return Scene(cameras, [light], objects)
def build_shielded_geometry():
air = Material(0.1, color='white')
u235_metal = Material(1.0, color='green')
poly = Material(1.0, color='red')
steel = Material(1.0, color='orange')
box = create_hollow(create_rectangle(20., 10.), create_rectangle(18., 8.))
hollow_circle = create_hollow(create_circle(3.9), create_circle(2.9))
hollow_circle.translate([-9 + 3.9 + 0.1, 0.])
small_box_1 = create_rectangle(2., 2.)
small_box_1.translate([6., 2.])
small_box_2 = create_rectangle(2., 2.)
small_box_2.translate([6., -2.])
#sim = Simulation(air, 50., 45., 'arc')
sim = Simulation(air,
100,
diameter=50.,
detector='plane',
detector_width=30.)
sim.detector.width = 30.
sim.geometry.solids.append(Solid(box, steel, air))
sim.geometry.solids.append(Solid(hollow_circle, steel, air))
sim.geometry.solids.append(Solid(small_box_1, poly, air))
sim.geometry.solids.append(Solid(small_box_2, steel, air))
sim.geometry.flatten()
return sim
def main():
""" create window, add shaders & scene objects, then run rendering loop """
width = 640
height = 480
camera = Camera(vec(0, 0, -5), 60, height / width, .3, 1000)
scene = Scene(camera,
light=vec(-.57735026919, -.57735026919, .57735026919) * .5)
pyramidMesh = Mesh(vertices=np.array(
((0, .5, 0), (.5, -.5, 0), (-.5, -.5, 0)), 'f'),
normals=np.array(
((0, 0, -1), (0.70710678118, 0, -0.70710678118),
(-0.70710678118, 0, -0.70710678118)), 'f'),
perVertexColor=np.array(
((1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)),
'f'),
indexes=np.array((0, 1, 2), 'u4'))
suzanne = Mesh.LoadMeshes("models/suzanne.obj")[0]
scene.Add3DObject(
Object3D(0,
translate(-1.5, 0, 1) @ rotate(vec(0.0, 1.0, 0.0), -200),
suzanne, Material("shaders/rainbow_shaded.frag")))
scene.Add3DObject(
Object3D(1,
translate(1.5, 0, 1) @ rotate(vec(0.0, 1.0, 0.0), 200),
suzanne, Material("shaders/shaded.frag")))
renderer = Renderer(scene)
renderer.Run()
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material([1., 1., 1.])
# mat_s1 = Material(colors.Aquamarine, finish=Finish(diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, transparent=True, ior=1.5))
# mat_s1 = Material(colors.Glass_Winebottle, finish=Finish(diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, transparent=True, ior=1.5))
mat_s1 = Material(colors.P_Silver3, finish=Finish(diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, transparent=True, ior=1.5))
mat_s2 = Material(colors.P_Copper3, finish=Medium, metallic=True)
mat_s3 = Material(colors.P_Chrome3, finish=Medium, metallic=True)
mat_s4 = Material(colors.P_Brass3, finish=Medium, metallic=True)
# Scene Elements + Scene
se_ls = LightSourcePoint([-5., 15., 20.], intensity=1000., emission_color=[2., 2., 2.])
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([0., 0., 20.], 4.), mat_s1)
se_s2 = SceneElement(Sphere([5.0, -1., 15.], 2.), mat_s2)
se_s3 = SceneElement(Sphere([3.0, 0, 22.], 2.), mat_s3)
se_s4 = SceneElement(Sphere([-5.5, 0, 15.], 3.), mat_s4)
scene = Scene([se_ls, se_base, se_s1, se_s2, se_s3, se_s4])
# Render
rt = RayTracer(camera, scene, num_bounces=5)
traced = rt.render()
plt.imshow(traced); plt.show()
def test_extra(self):
"""test_extra: Test extra values to make sure the code should work with any material
objects
"""
known_correct_values = {
"Ruby": 2,
"Copper": 7,
"Diamond": 1,
"Plastic": 1,
"Gold": 4
}
gold = Material('Gold', 4, 100)
copper = Material('Copper', 7, 65)
plastic = Material('Plastic', 15, 50)
diamond = Material('Diamond', 1, 1000)
ruby = Material('Ruby', 2, 500)
materials = [gold, plastic, copper, diamond, ruby]
lorry1 = Lorry(15)
lorry1.pickup_delivery(materials)
self.assertEqual(lorry1.cargo, known_correct_values)
self.assertEqual(lorry1.load_composition, 2905)
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
base_finish = SoftDull
base_finish.reflection = 0.1
mat_base = Material(colors.P_Chrome3, finish=base_finish)
mat_s1 = Material(colors.P_Brass3)
se_ls = LightSourcePoint([-1., 5., 35.],
intensity=200.,
emission_color=[2., 2., 2.])
se_base = SceneElement(Plane([0.0, -4.0, 20.], [0., 1., 0.]), mat_base)
se_s1 = SceneElement(Sphere([0., 0., 40.], 4.), mat_s1)
scene = Scene([se_ls, se_base, se_s1])
# scene = Scene([se_ls, se_base])
# Render
rt = RayTracer(camera, scene)
traced = rt.render()
plt.imshow(traced)
plt.show()
def setUp(self):
mat10 = Material(E11=38000., E22=9000., G12=3600., nu12=0.32, t=1.)
mat15 = Material(E11=38000., E22=9000., G12=3600., nu12=0.32, t=1.5)
self.lam = clt.Laminate([(15, mat15), (-30, mat10), (-15, mat15),
(30, mat10)])
# mload = np.array([2000, 1000, 500, 0, 0, 0]) # used in text
mload = np.array([1000, 500, 250, 0, 0, 0]) # used in calculations
self.sol = self.lam.get_linear_response(mload)
def main():
"""main: Driver code to show working implimentation of labsheet question
"""
gold = Material('Gold', 4, 100)
copper = Material('Copper', 7, 65)
plastic = Material('Plastic', 15, 50)
materials = [gold, plastic, copper]
lorry1 = Lorry(10)
lorry1.pickup_delivery(materials)
print(lorry1)
def ray_trace_test_geometry():
air = Material(0.0, color='white')
steel = Material(1.0, color='red')
box = create_hollow(create_rectangle(12., 12.), create_rectangle(10., 10.))
ring = create_hollow(create_circle(12.), create_circle(10.))
box.rotate(45.)
sim = Simulation(air, diameter=50.)
sim.detector.width = 30.
sim.geometry.solids.append(Solid(ring, steel, air))
sim.geometry.flatten()
return sim
def test_labsheet(self):
"""test_labsheet: Test labsheet values
"""
known_correct_values = {"Gold": 4, "Copper": 6}
gold = Material('Gold', 4, 100)
copper = Material('Copper', 7, 65)
plastic = Material('Plastic', 15, 50)
materials = [gold, plastic, copper]
lorry1 = Lorry(10)
lorry1.pickup_delivery(materials)
self.assertEqual(lorry1.cargo, known_correct_values)
self.assertEqual(lorry1.load_composition, 790)
def render():
# with open('examples/cube.obj') as f:
with open('examples/teapot.obj') as f:
lines = f.readlines()
# simple (read stupid) parser for obj files
V = []
F = []
for line in lines:
line = line.replace(' ', ' ')
if line[0:2] == "v ":
V.append(map(float, line.strip().split(' ')[1:]))
elif line[0:2] == "f ":
f = line.strip().split(' ')[1:]
f = map(lambda x: int(x.split('/')[0])-1, f)
F.extend(f)
n_polys = len(F) / 3
fi = [3 for _ in range(n_polys)]
# n_polys, fi, V, F = down_sample(n_polys, fi, V, F)
tm = TriangleMesh(n_polys, fi, F, np.array(V).T, clockwise=True)
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 2)
camera.translate([0, 0, -100])
# camera = Camera(w, h, fov=np.pi / 3)
# Materials
mat_base = Material([0.2, 0.2, 0.2])
# mat_s1 = Material(colors.NeonPink, diffuse=0.7, ambient=0.1, specular=0.8, roughness=1./120, reflection=0.)
mat_s1 = Material(colors.NeonPink, finish=VerySoftDull)
se_ls = LightSourceDirectional([1, -1, 0], intensity=2., emission_color=[1., 1., 1.])
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_tm = SceneElement(tm, mat_s1)
scene = Scene([se_ls, se_tm])
# Render
rt = RayTracer(camera, scene, num_bounces=0, background_color=0.5*np.ones((3, 1)))
traced = rt.render()
plt.imshow(traced); plt.show()
import ipdb; ipdb.set_trace()
def render_moon(scene):
light = Light(Color(1.0, 1.0, 1.0, 1.0), 1.0)
light.transform.position = Vector3(0.0, 2.0, -2.0)
scene.set_light(light)
lambertianTintMaterial = Material()
lambertianTintMaterial.albedo = Color(1.0, 1.0, 1.0, 1.0)
lambertianTintMaterial.shader = LambertianTintShader()
s1_earth = Sphere(0.6)
s1_earth.transform.position = Vector3(0, 0, 1.5)
s1_earth.material = lambertianTintMaterial.clone()
scene.add_objects(s1_earth)
s2_moon = Sphere(0.4)
s2_moon.transform.position = Vector3(-0.2, -0.5, 1.2)
s2_moon.material = lambertianTintMaterial.clone()
s2_moon.material.set_texture(Texture("images/moon.jpg"))
scene.add_objects(s2_moon)
v1 = Vector3(0.0, 1.5, 0.5)
v2 = Vector3(0.5, -1.0, 0.0)
animation_velocity = 0.4
def update_method(t):
p = Vector3(-0.2, -0.5, 1.2)
p = p.add(v1.multiply(np.cos(animation_velocity * t * np.pi)))
p = p.add(v2.multiply(np.sin(animation_velocity * t * np.pi)))
s2_moon.transform.position = p
s2_moon.transform.rotation = Vector3(
0.0, np.mod(0.5 * animation_velocity * t, 360), 0.0)
return update_method
def registrarMaterial():
material = Material(db)
data = request.get_json(force=True)
material.crear(data)
respuesta = make_response("Hello World")
respuesta.headers.add("Access-Control-Allow-Origin", "*")
return respuesta
def __init__(self): self.robot = Robot() self.basic = Basic() self.material = Material() self.dao = Dao() self.dao.connect() self.spider = Spider()
def test_default_material(self):
m = Material()
self.assertEqual(m.color, Color(1, 1, 1))
self.assertEqual(m.ambient, 0.1)
self.assertEqual(m.diffuse, 0.9)
self.assertEqual(m.specular, 0.9)
self.assertEqual(m.shininess, 200.0)
def create_cube(objects):
sx = 2
sy = 2
shader_type = shaders.TYPE_LIGHT_MAP
positions = [
np.array([-1, 1, 1]),
np.array([1, 1, 1]),
np.array([0, 1, 0]),
np.array([0, 1, 2]),
np.array([0, 0, 1]),
np.array([0, 2, 1]),
]
n0, n1, n2 = DEFAULT_N0, DEFAULT_N1, DEFAULT_N2
ns = [n0, -n0, n2, -n2, n1, -n1]
n0s = [n1, n1, n0, n0, n0, n0]
colors = [
material.COLOR_GREEN, material.COLOR_RED, material.COLOR_GRAY,
material.COLOR_GRAY, material.COLOR_GRAY, material.COLOR_GRAY
]
for i in range(6):
mtl = Material(colors[i])
illumination_map = IlluminationTexture()
mtl.add_illumination_map(illumination_map)
plane = Plane(positions[i], mtl, shader_type, ns[i], n0s[i], sx, sy)
objects.append(plane)
def build_flat_plane(self):
scene = Scene(self.screen, self.camera_position, COLOUR_WHITE, self.scale)
count = 1
for x in range(count):
for y in range(count):
s = int(self.screen.width / count)
cube_material = Material(
(0 + int(random.random() * 100), 150 + int(random.random() * 100), int(1 * random.random())),
# (0,0,255),
(0.5, 0.5, 0.5),
(0.8, 0.8, 0.8),
(0.5, 0.5, 0.5),
50
)
rectangle = Rectangle(
Point(x * s - self.screen.width/2, -self.screen.height / 2, self.screen.distance + y * s),
Point(x * s - self.screen.width/2, -self.screen.height / 2, self.screen.distance + (y+1) * s),
Point((x+1) * s - self.screen.width/2, -self.screen.height / 2, self.screen.distance + y * s),
cube_material
)
scene.add_object(rectangle)
light_position = Point(-self.screen.width/4,-self.screen.height/2 + 50, self.screen.width * 4 + self.screen.distance)
light = Light(light_position)
scene.add_light(light)
return scene
def get_material(self, info):
name = info["name"]
if name in self._material_dict:
print("factory get from gw: ", name)
return self._material_dict[name]
if "material" in info["type"]:
m = Material(name)
m.init(info)
self._material_dict[name] = m
return m
elif "device" in info["type"]:
if "furnace" in info["type"]:
m = Furnace(name)
m.init(info)
self._material_dict[name] = m
self._device_set.add(m)
return m
elif "manufactureStation" in info["type"]:
m = ManufactureStation(name)
m.init(info)
self._material_dict[name] = m
self._device_set.add(m)
return m
else:
raise FactoryError("error device: " + name)
else:
raise FactoryError("Error Material: " + name)
def main():
WIDTH = 800
HEIGHT = 400
camera = Vector(0, 0, -1)
objects = [
Sphere(Point(0, 0, 0), 0.5, Material(Color.fromHEX("#FF0000"))),
Sphere(Point(1, 0, 0), 0.5, Material(Color(0, 1, 0))),
Sphere(Point(-1, 0, 0), 0.5, Material(Color(0, 0, 1)))
]
lights = [Light(Point(10, 5, -10.0), Color.fromHEX("#FFFFFF"))]
scene = Scene(camera, objects, lights, WIDTH, HEIGHT)
engine = RenderEngine()
image = engine.render(scene)
with open("test.ppm", "w") as img_file:
image.writePPM(img_file)
def set_scene():
pos = np.array([0.0, 0.25, 0.6])
mat = Material(COLOR_BLUE)
radius = 0.25
sphere = Sphere(pos, mat, shaders.TYPE_FLAT, radius)
cameras = [set_camera()]
return Scene(cameras, [], [sphere])
def test_material1(self):
m = Material()
self.assertTrue(Color(1, 1, 1).equals(m.color))
self.assertEqual(0.1, m.ambient)
self.assertEqual(0.9, m.diffuse)
self.assertEqual(0.9, m.specular)
self.assertEqual(200.0, m.shininess)
def __init__(self, locations_database):
self.input = Read_excel_input()
self.locations = Location_Masterdata(locations_database)
self.requester_name = self.input.requester_name
self.requester_contacts = self.input.requester_contacts
self.stackable = self.input.stackable
self.dangerous_goods = self.input.dangerous_goods
self.li_ion = self.input.li_ion
self.ready_date = functions.date_by_adding_business_days(
datetime.date.today(), 5)
#shipper information:
self.shipper_code = self.input.shipper_code
self.shipper_company_name = self.locations.get_location_object(
self.shipper_code)['Company Name']
self.shipper_address = self.locations.get_location_object(
self.shipper_code)['Address']
#destination information:
self.destination_code = self.input.destination_code
self.incoterm = self.locations.get_location_object(
self.destination_code)['Incoterm']
self.airport = self.locations.get_location_object(
self.destination_code)['Airport']
self.destination_company_name = self.locations.get_location_object(
self.destination_code)['Company Name']
self.destination_address = self.locations.get_location_object(
self.destination_code)['Address']
self.reference_ID = functions.create_unique_reference(
self.locations.get_location_object(
self.destination_code)['Address']['Country'].replace(" ", "_"))
#list of shipment items:
self.material_dict = self.input.material_dict
self.material_object_array = []
for key, value in self.material_dict.items():
self.material_object_array.append(Material(key, value))
def __init__(self,
name,
height=DEFAULT_HEIGHT,
width=DEFAULT_WIDTH,
depth=DEFAULT_DEPTH,
start_pos=Vector3(0, 0, 0),
color=Color(0, 1, 0, 1)):
self.height = height
self.width = width
self.depth = depth
self.name = name
self.position = start_pos
self.rotation = Quaternion.identity()
self.scale = Vector3(1, 1, 1)
if (height == self.DEFAULT_HEIGHT) and (
width == self.DEFAULT_WIDTH) and (depth == self.DEFAULT_DEPTH):
self.mesh = self.BLOCK_MESH
else:
self.mesh = Mesh.create_cube((self.width, self.height, self.depth))
self.material = Material(color, "Block Material")
self.children = []
self.my_collider = AABB_Collider(
Vector3(self.width, self.height, self.depth))
def __init__(self,
scene,
vertices,
normals,
M=poseMatrix(),
primitive=GL_LINES,
material=None):
"""
:param scene: reference to the scene the model is instantiated in
:param vertices: model vertices read from obj file
:param normals: model normals read from obj file
:param M:position matrix
:param material:
:param primitive:
"""
BaseModel.__init__(self,
scene=scene,
M=M,
primitive=primitive,
visible=True)
# initialize the vertices/normals/indices of the shape
self.vertices = vertices
self.normals = normals
self.indices = None
# set position and other attributes necessary for drawing
self.vertex_colors = np.zeros((self.vertices.shape[0], 3), dtype='f')
# override the default material
self.material = Material(Ka=np.array([0.0, 0.0, 0.0], 'f'),
Kd=np.array([0.5, 0.5, 0.5], 'f'),
Ks=np.array([1.0, 1.0, 1.0], 'f'),
Ns=10.0)
def __init__(self):
if Missile.missile_mesh is None:
Missile.missile_mesh = Missile.create_missile_mesh()
Missile.missile_material = Material(Color(1, 0, 0, 1),
"MissileMaterial")
super().__init__("Missile")
# Determine the spawn position. There's 33% chance it comes from the right, 33% that it
# comes from behind the mountains, and 34% chance it comes from the left
self.position = Vector3(0, random.uniform(0, 3), 12)
r = random.uniform(0, 100)
if r > 66:
self.position.x = 7
self.rotation = Quaternion.AngleAxis(Vector3(0, 1, 0),
math.radians(-90))
elif r > 33:
self.position.y = -2
self.position.x = random.uniform(-4, 4)
self.rotation = Quaternion.AngleAxis(Vector3(1, 0, 0),
math.radians(-90))
else:
self.position.x = -7
self.rotation = Quaternion.AngleAxis(Vector3(0, 1, 0),
math.radians(90))
# Set the mesh and material of the missile
self.mesh = Missile.missile_mesh
self.material = Missile.missile_material
# Sets the missile linear speed
self.missile_speed = 2
# Sets the rotation speed (in radians per second)
self.missile_rotation_speed = 0.75
def upload_files():
if request.method == 'POST':
if 'file[]' not in request.files:
flash('No file part')
return redirect(request.url)
files = request.files.getlist("file[]")
# if user does not select file, browser also submit an empty part without filename
import time
for file in files:
print(file.filename)
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
type, folder = get_type_folder(file.filename)
# filename = secure_filename(file.filename)
filename = str(time.time()).replace(
".", "") + "." + file.filename.rsplit('.', 1)[1].lower()
material = Material(file, filename,
app.config['UPLOAD_FOLDER'] + "/" + folder)
material.save()
print("\n\n2" + str(file.filename) + "->" + filename + "\n\n")
return redirect(url_for('upload_file', filename=filename))
return {"error": "405"}
def render():
(w, h) = (640, 480)
camera = Camera(w, h, fov=np.pi / 6)
# Materials
mat_base = Material(colors.DimGray)
mat_s1 = Material(colors.P_Silver3,
finish=Finish(reflection=0.,
specular=0.8,
roughness=1. / 20))
mat_s2 = Material(colors.P_Brass3,
finish=Finish(ambient=0.25,
diffuse=0.5,
transparent=True,
specular=0.8,
roughness=1. / 80,
ior=1.5),
metallic=True)
se_ls = LightSourcePoint([-5., 10., 20.], intensity=1000.)
se_ls2 = LightSourceDirectional([1., -1., 1.], intensity=0.5)
se_base = SceneElement(Sphere([0.0, -10004., 20.], 10000.), mat_base)
se_s1 = SceneElement(Sphere([-3., -1., 20.], 2.), mat_s1)
se_s2 = SceneElement(Sphere([0, -1., 35.], 2.), mat_s1)
se_s3 = SceneElement(Sphere([4., -1., 40.], 2.), mat_s1)
se_s4 = SceneElement(Sphere([9., -1., 55.], 2.), mat_s1)
scene = Scene([se_ls, se_ls2, se_base, se_s1, se_s2, se_s3, se_s4])
# Render
rt = RayTracer(camera, scene)
traced_nodov = rt.render()
traced = rt.render_dov([-3., -1., 20.], num_samples=8)
# traced = rt.render_dov([0, -1., 35.], num_samples=8)
# traced = rt.render_dov([4., -1., 40.], num_samples=8)
# traced = rt.render_dov([9., -1., 55.], num_samples=4)
# traced = rt.render()
plt.subplot(211)
plt.imshow(traced_nodov)
plt.subplot(212)
plt.imshow(traced)
plt.show()
def materialExists():
material = Material(db)
data = request.get_json(force=True)
numSerie = data['numSerie']
if(material.exists(numSerie)):
return jsonify(material.jsonExists(numSerie))
else:
return str(False)
def setCnc(self):
self.cnc = Shapeoko()
self.loadTools()
self.cnc.setTool(self.toolList[0])
self.material = Material({})
self.cnc.setMaterial(self.material)
