Esempio n. 1
0
    def test_pen_do_something_else_working(self):
        import sys
        from io import StringIO

        saved_stdout = sys.stdout

        pen = Pen(color='red')

        try:
            out = StringIO()
            sys.stdout = out
            pen.do_something_else()
            output = out.getvalue().strip()

            self.assertEqual('red', output)
        finally:
            sys.stdout = saved_stdout
Esempio n. 2
0
    def __init__(self, game, screen, rows, cols, model):
        self.wn = screen
        self.num_rows = rows
        self.num_cols = cols
        self.model = model
        self.pixels = [[] for row in range(rows)]

        self.pixel_gap = 560 / self.num_cols

        self.get_x = lambda col: self.pixel_gap * col + 10
        self.get_y = lambda row: -self.pixel_gap * row + 270

        for row in range(rows):
            for col in range(cols):
                pixel = Pixel(self, row, col)

        self.pen = Pen(screen=self.wn, grid=self)
        self.game = game
Esempio n. 3
0
class Pattern:

    def __init__(self):
        self.pen = Pen()
        self.pen.callback = self.refresh
        pygame.init()
        self.size = 1200, 1080
        self.screen = pygame.display.set_mode(self.size)

    def render(self):
        self.screen.fill([25, 23, 28])
        self.pen.get_state().position = [200, 1000]
        self.pen.draw([
                    'F[+F]F[-F]F',
                    'F[+F]F',
                    'F[-F]F',
                ], 5, np.deg2rad(25.7))
        self.pen.get_state().position = [550, 1000]
        self.pen.draw('F[+F]F[-F][F]', 5, np.deg2rad(20))
        self.pen.get_state().position = [850, 1000]
        self.pen.draw('FF-[-F+F+F]+[+F-F-F]', 4, np.deg2rad(22.5))
        pygame.display.flip()
        while 1:
            for event in pygame.event.get():
                if event.type == pygame.QUIT: sys.exit()

    def refresh(self, prev_state, state):
        for event in pygame.event.get():
            if event.type == pygame.QUIT: sys.exit()

        pygame.draw.line(self.screen,
                         self.colorize(prev_state, state),
                         tuple(prev_state.position),
                         tuple(state.position))
        #pygame.display.flip()

    def colorize(self, prev_state, state):
        position = state.position
        col_part = [
            self.clamp(255 * np.sin(position[0]/self.size[0]), 0, 255),
            self.clamp(255 * np.cos(position[1]/self.size[1]), 0, 255),
        ]
        return col_part[1], col_part[0], 55

    def clamp(self, n, minn, maxn):
        return max(min(maxn, n), minn)
Esempio n. 4
0
 def test_pen_write_word_with_float_ink_result(self):
     pen = Pen(ink_container_value=10, size_letter=0.7)
     self.assertEqual('word', pen.write('word'))
     # 10 ink - 4 letters * (with size 0.7) = 7.2
     self.assertEqual(7.2, int(pen.ink_container_value))  # simulating java int type
Esempio n. 5
0
 def test_pen_write_no_word_with_negative_size_letter(self):
     pen = Pen(ink_container_value=100, size_letter=-2.0)
     self.assertEqual('', pen.write('word'))
Esempio n. 6
0
 def test_pen_write_whitespaces_do_not_use_ink(self):
     pen = Pen(ink_container_value=2000)
     text = 'A basic test runner implementation that outputs results to a stream.'
     text_without_whitespaces = text.replace(' ', '')
     self.assertEqual(text, pen.write(text))
     self.assertEqual(2000 - len(text_without_whitespaces), pen.ink_container_value)
Esempio n. 7
0
 def test_pen_write_no_word_with_no_ink(self):
     pen = Pen(ink_container_value=0)
     self.assertEqual('', pen.write('school'))
Esempio n. 8
0
 def test_pen_init_no_parameters(self):
     pen = Pen()
     self.assertEqual(1000, pen.ink_container_value)
     self.assertEqual(1.0, pen.size_letter)
     self.assertEqual('blue', pen.color)
Esempio n. 9
0
 def test_pen_write_part_of_word_with_not_enough_ink(self):
     pen = Pen(ink_container_value=5, size_letter=2.5)
     self.assertEqual('sc', pen.write('school'))
     # 5 ink - 2 letters * (with size 2.5) = 0
     self.assertEqual(0, pen.ink_container_value)
Esempio n. 10
0
from Pen import Pen

p1 = Pen('Parker', 10, 'Black')
p1.write()

p2 = Pen('Cello', 20, 'blue')
p2.write()

p3 = Pen('Raynolds', 0, 'Green')
p3.write()
Esempio n. 11
0
 def test_pen_get_color_working(self):
     pen = Pen(color='green')
     self.assertEqual('green', pen.get_color())
Esempio n. 12
0
 def test_pen_check_pen_state_working(self):
     pen = Pen(ink_container_value=10)
     self.assertTrue(pen.check_pen_state())
Esempio n. 13
0
 def test_pen_check_pen_state_failing(self):
     pen = Pen(ink_container_value=0)
     self.assertFalse(pen.check_pen_state())
