Ejemplo n.º 1
0
    def background(self):
        self.letters = f_read("emails")
        if config.NAME == "KLBFAX" and self.n == 1 and config.has_gmail_login(
        ):
            import gmail
            details = f_readlines("gmail")

            g = gmail.login(details[0], details[1])
            unread = g.inbox().mail(unread=True)
            for mail in unread:
                mail.fetch()
                lines = "".join(mail.body.split("\r")).split("\n")
                if lines[
                        0] == "EVENT" and "*****@*****.**" in mail.fr:
                    try:
                        with open_local('events', 'a') as f:
                            for line in lines:
                                if line != "EVENT":
                                    f.write(line + "\n")
                        mail.read()
                    except:
                        pass
                elif lines[
                        0] == "CARD" and "*****@*****.**" in mail.fr:
                    with open('/home/pi/cards/' + lines[1], "w") as f:
                        f.write("\n".join(lines[2:]))
                    mail.read()
                elif "POINTS" in lines[0].upper(
                ) and "*****@*****.**" in mail.fr:
                    from points import add_points
                    length = 1
                    points_to_give = 0
                    while length <= len(lines[2]):
                        try:
                            if lines[2][:length] != "-":
                                points_to_give = int(lines[2][:length])
                            length += 1
                        except:
                            break
                    add_points(lines[1].split("=")[0], points_to_give)
                    mail.read()

                else:
                    newletter = ""
                    for line in lines:
                        if line != "":
                            while len(line) > 79:
                                newletter += line[:79] + "\n"
                                line = line[79:]
                            newletter += line + "\n"

                    self.letters = newletter + "\n" + "from " + mail.fr + "\n\n" + self.letters
                    mail.read()
            self.letters = self.letters.split("\n")
            if len(self.letters) > 1000:
                self.letters = self.letters[:1000]
            with open_local("emails", "w") as f:
                f.write("\n".join(self.letters))
        else:
            self.letters = self.letters.split("\n")
Ejemplo n.º 2
0
def create_stroke_outline(path, radius, linejoin=sk2const.JOIN_MITER,
                          captype=sk2const.CAP_BUTT, miter_limit=MITER_LIMIT):
    """
    Outlines a single stroke. Returns two lists of lists of bezier
    segments for both sides of the stroke.
    """
    fw_segments = []
    bw_segments = []

    last_point = None

    segs = [path[0], ] + path[1]
    startpoint = [] + path[0]
    for i in range(len(segs)):
        segment = unpack_seg(segs[i], startpoint)
        startpoint = bezier_base_point(segs[i])
        if not segment[0]:
            if last_point:
                c1 = sub_points(segment[2], last_point)
                if not c1 == [0.0]:
                    t1 = mult_point(normalize(c1), radius)
                    fw_segments.append(
                        [add_points(last_point, [t1[1], -t1[0]]),
                         add_points(segment[2], [t1[1], -t1[0]])])
                    bw_segments.insert(0,
                                       [sub_points(segment[2], [t1[1], -t1[0]]),
                                        sub_points(last_point,
                                                   [t1[1], -t1[0]])])
            last_point = segment[2]

        else:
            segments = build_parallel([last_point, segment[1][0],
                                       segment[1][1], segment[2]], radius)
            fw_segments.append(segments)

            segments = build_parallel([segment[2], segment[1][1],
                                       segment[1][0], last_point], radius)
            bw_segments.insert(0, segments)
            last_point = segment[2]

    # Connect segments if necessary
    for item in [fw_segments, bw_segments]:
        join_segs(item, radius, linejoin, miter_limit,
                  path[2] == sk2const.CURVE_CLOSED)

    # Set caps for unclosed paths
    if not path[2] == sk2const.CURVE_CLOSED:
        fw_segments.insert(0, get_cap_segment(bw_segments[-1][-1],
                                              fw_segments[0][0], captype))
        bw_segments.insert(0, get_cap_segment(fw_segments[-1][-1],
                                              bw_segments[0][0], captype))

    return fw_segments, bw_segments
