예제 #1
0
    def init_gui(self):
        "Build the GUI."
        self.root.title('Gas Property Calculator')
        self.grid(column=0, row=0, sticky='nsew')

        # Initialize Variables
        self.initial_type = None
        self.final_type = None

        # Mixture creation
        species = []
        species_vals = []
        num_species = 9  # Number of species to include
        for i in range(num_species):
            # Create species buttons
            specie = tkinter.StringVar()
            spec = ttk.Entry(self, width=10, textvariable=specie)
            spec.grid(column=0, row=i+1)
            val = tkinter.DoubleVar()
            vals = ttk.Entry(self, width=12, textvariable=val)
            vals.grid(column=1, row=i+1)
            species.append(specie)
            species_vals.append(val)
        self.species = species
        self.species_vals = species_vals
        int_row = i + 1  # Intermediate row
        self.phi = tkinter.StringVar()
        self.phi_entry = ttk.Entry(self, width=10, textvariable=self.phi)
        self.phi_entry.grid(column=1, row=int_row+1)
        self.phi.trace('w', self.change_phi)  # Run when value changes
        ttk.Label(self, text='Equivalence Ratio').grid(column=0, row=int_row+1)
        ttk.Label(self, text='Species').grid(column=0, row=0)
        ttk.Label(self, text='Relative Moles').grid(column=1, row=0)

        # Separator
        ttk.Separator(self, orient='horizontal').grid(column=0, row=int_row+2,
                                                      columnspan=7,
                                                      sticky='ew')
        int_row += 3  # Move reference row down a bit
        # Initial / Calculated Conditions
        self.T = tkinter.StringVar()
        self.P = tkinter.StringVar()
        self.H = tkinter.StringVar()
        self.S = tkinter.StringVar()
        self.D = tkinter.StringVar()
        self.U = tkinter.StringVar()

        self.T_entry = ttk.Entry(self, width=12, textvariable=self.T)
        self.P_entry = ttk.Entry(self, width=12, textvariable=self.P)
        self.H_entry = ttk.Entry(self, width=12, textvariable=self.H)
        self.S_entry = ttk.Entry(self, width=12, textvariable=self.S)
        self.D_entry = ttk.Entry(self, width=12, textvariable=self.D)
        self.U_entry = ttk.Entry(self, width=12, textvariable=self.U)
        self.initial_entries = [self.T_entry, self.P_entry, self.H_entry,
                                self.S_entry, self.D_entry, self.U_entry]

        self.T_entry.grid(column=0, row=int_row+1)
        self.P_entry.grid(column=0, row=int_row+2)
        self.H_entry.grid(column=0, row=int_row+3)
        self.S_entry.grid(column=0, row=int_row+4)
        self.D_entry.grid(column=0, row=int_row+5)
        self.U_entry.grid(column=0, row=int_row+6)

        ttk.Label(self, text='Initial Conditions').grid(column=0, row=int_row)

        self.initial_button = ttk.Button(
            self, text='Calc. Initial Conditions',
            command=self.calculate_initial)
        self.initial_button.grid(column=0, row=int_row+7)

        # Final Conditions
        ttk.Separator(self, orient='vertical').grid(column=3, row=0,
                                                    rowspan=25, sticky='ns')

        self.T_f = tkinter.StringVar()
        self.P_f = tkinter.StringVar()
        self.H_f = tkinter.StringVar()
        self.S_f = tkinter.StringVar()
        self.D_f = tkinter.StringVar()
        self.U_f = tkinter.StringVar()

        self.T_f_entry = ttk.Entry(self, width=12, textvariable=self.T_f)
        self.P_f_entry = ttk.Entry(self, width=12, textvariable=self.P_f)
        self.H_f_entry = ttk.Entry(self, width=12, textvariable=self.H_f)
        self.S_f_entry = ttk.Entry(self, width=12, textvariable=self.S_f)
        self.D_f_entry = ttk.Entry(self, width=12, textvariable=self.D_f)
        self.U_f_entry = ttk.Entry(self, width=12, textvariable=self.U_f)
        self.final_entries = [self.T_f_entry, self.P_f_entry, self.H_f_entry,
                              self.S_f_entry, self.D_f_entry, self.U_f_entry]

        self.T_f_entry.grid(column=2, row=int_row+1)
        self.P_f_entry.grid(column=2, row=int_row+2)
        self.H_f_entry.grid(column=2, row=int_row+3)
        self.S_f_entry.grid(column=2, row=int_row+4)
        self.D_f_entry.grid(column=2, row=int_row+5)
        self.U_f_entry.grid(column=2, row=int_row+6)

        ttk.Label(self, text='Final Conditions').grid(column=2, row=int_row)
        ttk.Label(self, text='Temperature (K)').grid(column=1, row=int_row+1)
        ttk.Label(self, text='Pressure (Pa)').grid(column=1, row=int_row+2)
        ttk.Label(self, text='Enthalpy (J/kg)').grid(column=1, row=int_row+3)
        ttk.Label(self, text='Entropy (J/kg/K)').grid(column=1, row=int_row+4)
        ttk.Label(self, text='Density (kg/m^3)').grid(column=1, row=int_row+5)
        ttk.Label(self, text='Energy (J/kg)').grid(column=1, row=int_row+6)

        self.final_button = ttk.Button(
            self, text='Calc. Final Conditions',
            command=self.calculate_final)
        self.final_button.grid(column=2, row=int_row+7)

        # Menu bar
        self.root.option_add('*tearOff', 'FALSE')
        self.menubar = tkinter.Menu(self.root)
        self.menu_file = tkinter.Menu(self.menubar)
        self.menu_file.add_command(label='Exit', command=self.on_quit)
        self.menu_file.add_command(label='Open Chem. File', command=self.openf)
        self.menu_edit = tkinter.Menu(self.menubar)
        self.menubar.add_cascade(menu=self.menu_file, label='File')
        self.root.config(menu=self.menubar)

        # Problem type radio buttons
        ttk.Label(self, text='Problem Type').grid(column=4, row=0)
        self.problem_type = tkinter.IntVar()
        ttk.Radiobutton(self, text='Chemically Frozen',
                        variable=self.problem_type, value=0,
                        command=self.change_ptype).grid(column=4, row=1)
        ttk.Radiobutton(self, text='Isentropic Compression. cr:',
                        variable=self.problem_type, value=1,
                        command=self.change_ptype).grid(column=4, row=2)
        ttk.Radiobutton(self, text='Chemical Equilibrium',
                        variable=self.problem_type, value=2,
                        command=self.change_ptype).grid(column=4, row=3)
        self.cr = tkinter.StringVar()
        self.cr_Entry = ttk.Entry(self, width=5, textvariable=self.cr)
        self.cr_Entry.grid(column=5, row=2)
        self.cr.trace('w', self.change_cr)

        self.final_type_int = tkinter.IntVar()
        self.finaltype_buttons = [
                ttk.Radiobutton(self, text='TP', variable=self.final_type_int,
                                command=self.change_ftype, value=0),
                ttk.Radiobutton(self, text='HP', variable=self.final_type_int,
                                command=self.change_ftype, value=1),
                ttk.Radiobutton(self, text='SP', variable=self.final_type_int,
                                command=self.change_ftype, value=2),
                ttk.Radiobutton(self, text='SD', variable=self.final_type_int,
                                command=self.change_ftype, value=3),
                ttk.Radiobutton(self, text='UV', variable=self.final_type_int,
                                command=self.change_ftype, value=4),
                ttk.Radiobutton(self, text='Manual',
                                variable=self.final_type_int,
                                command=self.change_ftype, value=5)
                ]

        count = 5
        for button in self.finaltype_buttons:
            button.grid(column=4, row=count)
#            button.state(statespec=['disabled'])
            count += 1
#print
        # Calculated mixture properties
        self.calc_labels = ['Cp (J/kg/K)', 'Cv (J/kg/K', 'gamma',
                            'Gibbs (J/kg)', 'MW (kg/kmol)',
                            'IsoT compressibility (1/Pa)',
                            'Therm. expansion coeff (1/K)']

        self.calc_calls = ['cp', 'cv', 'GAMMA', 'g', 'mean_molecular_weight',
                           'isothermal_compressibility',
                           'thermal_expansion_coeff']
        i = int_row+8
        initials = []
        finals = []
        for label in self.calc_labels:
            init = tkinter.StringVar()
            final = tkinter.StringVar()
            ttk.Entry(self, width=12, textvariable=init,
                      state='readonly').grid(column=0, row=i)
            ttk.Entry(self, width=12, textvariable=final,
                      state='readonly').grid(column=2, row=i)
            ttk.Label(self, text=label).grid(column=1, row=i)
            i += 1
            initials.append(init)
            finals.append(final)
        self.initial_calc = initials
        self.final_calc = finals

        # Final Composition
        ttk.Label(self, text='Final Composition').grid(column=4, row=int_row,
                                                       columnspan=2)
        ttk.Label(self, text='Species').grid(column=4, row=int_row+1)
        ttk.Label(self, text='Mole Fraction').grid(column=5, row=int_row+1)
        final_spec = []
        final_mole_frac = []
        for ind in range(int_row+2, int_row+15):
            spec = tkinter.StringVar()
            val = tkinter.StringVar()
            ttk.Entry(self, width=10, textvariable=spec,
                      state='readonly').grid(column=4, row=ind)
            ttk.Entry(self, width=12, textvariable=val,
                      state='readonly').grid(column=5, row=ind)
            final_spec.append(spec)
            final_mole_frac.append(val)
        self.final_spec = final_spec
        self.final_mole_frac = final_mole_frac

        # Initialize chemistry file to therm.cti
        self.chemfile = os.path.join(sys.path[0], 'therm.cti')
예제 #2
0
    def __init__(self, master):
        self.master = master
        self.master.title("Nagrody za kody")
        self.master.geometry('700x500')

        self.frame1 = tk.Frame(master)
        self.frame1.pack(fill='both', expand=True)

        self.button_import = tk.Button(self.frame1,
                                       text="Import plików Excel",
                                       command=lambda: self.file_choose())
        self.button_import.pack()

        self.button_save = tk.Button(
            self.frame1,
            text="Podaj lokalizację zapisu",
            command=lambda: self.choose_save_location())
        self.button_save.pack()

        self.label_file_count = tk.Label(self.frame1)
        self.label_file_count.pack()

        self.var_win = tk.IntVar()
        self.checkbox_win = tk.Checkbutton(
            self.frame1,
            text="Sprawdzaj max/min dla PPE",
            variable=self.var_win,
            command=lambda: self.label_state(self.var_win.get()))
        self.checkbox_win.pack(anchor="e")

        self.win_count = tk.StringVar()
        self.win_entry = tk.Entry(self.frame1,
                                  textvariable=self.win_count,
                                  state="disabled")
        self.win_entry.pack(anchor="e")

        self.var_SE = tk.IntVar()
        self.checkbox_SE = tk.Checkbutton(
            self.frame1,
            text="Nie uwzględniaj sprzedawców kompleksowych",
            variable=self.var_SE)
        self.checkbox_SE.pack(anchor="e")

        self.var1 = tk.IntVar()
        self.checkbox_1 = tk.Checkbutton(self.frame1,
                                         text="Dane pewne - kolor zielony",
                                         variable=self.var1)
        self.checkbox_1.pack(anchor="w")

        self.var2 = tk.IntVar()
        self.checkbox_2 = tk.Checkbutton(self.frame1,
                                         text="Dane niepewne - kolor czerwony",
                                         variable=self.var2)
        self.checkbox_2.pack(anchor="w")

        self.var3 = tk.IntVar()
        self.checkbox_3 = tk.Checkbutton(
            self.frame1,
            text="Dane prognozowane - kolor niebieski",
            variable=self.var3)
        self.checkbox_3.pack(anchor="w")

        self.var4 = tk.IntVar()
        self.checkbox_4 = tk.Checkbutton(self.frame1,
                                         text="Dane ręczne - kolor różowy",
                                         variable=self.var4)
        self.checkbox_4.pack(anchor="w")

        self.var5 = tk.IntVar()
        self.checkbox_5 = tk.Checkbutton(
            self.frame1,
            text="Braki schematów - kolor turkusowy",
            variable=self.var5)
        self.checkbox_5.pack(anchor="w")

        self.var6 = tk.IntVar()
        self.checkbox_6 = tk.Checkbutton(self.frame1,
                                         text="Braki danych - kolor szary",
                                         variable=self.var6)
        self.checkbox_6.pack(anchor="w")

        self.var7 = tk.IntVar()
        self.checkbox_7 = tk.Checkbutton(self.frame1,
                                         text="Zamknięta umowa - kolor biały",
                                         variable=self.var7)
        self.checkbox_7.pack(anchor="w")

        self.start_button = tk.Button(
            self.frame1,
            text="Start",
            command=lambda: self.start(imported_files, location, self.
                                       progress_var))
        self.start_button.pack(anchor="s")

        self.progress_var = tk.DoubleVar()
        self.label_progress_var = tk.StringVar()
예제 #3
0
 def test_listvariable(self):
     widget = self.create()
     var = tkinter.DoubleVar(self.root)
     self.checkVariableParam(widget, 'listvariable', var)
예제 #4
0
# PWM 객체 생성 : 11번 핀, 주파수 - 100Hz
p_r = GPIO.PWM(LED_R, 100)
p_y = GPIO.PWM(LED_Y, 100)
p_g = GPIO.PWM(LED_G, 100)

# PWM 신호 출력
p_r.start(0)
p_y.start(0)
p_g.start(0)

# window Obj
window = tk.Tk()
window.geometry('300x300')

# 변수 설정
led_r_value = tk.DoubleVar()
led_y_value = tk.DoubleVar()
led_g_value = tk.DoubleVar()

led_r_value.set(0)
led_y_value.set(0)
led_g_value.set(0)


# duty 값을 변경 함수
def change_duty_r(dc):
    p_r.ChangeDutyCycle(led_r_value.get())


def change_duty_y(dc):
    p_y.ChangeDutyCycle(led_y_value.get())
예제 #5
0
# Pin number label
account_number_label = tk.Label(win, text="Account Number", width=30)

# The pin number entry and associated variable.
# Note: Modify this to 'show' PIN numbers as asterisks (i.e. **** not 1234)
pin_number_var = tk.StringVar()
pin_number_var.set("7890")
account_pin_entry = tk.Entry(win, text='PIN Number', show="*", textvariable=pin_number_var, state=DISABLED)

# The balance label and associated variable
balance_var = tk.StringVar()
balance_var.set('Balance: $0.00')
balance_label = tk.Label(win, text="Balance: $0.00", width=20)

# The Entry widget to accept a numerical value to deposit or withdraw
amount_entry_var = tk.DoubleVar()
amount_entry = tk.Entry(win, textvariable=amount_entry_var)

# The transaction text widget holds text of the accounts transactions
transaction_text_widget = tk.Text(win, height=10, width=48)

# The bank account object we will work with
account = BankAccount()


# ---------- Button Handlers for Login Screen ----------


def clear_pin_entry(event):
    """Function to clear the PIN number entry when the Clear / Cancel button is clicked."""
    # Clear the pin number entry here
#----------------------需要設定的參數----------------------------------------------
#檔名參數
file_name = tk.StringVar()
file_name.set('ANN_training_data_AC_combination_1129')
#輸入特徵參數
features_Num = tk.IntVar()
features_Num.set(8)
#輸入訓練次數
iteration = tk.IntVar()
iteration.set(20000)
#輸入隱藏層特徵數
hiddenlayer_features = tk.IntVar()
hiddenlayer_features.set(5)
#輸入學習速率
learning_rate = tk.DoubleVar()
learning_rate.set(0.3)

#學習狀況記錄
lossbuck_train = []
lossbuck_test = []
#----------------------需要設定的參數------------------------------------------------


def Tranning_by_Neural_Network():
    #---------------------ANN前數據讀檔處理---------------------------------------------
    #讀檔創建Dataframe
    #filepath='C:\\Users\\richard.weng\\Documents\\Python Scripts\\python_projects\\(1) NIVG Project\\ANN\\'
    file_data = file_name.get() + '.csv'
    df0 = pd.read_csv(file_data)
예제 #7
0
parser = argparse.ArgumentParser()
parser.add_argument("--game", "-g", type=str)
args = parser.parse_args()

# Setup game environment and GUI
env = Environment(args.game)
gui = GUI(env.game_name(), env.n_channels)

# Thread safe variables for use with GUI
action = Tk.IntVar()
action.set(0)
action_taken = Tk.BooleanVar()
action_taken.set(False)
action_released = Tk.BooleanVar()
action_released.set(False)
G = Tk.DoubleVar()
G.set(0.0)
is_terminate = Tk.BooleanVar()
is_terminate.set(False)

# Map input keys to agent actions
key_action_map = {' ': 5, 'left': 1, 'up': 2, 'right': 3, 'down': 4}


