Exemplo n.º 1
0
 def draw(self, color):
     sd.snowflake(center=sd.get_point(flake.xpoint, flake.ypoint),
                  length=flake.length,
                  color=color)
Exemplo n.º 2
0
# -*- coding: utf-8 -*-

# pip install simple_draw

import simple_draw as sd

# нарисовать треугольник из точки (300, 300) с длиной стороны 200
length = 200
point = sd.get_point(300, 300)

# v1 = sd.get_vector(start_point=point, angle=0, length=200, width=3)
# v1.draw()
#
# v2 = sd.get_vector(start_point=v1.end_point, angle=120, length=200, width=3)
# v2.draw()
#
# v3 = sd.get_vector(start_point=v2.end_point, angle=240, length=200, width=3)
# v3.draw()


# определить функцию рисования треугольника из заданной точки с заданным наклоном
def triangle(point, angle=0):
    v1 = sd.get_vector(start_point=point, angle=angle, length=200, width=3)
    v1.draw()

    v2 = sd.get_vector(start_point=v1.end_point,
                       angle=angle + 120,
                       length=200,
                       width=3)
    v2.draw()
Exemplo n.º 3
0
# -*- coding: utf-8 -*-

import simple_draw as sd

# Запросить у пользователя желаемую фигуру посредством выбора из существующих
#   вывести список всех фигур с номерами и ждать ввода номера желаемой фигуры.
# и нарисовать эту фигуру в центре экрана

# Код функций из упр lesson_004/02_global_color.py скопировать сюда
# Результат решения см lesson_004/results/exercise_03_shape_select.jpg
import simple_draw as sd

point_center = sd.get_point(300, 300)


def optiangle(angle_count, point, angle, length, step, the_color):
    #sd.background_color = (255, 255, 255)
    if angle_count == 1:
        length = length + 0
        angle = angle + 2
    if angle_count < 1:
        return
    v1 = sd.get_vector(start_point=point, angle=angle, length=length, width=3)
    v1.draw(color=the_color)

    optiangle(angle_count=angle_count - 1,
              point=v1.end_point,
              angle=angle + step,
              length=length,
              step=step,
              the_color=the_color)
Exemplo n.º 4
0
#  - справа от дома - дерево (можно несколько)
#  - справа в небе - радуга, слева - солнце (весна же!)
# пример см. lesson_005/results/04_painting.jpg
# Приправить своей фантазией по вкусу (коты? коровы? люди? трактор? что придумается)

import simple_draw as sd
from lesson_005.draw_object import tree
from lesson_005.draw_object import house
from lesson_005.draw_object import rainbow
from lesson_005.draw_object import sun
from lesson_005.draw_object import clouds
from lesson_005.draw_object import snow_melts
from lesson_005.draw_object import smile
sd.resolution = (1200, 600)

bottom_left_house_margin = sd.get_point(300, 1)
top_right_house_margin = sd.get_point(660, 211)

N = 20
center_snowflake = []
length_beam = []
drift = 0
step_draw = 0
for i in range(N):
    coord_xy = []
    x = sd.random_number(-22, 278)
    y = sd.random_number(640, 1400)
    coord_xy.append(x)
    coord_xy.append(y)
    center_snowflake.append(coord_xy)
    length_beam.append(sd.random_number(15, 20))
Exemplo n.º 5
0
# -*- coding: utf-8 -*-

import simple_draw as sd

sd.resolution = (1280, 720)

root_point = sd.get_point(600, 90)

# 1) Написать функцию draw_branches, которая должна рисовать две ветви дерева из начальной точки
# Функция должна принимать параметры:
# - точка начала рисования,
# - угол рисования,
# - длина ветвей,
# Отклонение ветвей от угла рисования принять 30 градусов,

# 2) Сделать draw_branches рекурсивной
# - добавить проверку на длину ветвей, если длина меньше 10 - не рисовать
# - вызывать саму себя 2 раза из точек-концов нарисованных ветвей,
#   с параметром "угол рисования" равным углу только что нарисованной ветви,
#   и параметром "длинна ветвей" в 0.75 меньшей чем длина только что нарисованной ветви