Ejemplo n.º 3
0
def create_stroke_outline (path, radius, linejoin=sk2_const.JOIN_MITER,
						captype=sk2_const.CAP_BUTT, miter_limit=MITER_LIMIT):
	"""
	Outlines a single stroke. Returns two lists of lists of bezier
	segments for both sides of the stroke.
	"""
	fw_segments = []
	bw_segments = []

	last_point = None

	segs = [path[0], ] + path[1]
	startpoint = [] + path[0]
	for i in range (len(segs)):
		segment = unpack_seg(segs[i], startpoint)
		startpoint = bezier_base_point(segs[i])
		if not segment[0]:
			if last_point:
				c1 = sub_points(segment[2], last_point)
				if not c1 == [0.0]:
					t1 = mult_point(normalize(c1), radius)
					fw_segments.append(
								[add_points(last_point, [t1[1], -t1[0]]),
								 add_points(segment[2], [t1[1], -t1[0]])])
					bw_segments.insert(0,
								[sub_points(segment[2], [t1[1], -t1[0]]),
								 sub_points(last_point, [t1[1], -t1[0]])])
			last_point = segment[2]

		else:
			segments = build_parallel([last_point, segment[1][0],
										segment[1][1], segment[2]], radius)
			fw_segments.append(segments)

			segments = build_parallel([segment[2], segment[1][1],
										segment[1][0], last_point], radius)
			bw_segments.insert(0, segments)
			last_point = segment[2]

	# Connect segments if necessary
	for item in [fw_segments, bw_segments]:
		join_segs(item, radius, linejoin, miter_limit,
				path[2] == sk2_const.CURVE_CLOSED)

	# Set caps for unclosed paths
	if not path[2] == sk2_const.CURVE_CLOSED:
		fw_segments.insert(0, get_cap_segment (bw_segments[-1][-1],
									fw_segments[0][0], captype))
		bw_segments.insert(0, get_cap_segment (fw_segments[-1][-1],
									bw_segments[0][0], captype))

	return fw_segments, bw_segments
Ejemplo n.º 4
0
def build_parallel(p, radius, recursionlimit=6):
    """
	This builds a list of bezier segments that are "sufficiently"
	close to a given source segment. It recursively subdivides, if
	the check for parallelity fails.	
	"""
    # find tangent to calculate orthogonal neighbor of endpoint
    for i in p[1:]:
        c1 = sub_points(i, p[0])
        if c1: break

    if c1 == [0, 0]: return []

    t1 = mult_point(normalize(c1), radius)
    p0 = add_points(p[0], [t1[1], -t1[0]])
    c1 = sub_points(p[1], p[0])

    for i in [p[2], p[1], p[0]]:
        c2 = sub_points(p[3], i)
        if not c2 == [0, 0]: break

    t2 = mult_point(normalize(c2), radius)
    p3 = add_points(p[3], [t2[1], -t2[0]])
    c2 = sub_points(p[3], p[2])

    sd = subdivide_seg(p)
    center = sd[3]
    ccenter = mult_point(normalize(sub_points(sd[4], sd[3])), radius)

    new_center = add_points(center, [ccenter[1], -ccenter[0]])
    seg = [p0, add_points(p0, c1), sub_points(p3, c2), p3]
    now_center = subdivide_seg(seg)[3]

    offset = mult_point(sub_points(new_center, now_center), 8.0 / 3)

    det = c1[0] * c2[1] - c1[1] * c2[0]
    if det:
        ndet = det / length(c1) / length(c2)
    else:
        ndet = 0

    if math.fabs(ndet) >= 0.1:
        # "sufficiently" linear independent, cramers rule:
        oc1 = mult_point(c1, ((offset[0] * c2[1] - offset[1] * c2[0]) / det))
        oc2 = mult_point(c2, ((c1[0] * offset[1] - c1[1] * offset[0]) / det))
    else:
        # don't bother to try to correct the error, will figure out
        # soon if subdivision is necessary.
        oc1 = [0.0, 0.0]
        oc2 = [0.0, 0.0]

    new_p1 = add_points(add_points(p0, c1), oc1)
    new_p2 = add_points(sub_points(p3, c2), oc2)
    proposed_segment = [p0, new_p1, new_p2, p3]
    if check_parallel(p, proposed_segment, radius) or recursionlimit <= 0:
        return proposed_segment
    else:
        # "Not parallel enough" - subdivide.
        return (build_parallel(sd[:4], radius, recursionlimit - 1) +
                build_parallel(sd[3:], radius, recursionlimit - 1)[1:])
