def __init__(self, debug_mode=False):
self._debug_mode = debug_mode
if not debug_mode:
self._display_type = os.environ.get("EPAPER_TYPE", "epd2in7")
if self._display_type == "epd2in7":
import epd2in7
self._display_width = epd2in7.EPD_HEIGHT # inversed
self._display_height = epd2in7.EPD_WIDTH
self._epd = epd2in7.EPD()
self._epd.init()
elif self._display_type == "epd4in2":
import epd4in2
self._display_width = epd4in2.EPD_WIDTH
self._display_height = epd4in2.EPD_HEIGHT
self._epd = epd4in2.EPD()
self._epd.init()
else:
raise "Invalid display config"
else:
self._display_width = EPD_WIDTH
self._display_height = EPD_HEIGHT
self._time_zone = tzlocal.get_localzone()
self._str_time = "XXXX"
self._drawing = drawing.Drawing(self._display_width,
self._display_height)
def test_string_initialization(self):
fixture = '''<?xml version="1.0" encoding="utf-8"?>
<svg height="300" width="300"><title>Example image</title>
<line class="st0" x1="2000" y1="2000" x2="3000" y2="3000"/>
</svg>'''
d = drawing.Drawing(raw=fixture)
self.assertEqual(len(d.processedroot), 1)
def test_ignores_unknown_args(self):
fixture = '''<?xml version="1.0" encoding="utf-8"?>
<svg height="300" width="300"><title>Example image</title>
<line class="st0" x1="200" y1="200" x2="300" y2="300"/></svg>'''
d = drawing.Drawing(raw=fixture)
expected = ['M 2000.0 2000.0', 'L 3000.0 3000.0', 'M 7500 7500']
self.assertEqual(d.instructions(), expected)
def test_g_grouping(self):
d = drawing.Drawing(filename='./fixtures/tests-fixture2.svg')
expected = [
'M 0.0 0.0', 'L 3000.0 0.0', 'L 3000.0 1000.0', 'L 0.0 1000.0',
'L 0.0 0.0', 'M 0.0 0.0', 'L 900.0 0.0', 'L 900.0 900.0',
'L 0.0 900.0', 'L 0.0 0.0', 'M 0.0 0.0', 'L 500.0 1000.0',
'M 7500 7500'
]
self.assertEqual(d.instructions(), expected)
def __init__(self, size=1):
super(PhysicalBoard, self).__init__(size)
self.drawing = drawing.Drawing()
for row in range(size):
row_width = LINE_SPACING * row
for line in range(row + 1):
x = line * LINE_SPACING - row_width / 2.0
y = TOP_OF_BOARD - row * LINE_HEIGHT * 1.5
self.drawing.line(x, y, x, y - LINE_HEIGHT)
def __init__(self):
"""Initialize the editor"""
# Initialize an empty document
self.document = document.Document()
# Initialize an empty drawing
self.drawing = drawing.Drawing()
self._clients = {}
self._colors = ['#AAFF00', '#FFAA00', '#FF00AA', '#AA00FF', '#00AAFF']
self._color_index = 0
def test_file_initialization(self):
d = drawing.Drawing(filename='./fixtures/tests-fixture.svg')
self.assertTrue(isinstance(d.processedroot[0], drawing.Rect))
def test_ignores_unknown_tags(self):
d = drawing.Drawing(raw='<svg><title>abc!</title></svg>')
self.assertEqual(d.instructions(), ['M 7500 7500'])
def test_empty_instructions(self):
d = drawing.Drawing(raw='<svg></svg>')
self.assertEqual(d.instructions(), ['M 7500 7500'])
def test_empty_initialization(self):
drawing.Drawing(raw='<svg></svg>')
with self.assertRaises(AttributeError):
drawing.Drawing(raw='')
import colors
import drawing
import matplotlib.pyplot as plt
class Image:
def __init__(self, image):
self.image = PIL.Image.open(image)
self.image = self.image.resize((800, 600))
self.image_rgb = self.image.convert('RGB')
def get_size(self):
return self.image.size
def generate_grid(self):
self.width, self.height = self.get_size()
for row in range(1, self.height):
for column in range(1, self.width):
self.simplified = C.check_color(
self.image_rgb.getpixel((column, row)))
D.draw_pixel(column, row, self.simplified)
if __name__ == '__main__':
IMAGE = 'test-image.jpg'
GAME_CODE = '8w7uC49AuzIv'
RGB = Image(IMAGE)
D = drawing.Drawing(GAME_CODE)
C = colors.Colours()
RGB.generate_grid()
for x,y in path:
#Remove any offset from the origin (clip blank space)
cx = (x - min_x)
#Convert to meters
cx *= ratio
cx += OFFSET[0]
#Remove any offset from the origin (clip blank space)
cy = (y - min_y)
#Convert to meters
cy *= ratio
cy += OFFSET[1]
converted.append((cx,cy))
converted_paths.append(converted)
return converted_paths
if __name__ == "__main__":
svg = etree.XML(open(sys.argv[1]).read())
inp = raw_input("Place_pen? (y/n)")
d = drawing.Drawing()
if inp.startswith("y"):
d.init()
inp = raw_input("Press enter when done")
d.grip_pen()
paths = get_paths(svg)
for path in convert_paths(paths):
d.path(path)
def __init__(self):
super(PhysicalUI, self).__init__()
self.drawing = drawing.Drawing()
def set_drawing_information(self):
"""
Fonction used to extract the information from the database
for which datetime is
in [self.datetime_drawing_min, self.datetime_drawing_max]
and fill the Drawing object.
"""
start_set_drawing = time.clock()
db = database.database(self.config)
#print("check day interval",
# self.datetime_drawing_min_day,
# self.datetime_drawing_max_day)
try:
tuple_drawings = db\
.get_all_in_time_interval("drawings",
self.datetime_drawing_min_day,
self.datetime_drawing_max_day)
lst_drawings_field = db.get_all_fields("drawings")
tuple_calibrations = db\
.get_all_in_time_interval("calibrations",
self.datetime_drawing_min_day,
self.datetime_drawing_max_day)
tuple_groups = db\
.get_all_in_time_interval("sGroups",
self.datetime_drawing_min_day,
self.datetime_drawing_max_day)
lst_groups_field = db.get_all_fields("sGroups")
except AttributeError:
QtGui.QMessageBox\
.warning(self,
"Month selection",
"You did not specify a month!")
lst_drawing = [el for el in tuple_drawings]
lst_calibrations = [el for el in tuple_calibrations]
lst_groups = [el for el in tuple_groups]
drawing_lst = []
for el in lst_drawing:
drawing_dict = dict(zip(lst_drawings_field, el))
drawing_tmp = drawing.Drawing(drawing_dict)
drawing_type = lst_drawing[lst_drawing.index(el)][2]
tuple_drawing_type = db.get_drawing_information("drawing_type",
drawing_type)
drawing_tmp.set_drawing_type(tuple_drawing_type[0])
for calib in lst_calibrations:
if drawing_tmp.datetime == calib[1]:
drawing_tmp.set_calibration(calib)
break
for group in lst_groups:
group_dict = dict(zip(lst_groups_field, group))
if drawing_tmp.datetime == group[1]:
drawing_tmp.set_group(group_dict)
drawing_lst.append(drawing_tmp)
end_set_drawing = time.clock()
# print("time for set drawing: ",
# end_set_drawing - start_set_drawing)
drawing_lst.sort(key=lambda x : x.datetime)
return drawing_lst
def __init__(self):
""" Initialise the game systems. """
# Change directory into the directory above this file - the
# one containng the 'res' tree. Note that if we've been built via
# py2exe, we will actually be in a zip file so account for that.
path = os.path.dirname(os.path.dirname(__file__))
if (os.path.basename(path) == "library.zip"):
path = os.path.dirname(path)
os.chdir( path )
sys.path += ["."]
# Services exposed to the entities.
self.game_services = SpaceGameServices(self)
# The resource loader.
self.resource_loader = resource.ResourceLoader()
# The configuration.
if os.path.isfile("./config.txt"):
self.config = self.resource_loader.load_config_file_from("./config.txt")
else:
self.config = self.resource_loader.load_config_file("base_config.txt")
# Create the renderer.
renderer_name = self.config.get_or_default("renderer", "src.pygame_renderer.PygameRenderer")
renderer_class = utils.lookup_type(renderer_name)
screen_size = (self.config.get_or_default("screen_width", 1024),
self.config.get_or_default("screen_height", 768))
self.renderer = renderer_class(screen_size, self.config, data_path="./res")
# The resource loaded needs a renderer to load images etc.
self.resource_loader.set_renderer(self.renderer)
# The input handling system.
self.input_handling = None
# The enemy.
self.wave_spawner = None
# Create the entity manager.
self.entity_manager = ecs.EntityManager(self.game_services)
# Configure the resource loader.
self.resource_loader.set_minimise_image_loading(
self.config.get_or_default("minimise_image_loading", False)
)
# The drawing visitor.
self.drawing = drawing.Drawing(self.game_services)
# Is the game running?
self.running = False
# Should we load the game?
self.want_load = False
# Should we pause the game?
self.want_pause = False
# Should we unpause the game?
self.want_resume = False
# Should we simulate one frame and then pause?
self.want_step = False
def main(make_video=True, estimates=None, plotting=['cam1', 'cam2', 'kalman']):
print("Hello, world! Let's run a Kalman filter simulation...")
if estimates:
d = drawing.Drawing(draw_estimates=estimates)
else:
d = drawing.Drawing()
# some useful constants:
total_seconds = 18
total_frames = total_seconds * kc.fps
center_coords = (kc.img_size[0] / 2, kc.img_size[1] / 2)
print('Doing simulation...')
# get the ball motion (a numpy 2xnframes matrix of coords):
# ball_motion = kc.get_brownian_ball_motion(center_coords, total_frames)
ball_motion = kc.get_simple_ball_motion(center_coords, total_seconds)
# ball_motion = kc.get_still_ball_motion(center_coords, total_seconds)
cam1_estimates = []
cam2_estimates = []
# cam3_estimates = []
average_estimates = []
closest_camera_estimates = []
kalman_estimates = []
# do the kalman filtering:
A_x = A_y = 0 # velocity of ball (calculated at each time step)
xhat_x = xhat_y = 0
P_x = P_y = 0
xhatminus_x = xhatminus_y = 0
Pminus_x = Pminus_y = 0
K_x = K_y = 0
xhat0_x = xhat0_y = 300
P0_x = P0_y = 1
xhatprev_x = xhat0_x
Pprev_x = P0_x
xhatprev_y = xhat0_y
Pprev_y = P0_y
for cnt, c in enumerate(ball_motion):
# "PREDICT" (time update)
xhatminus_x = xhatprev_x + (A_x)
Pminus_x = Pprev_x + kc.process_uncertainty
xhatminus_y = xhatprev_y + (A_y)
Pminus_y = Pprev_y + kc.process_uncertainty
# Take "measurements":
(cam1_estimate, cam1_sigma) = kc.get_cam_estimate(c, d.cam1center)
(cam2_estimate, cam2_sigma) = kc.get_cam_estimate(c, d.cam2center)
# (cam3_estimate,cam3_sigma) = kc.get_cam_estimate(c, d.cam3center)
# z = mat([cam1_estimate, cam2_estimate, cam3_estimate])
(z_x1, z_y1) = cam1_estimate
(z_x2, z_y2) = cam2_estimate
# Measurement noise covariance matrix:
R = pow(cam1_sigma, 2) + pow(cam2_sigma, 2)
z_x = (pow(cam2_sigma, 2) / (R)) * z_x1 + (pow(cam1_sigma, 2) /
(R)) * z_x2
z_y = (pow(cam2_sigma, 2) / (R)) * z_y1 + (pow(cam1_sigma, 2) /
(R)) * z_y2
# R = .01
# "CORRECT" (measurement update)
K_x = Pminus_x / (Pminus_x + R)
xhat_x = xhatminus_x + K_x * (z_x - xhatminus_x)
P_x = (1 - K_x) * Pminus_x
K_y = Pminus_y / (Pminus_y + R)
xhat_y = xhatminus_y + K_y * (z_y - xhatminus_y)
P_y = (1 - K_y) * Pminus_y
# We assume constant linear motion, so update the A values
# accordingly for the next iteration:
if cnt > 0:
A_x = ball_motion[cnt][0] - ball_motion[cnt - 1][0]
A_y = ball_motion[cnt][1] - ball_motion[cnt - 1][1]
# save this result for the next iteration:
xhatprev_x = xhat_x
Pprev_x = P_x
xhatprev_y = xhat_y
Pprev_y = P_y
# save measurements for later plotting:
cam1_estimates.append(cam1_estimate)
cam2_estimates.append(cam2_estimate)
# cam3_estimates.append(cam3_estimate)
kalman_estimates.append((int(xhat_x), int(xhat_y)))
closest_camera_estimates.append(
cam1_estimate if cam1_sigma < cam2_sigma else cam2_estimate)
average_estimates.append(
(int(average([cam1_estimate[0], cam2_estimate[0]])),
int(average([cam1_estimate[1], cam2_estimate[1]]))))
# eo filter loop
print('Done!')
# for v1,v2 in zip(closest_camera_estimates, average_estimates):
# print v1,v2,kc.get_dist_between_2_points(v1,v2)
print('Saving images...')
# plot the actual and estimated trajectories:
plt.plot([c[0] for c in ball_motion],
[kc.img_size[1] - c[1] for c in ball_motion],
kc.plotcolors['actual'],
label="Actual Trajectory")
plt.plot(ball_motion[0][0], kc.img_size[1] - ball_motion[0][1], 'ro')
plt.plot(ball_motion[-1][0], kc.img_size[1] - ball_motion[-1][1], 'go')
if 'cam1' in plotting:
plt.plot([c[0] for c in cam1_estimates],
[kc.img_size[1] - c[1] for c in cam1_estimates],
kc.plotcolors['cam1'],
label="Camera 1 Estimate")
if 'cam2' in plotting:
plt.plot([c[0] for c in cam2_estimates],
[kc.img_size[1] - c[1] for c in cam2_estimates],
kc.plotcolors['cam2'],
label="Camera 2 Estimate")
if 'average' in plotting:
plt.plot([c[0] for c in average_estimates],
[kc.img_size[1] - c[1] for c in average_estimates],
kc.plotcolors['average'],
label="Average Estimate")
if 'closest' in plotting:
plt.plot([c[0] for c in closest_camera_estimates],
[kc.img_size[1] - c[1] for c in closest_camera_estimates],
kc.plotcolors['closest'],
label="Closest Camera Estimate")
if 'kalman' in plotting:
plt.plot([c[0] for c in kalman_estimates],
[kc.img_size[1] - c[1] for c in kalman_estimates],
kc.plotcolors['kalman'],
label="Kalman Estimate")
plt.title('Ball Trajectory')
plt.legend(loc='best')
plt.xlabel('X Pixel')
plt.ylabel('Y Pixel')
plt.savefig(kc.trajectories_filename, format='png')
plt.cla()
# plot the x values:
plt.plot([c[0] for c in ball_motion],
kc.plotcolors['actual'],
label="Actual Position")
if 'cam1' in plotting:
plt.plot([c[0] for c in cam1_estimates],
kc.plotcolors['cam1'],
label="Camera 1 Estimate")
if 'cam2' in plotting:
plt.plot([c[0] for c in cam2_estimates],
kc.plotcolors['cam2'],
label="Camera 2 Estimate")
# plt.plot([c[0] for c in cam3_estimates], label="Camera 3 Estimate")
if 'average' in plotting:
plt.plot([c[0] for c in average_estimates],
kc.plotcolors['average'],
label="Average Estimate")
if 'closest' in plotting:
plt.plot([c[0] for c in closest_camera_estimates],
kc.plotcolors['closest'],
label="Closest Camera Estimate")
if 'kalman' in plotting:
plt.plot([c[0] for c in kalman_estimates],
kc.plotcolors['kalman'],
label="Kalman Estimate")
plt.title('X Values')
plt.legend(loc='best')
plt.xlabel('Frames')
plt.ylabel('Pixels')
plt.savefig(kc.x_estimates_filename, format='png')
plt.cla()
# plot the y values:
plt.plot([c[1] for c in ball_motion],
kc.plotcolors['actual'],
label="Actual Position")
if 'cam1' in plotting:
plt.plot([c[1] for c in cam1_estimates],
kc.plotcolors['cam1'],
label="Camera 1 Estimate")
if 'cam2' in plotting:
plt.plot([c[1] for c in cam2_estimates],
kc.plotcolors['cam2'],
label="Camera 2 Estimate")
# plt.plot([c[1] for c in cam3_estimates], label="Camera 3 Estimate")
if 'average' in plotting:
plt.plot([c[1] for c in average_estimates],
kc.plotcolors['average'],
label="Average Estimate")
if 'closest' in plotting:
plt.plot([c[1] for c in closest_camera_estimates],
kc.plotcolors['closest'],
label="Closest Camera Estimate")
if 'kalman' in plotting:
plt.plot([c[1] for c in kalman_estimates],
kc.plotcolors['kalman'],
label="Kalman Estimate")
plt.title('Y Values')
plt.legend(loc='best')
plt.xlabel('Frames')
plt.ylabel('Pixels')
plt.savefig(kc.y_estimates_filename, format='png')
plt.cla()
# plot the errors:
cam1errors = [
kc.get_dist_between_2_points(c[0], c[1])
for c in zip(ball_motion, cam1_estimates)
]
cam2errors = [
kc.get_dist_between_2_points(c[0], c[1])
for c in zip(ball_motion, cam2_estimates)
]
# cam3errors = [kc.get_dist_between_2_points(c[0], c[1]) for c in zip(ball_motion, cam3_estimates)]
averageerrors = [
kc.get_dist_between_2_points(c[0], c[1])
for c in zip(ball_motion, average_estimates)
]
closesterrors = [
kc.get_dist_between_2_points(c[0], c[1])
for c in zip(ball_motion, closest_camera_estimates)
]
kalmanerrors = [
kc.get_dist_between_2_points(c[0], c[1])
for c in zip(ball_motion, kalman_estimates)
]
if 'cam1' in plotting:
plt.plot(cam1errors, kc.plotcolors['cam1'], label='Camera 1')
if 'cam2' in plotting:
plt.plot(cam2errors, kc.plotcolors['cam2'], label='Camera 2')
# plt.plot(cam3errors, label='Camera 3')
if 'average' in plotting:
plt.plot(averageerrors, kc.plotcolors['average'], label='Average')
if 'closest' in plotting:
plt.plot(closesterrors,
kc.plotcolors['closest'],
label='Closest Camera')
if 'kalman' in plotting:
plt.plot(kalmanerrors, kc.plotcolors['kalman'], label='Kalman')
plt.title('Estimation Errors')
plt.legend(loc='best')
plt.xlabel('Frames')
plt.ylabel('Pixels')
plt.savefig(kc.cam_errors_filename, format='png')
w = numpy.bartlett(25)
cam1errors_filtered = numpy.convolve(w / w.sum(), cam1errors, mode='same')
cam2errors_filtered = numpy.convolve(w / w.sum(), cam2errors, mode='same')
# cam3errors_filtered = numpy.convolve(w/w.sum(), cam3errors, mode='same')
averageerrors_filtered = numpy.convolve(w / w.sum(),
averageerrors,
mode='same')
closesterrors_filtered = numpy.convolve(w / w.sum(),
closesterrors,
mode='same')
kalmanerrors_filtered = numpy.convolve(w / w.sum(),
kalmanerrors,
mode='same')
plt.cla()
if 'cam1' in plotting:
# plt.plot(cam1errors_filtered, kc.plotcolors['cam1'], label='Camera 1')
plt.plot(cam1errors_filtered,
kc.plotcolors['cam1'],
label='Camera 1',
linestyle='--')
if 'cam2' in plotting:
# plt.plot(cam2errors_filtered, kc.plotcolors['cam2'], label='Camera 2')
plt.plot(cam2errors_filtered,
kc.plotcolors['cam2'],
label='Camera 2',
linestyle='--')
# plt.plot(cam3errors_filtered, label='Camera 3')
if 'average' in plotting:
plt.plot(averageerrors_filtered,
kc.plotcolors['average'],
label='Average',
linewidth=2)
if 'closest' in plotting:
plt.plot(closesterrors_filtered,
kc.plotcolors['closest'],
label='Closest',
linewidth=2)
if 'kalman' in plotting:
plt.plot(kalmanerrors_filtered,
kc.plotcolors['kalman'],
label='Kalman',
linewidth=2)
plt.title('Smoothed Estimation Errors')
plt.legend(loc='best')
plt.xlabel('Frames')
plt.ylabel('Pixels')
plt.savefig(kc.cam_errors_filtered_filename, format='png')
print('Done!')
if make_video:
print('Rendering video...')
# write out the video:
stiter = iter([
'Motion: Straight Line', 'Motion: Straight Line',
'Motion: Sinusoid'
])
for t in xrange(len(ball_motion)):
# ball coordinates:
d.ball_coords = ball_motion[t]
# set up the status text:
d.cam1_estimate = cam1_estimates[t]
d.cam2_estimate = cam2_estimates[t]
# d.cam3_estimate = cam3_estimates[t]
d.average_estimate = average_estimates[t]
d.kalman_estimate = kalman_estimates[t]
d.frame_num = t
if not (t % (len(ball_motion) / 3)):
d.status_text = stiter.next()
# do the drawing
img = d.get_base_image()
d.write_frame(img)
print("Done!")
def draw_test_image():
"""If user chooses to draw image"""
print("For the best results, draw the digits in the middle of the box.")
drawing.Drawing(300, 100, int(IMG_PIXELS**0.5))
image = Image.open(os.getcwd().rsplit('\\', 1)[0] + "/drawIn/input.jpg")
test_image(image, 1.00, False)
def test_parsed_root(self):
d = drawing.Drawing(filename='./fixtures/tests-fixture.svg')
self.assertIsInstance(d.root, ET.Element)
def set_drawing_information(self, loc=0):
"""
Method that add an entry to the database
corresponding to the new drawing scanned
"""
db = database.database(self.config)
answer = QtGui.QMessageBox.Yes
lst_groups = []
if db.exist_in_db('drawings', 'DateTime', self.drawing_time):
tuple_drawings = db\
.get_all_in_time_interval("drawings",
self.drawing_time,
self.drawing_time)
lst_drawings_field = db.get_all_fields("drawings")
tuple_calibrations = db\
.get_all_in_time_interval("calibrations",
self.drawing_time,
self.drawing_time)
tuple_groups = db\
.get_all_in_time_interval("sGroups",
self.drawing_time,
self.drawing_time)
lst_groups_field = db.get_all_fields("sGroups")
lst_groups = [el for el in tuple_groups]
drawing_type = tuple_drawings[0][2]
tuple_drawing_type = db.get_drawing_information(
"drawing_type", drawing_type)
answer = QtGui\
.QMessageBox\
.question(self,
"new drawing",
"An entry corresponding to this drawing was found in the database. "
"Do you want to delete previous data ?",
QtGui.QMessageBox.Yes | QtGui.QMessageBox.No)
drawing_dict = dict(zip(lst_drawings_field, tuple_drawings[0]))
new_drawing = drawing.Drawing(drawing_dict)
new_drawing.set_drawing_type(tuple_drawing_type[0])
if self.drawing_time == tuple_calibrations[0][1]:
new_drawing.set_calibration(tuple_calibrations[0])
for group in lst_groups:
group_dict = dict(zip(lst_groups_field, group))
new_drawing.set_group(group_dict)
if answer == QtGui.QMessageBox.No:
db.replace_drawing(new_drawing)
if answer == QtGui.QMessageBox.Yes:
# delete the existing groups
for index in reversed(range(0, len(lst_groups))):
new_drawing.delete_group(self.config, index)
if answer == QtGui.QMessageBox.Yes:
new_drawing = drawing.Drawing()
self.config.set_file_path(self.drawing_time)
filename = self.config.filename
new_drawing.fill_from_daily_scan(
drawing_datetime=self.drawing_time,
observer=str(self.drawing_observer_linedit.text()).upper(),
operator=str(self.drawing_operator_linedit.text()).upper(),
drawing_type=str(self.drawing_type.currentText()),
drawing_quality=str(self.drawing_quality.currentText()),
drawing_name=filename)
#db.replace_drawing(new_drawing)
tuple_drawing_type = db.get_drawing_information(
"drawing_type", str(self.drawing_type.currentText()))
new_drawing.set_drawing_type(tuple_drawing_type[0])
if loc == 1:
self.config.set_file_path(self.drawing_time)
filename = self.config.filename
if os.path.isfile(self.config.file_path):
new_drawing = drawing.Drawing()
new_drawing.fill_from_daily_scan(
drawing_datetime=self.drawing_time,
observer=str(self.drawing_observer_linedit.text()).upper(),
operator=str(self.drawing_operator_linedit.text()).upper(),
drawing_type=str(self.drawing_type.currentText()),
drawing_quality=str(self.drawing_quality.currentText()),
drawing_name=filename)
# db.replace_drawing(new_drawing)
tuple_drawing_type = db.get_drawing_information(
"drawing_type", str(self.drawing_type.currentText()))
new_drawing.set_drawing_type(tuple_drawing_type[0])
QtGui.QMessageBox\
.information(self,
"drawing addition",
"New drawing added in the database for the " +
str(self.drawing_time))
else:
QtGui.QMessageBox\
.warning(self,
"drawing addition",
"There is not drawing the image directory correspoding to this date")
return
return [new_drawing]
level, height, apex = tet[0],tet[1],tet[2]
bottom = tetrahedronBottom(height,apex)
yield (level,height/2.,apex)
for p in bottom:
yield (level+1,height/2.,average(apex,p))
def sierpinski(height, x,y,z, level):
tetrahedra = [(0,height,(x,y,z))]
for i in range(level):
out = []
for tet in tetrahedra:
out += transform(tet)
tetrahedra = out
return tetrahedra
mc = Minecraft()
d = drawing.Drawing(mc)
pos = mc.player.getPos()
height = 240 if not settings.isPE else 128
levels = 7
mc.player.setPos(tetrahedronBottom(height,(pos.x,pos.y+height,pos.z))[0])
tetrahedra = sierpinski(height,pos.x,pos.y+height,pos.z,levels)
mc.postToChat("Drawing")
if len(argv) >= 2:
specifiedBlock = Block.byName(argv[1])
b = lambda level : specifiedBlock
else:
b = lambda level : RAINBOW[level % len(RAINBOW)]
for tet in tetrahedra:
drawTetrahedron(tet[1],tet[2],b(tet[0]))
def __init__(self, uid, panel_id):
#Awn Applet configuration
awn.AppletSimple.__init__(self, 'slickswitcher', uid, panel_id)
self.dialog = awn.Dialog(self)
self.dialog.set_skip_pager_hint(True)
self.set_tooltip_text(_("SlickSwitcher"))
self.size = self.get_size()
#Set up Switch - does wnck stuff
self.switch = switch.Switch()
#Set up Settings - does awn.Config stuff
self.settings = settings.Settings(self)
for key in ['use_custom', 'custom_back', 'custom_border']:
self.settings.config.notify_add(GROUP_DEFAULT, key, self.update_custom)
#Set up the dialog colors
self.dialog_style = self.dialog.get_style()
self.unmodified_style = self.dialog_style.copy()
self.dialog.connect('style-set', self.style_set)
#Set up Drawing - does the shiny drawing stuff
self.widget = drawing.Drawing(self.switch, self.settings, self)
self.dialog.add(self.widget)
#Set up the values for the ViewportSurface
self.update_backgrounds()
self.draw_background = False
self.number = self.switch.get_current_workspace_num()
num_columns = self.switch.get_num_columns()
self.row = int((self.number) / float(num_columns)) + 1
self.column = int((self.number) % num_columns) + 1
#Set up the text overlay
self.overlay = awn.OverlayText()
self.add_overlay(self.overlay)
self.overlay.props.font_sizing = 21.0
self.overlay.props.text = str(self.number)
self.overlay.props.active = not self.settings['use_custom_text']
self.overlay.props.apply_effects = True
self.overlay.connect('notify::text-color', self.overlay_notify)
self.overlay.connect('notify::text-outline-color', self.overlay_notify)
self.overlay.connect('notify::font-mode', self.overlay_notify)
self.overlay.connect('notify::text-outline-width', self.overlay_notify)
self.settings.config.notify_add(GROUP_DEFAULT, 'use_custom_text', self.toggle_custom_text)
#Connect to signals
#Applet signals
self.connect('realize', self.realize_event)
self.connect('size-changed', self.size_changed)
self.connect('clicked', self.toggle_dialog)
self.connect('context-menu-popup', self.show_menu)
self.connect('scroll-event', self.scroll)
self.dialog.props.hide_on_unfocus = True
#Any relevant signal from Wnck
self.switch.connect(self.update_icon)
#Start updating the icon every 2 second, in 2 seconds
gobject.timeout_add_seconds(2, self.timeout_icon)
#Force the widget to get the background color from the dialog
#self.dialog.realize()
self.widget.update_color()