# Key press handler for human player
def on_key_event(event):
    if event.key == 'q':  # quit the game
        gui.quit()
    elif (event.key == 'r'):  # reset the game environment
        env.reset()
    elif (event.key in key_action_map):
예제 #8
0
    def __init__(self, master, app=None):
        super(CreateFatigueWindow, self).__init__()
        if __name__ == '__main__':
            self._initial_structure_obj = test.get_structure_object()
            self.load_objects = [
                test.get_loa_fls_load(),
                test.get_loa_uls_load(),
                test.get_bal_fls_load(),
                test.get_bal_uls_load()
            ]
            self.active_line = 'line1'
            points = test.line_dict['line1']
            coords = (test.point_dict['point' + str(points[0])],
                      test.point_dict['point' + str(points[1])])
            self.pressure_coords = self.get_pressure_point_coord_from_two_points(
                coords[0], coords[1])
            self.comp_objects = [test.get_tank_object()]
            self._initial_fatigue_obj = test.get_fatigue_object()

        else:
            if app._line_to_struc[app._active_line][0] is None:
                return
            elif app._line_to_struc[app._active_line][0].Stiffener is None:
                return
            self.app = app
            self.active_line = app._active_line
            points = app._line_dict[self.active_line]
            coords = (app._point_dict['point' + str(points[0])],
                      app._point_dict['point' + str(points[1])])
            self.pressure_coords = self.get_pressure_point_coord_from_two_points(
                coords[0], coords[1])
            self._initial_structure_obj = app._line_to_struc[
                app._active_line][0].Stiffener
            self.load_objects = app._line_to_struc[app._active_line][3]

            self.comp_objects = [
                app._tank_dict['comp' + str(comp_i)]
                for comp_i in app.get_compartments_for_line(app._active_line)
            ]
            self._initial_fatigue_obj = app._line_to_struc[self.active_line][2]

        self._frame = master
        self._frame.wm_title("Specify fatigue properties here.")
        self._frame.geometry('1300x810')
        self._frame.grab_set()

        tk.Label(
            self._frame,
            text='-- Fatigue calculation for plates according to DNVGL-RP-C203, '
            'Section 5 Simplified fatigue analysis --',
            font='Verdana 15 bold').place(x=10, y=10)

        ent_w = 10

        self.new_sn_curve = tk.StringVar()
        self.new_k_factor = tk.DoubleVar()
        self.new_no_of_cycles = tk.DoubleVar()
        self.new_design_life = tk.DoubleVar()
        self.new_dff = tk.DoubleVar()

        self.new_weibull_loa = tk.DoubleVar()
        self.new_weibull_bal = tk.DoubleVar()
        self.new_weibull_prt = tk.DoubleVar()

        self.new_period_loa = tk.DoubleVar()
        self.new_period_bal = tk.DoubleVar()
        self.new_period_prt = tk.DoubleVar()

        self.new_corr_loc_loa = tk.DoubleVar()
        self.new_corr_loc_bal = tk.DoubleVar()
        self.new_corr_loc_prt = tk.DoubleVar()

        self.new_fraction_loa = tk.DoubleVar()
        self.new_fraction_bal = tk.DoubleVar()
        self.new_fraction_prt = tk.DoubleVar()

        self.new_az_loa = tk.DoubleVar()
        self.new_az_bal = tk.DoubleVar()
        self.new_az_prt = tk.DoubleVar()

        sn_curves = sn.get_all_curves()

        self.ent_sn_curve = tk.OptionMenu(self._frame,
                                          self.new_sn_curve,
                                          command=self.change_sn_curve,
                                          *sn_curves)
        self.ent_dff = tk.Entry(self._frame,
                                textvariable=self.new_dff,
                                width=ent_w)
        self.ent_k_factor = tk.Entry(self._frame,
                                     textvariable=self.new_k_factor,
                                     width=ent_w)
        self.ent_no_of_cycles = tk.Entry(self._frame,
                                         textvariable=self.new_no_of_cycles,
                                         width=ent_w)
        self.ent_new_design_life = tk.Entry(self._frame,
                                            textvariable=self.new_design_life,
                                            width=ent_w)

        self.ent_weibull_loa = tk.Entry(self._frame,
                                        textvariable=self.new_weibull_loa,
                                        width=ent_w)
        self.ent_weibull_bal = tk.Entry(self._frame,
                                        textvariable=self.new_weibull_bal,
                                        width=ent_w)
        self.ent_weibull_prt = tk.Entry(self._frame,
                                        textvariable=self.new_weibull_prt,
                                        width=ent_w)

        self.ent_period_loa = tk.Entry(self._frame,
                                       textvariable=self.new_period_loa,
                                       width=ent_w)
        self.ent_period_bal = tk.Entry(self._frame,
                                       textvariable=self.new_period_bal,
                                       width=ent_w)
        self.ent_period_prt = tk.Entry(self._frame,
                                       textvariable=self.new_period_prt,
                                       width=ent_w)

        self.ent_corr_loc_loa = tk.Entry(self._frame,
                                         textvariable=self.new_corr_loc_loa,
                                         width=ent_w)
        self.ent_corr_loc_bal = tk.Entry(self._frame,
                                         textvariable=self.new_corr_loc_bal,
                                         width=ent_w)
        self.ent_corr_loc_prt = tk.Entry(self._frame,
                                         textvariable=self.new_corr_loc_prt,
                                         width=ent_w)

        self.ent_fraction_loa = tk.Entry(self._frame,
                                         textvariable=self.new_fraction_loa,
                                         width=ent_w)
        self.ent_fraction_bal = tk.Entry(self._frame,
                                         textvariable=self.new_fraction_bal,
                                         width=ent_w)
        self.ent_fraction_prt = tk.Entry(self._frame,
                                         textvariable=self.new_fraction_prt,
                                         width=ent_w)

        self.ent_acc_loa = tk.Entry(self._frame,
                                    textvariable=self.new_az_loa,
                                    width=ent_w)
        self.ent_acc_bal = tk.Entry(self._frame,
                                    textvariable=self.new_az_bal,
                                    width=ent_w)
        self.ent_acc_prt = tk.Entry(self._frame,
                                    textvariable=self.new_az_prt,
                                    width=ent_w)

        start_x, start_y, dx, dy = 20, 100, 150, 35

        loaded_exist = False
        ballast_exist = False
        part_exist = False
        fls_exist = (loaded_exist, ballast_exist, part_exist)

        # Frames to hide loaded, ballast or part
        loa_fr = tk.Frame(self._frame,
                          width=100,
                          height=170,
                          bg="gray25",
                          colormap="new")
        bal_fr = tk.Frame(self._frame,
                          width=100,
                          height=170,
                          bg="gray25",
                          colormap="new")
        prt_fr = tk.Frame(self._frame,
                          width=100,
                          height=170,
                          bg="gray25",
                          colormap="new")

        for load in self.load_objects:
            if load != None:
                if load.get_limit_state() == 'FLS':
                    if load.get_load_condition() == 'loaded':
                        loaded_exist = True
                    elif load.get_load_condition() == 'ballast':
                        ballast_exist = True
                    elif load.get_load_condition() == 'part':
                        part_exist = True
                    else:
                        pass
            fls_exist = (loaded_exist, ballast_exist, part_exist)

        if self._initial_fatigue_obj == None:
            self.new_sn_curve.set('Ec')
            self.new_k_factor.set(1)
            self.new_no_of_cycles.set(10000)
            self.new_design_life.set(20)
            self.new_dff.set(2)
            if any(fls_exist):
                if loaded_exist:
                    self.new_fraction_loa.set(1 / fls_exist.count(True))
                    self.new_weibull_loa.set(0.8)
                    self.new_period_loa.set(8)
                    self.new_corr_loc_loa.set(0.5)
                    self.new_az_loa.set(0.5)
                if ballast_exist:
                    self.new_fraction_bal.set(1 / fls_exist.count(True))
                    self.new_weibull_bal.set(0.8)
                    self.new_period_bal.set(8)
                    self.new_corr_loc_bal.set(0.5)
                    self.new_az_bal.set(0.5)
                if part_exist:
                    self.new_fraction_prt.set(1 / fls_exist.count(True))
                    self.new_weibull_prt.set(0.8)
                    self.new_period_prt.set(8)
                    self.new_corr_loc_prt.set(0.5)
                    self.new_az_prt.set(0.5)
        else:
            fat_prop = self._initial_fatigue_obj.get_fatigue_properties()
            self.new_sn_curve.set(fat_prop['SN-curve'])
            self.new_k_factor.set(fat_prop['SCF'])
            self.new_no_of_cycles.set(fat_prop['n0'])
            self.new_design_life.set(fat_prop['Design life'])
            self.new_dff.set(fat_prop['DFF'])
            if any(fls_exist):
                if loaded_exist:
                    self.new_fraction_loa.set(fat_prop['Fraction'][0])
                    self.new_weibull_loa.set(fat_prop['Weibull'][0])
                    self.new_period_loa.set(fat_prop['Period'][0])
                    self.new_corr_loc_loa.set(fat_prop['CorrLoc'][0])
                    self.new_az_loa.set(fat_prop['Accelerations'][0])
                if ballast_exist:
                    self.new_fraction_bal.set(fat_prop['Fraction'][1])
                    self.new_weibull_bal.set(fat_prop['Weibull'][1])
                    self.new_period_bal.set(fat_prop['Period'][1])
                    self.new_corr_loc_bal.set(fat_prop['CorrLoc'][1])
                    self.new_az_bal.set(fat_prop['Accelerations'][1])
                if part_exist:
                    self.new_fraction_prt.set(fat_prop['Fraction'][2])
                    self.new_weibull_prt.set(fat_prop['Weibull'][2])
                    self.new_period_prt.set(fat_prop['Period'][2])
                    self.new_corr_loc_prt.set(fat_prop['CorrLoc'][2])
                    self.new_az_prt.set(fat_prop['Accelerations'][2])

        all_acc = (self.new_az_loa.get(), self.new_az_bal.get(),
                   self.new_az_prt.get())

        count = 1
        for load in self.load_objects:
            if load == None:
                continue
            press = []
            if load.get_limit_state() == 'FLS':
                tk.Label(self._frame, text=str(count)+'. '+load.get_name(), font='Verdana 8')\
                    .place(x=start_x + 5 * dx, y=start_y + (5+count) * dy)
                idx = 0
                for exist in fls_exist:
                    if exist:
                        press.append(
                            round(
                                load.get_calculated_pressure(
                                    self.pressure_coords, all_acc[idx],
                                    self._initial_structure_obj.
                                    get_structure_type()), 1))
                        idx += 1

                tk.Label(self._frame, text=press, font='Verdana 8') \
                    .place(x=start_x + 6.5 * dx, y=start_y + (5 + count) * dy)
                count += 1
        press = []
        for comp in self.comp_objects:
            if comp == None:
                continue
            tk.Label(self._frame, text=str(count) + '. ' +str(comp.get_name()), font='Verdana 8') \
                .place(x=start_x + 5 * dx, y=start_y + (5 + count) * dy)

            idx = 0

            if fls_exist[0] and comp.is_loaded_condition():
                press.append(
                    round(
                        comp.get_calculated_pressure(self.pressure_coords,
                                                     all_acc[0]), 1))
            if fls_exist[1] and comp.is_ballast_condition():
                press.append(
                    round(
                        comp.get_calculated_pressure(self.pressure_coords,
                                                     all_acc[1]), 1))
            if fls_exist[2] and any(
                [comp.is_loaded_condition(),
                 comp.is_ballast_condition()]):
                press.append(
                    round(
                        comp.get_calculated_pressure(self.pressure_coords,
                                                     all_acc[2]), 1))

            tk.Label(self._frame, text=press, font='Verdana 8') \
                .place(x=start_x + 6.5 * dx, y=start_y + (5 + count) * dy)

            count += 1

        tk.Label(self._frame, text='Design life:', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 0*dy)
        tk.Label(self._frame, text='Design Fatigue Factor (DFF):', font='Verdana 8 bold') \
            .place(x=start_x+ 3*dx , y=start_y + 0*dy)
        tk.Label(self._frame, text='SN-curve:', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 1*dy)
        tk.Label(self._frame, text='Cycles in return period, n0', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 2*dy)
        tk.Label(self._frame, text='Stress Concentration Factor, SCF', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 3*dy)

        tk.Label(self._frame, text='Loaded', font='Verdana 8 bold') \
            .place(x=start_x+2*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Ballast', font='Verdana 8 bold') \
            .place(x=start_x+3*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Part', font='Verdana 8 bold') \
            .place(x=start_x+4*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Defined loads', font='Verdana 8 bold') \
            .place(x=start_x+5*dx , y=start_y + 5*dy)
        tk.Label(self._frame, text='Resulting pressures', font='Verdana 8 bold') \
            .place(x=start_x+6.5*dx , y=start_y + 5*dy)

        tk.Label(self._frame, text='Fraction (sum of bal/part/loa is 1)', font='Verdana 8 bold') \
            .place(x=start_x, y=start_y + 6 * dy)
        tk.Label(self._frame, text='Weibull', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 7*dy)
        tk.Label(self._frame, text='Period', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 8*dy)
        tk.Label(self._frame, text='Corr. loc.', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 9*dy)
        tk.Label(self._frame, text='Accelerations', font='Verdana 8 bold') \
            .place(x=start_x , y=start_y + 10*dy)

        self.ent_new_design_life.place(x=start_x + 2 * dx, y=start_y + 0 * dy)
        self.ent_dff.place(x=start_x + 5 * dx, y=start_y + 0 * dy)
        self.ent_sn_curve.place(x=start_x + 2 * dx, y=start_y + 1 * dy)
        self.ent_no_of_cycles.place(x=start_x + 2 * dx, y=start_y + 2 * dy)
        self.ent_k_factor.place(x=start_x + 2 * dx, y=start_y + 3 * dy)

        self.ent_fraction_loa.place(x=start_x + 2 * dx, y=start_y + 6 * dy)
        self.ent_fraction_bal.place(x=start_x + 3 * dx, y=start_y + 6 * dy)
        self.ent_fraction_prt.place(x=start_x + 4 * dx, y=start_y + 6 * dy)

        self.ent_weibull_loa.place(x=start_x + 2 * dx, y=start_y + 7 * dy)
        self.ent_weibull_bal.place(x=start_x + 3 * dx, y=start_y + 7 * dy)
        self.ent_weibull_prt.place(x=start_x + 4 * dx, y=start_y + 7 * dy)

        self.ent_period_loa.place(x=start_x + 2 * dx, y=start_y + 8 * dy)
        self.ent_period_bal.place(x=start_x + 3 * dx, y=start_y + 8 * dy)
        self.ent_period_prt.place(x=start_x + 4 * dx, y=start_y + 8 * dy)

        self.ent_corr_loc_loa.place(x=start_x + 2 * dx, y=start_y + 9 * dy)
        self.ent_corr_loc_bal.place(x=start_x + 3 * dx, y=start_y + 9 * dy)
        self.ent_corr_loc_prt.place(x=start_x + 4 * dx, y=start_y + 9 * dy)

        self.ent_acc_loa.place(x=start_x + 2 * dx, y=start_y + 10 * dy)
        self.ent_acc_bal.place(x=start_x + 3 * dx, y=start_y + 10 * dy)
        self.ent_acc_prt.place(x=start_x + 4 * dx, y=start_y + 10 * dy)

        # if not loaded_exist:
        #     loa_fr.place(x=start_x + 2 * dx, y=start_y + 6 * dy)
        # elif not ballast_exist:
        #     bal_fr.place(x=start_x + 3 * dx, y=start_y + 6 * dy)
        # elif not part_exist:
        #     prt_fr.place(x=start_x + 4 * dx, y=start_y + 6 * dy)

        self._close_and_save = tk.Button(self._frame,
                                         text='Return fatigue parameters',
                                         command=self.save_and_close,
                                         bg='green',
                                         font='Verdana 15',
                                         fg='yellow')
        self._close_and_save.place(x=start_x + dx, y=start_y + dy * 15)
예제 #9
0
 def test_configure_variable(self):
     widget = self.create()
     var = tkinter.DoubleVar(self.root)
     self.checkVariableParam(widget, 'variable', var)
예제 #10
0
    def create_user_panel(self) -> object:
        self.x_label = tk.Label(text="X")
        self.x_label.grid(row=1, column=1)
        self.x_value = tk.DoubleVar()
        self.x_coor = tk.Entry(bd=5, textvariable=self.x_value)
        self.x_coor.grid(row=1, column=2)

        self.y_label = tk.Label(text="Y")
        self.y_label.grid(row=2, column=1)
        self.y_value = tk.DoubleVar()
        self.y_coor = tk.Entry(bd=5, textvariable=self.y_value)
        self.y_coor.grid(row=2, column=2)

        self.u_label = tk.Label(text="U")
        self.u_label.grid(row=1, column=3)
        self.u_value = tk.DoubleVar()
        self.u_coor = tk.Entry(bd=5, textvariable=self.u_value)
        self.u_coor.grid(row=1, column=4)

        self.v_label = tk.Label(text="V")
        self.v_label.grid(row=2, column=3)
        self.v_value = tk.DoubleVar()
        self.v_coor = tk.Entry(bd=5, textvariable=self.v_value)
        self.v_coor.grid(row=2, column=4)

        self.m_label = tk.Label(text="M")
        self.m_label.grid(row=3, column=1)
        self.m = tk.Scale(variable="weight",
                          activebackground="red",
                          orient="horizontal")
        self.m.grid(row=3, column=2)

        self.create_point = tk.Button(text="generate",
                                      command=self.CreateRandom)
        self.create_point.grid(row=3, column=3, columnspan=1)

        self.create_point = tk.Button(text="create", command=self.CreatePoint)
        self.create_point.grid(row=3, column=4, columnspan=1)

        #self.Verle_value = tk.IntVar()

        #        self.Verle1 = tk.Radiobutton(text="Верле(Python)", variable=self.Verle_value, value=1, indicatoron=0)
        #        self.Verle1.grid(row=4, column=1)
        #
        #        self.Verle2 = tk.Radiobutton(text="Верле(odeint)", variable=self.Verle_value, value=2, indicatoron=0)
        #        self.Verle2.grid(row=4, column=2)
        #
        #        self.Verle3 = tk.Radiobutton(text="Верле(cython)",variable=self.Verle_value, value=3, indicatoron=0)
        #        self.Verle3.grid(row=4, column=3)
        #
        #        self.Verle4 = tk.Radiobutton(text="Верле(parallel)", variable=self.Verle_value, value=4, indicatoron=0)
        #        self.Verle4.grid(row=4, column=4)

        #        self.x_label = tk.Label(text="emitter_X")
        #        self.x_label.grid(row=5, column=1)
        #        self.x_coor = tk.Entry(bd=5)
        #        self.x_coor.grid(row=5, column=2)

        #        self.emitter_y_label = tk.Label(text="emitter_Y")
        #        self.emitter_y_label.grid(row=5, column=3)
        #        self.emitter_y_coor = tk.Entry(bd=5)
        #        self.emitter_y_coor.grid(row=5, column=4)
        self.options = [
            "Верле(Python)", "Odeint", "Верле(cython)", "Верле(parallel)"
        ]

        self.Verle_value = tk.StringVar()
        self.Verle_value.set("Верле(Python)")
        self.Verle = tk.OptionMenu(root, self.Verle_value, *self.options)
        self.Verle.grid(row=5, column=1)
        self.Verle.config(font=('calibri', (10)), bg='white', width=12)
        self.Verle['menu'].config(font=('calibri', (10)), bg='white')

        self.verle_step = tk.Button(text="play", command=self.Play)
        self.verle_step.grid(row=5, column=2)

        self.verle_step = tk.Button(text="verle step", command=self.NextStep)
        self.verle_step.grid(row=7, column=1)

        self.verle_step = tk.Button(text="calculate time",
                                    command=self.CalculateTime)
        self.verle_step.grid(row=7, column=2)
예제 #11
0
    def __init__(self, root, master, *args, **kwargs):
        self.master = master
        self.root = root

        self.activation_function = "Symmetrical Hard limit"
        self.hebbian_rule = "Delta Rule"
        self.alpha = 0.1
        self.nUnit = 10
        self.t = -1 * np.ones((10,1000))
       # self.t.fill(-1.0/9.0)
        self.p = np.ones((785, 1000), dtype=np.float32)


        self.training_input = np.zeros((785, 800))
        self.training_target = np.zeros((10, 800))
        self.testing_input = np.zeros((785, 200))
        self.testing_target = np.zeros((10, 200))

        self.load_input_vector()
        self.weight = np.zeros((10, 785))

        #self.weight = (self.weight * 0.002) - 0.001

        self.x = np.zeros(100)
        self.y = np.zeros(100)

        self.x_start = 0
        #########################################################################
        #  Set up the constants and default values
        #########################################################################


        self.xmin = 0
        self.xmax = 1000
        self.ymin = 0
        self.ymax = 100

        #########################################################################
        #  Set up the plotting area
        #########################################################################
        self.plot_frame = tk.Frame(self.master)
        self.plot_frame.grid(row=0, column=0, columnspan=2, sticky=tk.N + tk.E + tk.S + tk.W)
        self.plot_frame.rowconfigure(0, weight=1)
        self.plot_frame.columnconfigure(0, weight=1)
        self.figure = plt.figure("")
        self.axes = self.figure.gca()
        self.axes.set_xlabel('Epoch')
        self.axes.set_ylabel('Error rate')
        self.axes.set_title("")
        plt.xlim(self.xmin, self.xmax)
        plt.ylim(self.ymin, self.ymax)
        self.canvas = FigureCanvasTkAgg(self.figure, master=self.plot_frame)

        self.plot_widget = self.canvas.get_tk_widget()
        self.plot_widget.grid(row=0, column=0, sticky=tk.N + tk.E + tk.S + tk.W)
        #########################################################################
        #  Set up the frame for sliders (scales)
        #########################################################################
        self.sliders_frame = tk.Frame(self.master)
        self.sliders_frame.grid(row=1, column=0, sticky=tk.N + tk.E + tk.S + tk.W)
        self.sliders_frame.rowconfigure(0, weight=10)
        self.sliders_frame.rowconfigure(1, weight=2)
        self.sliders_frame.columnconfigure(0, weight=5, uniform='xx')
        self.sliders_frame.columnconfigure(1, weight=1, uniform='xx')
        # set up the sliders

        self.alpha_slider = tk.Scale(self.sliders_frame, variable=tk.DoubleVar(), orient=tk.HORIZONTAL,
                                    from_=0.001, to_=1.0, resolution=0.01, bg="#DDDDDD",
                                    activebackground="#FF0000",
                                    highlightcolor="#00FFFF",
                                    label="Alpha",
                                    command=lambda event: self.alpha_slider_callback())
        self.alpha_slider.set(self.alpha)
        self.alpha_slider.bind("<ButtonRelease-1>", lambda event: self.alpha_slider_callback())
        self.alpha_slider.grid(row=2, column=0, sticky=tk.N + tk.E + tk.S + tk.W)
        #########################################################################
        #  Set up the frame for button(s)
        #########################################################################

        self.buttons_frame = tk.Frame(self.master)
        self.buttons_frame.grid(row=1, column=1, sticky=tk.N + tk.E + tk.S + tk.W)
        self.buttons_frame.rowconfigure(0, weight=1)
        self.buttons_frame.columnconfigure(0, weight=1, uniform='xx')



        self.label_for_hebbian_rule = tk.Label(self.buttons_frame, text="Select Learning Method",
                                                      justify="center")
        self.label_for_hebbian_rule.grid(row=3, column=0, sticky=tk.N + tk.E + tk.S + tk.W)
        self.hebbian_rule_variable = tk.StringVar()
        self.hebbian_rule_dropdown = tk.OptionMenu(self.buttons_frame, self.hebbian_rule_variable,
                                                          "Filtered Learning", "Delta Rule", "Unsupervised Hebb",
                                                          command=lambda
                                                              event: self.hebbian_rule_dropdown_callback())
        self.hebbian_rule_variable.set("Delta Rule")
        self.hebbian_rule_dropdown.grid(row=4, column=0, sticky=tk.N + tk.E + tk.S + tk.W)


        self.label_for_activation_function = tk.Label(self.buttons_frame, text="Transfer Function",
                                                      justify="center")
        self.label_for_activation_function.grid(row=5, column=0, sticky=tk.N + tk.E + tk.S + tk.W)
        self.activation_function_variable = tk.StringVar()
        self.activation_function_dropdown = tk.OptionMenu(self.buttons_frame, self.activation_function_variable,
                                                          "Symmetrical Hard limit", "Hyperbolic Tangent", "Linear",
                                                          command=lambda
                                                              event: self.activation_function_dropdown_callback())
        self.activation_function_variable.set("Hyperbolic Tangent")
        self.activation_function_dropdown.grid(row=6, column=0, sticky=tk.N + tk.E + tk.S + tk.W)

        self.draw_button = tk.Button(self.buttons_frame, text="Randomize Weights", fg="blue",width=16, command=self.randomize_weight)
        self.draw_button.grid(row=0, column=0)

        self.draw_button = tk.Button(self.buttons_frame, text="Adjust Weights (Learn)", fg="red",width=16, command=self.adjust_weight)
        self.draw_button.grid(row=1, column=0)

        print("Window size:", self.master.winfo_width(), self.master.winfo_height())
예제 #12
0
    def __init__(self, master, trackapp=None, tokenlist=None, *args, **kwargs):
        super().__init__(master, *args, **kwargs)
        self.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)
        self.trackapp = trackapp

        # app title
        version = "1.1.4a"
        self.master.title("Elevation Editor v." + version)

        new_tags = self.bindtags() + ("all", )
        self.bindtags(new_tags)

        # token and brush data
        self._tokens = tuple()
        self._elevationProfiles = []
        self._drag_data = {'x': 0, 'y': 0, 'items': [], 'feather': []}
        self._brush_data = {
            'x': 0,
            'r': tk.DoubleVar(value=10),
            'f0': tk.DoubleVar(value=10),
            'f1': tk.DoubleVar(value=10)
        }  #r = brush radius, f = feather radius
        self._brushes = tuple()
        self._feathers = tuple()
        self._leftfeather = False
        self._rightfeather = False
        self._feathermode2 = [tk.StringVar(), tk.StringVar()]
        self._mouselabel = {
            "x_coord": 0,
            "y_coord": 0,
            'x': tk.StringVar(),
            'z': tk.StringVar()
        }
        self._mousepos = {'x': 0, 'y': 0}
        self._widgetsize = (None, None)
        self._past = []
        self._future = []

        # set offset, scales
        self._high_x = 0
        self._high_y = 0
        self._low_x = 0
        self._low_y = 0
        self._first_z = 0
        self._brush_offset = self._high_x - self._low_x
        self._y_scale = -5.0
        self._x_scale = 1.0
        self._slopescale = -500
        self.isLoop = 0

        # set graphics
        self.line_width = 2
        can_bg = "#6090CC"
        self.c_gridFill = "#4C74A4"
        gCan_bg = "#303030"
        self.g_gridFill = "#202020"
        self.tokenFill = "#FFFFFF"
        self.brushFill = "#5682B8"
        self.featherFill = "#5B89C2"

        ### MENUS ----------------------------------------------------------------------------------

        # create a toplevel menu and a frame
        self.menubar = tk.Menu(self)

        #create pulldown file menu
        filemenu = tk.Menu(self.menubar, tearoff=0)
        filemenu.add_command(label="Load", command=self._load_ted)
        filemenu.add_command(label="Export", command=self._export_ted)
        filemenu.add_separator()
        #filemenu.add_command(label="Import elevation profile", command=self._import_ep)
        filemenu.add_command(label="Export elevation profile",
                             command=self._export_ep)
        filemenu.add_separator()
        filemenu.add_command(label="Quit", command=self.quit)
        self.menubar.add_cascade(label="File", menu=filemenu)

        #create pulldown edit menu
        editmenu = tk.Menu(self.menubar, tearoff=0)
        editmenu.add_command(label="Undo", command=self._undo)
        editmenu.add_command(label="Redo",
                             command=lambda: self._undo(arg="redo"))
        self.menubar.add_cascade(label="Edit", menu=editmenu)

        #create pulldown help menu
        helpmenu = tk.Menu(self.menubar, tearoff=0)
        helpmenu.add_command(label="Quick reference",
                             command=self._quick_reference)
        self.menubar.add_cascade(label="Help", menu=helpmenu)

        #display the menu
        self.master.config(menu=self.menubar)

        #left panel
        self.leftPanel = dg.LeftPanel(self)

        ### CREATE CANVASES ---------------------------------------------------------------------------

        c_width = 600

        # create a token canvas
        self.canvas = tk.Canvas(self,
                                width=c_width,
                                bg=can_bg,
                                height=400,
                                bd=1,
                                relief="groove")
        new_tags = self.canvas.bindtags() + ("brusharea", "all")
        self.canvas.bindtags(new_tags)

        #create a graph canvas
        self.graphCanvas = tk.Canvas(self,
                                     width=c_width,
                                     bg=gCan_bg,
                                     height=200,
                                     bd=1,
                                     relief="groove")

        new_tags = self.graphCanvas.bindtags() + ("brusharea", "all")
        self.graphCanvas.bindtags(new_tags)

        # create the brush
        self._create_brush(self._brush_data['x'])

        ### SCROLLBARS ---------------------------------------------------------------------------------

        #add scrollbars
        self.hbar = tk.Scrollbar(self, orient="horizontal", command=self.xview)
        self.vbar = tk.Scrollbar(self, orient="vertical", command=self.yview)
        self.canvas.config(xscrollcommand=self.hbar.set,
                           yscrollcommand=self.vbar.set)

        #add scalebar
        self.graphScaleBar = tk.Scrollbar(self,
                                          orient="vertical",
                                          command=self.graphScale)

        ### RULERS -----------------------------------------------------------------------------------

        self.r_width = 50

        #horizontal
        self.hruler = tk.Canvas(self, width=c_width, height=15,
                                bd=1)  #horizontal
        self.c_vruler = tk.Canvas(self, width=self.r_width, height=15,
                                  bd=1)  #canvas
        self.g_vruler = tk.Canvas(self, width=self.r_width, height=15,
                                  bd=1)  #graph

        ### BINDINGS ------------------------------------------------------------------------------------

        self.bind_class("brusharea", "<ButtonPress-1>",
                        self.OnTokenButtonPress)
        self.bind_class("brusharea", "<ButtonRelease-1>",
                        self.OnTokenButtonRelease)
        self.bind_class("brusharea", "<B1-Motion>", self.OnTokenMotion)
        self.bind_class("brusharea", "<Shift-B1-Motion>",
                        self.ShiftOnTokenMotion)
        self.bind_class("brusharea", "<Motion>", self.OnMotion)
        self.bind_class("brusharea", '<MouseWheel>', self.MouseWheel)
        self.bind_class("brusharea", '<Shift-MouseWheel>',
                        self.ShiftMouseWheel)
        self.bind_class("brusharea", '<Control-MouseWheel>',
                        self.ControlMouseWheel)
        self.bind_class("brusharea", '<Shift-Control-MouseWheel>',
                        self.ShiftControlMouseWheel)
        self.bind_class("brusharea", '<ButtonPress-3>', self.Button3Press)
        self.bind_class("brusharea", '<B3-Motion>', self.MouseScroll)
        self.bind('f', self.FButtonPress)
        self.bind('s', self.SButtonPress)
        self.bind('z', self.zkey)
        self.bind('<Alt-z>', self.altzkey)
        self.bind('<Control-z>', self._undo)
        self.bind('<Control-y>', self._undo)
        self.bind('<Left>', self._leftkey)
        self.bind('<Right>', self._rightkey)
        self.bind('<Configure>', self._my_configure)
        self.bind('<Return>', self._returnkey)

        ### GEOMETRY MANAGEMENT ---------------------------------------------------------------------

        self.leftPanel.grid(row=0, column=0, rowspan=3, sticky="NS")
        self.canvas.grid(row=0, column=2, sticky="WENS")
        self.graphCanvas.grid(row=2, column=2, sticky="WE")
        self.hbar.grid(row=3, column=2, sticky="WE")
        self.vbar.grid(row=0, column=3, sticky="NS")
        self.graphScaleBar.grid(row=2, column=3, sticky="NS")
        self.hruler.grid(row=1, column=2, sticky="WE")
        self.c_vruler.grid(row=0, column=1, sticky="NS")
        self.g_vruler.grid(row=2, column=1, sticky="NS")

        self.columnconfigure(2, weight=1)
        self.rowconfigure(0, weight=1)

        ### OTHER ---------------------------------------------------------------------------------

        self.update_idletasks()
        self.focus_set()