Ejemplo n.º 5
0
def build_parallel(p, radius, recursionlimit=6):
	"""
	This builds a list of bezier segments that are "sufficiently"
	close to a given source segment. It recursively subdivides, if
	the check for parallelity fails.	
	"""
	# find tangent to calculate orthogonal neighbor of endpoint
	for i in p[1:]:
		c1 = sub_points(i, p[0])
		if c1: break

	if c1 == [0, 0]: return []

	t1 = mult_point(normalize(c1), radius)
	p0 = add_points(p[0], [t1[1], -t1[0]])
	c1 = sub_points(p[1], p[0])

	for i in [p[2], p[1], p[0]]:
		c2 = sub_points(p[3], i)
		if not c2 == [0, 0]: break

	t2 = mult_point(normalize(c2), radius)
	p3 = add_points(p[3], [t2[1], -t2[0]])
	c2 = sub_points(p[3], p[2])

	sd = subdivide_seg(p)
	center = sd[3]
	ccenter = mult_point(normalize(sub_points(sd[4], sd[3])), radius)

	new_center = add_points(center, [ccenter[1], -ccenter[0]])
	seg = [p0, add_points(p0, c1), sub_points(p3, c2), p3]
	now_center = subdivide_seg(seg)[3]

	offset = mult_point(sub_points(new_center, now_center), 8.0 / 3)

	det = c1[0] * c2[1] - c1[1] * c2[0]
	if det:
		ndet = det / length(c1) / length(c2)
	else:
		ndet = 0

	if math.fabs(ndet) >= 0.1:
		# "sufficiently" linear independent, cramers rule:
		oc1 = mult_point(c1, ((offset[0] * c2[1] - offset[1] * c2[0]) / det))
		oc2 = mult_point(c2, ((c1[0] * offset[1] - c1[1] * offset[0]) / det))
	else:
		# don't bother to try to correct the error, will figure out
		# soon if subdivision is necessary.
		oc1 = [0.0, 0.0]
		oc2 = [0.0, 0.0]

	new_p1 = add_points(add_points(p0, c1), oc1)
	new_p2 = add_points(sub_points(p3, c2), oc2)
	proposed_segment = [p0, new_p1, new_p2, p3]
	if check_parallel (p, proposed_segment, radius) or recursionlimit <= 0:
		return proposed_segment
	else:
		# "Not parallel enough" - subdivide.
		return (build_parallel (sd[:4], radius, recursionlimit - 1) +
				  build_parallel (sd[3:], radius, recursionlimit - 1)[1:])
Ejemplo n.º 6
0
    def generate_content(self):
        if self.points:
            from points import add_points
            add_points("Slytherin", 2)

        if self.points:
            self.add_text("Page failed to load...")
            self.add_newline()
            self.add_newline()
            self.add_text("2 points to Slytherin!")
            self.add_newline()
            self.add_newline()

        if self.ee is None:
            self.add_text("UNKNOWN ERROR")
        elif type(self.ee) == str:
            self.add_wrapped_text(self.ee)
        else:
            self.add_wrapped_text(str(self.ee))
        self.add_newline()
        self.add_wrapped_text(self.trace)
Ejemplo n.º 7
0
    def generate_content(self):
        extra = ""
        name = self.name
        from page import greetings

        greeting = greetings.random()
        if "Rafael" in name:
            if random()<0.6:
                greeting = "Muy Feo"
                add_points("Gryffindor",-1)
                extra = "\n\n-1 points to Gryffindor!"

        if random() < 0.01:
            name = "Jigsaw"
            add_points("Slytherin",10)

            extra = "\n\n10 points to Slytherin!"
        if random() < 0.01:
            name = "Fake Belgin"
            add_points("Squiberin",10)

            extra = "\n\n10 points to Squiberin!"
        extra += "\n\n"+self.extra
        self.content = colour_print(printer.text_to_ascii(greeting))
        self.content += "\n\n"
        if self.large: self.content += colour_print(printer.text_to_ascii(name + "!"))
        else: self.content += name
        self.content += extra
Ejemplo n.º 8
0
def play_a_hand(board, forced_hands = [], forced_hand_positions = [], prevent_firstround_callers = [], prevent_secondround_callers = [], enable_alone = True, only_accept_alone = False, pass_condition = None):

	# does all of the setup for one hand
	setup(board, forced_hands, forced_hand_positions, prevent_firstround_callers, prevent_secondround_callers, enable_alone)
	
	if pass_condition is not None:
		if pass_condition(board):
			board.trump_suit = 'pass'
			return
	if board.trump_suit == 'null':	return		# happens if no one calls it
	
	# allow this option
	if only_accept_alone:
		if not board.going_alone:
			return
	
	# play 5 tricks
	for i in range(5):
		play_a_trick(board)
	
	# add points
	points.add_points(board)
	if board.show_each_turn:	print(board.hand_result.capitalize())
