.

MAIN.py

@@ -55,10 +55,8 @@ def setup_group(frame, group_name, data, input_vars, selected_params, group_widg
             picture_to_use = picture_path
             if grpnm == "inlay":
                 generate_picture_inlay(all_group_vars, picture_to_use)
-            elif grpnm == "wp_raw":
+            elif grpnm == "wp":
-                generate_picture_wpraw(all_group_vars, picture_to_use)
+                generate_picture_wp(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":

cfg_parsets/inlay.yml

@@ -0,0 +1,10 @@
+<<new par set>>:
+  INL_X_NUM: '10'
+  INL_X_OFFSET: '50'
+  INL_Y_NUM: '10'
+  INL_Y_OFFSET: '50'
+inlay1:
+  INL_X_NUM: '10'
+  INL_X_OFFSET: '50'
+  INL_Y_NUM: '9'
+  INL_Y_OFFSET: '50'

cfg_parsets/wp_fin.yml

@@ -1,6 +0,0 @@
-wpfin1:
-  h_grp_wpfin: ''
-  l_wpfin: '10'
-  x_wpfin: '30'
-  y_wpfin: '10'
-  z_wpfin: '13'

cfg_parsets/wp_raw.yml

@@ -1,9 +0,0 @@
-test:
-  x_wpraw: '20'
-  y_wpraw: '10'
-  z_wpraw: '20'
-wpraw1:
-  h_grp_wpraw: ''
-  x_wpraw: '20'
-  y_wpraw: '10'
-  z_wpraw: '30'

def.yml

@@ -11,23 +11,17 @@ groups:
       INL_Y_OFFSET: double
     cfg:
       picture_name: img_inlay.png
-  wp_raw:
+  wp:
     parameter:
-      x_wpraw: double
+      WPR_X: double
-      y_wpraw: double
+      WPR_Y: double
-      z_wpraw: double
+      WPR_Z: double
-      h_grp_wpraw: double
+      WP_CLP_OFFSET_X: double
+      WPR_GRP_OFFSET_Z: double
+      WPF_GRP_OFFSET_Y: double
+      WPF_GRP_OFFSET_Z: double
     cfg:
-      picture_name: img_wpraw.png
+      picture_name: img_wp.png
-  wp_fin:
-    parameter:
-      x_wpfin: double
-      y_wpfin: double
-      z_wpfin: double
-      l_wpfin: double
-      h_grp_wpfin: double
-    cfg:
-      picture_name: img_wpfin.png
   clp:
     parameter:
       clp_offset: double

funct_clp.py

@@ -5,11 +5,11 @@ 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
+        # Get WPR_X, WPR_Y, and WPR_Z values
         vars = all_group_vars['wp_raw']
-        x_wpraw = float(vars['x_wpraw'])
+        x_wpraw = float(vars['WPR_X'])
-        y_wpraw = float(vars['y_wpraw'])
+        y_wpraw = float(vars['WPR_Y'])
-        z_wpraw = float(vars['z_wpraw'])
+        z_wpraw = float(vars['WPR_Z'])
         x_cube = x_wpraw*2
         y_cube = y_wpraw*2
         z_cube = z_wpraw
@@ -17,7 +17,7 @@ def generate_picture_clp(all_group_vars, picture_path, DEBUG=False):
 
         # 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.")
+            raise ValueError("WPR_X, WPR_Y, and WPR_Z 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],
@@ -119,9 +119,9 @@ def generate_picture_clp(all_group_vars, picture_path, DEBUG=False):
 if __name__ == "__main__":
     all_group_vars = {
         'wp_raw': {
-            'x_wpraw': '10',   # Example values for testing
+            'WPR_X': '10',   # Example values for testing
-            'y_wpraw': '15',
+            'WPR_Y': '15',
-            'z_wpraw': '20'
+            'WPR_Z': '20'
         },
         'clp': {
             'clp_offset': '4'

funct_wp.py

@@ -4,55 +4,75 @@ import numpy as np
 
 
 def generate_picture_wp(all_group_vars, picture_path, DEBUG=False):
-    try:
+    # try:
-        # --- wpraw
+    vars = all_group_vars['wp']
-        vars = all_group_vars['wp_raw']
+    WPR_X, WPR_Y, WPR_Z, WP_CLP_OFFSET_X, WPR_GRP_OFFSET_Z, WPF_GRP_OFFSET_Y, WPF_GRP_OFFSET_Z = (float(vars[k]) for k in
-        x, y, z = float(vars['x_wpraw']), float(vars['y_wpraw']), float(vars['z_wpraw'])
+                           ['WPR_X', 'WPR_Y', 'WPR_Z', 'WP_CLP_OFFSET_X', 'WPR_GRP_OFFSET_Z', 'WPF_GRP_OFFSET_Y', 'WPF_GRP_OFFSET_Z'])
-        if min(x, y, z) <= 0:
+    if min(WPR_X, WPR_Y, WPR_Z) <= 0:
-            raise ValueError("Dimensions must be positive.")
+        raise ValueError("Dimensions must be positive.")
 
-        fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
+    # -------------------- wpraw -------------------------
-        x_cube, y_cube = 2 * x, 2 * y
+    fig, ax = plt.subplots(subplot_kw={'projection': '3d'})
-        vertices = np.array([[0, 0, 0], [x_cube, 0, 0], [x_cube, y_cube, 0], [0, y_cube, 0],
+    x_cube, y_cube = 2 * WPR_X, 2 * WPR_Y
-                             [0, 0, z], [x_cube, 0, z], [x_cube, y_cube, z], [0, y_cube, z]])
+    vertices = np.array([[0, 0, 0], [x_cube, 0, 0], [x_cube, y_cube, 0], [0, y_cube, 0],
-        faces = [vertices[[0, 1, 2, 3]], vertices[[4, 5, 6, 7]], vertices[[0, 3, 7, 4]],
+                         [0, 0, WPR_Z], [x_cube, 0, WPR_Z], [x_cube, y_cube, WPR_Z], [0, y_cube, WPR_Z]])
-                 vertices[[1, 2, 6, 5]], vertices[[0, 1, 5, 4]], vertices[[2, 3, 7, 6]]]
+    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))
+    # Polyeder hinzufügen
-        ax.set_box_aspect([x_cube, y_cube, z])
+    ax.add_collection3d(Poly3DCollection(faces, facecolors='k', linewidths=1, edgecolors='k', alpha=.15))
-        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
+    # Achsen-Einstellungen zusammenfassen
-        ax.quiver(0, 0, 0, max_size, 0, 0, color='r', linewidth=5)
+    ax.set_box_aspect([x_cube, y_cube, WPR_Z])
-        ax.quiver(0, 0, 0, 0, max_size, 0, color='g', linewidth=5)
+    ax.set(xticks=[], yticks=[], zticks=[])
-        ax.quiver(0, 0, 0, 0, 0, max_size, color='b', linewidth=5)
 
-        block_depth = y * 0.4
+    # Kugel zeichnen
-        ax.bar3d(-max_size, (y_cube - block_depth) * 0.5, z * 0.8, max_size, block_depth, z * 0.8, color='k', alpha=.25)
+    u, v = np.mgrid[0:2 * np.pi:20j, 0:np.pi:20j]
-        ax.bar3d(x_cube, (y_cube - block_depth) * 0.5, z * 0.8, max_size, block_depth, z * 0.8, color='k', alpha=.25)
+    ball_radius = min(WPR_X, WPR_Y, WPR_Z) * 0.1
+    ax.plot_surface(
+        WPR_X + ball_radius * np.cos(u) * np.sin(v),
+        WPR_Y + ball_radius * np.sin(u) * np.sin(v),
+        WPR_Z + ball_radius * np.cos(v),
+        color='r'
+    )
+
+    # Koordinatenachsen zeichnen
+    axis_len = max(x_cube, y_cube, WPR_Z) * 0.3
+    colors = ['r', 'g', 'b']
+    for i, vec in enumerate(np.eye(3)):
+        ax.quiver(0, 0, 0, *(axis_len * vec), color=colors[i], linewidth=5)
+
+    gripper_thickness = max(x_cube, y_cube, WPR_Z) * 0.1
+    gripper_wide = WPR_X * 0.4
+    GRP_ALPHA = .25
+    bars = [
+        ((x_cube - gripper_wide) * 0.5, -gripper_thickness, WPR_Z - WPR_GRP_OFFSET_Z),
+        ((x_cube - gripper_wide) * 0.5, y_cube, WPR_Z - WPR_GRP_OFFSET_Z),
+    ]
+    for (x, y, z) in bars:
+        ax.bar3d(
+            x, y, z,
+            gripper_wide, gripper_thickness, 2 * WPR_Z + WPR_GRP_OFFSET_Z,
+            color='r', alpha=GRP_ALPHA, edgecolor='k', linewidth=0.5
+        )
 
 
 
-        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:
+    ax.view_init(elev=18, azim=-130)
-            fig.savefig(picture_path, bbox_inches='tight', dpi=300, transparent=True)
+    ax.set_xlim([0, x_cube]); ax.set_ylim([0, y_cube]); ax.set_zlim([0, WPR_Z])
-        else:
+    ax.set_aspect('auto')
-            plt.show()
+
-        plt.close()
+    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}")
+
 
-    except Exception as e:
-        print(f"An error occurred: {e}")
 
 
 
@@ -62,7 +82,7 @@ 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'])
+        x, y, z = float(vars['WPR_X']), float(vars['WPR_Y']), float(vars['WPR_Z'])
         if min(x, y, z) <= 0:
             raise ValueError("Dimensions must be positive.")
 
@@ -114,7 +134,7 @@ 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'])
+        x, y, z = float(vars['WPR_X']), float(vars['WPR_Y']), float(vars['WPR_Z'])
         if min(x, y, z) <= 0:
             raise ValueError("Dimensions must be positive.")
 
@@ -190,8 +210,8 @@ def generate_picture_wpfin(all_group_vars, picture_path, DEBUG=False):
 
 
 if __name__ == "__main__":
-    vars = {'x_wpraw': 10, 'y_wpraw': 15, 'z_wpraw': 20}
+    vars = {'WPR_X': 20, 'WPR_Y': 15, 'WPR_Z': 20, 'WP_CLP_OFFSET_X': 20, 'WPR_GRP_OFFSET_Z': 15, 'WPF_GRP_OFFSET_Y': 20, 'WPF_GRP_OFFSET_Z': 20}
-    generate_picture_wpraw({'wp_raw': vars}, "cfg_picture/TEST_wpraw.jpg", DEBUG=True)
+    generate_picture_wp({'wp': vars}, "cfg_picture/TEST_wpraw.jpg", DEBUG=True)
 
-    vars = {'x_wpfin': 10, 'y_wpfin': 20, 'z_wpfin': 20, 'l_wpfin': 10}
+    # 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)
+    # generate_picture_wpfin({'wp_fin': vars}, "cfg_picture/TEST_wpfin.jpg", DEBUG=True)