# 3) первоначальный вызов:
# root_point = get_point(300, 30)
# draw_bunches(start_point=root_point, angle=90, length=100)

# Пригодятся функции
# sd.get_point()
# sd.get_vector()
# Возможный результат решения см lesson_004/results/exercise_04_fractal_01.jpg

# можно поиграть -шрифтами- цветами и углами отклонения
Exemplo n.º 6
0
                            length=length,
                            count_angles=5)


def draw_hexagon(start_point, angle, length):
    """Draw triangle.
    Start_point is start position for draw (down left angle)
    angle is tilt angle base regarding axis x
    length is length one side"""
    draw_equilateral_figure(start_point=start_point,
                            angle=angle,
                            length=length,
                            count_angles=6)


point = sd.get_point(100, 100)
draw_triangle(start_point=point, angle=10, length=100)

point = sd.get_point(300, 100)
draw_square(start_point=point, angle=20, length=100)

point = sd.get_point(100, 300)
draw_pentagon(start_point=point, angle=0, length=100)

point = sd.get_point(300, 300)
draw_hexagon(start_point=point, angle=0, length=100)

# Часть 1-бис.
# Попробуйте прикинуть обьем работы, если нужно будет внести изменения в этот код.
# Скажем, связывать точки не линиями, а дугами. Или двойными линиями. Или рисовать круги в угловых точках. Или...
# А если таких функций не 4, а 44?
Exemplo n.º 7
0
# -*- coding: utf-8 -*-

# (цикл for)

import simple_draw as sd

rainbow_colors = (sd.COLOR_RED, sd.COLOR_ORANGE, sd.COLOR_YELLOW,
                  sd.COLOR_GREEN, sd.COLOR_CYAN, sd.COLOR_BLUE,
                  sd.COLOR_PURPLE)

# Нарисовать радугу: 7 линий разного цвета толщиной 4 с шагом 5 из точки (50, 50) в точку (350, 450)
for coord in range(7):
    sd.line(start_point=sd.get_point(50 + coord * 10, 50),
            end_point=sd.get_point(500 + coord * 10, 500),
            color=rainbow_colors[coord],
            width=10)

# Усложненное задание, делать по желанию.
# Нарисовать радугу дугами от окружности (cсм sd.circle) за нижним краем экрана,
# поэкспериментировать с параметрами, что бы было красиво
# for coord in range(7):
#     sd.circle(center_position=sd.get_point(300, 0), radius=300 - coord * 20, color=rainbow_colors[coord], width=400)
# else:
#     sd.circle(center_position=sd.get_point(300, 0), radius=300 - (coord + 1) * 20, color=sd.COLOR_DARK_BLUE, width=400)

sd.pause()
Exemplo n.º 8
0
    next_angle1 = angle1 - sd.random_number(30 - 30 * .4, 30 + 30 * .4)
    next_length = length * random.uniform(.75 - .75 * .2, .75 + .75 * .2)
    draw_bunches(start_point=next_point,
                 angle1=next_angle1,
                 length=next_length,
                 count_color_tree=next_count_color_tree)
    next_point = v1.end_point
    next_angle1 = angle1 + sd.random_number(30 - 30 * .4, 30 + 30 * .4)
    next_length = length * random.uniform(.75 - .75 * .2, .75 + .75 * .2)
    draw_bunches(start_point=next_point,
                 angle1=next_angle1,
                 length=next_length,
                 count_color_tree=next_count_color_tree)


root_point = sd.get_point(300, 30)
draw_bunches(start_point=root_point, angle1=90, length=100, count_color_tree=0)

# 1) Написать функцию draw_branches, которая должна рисовать две ветви дерева из начальной точки
# Функция должна принимать параметры:
# - точка начала рисования,
# - угол рисования,
# - длина ветвей,
# Отклонение ветвей от угла рисования принять 30 градусов,

