def build_number_box(self, group="timergroup"):
"""
Creates a single number drawing
:param group: Group to put drawing in
:return: Drawing number box ready to render
"""
c.add_drawing(self.canvas, width=90, height=150, parent=group)
def run(self):
"""
A very basic stand-aloen run method to show what this looks like by default
:return: General number display example
"""
window_args = dict(
autosize=False,
height=200,
width=200,
x_pos=0,
y_pos=0,
)
with s.window("Drawing", **window_args):
c.add_drawing(self.name, width=90, height=150)
with s.window(
"command##window",
autosize=True,
y_pos=200,
x_pos=0,
):
c.add_input_text(
name="command##input",
width=600,
height=300,
multiline=True,
on_enter=True,
callback=self.execute,
)
c.start_dearpygui()
def __init__(self):
core.set_style_item_spacing(1, 1)
core.set_style_window_padding(0, 0)
core.set_main_window_size(690, 450)
with simple.window("main"):
core.add_drawing("canvas")
core.set_resize_callback(self.__resize)
core.set_render_callback(self.__render)
def __init__(self):
with simple.window(self.windowName):
core.add_drawing(self.pictureName, width=1500, height=1500)
core.draw_image(self.pictureName,
self.picturePath,
pmin=[0, 0],
pmax=[700, 700])
core.set_resize_callback(callback=self.window_resize,
handler=self.windowName)
super().__init__()
def __init__(self):
core.set_main_window_size(720, 540)
self.__width = 17
self.__height = 7
self.__total = self.__width * self.__height
self.__board = {}
size = core.get_main_window_size()
self.__paddle = [size[0] * .475, size[1] * .85]
self.__paddleSize = (80, 8)
# x, y, angle (rads), speed
self.__radius = 6
self.__speed = 300
self.__paddleSpeed = 1000
self.__speedMax = self.__speed * 3
self.__pos = (size[0] * .5, size[1] * .8, 0, -self.__speed)
with simple.window("main"):
with simple.group("scoreboard"):
core.add_label_text("score")
core.add_same_line()
core.add_text("score-value")
# core.add_same_line()
core.add_label_text("time")
core.add_same_line()
core.add_text("time-value")
core.add_drawing("canvas", width=size[0], height=size[1])
core.draw_circle("canvas",
size,
self.__radius, (255, 255, 255, 255),
fill=(128, 128, 128, 255),
tag="ball")
core.draw_rectangle("canvas", [
self.__paddle[0] - self.__paddleSize[0],
self.__paddle[1] - self.__paddleSize[1]
], [
self.__paddle[0] + self.__paddleSize[0],
self.__paddle[1] + self.__paddleSize[1]
], (255, 255, 255, 255),
fill=(128, 128, 128, 255),
tag="paddle")
core.set_resize_callback(self.__resize)
core.set_render_callback(self.__render)
core.set_key_down_callback(self.__keydown)
core.set_mouse_wheel_callback(self.__mousewheel)
def __init__(self):
core.set_vsync(False)
core.set_style_frame_padding(0, 0)
self.__width = 60
self.__height = 40
self.__fire = [0] * (self.__height * self.__width)
with simple.window("Controls", width=220, no_resize=True):
core.add_slider_int("Width", width=150, default_value=self.__width, min_value=5, max_value=80, clamped=True)
core.add_slider_int("Height", width=150, default_value=self.__height, min_value=5, max_value=50, clamped=True)
with simple.window("MainWindow"):
core.add_drawing("Canvas", width=1920, height=1080)
color = (0, 0, 0, 255)
for i in range(self.__width, self.__width * self.__height):
core.draw_quad("Canvas", (0, 0), (0, 0), (0, 0), (0, 0), color, thickness=0, tag=f"quad-{i}")
core.set_render_callback(self.__render)
def _draw_duplicates_set(self, duplicate_images_list: FileMetaDataList) -> None:
""" Draw a single image and all the files containing it.
All the files in duplicate_images_list containg duplicate of same image.
"""
try:
file_path = duplicate_images_list[0].GetPath()
core.add_drawing(
file_path,
width=100,
height=100,
parent=self._window_name)
core.draw_image(
file_path,
file_path,
[0, 0],
pmax=[100, 100],
uv_min=[0, 0],
uv_max=[1, 1],
tag="image")
for file in duplicate_images_list:
file_path = file.GetPath()
core.add_button(
'Delete ##'+file_path,
callback=self._delete_file_button_click_handler,
callback_data=file,
parent=self._window_name)
core.add_same_line(parent=self._window_name)
core.add_text(
file_path,
parent=self._window_name)
core.add_separator(parent=self._window_name)
except Exception as e:
core.log_error('View::_draw_duplicates_set - Exception : [%s]' % (e))
def camera_frame_control():
global thread_floaty
global running
if not thread_floaty:
dpg.log_debug("start")
thread_floaty = threading.Thread(target=produce_frame, args=())
thread_floaty.setDaemon(True)
thread_floaty.start()
print(id(thread_floaty))
else:
print(id(thread_floaty))
running=False
thread_floaty.join()
dpg.log_debug("stop")
thread_floaty = None
with sdpg.window():
dpg.add_drawing('drawing', width=1000, height=800)
dpg.add_text("tooltipTest")
def construct(self):
self.adjust_coordinate_to_center_tile()
with simple.group(self.name, parent=self.parent):
core.add_drawing("canvas",
width=self.map_size[0],
height=self.map_size[1])
core.add_texture(
"geomap",
self.stored_map,
256 * self.tile_radius,
256 * self.tile_radius,
)
if self.cached == False:
# Only use if necessary so that the OSM tile servers are not overloaded.
self.async_update_by_coordinate(self.latitude, self.longitude,
self.zoom)
else:
self.refresh()
def __init__(self, new_scan_click_callback: callable):
self._window_name: str = 'Hello Screen'
self._new_scan_click_callback: callable = new_scan_click_callback
main_window_size = core.get_main_window_size()
self._window_x_pos: int = int(main_window_size[0] / 2) - 200
self._window_y_pos: int = int(main_window_size[1] / 2) - 100
self._logo_full_path = get_resource_full_path('resources/logo.png')
with simple.window(self._window_name):
core.configure_item(self._window_name,
width=300,
height=250,
x_pos=self._window_x_pos,
y_pos=self._window_y_pos,
label='Welcome!')
core.add_text('Welcome to Duplicate Image Finder!')
core.add_text('Version: ' + get_version())
core.add_drawing(name='hello_screen_logo', width=100, height=100)
core.draw_image(drawing='hello_screen_logo',
file=self._logo_full_path,
pmin=[0, 0],
pmax=[100, 100],
uv_min=[0, 0],
uv_max=[1, 1],
tag="image")
core.add_button(name='start_new_scan_button',
label='Start New Scan',
callback=self._internal_new_scan_click_callback)
core.add_button(name='visit_source_page_button',
label='Visit Github source page',
callback=self._visit_source_page_click_callback)
def example_two():
"""
Commands to put into input
"""
with s.window("Hello World", autosize=True):
c.add_text("Hello world!")
c.show_logger()
c.log_info("Foo")
c.log_info("Check it out ma - no IDE!")
with s.window("Canvas", x_pos=0, y_pos=300, autosize=True):
c.add_drawing("Draw", width=300, height=300)
c.draw_circle(
"Draw",
center=[150, 150],
radius=50,
color=[125, 125, 125],
fill=[125, 125, 200],
)
def start():
"""
Renders main window elements.
"""
with open('token.txt', 'r') as token_file:
token = token_file.readline()
try:
# Connect to IBM
core.run_async_function(get_backends_async, data=token)
core.set_render_callback(show_button)
# Progress bar
with simple.window('Please wait',
no_scrollbar=True,
height=70,
width=400,
x_pos=500,
y_pos=200):
core.add_progress_bar('progress',
value=0.0,
overlay='Connecting to IBM...',
width=400)
core.run_async_function(progress_async, 0)
# Menu bar
with simple.menu_bar("Main Menu Bar"):
with simple.menu("File"):
core.add_menu_item("Save", callback=print_me)
core.add_menu_item("Save As", callback=print_me)
core.add_menu_item("Help", callback=open_help_window)
core.add_menu_item("About", callback=open_about_window)
# Parameters group
with simple.group('left group', width=350):
# Select file button
core.add_child('##file_block',
width=350,
height=180,
show=False)
core.add_button('File Selector', callback=file_picker)
core.add_spacing(name='##space2', count=3)
core.add_text('File location:')
core.add_label_text('##filedir',
value='None Selected',
source='directory')
core.add_spacing(name='##space3', count=3)
core.add_text('File name:')
core.add_label_text('##file',
value='None Selected',
source='file_directory')
core.end()
core.add_spacing(name='##space4', count=3)
# Architecture type radio button
core.add_child('##settings_block',
width=350,
height=450,
show=False)
core.add_text('Architecture type:')
core.add_radio_button('radio##1',
items=[
'IBM simulator',
'IBM quantum computer',
'Arbitrary computer coupling'
],
callback=show_architecture_list,
source='device_type')
core.add_spacing(name='##space5', count=3)
# "Create arbitrary coupling" button
core.add_button('Create custom architecture',
callback=create_architecture,
show=False)
core.add_spacing(name='##space11', count=3)
# Layout radio button
core.add_text('Quantum circuit layout method:')
core.add_radio_button(
'radio##2',
items=['Original IBM layout', 'Advanced SWAP placement'],
source='layout_type')
core.add_spacing(name='##space6', count=3)
# Optimization level slider
core.add_text('Optimization level:')
core.add_slider_int(
'##optimization_lvl',
default_value=1,
min_value=0,
max_value=3,
tip='drag the slider to select an optimization level',
width=300,
source='opt_level')
core.add_spacing(name='##space7', count=3)
# Number of iterations slider
core.add_text('Number of iterations:')
core.add_input_int('##num_of_iter',
width=300,
callback=check_iteration_num,
default_value=100)
core.add_spacing(name='##space8', count=3)
# Default settings button
core.add_button('Set Default', callback=set_default)
core.end()
core.add_spacing(name='##space9', count=3)
# Process button
core.add_button('Process', callback=process, show=False)
# graph images
core.add_same_line(name='line##3', xoffset=370)
with simple.group('center group'):
core.add_child('##images_block', width=640, show=False)
# Input circuit preview
core.add_text('Input circuit:')
core.add_drawing('input_circuit', width=600, height=500)
core.draw_rectangle('input_circuit', [0, 150], [600, 500],
[255, 255, 255, 0], [255, 255, 255, 50])
# Output circuit view
core.add_text('Output circuit:')
core.add_drawing('output_circuit', width=600, height=500)
core.draw_rectangle('output_circuit', [0, 150], [600, 500],
[255, 255, 255, 0], [255, 255, 255, 50])
core.end()
# program output
core.add_same_line(name='line##3', xoffset=1020)
with simple.group('right group'):
core.add_child('##output_block1',
width=460,
height=300,
show=False)
core.add_button('Open qasm file', callback=open_qasm)
core.add_text('Path to IBM circuit representation')
core.add_label_text('##circuitImage')
core.add_button('Mapping', callback=show_mapping)
core.end()
core.add_text('Program output:', show=False)
core.add_child('##output_block2',
width=460,
height=180,
show=False)
core.add_text('Program output will be displayed here',
wrap=440)
core.end()
except Exception as exc:
print("[ERROR]: {}".format(exc))
def draw_graph(architecture, mapping, diameter=20):
"""
Draws a physical architecture and labels mapped nodes.
Parameters:
architecture (str): Architecture type.
mapping (dict): Mapping from circuit graph to pysical architecture.
diameter (float): Diameter of the graph nodes. Also determines the size of resulting graph.
Returns:
None
"""
with simple.window('Graph',
width=800,
height=800,
on_close=delete_items(['Graph'])):
core.add_drawing('drawing1',
width=int(diameter * diameter * 2),
height=int((diameter / 2)**2))
start_x = diameter
start_y = diameter * 4
color_white = [255, 255, 255, 255]
color_black = [0, 0, 0, 255]
color_orange = [255, 170, 23, 255]
color_blue = [15, 27, 115, 255]
line_width = 5
num_of_nodes = {
architecture == 'ibmq_armonk':
1,
architecture == 'ibmq_athens' or architecture == 'ibmq_santiago' or architecture == 'ibmqx2' or architecture == 'ibmq_vigo' or architecture == 'ibmq_valencia' or architecture == 'ibmq_ourence':
5,
architecture == 'ibmq_16_melbourne':
15
}[True]
###
if architecture == 'ibmq_armonk':
# draw one node
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[0],
color=color_black,
size=diameter)
###
elif architecture == 'ibmq_athens' or architecture == 'ibmq_santiago':
for k in range(num_of_nodes):
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
# draw an edge only if it is not the last node
if k < 4:
core.draw_line("drawing1", [start_x + diameter, start_y],
[start_x + (diameter * 2), start_y],
color_white, line_width)
start_x += diameter * 3
###
elif architecture == 'ibmq_vigo' or architecture == 'ibmq_valencia' or architecture == 'ibmq_ourence':
for k in range(num_of_nodes):
if k == 2:
# save previous coordinates
previous_x, previous_y = start_x, start_y
# adjust coordinates
start_x -= (diameter * 3)
start_y -= (diameter * 3)
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text(
'drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text(
'drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
core.draw_line("drawing1", [start_x, start_y + diameter],
[start_x, start_y + (diameter * 2)],
color_white, line_width)
# restore coordinates
start_x, start_y = previous_x, previous_y
else:
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text(
'drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text(
'drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
# draw an edge only if it is not the last node
if k < 4:
core.draw_line("drawing1", [start_x + diameter, start_y],
[start_x + (diameter * 2), start_y],
color_white, line_width)
start_x += diameter * 3
###
elif architecture == 'ibmqx2':
k = 0
start_y = diameter
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
core.draw_line("drawing1", [start_x, start_y + diameter],
[start_x, start_y + (diameter * 2)], color_white,
line_width)
k += 1
start_y += diameter * 3
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
k += 1
start_x += diameter * 3
start_y -= diameter * 1.5
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
core.draw_line(
"drawing1",
[start_x + (diameter / 2) + 5, start_y - (diameter / 2) - 5],
[start_x + (diameter * 2), start_y - (diameter * 1.5)],
color_white, line_width)
core.draw_line(
"drawing1",
[start_x + (diameter / 2) + 5, start_y + (diameter / 2) + 5],
[start_x + (diameter * 2), start_y + (diameter * 1.5)],
color_white, line_width)
core.draw_line(
"drawing1",
[start_x - (diameter / 2) - 5, start_y - (diameter / 2) - 5],
[start_x - (diameter * 2), start_y - (diameter * 1.5)],
color_white, line_width)
core.draw_line(
"drawing1",
[start_x - (diameter / 2) - 5, start_y + (diameter / 2) + 5],
[start_x - (diameter * 2), start_y + (diameter * 1.5)],
color_white, line_width)
k += 1
start_x += diameter * 3
start_y += diameter * 1.5
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
k += 1
start_y -= diameter * 3
if k in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[k],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(k),
color=color_blue,
size=diameter)
core.draw_line("drawing1", [start_x, start_y + diameter],
[start_x, start_y + (diameter * 2)], color_white,
line_width)
###
elif architecture == 'ibmq_16_melbourne':
start_y = diameter
for k in range(num_of_nodes):
temp_key = num_of_nodes - (k + 1)
if temp_key in mapping.keys():
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_orange,
fill=color_orange)
temp_key = num_of_nodes - (k + 1)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
mapping[temp_key],
color=color_black,
size=diameter)
else:
core.draw_circle('drawing1', [start_x, start_y],
diameter,
color_white,
fill=color_white)
core.draw_text('drawing1',
[start_x - diameter, start_y + (diameter / 2)],
str(temp_key),
color=color_blue,
size=diameter)
if k != 7 and k != 8:
core.draw_line("drawing1", [start_x + diameter, start_y],
[start_x + (diameter * 2), start_y],
color_white, line_width)
if (k < 7):
core.draw_line("drawing1", [start_x, start_y + diameter],
[start_x, start_y + (diameter * 2)],
color_white, line_width)
start_x += diameter * 3
else:
start_x -= diameter * 3
if (k == 7):
start_y += diameter * 3
def open_help_window(sender, data):
"""
Opens new window with help annotations
"""
with simple.window('Help##window',
width=1000,
height=600,
on_close=delete_items(['Help##window'])):
with simple.tab_bar("Help tabs"):
with simple.tab('Architectures##help'):
core.add_drawing('armonk', width=72, height=75)
core.draw_image('armonk', './backends/armonk.png', [72, 72])
core.add_text('ibmq_armonk: 1 qubit.')
core.add_spacing(name='##space10', count=10)
core.add_drawing('athens', width=518, height=75)
core.draw_image('athens', './backends/athens-santiago.png',
[0, 72])
core.add_text('ibmq_athens and ibmq_santiago: 5 qubits.')
core.add_spacing(name='##space12', count=10)
core.add_drawing('yorktown', width=373, height=400)
core.draw_image('yorktown', './backends/ibmqx2.png', [0, 400])
core.add_text('ibmqx2: 5 qubits.')
core.add_spacing(name='##space13', count=10)
core.add_drawing('melb', width=1000, height=196)
core.draw_image('melb', './backends/melbourne.png', [0, 196])
core.add_text('ibmq_16_melbourne: 15 qubits.')
core.add_spacing(name='##space14', count=10)
with simple.tab('Instructions##help'):
core.add_text(
'1. In the Selector block a user can select optimization parameters:'
)
core.add_spacing(name='##text_spacing1', count=5)
core.add_text(
'* the level of optimization provided by IBM Q (ranging from 0 to 3)'
)
core.add_text(
'* IBM Original layout or advanced SWAP placement')
core.add_text('* location of placement')
core.add_text('* number of iterations.')
core.add_spacing(name='##text_spacing2', count=5)
core.add_text(
'2. In the Hardware & Circuit block choose between testing the circuit on a quantum computer (IBM Q) and simulator (Qasm).',
wrap=900)
core.add_spacing(name='##text_spacing3', count=5)
core.add_text(
'3. Choose quantum coupling (quantum computer architecture) - IBM Q or Qasm.',
wrap=900)
core.add_spacing(name='##text_spacing4', count=5)
core.add_text(
'4. Upload an input file. After selection, the file name will be displayed in the Hardware & Circuit block and the circuit representation will be displayed in the Circuit before the reduction block.',
wrap=900)
core.add_spacing(name='##text_spacing5', count=5)
core.add_text(
'5. When pressing on the Process button the tool will find the optimal mapping of the circuit onto the quantum computer architecture.',
wrap=900)
core.add_spacing(name='##text_spacing6', count=5)
core.add_text(
'6. The resulting mapping will appear in the Circuit after the reduction block.',
wrap=900)
def __init__(self):
self.__last = -1
self.__targetFPS = 30
# playhead position
self.__head = 0.
# playback stopped
self.__direction = 0.
# looping on
self.__loop = True
# thread that is "streaming" the video
self.__thread = None
self.__frameCount = self.__width = self.__height = 0
self.__root = path.dirname(path.realpath(__file__))
core.set_style_item_spacing(1, 1)
core.set_style_frame_padding(0, 0)
core.get_style_window_padding(0, 0)
width = 740
height = 680
core.set_main_window_size(width, height)
with simple.window("MainWindow"):
core.add_drawing("Canvas", width=width, height=height)
w = 50
h = 20
with simple.window("Media Bar",
autosize=True,
no_collapse=True,
no_close=True,
no_scrollbar=True):
with simple.group("Browser"):
core.add_listbox("Listing",
label='',
items=[],
callback=self.__itemChange)
with simple.group("Shuttle"):
core.add_button("Shuttle#Browse",
width=w,
height=h,
label="...",
callback=lambda: core.select_directory_dialog(
callback=self.__browser))
core.add_button("Shuttle#Front",
width=w,
height=h,
label='|<',
callback=lambda: self.__seek(0))
core.add_same_line()
core.add_button("Shuttle#Backwards",
width=w,
height=h,
label='<-',
callback=lambda: self.__play(-1))
core.add_same_line()
core.add_button("Shuttle#Forwards",
width=w,
height=h,
label='->',
callback=lambda: self.__play(1))
core.add_same_line()
core.add_button("Shuttle#End",
width=w,
height=h,
label='>|',
callback=lambda: self.__seek(-1))
core.add_same_line()
core.add_color_button("Shuttle#Loop", [50, 50, 227, 255],
width=w,
height=h,
callback=self.__loopToggle)
core.add_same_line()
core.add_text("ShuttleFPS")
core.add_drag_float("MediabarHead",
label="",
width=w * 5 + 5,
callback=self.__cbSeek)
core.set_render_callback(self.__render)
core.set_mouse_wheel_callback(self.__mouseWheel)
core.set_exit_callback(self.__close)
self.__scanDir()
def main():
empty_board = [['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E']]
initial_board = [['Tn','Cn','An','Dn','Rn','An','Cn','Tn'],
['Pn','Pn','Pn','Pn','Pn','Pn','Pn','Pn'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['_E','_E','_E','_E','_E','_E','_E','_E'],
['Pb','Pb','Pb','Pb','Pb','Pb','Pb','Pb'],
['Tb','Cb','Ab','Db','Rb','Ab','Cb','Tb']]
def mouse_click_callback(sender,data):
nonlocal c_board
if data == 0 and c_board.current_selection != -1:
m_position = dpg.get_mouse_pos()
position = c_board.get_board_position(m_position)
if not position:
return
if c_board.current_selection == 0:
c_board.change_box('P', position) # put peon
elif c_board.current_selection == 1:
c_board.change_box('T', position) # put toker
elif c_board.current_selection == 2:
c_board.change_box('C', position) # put horse
elif c_board.current_selection == 3:
c_board.change_box('A', position) # put bishop
elif c_board.current_selection == 4:
c_board.change_box('D', position) # put queen
elif c_board.current_selection == 5:
c_board.change_box('R', position) # put king
elif c_board.current_selection == 6:
c_board.change_box(None,position) # remove
elif c_board.current_selection == 7:
# draw arrow
size = c_board.piece_size
c = size//2
position = (position[0]*size+c,position[1]*size+c)
if c_board.step == 0:
c_board.lines.append([(),(),''])
c_board.lines[-1][0] = position
elif c_board.step == 1:
c_board.lines[-1][1] = position
color = dpg.get_value('drawing_color')
r = int(color[0])
g = int(color[1])
b = int(color[2])
color = 'rgb({},{},{})'.format(r,g,b)
c_board.lines[-1][2] = color
c_board.step = (c_board.step+1)%2
if c_board.step == 1:
return
elif c_board.current_selection == 8:
# delete arrow
size = c_board.piece_size
c = size//2
position = (position[0]*size+c,position[1]*size+c)
for i in range(len(c_board.lines)):
line = c_board.lines[i]
if position == line[0] or position == line[1]:
c_board.lines.remove(line)
break
elif c_board.current_selection == 9:
# color box
color = dpg.get_value('drawing_color')
r = int(color[0])
g = int(color[1])
b = int(color[2])
color = 'rgb({},{},{})'.format(r,g,b)
col = position[0]
row = position[1]
c_board.colored_boxes[row][col] = color
elif c_board.current_selection == 10:
# discolor box
col = position[0]
row = position[1]
c_board.colored_boxes[row][col] = None
c_board.draw_board()
if data == 1:
if c_board.piece_color == 'b':
c_board.piece_color = 'n'
dpg.set_value('color_piece', "Negro")
else:
c_board.piece_color = 'b'
dpg.set_value('color_piece', "Blanco")
def key_press_callback(sender, data):
nonlocal c_board
if data == dpg.mvKey_Right:
if c_board.reading_pgn:
pars.current_match.next_position()
c_board.draw_board()
else:
return
if data == dpg.mvKey_Left:
if c_board.reading_pgn:
pars.current_match.previews_position()
c_board.draw_board()
else:
return
if data == dpg.mvKey_Escape :
c_board.current_selection = -1
c_board.reading_pgn = False
dpg.set_value("accion", "Sin seleccionar")
dpg.set_value("pieza", "Sin seleccionar")
return
def load_callback(sender, data):
def file_callback(sender, data):
nonlocal c_board
file = open(data[1],'rb')
load_board = pickle.load(file)
file.close()
c_board = load_board
c_board.draw_board()
dpg.open_file_dialog(callback=file_callback, extensions=".sv")
def save_callback(sender, data):
nonlocal c_board
c_board.save_board()
def save_image_callback(sender,data):
nonlocal c_board
c_board.save_board_image()
def clean_callback(sender, data):
nonlocal c_board
nonlocal empty_board
c_board.reading_pgn = False
c_board.board = copy.deepcopy(empty_board)
c_board.lines = []
c_board.colored_boxes = [[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None]]
c_board.draw_board()
def default_board_callback(sender, data):
nonlocal c_board
nonlocal initial_board
c_board.reading_pgn = False
c_board.board = copy.deepcopy(initial_board)
c_board.lines = []
c_board.colored_boxes = [[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None],
[None,None,None,None,None,None,None,None]]
c_board.draw_board()
def close(sender,data):
try:
os.remove("tmp.png")
except Exception as e:
pass
def pgn_reader(sender,data):
def load_match(sender,data):
nonlocal pars
nonlocal c_board
coords = dpg.get_table_selections(sender)
dpg.delete_item('Partidas')
dpg.delete_item('Lista de Partidas')
i = coords[0][0]
match = pars.matches[i]
pars.current_match = match
c_board.board = match.board
c_board.reading_pgn = True
dpg.set_value('accion','Leyendo partida PGN')
dpg.set_value('pieza','Sin seleccionar')
c_board.draw_board()
def close_callback(sender,data):
dpg.delete_item('Partidas')
dpg.delete_item('Lista de Partidas')
def file_callback(sender, data):
nonlocal c_board
nonlocal pars
pars = Parser()
pars.get_plays(data[0]+'/'+data[1])
# Lista de partidas cargadas--------------------------------TODO
dpg.add_window('Lista de Partidas',on_close=close_callback)
colums = set()
for match in pars.matches:
for att in match.attr:
colums.add(att)
colums = list(colums)
# colums.sort()
dpg.add_table("Partidas", colums, callback=load_match)
rows = list()
for match in pars.matches:
row = list()
for colum in colums:
row.append(match.attr[colum])
rows.append(row)
for row in rows:
dpg.add_row("Partidas", row)
dpg.end()
dpg.open_file_dialog(callback=file_callback, extensions=".pgn")
def control_button(sender,data):
nonlocal c_board;
c_board.reading_pgn = False
add_arr = c_board.current_selection == 7
if add_arr and c_board.step == 1:
c_board.lines.pop()
c_board.step = 0
if sender == 'Peon':
c_board.current_selection = 0
dpg.set_value("accion", "Añadiendo Pieza")
dpg.set_value("pieza", "Peon")
elif sender == 'Torre':
c_board.current_selection = 1
dpg.set_value("accion", "Añadiendo Pieza")
dpg.set_value("pieza", "Torre")
elif sender == 'Caballo':
c_board.current_selection = 2
dpg.set_value("accion", "Añadiendo Pieza")
dpg.set_value("pieza", "Caballo")
elif sender == 'Alfil':
c_board.current_selection = 3
dpg.set_value("accion", "Añadiendo Pieza")
dpg.set_value("pieza", "Alfil")
elif sender == 'Reina':
c_board.current_selection = 4
dpg.set_value("accion", "Añadiendo Pieza")
dpg.set_value("pieza", "Reina")
elif sender == 'Rey':
c_board.current_selection = 5
dpg.set_value("accion", "Añadiendo Pieza")
dpg.set_value("pieza", "Rey")
elif sender == 'Eliminar Pieza':
c_board.current_selection = 6
dpg.set_value("accion", "Eliminando Pieza")
dpg.set_value("pieza", "Sin seleccionar")
elif sender == 'Añadir flecha':
c_board.current_selection = 7
dpg.set_value("accion", "Añadiendo flecha")
dpg.set_value("pieza", "Sin seleccionar")
elif sender == 'Eliminar flecha':
c_board.current_selection = 8
dpg.set_value("accion", "Eliminando flecha")
dpg.set_value("pieza", "Sin seleccionar")
elif sender == 'Colorear casilla':
c_board.current_selection = 9
dpg.set_value("accion", "Coloreando casilla")
dpg.set_value("pieza", "Sin seleccionar")
elif sender == 'Descolorear casilla':
c_board.current_selection = 10
dpg.set_value("accion", "Descolorando casilla")
dpg.set_value("pieza", "Sin seleccionar")
c_board = Board(board = copy.deepcopy(empty_board))
pars = Parser()
main_width = c_board.size+220
main_height= c_board.size+240
with dpgs.window('Diagramador'):
dpg.set_main_window_size(main_width, main_height)
dpg.set_main_window_resizable(False)
dpg.set_exit_callback(close)
with menu_bar('Menu bar'):
with menu('Archivo'):
dpg.add_menu_item("Guardar", callback=save_callback)
dpg.add_menu_item("Guardar Imagen", callback=save_image_callback)
dpg.add_menu_item("Cargar tablero", callback=load_callback)
with menu('Herramientas'):
dpg.add_menu_item("Leer archivo PGN", callback=pgn_reader)
with menu('Color'):
dpg.add_color_edit3('Seleccion de Color',source='drawing_color')
dpg.add_drawing("canvas", width=c_board.size,height=c_board.size)
dpg.add_image('board_img','',source=c_board.piece_p('Abb'))
dpg.add_same_line()
controles =(
"\nControles\n"
"Click Derecho : Cambiar color de pieza\n\n"
"Flecha derecha: Mostrar siguiente jugada PGN\n\n"
"Flecha izquierda: Mostrar la jugada PGN previa\n\n"
)
dpg.add_child('controls',autosize_x=True,height=c_board.size)
dpg.add_button('Peon',callback=control_button)
dpg.add_button('Torre',callback=control_button)
dpg.add_button('Caballo',callback=control_button)
dpg.add_button('Alfil',callback=control_button)
dpg.add_button('Reina',callback=control_button)
dpg.add_button('Rey',callback=control_button)
dpg.add_button('Eliminar Pieza',callback=control_button)
dpg.add_button('Añadir flecha',callback=control_button)
dpg.add_button('Eliminar flecha',callback=control_button)
dpg.add_button('Colorear casilla',callback=control_button)
dpg.add_button('Descolorear casilla',callback=control_button)
dpg.add_text(controles)
dpg.end()
dpg.set_value('drawing_color',[0,0,0])
name = "Nombre de Archivo"
dpg.add_input_text(name, width=250, source='save_name')
name = "Nombre de Imagen"
dpg.add_input_text(name, width=250, source='save_img_name')
dpg.add_button("Limpiar tablero", callback=clean_callback)
name = "Tablero por defecto"
dpg.add_button(name, callback=default_board_callback)
name = "Acción"
dpg.add_label_text(name, default_value='Sin seleccionar', source="accion")
dpg.add_label_text("Pieza", default_value='Sin seleccionar', source="pieza")
dpg.add_label_text("Color de pieza", default_value='Blanco', source='color_piece')
c_board.draw_board()
dpg.set_key_press_callback(key_press_callback)
dpg.set_mouse_click_callback(mouse_click_callback)
dpg.start_dearpygui(primary_window = 'Diagramador')
def _setup_add_widget(self, dpg_args) -> None:
dpgcore.add_drawing(self.id, **dpg_args)
def __init__(self):
core.set_vsync(False)
core.set_style_window_padding(0, 0)
self.__iteration = 3
# load the data blob
root = path.dirname(path.realpath(__file__))
with open(f'{root}/fractal.json', 'r') as data:
self.__fractalData = OrderedDict(json.load(data))
self.__fractalKeys = [k for k in self.__fractalData.keys()]
d = self.__fractalKeys[0]
self.__fractal = Fractal(**self.__fractalData[d])
size = core.get_main_window_size()
with simple.window("MainWindow"):
with simple.group("Controls"):
core.add_input_int("Iteration",
width=120,
min_value=2,
max_value=40,
min_clamped=True,
max_clamped=True,
default_value=self.__iteration,
callback=self.__cbIterationValue)
simple.tooltip(
"Iteration",
"How many times to re-run the pattern parser with the \
previous runs output. Increasing this directly increases computation time."
)
with simple.group("Controls-Angle"):
core.add_input_float("Angle",
width=120,
default_value=self.__fractal.dAngle,
callback=self.__cbAngleValue)
simple.tooltip(
"Angle",
"Degrees the turtle will turn either positive or negative, when issued such commands."
)
core.add_same_line()
core.add_checkbox("AngleAnimate",
default_value=False,
label="Animate")
core.add_input_float("AngleStep",
width=120,
default_value=.002,
step=0.001,
step_fast=0.01)
simple.tooltip(
"AngleStep",
"Amount the animator will step through the angle.")
core.add_input_float("Length",
width=120,
default_value=self.__fractal.delta,
callback=self.__cbDeltaValue)
simple.tooltip(
"Length",
"Relative distance, forward or backward, the turtle will take when commanded."
)
core.add_same_line()
core.add_listbox("power",
label='',
items=self.__fractalKeys,
callback=self.__cbFractalType)
core.add_drawing("Canvas", width=size[0] * 2, height=size[1] * 2)
core.set_resize_callback(self.__resize)
core.set_render_callback(self.__render)
self.__refresh()
def __init__(self):
with simple.window(self.windowName, width=self.xSize, height=self.ySize, x_pos=self.xPos, y_pos=self.yPos):
core.add_drawing(self.drawingName, width=self.widthMax, height=self.heightMax)
core.set_resize_callback(callback=self.window_resize, handler=self.windowName)
super().__init__()