Ejemplo n.º 9
0
 def background(self):
     import os
     files = ["points", "events", "emails"]
     if config.NAME == "KLBFAX" and config.MAIN == True:
         from points import add_points
         os.system(
             "scp mscroggs:~/.klb/points /home/pi/.klbtemp/points > /dev/null 2>&1"
         )
         with open("/home/pi/.klbtemp/points") as f:
             for line in f:
                 lsp = line.strip("\n").split(",")
                 add_points(lsp[0], int(lsp[1]), lsp[2])
         with open("/home/pi/.klbtemp/points", "w") as f:
             pass
         os.system(
             "scp /home/pi/.klbtemp/points mscroggs:~/.klb/points > /dev/null 2>&1"
         )
         for f in files:
             os.system("scp /home/pi/.klb/" + f + " mscroggs:~/.klbdump/" +
                       f + " > /dev/null 2>&1")
     else:
         for f in files:
             os.system("scp mscroggs:~/.klbdump/" + f + " /home/pi/.klb/" +
                       f + " > /dev/null 2>&1")
Ejemplo n.º 10
0
def flat_path(path, tlr=0.5):
    result = [[] + path[0]]
    start = [] + path[0]
    for point in path[1]:
        if len(point) == 2:
            result.append([] + point)
            start = [] + point
        else:
            p0 = sub_points(point[0], start)
            p1 = sub_points(point[1], start)
            p2 = sub_points(point[2], start)
            points = _flat_segment([0.0, 0.0], p0, p1, p2, tlr)
            for item in points:
                p = add_points(item, start)
                result.append(p)
            start = [] + point[2]
    return [result[0], result[1:], path[2]]
Ejemplo n.º 11
0
def check_parallel(source, parallel, radius, tolerance=0.01):
    """
	This function checks, if two bezier segments are "sufficiently"
	parallel. It checks, if the points for the parameters 0.25, 0.5
	and 0.75 of the tested segment are orthogonal to the resp.
	points of the source segment. 1% tolerance is default.
	
	It does not check the start and endpoints, since they are
	assumed to be correct by construction.
	"""
    for t0 in [0.25, 0.5, 0.75]:
        s = subdivide_seg(source, t0)
        t = subdivide_seg(parallel, t0)
        ccenter = mult_point(normalize(sub_points(s[4], s[3])), radius)
        orig = add_points(s[3], [ccenter[1], -ccenter[0]])
        if length(sub_points(orig, t[3])) >= tolerance * radius: return False
    return True
Ejemplo n.º 12
0
def check_parallel(source, parallel, radius, tolerance=0.01):
	"""
	This function checks, if two bezier segments are "sufficiently"
	parallel. It checks, if the points for the parameters 0.25, 0.5
	and 0.75 of the tested segment are orthogonal to the resp.
	points of the source segment. 1% tolerance is default.
	
	It does not check the start and endpoints, since they are
	assumed to be correct by construction.
	"""
	for t0 in [0.25, 0.5, 0.75]:
		s = subdivide_seg(source, t0)
		t = subdivide_seg(parallel, t0)
		ccenter = mult_point(normalize(sub_points(s[4], s[3])), radius)
		orig = add_points(s[3], [ccenter[1], -ccenter[0]])
		if length(sub_points(orig, t[3])) >= tolerance * radius: return False
	return True
Ejemplo n.º 13
0
def get_cap_segment(startpoint, endpoint, captype):
    """
    This returns a list of bezier segments that form the end cap of
    a line. Valid captypes are: CAP_BUTT, CAP_ROUND, CAP_SQUARE	
    """

    #  =====|
    if captype == sk2const.CAP_BUTT:
        return [startpoint, endpoint]

    # =====)
    elif captype == sk2const.CAP_ROUND:
        f = CIRCLE_CONSTANT
        d = mult_point(sub_points(endpoint, startpoint), 0.5)
        o = [d[1], -d[0]]

        new_p1 = add_points(startpoint, o)
        new_p2 = mult_point(o, f)

        return [
            startpoint,
            add_points(startpoint, new_p2),
            add_points(new_p1, mult_point(d, 1 - f)),
            add_points(new_p1, d),
            add_points(new_p1, mult_point(d, 1 + f)),
            add_points(endpoint, new_p2), endpoint
        ]

    # =====]
    elif captype == sk2const.CAP_SQUARE:
        d = mult_point(sub_points(endpoint, startpoint), 0.5)
        o = [d[1], -d[0]]

        new_p1 = add_points(startpoint, o)
        new_p2 = add_points(endpoint, o)

        return [
            startpoint, startpoint, new_p1, new_p1, new_p1, new_p2, new_p2,
            new_p2, endpoint, endpoint
        ]

    else:
        raise 'Unknown captype %d' % captype
