def pattern(self):
bottle_states = []
for r in range(NUM_NODES + 1):
bottle_states.append(r % 2 == 0)
stop = False
while not stop:
hue = random()
c1 = hue_to_color(hue)
c1 = Colour(rgb=(c1[0] / 255.0, c1[1] / 255.0, c1[2] / 255.0))
c2 = hue_to_color(hue + .5)
c2 = Colour(rgb=(c2[0] / 255.0, c2[1] / 255.0, c2[2] / 255.0))
gradient = []
for c in c1.range_to(c2, 181):
gradient.append(
(int(c.red * 255), int(c.green * 255), int(c.blue * 255)))
for angle in range(181, 0, -1):
for bottle, bottle_angle in self.geo.get_near_bottles(
angle, 1):
if bottle_angle < angle:
if bottle_states[bottle]:
self.trap.set_color(bottle,
gradient[int(bottle_angle)])
else:
self.trap.set_color(
bottle, gradient[int(180 - bottle_angle)])
bottle_states[bottle] = not bottle_states[bottle]
sleep(.03)
if self.stop_thread:
stop = True
break
class Config:
board_size = BOARD_SIZE
board_colour = Colour(WHITE)
vehicles = VEHICLE_SETS
width = WIDTH
height = HEIGHT
escape_car_colour = Colour(RED)
def __init__(self):
self.coloursDict = {
1: Colour(135, 206, 235, convertToDecimal=True),
2: Colour(82, 105, 53, convertToDecimal=True),
3: Colour(146, 108, 77, convertToDecimal=True),
4: Colour(169, 163, 163, convertToDecimal=True),
5: Colour(135, 206, 235, convertToDecimal=True),
}
def get_vehicle_from_config(vehicle_type, x, y, orientation, rgb,
escape_car_colour):
if vehicle_type == 'car':
vehicle = Car(Position(x, y), orientation, Colour(rgb))
elif vehicle_type == 'lorry':
vehicle = Lorry(Position(x, y), orientation, Colour(rgb))
else:
raise Exception('Unknown vehicle_type! {}'.format(vehicle_type))
if vehicle.colour == escape_car_colour:
vehicle.is_escape_vehicle = True
return vehicle
def __get_ranged_color(critical, current, high, temp_color):
if current >= critical:
return temp_color['critical']
elif current >= high:
return temp_color['high']
else:
start_color = Colour('#' + temp_color['start'])
end_color = Colour('#' + temp_color['end'])
color_list = list(start_color.range_to(end_color, high))
value = int(current)
return color_list[value]
def main():
import warnings
warnings.filterwarnings("ignore")
# create halo catalogue
halo_cat = MXXLCatalogue()
# empty galaxy catalogue
gal_cat = BGSGalaxyCatalogue(halo_cat)
# use hods to populate galaxy catalogue
hod = HOD_BGS()
gal_cat.add_galaxies(hod)
# position galaxies around their haloes
gal_cat.position_galaxies()
# add g-r colours
col = Colour()
gal_cat.add_colours(col)
# use colour-dependent k-correction to get apparent magnitude
kcorr = GAMA_KCorrection()
gal_cat.add_apparent_magnitude(kcorr)
# cut to galaxies brighter than apparent magnitude threshold
gal_cat.cut(gal_cat.get("app_mag") <= par.mag_faint)
# save catalogue to file
gal_cat.save_to_file(par.output_dir + "cat.hdf5", format="hdf5")
def make_embed(self, test_index) -> discord.Embed:
c = Colour(self.colour).rgb
new_c = discord.Colour.from_rgb(int(c[0] * 255), int(c[1] * 255),
int(c[2] * 255))
test = self.tests[test_index]
embed = discord.Embed(
title=f'{self.registration_date.year} {self.make} {self.model}',
colour=new_c)
embed.add_field(name='MOT Result', value=test.result, inline=True)
embed.add_field(name='MOT Date',
value=test.completed_date.strftime("%d/%m/%Y"),
inline=True)
if test.result != 'FAILED':
embed.add_field(name='MOT Expiry',
value=test.expiry_date.strftime("%d/%m/%Y"),
inline=True)
else:
embed.add_field(name='MOT Expiry', value='N/A', inline=True)
embed.add_field(
name='MOT Mileage',
value=
f'{"{:,}".format(test.odometer_reading.value)}{test.odometer_reading.unit}',
inline=True)
embed.add_field(name='MOT Number', value=test.id, inline=True)
embed.add_field(name='Car Colour', value=self.colour, inline=True)
return embed
def sendled():
timestamp = get_timestamp()
# make the socket blocking
# (waits for the data to be sent and for the 2 receive windows to expire)
s.setblocking(True)
Colour.blink_green()
######################
# Data
#######################
s.bind(6)
s.send(timestamp)
time.sleep(5)
# make the socket non-blocking
# (because if there's no data received it will block forever...)
s.setblocking(False)
def __init__(self, pin, length):
self._effect = Effects.RGB
self._thread = None
self._thread_terminate = False
self._thread_running = False
self.pixels = neopixel.NeoPixel(pin, length)
self._length = length
self.pixels[0] = (0, 255, 0)
self.colour = Colour(0, 0, 20)
self.paused = False
self._brightness = 1.0
for i in range(1, length):
self.pixels[i] = (0, 0, 20)
self._backup = []
self._temperature_pixels = []
self.save_period = Config.TIME_TO_SAVE
self.restore_timer = MyTimer(self.save_period, self.restore)
self.dim_timer = MyTimer(self.save_period, self._dim)
for i in range(0, self._length):
self._backup.append(self.pixels[i])
self._prepare_temperature_pixels()
self.saved = False
def __init__(self, renderer, highscores=None):
# Background stuff.
Menu.bg_offset_at_start = 250
Menu.bg_offset = Menu.bg_offset_at_start
Menu.bg_dimness_peak = 0x88
Menu.bg_dimness_current = 0xff
Menu.bg_diminish_rate = 0.33
self.choice = None
self.is_open = True
self.title = hud.Text('pyNoid', renderer, Constants.TITLE_FONT_SIZE)
self.title.position = vec2(50, 50)
self.credits = hud.Text('Kacper Tonia 2017/18', renderer,
Constants.TINY_FONT_SIZE)
self.credits.position = self.title.position + vec2(
self.title.size[0] // 2, self.title.size[1])
grey = Colour.greyscale(0.75)
sub1 = hud.Button.buildClickableText('New Game', renderer,
Colour.White, grey, grey,
Constants.MENU_FONT_SIZE)
sub2 = hud.Button.buildClickableText('Exit', renderer, Colour.White,
grey, grey,
Constants.MENU_FONT_SIZE)
self.menu = hud.VerticalContainer([sub1, sub2],
Constants.WINDOW_SIZE.y // 2)
if highscores:
leaderboard = []
player_name_length = max([len(x[0]) for x in highscores])
score_length = max([len(str(x[1])) for x in highscores])
s_format = '{:>%d} {}{}' % player_name_length
for idx, item in enumerate(highscores):
leaderboard.append(
hud.Text(
s_format.format(
item[0], item[1],
' ' * (score_length - len(str(item[1])))),
renderer, Constants.FONT_SIZE_1,
Colour.greyscale((5 - idx) / 5.0)))
self.render_content = hud.VerticalContainer(
leaderboard, Constants.WINDOW_SIZE.y * 3 // 4)
else:
self.render_content = []
def __init__(self, sprite):
super().__init__('rect renderer')
self.sprite = sprite
self.body = None
self.offset = (0, 0)
self.size = (10, 10)
self.colour = Colour((255, 10, 10))
def getColours(self, venues, dates):
colours = []
for ven in venues:
for date in dates:
c = Colour(ven, date)
colours.append(c)
return colours
def getPixel(self, pixelBox):
(x, y, x2, y2) = pixelBox
pixSize = x2 - x
colour = Colour(0, 0, 0)
for i in range(self.subPixels):
colour += self.rayfunc(
Ray3(self.eye,
(Point3(random.uniform(x, x2), random.uniform(y, y2), 1) -
self.eye)))
return old_div(colour, self.subPixels)
def colour(self):
if self.entry < 0:
return Colour(0, 0, 0)
colour = self.mat.litColour(self.normal, self.ambient, self.lights,
-self.ray.dir, self.texCords)
if self.reflection:
colour += self.mat.reflectivity * self.reflection.colour()
elif self.bgcolour:
colour += self.mat.reflectivity * self.bgcolour
return colour
def ray_trace(self, ray, scene):
colour = Colour(0, 0, 0)
# Find the nearest object hit by the ray in the scene
dist_hit, obj_hit = self.find_nearest(ray, scene)
if obj_hit is None:
return colour
hit_pos = ray.origin + ray.direction * dist_hit
hit_normal = obj_hit.normal(hit_pos)
colour += self.colour_at(obj_hit, hit_pos, hit_normal, scene)
return colour
def make_basic_embed(self):
c = Colour(self.colour).rgb
new_c = discord.Colour.from_rgb(int(c[0] * 255), int(c[1] * 255),
int(c[2] * 255))
embed = discord.Embed(
title=f'{self.registration_date.year} {self.make} {self.model}',
colour=new_c)
embed.add_field(name='MOT Expiry',
value=self.mot_expiry_date.strftime("%d/%m/%Y"),
inline=True)
embed.add_field(name='Colour', value=self.colour, inline=True)
return embed
def new_colour(_colour):
new_colour = utilities.check_vector(_colour, int)
if len(new_colour) == 3:
good = True
for i in range(3):
if 0 > new_colour[i] > 255:
good = False
if good:
return Colour(new_colour)
raise Exception(f'Cannot create colour {new_colour}. Make sure there are three elements between 0 and 255.')
def draw_box(self, start_x: int, start_y: int, end_x: int, end_y: int,
colour: Colour):
"""Draw a box
Args:
start_x (int): The x position of the left side of the box
start_y (int): The y position of the bottom
end_x (int): The x position of the right side
end_y (int): The y position of the top
colour (Colour): The colour of the background of the box
Return: None
"""
red, blue, green = colour.rgb()
self.buffer += f"""
def pattern(self):
stop = False
while not stop:
c1 = random_color()
c1 = Colour(rgb=(c1[0] / 255.0, c1[1] / 255.0, c1[2] / 255.0))
c2 = random_color()
c2 = Colour(rgb=(c2[0] / 255.0, c2[1] / 255.0, c2[2] / 255.0))
gradient = []
for c in c1.range_to(c2, 181):
gradient.append(
(int(c.red * 255), int(c.green * 255), int(c.blue * 255)))
for angle in range(181, 0, -1):
for bottle, bottle_angle in self.geo.get_near_bottles(
angle, 1):
if bottle_angle < angle:
self.trap.set_color(bottle,
gradient[int(bottle_angle)])
sleep(.01)
if self.stop_thread:
stop = True
break
def get_card(self, card_key):
if card_key in self._card_dict:
return self._card_dict[card_key]
colour_val = int(card_key[0:1])
number = int(card_key[1:])
if colour_val < 1 or colour_val > 6:
raise ValueError("Invalid colour val", colour_val)
if number < 1 or number > 10:
raise ValueError("Invalid card number", number)
new_card = Card(Colour(colour_val), number)
self._card_dict[card_key] = new_card
return new_card
def __init__(self, sprite):
super().__init__('particle emitter')
self.sprite = sprite
self.rate = 1
self.size = 3
self.life_time = 10
self.speed = 1
self.angle_range = (0, 360)
self.go = True
self.colour = Colour((0, 0, 0))
self.particles = []
self.count = 0
def pixelColour(self, x, y, samples=1):
pitch = .5 / samples
colour = Colour(0, 0, 0)
count = 0
for subX in range(samples):
for subY in range(samples):
count += 1
ray = self.getRay(x - .5 + (subX + 1) * pitch + subX * pitch,
y - .5 + (subY + 1) * pitch + subY * pitch)
hit = self.processRay(ray)
colour = colour + hit.colour()
#depth = math.log((hit.length() + 0.1), 10)
#colour = colour + Colour(depth, depth, depth)
self.pixels[samples] += 1
return colour / count
def getPixel(self, pixelBox):
(x, y, x2, y2) = pixelBox
pitch = old_div((x2 - x), (self.subPixels * 2))
xx = x
yy = y
count = 0
colour = Colour(0, 0, 0)
for col in range(self.subPixels):
for row in range(self.subPixels):
colour += self.rayfunc(
Ray3(self.eye,
(Point3(xx + pitch, yy + pitch, 1) - self.eye)))
count += 1
yy += pitch * 2
yy = y
xx += pitch * 2
assert count == self.subPixels * self.subPixels
return old_div(colour, count)
def create_color_stops(breaks, colors='RdYlGn', color_ramps=color_ramps):
"""Convert a list of breaks into color stops using colors from colorBrewer
or a custom list of color values in RGB, RGBA, HSL, CSS text, or HEX format.
See www.colorbrewer2.org for a list of color options to pass
"""
num_breaks = len(breaks)
stops = []
if isinstance(colors, list):
# Check if colors contain a list of color values
if len(colors) == 0 or len(colors) != num_breaks:
raise ValueError(
'custom color list must be of same length as breaks list')
for color in colors:
# Check if color is valid string
try:
Colour(color)
except:
raise ValueError(
'The color code {color} is in the wrong format'.format(
color=color))
for i, b in enumerate(breaks):
stops.append([b, colors[i]])
else:
if colors not in color_ramps.keys():
raise ValueError('color does not exist in colorBrewer!')
else:
try:
ramp = color_ramps[colors][num_breaks]
except KeyError:
raise ValueError(
"Color ramp {} does not have a {} breaks".format(
colors, num_breaks))
for i, b in enumerate(breaks):
stops.append([b, ramp[i]])
return stops
def _fade(self, colour1, colour2, steps, interval):
self._thread_running = True
lastUpdate = time.time() - interval
interval = interval / steps
for i in range(1, steps + 1):
r = round(((colour1.r * (steps - i)) + (colour2.r * i)) / steps)
g = round(((colour1.g * (steps - i)) + (colour2.g * i)) / steps)
b = round(((colour1.b * (steps - i)) + (colour2.b * i)) / steps)
while ((time.time() - lastUpdate) < interval):
pass
colour = Colour(r, g, b)
for j in range(0, self._length):
if not self.paused:
self._set_pixel(j, colour.r, colour.g, colour.b)
lastUpdate = time.time()
self._thread_running = False
self.colour = colour2
def match_color(self, color, convert2discord=True):
color = color.lower()
if color in self._color_names:
rgb = self._color_names[color]
if not convert2discord:
return rgb['hex']
rgb = rgb['rgb']
rgb = tuple(map(lambda c: c / 255.0, rgb))
else:
try:
rgb = Colour(color)
if not convert2discord:
return rgb.get_hex_l()
rgb = rgb.rgb
except:
return
return self.check_rgb(rgb)
def colour_at(self, obj_hit, hit_pos, normal, scene):
material = obj_hit.material
obj_colour = material.colour_at(hit_pos)
to_cam = scene.camera - hit_pos
specular_k = 50
colour = material.ambient * Colour.from_hex("#000000")
# Light calculations
for light in scene.lights:
to_light = Ray(hit_pos, light.position - hit_pos)
# Diffuse shading (Lambert)
colour += (
obj_colour
* material.diffuse
* max(normal.dot_product(to_light.direction), 0)
)
# Specular shading
half_vector = (to_light.direction + to_cam).normalise()
colour += (
light.colour
* material.specular
* max(normal.dot_product(half_vector), 0) ** specular_k
)
return colour
def __init__(self,
obj,
ray,
entry,
exit,
normal=None,
material=None,
TexCords=None):
self.obj = obj
self.entry = entry
self.exit = exit
self.normal = normal
self.normal2 = None
self.mat = material
self.texCords = TexCords
self.ray = ray
# Undefined variables
self.reflection = None
self.bgcolour = None
self.lights = [None]
# temp ambiant for when colour is called before calcLights
self.ambient = Colour(0.8, 0.8, 0.8)
def __init__(
self,
x_pos: int,
y_pos: int,
text: str = "",
min_width: int = 10,
min_height: int = 10,
):
"""
Create a Box
Args:
x_pos: The x position of the box
y_pos: The y position of the box
text: The text to show in the box
min_width: The minimum width for the box
min_height: The minimum height for the box
"""
self.x_pos = x_pos
self.y_pos = y_pos
self.colour = Colour("black")
# These settings are ratios of how far up/across our anchor point
# is (0 => left, 0.5 => middle, 1 => right for x)
self.x_anchor = 0.5
self.y_anchor = 0.5
self._min_width = min_width
self._min_height = min_height
# Option to put text at the top of the box
self.text_top = False
# Setting the text will actually try to resize the box so we need to
# do this last to make sure the min and max have already been set
self.text = text
def main():
width = 3200
height = 2000
camera = Vector(0, 0, -0.5)
lights = [
Light(Point(0, -0.6, -6), Colour.from_hex("#FFFFFF")),
Light(Point(5, -0.9, 10), Colour.from_hex("#FFFFFF")),
Light(Point(-1, -0.9, 10), Colour.from_hex("#FFFFFF"))
]
objects = [
Sphere(Point(-0.53, 0, 1), 0.5, Material(Colour.from_hex("#FF0000"))),
Sphere(Point(0.53, 0, 1), 0.5, Material(Colour.from_hex("#F80000"))),
Sphere(Point(0, 1000000.5, 1), 1000000,
Material(Colour.from_hex("#FFFFFF")))
]
scene = Scene(camera, objects, lights, width, height)
engine = RenderEngine()
image = engine.render(scene)
with open("render.ppm", "w") as img_file:
image.write_ppm(img_file)
class Shape:
def __init__(self):
self.poly = self.__randPoly(randint(config.POLY_MIN_SIDES, config.POLY_MAX_SIDES), 0, 0, config.PIC_W, config.PIC_H)
self.colour = Colour()
self.image = self.buildImage()
class ShapeCommand(object):
def __init__(self, shape):
self.shape = shape;
self.didExecute = False
class InsertPointCommand(ShapeCommand):
def execute(self):
if len(self.shape.poly) < config.POLY_MAX_SIDES:
index = randint(1, len(self.shape.poly)-2)
prevPoint = self.shape.poly[index-1]
nextPoint = self.shape.poly[index+1]
newPoint = (((prevPoint[0] + nextPoint[0]) / 2), ((prevPoint[1] + nextPoint[1]) / 2))
self.shape.poly.insert(index, newPoint)
self.insertedPoint = newPoint
self.didExecute = True
def undo(self):
if self.didExecute:
self.shape.poly.remove(self.insertedPoint)
class RemovePointCommand(ShapeCommand):
def execute(self):
if len(self.shape.poly) > config.POLY_MIN_SIDES:
self.poppedIndex = randint(0, len(self.shape.poly)-1)
self.poppedPoint = self.shape.poly.pop(self.poppedIndex)
self.didExecute = True
def undo(self):
if self.didExecute:
self.shape.poly.insert(self.poppedIndex, self.poppedPoint)
class MovePointCommand(ShapeCommand):
def __init__(self, shape, isMajor):
super(Shape.MovePointCommand, self).__init__(shape)
self.isMajor = isMajor
def execute(self):
if self.isMajor:
move = config.PIC_W / 3
else:
move = 3
self.index = randint(0, len(self.shape.poly)-1)
point = self.shape.poly[self.index]
x, y = point[0], point[1]
self.oldPoint = point
x += randint(-move, move)
x = min(config.PIC_W, max(0, x))
y += randint(-move, move)
y = min(config.PIC_H, max(0, y))
self.shape.poly[self.index] = (x, y)
def undo(self):
self.shape.poly[self.index] = self.oldPoint
class RebuildCommand(ShapeCommand):
def execute(self):
self.oldImage = self.shape.image
self.shape.image = self.shape.buildImage()
def undo(self):
self.shape.image = self.oldImage
def mutate(self, major=False):
commands = []
if chance(10):
if chance(1):
commands.append(Shape.RemovePointCommand(self))
else:
commands.append(Shape.InsertPointCommand(self))
else:
commands.append(Shape.MovePointCommand(self, isMajor=major))
commands.append(Shape.RebuildCommand(self))
return commands
def buildImage(self):
image = Image.new('RGBA', (config.PIC_W, config.PIC_H))
ImageDraw.Draw(image).polygon(self.poly, fill=self.colour.getTuple())
return image
def __randPoly(self, sides, minX, minY, maxX, maxY):
zoneDivisor = randint(1, 4)
zone = (randint(0, zoneDivisor-1), randint(0, zoneDivisor-1))
size = ((maxX - minX) / zoneDivisor, (maxY - minY) / zoneDivisor)
points = []
start = (zone[0] * size[0], zone[1] * size[1])
for i in xrange(sides):
points.append((randint(start[0], start[0] + size[0]), randint(start[1], start[1] + size[1])))
return points
def __init__(self): self.poly = self.__randPoly(randint(config.POLY_MIN_SIDES, config.POLY_MAX_SIDES), 0, 0, config.PIC_W, config.PIC_H) self.colour = Colour() self.image = self.buildImage()
