Added some callbacks for info meshgen/calcfem -> gui

Added some geometry checks

Author: Mark00V

DEV/test2.py

@@ -1,18 +1,12 @@
-# file A
-class TestA:
+import tkinter as tk
 
-    def main(self):
-        for n in range(100):
+# Create the main window
+root = tk.Tk()
+root.geometry("300x200")
 
-            print(n)
+# Create a Label widget with text
+label = tk.Label(root, text="This is a left-anchored label\nTest next line\nTest third line", anchor="w", justify="left")
+label.place(relx=0.01, rely=0.01)
 
-
-# file B
-class TestB:
-    def get_n(self, fun):
-        return fun
-
-    def main(self):
-        testa = TestA()
-        testa.main()
-        print()
+# Start the Tkinter main loop
+root.mainloop()

DEV/test3.py

@@ -0,0 +1,10 @@
+from shapely.geometry import Polygon
+
+# Define two polygons
+polygon1 = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
+polygon2 = Polygon([(0, 0), (2, 0), (3, 2), (1, 2)])
+
+# Check if they share part of the boundary
+share_boundary = polygon1.intersects(polygon2) and polygon1.touches(polygon2) and not (polygon1.contains(polygon2) or polygon2.contains(polygon1))
+
+print("Do the polygons share part of the boundary? ", share_boundary)

source/geometry.py

@@ -31,6 +31,7 @@
 from source.guistatics import GUIStatics
 import copy
 from PIL import ImageTk
+from shapely.geometry import Polygon
 
 class Geometry(tk.Toplevel):
     """
@@ -682,7 +683,6 @@ def delete_point():
 
         ##################################################
         # clear all button
-        ##################################################
         def clear_all():
             """
             Button action, clears all input
@@ -715,6 +715,17 @@ def clear_all():
                                      font=GUIStatics.STANDARD_FONT_BUTTON_MID, width=10, height=1)
         button_clear_all.place(relx=widgets_x_start + 0.25, rely=0.02)
 