Ejemplo n.º 14
0
	def split_seg(self, base_point, point, t=0.5):
		if is_bezier(point):
			p0 = base_point
			p1, p2, p3 = point[:3]
			t2 = 1.0 - t
			r = add_points(mult_point(p1, t2) , mult_point(p2, t))
			q1 = add_points(mult_point(p0, t2), mult_point(p1, t))
			q2 = add_points(mult_point(q1, t2), mult_point(r, t))
			q5 = add_points(mult_point(p2, t2), mult_point(p3, t))
			q4 = add_points(mult_point(r, t2), mult_point(q5, t))
			q3 = add_points(mult_point(q2, t2), mult_point(q4, t))
			return [[q1, q2, [] + q3, 0], q3, [q4, q5, [] + p3, 0]]
		else:
			new_point = add_points(mult_point(base_point, (1.0 - t)),
						mult_point(point, t))
			return [new_point, [] + new_point, None]
Ejemplo n.º 15
0
 def split_seg(self, base_point, point, t=0.5):
     if is_bezier(point):
         p0 = base_point
         p1, p2, p3 = point[:3]
         t2 = 1.0 - t
         r = add_points(mult_point(p1, t2), mult_point(p2, t))
         q1 = add_points(mult_point(p0, t2), mult_point(p1, t))
         q2 = add_points(mult_point(q1, t2), mult_point(r, t))
         q5 = add_points(mult_point(p2, t2), mult_point(p3, t))
         q4 = add_points(mult_point(r, t2), mult_point(q5, t))
         q3 = add_points(mult_point(q2, t2), mult_point(q4, t))
         return [[q1, q2, [] + q3, 0], q3, [q4, q5, [] + p3, 0]]
     else:
         new_point = add_points(mult_point(base_point, (1.0 - t)),
                                mult_point(point, t))
         return [new_point, [] + new_point, None]
Ejemplo n.º 16
0
def flat_path(path, tlr=0.5):
    result = []
    result.append([] + path[0])
    start = [] + path[0]
    for point in path[1]:
        if len(point) == 2:
            result.append([] + point)
            start = [] + point
        else:
            p0 = sub_points(point[0], start)
            p1 = sub_points(point[1], start)
            p2 = sub_points(point[2], start)
            points = _flat_segment([0.0, 0.0], p0, p1, p2, tlr)
            for item in points:
                p = add_points(item, start)
                result.append(p)
            start = [] + point[2]
    return [result[0], result[1:], path[2]]
Ejemplo n.º 17
0
def subdivide_seg(seg, t=0.5):
	"""
	This subdivides a bezier segment at the (optional) Parameter t
	"""
	assert len(seg) == 4
	t2 = 1.0 - t
	p01 = add_points(mult_point(seg[0], t2) , mult_point(seg[1], t))
	p12 = add_points(mult_point(seg[1], t2), mult_point(seg[2], t))
	p23 = add_points(mult_point(seg[2], t2), mult_point(seg[3], t))
	p012 = add_points(mult_point(p01, t2), mult_point(p12, t))
	p123 = add_points(mult_point(p12, t2), mult_point(p23, t))
	p0123 = add_points(mult_point(p012, t2), mult_point(p123, t))
	return (seg[0], p01, p012, p0123, p123, p23, seg[3])
Ejemplo n.º 18
0
def subdivide_seg(seg, t=0.5):
    """
    This subdivides a bezier segment at the (optional) Parameter t
    """
    assert len(seg) == 4
    t2 = 1.0 - t
    p01 = add_points(mult_point(seg[0], t2), mult_point(seg[1], t))
    p12 = add_points(mult_point(seg[1], t2), mult_point(seg[2], t))
    p23 = add_points(mult_point(seg[2], t2), mult_point(seg[3], t))
    p012 = add_points(mult_point(p01, t2), mult_point(p12, t))
    p123 = add_points(mult_point(p12, t2), mult_point(p23, t))
    p0123 = add_points(mult_point(p012, t2), mult_point(p123, t))
    return seg[0], p01, p012, p0123, p123, p23, seg[3]