# 2) Сделать draw_branches рекурсивной
# - добавить проверку на длину ветвей, если длина меньше 10 - не рисовать
# - вызывать саму себя 2 раза из точек-концов нарисованных ветвей,
#   с параметром "угол рисования" равным углу только что нарисованной ветви,
#   и параметром "длинна ветвей" в 0.75 меньшей чем длина только что нарисованной ветви
Exemplo n.º 9
0
    shape_draw(_point=_point,
               _length=_length,
               _angle=_angle,
               _n_corner=5,
               _color=sd.random_color())


def hexagon_v2(_point, _length=200, _angle=0):
    shape_draw(_point=_point,
               _length=_length,
               _angle=_angle,
               _n_corner=6,
               _color=sd.random_color())


point = sd.get_point(900, 600)
# for i in range(3, 15):
#     shape_draw(_point=point, _length=200, _n_corner=i, _angle=(i-3)*15, _color=sd.random_color())

triangle_v2(_point=sd.random_point(), _angle=23, _length=100)
square_v2(_point=sd.random_point(), _angle=67, _length=100)
pentagon_v2(_point=sd.random_point(), _angle=35, _length=100)
hexagon_v2(_point=sd.random_point(), _angle=8, _length=100)

# Часть 2-бис.
# А теперь - сколько надо работы что бы внести изменения в код? Выгода на лицо :)
# Поэтому среди программистов есть принцип D.R.Y. https://clck.ru/GEsA9
# Будьте ленивыми, не используйте копи-пасту!

sd.pause()
Exemplo n.º 10
0
# можно поиграть -шрифтами- цветами и углами отклонения
def draw_branches(start_point, angle, length):
    if length < 3:
        return
    v1 = sd.get_vector(start_point=start_point, angle=angle, length=length)
    if length > 6:
        v1.draw()
    else:
        v1.draw(color=sd.COLOR_GREEN)
    draw_branches(start_point=v1.end_point,
                  angle=angle - 30 + randint(-12, 12),
                  length=length * 0.75 * randint(8, 12) / 10)
    draw_branches(start_point=v1.end_point,
                  angle=angle + 30 + randint(-12, 12),
                  length=length * 0.75 * randint(8, 12) / 10)
    pass


root_point = sd.get_point(500, 30)
draw_branches(start_point=root_point, angle=90, length=100)
# 4) Усложненное задание (делать по желанию)
# - сделать рандомное отклонение угла ветвей в пределах 40% от 30-ти градусов
# - сделать рандомное отклонение длины ветвей в пределах 20% от коэффициента 0.75
# Возможный результат решения см lesson_004/results/exercise_04_fractal_02.jpg

# Пригодятся функции
sd.random_number()

sd.pause()
Exemplo n.º 11
0
# -*- coding: utf-8 -*-

# (цикл for)

import simple_draw as sd

rainbow_colors = (sd.COLOR_RED, sd.COLOR_ORANGE, sd.COLOR_YELLOW,
                  sd.COLOR_GREEN, sd.COLOR_CYAN, sd.COLOR_BLUE,
                  sd.COLOR_PURPLE)

# Нарисовать радугу: 7 линий разного цвета толщиной 4 с шагом 5 из точки (50, 50) в точку (350, 450)
# TODO здесь ваш код
startPoint = sd.get_point(50, 50)
endPoint = sd.get_point(350, 450)
step = 7
for color in rainbow_colors:
    sd.line(startPoint, endPoint, color, 4)
    startPoint.x += step
    endPoint.x += step
# Усложненное задание, делать по желанию.
# Нарисовать радугу дугами от окружности (cсм sd.circle) за нижним краем экрана,
# поэкспериментировать с параметрами, что бы было красиво
# TODO здесь ваш код
point = sd.get_point(350, -50)
radius = 600
for color in rainbow_colors:
    sd.circle(point, radius, color, 40)
    radius -= 20