예제 #13
0
"""A tour of ttk widgets we can use in our application"""

import tkinter as tk
from tkinter import ttk

root = tk.Tk()

my_string_var = tk.StringVar(value='Test')
my_int_var = tk.IntVar()
my_dbl_var = tk.DoubleVar()
my_bool_var = tk.BooleanVar()
pack_args = {"padx": 20, "pady": 20}


def my_callback(*_):
    print("Callback called!")


# Entry

myentry = ttk.Entry(root, textvariable=my_string_var, width=20)
myentry.pack(**pack_args)

# Spinbox

myspinbox = ttk.Spinbox(root,
                        from_=0,
                        to=100,
                        increment=.01,
                        textvariable=my_int_var,
                        command=my_callback)
예제 #14
0
	def __init__(self, master=None):
		"""Application initialization
		"""
		tk.Frame.__init__(self, master)
		try: 
			self.ser=serial.Serial('/dev/ttyUSB0', 9600, timeout=10, parity = serial.PARITY_NONE) #Keithley serial port - COM4: Deskotp, COM5: Laptop
		except:
			print("No serial port for keithley")
		try: 
			self.ser1=serial.Serial('/dev/ttyACM0', 9600, timeout=10, parity = serial.PARITY_NONE) #Arduino serial port
		except:
			print("No serial port for arduino")
		
		self.fig = plt.Figure(figsize=(7, 6), dpi=100)
		self.fig.suptitle("I-V Sweep")
		self.a = self.fig.add_subplot(111)
		self.a.grid(b=True, which='major', color='r', linestyle='--')
		
		self.start = tk.DoubleVar()
		self.start.set(0.0)
		self.stop = tk.DoubleVar()
		self.stop.set(0.5)
		self.steps = tk.IntVar()
		self.steps.set(100)
		self.compliance = tk.DoubleVar()
		self.compliance.set(0.005)
		self.delay = tk.DoubleVar()
		self.delay.set(0.1)
		self.loops = tk.IntVar()
		self.loops.set(1)
		self.loopCount = tk.IntVar()
		self.loopCount.set(1)
		self.filenamenumber = tk.IntVar()
		self.filenamenumber.set(0)
		self.filename = tk.StringVar()
		self.filename.set("Sweep_")
		self.filenametext = tk.StringVar()
		self.setfilename()
		self.modes = tk.IntVar()
		self.modes.set(0)
		self.holdMode = tk.IntVar()
		self.holdMode.set(0)

                #Graph Variables
		self.XStart = tk.DoubleVar()
		self.XStart.set(0.0)
		self.XStop = tk.DoubleVar()
		self.XStop.set(0.5)
		self.YStop = tk.DoubleVar()
		self.YStop.set(0.005)
		self.YStart = tk.DoubleVar()
		self.YStart.set(-self.YStop.get())
		
		self.mux = tk.IntVar()
		self.mux.set(0)
		self.quad0 = tk.BooleanVar()
		self.quad0.set(False)
		self.quad1 = tk.BooleanVar()
		self.quad1.set(False)
		self.quad2 = tk.BooleanVar()
		self.quad2.set(False)
		self.quad3 = tk.BooleanVar()
		self.quad3.set(False)
		self.columnconfigure(0, pad = 2)
		self.createWidgets()
		self.grid()
    def __init__(self, from_master):
        sg.RaModuleGui.__init__(self, from_master)
        self.ww = 740  # window width
        self.wh = 900  # window height
        self.title = "Project Maker"
        self.set_geometry(self.ww, self.wh, self.title)

        self.condition_i_list = []
        self.condition_p_list = []
        self.condition_pl_list = []
        self.condition_ter_list = []
        self.condition_init = ""
        self.condition_proj = ""

        self.dir2prj = ""  # os.path.dirname(os.path.abspath(__file__)) + "\\Geodata\\"
        self.dir2ap = config.dir2ml + "Output\\Rasters\\"
        self.fish = {}
        self.fish_applied = {}
        self.n = 0.04
        self.txcr = 0.047
        self.version = ""
        self.w_e = 14  # width of entries
        self.w_lb = 20  # width of listboxes
        self.xlsx_file_name = ""

        self.get_condition_lists()

        self.apply_wua = tk.BooleanVar()
        self.cover_app_pre = tk.BooleanVar()
        self.cover_app_post = tk.BooleanVar()
        self.prj_name = tk.StringVar()
        self.ter_cr = tk.DoubleVar()
        self.vege_cr = tk.DoubleVar()
        self.vege_stab_cr = tk.DoubleVar()

        self.complete_menus()

        # Create LABELS, ENTRIES and BUTTONS from LEFT to RIGHT and TOP-DOWN
        msg0 = "Welcome to the project maker GUI."
        msg1 = "Info - buttons help identifying requirements for running individual modules.\n\n"
        msg2 = "START: DEFINE AND VALIDATE VARIABLES\n"

        self.l_welcome = tk.Label(self,
                                  fg="white",
                                  background="gray45",
                                  text=msg0 + msg1 + msg2)
        self.l_welcome.grid(sticky=tk.EW,
                            row=0,
                            column=0,
                            rowspan=2,
                            columnspan=3,
                            padx=self.xd,
                            pady=self.yd)

        self.l_version = tk.Label(self, text="Project version: ")
        self.l_version.grid(sticky=tk.W,
                            row=3,
                            column=0,
                            padx=self.xd,
                            pady=self.yd)
        self.e_version = tk.Entry(self,
                                  width=self.w_e,
                                  textvariable=self.version)
        self.e_version.grid(sticky=tk.EW,
                            row=3,
                            column=1,
                            padx=self.xd,
                            pady=self.yd)
        self.l_version_help = tk.Label(
            self, fg="gray26", text="(3-digits: v+INT+INT, example: v10)")
        self.l_version_help.grid(sticky=tk.W,
                                 row=3,
                                 column=2,
                                 padx=self.xd,
                                 pady=self.yd)

        self.l_site_name = tk.Label(self, text="Project name: ")
        self.l_site_name.grid(sticky=tk.W,
                              row=4,
                              column=0,
                              padx=self.xd,
                              pady=self.yd)
        self.e_site_name = tk.Entry(self,
                                    width=self.w_e,
                                    textvariable=self.prj_name)
        self.e_site_name.grid(sticky=tk.EW,
                              row=4,
                              column=1,
                              padx=self.xd,
                              pady=self.yd)
        self.l_site_name_help = tk.Label(
            self, fg="gray26", text="(String, no spaces, example: MySite)")
        self.l_site_name_help.grid(sticky=tk.W,
                                   row=4,
                                   column=2,
                                   padx=self.xd,
                                   pady=self.yd)

        self.b_val_var = tk.Button(self,
                                   text="VALIDATE VARIABLES",
                                   command=lambda: self.verify_variables())
        self.b_val_var.grid(sticky=tk.EW,
                            row=8,
                            column=0,
                            columnspan=3,
                            padx=self.xd,
                            pady=self.yd * 2)

        self.l_placeholder1 = tk.Label(
            self,
            fg="white",
            background="gray45",
            text="ASSESS, DELINEATE AND STABILIZE PLANTINGS")
        self.l_placeholder1.grid(sticky=tk.EW,
                                 row=9,
                                 column=0,
                                 columnspan=3,
                                 padx=self.xd,
                                 pady=self.yd * 2)
        self.l_vege_cr = tk.Label(
            self, text="Do not plant where expected lifespans are less than:")
        self.l_vege_cr.grid(sticky=tk.W,
                            row=10,
                            column=0,
                            padx=self.xd,
                            pady=self.yd)
        self.e_vege_cr = tk.Entry(self,
                                  width=self.w_e,
                                  textvariable=self.vege_cr)
        self.e_vege_cr.grid(sticky=tk.EW,
                            row=10,
                            column=1,
                            padx=self.xd,
                            pady=self.yd)
        self.l_vege_cr_help = tk.Label(
            self, fg="gray26", text=" years (float number, example: 2.5)")
        self.l_vege_cr_help.grid(sticky=tk.W,
                                 row=10,
                                 column=2,
                                 padx=self.xd,
                                 pady=self.yd)
        self.l_vege_stab_cr = tk.Label(
            self,
            text="Stabilize plants where expected lifespans are less than:")
        self.l_vege_stab_cr.grid(sticky=tk.W,
                                 row=11,
                                 column=0,
                                 padx=self.xd,
                                 pady=self.yd)
        self.e_vege_stab_cr = tk.Entry(self,
                                       width=self.w_e,
                                       textvariable=self.vege_stab_cr)
        self.e_vege_stab_cr.grid(sticky=tk.EW,
                                 row=11,
                                 column=1,
                                 padx=self.xd,
                                 pady=self.yd)
        self.l_vege_stab_cr_help = tk.Label(
            self,
            fg="gray26",
            text=" years (should be higher than above value)")
        self.l_vege_stab_cr_help.grid(sticky=tk.W,
                                      row=11,
                                      column=2,
                                      padx=self.xd,
                                      pady=self.yd)
        self.l_condition_pl = tk.Label(
            self, text="Select plant Max Lifespan Condition: ")
        self.l_condition_pl.grid(sticky=tk.W,
                                 row=12,
                                 column=0,
                                 padx=self.xd,
                                 pady=self.yd)
        self.sb_condition_pl = tk.Scrollbar(self, orient=tk.VERTICAL)
        self.sb_condition_pl.grid(sticky=tk.W,
                                  row=12,
                                  column=2,
                                  padx=0,
                                  pady=self.yd)
        self.lb_condition_pl = tk.Listbox(
            self,
            height=3,
            width=self.w_lb,
            yscrollcommand=self.sb_condition_pl.set)
        self.lb_condition_pl.grid(sticky=tk.EW,
                                  row=12,
                                  column=1,
                                  padx=self.xd,
                                  pady=self.yd)
        self.lb_condition_pl.insert(tk.END, "Validate Variables")
        self.sb_condition_pl.config(command=self.lb_condition_pl.yview)
        self.b_s20 = tk.Button(self,
                               text="Place best vegetation plantings",
                               command=lambda: self.start_app("s2X"))
        self.b_s20.grid(sticky=tk.EW,
                        row=13,
                        column=0,
                        columnspan=2,
                        padx=self.xd,
                        pady=self.yd)
        self.b_s20["state"] = "disabled"
        self.b_s20_help = tk.Button(self,
                                    width=14,
                                    fg="blue",
                                    bg="white",
                                    text="Info (help)",
                                    command=lambda: self.help_info("s2X"))
        self.b_s20_help.grid(sticky=tk.E,
                             row=13,
                             column=2,
                             padx=self.xd,
                             pady=self.yd * 2)

        self.l_placeholder2 = tk.Label(self,
                                       fg="white",
                                       background="gray45",
                                       text="TERRAIN STABILIZATION")
        self.l_placeholder2.grid(sticky=tk.EW,
                                 row=14,
                                 column=0,
                                 columnspan=3,
                                 padx=self.xd,
                                 pady=self.yd * 2)
        self.l_ter_cr = tk.Label(self,
                                 text="Target lifespan of surface grains:")
        self.l_ter_cr.grid(sticky=tk.W,
                           row=15,
                           column=0,
                           padx=self.xd,
                           pady=self.yd)
        self.e_ter_cr = tk.Entry(self,
                                 width=self.w_e,
                                 textvariable=self.ter_cr)
        self.e_ter_cr.grid(sticky=tk.EW,
                           row=15,
                           column=1,
                           padx=self.xd,
                           pady=self.yd)
        self.l_ter_cr_help = tk.Label(
            self, fg="gray26", text=" years (float number, example: 2.5)")
        self.l_ter_cr_help.grid(sticky=tk.W,
                                row=15,
                                column=2,
                                padx=self.xd,
                                pady=self.yd)
        self.l_condition_ter = tk.Label(
            self, text="Select nat. eng. MaxLifespan Condition: ")
        self.l_condition_ter.grid(sticky=tk.W,
                                  row=18,
                                  column=0,
                                  padx=self.xd,
                                  pady=self.yd)
        self.sb_condition_ter = tk.Scrollbar(self, orient=tk.VERTICAL)
        self.sb_condition_ter.grid(sticky=tk.W,
                                   row=18,
                                   column=2,
                                   padx=0,
                                   pady=self.yd)
        self.lb_condition_ter = tk.Listbox(
            self,
            height=3,
            width=self.w_lb,
            yscrollcommand=self.sb_condition_ter.set)
        self.lb_condition_ter.grid(sticky=tk.EW,
                                   row=18,
                                   column=1,
                                   padx=self.xd,
                                   pady=self.yd)
        self.lb_condition_ter.insert(tk.END, "Validate Variables")
        self.sb_condition_ter.config(command=self.lb_condition_ter.yview)
        self.b_s30_def = tk.Button(self,
                                   width=14,
                                   bg="white",
                                   text="Set stability drivers",
                                   command=lambda: self.set_stab_vars())
        self.b_s30_def.grid(sticky=tk.E,
                            row=18,
                            column=2,
                            padx=self.xd,
                            pady=self.yd * 2)
        self.b_s30 = tk.Button(self,
                               text="Stabilize terrain",
                               command=lambda: self.start_app("s30"))
        self.b_s30.grid(sticky=tk.EW,
                        row=20,
                        column=0,
                        columnspan=2,
                        padx=self.xd,
                        pady=self.yd)
        self.b_s30["state"] = "disabled"
        self.b_s30_help = tk.Button(self,
                                    width=14,
                                    fg="blue",
                                    bg="white",
                                    text="Info (help)",
                                    command=lambda: self.help_info("s30"))
        self.b_s30_help.grid(sticky=tk.E,
                             row=20,
                             column=2,
                             padx=self.xd,
                             pady=self.yd * 2)

        self.l_placeholder3 = tk.Label(
            self,
            fg="white",
            background="gray45",
            text=" NET GAIN IN SEASONAL HABITAT AREA ")
        self.l_placeholder3.grid(sticky=tk.EW,
                                 row=21,
                                 column=0,
                                 columnspan=3,
                                 padx=self.xd,
                                 pady=self.yd * 2)
        self.l_choose_fish = tk.Label(
            self,
            text=
            "1) Select at least one fish species-lifestage (Physical Habitat)."
        )
        self.l_choose_fish.grid(sticky=tk.W,
                                row=22,
                                column=0,
                                columnspan=2,
                                padx=self.xd,
                                pady=self.yd)
        self.b_show_fish = tk.Button(
            self,
            width=14,
            background="white",
            text="Show selected fish",
            command=lambda: self.help_info("fish_selected"))
        self.b_show_fish.grid(sticky=tk.E,
                              row=22,
                              column=2,
                              padx=self.xd,
                              pady=self.yd)
        self.cb_cover_pre = tk.Checkbutton(
            self,
            text="Optional: Apply cover to pre-project",
            variable=self.cover_app_pre,
            onvalue=True,
            offvalue=False)
        self.cb_cover_pre.grid(sticky=tk.W,
                               row=23,
                               column=0,
                               padx=self.xd,
                               pady=self.yd)
        self.cb_cover_pre.deselect()
        self.cb_cover_post = tk.Checkbutton(
            self,
            text="Optional: Apply cover to post-project",
            variable=self.cover_app_post,
            onvalue=True,
            offvalue=False)
        self.cb_cover_post.grid(sticky=tk.W,
                                row=23,
                                column=1,
                                columnspan=2,
                                padx=self.xd,
                                pady=self.yd)
        self.cb_cover_post.deselect()
        # self.cb_apply_wua = tk.Checkbutton(self, text="Use WUA", variable=self.apply_wua, onvalue=True, offvalue=False)
        # self.cb_apply_wua.grid(sticky=tk.E, row=23, column=2, padx=self.xd, pady=self.yd)
        # self.cb_apply_wua.deselect()
        self.l_condition_i = tk.Label(
            self, text="2) Select pre-project condition (SHArC/SHArea): ")
        self.l_condition_i.grid(sticky=tk.W,
                                row=25,
                                column=0,
                                padx=self.xd,
                                pady=self.yd)
        self.sb_condition_i = tk.Scrollbar(self, orient=tk.VERTICAL)
        self.sb_condition_i.grid(sticky=tk.W,
                                 row=25,
                                 column=2,
                                 padx=0,
                                 pady=self.yd)
        self.lb_condition_i = tk.Listbox(
            self,
            height=3,
            width=self.w_lb,
            yscrollcommand=self.sb_condition_i.set)
        self.lb_condition_i.grid(sticky=tk.EW,
                                 row=25,
                                 column=1,
                                 padx=self.xd,
                                 pady=self.yd)
        self.lb_condition_i.insert(tk.END, "Validate Variables")
        self.sb_condition_i.config(command=self.lb_condition_i.yview)
        self.b_select_c_i = tk.Button(
            self,
            width=14,
            background="white",
            text="Confirm Selection",
            command=lambda: self.select_condition("chsi_initial"))
        self.b_select_c_i.grid(sticky=tk.E,
                               row=25,
                               column=2,
                               padx=self.xd,
                               pady=self.yd)
        self.l_condition_p = tk.Label(
            self, text="3) Select post-project condition (SHArC/SHArea): ")
        self.l_condition_p.grid(sticky=tk.W,
                                row=28,
                                column=0,
                                padx=self.xd,
                                pady=self.yd)
        self.sb_condition_p = tk.Scrollbar(self, orient=tk.VERTICAL)
        self.sb_condition_p.grid(sticky=tk.W,
                                 row=28,
                                 column=2,
                                 padx=0,
                                 pady=self.yd)
        self.lb_condition_p = tk.Listbox(
            self,
            height=3,
            width=self.w_lb,
            yscrollcommand=self.sb_condition_p.set)
        self.lb_condition_p.grid(sticky=tk.EW,
                                 row=28,
                                 column=1,
                                 padx=self.xd,
                                 pady=self.yd)
        self.lb_condition_p.insert(tk.END, "Validate Variables")
        self.sb_condition_p.config(command=self.lb_condition_i.yview)
        self.b_select_c_p = tk.Button(
            self,
            width=14,
            background="white",
            text="Confirm Selection",
            command=lambda: self.select_condition("chsi_project"))
        self.b_select_c_p.grid(sticky=tk.E,
                               row=28,
                               column=2,
                               padx=self.xd,
                               pady=self.yd)
        self.b_s40 = tk.Button(
            self,
            text="Calculate Net gain in Seasonal Habitat Area (SHArea)",
            command=lambda: self.start_app("s40"))
        self.b_s40.grid(sticky=tk.EW,
                        row=30,
                        column=0,
                        columnspan=2,
                        padx=self.xd,
                        pady=self.yd)
        self.b_s40["state"] = "disabled"
        self.b_s40_help = tk.Button(self,
                                    width=14,
                                    fg="blue",
                                    bg="white",
                                    text="Info (help)",
                                    command=lambda: self.help_info("s40"))
        self.b_s40_help.grid(sticky=tk.E,
                             row=23,
                             column=2,
                             padx=self.xd,
                             pady=self.yd)