Ejemplo n.º 19
0
def split_bezier_curve(start_point, end_point, t=0.5):
	p0 = [] + start_point
	if len(start_point) > 2: p0 = [] + start_point[2]
	p1, p2, p3, flag = deepcopy(end_point)
	p0_1 = add_points(mult_point(p0, (1.0 - t)), mult_point(p1, t))
	p1_2 = add_points(mult_point(p1, (1.0 - t)), mult_point(p2, t))
	p2_3 = add_points(mult_point(p2, (1.0 - t)), mult_point(p3, t))
	p01_12 = add_points(mult_point(p0_1, (1.0 - t)), mult_point(p1_2, t))
	p12_23 = add_points(mult_point(p1_2, (1.0 - t)), mult_point(p2_3, t))
	p0112_1223 = add_points(mult_point(p01_12, (1.0 - t)), mult_point(p12_23, t))
	new_point = [p0_1, p01_12, p0112_1223, flag]
	new_end_point = [p12_23, p2_3, p3, flag]
	return new_point, new_end_point
Ejemplo n.º 20
0
def get_cap_segment (startpoint, endpoint, captype):
	"""
	This returns a list of bezier segments that form the end cap of
	a line. Valid captypes are: CAP_BUTT, CAP_ROUND, CAP_SQUARE	
	"""

	#  =====|
	if captype == sk2_const.CAP_BUTT:
		return [startpoint, endpoint]

	#  =====)
	elif captype == sk2_const.CAP_ROUND:
		f = CIRCLE_CONSTANT
		d = mult_point(sub_points(endpoint, startpoint), 0.5)
		o = [d[1], -d[0]]

		new_p1 = add_points(startpoint, o)
		new_p2 = mult_point(o, f)

		return [startpoint,
				add_points(startpoint, new_p2),
				add_points(new_p1, mult_point(d, 1 - f)),
				add_points(new_p1, d),
				add_points(new_p1, mult_point(d, 1 + f)),
				add_points(endpoint, new_p2),
				endpoint]

	#  =====]
	elif captype == sk2_const.CAP_SQUARE:
		d = mult_point(sub_points(endpoint, startpoint), 0.5)
		o = [d[1], -d[0]]

		new_p1 = add_points(startpoint, o)
		new_p2 = add_points(endpoint, o)

		return [startpoint, startpoint, new_p1, new_p1, new_p1,
				new_p2, new_p2, new_p2, endpoint, endpoint]

	else:
		raise "Unknown captype %d" % captype
Ejemplo n.º 21
0
def split_bezier_curve(start_point, end_point, t=0.5):
    p0 = start_point[2] if len(start_point) > 2 else start_point
    p1, p2, p3 = end_point[:3]
    flag = end_point[3] if len(end_point) == 4 else sk2const.NODE_CUSP
    p0_1 = add_points(mult_point(p0, (1.0 - t)), mult_point(p1, t))
    p1_2 = add_points(mult_point(p1, (1.0 - t)), mult_point(p2, t))
    p2_3 = add_points(mult_point(p2, (1.0 - t)), mult_point(p3, t))
    p01_12 = add_points(mult_point(p0_1, (1.0 - t)), mult_point(p1_2, t))
    p12_23 = add_points(mult_point(p1_2, (1.0 - t)), mult_point(p2_3, t))
    p0112_1223 = add_points(mult_point(p01_12, (1.0 - t)),
                            mult_point(p12_23, t))
    new_point = [p0_1, p01_12, p0112_1223, flag]
    new_end_point = [p12_23, p2_3, p3, flag]
    return new_point, new_end_point
Ejemplo n.º 22
0
def split_bezier_curve(start_point, end_point, t=0.5):
    p0 = [] + start_point
    if len(start_point) > 2:
        p0 = [] + start_point[2]
    p1, p2, p3, flag = deepcopy(end_point)
    p0_1 = add_points(mult_point(p0, (1.0 - t)), mult_point(p1, t))
    p1_2 = add_points(mult_point(p1, (1.0 - t)), mult_point(p2, t))
    p2_3 = add_points(mult_point(p2, (1.0 - t)), mult_point(p3, t))
    p01_12 = add_points(mult_point(p0_1, (1.0 - t)), mult_point(p1_2, t))
    p12_23 = add_points(mult_point(p1_2, (1.0 - t)), mult_point(p2_3, t))
    p0112_1223 = add_points(mult_point(p01_12, (1.0 - t)),
                            mult_point(p12_23, t))
    new_point = [p0_1, p01_12, p0112_1223, flag]
    new_end_point = [p12_23, p2_3, p3, flag]
    return new_point, new_end_point