sd.pause()
Exemplo n.º 12
0
# 4) Усложненное задание (делать по желанию)


def draw_branches(point, angle, length):
    delta_angle1 = sd.random_number(18, 42)
    delta_angle2 = sd.random_number(18, 42)
    delta_length1 = (sd.random_number(60, 90)) * 0.01
    delta_length2 = (sd.random_number(60, 90)) * 0.01
    if length < 2:
        return
    branch1 = sd.get_vector(start_point=point, angle=angle, length=length)
    next_angle1 = angle + delta_angle1
    next_angle2 = angle - delta_angle2
    next_length1 = length * delta_length1
    next_length2 = length * delta_length2
    branch1.draw()
    draw_branches(point=branch1.end_point,
                  angle=next_angle1,
                  length=next_length1)
    draw_branches(point=branch1.end_point,
                  angle=next_angle2,
                  length=next_length2)


root_point = sd.get_point(600, 30)

draw_branches(point=root_point, angle=90, length=100)

sd.pause()
#зачёт!
Exemplo n.º 13
0
# Код функций из упр lesson_004/02_global_color.py скопировать сюда
# Результат решения см lesson_004/results/exercise_03_shape_select.jpg

print("Возможные фигуры:")

figure = {
    '0': ("Треугольник", triangle),
    '1': ("Квадрат", square),
    '2': ("Пятиугольник", pentagon),
    '3': ("Шестиугольник", hexagon)
}

length = 100

middle_point = sd.get_point(sd.resolution[0] / 2 - length / 2, sd.resolution[1] / 2 - length / 2)

for key, value in figure.items():
    print(key, ':', value[0])
number = input()
while True:
    if number not in figure.keys():
        print('Введите корректный номер')
        number = input()
    else:
        fig = figure.get(number)[1]
        break
fig(point=middle_point, angle=0, length=length)

sd.pause()
Exemplo n.º 14
0
# -*- coding: utf-8 -*-
import simple_draw as sd
from old_lesson.rainbow import rainbow
from old_lesson.tree import tree
from old_lesson.snowfall import snowfall, snowdrift
from old_lesson.wall import wall

sd.set_screen_size(width=1400, height=780)

rainbow_point = [500, 0]
rainbow(rainbow_point, 950)

tree_point = sd.get_point(1200, 0)
tree(point=tree_point, angle=90, length=90, delta=30)
tree_point = sd.get_point(1120, 250)
tree(point=tree_point, angle=90, length=70, delta=30)
tree_point = sd.get_point(1150, 400)
tree(point=tree_point, angle=90, length=55, delta=30)

point_rectangle = sd.get_point(370, 0)
point_rectangle_2 = sd.get_point(820, 420)
sd.rectangle(point_rectangle,
             point_rectangle_2,
             color=sd.COLOR_YELLOW,
             width=1)
wall()

point_triangle = sd.get_point(350, 420)
v1 = sd.get_vector(start_point=point_triangle, angle=0, length=490, width=3)
v1.draw()
point_triangle_2 = v1.end_point
Exemplo n.º 15
0
import simple_draw as sd

sd.resolution = (1200, 600)
# познакомится с параметрами библиотечной функции рисования снежинки sd.snowflake()

# sd.snowflake(center=point_0, length=200, factor_a=0.5)

# реализовать падение одной снежинки
y = 500
x = 100

y2 = 450
x2 = 150
while True:
    sd.clear_screen()
    point = sd.get_point(x, y)
    sd.snowflake(center=point, length=50)
    y -= 60
    if y < 50:
        break
    x = x + 30

    point2 = sd.get_point(x2, y2)
    sd.snowflake(center=point2, length=30)
    y2 -= 10
    if y2 < 50:
        break
    x2 = x2 + 20

    sd.sleep(0.1)
    if sd.user_want_exit():
Exemplo n.º 16
0
import simple_draw as sd

radius = 60
eye = radius // 7