예제 #16
0
    def create_cutscreen(self, gcodeDir, title):
        tk.Button(master=self, text='Back',
                  command=lambda: self.create_main()).pack(side='top',
                                                           anchor='w')

        self.w = tk.Label(self, text=title, font=("Helvetica", 36))
        self.w.pack()

        tk.Button(master=self,
                  text='Select All',
                  command=lambda: self.select_all()).pack(side='top',
                                                          anchor='center')

        # Loop  through files in given dir and create check boxes
        directory = os.fsencode(gcodeDir)
        self.checkboxes = []
        self.zValues = []
        for file in sorted(os.listdir(directory), key=alphanum_key):
            filename = os.fsdecode(file)
            if filename.endswith(
                    ".gcode"
            ) and "_COMPILED_" not in filename and "000" not in filename:
                fm = tk.Frame(self)
                chkVar = tk.IntVar()
                chkVar.set(0)
                zVar = tk.DoubleVar()
                zVar.set(' 0.000')
                self.zValues.append((zVar, filename))
                self.checkboxes.append((chkVar, filename))
                zLabel = tk.Label(fm,
                                  text=" 0.00",
                                  textvariable=zVar,
                                  font=("Courier", 14))
                self.zLabels.append((zLabel, filename))
                zLabel.pack(side="left", fill="x")
                tk.Checkbutton(fm, text=filename,
                               variable=chkVar).pack(side="left")

                tk.Button(fm,
                          text="+0.01",
                          bg="blue",
                          command=partial(self.changeZindexValue, 0.01,
                                          filename)).pack(side="right")
                tk.Button(fm,
                          text="+0.005",
                          bg="blue",
                          command=partial(self.changeZindexValue, 0.005,
                                          filename)).pack(side="right")
                tk.Button(fm,
                          text="-0.005",
                          bg="green",
                          command=partial(self.changeZindexValue, -0.005,
                                          filename)).pack(side="right")
                tk.Button(fm,
                          text="-0.01",
                          bg="green",
                          command=partial(self.changeZindexValue, -0.01,
                                          filename)).pack(side="right")
                fm.pack(fill="both", expand="yes", side="top")

        tk.Button(master=self,
                  text='Generate GCode',
                  command=lambda: self.generateGcode(gcodeDir, title)).pack(
                      side='top', anchor='center')

        self.quit = tk.Button(self,
                              text="QUIT",
                              fg="red",
                              command=root.destroy)
        self.quit.pack(side="bottom")
