commit 4f4be68923027778c9196ecaae7b840b7f9a5511 Author: Eduard Gerlitz Date: Mon Mar 3 11:08:19 2025 +0100 Initial commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8c65d69 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +/.idea +/__pycache__/ +*ARCHIV* +*BAK* +*BACKUP* \ No newline at end of file diff --git a/EXEC_INSTALL.ps1 b/EXEC_INSTALL.ps1 new file mode 100644 index 0000000..d07019a --- /dev/null +++ b/EXEC_INSTALL.ps1 @@ -0,0 +1,8 @@ +# Construct the full path to the Python script +$ymlPath = "./_condaenv.yml" + +# Execute the Python script +& conda env create -f $ymlPath + +# Pause at the end of the script +Read-Host -Prompt "Press any key to exit" diff --git a/EXEC_MAIN.ps1 b/EXEC_MAIN.ps1 new file mode 100644 index 0000000..fc207a5 --- /dev/null +++ b/EXEC_MAIN.ps1 @@ -0,0 +1,16 @@ +#---------- USER DEFINE -------------- +$venvName = "dmu50_wingui" +$scriptPath = "./MAIN.py" +#------------------------------------- + +# Get the current username +$username = [System.Environment]::UserName + +# Construct the path to the Python executable +$pythonExe = "C:\Users\$username\AppData\Local\miniconda3\envs\$venvName\python.exe" + +# Execute the Python script +& $pythonExe $scriptPath + +# Pause at the end of the script +Read-Host -Prompt "Press Enter to exit" diff --git a/MAIN.py b/MAIN.py new file mode 100644 index 0000000..1fbf5a3 --- /dev/null +++ b/MAIN.py @@ -0,0 +1,351 @@ +# main.py + +from functions import * +from funct_inlay import * +from funct_wp import * +from funct_grp import * +from funct_clp import * +from funct_gen import * + +import tkinter as tk +from tkinter import ttk +import yaml +import shutil + +folder_parsets = "cfg_parsets" +folder_pictures = "cfg_picture" +folder_output = "out" +file_def = "def.yml" +file_jobs = "jobs.yml" +name_newparset = "<>" +name_newjob = "<>" +pic_sizelimit = 200 + + +def setup_group(frame, group_name, data, input_vars, selected_params, group_widgets): + group_data = data['groups'][group_name] + picture_name = group_data['cfg']['picture_name'] # Picture name defined in def.yml + picture_path = os.path.join(folder_pictures, picture_name) # Full path to the picture + + + # Dropdown for parameter sets + param_values = get_existing_parameters(group_name, folder_parsets) + param_values.append(name_newparset) + param_var = selected_params[group_name] # Bind the dropdown to the corresponding selected_param entry + param_dropdown = ttk.Combobox(frame, textvariable=param_var, values=param_values) + group_widgets[group_name] = {"param_dropdown": param_dropdown} # Save for later reference + source_path = f"{folder_pictures}/{data['general']['initpic_name']}" + + # Handle missing picture case + if not os.path.exists(picture_path): + shutil.copy(source_path, picture_path) + + + # Function to update the picture based on inputs or use the init picture + def update_inlay_picture(): + grpnm = group_name + all_group_vars = {group_name: {key: var.get() for key, var in group_vars.items()} for group_name, group_vars in + input_vars.items()} + + # Use the source_path if the selected parameter set is the new parameter set placeholder + # print(param_dropdown.get()) + if param_dropdown.get() == name_newparset: + picture_to_use = source_path + else: + picture_to_use = picture_path + if grpnm == "inlay": + generate_picture_inlay(all_group_vars, picture_to_use) + elif grpnm == "wp_raw": + generate_picture_wpraw(all_group_vars, picture_to_use) + elif grpnm == "wp_fin": + generate_picture_wpfin(all_group_vars, picture_to_use) + elif grpnm == "grp": + generate_picture_grp(all_group_vars, picture_to_use) + elif grpnm == "clp": + generate_picture_clp(all_group_vars, picture_to_use) + + group_image_tk = load_image(picture_to_use, pic_sizelimit) + image_label.configure(image=group_image_tk) + image_label.image = group_image_tk # Keep a reference to avoid garbage collection + + + # Function to load a parameter set + def load_selected_param(): + selected_param = param_dropdown.get() + if selected_param != name_newparset: + param_data = load_yaml(group_name, selected_param, folder_parsets) + for key, value in param_data.items(): + input_vars[group_name][key].set(value) + update_inlay_picture() + + # Function to save the current parameter set + def save_current_param(): + param_name = param_dropdown.get() + if param_name not in param_values and param_name.strip(): + param_values.insert(-1, param_name) # Insert before '<>' + param_dropdown['values'] = param_values + param_dropdown.set(param_name) + if name_newparset not in param_values: + param_values.append(name_newparset) # Ensure it's only appended once + param_data = {key: var.get() for key, var in input_vars[group_name].items()} + save_yaml(group_name, param_name, param_data, folder_parsets) + update_inlay_picture() + + # Function to delete the current parameter set + def delete_current_param(): + param_name = param_dropdown.get() + if param_name in param_values and param_name != name_newparset: + confirm = messagebox.askyesno("Delete Parameter", f"Are you sure you want to delete '{param_name}'?") + if confirm: + delete_yaml(group_name, param_name, folder_parsets) + param_values.remove(param_name) + if name_newparset not in param_values: + param_values.append(name_newparset) # Ensure it's only appended once + + # If there are any parameter sets left, select the next one; otherwise, show name_newparset + if param_values and param_values[0] != name_newparset: + param_dropdown['values'] = param_values + param_dropdown.set(param_values[0]) # Select the first remaining parameter set + load_selected_param() # Load the values of the first remaining parameter set + else: + # If no parameter sets left, show name_newparset + param_dropdown['values'] = [name_newparset] + param_dropdown.set(name_newparset) + + # Clear the input fields when no parameter sets are left + for key in input_vars[group_name]: + input_vars[group_name][key].set('') + + # Detect and save a new parameter set if entered via dropdown (press Enter) + def on_enter_new_param(event): + selected_param = param_dropdown.get() + if selected_param not in param_values and selected_param.strip(): + param_values.insert(-1, selected_param) + param_dropdown['values'] = param_values + save_current_param() + param_dropdown.set(selected_param) + if name_newparset not in param_values: + param_values.append(name_newparset) # Ensure it's only appended once + update_inlay_picture() + + # Load and display the specific group picture + group_image_tk = load_image(source_path, pic_sizelimit) + image_label = ttk.Label(frame, image=group_image_tk) + image_label.image = group_image_tk # Keep a reference to avoid garbage collection + image_label.grid(row=0, column=0, columnspan=2, padx=10, pady=10, sticky="") # Center the image in the middle + frame.grid_rowconfigure(0, minsize=230) + + # Add horizontal line + ttk.Separator(frame, orient='horizontal').grid(row=1, column=0, columnspan=2, sticky="ew", pady=10) + + # Dropdown field and buttons for save/load/delete + ttk.Label(frame, text="Parameter Set:").grid(row=2, column=0, padx=5, pady=5, sticky="w") + param_dropdown.grid(row=2, column=1, padx=5, pady=5) + # ttk.Button(frame, text="Load", command=load_selected_param).grid(row=3, column=0, padx=5, pady=5, sticky="w") + ttk.Button(frame, text="Save", command=save_current_param).grid(row=3, column=0, padx=5, pady=5, sticky="w") + ttk.Button(frame, text="Delete", command=delete_current_param).grid(row=3, column=1, padx=5, pady=5, sticky="w") + + # Add horizontal line + ttk.Separator(frame, orient='horizontal').grid(row=4, column=0, columnspan=2, sticky="ew", pady=10) + + # Setup input fields below dropdown and buttons + row = 5 + group_vars = {} + for var_name, _ in group_data['parameter'].items(): + ttk.Label(frame, text=var_name).grid(row=row, column=0, padx=5, pady=5, sticky="e") + var = tk.StringVar() + group_vars[var_name] = var + ttk.Entry(frame, textvariable=var).grid(row=row, column=1, padx=5, pady=5, sticky="w") + row += 1 + input_vars[group_name] = group_vars + + # Automatically select and load the first parameter set + if param_values and param_values[0] != name_newparset: + param_var.set(param_values[0]) + load_selected_param() # Directly load the first parameter set + else: + param_var.set(name_newparset) # If no parameters available, set to default + + # Bind the dropdown selection event + param_dropdown.bind("<>", lambda event: load_selected_param()) + # param_dropdown.event_generate("<>") # Trigger the ComboboxSelected + + # Bind the Enter key to detect when a new parameter set is typed and saved + param_dropdown.bind("", on_enter_new_param) + + # Automatically generate and display the picture at startup + update_inlay_picture() + + + +def setup_jobs(frame, data, selected_job, selected_params, input_vars, group_widgets): + # Load existing jobs from the jobs.yml file + job_values = get_existing_parameters("jobs", folder_parsets) + job_values.append(name_newjob) + + # Function to load selected job and update each group + def load_selected_job(): + job_name = selected_job.get() + if job_name != name_newjob: + job_data = load_yaml("jobs", job_name, folder_parsets) + # Update the parameter sets for each group according to the job + for group_name, param_set in job_data.items(): + if group_name in selected_params: + # Check if the parameter set exists for the group + param_values = get_existing_parameters(group_name, folder_parsets) + if param_set not in param_values: + # If parameter set is missing, set to <> and clear fields + selected_params[group_name].set(name_newparset) + clear_input_fields(group_name) + else: + selected_params[group_name].set(param_set) + # Manually trigger the parameter dropdown change for the group + param_dropdown = group_widgets[group_name]["param_dropdown"] + param_dropdown.set(param_set) # Update dropdown to show selected set + param_dropdown.event_generate("<>") + + # Function to clear the input fields when a parameter set is missing + def clear_input_fields(group_name): + for key in input_vars[group_name]: + input_vars[group_name][key].set('') # Clear the input fields + + # Function to load the selected parameter set for a group and update inputs + def load_selected_param_for_group(group_name, param_set): + try: + param_data = load_yaml(group_name, param_set, folder_parsets) + for key, value in param_data.items(): + input_vars[group_name][key].set(value) + # Trigger the picture update by generating the ComboboxSelected event + param_dropdown = group_widgets[group_name]["param_dropdown"] + param_dropdown.event_generate("<>") + except FileNotFoundError: + # Handle missing parameter set gracefully + selected_params[group_name].set(name_newparset) + clear_input_fields(group_name) + + # Function to save the current job + def save_current_job(): + job_name = selected_job.get() + if job_name not in job_values and job_name.strip(): + job_values.insert(-1, job_name) # Insert before '<>' + selected_job.set(job_name) + job_data = {group_name: selected_params[group_name].get() for group_name in data['groups']} + save_yaml("jobs", job_name, job_data, folder_parsets) + + # Update job dropdown after saving a new job + job_dropdown['values'] = job_values + job_dropdown.set(job_name) + + # Function to delete the selected job + def delete_current_job(): + job_name = selected_job.get() + if job_name in job_values and job_name != name_newjob: + confirm = messagebox.askyesno("Delete Job", f"Are you sure you want to delete '{job_name}'?") + if confirm: + delete_yaml("jobs", job_name, folder_parsets) + job_values.remove(job_name) + selected_job.set(job_values[0] if job_values else name_newjob) + # Update job dropdown after deletion + job_dropdown['values'] = job_values + load_selected_job() + + # Job dropdown and buttons for save/load/delete + ttk.Label(frame, text="Job:").grid(row=0, column=0, padx=5, pady=5, sticky="w") + job_dropdown = ttk.Combobox(frame, textvariable=selected_job, values=job_values) + job_dropdown.grid(row=0, column=1, padx=5, pady=5) + ttk.Button(frame, text="Save", command=save_current_job).grid(row=1, column=0, padx=5, pady=5, sticky="w") + ttk.Button(frame, text="Delete", command=delete_current_job).grid(row=1, column=1, padx=5, pady=5, sticky="w") + + # Bind job selection to loading the selected job and updating the groups + job_dropdown.bind("<>", lambda event: load_selected_job()) + job_dropdown.bind("", lambda event: save_current_job()) + + # After setting up all UI components + if job_values and job_values[0] != name_newjob: + selected_job.set(job_values[0]) # Select the first job automatically + load_selected_job() # Load the first job's parameters and update the corresponding parameter sets + + return load_selected_job + + + +def setup_evaluation(root, folder_pictures, data, folder_output, input_vars, selected_params): + # Create a frame for the EVALUATION section + frame = ttk.LabelFrame(root, text="EVALUATION", padding=(10, 10)) + frame.grid(row=2, column=0, columnspan=5, padx=10, pady=10, sticky="nsew") + + # Load and display the specific initial picture + picture_path = f"{folder_pictures}/{data['general']['initpic_name']}" + group_image_tk = load_image(picture_path, 200) # Assuming a function load_image exists and works as expected + image_label = ttk.Label(frame, image=group_image_tk) + image_label.image = group_image_tk # Keep a reference to avoid garbage collection + image_label.grid(row=0, column=0, rowspan=2, padx=10, pady=10) + + # Function to generate configuration file based on current parameters + def btn_gen(): + generate_config_spf(folder_output, input_vars, selected_params) + + # Place buttons in the vertical frame for operations + button_frame = ttk.Frame(frame) + button_frame.grid(row=0, column=1, padx=10, pady=10, sticky="n") + button1 = ttk.Button(button_frame, text="GENERATE DMUAUT_CFG.SPF FILE", width=45, command=btn_gen) + button1.grid(row=0, column=0, padx=10, pady=5) + + root.grid_columnconfigure(0, weight=1) + + + + +def main(): + # Tkinter root setup + root = tk.Tk() + root.title("DMU50") + + # Load object definitions from YAML + with open(file_def, 'r') as file: + data = yaml.safe_load(file) + + input_vars = {} + selected_params = {} # Dictionary to track selected parameters for each group + selected_job = tk.StringVar() + group_widgets = {} # Dictionary to store widgets related to groups + + def setup_ui(): + # ---- Setup Jobs UI + frame = ttk.LabelFrame(root, text="Jobs", padding=(10, 10)) + frame.grid(row=0, column=0, columnspan=5, padx=10, pady=10, sticky="nsew") + load_selected_job = setup_jobs(frame, data, selected_job, selected_params, input_vars, group_widgets) + + # ---- Create the UI for each group + for col_idx, group_name in enumerate(data['groups']): + frame_group = ttk.LabelFrame(root, text=group_name, padding=(10, 10)) + frame_group.grid(row=1, column=col_idx, padx=10, pady=10, sticky="nsew") + + selected_params[group_name] = tk.StringVar() + setup_group(frame_group, group_name, data, input_vars, selected_params, group_widgets) + + root.grid_columnconfigure(list(range(col_idx + 1)), weight=1) + root.grid_rowconfigure(0, weight=1) + + # ---- Setup the EVALUATION section + setup_evaluation(root, folder_pictures, data, folder_output, input_vars, selected_params) + + # After the UI is fully set up, load the selected job to update parameter lists + load_selected_job() # Ensure this is called to load the job parameters + + # Show the window after setup is complete + root.deiconify() + + # Initially hide the root window + root.withdraw() + + # Delay UI setup by 1000 milliseconds (1 second) + root.after(300, setup_ui) + + # Start the Tkinter event loop + root.mainloop() + + +if __name__ == "__main__": + main() + diff --git a/_condaenv.yml b/_condaenv.yml new file mode 100644 index 0000000..4cb3d4c --- /dev/null +++ b/_condaenv.yml @@ -0,0 +1,10 @@ +name: dmu50_wingui +channels: + - defaults + - conda-forge +dependencies: + - python=3.10 + - pyyaml + - jsonschema + - tk + - pillow \ No newline at end of file diff --git a/cfg_parsets/clp.yml b/cfg_parsets/clp.yml new file mode 100644 index 0000000..7d9d38f --- /dev/null +++ b/cfg_parsets/clp.yml @@ -0,0 +1,4 @@ +clp1: + clp_offset: '0' +clp2: + clp_offset: '0' diff --git a/cfg_parsets/grp.yml b/cfg_parsets/grp.yml new file mode 100644 index 0000000..e1bd8b1 --- /dev/null +++ b/cfg_parsets/grp.yml @@ -0,0 +1,28 @@ +grp1: + h_offset: '30' + h_step: '10' + hub: '50' + steps_num: '5' + w_offset: '40' + w_step: '45' +grp2: + h_offset: '30' + h_step: '5' + hub: '10' + steps_num: '6' + w_offset: '20' + w_step: '10' +grp3: + h_offset: '10' + h_step: '25' + hub: '10' + steps_num: '5' + w_offset: '25' + w_step: '45' +newset: + h_offset: '10' + h_step: '25' + hub: '10' + steps_num: '5' + w_offset: '25' + w_step: '45' diff --git a/cfg_parsets/inlay.yml b/cfg_parsets/inlay.yml new file mode 100644 index 0000000..2258b1d --- /dev/null +++ b/cfg_parsets/inlay.yml @@ -0,0 +1,12 @@ +inlay7: + kos: '4' + x_num: '4' + x_offset: '30' + y_num: '3' + y_offset: '30' +inlay_kleinteil: + kos: '4' + x_num: '7' + x_offset: '5' + y_num: '4' + y_offset: '4' diff --git a/cfg_parsets/jobs.yml b/cfg_parsets/jobs.yml new file mode 100644 index 0000000..4cfa5c8 --- /dev/null +++ b/cfg_parsets/jobs.yml @@ -0,0 +1,12 @@ +job1: + clp: clp1 + grp: grp1 + inlay: inlay7 + wp_fin: wpfin1 + wp_raw: wpraw1 +job3: + clp: clp1 + grp: grp3 + inlay: inlay_kleinteil + wp_fin: wpfin1 + wp_raw: wpraw1 diff --git a/cfg_parsets/wp_fin.yml b/cfg_parsets/wp_fin.yml new file mode 100644 index 0000000..fb8ec07 --- /dev/null +++ b/cfg_parsets/wp_fin.yml @@ -0,0 +1,5 @@ +wpfin1: + l_wpfin: '8' + x_wpfin: '20' + y_wpfin: '10' + z_wpfin: '13' diff --git a/cfg_parsets/wp_raw.yml b/cfg_parsets/wp_raw.yml new file mode 100644 index 0000000..25c1341 --- /dev/null +++ b/cfg_parsets/wp_raw.yml @@ -0,0 +1,8 @@ +test: + x_wpraw: '20' + y_wpraw: '10' + z_wpraw: '20' +wpraw1: + x_wpraw: '10' + y_wpraw: '10' + z_wpraw: '20' diff --git a/cfg_picture/Thumbs.db b/cfg_picture/Thumbs.db new file mode 100644 index 0000000..b695f3f Binary files /dev/null and b/cfg_picture/Thumbs.db differ diff --git a/cfg_picture/img_clp.png b/cfg_picture/img_clp.png new file mode 100644 index 0000000..fd00736 Binary files /dev/null and b/cfg_picture/img_clp.png differ diff --git a/cfg_picture/img_grp.png b/cfg_picture/img_grp.png new file mode 100644 index 0000000..f746530 Binary files /dev/null and b/cfg_picture/img_grp.png differ diff --git a/cfg_picture/img_inlay.png b/cfg_picture/img_inlay.png new file mode 100644 index 0000000..c33977b Binary files /dev/null and b/cfg_picture/img_inlay.png differ diff --git a/cfg_picture/img_wpfin.png b/cfg_picture/img_wpfin.png new file mode 100644 index 0000000..2252538 Binary files /dev/null and b/cfg_picture/img_wpfin.png differ diff --git a/cfg_picture/img_wpraw.png b/cfg_picture/img_wpraw.png new file mode 100644 index 0000000..8a10263 Binary files /dev/null and b/cfg_picture/img_wpraw.png differ diff --git a/cfg_picture/puppy - Kopie.png b/cfg_picture/puppy - Kopie.png new file mode 100644 index 0000000..bf61fb7 Binary files /dev/null and b/cfg_picture/puppy - Kopie.png differ diff --git a/cfg_picture/puppy.png b/cfg_picture/puppy.png new file mode 100644 index 0000000..bf61fb7 Binary files /dev/null and b/cfg_picture/puppy.png differ diff --git a/def.yml b/def.yml new file mode 100644 index 0000000..2d50973 --- /dev/null +++ b/def.yml @@ -0,0 +1,44 @@ +general: + yolovar: int + initpic_name: puppy.png + +groups: + inlay: + parameter: + x_num: int + x_offset: double + y_num: int + y_offset: double + kos: str + cfg: + picture_name: img_inlay.png + wp_raw: + parameter: + x_wpraw: double + y_wpraw: double + z_wpraw: double + cfg: + picture_name: img_wpraw.png + wp_fin: + parameter: + x_wpfin: double + y_wpfin: double + z_wpfin: double + l_wpfin: double + cfg: + picture_name: img_wpfin.png + grp: + parameter: + hub: double + h_offset: double + h_step: double + w_offset: double + w_step: double + steps_num: int + cfg: + picture_name: img_grp.png + clp: + parameter: + clp_offset: double + cfg: + picture_name: img_clp.png diff --git a/funct_clp.py b/funct_clp.py new file mode 100644 index 0000000..dfd4a3d --- /dev/null +++ b/funct_clp.py @@ -0,0 +1,130 @@ +import matplotlib.pyplot as plt +from mpl_toolkits.mplot3d.art3d import Poly3DCollection +import numpy as np + + +def generate_picture_clp(all_group_vars, picture_path, DEBUG=False): + try: + # Get x_wpraw, y_wpraw, and z_wpraw values + vars = all_group_vars['wp_raw'] + x_wpraw = float(vars['x_wpraw']) + y_wpraw = float(vars['y_wpraw']) + z_wpraw = float(vars['z_wpraw']) + x_cube = x_wpraw*2 + y_cube = y_wpraw*2 + z_cube = z_wpraw + clp_offset = float(all_group_vars['clp']['clp_offset']) + + # ERROR HANDLING + if x_cube <= 0 or y_cube <= 0 or z_cube <= 0: + raise ValueError("x_wpraw, y_wpraw, and z_wpraw must be positive values.") + + # Define the vertices of the cube based on wpraw dimensions + vertices = (np.array([[0, 0, 0], [x_cube, 0, 0], [x_cube, y_cube, 0], [0, y_cube, 0], + [0, 0, z_cube], [x_cube, 0, z_cube], [x_cube, y_cube, z_cube], [0, y_cube, z_cube]]) + + np.array([0, -clp_offset, 0])) + + # Define the 6 faces of the cube + faces = [[vertices[j] for j in [0, 1, 2, 3]], # Bottom face + [vertices[j] for j in [4, 5, 6, 7]], # Top face + [vertices[j] for j in [0, 3, 7, 4]], # Left face + [vertices[j] for j in [1, 2, 6, 5]], # Right face + [vertices[j] for j in [0, 1, 5, 4]], # Front face + [vertices[j] for j in [2, 3, 7, 6]]] # Back face + + # Plot the cube in 3D + fig = plt.figure() + ax = fig.add_subplot(111, projection='3d') + + # Plot the cube with the specified faces + ax.add_collection3d(Poly3DCollection(faces, facecolors='k', linewidths=1, edgecolors='k', alpha=.15)) + + # Set the aspect ratio for each axis + ax.set_box_aspect([x_cube, y_cube, z_cube]) + + # Hide the axis ticks and labels + ax.set_xticks([]) # Hide X axis ticks + ax.set_yticks([]) # Hide Y axis ticks + ax.set_zticks([]) # Hide Z axis ticks + + # Add a ball (sphere) at the center of the cube + ball_radius = min(x_wpraw, y_wpraw, z_wpraw) * 0.1 # Size relative to cube dimensions + + u = np.linspace(0, 2 * np.pi, 20) + v = np.linspace(0, np.pi, 20) + x_sphere = x_wpraw + ball_radius * np.outer(np.cos(u), np.sin(v)) + y_sphere = y_wpraw - clp_offset + ball_radius * np.outer(np.sin(u), np.sin(v)) + z_sphere = z_wpraw + ball_radius * np.outer(np.ones(np.size(u)), np.cos(v)) + ax.plot_surface(x_sphere, y_sphere, z_sphere, color='red', alpha=1) + + # Add the origin sparrow (a small 3D marker at the origin) + max_size = max(x_cube, y_cube, z_cube) * 0.2 # Scale the arrows relative to the smallest dimension + ax.quiver(0, -clp_offset, 0, max_size, 0, 0, color='red', linewidth=2, label='X-axis') # Red arrow for X-axis + ax.quiver(0, -clp_offset, 0, 0, max_size, 0, color='green', linewidth=2, label='Y-axis') # Green arrow for Y-axis + ax.quiver(0, -clp_offset, 0, 0, 0, max_size, color='blue', linewidth=2, label='Z-axis') # Blue arrow for Z-axis + + # Add two black blocks (greifer fingers) on the Y-faces in the middle of the cube height + max_size2 = max(x_cube, y_cube, z_cube) * 0.4 # Scale the arrows relative to the smallest dimension + ax.bar3d(-max_size2, -(2.0-1)/2 * y_cube, -z_wpraw * 0.0, + max_size2, 2.0 * y_cube, z_wpraw * 0.2, + color='black', alpha=.10) + ax.bar3d(-max_size2, -(2.0-1)/2 * y_cube, -z_wpraw * 0.0, + max_size2+3, 2.0 * y_cube, -z_wpraw * 0.2, + color='black', alpha=.10) + + ax.bar3d(x_cube, -(2-1)/2 * y_cube, -z_wpraw * 0.0, + max_size2, 2.0 * y_cube, z_wpraw * 0.2, + color='black', alpha=.10) + ax.bar3d(x_cube-3, -(2-1)/2 * y_cube, -z_wpraw * 0.0, + max_size2+3, 2.0 * y_cube, -z_wpraw * 0.2, + color='black', alpha=.10) + + # Add the origin sparrow (a small 3D marker at the origin) + max_size3 = max(x_cube, y_cube, z_cube) * 0.3 # Scale the arrows relative to the smallest dimension + ax.quiver(x_wpraw, y_wpraw, 0, max_size3, 0, 0, color='red', linewidth=3, label='X-axis') # Red arrow for X-axis + ax.quiver(x_wpraw, y_wpraw, 0, 0, max_size3, 0, color='green', linewidth=3, label='Y-axis') # Green arrow for Y-axis + ax.quiver(x_wpraw, y_wpraw, 0, 0, 0, max_size3, color='blue', linewidth=3, label='Z-axis') # Blue arrow for Z-axis + + # Set viewing angle + ax.view_init(elev=30, azim=-150) # Set elevation to 24° and azimuth to -151° + # ax.view_init(elev=90, azim=180) # Set elevation to 24° and azimuth to -151° + + # Set limits for the axes + # ax.set_xlim([0, x_cube]) + # ax.set_ylim([0, y_cube]) + # ax.set_zlim([0, z_cube]) + + # Set equal aspect ratio to make grid cells look square + ax.set_aspect('equal') + + if not DEBUG: + # Save the figure to the specified picture path + fig.savefig(picture_path, bbox_inches='tight', pad_inches=0.1, dpi=300, transparent=True) + else: + plt.show() + + # Close the figure to free memory + plt.close() + + except ValueError as ve: + # Handle value error (e.g., invalid input) + print(f"Invalid Input: Error: {ve}") + + except Exception as e: + # Catch any other exceptions and show a generic error message + print(f"An error occurred while generating the 3D cube: {e}") + + +# Example use-case +if __name__ == "__main__": + all_group_vars = { + 'wp_raw': { + 'x_wpraw': '10', # Example values for testing + 'y_wpraw': '15', + 'z_wpraw': '20' + }, + 'clp': { + 'clp_offset': '4' + } + } + generate_picture_clp(all_group_vars, 'output_image.png', DEBUG=True) diff --git a/funct_gen.py b/funct_gen.py new file mode 100644 index 0000000..087e69c --- /dev/null +++ b/funct_gen.py @@ -0,0 +1,46 @@ +# funct_gen.py + +import os +import time + + +# Function to generate the DMUAUT_CFG.SPF configuration file and save selected parameter sets +def generate_config_spf(folder_output, input_vars, selected_params): + # Get the current timestamp for folder name (format: YYMMDD_HHmmSS) + timestamp = time.strftime("%y%m%d_%H%M%S") + folder_path = os.path.join(folder_output, f"{timestamp}") + + # Create the folder with the timestamp + if not os.path.exists(folder_path): + os.makedirs(folder_path) + + # Define the file path for the SPF configuration file + spf_file_path = os.path.join(folder_path, "DMUAUT_CFG.SPF") + + # Generate the SPF file content + with open(spf_file_path, "w") as spf_file: + spf_file.write(f"; CFG FILE FOR DMU50 AUTOMATION\n") + spf_file.write(f"; GENERATED: {timestamp}\n") + spf_file.write("; ---------------------------------------------------\n") + + # Iterate over the input variables (each group), and write them into the file + for group_name, variables in input_vars.items(): + for var_name, var_value in variables.items(): + spf_file.write(f"{var_name.upper()} = {var_value.get()}\n") + spf_file.write("\n") + spf_file.write("; ---------------------------------------------------\n") + + # Define the file path for the text file with selected parameter sets + selected_params_file_path = os.path.join(folder_path, "selected_param_sets.txt") + + # Save the currently selected parameter sets in a .txt file + with open(selected_params_file_path, "w") as param_file: + param_file.write("Selected Parameter Sets:\n") + for group_name, param_name in selected_params.items(): + # Extract the actual value from the tk.StringVar object using .get() + param_file.write(f"{group_name}: {param_name.get()}\n") + + print(f"Configuration files saved in {folder_path}") + +# def generate_config_spf(): +# tbd diff --git a/funct_grp.py b/funct_grp.py new file mode 100644 index 0000000..ebcb82e --- /dev/null +++ b/funct_grp.py @@ -0,0 +1,88 @@ +import matplotlib.pyplot as plt +import numpy as np + + +def generate_picture_grp(all_group_vars, picture_path, DEBUG=False): + try: + # Extract variables for the gripper + vars = all_group_vars['grp'] + h_offset = float(vars['h_offset']) + h_step = float(vars['h_step']) + w_offset = float(vars['w_offset']) + w_step = float(vars['w_step']) + steps_num = int(vars['steps_num']) + + # ERROR HANDLING + if h_step <= 0 or w_step <= 0 or steps_num <= 0: + raise ValueError("h_step, w_step, and steps_num must be positive values.") + + # Initialize figure + fig, ax = plt.subplots(figsize=(6, 6)) # Square figure + ax.set_aspect('equal') + + # Draw the gripper finger + def draw_gripper(x_sign=1): + max_width = x_sign * (w_offset + w_step * (steps_num - 1)) + current_height = h_offset + current_width = x_sign * w_offset + + # Draw the first block + rect = plt.Rectangle((x_sign, 0), max_width - x_sign, h_offset, facecolor='black', linewidth=0) + ax.add_patch(rect) + + # Draw the steps + for _ in range(steps_num): + rect = plt.Rectangle((current_width, current_height), max_width - current_width, h_step, facecolor='black', linewidth=0) + ax.add_patch(rect) + current_height += h_step + current_width += x_sign * w_step + + # Draw original gripper finger and x flipped + draw_gripper() + draw_gripper(x_sign=-1) + + # Plot the origin point at (0, 0) + ax.plot(0, 0, marker='o', markersize=10, color='red') # Red point at origin + + # Flip the y-axis (invert it) + ax.invert_yaxis() + + # Set equal aspect ratio to make grid cells look square + ax.set_aspect('equal') + + # Hide major ticks and labels (only gridlines should be visible) + ax.set_xticks([]) + ax.set_yticks([]) + + # Add a white border around the plot to ensure the outer gridlines are visible + fig.patch.set_facecolor('white') + plt.subplots_adjust(left=0.05, right=0.95, top=0.95, bottom=0.05) # Adjust padding for the white border + + if not DEBUG: + # Save the figure to the specified picture path + plt.gca().set_aspect('equal', adjustable='box') + fig.savefig(picture_path, bbox_inches='tight', pad_inches=0.1, dpi=300, transparent=True) + else: + plt.show() + + # Close the figure to free memory + plt.close() + + except ValueError as ve: + # Handle value error (e.g., invalid input) + print(f"Invalid Input: Error: {ve}") + except Exception as e: + # Catch any other exceptions and show a generic error message + print(f"An error occurred while generating the gripper finger: {e}") + + +if __name__ == "__main__": + vars = { + 'h_offset': 10, + 'h_step': 5, + 'w_offset': 20, + 'w_step': 10, + 'steps_num': 5 + } + picture_path = "cfg_picture/TEST_gripper_finger.jpg" + generate_picture_grp(vars, picture_path, DEBUG=True) diff --git a/funct_inlay.py b/funct_inlay.py new file mode 100644 index 0000000..f9e9b73 --- /dev/null +++ b/funct_inlay.py @@ -0,0 +1,63 @@ +import matplotlib.pyplot as plt +import numpy as np + +def generate_picture_inlay(all_group_vars, picture_path, DEBUG=False): + try: + vars = all_group_vars['inlay'] + x_num, y_num = int(vars['x_num']), int(vars['y_num']) + x_offset_mm, y_offset_mm = float(vars['x_offset']), float(vars['y_offset']) + canvas_width_mm, canvas_height_mm = 800, 1200 + x_offset = x_offset_mm / canvas_height_mm # Swapping due to axis swap + y_offset = y_offset_mm / canvas_width_mm # Swapping due to axis swap + + if x_num <= 0 or y_num <= 0: + raise ValueError("x_num and y_num must be positive integers.") + + fig, ax = plt.subplots(figsize=(12, 8)) + ax.set_facecolor('black') + + total_x_offset = x_offset * (y_num + 1) + total_y_offset = y_offset * (x_num + 1) + rect_width = (1 - total_y_offset) / x_num + rect_height = (1 - total_x_offset) / y_num + + for j in range(x_num): + for i in range(y_num): + # Mirroring horizontally + x_start = 1 - (y_offset + i * (rect_height + y_offset) + rect_height) + y_start = x_offset + j * (rect_width + x_offset) + + rect = plt.Rectangle((x_start, y_start), rect_height, rect_width, color='white') + ax.add_patch(rect) + + triangle = plt.Polygon([ + (x_start + rect_height, y_start), # Bottom right of the rectangle + (x_start + rect_height - 0.05 * rect_height, y_start), # Left along the bottom + (x_start + rect_height, y_start + 0.05 * rect_width) # Up from the bottom right + ], color='black') + ax.add_patch(triangle) + + # Arrows with adjusted margins + ax.arrow(0.98, 0.02, -0.9, 0, head_width=0.03, head_length=0.02, fc='green', ec='green', linewidth=2, edgecolor='white') + ax.arrow(0.98, 0.02, 0, 0.9, head_width=0.02, head_length=0.03, fc='red', ec='red', linewidth=2, edgecolor='white') + + ax.set_xlim(0, 1) + ax.set_ylim(0, 1) + ax.set_xticks([]), ax.set_yticks([]) + plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1) # Adjusting the margins + + if DEBUG: + plt.show() + else: + fig.savefig(picture_path, bbox_inches='tight', pad_inches=0.5, dpi=300, transparent=True) # Adjusted padding + plt.close() + + except ValueError as ve: + print(f"Invalid Input: {ve}") + except Exception as e: + print(f"Error generating matrix: {e}") + +if __name__ == "__main__": + vars = {'x_num': 5, 'y_num': 3, 'x_offset': 20, 'y_offset': 20} + picture_path = "cfg_picture/TEST_inlay.jpg" + generate_picture_inlay({'inlay': vars}, picture_path, DEBUG=True) diff --git a/funct_wp.py b/funct_wp.py new file mode 100644 index 0000000..abdcc7f --- /dev/null +++ b/funct_wp.py @@ -0,0 +1,142 @@ +import matplotlib.pyplot as plt +from mpl_toolkits.mplot3d.art3d import Poly3DCollection +import numpy as np + + +def generate_picture_wpraw(all_group_vars, picture_path, DEBUG=False): + try: + # --- wpraw + vars = all_group_vars['wp_raw'] + x, y, z = float(vars['x_wpraw']), float(vars['y_wpraw']), float(vars['z_wpraw']) + if min(x, y, z) <= 0: + raise ValueError("Dimensions must be positive.") + + fig, ax = plt.subplots(subplot_kw={'projection': '3d'}) + x_cube, y_cube = 2 * x, 2 * y + vertices = np.array([[0, 0, 0], [x_cube, 0, 0], [x_cube, y_cube, 0], [0, y_cube, 0], + [0, 0, z], [x_cube, 0, z], [x_cube, y_cube, z], [0, y_cube, z]]) + faces = [vertices[[0, 1, 2, 3]], vertices[[4, 5, 6, 7]], vertices[[0, 3, 7, 4]], + vertices[[1, 2, 6, 5]], vertices[[0, 1, 5, 4]], vertices[[2, 3, 7, 6]]] + + ax.add_collection3d(Poly3DCollection(faces, facecolors='k', linewidths=1, edgecolors='k', alpha=.15)) + ax.set_box_aspect([x_cube, y_cube, z]) + ax.set_xticks([]); + ax.set_yticks([]); + ax.set_zticks([]) + ball_radius = min(x, y, z) * 0.1 + u, v = np.linspace(0, 2 * np.pi, 20), np.linspace(0, np.pi, 20) + x_sphere = x + ball_radius * np.outer(np.cos(u), np.sin(v)) + y_sphere = y + ball_radius * np.outer(np.sin(u), np.sin(v)) + z_sphere = z + ball_radius * np.outer(np.ones_like(u), np.cos(v)) + ax.plot_surface(x_sphere, y_sphere, z_sphere, color='r', alpha=1) + + max_size = max(x_cube, y_cube, z) * 0.3 + ax.quiver(0, 0, 0, max_size, 0, 0, color='r', linewidth=5) + ax.quiver(0, 0, 0, 0, max_size, 0, color='g', linewidth=5) + ax.quiver(0, 0, 0, 0, 0, max_size, color='b', linewidth=5) + + block_depth = y * 0.4 + ax.bar3d(-max_size, (y_cube - block_depth) * 0.5, z * 0.8, max_size, block_depth, z * 0.8, color='k', alpha=.25) + ax.bar3d(x_cube, (y_cube - block_depth) * 0.5, z * 0.8, max_size, block_depth, z * 0.8, color='k', alpha=.25) + + + + ax.view_init(elev=18, azim=-130) + ax.set_xlim([0, x_cube]); ax.set_ylim([0, y_cube]); ax.set_zlim([0, z]) + ax.set_aspect('auto') + + if not DEBUG: + fig.savefig(picture_path, bbox_inches='tight', dpi=300, transparent=True) + else: + plt.show() + plt.close() + + except Exception as e: + print(f"An error occurred: {e}") + + +def generate_picture_wpfin(all_group_vars, picture_path, DEBUG=False): + try: + # --- wpraw + vars = all_group_vars['wp_raw'] + x, y, z = float(vars['x_wpraw']), float(vars['y_wpraw']), float(vars['z_wpraw']) + if min(x, y, z) <= 0: + raise ValueError("Dimensions must be positive.") + + fig, ax = plt.subplots(subplot_kw={'projection': '3d'}) + x_cube, y_cube = 2 * x, 2 * y + vertices = np.array([[0, 0, 0], [x_cube, 0, 0], [x_cube, y_cube, 0], [0, y_cube, 0], + [0, 0, z], [x_cube, 0, z], [x_cube, y_cube, z], [0, y_cube, z]]) + faces = [vertices[[0, 1, 2, 3]], vertices[[4, 5, 6, 7]], vertices[[0, 3, 7, 4]], + vertices[[1, 2, 6, 5]], vertices[[0, 1, 5, 4]], vertices[[2, 3, 7, 6]]] + + ax.add_collection3d(Poly3DCollection(faces, facecolors='k', linewidths=1, edgecolors='k', alpha=.15)) + ax.set_box_aspect([x_cube, y_cube, z]) + ax.set_xticks([]); + ax.set_yticks([]); + ax.set_zticks([]) + ball_radius = min(x, y, z) * 0.1 + u, v = np.linspace(0, 2 * np.pi, 20), np.linspace(0, np.pi, 20) + x_sphere = x + ball_radius * np.outer(np.cos(u), np.sin(v)) + y_sphere = y + ball_radius * np.outer(np.sin(u), np.sin(v)) + z_sphere = z + ball_radius * np.outer(np.ones_like(u), np.cos(v)) + ax.plot_surface(x_sphere, y_sphere, z_sphere, color='r', alpha=1) + + + # --- wprfin + vars = all_group_vars['wp_fin'] + x, y, z, l = float(vars['x_wpfin']), float(vars['y_wpfin']), float(vars['z_wpfin']), float(vars['l_wpfin']) + if min(x, y, z, l) <= 0: + raise ValueError("Dimensions must be positive.") + + fig, ax = plt.subplots(subplot_kw={'projection': '3d'}) + x_offset = x - l / 2 + vertices = np.array([[0, 0, 0], [l, 0, 0], [l, 2 * y, 0], [0, 2 * y, 0], + [0, 0, z], [l, 0, z], [l, 2 * y, z], [0, 2 * y, z]]) + np.array([x_offset, 0, 0]) + faces = [vertices[[0, 1, 2, 3]], vertices[[4, 5, 6, 7]], vertices[[0, 3, 7, 4]], + vertices[[1, 2, 6, 5]], vertices[[0, 1, 5, 4]], vertices[[2, 3, 7, 6]]] + + ax.add_collection3d(Poly3DCollection(faces, facecolors='k', linewidths=1, edgecolors='k', alpha=.15)) + ball_radius = min(x, y, z) * 0.1 + u, v = np.linspace(0, 2 * np.pi, 20), np.linspace(0, np.pi, 20) + x_sphere = x + ball_radius * np.outer(np.cos(u), np.sin(v)) + y_sphere = y + ball_radius * np.outer(np.sin(u), np.sin(v)) + z_sphere = z + ball_radius * np.outer(np.ones_like(u), np.cos(v)) + ax.plot_surface(x_sphere, y_sphere, z_sphere, color='blue', alpha=1) + + max_size = max(l, 2 * y, z) * 0.3 + ax.quiver(0, 0, 0, max_size, 0, 0, color='red', linewidth=5) + ax.quiver(0, 0, 0, 0, max_size, 0, color='green', linewidth=5) + ax.quiver(0, 0, 0, 0, 0, max_size, color='blue', linewidth=5) + + block_depth = y * 0.4 + ax.bar3d(-max_size + x_offset, (2 * y - block_depth) * 0.5, z * 0.8, max_size, block_depth, z * 0.8, + color='black', alpha=.25) + ax.bar3d(l + x_offset, (2 * y - block_depth) * 0.5, z * 0.8, max_size, block_depth, z * 0.8, color='black', + alpha=.25) + + ax.view_init(elev=18, azim=-130) + ax.set_xticks([]); + ax.set_yticks([]); + ax.set_zticks([]) + ax.set_xlim([0, l + x_offset]); + ax.set_ylim([0, 2 * y]); + ax.set_zlim([0, z]) + ax.set_aspect('equal') + + if not DEBUG: + fig.savefig(picture_path, bbox_inches='tight', dpi=300, transparent=True) + else: + plt.show() + plt.close() + + except Exception as e: + print(f"An error occurred: {e}") + + +if __name__ == "__main__": + vars = {'x_wpraw': 10, 'y_wpraw': 15, 'z_wpraw': 20} + generate_picture_wpraw({'wp_raw': vars}, "cfg_picture/TEST_wpraw.jpg", DEBUG=True) + + vars = {'x_wpfin': 10, 'y_wpfin': 20, 'z_wpfin': 20, 'l_wpfin': 10} + generate_picture_wpfin({'wp_fin': vars}, "cfg_picture/TEST_wpfin.jpg", DEBUG=True) diff --git a/functions.py b/functions.py new file mode 100644 index 0000000..2c53bb9 --- /dev/null +++ b/functions.py @@ -0,0 +1,89 @@ +# functions.py + +import yaml +from PIL import Image, ImageTk +from tkinter import ttk, filedialog, messagebox +import tkinter as tk +import os + +# Function to load object definitions from YAML + +# Load a specific parameter set from a YAML file for a group +def load_yaml(group_name, param_name, folder_parsets): + yml_file = os.path.join(folder_parsets, f"{group_name}.yml") + if os.path.exists(yml_file): + with open(yml_file, 'r') as file: + data = yaml.safe_load(file) + return data.get(param_name, {}) + return {} + +# Save a parameter set to a YAML file for a group +def save_yaml(group_name, param_name, param_data, folder_parsets): + yml_file = os.path.join(folder_parsets, f"{group_name}.yml") + all_data = load_existing_data(yml_file) + all_data[param_name] = param_data + with open(yml_file, 'w') as file: + yaml.dump(all_data, file) + # messagebox.showinfo("Success", f"Parameter set '{param_name}' saved to {group_name}.yml") + +def delete_yaml(group_name, param_name, folder_parsets): + yml_file = os.path.join(folder_parsets, f"{group_name}.yml") + if os.path.exists(yml_file): + with open(yml_file, 'r') as file: + data = yaml.safe_load(file) + if param_name in data: + del data[param_name] # Remove the specific parameter set + with open(yml_file, 'w') as file: + yaml.safe_dump(data, file) + +# Load existing data from a YAML file +def load_existing_data(yml_file): + if os.path.exists(yml_file): + with open(yml_file, 'r') as file: + return yaml.safe_load(file) or {} + return {} + +# Fetch existing parameter sets from a group-specific YAML file +def get_existing_parameters(group_name, folder_parsets): + yml_file = os.path.join(folder_parsets, f"{group_name}.yml") + data = load_existing_data(yml_file) + return list(data.keys()) + +# Load the image for the UI +def load_image(image_file, sizelimit=200): + image = Image.open(image_file) + w, h = image.size + if w > h: + new_w, new_h = sizelimit, int(sizelimit * h / w) + else: + new_h, new_w = sizelimit, int(sizelimit * w / h) + return ImageTk.PhotoImage(image.resize((new_w, new_h), Image.Resampling.LANCZOS)) + +# Create a new parameter set and save it +def create_new_parameter_set(group_name, param_name, input_vars, folder_parsets): + if not param_name: + messagebox.showerror("Error", "Parameter set name cannot be empty.") + return + param_data = {key: var.get() for key, var in input_vars[group_name].items()} + save_yaml(group_name, param_name, param_data, folder_parsets) + +# Update the dropdown after saving new parameter set +def update_dropdown(param_values, param_name, param_dropdown): + param_values.insert(-1, param_name) + param_dropdown['values'] = param_values + +# Create a popup window for creating a new parameter set +def create_new_param_popup(root, group_name, input_vars, param_values, param_dropdown, folder_parsets): + new_window = tk.Toplevel(root) + new_window.title(f"Create New Parameter Set for {group_name}") + tk.Label(new_window, text="Parameter Set Name:").pack(pady=10) + param_name_entry = tk.Entry(new_window) + param_name_entry.pack(pady=10) + + def create_param_set(): + param_name = param_name_entry.get() + create_new_parameter_set(group_name, param_name, input_vars, folder_parsets) + update_dropdown(param_values, param_name, param_dropdown) + new_window.destroy() + + tk.Button(new_window, text="Create", command=create_param_set).pack(pady=10) diff --git a/out/241016_164629/DMUAUT_CFG.SPF b/out/241016_164629/DMUAUT_CFG.SPF new file mode 100644 index 0000000..849ed91 --- /dev/null +++ b/out/241016_164629/DMUAUT_CFG.SPF @@ -0,0 +1,29 @@ +; CFG FILE FOR DMU50 AUTOMATION +; GENERATED: 241016_164629 +; --------------------------------------------------- +X_NUM = 8 +X_OFFSET = 5 +Y_NUM = 7 +Y_OFFSET = 4 +KOS = 4 + +; --------------------------------------------------- +X_WPRAW = 10 +Y_WPRAW = 1 +Z_WPRAW = 1 + +; --------------------------------------------------- +X_WPFIN = +Y_WPFIN = +Z_WPFIN = +L_WPFIN = + +; --------------------------------------------------- +HUB = 10 +H_OFFSET = 20 +H_STEP = 5 +W_OFFSET = 20 +W_STEP = 10 +STEPS_NUM = 6 + +; --------------------------------------------------- diff --git a/out/241016_164629/selected_param_sets.txt b/out/241016_164629/selected_param_sets.txt new file mode 100644 index 0000000..da27e1a --- /dev/null +++ b/out/241016_164629/selected_param_sets.txt @@ -0,0 +1,5 @@ +Selected Parameter Sets: +inlay: inlay7 +wp_raw: wpraw1 +wp_fin: <> +grp: grp1 diff --git a/out/241017_101415/DMUAUT_CFG.SPF b/out/241017_101415/DMUAUT_CFG.SPF new file mode 100644 index 0000000..6021115 --- /dev/null +++ b/out/241017_101415/DMUAUT_CFG.SPF @@ -0,0 +1,29 @@ +; CFG FILE FOR DMU50 AUTOMATION +; GENERATED: 241017_101415 +; --------------------------------------------------- +X_NUM = 11 +X_OFFSET = 5 +Y_NUM = 4 +Y_OFFSET = 4 +KOS = 4 + +; --------------------------------------------------- +X_WPRAW = 10 +Y_WPRAW = 10 +Z_WPRAW = 20 + +; --------------------------------------------------- +X_WPFIN = 10 +Y_WPFIN = 10 +Z_WPFIN = 20 +L_WPFIN = 10 + +; --------------------------------------------------- +HUB = 10 +H_OFFSET = 20 +H_STEP = 5 +W_OFFSET = 20 +W_STEP = 10 +STEPS_NUM = 6 + +; --------------------------------------------------- diff --git a/out/241017_101415/selected_param_sets.txt b/out/241017_101415/selected_param_sets.txt new file mode 100644 index 0000000..485e528 --- /dev/null +++ b/out/241017_101415/selected_param_sets.txt @@ -0,0 +1,5 @@ +Selected Parameter Sets: +inlay: inlay4 +wp_raw: wpraw1 +wp_fin: wpfin1 +grp: grp1 diff --git a/out/241017_103326/DMUAUT_CFG.SPF b/out/241017_103326/DMUAUT_CFG.SPF new file mode 100644 index 0000000..9148e71 --- /dev/null +++ b/out/241017_103326/DMUAUT_CFG.SPF @@ -0,0 +1,29 @@ +; CFG FILE FOR DMU50 AUTOMATION +; GENERATED: 241017_103326 +; --------------------------------------------------- +X_NUM = 7 +X_OFFSET = 5 +Y_NUM = 4 +Y_OFFSET = 4 +KOS = g54 + +; --------------------------------------------------- +X_WPRAW = 5 +Y_WPRAW = 5 +Z_WPRAW = 15 + +; --------------------------------------------------- +X_WPFIN = 10 +Y_WPFIN = 10 +Z_WPFIN = 13 +L_WPFIN = 8 + +; --------------------------------------------------- +HUB = 10 +H_OFFSET = 10 +H_STEP = 5 +W_OFFSET = 25 +W_STEP = 4 +STEPS_NUM = 6 + +; --------------------------------------------------- diff --git a/out/241017_103326/selected_param_sets.txt b/out/241017_103326/selected_param_sets.txt new file mode 100644 index 0000000..8868e76 --- /dev/null +++ b/out/241017_103326/selected_param_sets.txt @@ -0,0 +1,5 @@ +Selected Parameter Sets: +inlay: inlay_kleinteil +wp_raw: wpraw2 +wp_fin: wpfin1 +grp: grp1 diff --git a/out/241017_180108/DMUAUT_CFG.SPF b/out/241017_180108/DMUAUT_CFG.SPF new file mode 100644 index 0000000..4570c00 --- /dev/null +++ b/out/241017_180108/DMUAUT_CFG.SPF @@ -0,0 +1,32 @@ +; CFG FILE FOR DMU50 AUTOMATION +; GENERATED: 241017_180108 +; --------------------------------------------------- +X_NUM = 8 +X_OFFSET = 5 +Y_NUM = 7 +Y_OFFSET = 4 +KOS = 4 + +; --------------------------------------------------- +X_WPRAW = 10 +Y_WPRAW = 10 +Z_WPRAW = 20 + +; --------------------------------------------------- +X_WPFIN = 10 +Y_WPFIN = 10 +Z_WPFIN = 13 +L_WPFIN = 8 + +; --------------------------------------------------- +HUB = 50 +H_OFFSET = 30 +H_STEP = 10 +W_OFFSET = 40 +W_STEP = 45 +STEPS_NUM = 5 + +; --------------------------------------------------- +CLP_OFFSET = + +; --------------------------------------------------- diff --git a/out/241017_180108/selected_param_sets.txt b/out/241017_180108/selected_param_sets.txt new file mode 100644 index 0000000..d5904ab --- /dev/null +++ b/out/241017_180108/selected_param_sets.txt @@ -0,0 +1,6 @@ +Selected Parameter Sets: +inlay: inlay7 +wp_raw: wpraw1 +wp_fin: wpfin1 +grp: grp1 +clp: <> diff --git a/out/241017_181437/DMUAUT_CFG.SPF b/out/241017_181437/DMUAUT_CFG.SPF new file mode 100644 index 0000000..a9244de --- /dev/null +++ b/out/241017_181437/DMUAUT_CFG.SPF @@ -0,0 +1,32 @@ +; CFG FILE FOR DMU50 AUTOMATION +; GENERATED: 241017_181437 +; --------------------------------------------------- +X_NUM = 8 +X_OFFSET = 5 +Y_NUM = 7 +Y_OFFSET = 4 +KOS = 4 + +; --------------------------------------------------- +X_WPRAW = 5 +Y_WPRAW = 5 +Z_WPRAW = 15 + +; --------------------------------------------------- +X_WPFIN = 10 +Y_WPFIN = 10 +Z_WPFIN = 13 +L_WPFIN = 8 + +; --------------------------------------------------- +HUB = 50 +H_OFFSET = 30 +H_STEP = 10 +W_OFFSET = 40 +W_STEP = 45 +STEPS_NUM = 5 + +; --------------------------------------------------- +CLP_OFFSET = 0 + +; --------------------------------------------------- diff --git a/out/241017_181437/selected_param_sets.txt b/out/241017_181437/selected_param_sets.txt new file mode 100644 index 0000000..dd0b10b --- /dev/null +++ b/out/241017_181437/selected_param_sets.txt @@ -0,0 +1,6 @@ +Selected Parameter Sets: +inlay: inlay7 +wp_raw: wpraw2 +wp_fin: wpfin1 +grp: grp1 +clp: clp2 diff --git a/out/241017_184239/DMUAUT_CFG.SPF b/out/241017_184239/DMUAUT_CFG.SPF new file mode 100644 index 0000000..a4a4465 --- /dev/null +++ b/out/241017_184239/DMUAUT_CFG.SPF @@ -0,0 +1,32 @@ +; CFG FILE FOR DMU50 AUTOMATION +; GENERATED: 241017_184239 +; --------------------------------------------------- +X_NUM = +X_OFFSET = +Y_NUM = +Y_OFFSET = +KOS = + +; --------------------------------------------------- +X_WPRAW = 10 +Y_WPRAW = 10 +Z_WPRAW = 20 + +; --------------------------------------------------- +X_WPFIN = 10 +Y_WPFIN = 10 +Z_WPFIN = 13 +L_WPFIN = 8 + +; --------------------------------------------------- +HUB = 10 +H_OFFSET = 10 +H_STEP = 5 +W_OFFSET = 25 +W_STEP = 45 +STEPS_NUM = 2 + +; --------------------------------------------------- +CLP_OFFSET = 4 + +; --------------------------------------------------- diff --git a/out/241017_184239/selected_param_sets.txt b/out/241017_184239/selected_param_sets.txt new file mode 100644 index 0000000..774e8ea --- /dev/null +++ b/out/241017_184239/selected_param_sets.txt @@ -0,0 +1,6 @@ +Selected Parameter Sets: +inlay: <> +wp_raw: wpraw1 +wp_fin: wpfin1 +grp: grp3 +clp: clp1