def smile(color):
    eye_left = sd.get_point(point.x - 25, point.y + 20)
    eye_right = sd.get_point(point.x + 25, point.y + 20)
    start_point = sd.get_point(point.x - 45, point.y - 10)
    end_point = sd.get_point(point.x - 25, point.y - 30)
    start_point1 = sd.get_point(point.x - 25, point.y - 30)
    end_point1 = sd.get_point(point.x + 20, point.y - 30)
    start_point2 = sd.get_point(point.x + 20, point.y - 30)
    end_point2 = sd.get_point(point.x + 40, point.y - 10)
    sd.circle(center_position=point, radius=radius, width=2, color=color)
    sd.circle(center_position=eye_left, radius=eye, width=0, color=color)
    sd.circle(center_position=eye_right, radius=eye, width=0, color=color)
    sd.line(start_point=start_point, end_point=end_point, color=color, width=2)
    sd.line(start_point=start_point1, end_point=end_point1, color=color, width=2)
    sd.line(start_point=start_point2, end_point=end_point2, color=color, width=2)


point = sd.get_point(325, 175)
smile(color=sd.COLOR_BLACK)


# sd.pause()
Exemplo n.º 17
0
 def draw_internal(self, color):
     sd.snowflake(center=sd.get_point(self.x, self.y), length=self.length, color=color)
Exemplo n.º 18
0
# (цикл for)

import simple_draw as sd

# Нарисовать радугу: 7 линий разного цвета толщиной 4 с шагом 5 из точки (50, 50) в точку (350, 450)
rainbow_colors = (sd.COLOR_RED, sd.COLOR_ORANGE, sd.COLOR_YELLOW,
                  sd.COLOR_GREEN, sd.COLOR_CYAN, sd.COLOR_BLUE,
                  sd.COLOR_PURPLE)
point = sd.get_point(240, 50)
radius = 400
i = 6
for color in rainbow_colors:
    radius += 5
    sd.circle(center_position=point, radius=radius, color=color, width=4)
    i -= 1

sd.line(sd.get_point(0, 0),
        sd.get_point(600, 0),
        color=sd.COLOR_GREEN,
        width=100)

sd.pause()
Exemplo n.º 19
0
 def draw(self):
     sd.start_drawing()
     point = sd.get_point(self.x, self.y)
     sd.snowflake(center=point, length=self.length)
     sd.finish_drawing()
Exemplo n.º 20
0

def hexagon(point, leng, angle):
    figure(point=point, leng=leng, angle=angle, number_of_points=6)


def figure(point, leng, angle, number_of_points):
    new_point = point
    for i in range(0, number_of_points - 1):
        vector = sd.get_vector(new_point, angle * i, length=leng)
        vector.draw()
        new_point = vector.end_point
    sd.line(start_point=new_point, end_point=point)


center_point = sd.get_point(sd.resolution[0] / 2, sd.resolution[1] / 2)

figure_all = {
    0: 'треугольник',
    1: 'квадрат',
    2: 'пятиугольник',
    3: 'шестиугольник'
}
for index, val in figure_all.items():
    print(index, ':', val)

figure_choose = ''
while True:
    try:
        figure_number = input("выберите фигуру: ")
        figure_choose = figure_all[int(figure_number)]
Exemplo n.º 21
0
def snow_paint(color):
    global snow_list
    for index, l_list in enumerate(snow_list):
        coord_x, coord_y, length = l_list
        point = sd.get_point(coord_x, coord_y)
        sd.snowflake(center=point, length=length, color=color)