예제 #17
0
def main():
    """Главная функция главного модуля.
    Создаёт объекты графического дизайна библиотеки tkinter: окно, холст, фрейм с кнопками, кнопки.
    """
    global physical_time
    global displayed_time
    global time_step
    global time_speed
    global space
    global start_button

    print('Modelling started!')
    physical_time = 0

    root = tkinter.Tk()
    root.title("Kepler's laws of motion")
    window_size = str(window_width) + "x" + str(window_height + 60)
    root.geometry(window_size)
    # космическое пространство отображается на холсте типа Canvas
    space = tkinter.Canvas(root,
                           width=window_width,
                           height=window_height,
                           bg="black")
    space.pack(side=tkinter.TOP)
    # нижняя панель с кнопками
    frame = tkinter.Frame(root)
    frame.pack(side=tkinter.BOTTOM)

    start_button = tkinter.Button(frame,
                                  text="Start",
                                  command=start_execution,
                                  width=6)
    start_button.pack(side=tkinter.LEFT)

    time_step = tkinter.DoubleVar()
    time_step.set(1)
    time_step_entry = tkinter.Entry(frame, textvariable=time_step)
    time_step_entry.pack(side=tkinter.LEFT)

    time_speed = tkinter.DoubleVar()
    scale = tkinter.Scale(frame,
                          variable=time_speed,
                          orient=tkinter.HORIZONTAL)
    scale.pack(side=tkinter.LEFT)

    load_file_button = tkinter.Button(frame,
                                      text="Open file...",
                                      command=open_file_dialog)
    load_file_button.pack(side=tkinter.LEFT)
    save_file_button = tkinter.Button(frame,
                                      text="Save to file...",
                                      command=save_file_dialog)
    save_file_button.pack(side=tkinter.LEFT)
    open_diagram_button = tkinter.Button(frame,
                                         text="View stats",
                                         command=open_diagram)
    open_diagram_button.pack(side=tkinter.LEFT)

    displayed_time = tkinter.StringVar()
    displayed_time.set(str(physical_time) + " seconds gone")
    time_label = tkinter.Label(frame, textvariable=displayed_time, width=30)
    time_label.pack(side=tkinter.RIGHT)

    root.mainloop()
    print('Modelling finished!')
예제 #18
0
    def __init__(self, parent, controller):
        tk.Frame.__init__(self, parent)
        #       #object is label, bg background, fg foreground
        #       #input labels
        ilabel1 = tk.Label(self, text="Exhaust Velocity (m/s)",
                           fg="black").grid(row=4, sticky="e")
        ilabel2 = tk.Label(self, text="Launch Alitutde (m)",
                           fg="black").grid(row=5, sticky="e")
        ilabel3 = tk.Label(self, text="Target Alitutde (m)",
                           fg="black").grid(row=6, sticky="e")
        ilabel4 = tk.Label(self, text="Estimate burn time (s)",
                           fg="black").grid(row=7, sticky="e")
        ilabel5 = tk.Label(self, text="Empty mass target (kg)",
                           fg="black").grid(row=8, sticky="e")
        ilabel6 = tk.Label(self,
                           text="Start nozzle flow rate (kg/s)",
                           fg="black").grid(row=9, sticky="e")

        #       #output labels
        olabel1 = tk.Label(self,
                           text="Specific gravitational potential (kJ)").grid(
                               row=11, sticky="e")
        olabel2 = tk.Label(self, text="Velocity (m/s)").grid(row=12,
                                                             sticky="e")
        olabel3 = tk.Label(self, text="Gravity loss (m/s)").grid(row=13,
                                                                 sticky="e")
        olabel4 = tk.Label(self, text="Drag loss (m/s)").grid(row=14,
                                                              sticky="e")
        olabel5 = tk.Label(self, text="Total velocity (m/s)").grid(row=15,
                                                                   sticky="e")
        olabel6 = tk.Label(self, text="Mass ratio").grid(row=16, sticky="e")
        olabel7 = tk.Label(self, text="Propellant mass (kg)").grid(row=17,
                                                                   sticky="e")
        olabel8 = tk.Label(self, text="Total mass (kg)").grid(row=18,
                                                              sticky="e")
        olabel9 = tk.Label(self,
                           text="Start propellant mass (kg)").grid(row=19,
                                                                   sticky="e")
        olabel10 = tk.Label(self,
                            text="Final vapour mass (kg)").grid(row=20,
                                                                sticky="e")
        olabel11 = tk.Label(self, text="Liquid burn time (s)").grid(row=21,
                                                                    sticky="e")
        global exvel
        global lalt
        global talt
        global tb
        global emt
        global snfr
        exvel = tk.DoubleVar()
        lalt = tk.DoubleVar()
        talt = tk.DoubleVar()
        tb = tk.DoubleVar()
        emt = tk.DoubleVar()
        snfr = tk.DoubleVar()

        self.entry1 = tk.Entry(self, textvariable=exvel)
        self.entry1.grid(row=4, column=1)
        self.entry2 = tk.Entry(self, textvariable=lalt)
        self.entry2.grid(row=5, column=1)
        self.entry3 = tk.Entry(self, textvariable=talt)
        self.entry3.grid(row=6, column=1)
        self.entry4 = tk.Entry(self, textvariable=tb)
        self.entry4.grid(row=7, column=1)
        self.entry5 = tk.Entry(self, textvariable=emt)
        self.entry5.grid(row=8, column=1)
        self.entry6 = tk.Entry(self, textvariable=snfr)
        self.entry6.grid(row=9, column=1)
        button1 = ttk.Button(self,
                             text="Calculate",
                             command=self.initial_estimates1).grid(row=10,
                                                                   column=0)
예제 #19
0
    def populate_portfolio(self):
        '''
        Get all symbol info from Binance needed to
        populate user portfolio data and execute trades
        '''
        self.coins = self.coins_base
        self.portfolio.delete(*self.portfolio.get_children())
        exchange_coins = []
        trade_currency = self.trade_currency
        self.trade_coin = trade_currency

        #update the GUI context
        self.key_label.destroy()
        self.key_entry.destroy()
        self.secret_label.destroy()
        self.secret_entry.destroy()
        self.login.destroy()

        updatetext = tk.StringVar()
        updatetext.set('Initializing')
        self.progresslabel = tk.Label(self.controls_view,
                                      textvariable=updatetext)
        self.progresslabel.grid(row=1,
                                column=0,
                                columnspan=4,
                                sticky=tk.E + tk.W)
        progress_var = tk.DoubleVar()
        progress = 0
        progress_var.set(progress)
        self.progressbar = tkinter.ttk.Progressbar(self.controls_view,
                                                   variable=progress_var,
                                                   maximum=len(self.coins))
        self.progressbar.grid(row=0,
                              column=0,
                              columnspan=4,
                              sticky=tk.E + tk.W)
        for coin in self.coins['coin']:
            self.progressbar.update()
            progress += 1
            progress_var.set(progress)
            updatetext.set('Fetching {0} account information'.format(coin))
            self.progresslabel.update()
            pair = coin + trade_currency
            balance = self.client.get_asset_balance(asset=coin)
            if coin != trade_currency:
                price = float(
                    self.client.get_symbol_ticker(symbol=pair)['price'])
                symbolinfo = self.client.get_symbol_info(
                    symbol=pair)['filters']
                minvalue = float(symbolinfo[3]['minNotional'])
                if self.min_trade_value is not None:
                    minvalue = self.min_trade_value
                row = {
                    'coin': coin,
                    'exchange_balance': float(balance['free']),
                    'locked_balance': float(balance['locked']),
                    'minprice': float(symbolinfo[0]['minPrice']),
                    'maxprice': float(symbolinfo[0]['maxPrice']),
                    'ticksize': float(symbolinfo[0]['tickSize']),
                    'minqty': float(symbolinfo[2]['minQty']),
                    'maxqty': float(symbolinfo[2]['maxQty']),
                    'stepsize': float(symbolinfo[2]['stepSize']),
                    'minnotional': minvalue,
                    'symbol': pair,
                    'askprice': price,
                    'bidprice': price,
                    'price': price,
                    'last_placement': None,
                    'last_execution': None
                }
            else:
                fixed_balance = self.coins.loc[self.coins['coin'] ==
                                               coin]['fixed_balance']
                row = {
                    'coin': coin,
                    'exchange_balance': float(balance['free']),
                    'locked_balance': float(balance['locked']),
                    'minprice': 0,
                    'maxprice': 0,
                    'ticksize': 0,
                    'minqty': 0,
                    'maxqty': 0,
                    'stepsize': 0,
                    'minnotional': 0,
                    'symbol': coin + coin,
                    'askprice': 1.0,
                    'bidprice': 1.0,
                    'price': 1.0,
                    'last_placement': None,
                    'last_execution': None
                }
            exchange_coins.append(row)
        exchange_coins = pd.DataFrame(exchange_coins)
        self.coins = pd.merge(self.coins,
                              exchange_coins,
                              on='coin',
                              how='outer')
        self.coins['value'] = self.coins.apply(
            lambda row: row.price * (row.exchange_balance + row.fixed_balance),
            axis=1)
        self.total = np.sum(self.coins['value'])
        self.coins['actual'] = self.coins.apply(
            lambda row: 100.0 * row.value / self.total, axis=1)
        self.update_status()
        i = 0
        for row in self.coins.itertuples():
            self.portfolio.insert(
                '',
                i,
                iid=row.coin,
                text=row.coin,
                values=(row.fixed_balance, row.exchange_balance,
                        row.locked_balance, '{0} %'.format(row.allocation),
                        '{0:.2f} %'.format(row.actual),
                        round_decimal(row.price, row.ticksize),
                        round_decimal(row.price, row.ticksize), '', ''))
            i += 1
        updatetext.set('Testing connection'.format(coin))
        self.dryrun()
        self.progressbar.destroy()
        self.progresslabel.destroy()

        self.automate = tk.BooleanVar()
        self.automate.set(False)
        self.automate_text = tk.StringVar()
        self.automate_text.set('Start Automation')
        self.toggle_automate = tk.Button(
            self.controls_view,
            textvariable=self.automate_text,
            command=lambda: self.automation(toggle=True))
        self.toggle_automate.grid(row=0,
                                  column=0,
                                  rowspan=2,
                                  columnspan=2,
                                  sticky=tk.E + tk.W + tk.N + tk.S)
        self.sell_button = tk.Button(self.controls_view,
                                     text='Execute Sells',
                                     command=self.execute_sells)
        self.sell_button.grid(row=0,
                              column=2,
                              columnspan=2,
                              sticky=tk.E + tk.W)
        self.buy_button = tk.Button(self.controls_view,
                                    text='Execute Buys',
                                    command=self.execute_buys)
        self.buy_button.grid(row=1, column=2, columnspan=2, sticky=tk.E + tk.W)
예제 #20
0
    def __init__(self, parent, controller):
        tk.Frame.__init__(self, parent)
        #geometry
        ilabel1 = tk.Label(self, text="Geometry", fg="black").grid(row=4,
                                                                   sticky="e")
        ilabel2 = tk.Label(self,
                           text="Injector hole diameter (mm)",
                           fg="black").grid(row=5, sticky="e")
        ilabel3 = tk.Label(
            self,
            text="Oxidiser/Fuel ratio",
            fg="black",
        ).grid(row=6, sticky="e")
        ilabel4 = tk.Label(self,
                           text="Tank pressure - Chamber pressure (Bar)",
                           fg="black").grid(row=7, sticky="e")
        ilabel5 = tk.Label(self, text="Loss coefficient",
                           fg="black").grid(row=8, sticky="e")
        ilabel6 = tk.Label(self,
                           text="Density of oxidiser (kg/m^3)",
                           fg="black").grid(row=9, sticky="e")
        ilabel7 = tk.Label(self,
                           text="Mass flow rate oxidiser (kg/s)",
                           fg="black").grid(row=10, sticky="e")

        #stress
        ilabel9 = tk.Label(self, text="Stress Analysis",
                           fg="black").grid(row=12, sticky="e")
        ilabel10 = tk.Label(self, text="Max pressure drop (Pa)",
                            fg="black").grid(row=13, sticky="e")
        ilabel11 = tk.Label(self, text="Poisson Ratio",
                            fg="black").grid(row=14, sticky="e")
        ilabel12 = tk.Label(self, text="Yield Stress (Pa)",
                            fg="black").grid(row=15, sticky="e")
        ilabel13 = tk.Label(self, text="Radius of injector (m)",
                            fg="black").grid(row=16, sticky="e")
        ilabel14 = tk.Label(self, text="Safety Factor",
                            fg="black").grid(row=17, sticky="e")

        global ihd
        global of
        global tpcp
        global lc
        global doo
        global mfrn
        global mpd
        global Pr
        global Ys
        global roi
        global SF

        ihd = tk.DoubleVar()
        of = tk.DoubleVar()
        tpcp = tk.DoubleVar()
        lc = tk.DoubleVar()
        doo = tk.DoubleVar()
        mfrn = tk.DoubleVar()
        mpd = tk.DoubleVar()
        Pr = tk.DoubleVar()
        Ys = tk.DoubleVar()
        roi = tk.DoubleVar()
        SF = tk.DoubleVar()

        self.entry1 = tk.Entry(self, textvariable=ihd)
        self.entry1.grid(row=5, column=1)
        self.entry2 = tk.Entry(self, textvariable=of)
        self.entry2.grid(row=6, column=1)
        self.entry3 = tk.Entry(self, textvariable=tpcp)
        self.entry3.grid(row=7, column=1)
        self.entry4 = tk.Entry(self, textvariable=lc)
        self.entry4.grid(row=8, column=1)
        self.entry5 = tk.Entry(self, textvariable=doo)
        self.entry5.grid(row=9, column=1)
        self.entry6 = tk.Entry(self, textvariable=mfrn)
        self.entry6.grid(row=10, column=1)
        self.entry7 = tk.Entry(self, textvariable=mpd)
        self.entry7.grid(row=13, column=1)
        self.entry8 = tk.Entry(self, textvariable=Pr)
        self.entry8.grid(row=14, column=1)
        self.entry9 = tk.Entry(self, textvariable=Ys)
        self.entry9.grid(row=15, column=1)
        self.entry10 = tk.Entry(self, textvariable=roi)
        self.entry10.grid(row=16, column=1)
        self.entry11 = tk.Entry(self, textvariable=SF)
        self.entry11.grid(row=17, column=1)

        olabel1 = tk.Label(self, text="Area of orifice (m^2)").grid(row=5,
                                                                    column=2,
                                                                    sticky="e")
        olabel2 = tk.Label(self, text="Number of orificies").grid(row=6,
                                                                  column=2,
                                                                  sticky="e")
        olabel3 = tk.Label(self, text="Thickness (mm)").grid(row=13,
                                                             column=2,
                                                             sticky="e")

        button1 = tk.Button(self, text="Calculate",
                            command=self.injectorcalc1).grid(row=11, column=0)
        button2 = tk.Button(self,
                            text="Calculate",
                            command=self.injectorcalcstress1).grid(row=18,
                                                                   column=0)