+        # Check geometry button
+        def check_geometry_on_button():
+            """
+
+            :return:
+            """
+            self.check_geometry_detail()
+
+        button_check_geometry = tk.Button(self, text="Check Geometry", command=check_geometry_on_button,
+                                     font=GUIStatics.STANDARD_FONT_BUTTON_MID, width=16, height=1)
+        button_check_geometry.place(relx=widgets_x_start + 0.35, rely=0.02)
         ##################################################
         # Add canvas for system visualization - DYNAMIC
         self.canvas = tk.Canvas(self, width=GUIStatics.CANVAS_SIZE_X, height=GUIStatics.CANVAS_SIZE_Y,
@@ -823,7 +834,7 @@ def check_and_accept():
             :return:
             """
 
-            if check_geometry():
+            if self.check_geometry_detail():
                 self.return_geometry()
             else:
                 check_geometry_error_window()
@@ -859,6 +870,59 @@ def debug():
 
         self.update_graphics()  # if Geometry class is loaded with input self.geometry_input, see init
 
+    def check_geometry_detail(self):
+        """
+        Detailed check for geometry
+        :return:
+        """
+        check_passed = True
+
+        check_fail_str = ''
+        check_failed_list = []
+        for ip1, poly1 in enumerate(self.polygons.values()):
+            poly1_shapely = Polygon([(node[0], node[1]) for node in poly1['coordinates']])
+            for ip2, poly2 in enumerate(list(self.polygons.values())[ip1 + 1:], start=ip1+1):
+                poly2_shapely = Polygon([(node[0], node[1]) for node in poly2['coordinates']])
+                # check if positive polygons overlap
+                if poly1['area_neg_pos'] == 'Positive' and poly2['area_neg_pos'] == 'Positive':
+                    if poly1_shapely.overlaps(poly2_shapely):
+                        check_fail_str = f"Geometryerror: Positive Polygon {ip1} and Positive Polygon {ip2} overlap"
+                        check_failed_list.append(check_fail_str)
+                # check if negative polygons overlap
+                if poly1['area_neg_pos'] == 'Negative' and poly2['area_neg_pos'] == 'Negative':
+                    if poly1_shapely.overlaps(poly2_shapely):
+                        check_fail_str = f"Geometryerror: Negative Polygon {ip1} and Negative Polygon {ip2} overlap"
+                        check_failed_list.append(check_fail_str)
+                # check if negative polygon inside positive polygon
+                if poly1['area_neg_pos'] == 'Positive' and poly2['area_neg_pos'] == 'Negative':
+                        if poly1_shapely.intersects(poly2_shapely):
+                            if not poly1_shapely.contains(poly2_shapely):
+                                check_fail_str = f"Geometryerror: Positive Polygon {ip1} and Negative Polygon {ip2} intersect"
+                                check_failed_list.append(check_fail_str)
+                if poly1['area_neg_pos'] == 'Negative' and poly2['area_neg_pos'] == 'Positive':
+                        if poly1_shapely.intersects(poly2_shapely):
+                            if not poly2_shapely.contains(poly1_shapely):
+                                check_fail_str = f"Geometryerror: Negative Polygon {ip1} and Positive Polygon {ip2} intersect"
+                                check_failed_list.append(check_fail_str)
+
+
+
+                # # Check if negative polygon intersects with positive polygon (boundary crossed/shared)
+                # if poly1['area_neg_pos'] == 'Positive' and poly2['area_neg_pos'] == 'Negative':
+                #     if poly1_shapely.intersects(poly2_shapely) and not poly1_shapely.contains(poly2_shapely):
+                #         check_fail_str = f"Geometryerror: Positive Polygon {ip1} and Negative Polygon {ip2} intersect"
+                #         check_failed_list.append(check_fail_str)
+                # if poly1['area_neg_pos'] == 'Negative' and poly2['area_neg_pos'] == 'Positive':
+                #     if poly1_shapely.intersects(poly2_shapely) and not poly2_shapely.contains(poly1_shapely):
+                #         check_fail_str = f"Geometryerror: Negative Polygon {ip1} and Positive Polygon {ip2} intersect"
+                #         check_failed_list.append(check_fail_str)
+
+        for elem in check_failed_list:
+            print(elem)
+
+
+        return check_passed
+
     def update_graphics(self):
         """
         Updates the canvas, draws static elements (coordsystem, grid) and draws defined polygons and single points

source/gui.py

@@ -95,7 +95,7 @@ def __init__(self):
         self.triangulation_region_dict = None
         # Other
         GUIStatics.CANVAS_SCALE_FACTOR = 100
-        self.elemcounter = 0  # Callbackvariable for parsing elements calculated from class CalcFEM to class GUI
+        self.calc_info = {'step': None, 'n': None, 'other': None}  # Callbackvariable for parsing elements calculated from class CalcFEM to class GUI
 
         # some output for user
         self.text_information_str = ''
@@ -267,7 +267,7 @@ def thread_create_mesh():
                 try:
                     mesh = CreateMesh(self.region_parameters, self.boundary_parameters,
                                       self.node_parameters, self.calculation_parameters)
-                    mesh_generator_output = mesh.create_mesh()
+                    mesh_generator_output = mesh.create_mesh(callback=self.callback_calc)
                     self.nodes_mesh_gen = mesh_generator_output[0]
                     self.single_nodes_dict = mesh_generator_output[1]
                     self.boundary_nodes_dict = mesh_generator_output[2]
@@ -280,15 +280,15 @@ def thread_create_mesh():
 
             window_create_mesh_wait = tk.Toplevel(self)
             window_create_mesh_wait.title('CREATING MESH')
-            window_create_mesh_wait.geometry(f"{200}x{150}")
+            window_create_mesh_wait.geometry(f"{300}x{150}")
             window_create_mesh_wait.resizable(False, False)
             icon_image = ImageTk.PhotoImage(data=GUIStatics.return_icon_bytestring())
             window_create_mesh_wait.tk.call('wm', 'iconphoto', window_create_mesh_wait._w, icon_image)
-            tk.Label(window_create_mesh_wait, text="Creating Mesh...\nPlease Wait",
+            tk.Label(window_create_mesh_wait, text="Creating Mesh...Please Wait",
                      font=GUIStatics.STANDARD_FONT_MID_BOLD).place(relx=0.15, rely=0.1)
             window_create_mesh_wait_label = tk.Label(window_create_mesh_wait, text="",
-                                                     font=GUIStatics.STANDARD_FONT_MID_BOLD)
-            window_create_mesh_wait_label.place(relx=0.35, rely=0.6)
+                                                     font=GUIStatics.STANDARD_FONT_SMALL_BOLD, anchor="sw", justify="left")
+            window_create_mesh_wait_label.place(relx=0.05, rely=0.3)
             thread_mesh = threading.Thread(target=thread_create_mesh)
             thread_mesh.start()
 
@@ -301,11 +301,11 @@ def update_wait_label():
                 """
                 wait_text = ''
                 while thread_mesh.is_alive():
-                    if wait_text == '.....':
-                        wait_text = ''
-                    wait_text += '.'
+                    wait_text = (f"Current Step: \n"
+                                 f"{self.calc_info['step']}\n"
+                                 f"{self.calc_info['n']}   {self.calc_info['other']}")
                     window_create_mesh_wait_label.config(text=wait_text)
-                    time.sleep(0.5)
+                    time.sleep(0.05)
                 window_create_mesh_wait.destroy()
 
             update_thread = threading.Thread(target=update_wait_label)
@@ -349,7 +349,7 @@ def thread_solve_system():
                         self.calculation_parameters)
                 try:
                     calcfem = CalcFEM(params_mesh, params_boundaries_materials)
-                    self.solution = calcfem.calc_fem(callback=self.callback_calcfem)
+                    self.solution = calcfem.calc_fem(callback=self.callback_calc)
                 except np.linalg.LinAlgError:
                     err_message = ('Singular Matrix encountered!\n'
                                    'Check Boundary Conditions \n'
@@ -381,15 +381,15 @@ def thread_solve_system():
 
             window_solve_system_wait = tk.Toplevel(self)
             window_solve_system_wait.title('SOLVING')
-            window_solve_system_wait.geometry(f"{200}x{150}")
+            window_solve_system_wait.geometry(f"{300}x{150}")
             window_solve_system_wait.resizable(False, False)
             icon_image = ImageTk.PhotoImage(data=GUIStatics.return_icon_bytestring())
             window_solve_system_wait.tk.call('wm', 'iconphoto', window_solve_system_wait._w, icon_image)
-            tk.Label(window_solve_system_wait, text="Solving System...\nPlease Wait",
-                     font=GUIStatics.STANDARD_FONT_MID_BOLD).place(relx=0.15, rely=0.1)
+            tk.Label(window_solve_system_wait, text="Solving System...Please Wait",
+                     font=GUIStatics.STANDARD_FONT_MID_BOLD, ).place(relx=0.15, rely=0.1)
             window_solve_system_wait_label = tk.Label(window_solve_system_wait, text="",
-                                                     font=GUIStatics.STANDARD_FONT_MID_BOLD)
-            window_solve_system_wait_label.place(relx=0.35, rely=0.6)
+                                                     font=GUIStatics.STANDARD_FONT_SMALL_BOLD, anchor="sw", justify="left")
+            window_solve_system_wait_label.place(relx=0.05, rely=0.3)
             thread_mesh = threading.Thread(target=thread_solve_system)
             thread_mesh.start()
 
@@ -400,12 +400,12 @@ def update_wait_label():
                 """
                 wait_text = ''
                 while thread_mesh.is_alive():
-                    if wait_text == '.....':
-                        wait_text = ''
-                    #wait_text += '.'
-                    wait_text = f"Element: {self.elemcounter} / {len(self.triangulation)}"
+                    wait_text = (f"Current Step: \n"
+                                 f"{self.calc_info['step']}\n"
+                                 f"{self.calc_info['n']}   {self.calc_info['other']}")
+
                     window_solve_system_wait_label.config(text=wait_text)
-                    time.sleep(0.1)
+                    time.sleep(0.05)
                 window_solve_system_wait.destroy()
 
             update_thread = threading.Thread(target=update_wait_label)
@@ -1244,11 +1244,11 @@ def accept_bcs():
                                   width=12, height=1, font=GUIStatics.STANDARD_FONT_BUTTON_MID_BOLD)
         button_accept.place(relx=widgets_x_start + 0.05, rely=0.895)
 
-    def callback_calcfem(self, calc_info):
+    def callback_calc(self, calc_info):
         """
         callback for parsing calculation e.g. element matrices to GUI
         """
-        print(f"Current Step: {calc_info['step']}    {calc_info['n']} {calc_info['other']}", end='\r')
+        self.calc_info = calc_info
 
     def create_BC_params(self):
         """