Exemplo n.º 22
0
def smile(add_wink):
    i = 0
    while i < 2:
        x = 425
        y = 130
        point_smile = sd.get_point(x, y)
        point_eyes_1 = sd.get_point(x - 6, y + 5)
        point_eyes_2 = sd.get_point(x + 6, y + 5)
        color_smile = sd.COLOR_BLACK
        color_eyes_lips = sd.COLOR_WHITE
        radius = 20
        sd.circle(point_smile, radius, color_smile, width=0)
        sd.circle(point_eyes_1, 2, color_eyes_lips, width=1)
        if add_wink < 3:
            sd.line(sd.get_point(x, y + 5),
                    sd.get_point(x + 10, y + 5),
                    color_eyes_lips,
                    width=1)
        else:
            sd.circle(point_eyes_2, 2, color_eyes_lips, width=1)
        start_point1 = sd.get_point(x - 4, y - 6)
        end_point1 = sd.get_point(x - 3, y - 5)
        start_point2 = sd.get_point(x - 3, y - 5)
        end_point2 = sd.get_point(x + 3, y - 5)
        start_point3 = sd.get_point(x + 3, y - 5)
        end_point3 = sd.get_point(x + 4, y - 6)
        sd.line(start_point1, end_point1, color_eyes_lips, 1)
        sd.line(start_point2, end_point2, color_eyes_lips, 1)
        sd.line(start_point3, end_point3, color_eyes_lips, 1)

        point_list1 = (sd.get_point(x - 17,
                                    y + 12), sd.get_point(x - 9, y + 18),
                       sd.get_point(x - 17, y + 35))
        sd.polygon(point_list1, sd.COLOR_BLACK, width=0)
        point_list2 = (sd.get_point(x + 17,
                                    y + 2), sd.get_point(x + 9, y + 18),
                       sd.get_point(x + 17, y + 35))
        sd.polygon(point_list2, sd.COLOR_BLACK, width=0)

        sd.rectangle(sd.get_point(402, 78), sd.get_point(448, 115),
                     sd.COLOR_BLACK)
        i += 1
# -*- coding: utf-8 -*-
import random

import simple_draw as sd

sd.resolution = (1200, 600)

# Нарисовать пузырек - три вложенных окружностей с шагом 5 пикселей
point = sd.get_point(300, 300)
radius = 50
for _ in range(3):
    radius += 5
    sd.circle(center_position=point, radius=radius, width=2)
sd.sleep(1)
sd.clear_screen()


# Написать функцию рисования пузырька, принммающую 3 (или более) параметра: точка рисования, шаг и цвет
def buble(point, step, color):
    radius = 50
    for _ in range(3):
        radius += step
        sd.circle(center_position=point, radius=radius, width=2, color=color)


# Нарисовать 10 пузырьков в ряд
for x in range(100, 1001, 100):
    point = sd.get_point(x, 100)
    buble(point=point, step=5, color=(255, 127, 0))
sd.sleep(1)
sd.clear_screen()
Exemplo n.º 24
0
# (цикл for)

import simple_draw as sd

rainbow_colors = (sd.COLOR_RED, sd.COLOR_ORANGE, sd.COLOR_YELLOW,
                  sd.COLOR_GREEN, sd.COLOR_CYAN, sd.COLOR_BLUE,
                  sd.COLOR_PURPLE)

# Нарисовать радугу: 7 линий разного цвета толщиной 4 с шагом 5 из точки (50, 50) в точку (350, 450)
color = -1
for i in range(0, 30, 5):
    if color >= 6:
        break
    color += 1
    sd.line(start_point=sd.get_point(50 + i, 50),
            end_point=sd.get_point(350 + i, 450),
            color=rainbow_colors[color],
            width=4)

# Усложненное задание, делать по желанию.
# Нарисовать радугу дугами от окружности (cсм sd.circle) за нижним краем экрана,
# поэкспериментировать с параметрами, что бы было красиво


def rainbow(point, step):
    color = -1
    radius = 450
    for _ in range(0, 30):
        if color >= 6:
            break
Exemplo n.º 25
0
# Размер задается начальной (нижний левый угол) и конечной (верхний правый угол) точками