Ejemplo n.º 23
0
    def generate_content(self):
        letters = f_read("emails")

        if not os.getenv('SLAVE'):
            import gmail
            details = f_readlines("gmail")

            g = gmail.login(details[0],details[1])
            unread = g.inbox().mail(unread=True)
            for mail in unread:
                mail.fetch()
                lines = "".join(mail.body.split("\r")).split("\n")
                if lines[0] == "EVENT" and "*****@*****.**" in mail.fr:
                    try:
                        with open(join(expanduser("~"),'.klb/events'),'a') as f:
                            for line in lines:
                                if line!="EVENT":
                                    f.write(line+"\n")
                        mail.read()
                    except:
                        pass
                elif lines[0] == "CARD" and "*****@*****.**" in mail.fr:
                    with open('/home/pi/cards/'+lines[1],"w") as f:
                        f.write("\n".join(lines[2:]))
                    mail.read()
                elif "POINTS" in lines[0].upper() and "*****@*****.**" in mail.fr:
                    from points import add_points
                    length = 1
                    points_to_give = 0
                    while length<=len(lines[2]):
                        try:
                            if lines[2][:length]!="-":
                                points_to_give = int(lines[2][:length])
                            length += 1
                        except:
                            break
                    add_points(lines[1].split("=")[0],points_to_give)
                    mail.read()
    
                else:
                    newletter_col = choice(self.colours.Background.non_boring)
                    newletter = ""
                    for line in lines:
                        if line!="":
                            while len(line)>79:
                                newletter += newletter_col+line[:79]+"\n"
                                line=line[79:]
                            newletter+=newletter_col+line+"\n"
    
                    letters=newletter+"\n"+newletter_col+self.colours.Foreground.BLACK+"from "+mail.fr+self.colours.Foreground.DEFAULT+self.colours.Background.DEFAULT+"\n\n"+letters
                    mail.read()
            letters = letters.split("\n")
            if len(letters)>1000:
                letters = letters[:1000]
            with open(join(expanduser("~"),".klb/emails"),"w") as f:
                f.write("\n".join(letters))

        else:
            letters = letters.split("\n")
        letters = letters[20*(self.n-1):20*self.n]
        letters = "\n".join(letters)
        letters = unicode(letters,'latin1')


        page = self.colours.colour_print(printer.text_to_ascii("Have your say "+str(self.n)+"/21",vertical_condense=True))
        page += "\n\n"
        page += letters
        page += self.colours.Foreground.DEFAULT
        page += self.colours.Background.DEFAULT
        page += "\n\n"
        if self.n==21:
            page += "~ END OF LETTERS ~"
        else:
            page += "The letters continue on page "+str(200+self.n)
        self.content = page
Ejemplo n.º 24
0
 def generate_content(self):
     from points import add_points
     add_points("Slytherin", 2)
Ejemplo n.º 25
0
def get_join_segment(startpoint,
                     endpoint,
                     radius,
                     jointype,
                     miter_limit=MITER_LIMIT):
    """
    This returns a list of bezier segments that joins two points
    with a given radius (fails if the radius is smaller than the
    distance between startpoint) and endpoint). 
    jointype is one of 	JOIN_MITER, JOIN_ROUND, JOIN_BEVEL	
    """

    if jointype == sk2const.JOIN_MITER:
        d = mult_point(sub_points(endpoint, startpoint), 0.5)

        if d == [0, 0]:
            return []

        o = normalize([d[1], -d[0]])

        if radius < length(d):
            return [startpoint, endpoint]

        h = math.sqrt(radius**2 - length(d)**2)

        h2 = length(d)**2 / h

        if h2 + h > miter_limit * radius:
            # Hit miter limit
            return [startpoint, endpoint]

        edge = add_points(add_points(startpoint, d), mult_point(o, h2))
        new_seg1 = line_to_curve(startpoint, edge)
        new_seg2 = line_to_curve(edge, endpoint)
        return [
            startpoint,
        ] + new_seg1 + new_seg2

    elif jointype == sk2const.JOIN_ROUND:
        f = CIRCLE_CONSTANT
        d = mult_point(sub_points(endpoint, startpoint), 0.5)

        if d == [0, 0]:
            return []

        o = mult_point(normalize([d[1], -d[0]]), radius)

        if radius < length(d):
            return [startpoint, endpoint]

        h = math.sqrt(radius**2 - length(d)**2) / radius

        center = sub_points(add_points(startpoint, d), mult_point(o, h))
        d = mult_point(normalize(d), radius)

        t0 = circleparam(h)
        quadseg = [
            sub_points(center, d),
            add_points(sub_points(center, d), mult_point(o, f)),
            add_points(sub_points(center, mult_point(d, f)), o),
            add_points(center, o)
        ]
        ret = [startpoint] + list(subdivide_seg(quadseg, t0)[4:])

        quadseg = [
            add_points(center, o),
            add_points(add_points(center, o), mult_point(d, f)),
            add_points(add_points(center, d), mult_point(o, f)),
            add_points(center, d)
        ]
        ret = ret + list(subdivide_seg(quadseg, 1 - t0)[1:3]) + [endpoint]

        return ret

    elif jointype == sk2const.JOIN_BEVEL:
        return [startpoint, endpoint]

    else:
        raise "Unknown join type %d" % jointype