예제 #21
0
    def init_gui(self):

        """

        Setups all the parameters (and their values) needed by the GUI.
        
        Includes window size, components, background, and more. 

        Args: 
            
            None


        Returns: 
            
            None


        """

        self.root.title('Arm Solutions')
        self.root.geometry("1200x800")


        self.background_image = Image.open("Flat_colorful_background.png")
        self.background_image = self.background_image.resize((2000,2000), Image.ANTIALIAS)
        self.background_image = ImageTk.PhotoImage(self.background_image)

        self.label = tkinter.Label(self.root, image=self.background_image)

        self.label.image = self.background_image
        self.label.place(x=0,y=0, relwidth=1, relheight=1)

        self.root.grid_columnconfigure(1, weight=1)
        self.root.grid_columnconfigure(0, weight=1)

        self.root.option_add('*tearOff', 'FALSE') # Disables ability to tear menu bar into own window
#
        self.systemStatusLabelText = tkinter.StringVar()

        self.systemStatusLabel = tkinter.Label(textvariable= self.systemStatusLabelText , bg = '#e81a1a', width = 25)


        self.startup_button = tkinter.Button(self.root, text ="Start Up/Resume System", command = self.startSystem, height=3, width= 35, bg = '#499c5f')
        self.pause_button = tkinter.Button(self.root, text ="Put System in Standby", command = self.pauseSystem, height=3, width= 35, bg ='#f9ff54')
        self.settings_button = tkinter.Button(self.root, text ="System Settings", command = self.systemSettings, height=3, width= 35, bg = '#adaaaa')
        self.exit_button = tkinter.Button(self.root, text ="Shut Down System", command = self.on_exit, height=3, width= 35, bg = '#e81a1a')


        self.imageFrame = tkinter.Frame(self.root)
        self.imageFrame.grid(row=0, column=1, padx=10, pady=50, rowspan=4)




        self.startup_button.grid(row=0,column=0, padx=50, pady=(60,100))
        self.pause_button.grid(row=1,column=0, padx=50, pady=(0,100))
        self.settings_button.grid(row=2, column=0, padx=50, pady=(0,100))
        self.exit_button.grid(row=3, column=0, padx=50)
        self.systemStatusLabel.grid(row=3, column=1, pady=10, padx=240)




        self.systemStatusLabel.config(font=("New Times Roman", 20))
        self.startup_button.config(font=("New Times Roman", 16))
        self.pause_button.config(font=("New Times Roman", 16))
        self.settings_button.config(font=("New Times Roman", 16))
        self.exit_button.config(font=("New Times Roman", 16))


        # Menu Bar
        self.menubar = Menubar(self.root)

        # Padding
        for child in self.winfo_children():
            child.grid_configure(padx=10, pady=5)


        self.lmain = tkinter.Label(self.imageFrame)

        #Variables used later on
        self.speed = tkinter.DoubleVar()
        self.systemStatusLabelText.set("System Status - Offline")
예제 #22
0
    def __init__(self, parent, controller):
        tk.Frame.__init__(self, parent)
        #        label1=tk.Label(self,text="Combustion Chamber", font = LARGE_FONT)
        #        label1.grid(row=0,column=0)

        ilabel1 = tk.Label(self,
                           text="Average regression rate (mm/s)",
                           fg="black").grid(row=0, sticky="e")
        ilabel2 = tk.Label(self,
                           text="Vapour average regression rate (mm/s)",
                           fg="black").grid(row=1, sticky="e")
        ilabel3 = tk.Label(
            self,
            text="Density of fuel (kg/m^3)",
            fg="black",
        ).grid(row=2, sticky="e")
        ilabel4 = tk.Label(
            self,
            text="Maximum Flux (kg/s/m^2)",
            fg="black",
        ).grid(row=3, sticky="e")

        global avg_rate
        global vap_avg_rate
        global fuel_density
        global max_flux

        avg_rate = tk.DoubleVar()
        vap_avg_rate = tk.DoubleVar()
        fuel_density = tk.DoubleVar()
        max_flux = tk.DoubleVar()

        self.entry1 = tk.Entry(self, textvariable=avg_rate)
        self.entry1.grid(row=0, column=1)
        self.entry2 = tk.Entry(self, textvariable=vap_avg_rate)
        self.entry2.grid(row=1, column=1)
        self.entry3 = tk.Entry(self, textvariable=fuel_density)
        self.entry3.grid(row=2, column=1)
        self.entry4 = tk.Entry(self, textvariable=max_flux)
        self.entry4.grid(row=3, column=1)

        button1 = tk.Button(self, text="Calculate",
                            command=self.portgeom1).grid(row=4, column=0)

        olabel1 = tk.Label(self, text="Oxidiser mass (kg)").grid(row=5,
                                                                 column=0,
                                                                 sticky="e")
        olabel2 = tk.Label(self, text="Fuel mass (kg)").grid(row=6,
                                                             column=0,
                                                             sticky="e")
        olabel3 = tk.Label(self, text="End flow rate (kg/s)").grid(row=7,
                                                                   column=0,
                                                                   sticky="e")
        olabel4 = tk.Label(self,
                           text="Initial port area (m^2)").grid(row=8,
                                                                column=0,
                                                                sticky="e")
        olabel5 = tk.Label(self,
                           text="Initial port diameter (m)").grid(row=9,
                                                                  column=0,
                                                                  sticky="e")
        olabel6 = tk.Label(self, text="Final liquid port diameter(mm)").grid(
            row=10, column=0, sticky="e")
        olabel7 = tk.Label(self,
                           text="Final port diameter(mm)").grid(row=11,
                                                                column=0,
                                                                sticky="e")
        olabel8 = tk.Label(self,
                           text="Mid burn port diamater (mm)").grid(row=12,
                                                                    column=0,
                                                                    sticky="e")
        olabel9 = tk.Label(self, text="Mid flow rate (kg/s)").grid(row=13,
                                                                   column=0,
                                                                   sticky="e")
        olabel10 = tk.Label(self, text="Grain length (m)").grid(row=14,
                                                                column=0,
                                                                sticky="e")
        olabel11 = tk.Label(self, text="Port length (m)").grid(row=15,
                                                               column=0,
                                                               sticky="e")
예제 #23
0
    def setup_multicolor(self):
        """ initial setup of multicolor options and variables"""
        # Setup the options for multicolor
        multicolormasterframe = tk.Frame(self.tab_configure)
        channel_choices = sorted(list(self.data.keys()))
        rgb = ['red', 'green', 'blue']
        self.multicolorframes = {
            color: tk.Frame(multicolormasterframe, bg=color)
            for color in rgb
        }
        self.multicolorlabels = {
            color: tk.Label(self.multicolorframes[color],
                            text=color,
                            bg=color,
                            width=10)
            for color in rgb
        }
        self.multicolorvars = {color: tk.StringVar() for color in rgb}
        self.multicolorpower = {color: tk.DoubleVar() for color in rgb}
        self.multicolormin = {color: tk.DoubleVar() for color in rgb}
        self.multicolormax = {color: tk.DoubleVar() for color in rgb}

        self.multicolordropdowns = {
            color: tk.OptionMenu(self.multicolorframes[color],
                                 self.multicolorvars[color], *channel_choices)
            for color in rgb
        }

        self.multicolorscales = {
            color: tk.Scale(
                self.multicolorframes[color],
                variable=self.multicolorpower[color],
                orient=tk.HORIZONTAL,
                from_=self.config.ranges['multi_color_power_min'],
                to_=self.config.ranges['multi_color_power_max'],
                bg=color,
                resolution=self.config.ranges['multi_color_power_resolution'],
                length=200)
            for color in rgb
        }
        self.multicolorminscale = {
            color:
            tk.Scale(self.multicolorframes[color],
                     variable=self.multicolormin[color],
                     orient=tk.HORIZONTAL,
                     from_=0,
                     to_=self.config.ranges['multi_color_vmin'],
                     bg=color,
                     resolution=self.config.ranges['multi_color_vresolution'],
                     length=200)
            for color in rgb
        }
        self.multicolormaxscale = {
            color:
            tk.Scale(self.multicolorframes[color],
                     variable=self.multicolormax[color],
                     orient=tk.HORIZONTAL,
                     from_=self.config.ranges['multi_color_vmax'],
                     to_=100,
                     bg=color,
                     resolution=self.config.ranges['multi_color_vresolution'],
                     length=200)
            for color in rgb
        }

        for color in rgb:
            self.multicolorvars[color].set(
                self.config.products_map[self.config.default[color]])
            self.multicolorpower[color].set(self.config.default[color +
                                                                "_power"])

            self.multicolormin[color].set(0)
            self.multicolormax[color].set(100)
            self.multicolordropdowns[color].config(bg=color, width=10)
            self.multicolorlabels[color].pack(side=tk.LEFT)

            self.multicolorscales[color].pack(side=tk.RIGHT)
            self.multicolormaxscale[color].pack(side=tk.RIGHT)
            self.multicolorminscale[color].pack(side=tk.RIGHT)
            self.multicolordropdowns[color].pack()
            self.multicolorframes[color].pack(fill=tk.BOTH)
        multicolormasterframe.grid(row=1, column=0, columnspan=5, rowspan=3)
    #===========================================================================
    popup.protocol("WM_DELETE_WINDOW", on_closing)
    popup.bind('<Escape>', lambda e: popup.destroy())

    #===========================================================================
    # Label text
    #===========================================================================
    plabletextstr = StringVar()
    plabletextstr.set("")
    tk.Label(popup, textvariable=plabletextstr).grid(row=0, column=0)

    #===========================================================================
    # Progress bar
    #===========================================================================
    progress = 0
    progress_var = tk.DoubleVar()
    progress_bar = ttk.Progressbar(popup,
                                   variable=progress_var,
                                   length=490,
                                   maximum=100)
    progress_bar.grid(row=1,
                      column=0)  #.pack(fill=tk.X, expand=1, side=tk.BOTTOM)
    progress_bar.place(x=5, y=25)
    popup.pack_slaves()

    #===========================================================================
    # Read number of line 'data_generated.txt'
    #===========================================================================
    num_data_generated_lines = 0
    num_data_generated_lines = sum(
        1 for line in open(progress_bar_result_file_path))
    def createWidgets(self):
        # Tab Control introduced here --------------------------------------
        tabControl = ttk.Notebook(self.win)  # Create Tab Control

        tab1 = ttk.Frame(tabControl)  # Create a tab
        tabControl.add(tab1, text='Tab 1')  # Add the tab

        tab2 = ttk.Frame(tabControl)  # Add a second tab
        tabControl.add(tab2, text='Tab 2')  # Make second tab visible

        tabControl.pack(expand=1, fill="both")  # Pack to make visible
        # ~ Tab Control introduced here -----------------------------------------

        # We are creating a container frame to hold all other widgets
        self.monty = ttk.LabelFrame(tab1, text=' Mighty Python ')
        self.monty.grid(column=0, row=0, padx=8, pady=4)

        # Changing our Label
        ttk.Label(self.monty, text="Enter a name:").grid(column=0,
                                                         row=0,
                                                         sticky='W')

        # Adding a Textbox Entry widget
        self.name = tk.StringVar()
        nameEntered = ttk.Entry(self.monty, width=12, textvariable=self.name)
        nameEntered.grid(column=0, row=1, sticky='W')

        # Adding a Button
        self.action = ttk.Button(self.monty,
                                 text="Click Me!",
                                 command=self.clickMe)
        self.action.grid(column=2, row=1)

        ttk.Label(self.monty, text="Choose a number:").grid(column=1, row=0)
        number = tk.StringVar()
        numberChosen = ttk.Combobox(self.monty, width=12, textvariable=number)
        numberChosen['values'] = (1, 2, 4, 42, 100)
        numberChosen.grid(column=1, row=1)
        numberChosen.current(0)

        # Adding a Spinbox widget using a set of values
        self.spin = Spinbox(self.monty,
                            values=(1, 2, 4, 42, 100),
                            width=5,
                            bd=8,
                            command=self._spin)
        self.spin.grid(column=0, row=2)

        # Using a scrolled Text control
        scrolW = 30
        scrolH = 3
        self.scr = scrolledtext.ScrolledText(self.monty,
                                             width=scrolW,
                                             height=scrolH,
                                             wrap=tk.WORD)
        self.scr.grid(column=0, row=3, sticky='WE', columnspan=3)

        #-------------------------------------------------------------------------
        # Adding another Button
        self.action = ttk.Button(self.monty,
                                 text="Clear Text",
                                 command=self.clearScrol)
        self.action.grid(column=2, row=2)

        # Adding more Feature Buttons
        for idx in range(3):
            b = ttk.Button(self.monty, text="Feature" + str(idx + 1))
            b.grid(column=idx, row=4)

        ###########################
        # Tab Control 2 refactoring  -----------------------------------------
        # We are creating a container frame to hold all other widgets -- Tab2
        self.monty2 = ttk.LabelFrame(tab2, text=' Holy Grail ')
        self.monty2.grid(column=0, row=0, padx=8, pady=4)
        # Creating three checkbuttons
        chVarDis = tk.IntVar()
        check1 = tk.Checkbutton(self.monty2,
                                text="Disabled",
                                variable=chVarDis,
                                state='disabled')
        check1.select()
        check1.grid(column=0, row=0, sticky=tk.W)

        self.chVarUn = tk.IntVar()
        self.check2 = tk.Checkbutton(self.monty2,
                                     text="UnChecked",
                                     variable=self.chVarUn)
        self.check2.deselect()
        self.check2.grid(column=1, row=0, sticky=tk.W)

        self.chVarEn = tk.IntVar()
        self.check3 = tk.Checkbutton(self.monty2,
                                     text="Toggle",
                                     variable=self.chVarEn)
        self.check3.deselect()
        self.check3.grid(column=2, row=0, sticky=tk.W)

        # trace the state of the two checkbuttons
        self.chVarUn.trace(
            'w', lambda unused0, unused1, unused2: self.checkCallback())
        self.chVarEn.trace(
            'w', lambda unused0, unused1, unused2: self.checkCallback())
        # ~ Tab Control 2 refactoring  -----------------------------------------

        # Radiobutton list
        colors = ["Blue", "Gold", "Red"]

        self.radVar = tk.IntVar()

        # Selecting a non-existing index value for radVar
        self.radVar.set(99)

        # Creating all three Radiobutton widgets within one loop
        for col in range(3):
            curRad = 'rad' + str(col)
            curRad = tk.Radiobutton(self.monty2,
                                    text=colors[col],
                                    variable=self.radVar,
                                    value=col,
                                    command=self.radCall)
            curRad.grid(column=col, row=6, sticky=tk.W, columnspan=3)
            # And now adding tooltips
            ToolTip(curRad, 'This is a Radiobutton control.')

        # Create a container to hold labels
        labelsFrame = ttk.LabelFrame(self.monty2, text=' Labels in a Frame ')
        labelsFrame.grid(column=0, row=7)

        # Place labels into the container element - vertically
        ttk.Label(labelsFrame, text="Label1").grid(column=0, row=0)
        ttk.Label(labelsFrame, text="Label2").grid(column=0, row=1)

        # Add some space around each label
        for child in labelsFrame.winfo_children():
            child.grid_configure(padx=8)

        # Creating a Menu Bar
        menuBar = Menu(tab1)
        self.win.config(menu=menuBar)

        # Add menu items
        fileMenu = Menu(menuBar, tearoff=0)
        fileMenu.add_command(label="New")
        fileMenu.add_separator()
        fileMenu.add_command(label="Exit", command=self._quit)
        menuBar.add_cascade(label="File", menu=fileMenu)

        # Add another Menu to the Menu Bar and an item
        helpMenu = Menu(menuBar, tearoff=0)
        helpMenu.add_command(label="About")
        menuBar.add_cascade(label="Help", menu=helpMenu)

        # Change the main windows icon
        self.win.iconbitmap('pyc.ico')

        # Using tkinter Variable Classes
        strData = tk.StringVar()
        strData.set('Hello StringVar')
        print(strData.get())

        # Default tkinter Variable Classes
        intData = tk.IntVar()
        print(intData.get())
        print(tk.DoubleVar())
        print(tk.BooleanVar())

        # It is not necessary to create a tk.StringVar()
        strData = tk.StringVar()
        strData = self.spin.get()
        print("Hello " + strData)

        # Printing the Global works
        print(GLOBAL_CONST)

        # call method
        self.usingGlobal()

        # Place cursor into name Entry
        nameEntered.focus()

        # Add a Tooltip to the Spinbox
        ToolTip(self.spin, 'This is a Spin control.')

        # Add Tooltips to more widgets
        ToolTip(nameEntered, 'This is an Entry control.')
        ToolTip(self.action, 'This is a Button control.')
        ToolTip(self.scr, 'This is a ScrolledText control.')