sd.caption = 'drawing a wall'
sd.resolution = (800, 600)
# размер кирпича:
brick_length, brick_height = 100, 50
# нижний левый угол стены (с крайнего нижнего угла экрана = 0, 0):
start_position_x, start_position_y = 100, 100
# правый верхний угол стены (до верхнего правого угла экрана = sd.resolution[0], sd.resolution[1]):
end_position_x, end_position_y = 700, 500
# задаем размер межрядного шва (шов кладки):
seam = 3
# задаем цвет:
color = sd.COLOR_DARK_ORANGE

left_bottom = sd.get_point(start_position_x, start_position_y)
right_top = sd.get_point(start_position_x + brick_length,
                         start_position_y + brick_height)
wall_top = sd.get_point(end_position_x, end_position_y)
sd.rectangle(left_bottom=left_bottom,
             right_top=wall_top,
             width=seam,
             color=color)
row = 'odd'
position_x = start_position_x

for y in range(start_position_y, end_position_y, brick_height):
    for x in range(position_x, end_position_x, brick_length):
        if x + brick_length <= end_position_x:
            shift_x = x + brick_length
        else:
Exemplo n.º 26
0
 def clear_previous_picture(self):
     sd.snowflake(center=sd.get_point(flake.xpoint, flake.ypoint),
                  length=flake.length,
                  color=sd.background_color)
Exemplo n.º 27
0
def draw_the_boy_who_alive(x, y, color=sd.COLOR_YELLOW):
    """Draw boy with scar in point(x, y)"""

    # голова и глаза
    head_center = sd.get_point(x, y)
    sd.circle(center_position=head_center, radius=100, width=2, color=color)
    left_eye_center = sd.get_point(x - 30, y + 25)
    sd.circle(center_position=left_eye_center, radius=15, color=color)
    right_eye_center = sd.get_point(x + 30, y + 25)
    sd.circle(center_position=right_eye_center, radius=15, color=color)

    # нос
    end_nose = sd.get_point(x, y - 20)
    sd.line(start_point=head_center, end_point=end_nose, width=1, color=color)

    # рот
    mouth_center = sd.get_point(x, y - 60)  # 200, 140
    smoothing_mouth_point = sd.get_point(x + 50, y - 50)
    right_end_of_mouth = sd.get_point(x - 50, y - 50)
    left_end_of_mouth = sd.get_point(x + 50, y - 50)
    mouth_point_list = (right_end_of_mouth, mouth_center,
                        smoothing_mouth_point, left_end_of_mouth)
    sd.lines(point_list=mouth_point_list, closed=True, width=2, color=color)

    # дужки очков
    start_left_tempera = sd.get_point(x - 45, y + 25)
    end_left_tempera = sd.get_point(x - 90, y + 30)
    start_right_tempera = sd.get_point(x + 45, y + 25)
    end_right_tempera = sd.get_point(x + 90, y + 30)
    start_middle_tempera = sd.get_point(x + 15, y + 25)
    end_middle_tempera = sd.get_point(x - 15, y + 25)
    sd.line(start_point=start_left_tempera,
            end_point=end_left_tempera,
            color=color)
    sd.line(start_point=start_right_tempera,
            end_point=end_right_tempera,
            color=color)
    sd.line(start_point=start_middle_tempera,
            end_point=end_middle_tempera,
            color=color)

    # шрам
    scar_start = sd.get_point(x - 20, y + 70)
    scar_point_1 = sd.get_point(x - 30, y + 70)
    scar_point_2 = sd.get_point(x - 40, y + 50)
    end_of_scar = sd.get_point(x - 50, y + 50)

    scar_points_list = (scar_start, scar_point_1, scar_point_2, end_of_scar)
    sd.lines(point_list=scar_points_list, closed=False, width=2, color=color)

    # волосы
    hair_start = sd.get_point(x - 30, y + 95)
    hair_point_1 = sd.get_point(x - 30, y + 120)
    hair_point_2 = sd.get_point(x - 10, y + 100)
    hair_point_3 = sd.get_point(x, y + 120)
    hair_point_4 = sd.get_point(x + 20, y + 95)
    hair_point_5 = sd.get_point(x + 30, y + 120)
    end_of_hair = sd.get_point(x + 40, y + 90)

    hairs_points_list = (hair_start, hair_point_1, hair_point_2, hair_point_3,
                         hair_point_4, hair_point_5, end_of_hair)
    sd.lines(point_list=hairs_points_list, closed=False, width=2, color=color)