Ejemplo n.º 26
0
from os.path import expanduser, join, isdir
from os import mkdir
import log_setup
from random import choice
from points import add_points
import Keyboard
import weather

if not isdir(join(expanduser('~'), '.klb')):
    mkdir(join(expanduser('~'), '.klb'))

if not os.getenv("SLAVE"):
    house = choice(["Ravenclaw", "Gryffindor", "Slytherin", "Hufflepuff", "Squib",
                    "Durmstrang"])

    add_points(house, 1)
    if house == "Hufflepuff":
        print("1 point to "+house+"! GO PUFFS!")
    else:
        print("1 point to "+house+"!")

log_setup.read_from_file()


Keyboard.start_keyboard_thread()
Keyboard.subscribe(ceefax.name_page_handler)

weather_thread = weather.weatherThread()
weather_thread.start()

while True:
Ejemplo n.º 27
0
def get_join_segment(startpoint, endpoint, radius, jointype,
					miter_limit=MITER_LIMIT):
	"""
	This returns a list of bezier segments that joins two points
	with a given radius (fails if the radius is smaller than the
	distance between startpoint) and endpoint). 
	jointype is one of 	JOIN_MITER, JOIN_ROUND, JOIN_BEVEL	
	"""

	if jointype == sk2_const.JOIN_MITER:
		d = mult_point(sub_points(endpoint, startpoint), 0.5)

		if d == [0, 0]: return []

		o = normalize([d[1], -d[0]])
		h = math.sqrt(radius ** 2 - length(d) ** 2)

		h2 = length(d) ** 2 / h

		if h2 + h > miter_limit * radius:
			# Hit miter limit
			return [startpoint, endpoint]

		edge = add_points(add_points(startpoint, d), mult_point(o, h2))
		new_seg1 = line_to_curve(startpoint, edge)
		new_seg2 = line_to_curve(edge, endpoint)
		return [startpoint, ] + new_seg1 + new_seg2

	elif jointype == sk2_const.JOIN_ROUND:
		f = CIRCLE_CONSTANT
		d = mult_point(sub_points(endpoint, startpoint), 0.5)

		if d == [0, 0]: return []

		o = mult_point(normalize([d[1], -d[0]]), radius)

		h = math.sqrt(radius ** 2 - length(d) ** 2) / radius

		center = sub_points(add_points(startpoint, d), mult_point(o, h))
		d = mult_point(normalize(d), radius)

		t0 = circleparam(h)
		quadseg = [sub_points(center, d),
					add_points(sub_points(center, d), mult_point(o, f)),
					add_points(sub_points(center, mult_point(d, f)), o),
					add_points(center, o)]
		ret = [startpoint] + list (subdivide_seg(quadseg, t0)[4:])

		quadseg = [add_points(center, o),
					add_points(add_points(center, o), mult_point(d, f)),
					add_points(add_points(center, d), mult_point(o, f)),
					add_points(center, d)]
		ret = ret + list (subdivide_seg(quadseg, 1 - t0)[1:3]) + [endpoint]

		return ret

	elif jointype == sk2_const.JOIN_BEVEL:
		return [startpoint, endpoint]

	else:
		raise "Unknown join type %d" % jointype