예제 #26
0
    def __init__(self):
        tk.Toplevel.__init__(self)
        self.title('Data Augmentation')
        self.layout = {
            'global': {
                'start': {
                    'x': 15,
                    'y': 20
                },
                'space': {
                    'x': 15,
                    'y': 25
                },
                'tiny_space': {
                    'x': 5,
                    'y': 10
                }
            }
        }
        self.data_augmentation_entity = None
        self.window_width = 750
        self.window_height = 220

        self.layout_utils = LayoutGUI(self.layout, self.window_width)
        screenwidth = self.winfo_screenwidth()
        screenheight = self.winfo_screenheight()
        size = '%dx%d+%d+%d' % (self.window_width, self.window_height,
                                (screenwidth - self.window_width) / 2,
                                (screenheight - self.window_height) / 2)
        self.geometry(size)
        # ============================= Group 4 =====================================
        self.label_frame_augmentation = ttk.Labelframe(
            self, text='Data Augmentation')
        self.label_frame_augmentation.place(
            x=self.layout['global']['start']['x'],
            y=self.layout['global']['start']['y'],
            width=725,
            height=150)

        # 二值化 - 标签
        self.binaryzation_text = ttk.Label(self,
                                           text='Binaryzation',
                                           anchor=tk.W)
        self.layout_utils.inside_widget(
            src=self.binaryzation_text,
            target=self.label_frame_augmentation,
            width=72,
            height=20,
        )

        # 二值化 - 输入框
        self.binaryzation_val = tk.StringVar()
        self.binaryzation_val.set(-1)
        self.binaryzation_entry = ttk.Entry(self,
                                            textvariable=self.binaryzation_val,
                                            justify=tk.LEFT)
        self.layout_utils.next_to_widget(src=self.binaryzation_entry,
                                         target=self.binaryzation_text,
                                         width=55,
                                         height=20,
                                         tiny_space=True)

        # 滤波 - 标签
        self.median_blur_text = ttk.Label(self,
                                          text='Median Blur',
                                          anchor=tk.W)
        self.layout_utils.next_to_widget(src=self.median_blur_text,
                                         target=self.binaryzation_entry,
                                         width=80,
                                         height=20,
                                         tiny_space=False)

        # 滤波 - 输入框
        self.median_blur_val = tk.IntVar()
        self.median_blur_val.set(-1)
        self.median_blur_entry = ttk.Entry(self,
                                           textvariable=self.median_blur_val,
                                           justify=tk.LEFT)
        self.layout_utils.next_to_widget(src=self.median_blur_entry,
                                         target=self.median_blur_text,
                                         width=52,
                                         height=20,
                                         tiny_space=True)

        # 高斯模糊 - 标签
        self.gaussian_blur_text = ttk.Label(self,
                                            text='Gaussian Blur',
                                            anchor=tk.W)
        self.layout_utils.next_to_widget(src=self.gaussian_blur_text,
                                         target=self.median_blur_entry,
                                         width=85,
                                         height=20,
                                         tiny_space=False)

        # 高斯模糊 - 输入框
        self.gaussian_blur_val = tk.IntVar()
        self.gaussian_blur_val.set(-1)
        self.gaussian_blur_entry = ttk.Entry(
            self, textvariable=self.gaussian_blur_val, justify=tk.LEFT)
        self.layout_utils.next_to_widget(src=self.gaussian_blur_entry,
                                         target=self.gaussian_blur_text,
                                         width=62,
                                         height=20,
                                         tiny_space=True)

        # 椒盐噪声 - 标签
        self.sp_noise_text = ttk.Label(self,
                                       text='Pepper Noise (0-1)',
                                       anchor=tk.W)
        self.layout_utils.next_to_widget(src=self.sp_noise_text,
                                         target=self.gaussian_blur_entry,
                                         width=110,
                                         height=20,
                                         tiny_space=False)

        # 椒盐噪声 - 输入框
        self.sp_noise_val = tk.DoubleVar()
        self.sp_noise_val.set(-1)
        self.sp_noise_entry = ttk.Entry(self,
                                        textvariable=self.sp_noise_val,
                                        justify=tk.LEFT)
        self.layout_utils.next_to_widget(src=self.sp_noise_entry,
                                         target=self.sp_noise_text,
                                         width=71,
                                         height=20,
                                         tiny_space=True)

        # 旋转 - 标签
        self.rotate_text = ttk.Label(self, text='Rotate (0-90)', anchor=tk.W)
        self.layout_utils.below_widget(src=self.rotate_text,
                                       target=self.binaryzation_text,
                                       width=72,
                                       height=20,
                                       tiny_space=True)

        # 旋转 - 输入框
        self.rotate_val = tk.IntVar()
        self.rotate_val.set(-1)
        self.rotate_entry = ttk.Entry(self,
                                      textvariable=self.rotate_val,
                                      justify=tk.LEFT)
        self.layout_utils.next_to_widget(src=self.rotate_entry,
                                         target=self.rotate_text,
                                         width=55,
                                         height=20,
                                         tiny_space=True)

        # 随机空白边缘 - 标签
        self.random_blank_text = ttk.Label(self,
                                           text='Blank Border',
                                           anchor=tk.W)
        self.layout_utils.next_to_widget(src=self.random_blank_text,
                                         target=self.rotate_entry,
                                         width=72,
                                         height=20,
                                         tiny_space=False)

        # 随机空白边缘 - 输入框
        self.random_blank_val = tk.IntVar()
        self.random_blank_val.set(-1)
        self.random_blank_entry = ttk.Entry(self,
                                            textvariable=self.random_blank_val,
                                            justify=tk.LEFT)
        self.layout_utils.next_to_widget(src=self.random_blank_entry,
                                         target=self.random_blank_text,
                                         width=55,
                                         height=20,
                                         tiny_space=True)

        # 随机边缘位移 - 标签
        self.random_transition_text = ttk.Label(self,
                                                text='Transition',
                                                anchor=tk.W)
        self.layout_utils.next_to_widget(src=self.random_transition_text,
                                         target=self.random_blank_entry,
                                         width=60,
                                         height=20,
                                         tiny_space=False)

        # 随机边缘位移 - 输入框
        self.random_transition_val = tk.IntVar()
        self.random_transition_val.set(-1)
        self.random_transition_entry = ttk.Entry(
            self, textvariable=self.random_transition_val, justify=tk.LEFT)
        self.layout_utils.next_to_widget(src=self.random_transition_entry,
                                         target=self.random_transition_text,
                                         width=55,
                                         height=20,
                                         tiny_space=True)

        # 透视变换 - 多选框
        self.warp_perspective_val = tk.IntVar()
        self.warp_perspective_val.set(0)
        self.warp_perspective = ttk.Checkbutton(
            self,
            text='Distortion',
            variable=self.warp_perspective_val,
            onvalue=1,
            offvalue=0)
        self.layout_utils.below_widget(src=self.warp_perspective,
                                       target=self.rotate_text,
                                       width=80,
                                       height=20,
                                       tiny_space=False)

        # 直方图均衡化 - 多选框
        self.equalize_hist_val = tk.IntVar()
        self.equalize_hist_val.set(0)
        self.equalize_hist = ttk.Checkbutton(self,
                                             text='EqualizeHist',
                                             variable=self.equalize_hist_val,
                                             offvalue=0)
        self.layout_utils.next_to_widget(src=self.equalize_hist,
                                         target=self.warp_perspective,
                                         width=100,
                                         height=20,
                                         tiny_space=True)

        # 拉普拉斯 - 多选框
        self.laplace_val = tk.IntVar()
        self.laplace_val.set(0)
        self.laplace = ttk.Checkbutton(self,
                                       text='Laplace',
                                       variable=self.laplace_val,
                                       onvalue=1,
                                       offvalue=0)
        self.layout_utils.next_to_widget(src=self.laplace,
                                         target=self.equalize_hist,
                                         width=64,
                                         height=20,
                                         tiny_space=True)

        # 随机亮度 - 多选框
        self.brightness_val = tk.IntVar()
        self.brightness_val.set(0)
        self.brightness = ttk.Checkbutton(self,
                                          text='Brightness',
                                          variable=self.brightness_val,
                                          offvalue=0)
        self.layout_utils.next_to_widget(src=self.brightness,
                                         target=self.laplace,
                                         width=80,
                                         height=20,
                                         tiny_space=True)

        # 随机饱和度 - 多选框
        self.saturation_val = tk.IntVar()
        self.saturation_val.set(0)
        self.saturation = ttk.Checkbutton(self,
                                          text='Saturation',
                                          variable=self.saturation_val,
                                          offvalue=0)
        self.layout_utils.next_to_widget(src=self.saturation,
                                         target=self.brightness,
                                         width=80,
                                         height=20,
                                         tiny_space=True)

        # 随机色相 - 多选框
        self.hue_val = tk.IntVar()
        self.hue_val.set(0)
        self.hue = ttk.Checkbutton(self,
                                   text='Hue',
                                   variable=self.hue_val,
                                   offvalue=0)
        self.layout_utils.next_to_widget(src=self.hue,
                                         target=self.saturation,
                                         width=50,
                                         height=20,
                                         tiny_space=True)

        # 随机Gamma - 多选框
        self.gamma_val = tk.IntVar()
        self.gamma_val.set(0)
        self.gamma = ttk.Checkbutton(self,
                                     text='Gamma',
                                     variable=self.gamma_val,
                                     offvalue=0)
        self.layout_utils.next_to_widget(src=self.gamma,
                                         target=self.hue,
                                         width=80,
                                         height=20,
                                         tiny_space=True)

        # 随机通道 - 多选框
        self.channel_swap_val = tk.IntVar()
        self.channel_swap_val.set(0)
        self.channel_swap = ttk.Checkbutton(self,
                                            text='Channel Swap',
                                            variable=self.channel_swap_val,
                                            offvalue=0)
        self.layout_utils.next_to_widget(src=self.channel_swap,
                                         target=self.gamma,
                                         width=100,
                                         height=20,
                                         tiny_space=True)

        # 保存 - 按钮
        self.btn_save = ttk.Button(self,
                                   text='Save Configuration',
                                   command=lambda: self.save_conf())
        self.layout_utils.widget_from_right(
            src=self.btn_save,
            target=self.label_frame_augmentation,
            width=120,
            height=24,
            tiny_space=True)
예제 #27
0
    def create_widgets(self):
        '''
        Widget描画用処理
        '''
        #ラベルの描画
        #ラベル表示するテキストを設定 font(フォント名/サイズ/太文字),fg:文字色,bg:背景色
        self.label1 = tk.Label(self,text='Recipe Generation',font=("Helvetica", 20, "bold"),fg = "orange",bg = "white")
        self.label1.grid(row=0,column =0,sticky=tk.W)

        #キャンバスの描画 (Opencvで読み込んだ画像の表示)
        image_bgr = cv2.imread("online_kitchen.png")
        image_bgr = cv2.resize(image_bgr,(100,100))            # opencv画像をresize
        image_rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB) # imreadはBGRなのでRGBに変換
        image_pil = Image.fromarray(image_rgb)                 # RGBをPILフォーマットに変換
        self.image_tk  = ImageTk.PhotoImage(image_pil)         # ImageTkフォーマットへ変換
        self.canvas = tk.Canvas(self, bg="grey", width=image_bgr.shape[0], height=image_bgr.shape[1])
        self.canvas.create_image(0, 0, image=self.image_tk, anchor='nw') # ImageTk 画像配置
        self.canvas.grid(row=1,column =0,columnspan=2,sticky=tk.W)

        #ボタンの描画
        self.button1 = tk.Button(self,text="Hello World",bg='#f0e68c',command=self.func_callback_button) #ボタン文字列・コールバック関数の設定
        self.button1.grid(row=2,column =0,sticky=tk.W)
        ##http://infohost.nmt.edu/tcc/help/pubs/tkinter/web/anchors.html

        # #テキストボックスの描画
        # self.textbox1 = tk.Entry(self,width=20)
        # self.textbox1.insert(tk.END,"default") #テキストボックス初期文字列の設定
        # self.textbox1.grid(row=3,column =0,sticky=tk.W)

        #チェックボタンの描画
        # self.chval = tk.BooleanVar(False) #チェックボタン初期値設定
        # self.chbox1 = tk.Checkbutton(self, text = 'check1', variable = self.chval) #チェックボタンテキスト/変数紐づけ設定
        # self.chbox1.grid(row=4,column =0,sticky=tk.W)

        #ラジオボタンの描画 (択一式)
        # self.radval = tk.IntVar(0)  #ラジオボタンテキスト/変数紐づけ設定
        # self.radbut1 = tk.Radiobutton(self, text = 'radio0', variable = self.radval, value = 0) #ラジオボタンテキスト/変数紐づけ設定
        # self.radbut1.grid(row=5,column =0,sticky=tk.W)
        # self.radbut2 = tk.Radiobutton(self, text = 'radio1', variable = self.radval, value = 1) #ラジオボタンテキスト/変数紐づけ設定
        # self.radbut2.grid(row=5,column =1,sticky=tk.W)

        # ラベル表示するテキストを設定 font(フォント名/サイズ/太文字),fg:文字色,bg:背景色
        self.label2 = tk.Label(self, text='甘味', font=("Helvetica", 10, "normal"), fg="black", bg="white")
        self.label2.grid(row=3, column=0, sticky=tk.W)

        #シークバーの表示
        self.seekbarval1 = tk.DoubleVar() #シークバー変数設定
        self.seekbarval1.trace("w", self.func_callback_seekbar) #シークバー変数変動時コールバック関数設定
        self.sc = ttk.Scale(self,variable=self.seekbarval1,orient=tk.HORIZONTAL,from_=0,to=255)  #シークバー描画
        self.sc.grid(row=4, column=0,columnspan=2, sticky=(tk.N,tk.E,tk.S,tk.W))

        # ラベル表示するテキストを設定 font(フォント名/サイズ/太文字),fg:文字色,bg:背景色
        self.label3 = tk.Label(self, text='塩味', font=("Helvetica", 10, "normal"), fg="black", bg="white")
        self.label3.grid(row=5, column=0, sticky=tk.W)

        # シークバーの表示
        self.seekbarval2 = tk.DoubleVar()  # シークバー変数設定
        self.seekbarval2.trace("w", self.func_callback_seekbar)  # シークバー変数変動時コールバック関数設定
        self.sc = ttk.Scale(self, variable=self.seekbarval2, orient=tk.HORIZONTAL, from_=0, to=255)  # シークバー描画
        self.sc.grid(row=6, column=0, columnspan=2, sticky=(tk.N, tk.E, tk.S, tk.W))

        # ラベル表示するテキストを設定 font(フォント名/サイズ/太文字),fg:文字色,bg:背景色
        self.label4 = tk.Label(self, text='酸味', font=("Helvetica", 10, "normal"), fg="black", bg="white")
        self.label4.grid(row=7, column=0, sticky=tk.W)

        # シークバーの表示
        self.seekbarval3 = tk.DoubleVar()  # シークバー変数設定
        self.seekbarval3.trace("w", self.func_callback_seekbar)  # シークバー変数変動時コールバック関数設定
        self.sc = ttk.Scale(self, variable=self.seekbarval3, orient=tk.HORIZONTAL, from_=0, to=255)  # シークバー描画
        self.sc.grid(row=8, column=0, columnspan=2, sticky=(tk.N, tk.E, tk.S, tk.W))

        # ラベル表示するテキストを設定 font(フォント名/サイズ/太文字),fg:文字色,bg:背景色
        self.label5 = tk.Label(self, text='苦味', font=("Helvetica", 10, "normal"), fg="black", bg="white")
        self.label5.grid(row=9, column=0, sticky=tk.W)

        # シークバーの表示
        self.seekbarval4 = tk.DoubleVar()  # シークバー変数設定
        self.seekbarval4.trace("w", self.func_callback_seekbar)  # シークバー変数変動時コールバック関数設定
        self.sc = ttk.Scale(self, variable=self.seekbarval4, orient=tk.HORIZONTAL, from_=0, to=255)  # シークバー描画
        self.sc.grid(row=10, column=0, columnspan=2, sticky=(tk.N, tk.E, tk.S, tk.W))

        # ラベル表示するテキストを設定 font(フォント名/サイズ/太文字),fg:文字色,bg:背景色
        self.label6 = tk.Label(self, text='旨味', font=("Helvetica", 10, "normal"), fg="black", bg="white")
        self.label6.grid(row=11, column=0, sticky=tk.W)

        # シークバーの表示
        self.seekbarval5 = tk.DoubleVar()  # シークバー変数設定
        self.seekbarval5.trace("w", self.func_callback_seekbar)  # シークバー変数変動時コールバック関数設定
        self.sc = ttk.Scale(self, variable=self.seekbarval5, orient=tk.HORIZONTAL, from_=0, to=255)  # シークバー描画
        self.sc.grid(row=12, column=0, columnspan=2, sticky=(tk.N, tk.E, tk.S, tk.W))