Exemplo n.º 28
0
        return
    vector_0 = sd.get_vector(start_point=start_point,
                             angle=angle,
                             length=length)
    vector_0.draw()
    next_point = vector_0.end_point
    delta_angle = 30 + sd.random_number(0, 40) / 100
    delta_length = .75 + sd.random_number(-10, 10) / 100
    draw_branches(start_point=next_point,
                  angle=angle + delta_angle,
                  length=length * delta_length)
    delta_angle = 30 + sd.random_number(0, 40) / 100
    delta_length = .75 + sd.random_number(-10, 10) / 100
    draw_branches(start_point=next_point,
                  angle=angle - delta_angle,
                  length=length * delta_length)


point = sd.get_point(600, 0)
draw_branches(start_point=point, angle=90, length=200)

# 4) Усложненное задание (делать по желанию)
# - сделать рандомное отклонение угла ветвей в пределах 40% от 30-ти градусов
# - сделать рандомное отклонение длины ветвей в пределах 20% от коэффициента 0.75
# Возможный результат решения см lesson_004/results/exercise_04_fractal_02.jpg

# Пригодятся функции
# sd.random_number()

sd.pause()
Exemplo n.º 29
0
# TODO здесь ваш код
sd.resolution = (1200, 600)


# radius = 50
# for _ in range(3):
#     radius += 3
#     sd.circle(center_position=point, radius=radius, width=2)
def bubble(point, step):
    radius = 50
    for _ in range(3):
        radius += step
        sd.circle(center_position=point, radius=radius, width=2)


#
#
# point = sd.get_point(500, 500)
# bubble(point, 100)

# for x in range(100, 1001, 100):
#     point = sd.get_point(x, 100)
#     bubble(point, 5)
for y in range(100, 401, 100):
    for x in range(100, 1001, 100):
        point = sd.get_point(x, y)
        bubble(point, 5)

simple_draw.pause()
Exemplo n.º 30
0
print('Выберите цвет: ')
# вывод соответствия номера - цвету
for color in colors.items():
    print(color[0], ': ', color[1][0])

# выбор цвета и проверка правильности ввода
while True:
    user_color = input('Введите желаемый цвет: ')
    if user_color in colors.keys():
        color_draw = colors[user_color][1]
        break
    else:
        print('Вы ввели неправильный номер цвета!')

angle = 30
length = 100
width = 5
start_point_triangle = sd.get_point(100, 100)
start_point_squares = sd.get_point(600, 100)
start_point_pentagon = sd.get_point(300, 300)
start_point_hexagon = sd.get_point(700, 300)

triangle(start_point_triangle, angle, length)
squares(start_point_squares, angle, length)
pentagon(start_point_pentagon, angle, length)
hexagon(start_point_hexagon, angle, length)

sd.pause()

# зачет!
Exemplo n.º 31
0
# pip install simple draw

import simple_draw as sd
start_point = sd.get_point(300, 10)
my_angle = 90
my_length = 200

vector = sd.get_vector(
    start_point = start_point, angle=my_angle, length=my_length, width=6)
vector.draw()

start_point_2 = vector.end_point
my_angle_2 = my_angle - 20
my_length_2 = my_length * .7

vector_2 = sd.get_vector(
    start_point = start_point_2, angle=my_angle_2, length=my_length_2, width=6)
vector_2.draw()

start_point_3 = vector.end_point
my_angle_3 = my_angle + 20
my_length_3 = my_length * .7

vector_3 = sd.get_vector(
    start_point = start_point_3, angle=my_angle_3, length=my_length_3, width=6)
vector_3.draw()

sd.pause()