def __init__(self, root):
super().__init__(root)
self.canvas = cv.Canvas(self)
self.add_canvas()
self.x = [-10, 10, 0.1]
self.z = [-10, 10, 0.1]
self.ox = 0
self.oy = 0
self.oz = 0
self.scale = None
self.frame_color = tk.Frame(self)
self.color = 'black'
self.color_win = None
self.add_color()
self.frame_funcs = tk.Frame(self)
self.func = tk.IntVar()
self.func.set(0)
self.add_funcs()
self.frame_limits = tk.Frame(self)
self.dx = []
self.dz = []
self.add_limits()
self.frame_entries = tk.Frame(self)
self.add_entry()
self.frame_buttons = tk.Frame(self)
self.add_buttons()
def main():
P = [[40], [40]]
V0 = [[30], [30]]
V1 = [[40], [70]]
V2 = [[50], [30]]
points = [V0, V1, V2]
aspect_correct = [[1, 0], [0, 4 / 7]]
home = "\N{escape}[H"
wakeup_time = time.time()
print(home + "\N{escape}[J\N{escape}[?25l")
t = 0
try:
while True:
kanvas = canvas.Canvas()
rot = matrix.rotate_2D(t * 0.5)
r_points = []
for point in points:
C = matrix.sub(point, P)
C = matrix.mult(rot, C)
C = matrix.add(P, C)
C = matrix.mult(aspect_correct, C)
r_points.append(C)
t += 1
kanvas.triangle(round(r_points[0][0][0]), round(r_points[0][1][0]),
round(r_points[1][0][0]), round(r_points[1][1][0]),
round(r_points[2][0][0]), round(r_points[2][1][0]))
image = home + kanvas.get_image()
print(image)
wakeup_time += 0.05
time.sleep(max(0, wakeup_time - time.time()))
finally:
print(home + "\N{escape}[J \N{escape}[?25h")
def test_ppm_ends_with_newline(self):
"""Satisfy picky image viewers by ensuring the ppm file ends in a
newline
"""
c = canvas.Canvas(5, 3)
ppm_content = c._get_ppm_file_content()
self.assertEqual(ppm_content[-1:], "\n")
def main():
P = [[40],
[40],
[0]]
Axis = [[10],
[5],
[3]]
# V0 = [[30],
# [30],
# [0]]
# V1 = [[40],
# [70],
# [0]]
# V2 = [[50],
# [30],
# [0]]
# points = [V0, V1, V2]
points = []
for i in range(15):
points.append([[random.randint(20, 60)],
[random.randint(30, 60)],
[random.randint(-20, 20)]])
aspect_correct = [[1, 0, 0],
[0, 4/7, 0],
[0, 0, 1]]
home = "\N{escape}[H"
wakeup_time = time.time()
print(home + "\N{escape}[J\N{escape}[?25l")
t = 0
try:
while True:
kanvas = canvas.Canvas()
rot = matrix.rotate_3D(t * 0.1, Axis)
r_points = []
for point in points:
C = matrix.sub(point, P)
C = matrix.mult(rot, C)
C = matrix.add(P, C)
C = matrix.mult(aspect_correct, C)
r_points.append(C)
t += 1
for r_point in r_points:
kanvas.dab(round(r_point[0][0]),
round(r_point[1][0]))
# kanvas.triangle(round(r_points[0][0][0]),
# round(r_points[0][1][0]),
# round(r_points[1][0][0]),
# round(r_points[1][1][0]),
# round(r_points[2][0][0]),
# round(r_points[2][1][0]))
image = home + kanvas.get_image()
print(image)
wakeup_time += 0.05
time.sleep(max(0, wakeup_time - time.time()))
finally:
print(home + "\N{escape}[J \N{escape}[?25h")
def test_write_to_canvas(self):
"""Test we can write to and read from a canvas"""
c = canvas.Canvas(10, 20)
red = colors.Color(1, 0, 0)
c.set(2, 3, red)
self.assertEqual(c.canvas[2][3], red)
def GroupGraph(self):
#graphics and toolbars
Rd = canvas.Canvas(self.main_widget, width=5, height=5, dpi=100)
self.dataCanvas = Rd
Cd = canvas.Canvas(self.main_widget, width=5, height=5, dpi=100)
self.errorCanvas = Cd
toolbarRd = NavigationToolbar(Rd, self)
toolbarCd = NavigationToolbar(Cd, self)
groupBoxGraph = QGroupBox('Graphics and toolbars')
vbox = QVBoxLayout()
vbox.addWidget(toolbarRd)
vbox.addWidget(Rd)
vbox.addWidget(toolbarCd)
vbox.addWidget(Cd)
vbox.addStretch(1)
groupBoxGraph.setLayout(vbox)
return groupBoxGraph
def test_empty_canvas(self):
"""Test that an empty canvas is filled with black pixels"""
c = canvas.Canvas(10, 20)
self.assertEqual(len(c.canvas), 10)
self.assertEqual(len(c.canvas[0]), 20)
for i in range(10):
for j in range(20):
self.assertEqual(c.canvas[i][j],
colors.Color(0, 0, 0))
def build_ui(self):
# using grid system to set the widgets in the window
self.cnv = canvas.Canvas(self)
self.cnv.grid(row=0, column=0, columnspan=2, rowspan=2)
self.res = predictions_ui.Results(self)
bl = tk.Button(self, text="Clear Canvas", command=self.clear_all)
bl.grid(row=2, column=0)
br = tk.Button(self, text="Predict Drawing", command=self.predict)
br.grid(row=2, column=1)
def main():
PAUSE = False
print('Initializing canvas...')
canv = canvas.Canvas(*RESOLUTION)
canv.render_single_frame(pause=PAUSE)
print('Drawing borders...')
canv.draw_borders()
canv.render_single_frame(pause=PAUSE)
NUM_CIRCLES = 16
print('Adding', NUM_CIRCLES, 'circles...')
RADIUS_RANGE = (8, 8)
VELOCITY_RANGE = (4, 4)
border_zone = 20
CX = RESOLUTION[1] / 2
CY = RESOLUTION[0] / 2
for count in range(NUM_CIRCLES):
radius = random.randint(*RADIUS_RANGE)
# Leave space for the dodger to start in the middle
SPACE = 70
cx = double_interval_random(border_zone + radius, CX - SPACE,
CX + SPACE,
RESOLUTION[1] - (border_zone + radius))
cy = double_interval_random(border_zone + radius, CY - SPACE,
CY + SPACE,
RESOLUTION[0] - (border_zone + radius))
velocity = random.uniform(*VELOCITY_RANGE)
theta = random.uniform(0, 2 * np.pi)
vx = velocity * np.cos(theta)
vy = velocity * np.sin(theta)
canv.add_circle(cx, cy, radius, vx, vy)
canv.render_single_frame(pause=PAUSE)
DODGER_SPEED = 200
MODEL = 2
print('Adding dodger...')
theta = random.uniform(0, 2 * np.pi)
canv.create_dodger(CX, CY, theta, DODGER_SPEED, MODEL)
canv.render_single_frame(pause=True)
# motion
SECONDS = 15
EMPIRICAL_FPS = 64
TOTAL_FRAMES = SECONDS * EMPIRICAL_FPS
canv.main_game_loop()
def test_ppm_long_line_splitting(self):
"""Test that we split longer lines at or before 70 characters"""
c = canvas.Canvas(10, 2)
for i in range(c.width):
for j in range(c.height):
c.set(i, j, colors.Color(1, 0.8, 0.6))
ppm_content = c._get_ppm_file_content()
ppm_lines = ppm_content.split("\n")
self.assertEqual(ppm_lines[3],
"255 204 153 255 204 153 255 204 153 255 204 153 255 204 153 255 204")
self.assertEqual(ppm_lines[4],
"153 255 204 153 255 204 153 255 204 153 255 204 153")
self.assertEqual(ppm_lines[5],
"255 204 153 255 204 153 255 204 153 255 204 153 255 204 153 255 204")
self.assertEqual(ppm_lines[6],
"153 255 204 153 255 204 153 255 204 153 255 204 153")
def main():
client = canvas.Canvas("https://fhict.instructure.com", read_api_key())
previous_day = datetime.datetime.now(
datetime.timezone.utc) - datetime.timedelta(days=5)
ok, announcements_or_error = client.get_announcements_after(previous_day)
if not ok:
print("error: {}".format(announcements_or_error))
return
announcements = announcements_or_error
for announcement in announcements:
title = announcement["title"]
author = announcement["author"]["display_name"]
post_time = announcement["posted_at"]
message = announcement["message"]
print(announcement)
print(
"title: {}\n\tpost time: {}\n\tauthor: {} \n\tmessage: {}".format(
title, post_time, author, message))
def open_image(self,
path,
bitDepth=16,
enableAutoWB=False,
brightness=20,
blackLevel=50):
if not path == '':
canvas_widget = canvas.Canvas(self, self.config)
self.connect_canvas(canvas_widget)
self.CANVAS_SCALE_FACTOR_CHANGED.emit(self.scaleFactor)
img_array = self.load_image(canvas_widget, path, bitDepth,
enableAutoWB, brightness, blackLevel)
self.photoList.append(img_array)
self.pathList.append(path)
self.mainTab.addTab(canvas_widget, os.path.basename(path))
self.mainTab.setCurrentIndex(self.mainTab.count() - 1)
canvas_widget.fit_canvas()
canvas_widget.toggle_mode(self._mode)
self.currentPath = path
self.FILE_OPENED.emit(path)
def __init__(self, root):
super().__init__(root)
self.canvas = cv.Canvas(self)
self.add_canvas()
self.img = None
self.add_image()
self.frame_input = tk.Frame(self)
self.coors = None
self.add_input()
self.frame_color = tk.Frame(self)
self.color = tk.IntVar()
self.color.set(0)
self.add_color()
self.frame_buttons = tk.Frame(self)
self.mode = tk.IntVar()
self.mode.set(0)
self.add_buttons()
def test_ppm_file_content(self):
"""Test the content of the PPM header is correct"""
c = canvas.Canvas(5, 3)
c1 = colors.Color(1.5, 0, 0)
c2 = colors.Color(0, 0.5, 0)
c3 = colors.Color(-0.5, 0, 1)
c.set(0, 0, c1)
c.set(2, 1, c2)
c.set(4, 2, c3)
ppm_content = c._get_ppm_file_content()
ppm_lines = ppm_content.split("\n")
self.assertEqual(ppm_lines[0], "P3")
self.assertEqual(ppm_lines[1], "5 3")
self.assertEqual(ppm_lines[2], "255")
self.assertEqual(ppm_lines[3], "255 0 0 0 0 0 0 0 0 0 0 0 0 0 0")
self.assertEqual(ppm_lines[4], "0 0 0 0 0 0 0 128 0 0 0 0 0 0 0")
self.assertEqual(ppm_lines[5], "0 0 0 0 0 0 0 0 0 0 0 0 0 0 255")
def main():
# Initialize canvas
print('Initializing canvas...')
canvas_object = canvas.Canvas(*kResolution)
canvas_object.RenderSingleFrame(kPause)
# Draw borders
print('Drawing borders...')
canvas_object.DrawBorders()
canvas_object.RenderSingleFrame(kPause)
# Draw circles
print('Adding', kNumCircles, 'circles...')
for count in range(kNumCircles):
radius = random.randint(*kCircleRadiusRange)
# Leave space for the dodger to start in the middle
xmin, xmax = canvas_object.playable_area_xrange_
ymin, ymax = canvas_object.playable_area_yrange_
cx = math_util.RandomSlicedInterval(xmin, xmax, kMiddleSpawnBufferRatio)
cy = math_util.RandomSlicedInterval(ymin, ymax, kMiddleSpawnBufferRatio)
velocity = random.uniform(*kCircleVelocityRange)
theta = math_util.RandomAngle()
vx = velocity * np.cos(theta)
vy = velocity * np.sin(theta)
canvas_object.AddCircle(cx, cy, radius, vx, vy)
canvas_object.RenderSingleFrame(kPause)
# Draw dodger
print('Adding dodger...')
xmin, xmax = canvas_object.playable_area_xrange_
ymin, ymax = canvas_object.playable_area_yrange_
cx = math_util.RoundToInt(0.5 * (xmin + xmax))
cy = math_util.RoundToInt(0.5 * (ymin + ymax))
theta = math_util.RandomAngle()
canvas_object.CreateDodger(cx, cy, theta, kDodgerSpeed, kDodgerTurningRate)
canvas_object.RenderSingleFrame(pause=True)
# Motion
#SECONDS = 15
#EMPIRICAL_FPS = 64
#TOTAL_FRAMES = SECONDS*EMPIRICAL_FPS
canvas_object.MainGameLoop()
def render(self, scene: scenes.Scene):
"""Renders a scene and returns a filled in canvas"""
logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
time_0 = time.time()
logging.info(f"Starting to render scene with size "
f"{self.hsize}, {self.vsize}")
image = canvas.Canvas(self.hsize, self.vsize)
for y in range(self.vsize):
print(y)
for x in range(self.hsize):
ray = self.ray_for_pixel(x, y)
color, _ = scene.color_at(ray)
image.set(x, y, color)
time_1 = time.time()
logging.info(
f"Rendered scene in {round(time_1-time_0, 2)}s "
f"({round(self.hsize*self.vsize/(time_1-time_0), 2)} pps)")
return image
def __init__(self, root):
super().__init__(root)
self.canvas = cv.Canvas(self)
self.add_canvas()
self.frame_cutter = tk.Frame(self)
self.cutter_coors = None
self.cutter = []
self.add_cutter()
self.frame_section = tk.Frame(self)
self.section_coors = None
self.section = []
self.add_section()
self.frame_color = tk.Frame(self)
self.color_wins = dict()
self.colors = {'cutter': 'black', 'section': 'red', 'result': 'blue'}
self.add_color()
self.frame_buttons = tk.Frame(self)
self.add_buttons()
def scan_trace(self, file):
mycanvas = canvas.Canvas()
for line in file:
line = line.split()
event_type = line[0]
timestamp = float(line[1])
hop_src_node = int(line[2])
hop_dst_node = int(line[3])
packet_name = line[4] # TCP or ACK
packet_size = int(line[5])
packet_flag = line[6] # C is a control packet
# print packet_flag[0]
ip_src_node = int(line[2]) # todo : change this
ip_dst_node = int(line[3]) # todo : change this
src_port = 0 # todo : change this
dst_port = 0 # todo : change this
packet_id = int(line[11])
sequence_number = int(line[10])
mycanvas.add_event(timestamp, packet_id, packet_name, event_type,
hop_src_node, hop_dst_node, ip_src_node,
ip_dst_node, src_port, dst_port,
sequence_number, packet_flag, packet_size)
return mycanvas
def index():
# Start the webcam camera
cap = cv2.VideoCapture(1)
# Initialize variables
paper_contour = np.array([])
bg_thresh = None
finger_thresh = None
thresh2 = None
finger_thresh2 = None
stable_threshold = 0.01
farthest = None # Point tracking the fingertip of the user
current_position = None
num_frames = 4
history = paper_buffer.Paper_Buffer(num_frames)
click_threshold = 8
while (True):
# Capture a video frame-by-frame
ret, frame = cap.read()
# Find the edges in each frame
gray = cv2.cvtColor(
frame,
cv2.COLOR_BGR2GRAY) # Turn image frame into grayscale version
blur = cv2.GaussianBlur(
gray, (5, 5),
0) # Execute a Gaussian blur to remove noise from the frame
thresh = cv2.threshold(blur.copy(), 127, 255,
cv2.THRESH_BINARY)[1] # Create a binary image
edges = cv2.Canny(thresh, 50, 200) # Isolate the edges in the picture
# Find contours in the edged image, keep only the largest ones, and initialize our screen contour
_, temp_contours, _ = cv2.findContours(edges.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_SIMPLE)
contours = sorted(temp_contours, key=cv2.contourArea,
reverse=True)[:10]
# Loop over contours to find which contour belongs to the paper
count = 0
for contour in contours:
# Approximate how many points the perimeter of the contour has
perimeter = cv2.arcLength(contour, True)
area = cv2.contourArea(contour)
approx = cv2.approxPolyDP(contour, 0.02 * perimeter, True)
# If the approximated contour has 4 points, we can assume we have found our paper
if len(approx) == 4 and perimeter > 1000 and area > 2000:
# Save the paper contour
paper_contour = approx
# Save the canvas thresholds
bg_thresh = np.zeros(thresh.shape, dtype=np.uint8)
finger_thresh = np.zeros(thresh.shape, dtype=np.uint8)
# Store the canvas information for use in future calculations
paper_canvas = canvas.Canvas(map(lambda x: x[0],
paper_contour))
# Fill in the paper to filter out the canvas later (when extracting the user's hand)
cv2.fillConvexPoly(bg_thresh, paper_contour, 255)
break
# Draw red circles at the corners of the paper
for point in paper_contour:
cv2.circle(frame, (point[0][0], point[0][1]), 5, (0, 0, 255), 3)
# Draw a green outline around the edges of the paper
cv2.polylines(frame, [paper_contour], True, (0, 255, 0), 3)
# Create a mask of the frame to prepare for bitwise operations
_, mask = cv2.threshold(blur, 127, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)
# Check if the threshold and mask are the same size before performing operations
if np.shape(bg_thresh) == np.shape(mask):
# Isolate the user's hand in the binary image
mask_clean = cv2.bitwise_and(mask, bg_thresh)
bg_thresh_clean = cv2.bitwise_and(bg_thresh, bg_thresh)
finger_thresh2 = cv2.bitwise_xor(mask_clean, bg_thresh)
# Get rid of leftover noise at the paper edges
cv2.polylines(finger_thresh2, [paper_contour], True, (0, 0, 0), 3)
# Calculate the differential value
temp = cv2.bitwise_xor(finger_thresh,
finger_thresh2,
mask=bg_thresh)
dif_value = np.sum(temp / (np.sum(finger_thresh2) + 0.1))
# Calculate the lowest point of the finger mask, corresponding to the fingertip
if dif_value > stable_threshold:
# Collect the coordinates where the finger threshold is above a certain height
y_values, x_values = np.where(finger_thresh2 > 0)
# Find the y-value with the highest magnitude, corresponding to the lowest point on the screen
if len(y_values > 0):
# Track the current position of the user's fingertip
index = np.argmax(y_values)
farthest = (x_values[index], y_values[index])
current_position = farthest
# Initialize booleans used to check if a click has occurred
click_pre = False
click_down = False
click_up = False
time.sleep(0.008)
for element in np.roll(history.array, history.head,
axis=0):
distance = canvas.distance_point_point(
element, current_position)
#print distance
if click_up:
continue
if click_down and distance > 10:
click_up = True
print '=========================== CLICK ====================='
paper_canvas.get_button(current_position)
history.clear()
click_up = False
click_down = False
click_pre = False
elif click_pre and distance > 5 and distance < 20:
click_down = True
print '================ DOWN ==============='
elif distance < 5:
click_pre = True
# Update history queue
history.enqueue(current_position)
# Place a blue circle to mark the fingertip
cv2.circle(frame, farthest, 5, (255, 0, 0), 3)
# Display the resulting frame
cv2.imshow('frame', frame)
else:
# Display the resulting frame
cv2.imshow('frame', frame)
# Display the resulting frame
if cv2.waitKey(1) & 0xFF == ord('q'):
paper_canvas.replay()
break
# When everything is done, release the capture
cap.release()
cv2.destroyAllWindows()
help="Directory where PrairieLearn repo is stored")
parser.add_argument("pl_course_instance",
help="Course instance where assessment will be created")
parser.add_argument("-s",
"--assessment-set",
default="Quiz",
help="Assessment set to assign this assessment to")
parser.add_argument("-n",
"--assessment-number",
default="",
help="Assessment set to assign this assessment to")
parser.add_argument("--topic",
default="None",
help="Assessment set to assign this assessment to")
args = parser.parse_args()
canvas = canvas.Canvas(args=args)
if not os.path.exists(os.path.join(args.pl_repo, 'infoCourse.json')):
raise Exception("Provided directory is not a PrairieLearn repository")
print('Reading data from Canvas...')
course = canvas.course(args.course, prompt_if_needed=True)
print('Using course: %s / %s' %
(course['term']['name'], course['course_code']))
quiz = course.quiz(args.quiz, prompt_if_needed=True)
print('Using quiz: %s' % (quiz['title']))
# Reading questions
print('Retrieving quiz questions from Canvas...')
(questions, groups) = quiz.questions()
def __init__(self):
super(Window, self).__init__()
self.image_worker = process.Image()
self.image_crop = [800, 1800, 1650, 2650]
self.current_status = {}
self.canvas_config = configparser.ConfigParser()
self.canvas_config.read('./configuration.ini')
self.mainSplitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
self.topSplitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
self.canvasFrame = QtWidgets.QWidget()
self.canvasFrameGrid = QtWidgets.QHBoxLayout(self.canvasFrame)
self.canvas = canvas.Canvas(self, self.canvas_config)
self.digital_tile = digital_tile.DigTile(self)
self.controlPanel = QtWidgets.QWidget(self)
self.controlPanelGrid = QtWidgets.QGridLayout(self.controlPanel)
self.supportedFormates = {'*.3fr','*.ari','*.arw','*.srf', '*.sr2','*.bay','*.cri','*.crw', '*.cr2', '*.cr3', '*.cap','*.iiq','*.eip',\
'*.dcs','*.dcr','*.drf','*.k25', '*.kdc','*.dng','*.erf','*.fff', '*.mef', '*.mdc', '*.mos','*.mrw','*.nef',\
'*.nrw','*.orf','*.pef','*.ptx', '*.pxn','*.r3d','*.raf','*.raw', '*.rw2', '*.rwl', '*.rwz','*.srw','*.x3f',\
'*.3FR','*.ARI','*.ARW','*.SRF', '*.SR2','*.BAY','*.CRI','*.CRW', '*.CR2', '*.CR3', '*.CAP','*.IIQ','*.EIP',\
'*.DCS','*.DCR','*.DRF','*.K25', '*.KDC','*.DNG','*.ERF','*.FFF', '*.MEF', '*.MDC', '*.MOS','*.MRW','*.NEF',\
'*.NRW','*.ORF','*.PEF','*.PTX', '*.PXN','*.R3D','*.RAF','*.RAW', '*.RW2', '*.RWL', '*.RWZ','*.SRW','*.X3F',\
'*.bmp','*.eps','*.gif','*.icns','*.ico','*.im', '*.jpg','*.jpeg','*.jpeg2000','*.msp', '*.pcx','*.png','*.ppm',\
'*.sgi','*.tiff','*.tif','*.xbm','*.BMP','*.EPS','*.GIF','*.ICNS','*.ICO', '*.IM', '*.JPG','*.JPEG','*.JPEG2000',\
'*.MSP','*.PCX','*.PNG','*.PPM','*.SGI','*.TIFF','*.TIF','*.XBM'}
self.open_label = QtWidgets.QLabel('Choose image file:\n')
self.open_label.setMaximumHeight(100)
self.open_button = QtWidgets.QPushButton('Browse...')
self.open_button.clicked.connect(self.browse_image)
self.browser_widget = browser.Browser(self, self.supportedFormates)
self.IMAGE_CHOSEN.connect(self.browser_widget.tree_update)
self.browser_widget.FILE_DOUBLE_CLICKED.connect(self.open_image)
self.browser_widget.setMaximumHeight(400)
self.nbs_label = QtWidgets.QLabel('Number of scales:')
self.nba_label = QtWidgets.QLabel('Number of angles:')
self.ac_label = QtWidgets.QLabel('Use curvet at the coarest scale?')
self.nbs = QtWidgets.QComboBox()
for s in range(3, 20):
self.nbs.addItem(str(s))
self.nbs.setCurrentText('5')
self.nbs.currentTextChanged.connect(self.nbs_changed)
self.nba = QtWidgets.QComboBox()
for a in [8, 16, 32, 64]:
self.nba.addItem(str(a))
self.nba.currentTextChanged.connect(self.nba_changed)
self.ac = QtWidgets.QCheckBox()
self.ac.setChecked(True)
self.ac.stateChanged.connect(self.ac_changed)
self.wedge_index_label = QtWidgets.QLabel('Current wedge index:')
self.threshold_label = QtWidgets.QLabel('Threshold ({})'.format(30))
self.threshold_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.threshold_slider.setMinimum(0)
self.threshold_slider.setMaximum(255)
self.threshold_slider.setValue(30)
self.threshold_slider.valueChanged.connect(self.threshold_changed)
self.cursor_selections_label = QtWidgets.QLabel(
'Cursor selection rule:')
self.cursor_selections = QtWidgets.QComboBox()
self.cursor_selections.addItem('cell')
self.cursor_selections.addItem('level')
self.cursor_selections.currentTextChanged.connect(
self.digital_tile.set_cursor_selection_rule)
self.click_functions_label = QtWidgets.QLabel('Click function:')
self.click_functions = QtWidgets.QComboBox()
self.click_functions.addItem('select')
self.click_functions.addItem('show')
self.click_functions.currentTextChanged.connect(
self.digital_tile.set_click_function_rule)
self.previous_difference_scale_factor = 10
self.difference_scale_factor_label = QtWidgets.QLabel(
'Difference gain ({})'.format(
self.previous_difference_scale_factor))
self.difference_scale_factor_slider = QtWidgets.QSlider(
QtCore.Qt.Horizontal)
self.difference_scale_factor_slider.setMinimum(1)
self.difference_scale_factor_slider.setMaximum(100)
self.difference_scale_factor_slider.setValue(
self.previous_difference_scale_factor)
self.difference_scale_factor_slider.valueChanged.connect(
self.difference_scale_factor_changed)
self.button_group = QtWidgets.QGroupBox()
self.button_group_grid = QtWidgets.QVBoxLayout(self.button_group)
self.show_selected_cells_button = QtWidgets.QPushButton(
"Show Selected Cells")
self.show_selected_cells_button.clicked.connect(
self.show_selected_cells)
self.show_selected_cells_button.setEnabled(False)
self.close_all_button = QtWidgets.QPushButton("Close All")
self.close_all_button.setEnabled(False)
self.close_all_button.clicked.connect(self.clear_all)
self.load_curvelet_button = QtWidgets.QPushButton(
"Load Curvelet Digital Tile")
self.load_curvelet_button.clicked.connect(self.load_curvelet_transform)
self.load_curvelet_button.setEnabled(False)
self.show_modified_image_button = QtWidgets.QPushButton("Show Results")
self.show_modified_image_button.clicked.connect(self.show_modified)
self.show_modified_image_button.setEnabled(False)
self.apply_threshold_button = QtWidgets.QPushButton(
'Apply Threshold Denoise')
self.apply_threshold_button.clicked.connect(self.threshold_denoise)
self.apply_threshold_button.setEnabled(False)
self.button_group_grid.addWidget(self.show_selected_cells_button)
self.button_group_grid.addWidget(self.close_all_button)
self.button_group_grid.addWidget(self.load_curvelet_button)
self.button_group_grid.addWidget(self.show_modified_image_button)
self.button_group_grid.addWidget(self.apply_threshold_button)
self.button_group_grid.setAlignment(QtCore.Qt.AlignTop)
self.controlPanelGrid.setAlignment(QtCore.Qt.AlignTop)
self.controlPanelGrid.addWidget(self.open_label, 0, 0, 1, 6)
self.controlPanelGrid.addWidget(self.open_button, 1, 0, 1, 6)
self.controlPanelGrid.addWidget(self.browser_widget, 2, 0, 1, 6)
self.controlPanelGrid.addWidget(self.nbs_label, 10, 0, 1, 2)
self.controlPanelGrid.addWidget(self.nbs, 10, 2, 1, 4)
self.controlPanelGrid.addWidget(self.nba_label, 11, 0, 1, 2)
self.controlPanelGrid.addWidget(self.nba, 11, 2, 1, 4)
self.controlPanelGrid.addWidget(self.ac_label, 12, 0, 1, 2)
self.controlPanelGrid.addWidget(self.ac, 12, 2, 1, 4)
self.controlPanelGrid.addWidget(self.threshold_label, 13, 0, 1, 2)
self.controlPanelGrid.addWidget(self.threshold_slider, 13, 2, 1, 4)
self.controlPanelGrid.addWidget(self.difference_scale_factor_label, 14,
0, 1, 2)
self.controlPanelGrid.addWidget(self.difference_scale_factor_slider,
14, 2, 1, 4)
self.controlPanelGrid.addWidget(self.cursor_selections_label, 20, 0, 1,
2)
self.controlPanelGrid.addWidget(self.cursor_selections, 20, 2, 1, 4)
self.controlPanelGrid.addWidget(self.click_functions_label, 21, 0, 1,
2)
self.controlPanelGrid.addWidget(self.click_functions, 21, 2, 1, 4)
self.controlPanelGrid.addWidget(self.wedge_index_label, 22, 0, 1, 6)
self.controlPanelGrid.addWidget(self.digital_tile, 30, 0, 1, 5)
self.controlPanelGrid.addWidget(self.button_group, 30, 5, 1, 1)
self.statusBar = QtWidgets.QGroupBox("Log")
self.statusBar.setStyleSheet('QGroupBox::title {color:blue;}')
self.statusGrid = QtWidgets.QGridLayout(self.statusBar)
self.progressBar = QtWidgets.QProgressBar()
self.progressBar.setVisible(False)
self.progressBar.setOrientation(QtCore.Qt.Horizontal)
self.progressBarSizePolicy = self.progressBar.sizePolicy()
self.progressBarSizePolicy.setRetainSizeWhenHidden(True)
self.progressBarSizePolicy.setHorizontalPolicy(
QtWidgets.QSizePolicy.Expanding)
self.progressBar.setSizePolicy(self.progressBarSizePolicy)
self.logBox = QtWidgets.QTextEdit(QtCore.QTime.currentTime().toString("hh:mm:ss")+\
"\u00A0\u00A0\u00A0\u00A0Initialized!")
self.logCursor = QtGui.QTextCursor(self.logBox.document())
self.logCursor.movePosition(QtGui.QTextCursor.End)
self.logBox.setTextCursor(self.logCursor)
self.logBox.ensureCursorVisible()
self.logBox.setAlignment(QtCore.Qt.AlignTop)
self.logBox.setFrameShape(QtWidgets.QFrame.NoFrame)
self.logBoxScroll = QtWidgets.QScrollArea()
self.logBoxScroll.setWidget(self.logBox)
self.logBoxScroll.setWidgetResizable(True)
self.logBoxScroll.setFrameShape(QtWidgets.QFrame.NoFrame)
self.statusGrid.addWidget(self.logBoxScroll, 0, 0)
self.statusGrid.setAlignment(self.progressBar, QtCore.Qt.AlignRight)
self.canvasFrameGrid.addWidget(self.canvas, 1)
self.topSplitter.addWidget(self.canvasFrame)
self.topSplitter.addWidget(self.controlPanel)
self.topSplitter.setSizes([800, 400])
self.topSplitter.setStretchFactor(0, 1)
self.topSplitter.setStretchFactor(1, 1)
self.topSplitter.setCollapsible(0, False)
self.topSplitter.setCollapsible(1, False)
self.mainSplitter.addWidget(self.topSplitter)
self.mainSplitter.addWidget(self.statusBar)
self.mainSplitter.setSizes([800, 100])
self.mainSplitter.setStretchFactor(0, 1)
self.mainSplitter.setStretchFactor(1, 1)
self.mainSplitter.setCollapsible(0, False)
self.mainSplitter.setCollapsible(1, False)
self.setCentralWidget(self.mainSplitter)
def show_modified(self):
if hasattr(self, 'fdct_worker'):
Ct = self.fdct_worker.vect(self.curvelet_structure.structure)
self.image_modified = pilImage.fromarray(
self.fdct_worker.inv(Ct)).convert('L')
self.image_diff = pilImage.eval(
pilChops.difference(self.image, self.image_modified),
lambda x: x * self.difference_scale_factor_slider.value())
if not hasattr(self, 'canvas_modified'):
self.canvas_modified = canvas.Canvas(self, self.canvas_config)
self.canvas_diff = canvas.Canvas(self, self.canvas_config)
self.canvas_modified.set_photo(
self.image_worker.pilImg2qPixImg(self.image_modified))
self.canvas_diff.set_photo(
self.image_worker.pilImg2qPixImg(self.image_diff))
self.canvas.WHEEL_EVENT.connect(
self.canvas_modified.wheelEvent)
self.canvas.WHEEL_EVENT.connect(self.canvas_diff.wheelEvent)
self.canvas.verticalScrollBar().valueChanged.connect(
self.canvas_modified.verticalScrollBar().setValue)
self.canvas.horizontalScrollBar().valueChanged.connect(
self.canvas_modified.horizontalScrollBar().setValue)
self.canvas.verticalScrollBar().rangeChanged.connect(
self.canvas_modified.verticalScrollBar().setRange)
self.canvas.horizontalScrollBar().rangeChanged.connect(
self.canvas_modified.horizontalScrollBar().setRange)
self.canvas_modified.verticalScrollBar().valueChanged.connect(
self.canvas.verticalScrollBar().setValue)
self.canvas_modified.horizontalScrollBar(
).valueChanged.connect(
self.canvas.horizontalScrollBar().setValue)
self.canvas_modified.verticalScrollBar().rangeChanged.connect(
self.canvas.verticalScrollBar().setRange)
self.canvas_modified.horizontalScrollBar(
).rangeChanged.connect(
self.canvas.horizontalScrollBar().setRange)
self.canvas.verticalScrollBar().valueChanged.connect(
self.canvas_diff.verticalScrollBar().setValue)
self.canvas.horizontalScrollBar().valueChanged.connect(
self.canvas_diff.horizontalScrollBar().setValue)
self.canvas.verticalScrollBar().rangeChanged.connect(
self.canvas_diff.verticalScrollBar().setRange)
self.canvas.horizontalScrollBar().rangeChanged.connect(
self.canvas_diff.horizontalScrollBar().setRange)
self.canvas_diff.verticalScrollBar().valueChanged.connect(
self.canvas.verticalScrollBar().setValue)
self.canvas_diff.horizontalScrollBar().valueChanged.connect(
self.canvas.horizontalScrollBar().setValue)
self.canvas_diff.verticalScrollBar().rangeChanged.connect(
self.canvas.verticalScrollBar().setRange)
self.canvas_diff.horizontalScrollBar().rangeChanged.connect(
self.canvas.horizontalScrollBar().setRange)
self.canvas_modified.WHEEL_EVENT.connect(
self.canvas.wheelEvent)
self.canvas_modified.WHEEL_EVENT.connect(
self.canvas_diff.wheelEvent)
self.canvas_diff.WHEEL_EVENT.connect(self.canvas.wheelEvent)
self.canvas_diff.WHEEL_EVENT.connect(
self.canvas_modified.wheelEvent)
self.canvasFrameGrid.addWidget(self.canvas_modified, 1)
self.canvasFrameGrid.addWidget(self.canvas_diff, 1)
self.canvas.fit_canvas()
self.canvas_modified.fit_canvas()
self.canvas_diff.fit_canvas()
self.update_log('[SUCCESS] Modified image showed!')
else:
self.canvas_modified.set_photo(
self.image_worker.pilImg2qPixImg(self.image_modified))
self.canvas_diff.set_photo(
self.image_worker.pilImg2qPixImg(self.image_diff))
self.update_log('[SUCCESS] Modified image updated!')
self.show_modified_image_button.setEnabled(False)
else:
self.update_log(
'[ERROR] Please load the curvelet transform first!')
import canvas
if (1 == 0):
cv = canvas.Canvas()
cv.printme()
if (1 == 0):
cv = canvas.Canvas()
cv.draw_hlne(1, 0, 1, 1)
cv.printme()
# def draw_triangle(self, x_top, y_top, height, y0, y1, value = 1)
if (0 == 1):
cv = canvas.Canvas()
cv.draw_triangle(x_top=0, y_top=0, height=5, y0=0, y1=5, value=1)
cv.printme()
# def draw_triangle(self, x_top, y_top, height, y0, y1, value = 1)
if (0 == 1):
cv = canvas.Canvas()
cv.draw_triangle(x_top=0, y_top=5, height=5, y0=0, y1=5, value=1)
cv.draw_triangle(x_top=0, y_top=0, height=5, y0=0, y1=5, value=1)
cv.printme()
# def draw_triangle(self, x_top, y_top, height, y0, y1, value = 1)
if (1 == 0):
cv = canvas.Canvas()
cv.draw_rectangle(x_top=0, y_top=0, height=5, width=2)
cv.printme()
# def draw_triangle(self, x_top, y_top, height, y0, y1, value = 1)
pygame.display.set_caption('Shoe generator')
clock = pygame.time.Clock()
pygame.init()
gameDisplay = pygame.display.set_mode((1250, 600),
pygame.DOUBLEBUF) # Create display
controller = events.EventManager()
cGAN = network.CGAN().cuda()
# Load cGAN parameters
checkpoint = torch.load(constants.NETWORK_FILE_NAME)
cGAN.generator.load_state_dict(checkpoint['g_state_dict'])
cGAN.discriminator.load_state_dict(checkpoint['d_state_dict'])
draw_canvas = canvas.Canvas(512, 20, 44, gameDisplay, evManager=controller)
render_canvas = canvas.Preview(512,
1250 - 20 - 512,
44,
gameDisplay,
draw_canvas,
cGAN,
evManager=controller)
# Define input box here so python doesnt immediatly put it in garbage after creating it
input_box = False
def input_func():
global input_box
input_box = gui.InputBox(625 - 240,
def main():
"""
Conway's Game of Life.
"""
(width, height) = (800, 600)
cell_size = 16
fps = 60
update_rate = 500
update_event_id = 24
animation = True
starting_cells = 1000
try:
f = open("init.txt", 'r')
for line in f:
param = line.split("=")
if param[0] == "width":
width = int(param[1])
elif param[0] == "height":
height = int(param[1])
elif param[0] == "cellsize":
cell_size = int(param[1])
elif param[0] == "fps":
fps = int(param[1])
elif param[0] == "updaterate":
update_rate = int(param[1])
elif param[0] == "startingcells":
starting_cells = int(param[1])
except:
f = open("init.txt", "w")
f.write(
"width=800\n" +
"height=600\n" +
"cellsize=16\n" +
"fps=60\n" +
"updaterate=500\n" +
"startingcells=1000\n"
)
grid_size = (width/cell_size, height/cell_size)
grid = g.Grid(grid_size)
canvas = c.Canvas((width, height), cell_size, grid_size)
events = e.GameEvent(update_event_id, fps, update_rate, grid, canvas)
message = "none"
params = []
pause = False
grid.randomize_cells(starting_cells)
pygame.init()
# main game loop
while message != "quit":
message, params = events.run()
if message == "update grid" and not pause:
grid.update_cells()
elif message == "pause":
pause = True
elif message == "resume":
pause = False
elif message == "place cell":
grid.add_cell(*params)
elif message == "remove cell":
grid.remove_cell(*params)
else:
pass
canvas.draw_grid(grid, *params)
# Preliminary Declarations
import os
import random
import player
import canvas
import secretboss
from mrsun import Mr_Sun
from painting import Painting
player = player.Player("")
canvas = canvas.Canvas()
secret_boss = secretboss.Secret_Boss()
al = Mr_Sun()
painting = Painting()
min_roll = 1
max_roll = 6
roll_it = False
enable_secret = False
# Game Begins
al.cool_face()
print("""
> Howdy there! I'm the sun, but my friends call me Al, and you can too.
> Welcome to Paint Attack!
> You're a just humble artist who recently has been struck with a bad case of artist's block.
> But today's the day you finally fight back and create another masterpiece.
> The object of the game is to work on your piece (i.e. fight your canvas) until it's completed.
""")
player_name = raw_input("> Soooooooo... what's your name? ")
logger = logging.getLogger(__name__)
logging.getLogger().addHandler(logging.StreamHandler())
def read_canvas_api_key():
with open('canvas-api-key.txt', 'r') as api_key_file:
api_key = api_key_file.readline().strip()
return api_key
def read_telegram_api_key():
with open('telegram-api-key.txt', 'r') as api_key_file:
api_key = api_key_file.readline().strip()
return api_key
sub_manager = subscribermanager.SubscriberManager('subscribers.txt')
announcement_reader = canvas.Canvas(fhict_canvas_url, read_canvas_api_key())
class MLStripper(HTMLParser):
def __init__(self):
self.reset()
self.strict = False
self.convert_charrefs= True
self.fed = []
def handle_data(self, d):
self.fed.append(d)
def get_data(self):
return ''.join(self.fed)
def strip_tags(html):
s = MLStripper()
s.feed(html)
'-r',
'24', # frames per second
'-i',
'-', # The imput comes from a pipe
'-an', # Tells FFMPEG not to expect any audio
'-vcodec',
'mpeg4',
'my_output_videofile.mp4'
]
pipe = sp.Popen(command, stdin=sp.PIPE, stderr=sp.PIPE)
# fourcc = VideoWriter_fourcc(*'mp4v')
# video = VideoWriter('./triangle.mp4', fourcc, float(FPS), (width, height))
my_canvas = canvas.Canvas(width, height)
vertices = np.array([[200, 200], [300, 300], [400, 200], [200, 200]])
my_triangle = polygon.Polygon(vertices)
for frameNum in range(0, FPS * seconds):
# blank canvas to redraw the triangle in its new state
my_canvas.image = np.array(my_canvas.background)
# draw the triangle
my_canvas.draw(my_triangle)
image = my_canvas.image
# transform the triangle object
if frameNum < FPS * seconds / 3:
my_triangle.translate(np.array([2, 2]))
def bmp(request, comp=False):
event, event1 = calcGet(request.GET, comp)
response = HttpResponse(mimetype='image/bmp')
p = canvas.Canvas(response)
mx, my = 0, 0
p.translate(375, 375)
R = 360
p.pen = p.pens[1.5]
p.setStrokeColorRGB(1, 0, 0)
#p.setLineWidth(0.5)
p.circle(mx, my, R)
p.setStrokeColorRGB(0, 0, 0)
p.circle(mx, my, 1.01 * R)
p.circle(mx, my, 0.15 * R)
p.circle(mx, my, 0.85 * R)
p.circle(mx, my, 0.7 * R)
for b in bhavas:
i = int(((event[b] - event["I"]) / 3600 + 450) % 360)
p.rotate(i)
p.line(0.15 * R, 0, 0.7 * R, 0)
p.rotate(-i)
h = 35
tp = 820
bits = open("astro/chart/words.bmp", 'rb').read()
rashiw = [
canvas.readBits(bits, 0, tp - (y + 1) * h, 120, tp - y * h)
for y in range(12)
]
h = 26.5
tp = 400
grahaw = [
canvas.readBits(bits, 0, tp - (y + 1) * h, 80, tp - y * h)
for y in range(12)
]
tp = 815
h = 24
nktw = [
canvas.readBits(bits, 130, tp - (y + 1) * h, 300, tp - y * h)
for y in range(27)
]
for a in range(0, 360, 30):
i = a + 90 - event["I"] / 3600
call(p, [
("rotate", (i, )),
("line", (
0.7 * R,
0,
0.85 * R,
0,
)),
("rotate", (15, )),
('translate', (0.75 * R, 0)),
[('rotate', (90 * ifDownHalf(i + 15), )),
('addPoints', (rashiw[a / 30], ))],
])
for a in range(108):
i = a * 10.0 / 3 + 90 - event["I"] / 3600
call(p, [
("rotate", (i, )),
("line", (
0.85 * R,
0,
(0.9 + (a % 4 == 0 and 0.1)) * R,
0,
)),
])
if not a % 4 == 0:
continue
call(p, [
("rotate", (i + 20.0 / 3, )),
('translate', (0.95 * R + 3 * ifDownHalf(i + 20.0 / 3), 0)),
[('rotate', (90 * ifDownHalf(i), )),
('addPoints', (nktw[a / 4], ))],
])
p.setStrokeColorRGB(0, 0, 1)
p.pen = p.pens[3]
for ndx, plnt in enumerate(wheel.planets):
i = (event[plnt] - event["I"]) / 3600 + 90
call(
p,
[
("rotate", (i, )),
("line", (
0.8 * R,
0,
0.85 * R,
0,
)),
('translate', (0.65 * R, 0)), #+ 3 * ifDownHalf(i)
("rotate", (-i, )),
('addPoints', (grahaw[ndx], )),
])
if comp:
p.setStrokeColorRGB(1, 0, 0)
p.pen = p.pens[3]
for ndx, plnt in enumerate(wheel.planets):
i = (event1[plnt] - event["I"]) / 3600 + 90
call(
p,
[
("rotate", (i, )),
("line", (
0.8 * R,
0,
0.85 * R,
0,
)),
('translate', (0.65 * R, 0)), #+ 3 * ifDownHalf(i)
("rotate", (-i, )),
('addPoints', (grahaw[ndx], )),
])
p.pen = p.pens[2]
if 'orb' in event:
orb = eval(event['orb'])
else:
orb = seiyo_trans if comp else seiyo
f = orb.getAspectColor
#f=seiyo.getAspectColor
for p1 in range(len(sinhala_planets_short)):
for p2 in range(p1 + 1, len(sinhala_planets_short)):
ps = sinhala_planets_short.keys()[p1], sinhala_planets_short.keys(
)[p2]
a = abs(event[ps[0]] - event1[ps[1]]) / 3600.00
clr = f(ps[0], ps[1], a)
if len(clr):
CC = getattr(colors, clr)
p.setStrokeColorRGB(*CC.rgb())
pp = polar2xy(0.6 * R, (event[ps[0]]-event["I"])/3600+90), \
polar2xy(0.6 * R, (event1[ps[1]]-event["I"])/3600+90)
p.line(pp[0][0], pp[0][1], pp[1][0], pp[1][1])
p.save()
return response
def circlechart(request, key=None):
event = calc(key) if key else calcGet(request.GET)
response = HttpResponse(mimetype='application/pdf')
response[
'Content-Disposition'] = 'attachment; filename=Horoscope.pdf' #%re.sub(r'\s',"_",event['name']))#.encode('utf-8','ignore')
p = canvas.Canvas(response) #MyCanvas(response)#
mx, my = 0, 0
p.translate(298, 600)
R = 200
p.setStrokeColorRGB(1, 0, 0)
p.setLineWidth(0.5)
p.circle(mx, my, R)
p.setStrokeColorRGB(0, 0, 0)
p.circle(mx, my, 1.01 * R)
p.circle(mx, my, 0.15 * R)
p.circle(mx, my, 0.85 * R)
p.circle(mx, my, 0.7 * R)
pdfmetrics.registerFont(
TTFont('kaputa', r"astro/chart/kaputa.ttf")
) #r'D:\kendra-python\workspace\mysitedjando_101226\mysite\astro\chart\kaputa.ttf'))
p.setFont('kaputa', 12)
for b in bhavas:
i = int(((event[b] - event["I"]) / 3600 + 450) % 360)
p.rotate(i)
p.line(0.15 * R, 0, 0.7 * R, 0)
p.rotate(-i)
for a in range(0, 360, 30):
i = a + 90 - event["I"] / 3600
call(p, [
("rotate", (i, )),
("line", (
0.7 * R,
0,
0.85 * R,
0,
)),
("rotate", (15, )),
('translate', (0.775 * R + 3 * ifDownHalf(i + 15), 0)),
[('rotate', (90 * ifDownHalf(i + 15), )),
('drawCentredString', (0, 0, getKaputa(sinhala_rashis[a / 30])))],
])
for a in range(108):
i = a * 10.0 / 3 + 90 - event["I"] / 3600
call(p, [
("rotate", (i, )),
("line", (
0.85 * R,
0,
(0.9 + (a % 4 == 0 and 0.1)) * R,
0,
)),
])
if not a % 4 == 0:
continue
call(p, [
("rotate", (i + 20.0 / 3, )),
('translate', (0.95 * R + 3 * ifDownHalf(i + 20.0 / 3), 0)),
[('rotate', (90 * ifDownHalf(i), )),
('drawCentredString',
(0, 0, getKaputa(sinhala_nakshatra_short[a / 4])))],
])
p.setStrokeColor(colors.blue)
p.setLineWidth(1)
for plnt in sinhala_planets_short:
i = (event[plnt] - event["I"]) / 3600 + 90
call(
p,
[
("rotate", (i, )),
("line", (
0.8 * R,
0,
0.85 * R,
0,
)),
#("rotate",(ifLeftHalf(i)*5,)),
('translate', (0.65 * R, 0)), #+ 3 * ifDownHalf(i)
("rotate", (-i, )),
(funcOn(i),
(0, funcOn(i) != "drawCentredString"
and -4, getKaputa(readUnicode(sinhala_planets_short[plnt]))))
])
p.setLineWidth(0.75)
for p1 in range(len(sinhala_planets_short)):
for p2 in range(p1 + 1, len(sinhala_planets_short)):
ps = sinhala_planets_short.keys()[p1], sinhala_planets_short.keys(
)[p2]
a = abs(event[ps[0]] - event[ps[1]]) / 3600.00
clr = seiyo.getAspectColor(ps[0], ps[1], a)
if len(clr):
p.setStrokeColor(getattr(colors, clr))
pp = map(
lambda ps: polar2xy(0.6 * R,
(event[ps] - event["I"]) / 3600 + 90),
ps)
p.line(pp[0][0], pp[0][1], pp[1][0], pp[1][1])
p.showPage()
p.save()
return response