Esempio n. 14
0
 def test_pen_init_three_parameters(self):
     pen = Pen(ink_container_value=1, size_letter=0.9, color='green')
     self.assertEqual(1, pen.ink_container_value)
     self.assertEqual(0.9, pen.size_letter)
     self.assertEqual('green', pen.color)
Esempio n. 15
0
 def test_pen_init_two_parameters(self):
     pen = Pen(ink_container_value=3000, size_letter=2.5)
     self.assertEqual(3000, pen.ink_container_value)
     self.assertEqual(2.5, pen.size_letter)
     self.assertEqual('blue', pen.color)
Esempio n. 16
0
 def test_pen_init_one_parameter(self):
     pen = Pen(ink_container_value=90)
     self.assertEqual(90, pen.ink_container_value)
     self.assertEqual(1.0, pen.size_letter)
     self.assertEqual('blue', pen.color)
Esempio n. 17
0
class Grid:
    def __init__(self, game, screen, rows, cols, model):
        self.wn = screen
        self.num_rows = rows
        self.num_cols = cols
        self.model = model
        self.pixels = [[] for row in range(rows)]

        self.pixel_gap = 560 / self.num_cols

        self.get_x = lambda col: self.pixel_gap * col + 10
        self.get_y = lambda row: -self.pixel_gap * row + 270

        for row in range(rows):
            for col in range(cols):
                pixel = Pixel(self, row, col)

        self.pen = Pen(screen=self.wn, grid=self)
        self.game = game

    def initialize_all_pixels(self):
        ''' One-time only '''
        for row in self.pixels:
            for pixel in row:
                pixel.neighbors = pixel.get_neighbors()

    def listen_to_user(self):
        ''' Use the implemented pen. '''
        onmove(self.pen.wn, self.pen.move_handler)
        self.pen.onclick(self.pen.click_handler)

        t.listen()

    def color_clicked_pixel(self, x, y):
        '''
        Using the mouse cord, find the pixel that
        is clicked, and color it (and it's neighbors).
        '''
        col = int(x - 280) // int(self.pixel_gap)
        row = int(y) // int(self.pixel_gap)

        # Convert to correct values
        row = -row + 13
        col = col + 14

        if row < 0 or col < 0:  # Avoid errors and wrong indexing
            return

        self.pixels[row][col].draw(x, y)

    def convert_location(self, row, col):
        x = self.get_x(col)
        y = self.get_y(row)

        return (x, y)

    def export_grid(self):
        '''
        Export the grid to a numpy array that will
        be feeded to the Neural Network.
        '''
        all_pixels = [[] for row in range(self.num_rows)]

        for row in range(self.num_rows):
            for col in range(self.num_cols):
                if self.pixels[row][col].is_colored:
                    all_pixels[row].append(1)
                else:
                    all_pixels[row].append(0)

        pixel_array = np.array(all_pixels)
        pixel_array = pixel_array.reshape(1, 28, 28, 1)
        pixel_array = pixel_array.astype('float32')

        return pixel_array

    def make_a_prediction(self):

        input_grid = self.export_grid()

        prediction = self.model.predict(input_grid)
        if max(prediction[0]) < 0.25:  # Don't take bad decisions
            result = None
        else:
            result = np.argmax(prediction[0])

        if result != None:
            for balloon in self.game.balloons:
                if balloon.value == result:
                    balloon.kill()

        #print("Prediction: {}".format(result))

        # Get ready for the next drawing
        self.reset()

    def reset(self):
        ''' Uncolor all pixels. '''
        for row in self.pixels:
            for pixel in row:
                pixel.is_colored = False
                pixel.ht()
Esempio n. 18
0
 def test_pen_write_full_word_with_enough_ink(self):
     pen = Pen()
     self.assertEqual('school', pen.write('school'))
     # default 1000 ink - 6 letters * (with default size 1.0) = 994
     self.assertEqual(994, pen.ink_container_value)
Esempio n. 19
0
print("Hari/Tgl: Kamis, 14 Januari 2021  ")
print("#" * 34)

# main program
print("\n-> Create Object Backpack")
item_list = Backpack(owner="Bintang", capacity=3)
item_list.detail()

print("\n-> Backpack.remove()")
item_list.remove()

print("\n-> Backpack.add() menambahkan Object Eraser")
item_list.add(Eraser(owner="Bintang"))

print("\n-> Backpack.add() menambahkan Object Pen")
item_list.add(Pen(owner="Agastya"))

print("\n-> Backpack.add() menambahkan Object Notebook")
item_list.add(Notebook(owner="Bintang"))

print("\n-> Backpack.add() menambahkan Object Ruler")
item_list.add(Ruler(owner="Agastya"))

print("\n-> Backpack.remove(4) pada index = 4")
item_list.remove(4)

print("\n-> Backpack.remove(1) pada index = 1")
item_list.remove(1)

print("\n-> Backpack.add() menambahkan Object Pencil")
item_list.add(Pencil(owner="Bintang"))
Esempio n. 20
0
 def __init__(self):
     self.pen = Pen()
     self.pen.callback = self.refresh
     pygame.init()
     self.size = 1200, 1080
     self.screen = pygame.display.set_mode(self.size)