def _spherepack_curl():
"""
Calculate curl using SPHEREPACK spectral methods.
If the value of R_sphere is not the same as the earth radius
used in package sphere, adjust curl to reflect R_sphere. A
Numeric array is returned.
SPHEREPACK outputs a number of diagnostic messages to
stdout (and perhaps to stderr). The one that's irritating
is the one saying data will be converted to Float32. Thus,
we silently ensure that calculations are used only on Float32
data, to surpress the warnings. I did this because redirect-
ing stdout/stderr turned out to be too difficult; just
altering the sys attributes didn't work.
"""
import sphere
sph_obj = sphere.Sphere( x.astype(ma.Float32) \
, y.astype(ma.Float32) )
if np.allclose(np.array(R_sphere), sphere.radius):
curl = sph_obj.vrt( Fx.astype(ma.Float32) \
, Fy.astype(ma.Float32) )
else:
curl = sph_obj.vrt( Fx.astype(ma.Float32) \
, Fy.astype(ma.Float32) ) \
* sphere.radius / R_sphere
return curl
def animate():
#This opens the original code and reads it into a string so I can work with it
file = open('base.pov')
text = file.read()
file.close()
i = 0
while i < 10:
sphere1 = sphere.Sphere(0, 0, 1.4, 1)
match = re.search("^sphere\s{.......................", text, re.DOTALL)
insertString = ""
if match:
insertString += bounceBall(sphere1, match.group(), i)
text = text.replace(match.group(), insertString)
else:
print "No match Found"
outfile = 'tmp2.pov'
fileOut = open(outfile, 'w')
fileOut.write(text)
fileOut.close()
picNo = i
pov_cmd = ' pvengine.exe +I%s +O%s -D -V +A +H600 +W800'
cmd = pov_cmd % ('tmp2.pov', str(picNo).zfill(4) + "temp2.png")
os.system(cmd)
i += 1
return i
def intersectsSprite(self, sprite):
sph = sphere.Sphere()
sph.center.set(0, 0, 0)
sph.radius = 0.7071067811865476
sph.applyMatrix4(sprite.matrixWorld)
return self.intersectsSphere(sph)
def setup():
global shaderSystem, grid_image, grid_texture, planet, cam
# One-time GL setup
pyglet.gl.glClearColor(1, 1, 1, 1)
shaderSystem = ShaderSystem()
mainShader = shaderSystem.createShader("main")
grid_image = pyglet.image.load('images/grid.png')
grid_texture = grid_image.get_texture()
planet = sphere.Sphere(1.0)
cam = camera.Camera(position=Vector3(0.0, 0.0, -10.0))
mainShader.unbind()
def __init__(self, points):
'''
Initializes the triangle by setting its 3 corner points.
Inputs: points -> the three coordinate points of the triangle
'''
self.points = points
p, q, r = self.points[:, 0], self.points[:, 1], self.points[:, 2]
# calculate the triangle sphere's center and radius
center, radius = sphere.calc_cr(p, q, r)
# the bounding sphere of the triangle
self.sphere = sphere.Sphere(center, radius)
def __init__(self, number_of_spheres, max_size, max_mass, box_size,
elasticity, friction):
self.balls = []
self.max_size = max_size
self.max_mass = max_mass
for i in range(number_of_spheres):
self.balls.append(sphere.Sphere(elasticity, friction))
for ball in self.balls:
ball.reset(self.max_size, self.max_mass, box_size, self.balls)
def intersectsObject(self, object):
sph = sphere.Sphere()
geometry = object.geometry
if geometry.boundingSphere is None:
geometry.computeBoundingSphere()
sph.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld)
return self.intersectsSphere(sph)
def main():
while True:
start_rad = float (input("What size Sphere do you want?\nEnter 0 to quit.") )
if start_rad == 0:
break
else:
mySphere = sphere.Sphere(start_rad)
print("The Diameter of your Sphere is",
mySphere.diameter() )
print("The Circumference of your Sphere is", mySphere.circumference())
print("The Surface Area of your Sphere is", mySphere.surface())
print("The Volume of your Sphere is", mySphere.volume())
def main():
problema = sphere.Sphere()
individuos = 32
dimensiones = [2, 4, 8, 16]
intervalos = 8
a = 1
Q = 20
evaporacion = 0.9
t0 = 0.00001
generaciones = 2000
for dim in dimensiones:
for i in range(5):
aco = ACO.ACO(i, individuos, dim, intervalos, a, Q, evaporacion,
t0, problema, generaciones)
aco.run()
def main():
problema = sphere.Sphere()
problema_nombre = "sphere"
cantidadParticulas = 50
iteraciones = 2000
dimensiones = 2
for dim in range(4):
for i in range(5):
de = DifferentialEvolution.DE(iteraciones,
cantidadParticulas,
dimensiones,
problema,
problema_nombre,
i)
de.run()
dimensiones = dimensiones*2
def main():
problema = sphere.Sphere()
problema_nombre = "sphere"
cantidadParticulas = 50
tamanioVecindario = 16
iteraciones = 2000
dimensiones = 2
cognitionLearningRate = 1.4944
socialLearningRate = 1.4944
for dim in range(4):
for i in range(5):
spo = SwarmParticleOptimization.SPO(iteraciones,
cantidadParticulas,
tamanioVecindario, dimensiones,
cognitionLearningRate,
socialLearningRate, problema,
problema_nombre, i)
spo.run()
dimensiones = dimensiones * 2
def main():
ros = rosenbrock.Rosenbrock()
sph = sphere.Sphere()
qua = quartic.Quartic()
ras = rastrigin.Rastrigin()
aux = np.array([])
graph = np.array([])
ejecuciones = 1
draw = drawer.Drawer()
individuos = 32
dimensiones = 16
intervalos = 8
a = 1
Q = 20
evaporacion = 0.9
t0 = 0.00001
generaciones = 100
bestFitnessPos = 100
graphName = "Quartic" + str(dimensiones) + "D"
aco = ACO.ACO(individuos, dimensiones, intervalos, a, Q, evaporacion, t0,
ras, generaciones, bestFitnessPos)
for i in range(ejecuciones):
aux = aco.run()
if i == 0:
graph = aux
else: #Sumamos el resto de las ejecuciones.
for a in range(len(aux)):
graph[a] = graph[a] + aux[a]
for x in range(len(graph)):
graph[x] = graph[
x] / ejecuciones #Obtenemos el promedio de cada posicion
draw.drawIndividual(graph, graphName)
file = open(graphName + ".txt", "w")
for y in range(len(graph)):
file.write(str(graph[y]) + "\n")
file.close()
def main():
sphere_problem = sphere.Sphere()
rastrigin_problem = rastrigin.Rastrigin()
quartic_problem = quartic.Quartic()
rosenbrock_problem = rosenbrock.Rosenbrock()
population_size = 16
generations = 2000
mutation_rate = 0.1
for dimentions in [2, 4, 8]:
raw_sets = []
for i in range(5):
ag = PSAlgorithm.ParticleSwarmAlgorithm(population_size, dimentions, generations, mutation_rate, quartic_problem)
raw_sets.append(ag.run())
print(zip_average(raw_sets), dimentions)
plt.plot(range(100, generations+100, 100), zip_average(raw_sets), label = str(dimentions))
# plt.legend(['2', '4', '8'])
plt.legend()
plt.show()
eyeX = 3.0
eyeY = 0.0
eyeZ = 0.0
# gluLookAt 'up' coordinates
upX = 0.0
upY = 0.0
upZ = 1.0
mousePosX = 0
mousePosY = 0
isPressedMouseLeft = 0
isPressedMouseRight = 0
rotation = 0
Sph = sphere.Sphere(1.0)
Cyl = cylinder.Cylinder(0.75, 1.25, 16)
def InitGL(Width, Height):
# We call this right after our OpenGL window is created.
global eyeX, eyeY, eyeZ, upX, upY, upZ
# This Will Clear The Background Color To Black
glClearColor(0.0, 0.0, 0.0, 0.0)
glClearDepth(1.0) # Enables Clearing Of The Depth Buffer
glDepthFunc(GL_LESS) # The Type Of Depth Test To Do
glEnable(GL_DEPTH_TEST) # Enables Depth Testing
# glShadeModel(GL_SMOOTH) # Enables Smooth Color Shading
glShadeModel(GL_FLAT) # Enables Flat Color Shading
import transform
import light
import material
cam = camera.FreeCamera(bdgmath.Vector3(3, -7, 10), bdgmath.Vector3(0, 0, 4))
scene = scene.Scene()
scene.addLight(light.DirectionalLight(bdgmath.Vector3(-1, 0.5, -4), 0.8))
scene.addLight(light.AmbientLight(0.2))
floor = plane.ZPlane(0)
floor.squareSize = 2
scene.addObject(floor)
s = sphere.Sphere(bdgmath.Vector3(0, 0, 4), 2)
s.material = material.Reflect(
(0.4, 0.4, 0.4), # base color
0.5, # kR the amount of reflected light to use
0.3, # kD the amount of diffuse light to use
0.2, # kA the amount of ambient light to use
)
scene.addObject(s)
#repeatedSphere = repeated2d.Repeated2d(10, 10, s)
#scene.addObject(repeatedSphere)
plinth = box.Box(bdgmath.Vector3(1.5, 1.5, 1))
translatedPlinth = transform.Translate3d(bdgmath.Vector3(0, 0, 1), plinth)
scene.addObject(translatedPlinth)
#repeatedPlinth = repeated2d.Repeated2d(10, 10, translatedPlinth)
def load(self):
# 3D Model Loader
# load_model = models.Models("CornellBox-Original.obj")
# self.create_model(load_model, glm.vec3(0.0, 0.0, -2.0))
# First Scene: FOUR SPHERE
# self.primitives.append(sphere.Sphere(glm.vec3(0.0, 0.0, 0.0), 0.2))
# self.primitives.append(sphere.Sphere(glm.vec3(-0.5, 0.0, -1.0), 0.2))
# self.primitives.append(sphere.Sphere(glm.vec3(0.0, -0.5, -2.0), 0.2))
# self.primitives.append(sphere.Sphere(glm.vec3(0.0, 0.5, -3.0), 0.2))
# Second Scene: TRIFORCE
# self.primitives.append(triangle.Triangle(glm.vec3(0.0, 0.6, -2.0), glm.vec3(-0.2, 0.3, -2.0), glm.vec3(0.2, 0.3, -2.0)))
# self.primitives.append(triangle.Triangle(glm.vec3(-0.2, 0.3, -2.0), glm.vec3(-0.4, 0.0, -2.0), glm.vec3(0.0, 0.0, -2.0)))
# self.primitives.append(triangle.Triangle(glm.vec3(0.2, 0.3, -2.0), glm.vec3(0.0, 0.0, -2.0), glm.vec3(0.4, 0.0, -2.0)))
# Third Scene: THE WIZARD
# self.primitives.append(sphere.Sphere(glm.vec3(0.0, 0.5, -3.0), 0.2))
# self.primitives.append(triangle.Triangle(glm.vec3(0.0, 1.0, -0.5), glm.vec3(-1.0, -2.0, -3.0), glm.vec3(1.0, -2.0, -3.0)))
# Forth Scene: TRIANGLES
# self.primitives.append(triangle.Triangle(glm.vec3(-0.2, 0.3, -1.0), glm.vec3(-0.4, 0.0, -1.0), glm.vec3(0.0, 0.0, -1.0)))
# self.primitives.append(triangle.Triangle(glm.vec3(-0.2, 0.3, -1.5), glm.vec3(-0.4, 0.0, -1.5), glm.vec3(0.0, 0.0, -1.5)))
# self.primitives.append(triangle.Triangle(glm.vec3(-0.2, 0.3, -2.0), glm.vec3(-0.4, 0.0, -2.0), glm.vec3(0.0, 0.0, -2.0)))
# self.primitives.append(triangle.Triangle(glm.vec3(-0.2, 0.3, -2.5), glm.vec3(-0.4, 0.0, -2.5), glm.vec3(0.0, 0.0, -2.5)))
# self.primitives.append(triangle.Triangle(glm.vec3(-0.2, 0.3, -3.0), glm.vec3(-0.4, 0.0, -3.0), glm.vec3(0.0, 0.0, -3.0)))
# Pathtracer Scene: CORNELL BOX WITH SPHERES
# BACK
self.primitives.append(
triangle.Triangle(
glm.vec3(1.2, -1.2, -2.5), glm.vec3(-1.2, 1.2, -2.5),
glm.vec3(-1.2, -1.2, -2.5),
diffuse.Diffuse(brdf=glm.vec3(0.725, 0.71, 0.68))))
self.primitives.append(
triangle.Triangle(
glm.vec3(1.2, -1.2, -2.5), glm.vec3(1.2, 1.2, -2.5),
glm.vec3(-1.2, 1.2, -2.5),
diffuse.Diffuse(brdf=glm.vec3(0.725, 0.71, 0.68))))
# FLOOR
self.primitives.append(
triangle.Triangle(
glm.vec3(-1.2, -1.2, -2.5), glm.vec3(1.2, -1.2, -2.5),
glm.vec3(-1.2, -1.0, -1.0),
diffuse.Diffuse(brdf=glm.vec3(0.725, 0.71, 0.68))))
self.primitives.append(
triangle.Triangle(
glm.vec3(-1.2, -1.0, -1.0), glm.vec3(1.2, -1.2, -2.5),
glm.vec3(1.2, -1.0, -1.0),
diffuse.Diffuse(brdf=glm.vec3(0.725, 0.71, 0.68))))
# LEFT WALL
self.primitives.append(
triangle.Triangle(
glm.vec3(-1.2, -1.2, -2.5), glm.vec3(-1.2, -1.0, -1.0),
glm.vec3(-1.2, 1.2, -2.5),
diffuse.Diffuse(brdf=glm.vec3(0.14, 0.45, 0.091))))
self.primitives.append(
triangle.Triangle(
glm.vec3(-1.2, 1.2, -2.5), glm.vec3(-1.2, -1.0, -1.0),
glm.vec3(-1.2, 1.2, -1.0),
diffuse.Diffuse(brdf=glm.vec3(0.14, 0.45, 0.091))))
# RIGHT WALL
self.primitives.append(
triangle.Triangle(
glm.vec3(1.2, 1.2, -1.0), glm.vec3(1.2, -1.0, -1.0),
glm.vec3(1.2, 1.2, -2.5),
diffuse.Diffuse(brdf=glm.vec3(0.63, 0.065, 0.05))))
self.primitives.append(
triangle.Triangle(
glm.vec3(1.2, 1.2, -2.5), glm.vec3(1.2, -1.0, -1.0),
glm.vec3(1.2, -1.2, -2.5),
diffuse.Diffuse(brdf=glm.vec3(0.63, 0.065, 0.05))))
# CEILING
self.primitives.append(
triangle.Triangle(
glm.vec3(-1.2, 1.2, -1.0), glm.vec3(-1.2, 1.2, -2.5),
glm.vec3(1.2, 1.2, -2.5),
diffuse.Diffuse(brdf=glm.vec3(0.725, 0.71, 0.68))))
self.primitives.append(
triangle.Triangle(
glm.vec3(1.2, 1.2, -2.5), glm.vec3(1.2, 1.2, -1.0),
glm.vec3(-1.2, 1.2, -1.0),
diffuse.Diffuse(brdf=glm.vec3(0.725, 0.71, 0.68))))
# LIGHT
self.primitives.append(
triangle.Triangle(
glm.vec3(-0.5, 1.19, -1.5), glm.vec3(-0.5, 1.19, -2.0),
glm.vec3(0.5, 1.19, -2.0),
light.Light(emittance=glm.vec3(30.0, 30.0, 30.0))))
self.primitives.append(
triangle.Triangle(
glm.vec3(0.5, 1.19, -2.0), glm.vec3(0.5, 1.19, -1.5),
glm.vec3(-0.5, 1.19, -1.5),
light.Light(emittance=glm.vec3(30.0, 30.0, 30.0))))
# SPHERES
self.primitives.append(
sphere.Sphere(glm.vec3(-0.5, -0.65, -1.5), 0.4, mirror.Mirror()))
self.primitives.append(
sphere.Sphere(glm.vec3(0.6, -0.65, -1.8), 0.4,
diffuse.Diffuse(brdf=glm.vec3(0.725, 0.71, 0.68))))
def sfvp():
#-----------------------------------------------------------------------------------
#
# purpose: starting with analytically generated winds, calculate the stream
# function and velocity potential using Spherepack and compare with
# analytically generated stream function and velocity potential.
#
# usage: sfvp()
#
# passed : nothing
#
# returned: nothing
#
#-----------------------------------------------------------------------------------
sendmsg(
'**************** calculate the stream function and velocity potential on gaussian grid *****************'
)
sendmsg(' ')
testError = 0
comp = 'computed'
nlon = 128
nlat = 64
lonvals, latvals, timevals, u, v, sfexact, vpexact = sphere_test(
nlon, nlat, 'v', 'gaussian')
nt = len(timevals)
x = sphere.Sphere(lonvals,
latvals,
numberLevels=0,
numberTimes=nt,
computed_stored=comp)
sfcal, vpcal = x.sfvp(u, v)
scale = radius # scale exact functions to radius for the earth
sfexact = sphere.geoscale(scale, sfexact)
vpexact = sphere.geoscale(scale, vpexact)
sfexact = remove_offset(sfcal, sfexact) # subtract the offset
vpexact = remove_offset(vpcal, vpexact)
sendmsg('******* compare results')
rms = rmserror(sfcal, sfexact) # stream function rms error
sendmsg(
'expected normalized rms error in stream function computation is less than 1.e-05'
)
sendmsg('calculated normalized rms error in stream function computation =',
rms)
sendmsg(' ')
if rms > 1.e-05:
testError = testError + 1
rms = rmserror(vpcal, vpexact) # velocity potential rms error
sendmsg(
'expected normalized rms error in velocity potential computation is less than 1.e-05'
)
sendmsg(
'calculated normalized rms error in velocity potential computation =',
rms)
sendmsg(' ')
if rms > 1.e-05:
testError = testError + 1
if writeTestcase == 'yes':
sendmsg('******* write data')
sendmsg('calculated stream function written to sfcal.nc'
) # write netcdf file
writeField(lonvals, latvals, timevals, 'sfcal', sfcal)
sendmsg('calculated velocity potential written to vpcal.nc')
writeField(lonvals, latvals, timevals, 'vpcal', vpcal)
sendmsg(' ')
sendmsg(
'exact stream function written to sfexact.nc') # write netcdf file
writeField(lonvals, latvals, timevals, 'sfexact', sfexact)
sendmsg('exact velocity potential written to vpexact.nc')
writeField(lonvals, latvals, timevals, 'vpexact', vpexact)
sendmsg(' ')
sendmsg(' ')
return testError
def main():
s = sphere.Sphere()
ag = AGC.AGC(32, 2, 4000, 0.02, s)
ag.run()
for i in ag._individuos:
print(i._cromosoma)
phi_basis = de.Fourier('phi', 2 * (L_max + 1), interval=(0, 2 * np.pi))
theta_basis = de.Fourier('theta', L_max + 1, interval=(0, np.pi))
domain = de.Domain([phi_basis, theta_basis], grid_dtype=np.float64)
phi = domain.grids(1)[0]
# set up fields
v_th = domain.new_field()
v_ph = domain.new_field()
p = domain.new_field()
om = domain.new_field()
psi = domain.new_field()
# set up sphere
p.require_coeff_space()
m_start = p.layout.start(1)[0]
m_len = p.layout.local_shape(1)[0]
S = sph.Sphere(L_max, S_max, m_min=m_start, m_max=m_start + m_len)
# Calculate theta grid
theta_slice = domain.distributor.layouts[-1].slices(1)[1]
theta_len = domain.local_grid_shape(1)[1]
theta = S.grid[theta_slice].reshape([1, theta_len])
figure, ax = plt.subplots(1, 1)
figure.set_size_inches(6, 6)
lon = np.linspace(0, 2 * np.pi, 2 * (L_max + 1))
lat = grid - np.pi / 2
meshed_grid = np.meshgrid(lon, lat)
lat_grid = meshed_grid[1]
lon_grid = meshed_grid[0]
cam = camera.FreeCamera(bdgmath.Vector3(8, -12, 8), bdgmath.Vector3(0, 0, 5)) scene = scene.Scene() scene.addLight(light.DirectionalLight(bdgmath.Vector3(-1, 0.5, -4), 0.8)) scene.addLight(light.AmbientLight(0.2)) floor = plane.ZPlane(0) floor.squareSize = 2 scene.addObject(floor) cube = box.Box(bdgmath.Vector3(5, 5, 5)) cube.color = (1.0, 0.75, 0.25) negSphere = sphere.Sphere(bdgmath.Vector3(2.5, -2.5, 2.5), 4.5) cubeMinusSphere = csg.Difference(cube, negSphere) torus = donut.Donut(3.5, 1) torus.color = torus.color1 = torus.color2 = (0, 0.8, 0) rotTorus = transform.RotateZ(225, transform.RotateX(45, torus)) torusCube = csg.Union(cubeMinusSphere, rotTorus) posTorusCube = transform.Translate3d(bdgmath.Vector3(0, 0, 5), torusCube) scene.addObject(posTorusCube) #cam.renderScene(scene, 640, 320, "raytest.png", 5)
def can_use_sphere(longitude, latitude):
"""Test if can use sphere package.
Calling Sequence:
Result = can_use_sphere(longitude, latitude)
Note that Result is a 3-element tuple, not a scalar. See the
description below for details.
Test if the longitude-latitude domain and Python package configur-
ation allows use of the NCAR SPHEREPACK 3.0 package. Specifically
the function tests:
(1) Can you import sphere?
(2) Is the longitude vector evenly spaced?
(3) Does the longitude vector entirely span the globe, but doesn't
repeat?
(4) Is the latitude vector gaussian? If not, is it evenly spaced
and includes the poles?
If the answer to (1) is no, then there's no use to go through the
other tests and the function return tuple element [0] is 0. If (2)
or (3) is no, return tuple element [0] is 0. If (4) is both not
gaussian and not evenly spaced with the poles, return tuple
element [0] is 0. Otherwise, return tuple element [0] is 1. Note
that (4) uses the latitude checker in the sphere package.
Method Arguments:
* longitude: Vector of longitudes of the domain [deg]. Can be
in any order, and a Numeric array or regular list/tuple.
* latitude: Vector of latitudes of the domain [deg]. Can be in
any order, and a Numeric array or regular list/tuple.
Output Result:
* A 3-element tuple:
[0]: 1 if the longitude-latitude domain and Python package
configuration passes tests to allow use of the NCAR
SPHEREPACK 3.0 package. 0 if does not pass those tests.
[1]: String containing messages written to stdout by calls to
module sphere used for checking latitude (e.g. if it is
gaussian, etc.). If there are no messages or there were
no calls needed to sphere for checking latitude, value is
empty string.
[2]: Same as [1] except contains stderr messages.
Examples:
>>> from can_use_sphere import can_use_sphere
>>> import numpy as np
>>> lon = np.arange(36)*10
>>> lat = [-90, -60, -30, 0, 30, 60, 90]
>>> can_use_sphere(lon, lat)[0]
1
>>> lat = [-90, -60, -30, 0, 30, 60, 87]
>>> can_use_sphere(lon, lat)[0]
0
>>> can_use_sphere(lon, lat)[1].splitlines()[1]
'CANNOT PROCESS THE DATA - Latitude values are incorrect'
"""
#- Test if the sphere package exists:
try:
import sphere
except ImportError:
return (0, '', '')
#- Convert input to Numeric and sort:
lon = np.sort(np.array(longitude))
lat = np.sort(np.array(latitude))
#- Check if either vector is less than 2 elements. If so,
# return false:
if (len(lon) < 2) or (len(lat) < 2): return (0, '', '')
#- Is the longitude vector evenly spaced? If not, return false:
diff_lon = lon[1:] - lon[0:-1]
if not np.allclose(diff_lon, diff_lon[0]): return (0, '', '')
#- Does the longitude vector exactly spans the globe but without
# repeating? If not, return false:
if not np.allclose((lon[-1] + diff_lon[0] - lon[0]), 360.0):
return (0, '', '')
#- Check latitude (e.g. whether it is gaussian, whether it includes
# the pole points if they are evenly spaced) and any other bad
# conditions for sphere using the sphere package checker. If
# sphere can't execute correctly, return 0. Also return standard
# error and standard out:
temp_out = sys.stdout
temp_err = sys.stderr
sys.stdout = io.StringIO()
sys.stderr = io.StringIO()
try:
try:
sph_obj = sphere.Sphere(lon, lat)
sph_obj_exception = 0
except:
sph_obj_exception = 1
finally:
stdout = sys.stdout.getvalue()
stderr = sys.stderr.getvalue()
sys.stdout.close()
sys.stderr.close()
sys.stdout = temp_out
sys.stderr = temp_err
if sph_obj_exception == 1: return (0, stdout, stderr)
#- Return true if haven't returned yet:
return (1, stdout, stderr)
#cam = camera.YCamera(0, -5, 3) #cam.setViewDistance(2) #cam.setViewWidth(2) cam = camera.FreeCamera(bdgmath.Vector3(10, -8, 6), bdgmath.Vector3(0, 0, 5)) scene = scene.Scene() scene.addLight(light.DirectionalLight(bdgmath.Vector3(-1, 1, -4), 0.8)) scene.addLight(light.AmbientLight(0.2)) scene.addObject(plane.ZPlane(0)) #scene.addObject(plane.ZPlane(-2)) #scene.addObject(sphere.Sphere(bdgmath.Vector3(-0.1, 0, 2.5), 2.5)) s2 = sphere.Sphere(bdgmath.Vector3(3.5, 2, 2), 2) s2.color1 = (40, 200, 40) #s2.color2 = (0, 250, 0) s2.color2 = (40, 200, 40) #scene.addObject(s2) s3 = sphere.Sphere(bdgmath.Vector3(-4, 2, 2), 2) s3.color1 = (40, 40, 200) #s3.color2 = (0, 0, 250) s3.color2 = s3.color1 #scene.addObject(s3) #cyl = cylinder.ZCylinder(bdgmath.Vector2(1, 4), 1) #scene.addObject(cyl) donut = donut.Donut(2.5, 1)
def main():
s = sphere.Sphere()
for i in range(5):
ag = AGC.AGC(32, 16, 2000, 0.02, s, i)
ag.run()