예제 #28
0
    def __init__(self, parent, fields, settings, callbacks, *args, **kwargs):
        super().__init__(parent, *args, **kwargs)
        self.settings = settings
        self.callbacks = callbacks

        # New for ch7
        self.current_record = None

        # A dict to keep track of input widgets
        self.inputs = {}

        # Build the form
        self.record_label = ttk.Label()
        self.record_label.grid(row=0, column=0)

        # recordinfo section
        recordinfo = tk.LabelFrame(self, text="Record Information")

        # line 1
        self.inputs['Date'] = w.LabelInput(
            recordinfo, "Date",
            field_spec=fields['Date']
        )
        self.inputs['Date'].grid(row=0, column=0)
        self.inputs['Time'] = w.LabelInput(
            recordinfo, "Time",
            field_spec=fields['Time']
        )
        self.inputs['Time'].grid(row=0, column=1)
        self.inputs['Technician'] = w.LabelInput(
            recordinfo, "Technician",
            field_spec=fields['Technician']
        )
        self.inputs['Technician'].grid(row=0, column=2)

        # line 2
        self.inputs['Lab'] = w.LabelInput(
            recordinfo, "Lab",
            field_spec=fields['Lab']
        )
        self.inputs['Lab'].grid(row=1, column=0)
        self.inputs['Plot'] = w.LabelInput(
            recordinfo, "Plot",
            field_spec=fields['Plot']
        )
        self.inputs['Plot'].grid(row=1, column=1)
        self.inputs['Seed sample'] = w.LabelInput(
            recordinfo, "Seed sample",
            field_spec=fields['Seed sample']
        )
        self.inputs['Seed sample'].grid(row=1, column=2)

        recordinfo.grid(row=1, column=0, sticky="we")

        # Environment Data
        environmentinfo = tk.LabelFrame(self, text="Environment Data")
        self.inputs['Humidity'] = w.LabelInput(
            environmentinfo, "Humidity (g/m³)",
            field_spec=fields['Humidity']
        )
        self.inputs['Humidity'].grid(row=0, column=0)
        self.inputs['Light'] = w.LabelInput(
            environmentinfo, "Light (klx)",
            field_spec=fields['Light']
        )
        self.inputs['Light'].grid(row=0, column=1)
        self.inputs['Temperature'] = w.LabelInput(
            environmentinfo, "Temperature (°C)",
            field_spec=fields['Temperature']
        )
        self.inputs['Temperature'].grid(row=0, column=2)
        self.inputs['Equipment Fault'] = w.LabelInput(
            environmentinfo, "Equipment Fault",
            field_spec=fields['Equipment Fault']
        )
        self.inputs['Equipment Fault'].grid(row=1, column=0, columnspan=3)
        environmentinfo.grid(row=2, column=0, sticky="we")

        # Plant Data section
        plantinfo = tk.LabelFrame(self, text="Plant Data")

        self.inputs['Plants'] = w.LabelInput(
            plantinfo, "Plants",
            field_spec=fields['Plants']
        )
        self.inputs['Plants'].grid(row=0, column=0)
        self.inputs['Blossoms'] = w.LabelInput(
            plantinfo, "Blossoms",
            field_spec=fields['Blossoms']
        )
        self.inputs['Blossoms'].grid(row=0, column=1)
        self.inputs['Fruit'] = w.LabelInput(
            plantinfo, "Fruit",
            field_spec=fields['Fruit']
        )
        self.inputs['Fruit'].grid(row=0, column=2)
        # Height data
        # create variables to be updated for min/max height
        # they can be referenced for min/max variables
        min_height_var = tk.DoubleVar(value='-infinity')
        max_height_var = tk.DoubleVar(value='infinity')

        self.inputs['Min Height'] = w.LabelInput(
            plantinfo, "Min Height (cm)",
            field_spec=fields['Min Height'],
            input_args={"max_var": max_height_var,
                        "focus_update_var": min_height_var}
        )
        self.inputs['Min Height'].grid(row=1, column=0)
        self.inputs['Max Height'] = w.LabelInput(
            plantinfo, "Max Height (cm)",
            field_spec=fields['Max Height'],
            input_args={"min_var": min_height_var,
                        "focus_update_var": max_height_var}
        )
        self.inputs['Max Height'].grid(row=1, column=1)
        self.inputs['Median Height'] = w.LabelInput(
            plantinfo, "Median Height (cm)",
            field_spec=fields['Median Height'],
            input_args={"min_var": min_height_var,
                        "max_var": max_height_var}
        )
        self.inputs['Median Height'].grid(row=1, column=2)

        plantinfo.grid(row=3, column=0, sticky="we")

        # Notes section
        self.inputs['Notes'] = w.LabelInput(
            self, "Notes",
            field_spec=fields['Notes'],
            input_args={"width": 75, "height": 10}
        )
        self.inputs['Notes'].grid(sticky="w", row=4, column=0)

        # The save button
        self.savebutton = ttk.Button(
            self,
            text="Save",
            command=self.callbacks["on_save"])
        self.savebutton.grid(sticky="e", row=5, padx=10)


        # default the form
        self.reset()
예제 #29
0
    def __init__(self, reference):
        super(Central, self).__init__()
        # Saving reference to gui
        self.reference = reference

        # Setting up widgets
        self.grid_columnconfigure(0, weight=1)
        w = reference.width
        h = reference.height
        self.devices = tk.StringVar(self)
        self.connection_state = tk.StringVar(self)
        self.connection_state.set("Inactive")
        self.b1t = tk.StringVar(self)
        self.b1t.set("Connect")
        self.b2t = tk.StringVar(self)
        self.b2t.set("Upload")
        self.mode = tk.StringVar(self)
        self.mode.set("AOO")
        self.l8t = tk.StringVar(self)
        self.l8t.set("Atrium")
        self.devices_list = []
        self.devices_text = ['a']
        print(self.devices_list)
        self.f1 = tk.Frame(self, height=reference.height, width=250, bg="grey").place(x=0, y=0)
        self.l1 = tk.Label(self, text="Pacemaker Menu").place(x=75, y=10)
        self.l2 = tk.Label(self, text="Devices").place(x=15, y=44)

        self.o1 = tk.OptionMenu(self, self.devices, *self.devices_text)
        self.devices_refresh()

        self.o1.place(anchor=tk.NE, x=235, y=40)
        self.b1 = tk.Button(self, textvariable=self.b1t, command=self.device_button, state=tk.DISABLED, width=30)
        self.b1.place(x=15, y=80)
        self.devices.trace('w', self.device_select)
        self.l3 = tk.Label(self, text="Connection Status").place(x=15, y=120)
        self.l4 = tk.Label(self, textvariable=self.connection_state).place(anchor=tk.NE, x=235, y=120)
        self.b2 = tk.Button(self, textvariable=self.b2t, command=self.device_upload, state=tk.DISABLED, width=30)
        self.b2.place(x=15, y=180)
        self.b3 = tk.Button(self, text="Refresh", command=self.devices_refresh, width=30)
        self.b3.place(x=15, y=210)

        self.l10 = tk.Label(self, text="Egram PlayBack").place(x=75, y=340)
        self.b4 = tk.Button(self, text="Play", command=self.device_play, width=9, state=tk.DISABLED)
        self.b4.place(x=15, y=370)
        self.b5 = tk.Button(self, text="Stop", command=self.device_stop, width=9, state=tk.DISABLED)
        self.b5.place(x=90, y=370)
        self.b6 = tk.Button(self, text="Clear", command=self.device_clear, width=9, state=tk.DISABLED)
        self.b6.place(x=165, y=370)

        # Pacemaker parameters
        self.t1 = tk.Label(self, text="Pacemaker Parameter").place(x=w/2+60, y=0)
        self.o2 = tk.OptionMenu(self, self.mode, "AOO", "VOO", "AAI", "VVI", "DOO", "AOOR", "VOOR", "AAIR", "VVIR", "DOOR").place(x=265, y=40)
        self.l7 = tk.Label(self, text="Affected Chamber: ").place(x=355, y=46)
        self.l8 = tk.Label(self, textvariable=self.l8t).place(x=460, y=46)
        self.mode.trace('w', self.mode_select)

        rx = 265
        ry = 76
        rinc = 170
        self.s1v = tk.DoubleVar()
        self.s1 = tk.Scale(self, orient=tk.HORIZONTAL, variable=self.s1v, length=150, from_=0.1, to=1.9, resolution=0.1)
        self.s1.place(x=rx, y=ry)
        self.s1v.set(0.4)
        self.s1t = tk.Label(self, text="Pulse Width (ms)").place(x=rx+20, y=ry+40)
        rx += rinc

        self.s2v = tk.DoubleVar()
        self.s2 = tk.Scale(self, orient=tk.HORIZONTAL, variable=self.s2v, length=150, from_=500, to=7500, resolution=50)
        self.s2.place(x=rx, y=ry)
        self.s2v.set(3750)
        self.s2t = tk.Label(self, text="Pulse Amplitude (mV)").place(x=rx+20, y=ry+40)
        rx += rinc
        self.s3v = tk.DoubleVar()
        self.s3 = tk.Scale(self, orient=tk.HORIZONTAL, variable=self.s3v, length=150, from_=30, to=175, resolution=1)
        self.s3.place(x=rx, y=ry)
        self.s3v.set(60)
        self.s3t = tk.Label(self, text="Lower Limit (ppm)").place(x=rx+20, y=ry+40)

        self.s5v = tk.DoubleVar()
        self.s5 = tk.Scale(self, orient=tk.HORIZONTAL, variable=self.s5v, length=150, from_=120, to=300, resolution=1)
        self.s5.place(x=rx, y=ry+70)
        self.s5v.set(200)
        self.s5t = tk.Label(self, text="Upper Limit (ppm)").place(x=rx+20, y=ry+110)
        rx += rinc
        self.s4v = tk.DoubleVar()
        self.s4 = tk.Scale(self, orient=tk.HORIZONTAL, variable=self.s4v, length=150, from_=150, to=500, resolution=5)
        self.s4.place(x=rx, y=ry)
        self.s4v.set(250)
        self.s4t = tk.Label(self, text="Refractory Period (ms)").place(x=rx+20, y=ry+40)

        # Create Graphs

        canvasHeight = 300
        canvasWidth = 500
        self.c1 = Graph(reference=reference, canv_h=canvasHeight,canv_w=canvasWidth, name="Atrium EGram")
        self.c1.place(x=-2, y=398)
        self.c2 = Graph(reference=reference, canv_h=canvasHeight, canv_w=canvasWidth, name="Ventricle EGram")
        self.c2.place(x=500, y=398)
        self.reference.coms.set_atr_graph(self.c1)
        self.reference.coms.set_vent_graph(self.c2)

        self.pack(expand=1, fill=tk.BOTH)
 def __init__(self, parent):
     '''
     Constructed function, initiate  arguments and UI.
     '''
     super().__init__()
     self.title('Settings')
     self.parent = parent  # the parent window
     self.window_size = [100, 100]
     self.stride = 25
     self.geometry('450x250')
     self.resizable(False, False)
     # the "Scale" row
     Scale_frame = tk.Frame(self)
     Scale_frame.pack(fill="x")
     tk.Label(Scale_frame,
              text='Scale (200 for default) :',
              width=40,
              font=('Times New Roman', 12)).pack(side=tk.LEFT)
     self.Scale = tk.IntVar(value=200)
     tk.Entry(Scale_frame, textvariable=self.Scale,
              width=8).pack(side=tk.LEFT)
     # the "Sigma" row
     Sigma_frame = tk.Frame(self)
     Sigma_frame.pack(fill="x")
     tk.Label(Sigma_frame,
              text='Sigma (0.6 for default) :',
              width=40,
              font=('Times New Roman', 12)).pack(side=tk.LEFT)
     self.Sigma = tk.DoubleVar(value=0.6)
     tk.Entry(Sigma_frame, textvariable=self.Sigma,
              width=8).pack(side=tk.LEFT)
     # the "Min_size" row
     Min_size_frame = tk.Frame(self)
     Min_size_frame.pack(fill="x")
     tk.Label(Min_size_frame,
              text='Min_size (80 for default) :',
              width=40,
              font=('Times New Roman', 12)).pack(side=tk.LEFT)
     self.Min_size = tk.IntVar(value=80)
     tk.Entry(Min_size_frame, textvariable=self.Min_size,
              width=8).pack(side=tk.LEFT)
     # the "Min_elongation" row
     Min_elongation_frame = tk.Frame(self)
     Min_elongation_frame.pack(fill="x")
     tk.Label(Min_elongation_frame,
              text='Min_elongation (0.5 for default) :',
              width=40,
              font=('Times New Roman', 12)).pack(side=tk.LEFT)
     self.Min_elongation = tk.DoubleVar(value=0.5)
     tk.Entry(Min_elongation_frame,
              textvariable=self.Min_elongation,
              width=8).pack(side=tk.LEFT)
     # the "Maximum_box" row
     Maximum_box_frame = tk.Frame(self)
     Maximum_box_frame.pack(fill="x")
     tk.Label(Maximum_box_frame,
              text='Maxsize of bounding box (10000 pixels for default) :',
              width=40,
              font=('Times New Roman', 12)).pack(side=tk.LEFT)
     self.Maximum_box = tk.IntVar(value=10000)
     tk.Entry(Maximum_box_frame, textvariable=self.Maximum_box,
              width=8).pack(side=tk.LEFT)
     # the "Minimum_box" row
     Minimum_box_frame = tk.Frame(self)
     Minimum_box_frame.pack(fill="x")
     tk.Label(Minimum_box_frame,
              text='Minsize of bounding box (100 pixels for default) :',
              width=40,
              font=('Times New Roman', 12)).pack(side=tk.LEFT)
     self.Minimum_box = tk.IntVar(value=100)
     tk.Entry(Minimum_box_frame, textvariable=self.Minimum_box,
              width=8).pack(side=tk.LEFT)
     # the button row
     self.button_frame = tk.Frame(self)
     self.button_frame.pack(fill="x", pady=10)
     tk.Button(self.button_frame,
               text="Cancel",
               command=self.cancel,
               relief='raised',
               font=('Times New Roman', 12)).pack(side=tk.RIGHT, padx=20)
     tk.Button(self.button_frame,
               text="Confirm",
               command=self.ok,
               relief='raised',
               font=('Times New Roman', 12)).pack(side=tk.LEFT, padx=20)
     # the warning label
     self.warning_label = tk.Label(
         self,
         text='Please input the desired windowsize',
         width=45,
         height=20,
         font=('Times New Roman', 10))
     self.warning_label.pack(pady=5, fill='x')