def test_RemoteControl(self):
remote_control = RemoteControl()
living_room_light = Light('Living Room')
kitchen_light = Light('Kitchen')
stereo = Stereo('Living Room')
living_room_light_on = LightOnCommand(living_room_light)
living_room_light_off = LightOffCommand(living_room_light)
kitchen_light_on = LightOnCommand(kitchen_light)
kitchen_light_off = LightOffCommand(kitchen_light)
stereo_on_with_CD = StereoOnWithCDCommand(stereo)
stereo_off = StereoOffCommand(stereo)
remote_control.set_command(0, living_room_light_on, living_room_light_off)
remote_control.set_command(1, kitchen_light_on, kitchen_light_off)
remote_control.set_command(2, stereo_on_with_CD, stereo_off)
print(remote_control)
remote_control.on_button_was_pushed(0)
remote_control.off_button_was_pushed(0)
remote_control.on_button_was_pushed(1)
remote_control.off_button_was_pushed(1)
remote_control.undo_button_was_pushed()
remote_control.on_button_was_pushed(2)
remote_control.off_button_was_pushed(2)
remote_control.undo_button_was_pushed()
def discover_devices(self):
self.lights = []
self.devices = []
responses = self.broadcast_with_resp(
GetService,
StateService,
)
for r in responses:
device = Device(r.target_addr, r.ip_addr, r.service, r.port,
self.source_id, self.verbose)
try:
if device.is_light():
if device.supports_multizone():
device = MultiZoneLight(r.target_addr, r.ip_addr,
r.service, r.port,
self.source_id, self.verbose)
elif device.supports_chain():
device = TileChain(r.target_addr, r.ip_addr, r.service,
r.port, self.source_id,
self.verbose)
else:
device = Light(r.target_addr, r.ip_addr, r.service,
r.port, self.source_id, self.verbose)
self.lights.append(device)
except WorkflowException:
# cheating -- it just so happens that all LIFX devices are lights right now
device = Light(r.target_addr, r.ip_addr, r.service, r.port,
self.source_id, self.verbose)
self.lights.append(device)
self.devices.append(device)
def led_blink(color, count):
if color == "red":
led = Light(17)
elif color == "green":
led = Light(18)
else:
led = Light(17)
for i in range(count):
led.blink()
time.sleep(1)
def render_random_spheres(scene):
total_sphere = random.randint(1, 15)
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)
for i in range(0, total_sphere):
s = Sphere(random.randint(10, 200) / 100.0)
s.transform.position = Vector3(random.randint(-3, 3),
random.randint(-3, 3),
random.randint(2, 10))
s.albedo = Color(
float(random.randint(20, 255)) * 1.0 / 255.0,
float(random.randint(20, 255)) * 1.0 / 255.0,
float(random.randint(20, 255)) * 1.0 / 255.0, 1.0)
print("Sphere got color " + str(s.albedo))
scene.add_objects(s)
v1 = Vector3(8.0, 0.0, -1.0)
v2 = Vector3(0.0, 8.0, -3.0)
animation_velocity = 0.5
def update_method(t):
p = Vector3(0.0, 2.0, -2.0)
p = p.add(v1.multiply(np.cos(animation_velocity * t * np.pi)))
p = p.add(v2.multiply(np.sin(animation_velocity * t * np.pi)))
light.transform.position = p
return update_method
def main():
remote_control = RemoteControl()
light = Light()
light_on_command = LightOnCommand(light)
light_off_command = LightOffCommand(light)
fan = CellingFan()
celling_fan_high_command = CellingFanHighCommand(fan)
celling_fan_low_command = CellingFanLowCommand(fan)
celling_fan_off_command = CellingFanOffCommand(fan)
remote_control.set_command(2, light_on_command, light_off_command)
remote_control.set_command(5, celling_fan_high_command, celling_fan_off_command)
remote_control.set_command(6, celling_fan_low_command, celling_fan_off_command)
remote_control.on_button_pushed(1)
remote_control.off_button_pushed(1)
remote_control.undo_button_pushed()
remote_control.on_button_pushed(2)
remote_control.off_button_pushed(2)
remote_control.undo_button_pushed()
remote_control.on_button_pushed(6)
remote_control.off_button_pushed(6)
remote_control.undo_button_pushed()
remote_control.on_button_pushed(5)
remote_control.undo_button_pushed()
def handle_events():
global see_right, skeletons, items, click, bonfire_ready, background, bonfire, light, stone, wood
events = get_events()
for event in events:
if event.type == SDL_QUIT:
game_framework.quit()
elif event.type == SDL_MOUSEMOTION:
mousecursor.position(x=event.x, y=VIEW_HEIGHT - 1 - event.y)
elif event.type == SDL_KEYDOWN and event.key == SDLK_ESCAPE:
del (skeletons)
del (items)
del light
game_framework.change_state(title_state)
elif event.type == SDL_KEYDOWN and event.key == SDLK_p:
game_framework.push_state(pause_state)
elif event.type == SDL_MOUSEBUTTONDOWN and event.button == SDL_BUTTON_RIGHT:
if collision(ui, mousecursor):
if stone >= 2 and wood >= 2:
game_world.remove_object(bonfire)
game_world.remove_object(light)
bonfire = Bonfire(player.x, player.y)
game_world.add_object(bonfire, 3)
bonfire.set_background(background)
light = Light(bonfire.x, bonfire.y)
game_world.add_object(light, 3)
light.set_background(background)
stone -= 2
wood -= 2
else:
player.handle_event(event)
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 __init__(self, color=None, nickName=None, owner=None):
self.wheels = []
self.light = Light()
self.color = color
self.nickName = nickName
self.owner = owner
self.direction = 0
def test_casting_with_obstacles(self):
block = Block((0, 0, 0), 10, 10, 10, 10)
light = Light(10, 10, 50, [block])
light.update()
visibitlity = light.visibility
self.assertEqual(visibitlity, self.result)
def _decode_light(d):
"""
Creates a Light instance from a dictionary containing the guts of a Light
instance.
Parameters:
d (Dictionary): The dictionary that contains the organs and ideas of
the Light we are trying to coax into existence.
Returns:
A cultivated Light.
Preconditions:
The dictionary actually does specify a light. (i.e. it was encoded
using _encode_light().)
Postconditions:
A Light is created.
"""
# Create the three different ColorChannels from members of the dictionary.
r = ColorChannel(d['r_t'], d['r_v'], d['r_c'])
g = ColorChannel(d['g_t'], d['g_v'], d['g_c'])
b = ColorChannel(d['b_t'], d['b_v'], d['b_c'])
# Construct and return the Light instance that wraps the ColorChannels.
return Light(r, g, b, d['name'], d['id'])
def post_lights():
"""
Füge eine neue Lampe hinzu
:body name: Name der Lampe
:body ip_address: IP Adresse der Lampe
:body port: Port des HTTP-Servers der Lampe
"""
json = request.get_json()
if not json:
return jsonify({'message': 'no data received'}), 400
name = json.get('name')
ip_address = json.get('ip_address')
port = json.get('port')
if not name or not ip_address or not port:
return jsonify({'message': 'information is missing'}), 400
light = Light(None,
name,
ip_address,
port,
r=json.get('r', 0),
g=json.get('g', 0),
b=json.get('b', 0))
light.save()
return jsonify({'message': 'Light saved'}), 200
def main():
remote = SimpleRemoteControl()
light = Light()
light_on = LightOnCommand(light)
remote.set_command(light_on)
remote.button_was_pressed()
def __init__(self, refPath, dataPath, dbFilename):
GPIO.cleanup()
GPIO.setmode(GPIO.BCM)
GPIO.setup(self.AUTO_START_GPIO_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
self.__i2c = I2C(2)
self.__analog = Analog(sel.__i2c.getLock(), 0x49)
self.default = Default()
self.database = Database(dataPath, dbFilename)
self.waterlevel = Waterlevel(debug, self.database)
self.light = Light(self.database)
self.curtain = Curtain(self.database)
self.pressure = Pressure(self.database, self.default, self.__analog)
self.temperature = Temperature("28-0417716a37ff", self.database)
self.redox = Redox(debug, self.database, self.default, self.__analog)
self.ph = PH(debug, self.database, self.default, self.__analog,
self.temperature)
self.robot = Robot(debug, self.database)
self.pump = Pump(debug, self.database, self.default, self.robot,
self.redox, self.ph, self.temperature)
self.panel = Panel(debug, self.database, self.default, self.pump,
self.redox, self.ph, self.__i2c)
self.statistic = Statistic(debug, self.pump, self.robot, self.redox,
self.ph, self.temperature, self.pressure,
self.waterlevel)
self.refPath = refPath
self.__autoSaveTick = 0
self.__today = date.today().day - 1
debug.TRACE(debug.DEBUG, "Initialisation done (Verbosity level: %s)\n",
debug)
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 scene2():
scene = Scene()
obj = GameObject('0')
obj.load_mesh('../data/camero.obj')
obj.load_texture('../data/camero.png', 256)
obj.set_scale(20)
obj.rotate_y(-45)
scene.objects += [obj]
scene.light = Light()
scene.light.shadow_map_dim = 512
scene.light.shadow_map_bias = 1
scene.light.translate_z(1000)
scene.light.translate_y(1500)
scene.light.translate_x(2000)
scene.light.rotate_y(100)
scene.light.rotate_x(45)
image_width = 640
image_height = 480
scene.camera = Camera(0.98, 0.735, image_width, image_height, 1, 10000, 20,
np.eye(4))
scene.camera.translate_y(40)
scene.camera.translate_z(60)
scene.camera.rotate_x(35)
return scene
def test_SimpleRemoteControl(self):
remote = SimpleRemoteControl()
light = Light()
light_on_command = LightOnCommand(light)
remote.set_command(light_on_command)
remote.button_was_pressed()
def __init__(self):
#
# instantiate all our classes
self.comms = Comms(config.ORIGIN_NUM, config.TARGET_NUMS)
self.light = Light(config.CITY_NAME, config.LATITUDE, config.LONGITUDE,
config.SUNRISE_DELAY, config.SUNSET_DELAY)
self.door = Door(config.REVS)
self.camera = Camera(config.MAX_HORZ, config.MAX_VERT)
def addLight(self, name, status=0):
if not self.repository.isConnected(name):
self.repository.add(Light(name, status))
logging.info("Added new light \"{0}\"".format(name))
else:
e = ComponentAlreadyConnectedError(name)
logging.exception("addLight -" + e.__str__())
raise e
def setLightStatus(self, name, value):
if self.repository.isConnected(name):
self.repository.update(Light(name, value))
logging.info("Set light \"{0}\" to {1}".format(name, value))
else:
e = ComponentNotConnectedError(name)
logging.exception("setLightStatus - " + e.__str__())
raise e
def __init__(self, device, user):
from config import Config
from light import Light
self.config = Config(device, user)
self.light = Light(device, user)
# After create Light object, search for new lights.
self.light.findNewLights()
def test_shadow7(self):
eyev = Vector(0, 0, -1)
normalv = Vector(0, 0, -1)
light = Light(Point(0, 0, -10), Color(1, 1, 1))
in_shadow = True
m = Material()
result = m.lighting(Sphere(), light, Point(0, 0, 0), eyev, normalv,
in_shadow)
self.assertTrue(result.equals(Color(0.1, 0.1, 0.1)))
def main():
WIDTH = 1000
HEIGHT = 1000
camera = point(0, 0, -1)
objects = [
sphere(point(0, 0, 0), 0.5,
Material(color.from_hex("#FFFFFF"), 0.05, 0.1))
]
lights = [
Light(point(10.0 * -1.14, 10 * 1.14, 0), color.from_hex("#FF0000")),
Light(point(0, -10, 0), color.from_hex("#00FF00")),
Light(point(10.0 * 1.14, 10.0 * 1.14, 0), color.from_hex("#0000FF")),
]
scene_1 = scene(camera, objects, lights, WIDTH, HEIGHT)
engine = RenderEngine()
im = engine.render(scene_1)
with open("render.ppm", "w") as img_file:
im.write_ppm(img_file)
def __init__(self, x, y, rope_length, obstacles=[]):
"""expects that set_up_surface for Light has been called"""
self.x = x
self.y = y
self.obstacles = obstacles
self.rope_length = rope_length
self.bob = Pendulum(BOB_ANGLE, self.rope_length, (self.x, self.y))
self.light = Light(self.x, self.y + self.rope_length,
SWINGING_LIGHT_RADIUS, self.obstacles)
self.light.update()
def main():
print('Reading ...')
start = datetime.datetime.now()
# data source name
data_source_name = 'better-ball.d'
# shading type:
# 0 - no shading (framework)
# 1 - constant shading
# 2 - Gouraud shading
# 3 - Phong shading
shading = 3
world_space = Space()
world_space.append_by_file(data_source_name + '.txt') # geometry data
camera = Camera()
camera.set_by_file(data_source_name + '.camera.txt') # camera profile
light = Light()
light.set_by_file(data_source_name + '.light.txt') # light profile
material = Material()
material.set_by_file(data_source_name +
'.material.txt') # material profile
illumination = Illumination()
illumination.set(camera, light, material, shading)
display = Display()
display.set(800) # change window size
cost = datetime.datetime.now() - start
print('Finish. (cost = ' + str(cost) + ')\n')
print('Calculating: transform ...')
start = datetime.datetime.now()
view_space = copy.deepcopy(world_space)
view_space.transform(world_to_view, camera)
screen_space = copy.deepcopy(view_space)
screen_space.transform(view_to_screen, camera)
device_space = copy.deepcopy(screen_space)
device_space.transform(screen_to_device, display)
cost = datetime.datetime.now() - start
print('Finish. (cost = ' + str(cost) + ')\n')
window = Window()
window.set(world_space, device_space, illumination, display)
window.show()
def createLights(LIGHTS, lightColors, lightPos):
i = 0
for color in lightColors:
x = (lightPos[i][0] * 3.5 / 700) - 1.75 # Gets a scale por the x axis
y = (lightPos[i][1] * 3.5 / 394) - 1.75 # Gets a scale por the y axis
print("X pos:", x, "Y pos: ", y)
LIGHTS.append(
Light(Point(x, y, random.randint(-5, 0)), Color.from_hex(color)))
i += 1
pass
def test_azimut_symetry(self):
azimut = 53
symetric_azimut = -azimut
elevation = 10
reader = LdtReader(LDT_PATH)
light = Light(reader.azimuts, reader.elevations, reader.intenzities)
intenzity = light.intenzity(azimut, elevation)
symetric_intenzity = light.intenzity(symetric_azimut, elevation)
self.assertEqual(intenzity, symetric_intenzity)
def test_different(self):
azimut = 53
other_azimut = 180
elevation = 10
reader = LdtReader(LDT_PATH)
light = Light(reader.azimuts, reader.elevations, reader.intenzities)
intenzity = light.intenzity(azimut, elevation)
other_intenzity = light.intenzity(other_azimut, elevation)
self.assertNotEqual(intenzity, other_intenzity)
def __init__(self, light=Light(Point(-10, 10, -10), Color(1, 1, 1))):
self.light = light
s1 = Sphere()
s1.material.color = Color(0.8, 1.0, 0.6)
s1.material.diffuse = 0.7
s1.material.specular = 0.2
s2 = Sphere()
t2 = scale(0.5, 0.5, 0.5)
s2.set_transform(t2)
self.objs = [s1, s2]
def test_material6(self):
position = Point(0, 0, 0)
m = Material()
eyev = Vector(0, 0, -1)
normalv = Vector(0, 0, -1)
light = Light(Point(0, 0, 10), Color(1, 1, 1))
in_shadow = False
result = m.lighting(Sphere(), light, position, eyev, normalv,
in_shadow)
self.assertTrue(Color(0.1, 0.1, 0.1).equals(result))
def from_config(cls, city_config_path):
cars_filepath = Path(city_config_path) / cls.CARS_FILE
with open(cars_filepath, 'r') as f:
car_records = json.load(f)
layout_filepath = Path(city_config_path) / cls.LAYOUT_FILE
with open(layout_filepath, 'r') as f:
layout = json.load(f)
schedule_filepath = Path(city_config_path) / cls.SCHEDULE_FILE
with open(schedule_filepath, 'r') as f:
schedule = json.load(f)
lights = {}
roads = {}
cars = {}
for road_record in layout['roads']:
id = road_record['id']
length = road_record['length']
roads[id] = Road(id, length)
for light_record in layout['lights']:
id = light_record['id']
roads_in_ids = light_record['roads_in']
roads_out_ids = light_record['roads_out']
for road_in in roads_in_ids:
roads[road_in].light_out = id
for road_out in roads_out_ids:
roads[road_out].light_in = id
lights[id] = Light(id, roads_in_ids, roads_out_ids)
for car_record in car_records:
id = car_record['id']
road_ids = car_record['roads']
# TODO: Check that the order of roads is possible
cars[id] = Car(id, road_ids)
time_allocated = layout['time_allocated']
for light_record in schedule:
light_id = light_record['light']
signals = []
for signal_record in light_record['signals']:
road_id = signal_record['road']
time = signal_record['time']
signal = Signal(road_id, time)
signals.append(signal)
lights[light_id].signals = signals
return cls(roads, lights, cars, time_allocated)
