better waypoint calculation

.gitignore

@@ -11,3 +11,5 @@ VISION_KEY.json
 .streamlit/secrets.toml
 
 backup/
+
+temp.jpg

app.py

@@ -61,25 +61,27 @@ def create_XML(full_pred, text_mapping, scale):
     }
     
     size_elements = {
-        'start': (36, 36),
-        'task': (100, 80),
-        'message': (36, 36),
-        'messageEvent': (36, 36),
-        'end': (36, 36),
-        'exclusiveGateway': (50, 50),
-        'event': (36, 36),
-        'parallelGateway': (50, 50),
-        'sequenceFlow': (150, 10),
-        'pool': (250, 100),
-        'lane': (200, 100),
-        'dataObject': (40, 60),
-        'dataStore': (60, 60),
-        'subProcess': (120, 90),
-        'eventBasedGateway': (50, 50),
-        'timerEvent': (40, 40),
+        'start': (43.2, 43.2),
+        'task': (120, 96),
+        'message': (43.2, 43.2),
+        'messageEvent': (43.2, 43.2),
+        'end': (43.2, 43.2),
+        'exclusiveGateway': (60, 60),
+        'event': (43.2, 43.2),
+        'parallelGateway': (60, 60),
+        'sequenceFlow': (180, 12),
+        'pool': (300, 120),
+        'lane': (240, 120),
+        'dataObject': (48, 72),
+        'dataStore': (72, 72),
+        'subProcess': (144, 108),
+        'eventBasedGateway': (60, 60),
+        'timerEvent': (48, 48),
     }
 
 
+
+
     definitions = ET.Element('bpmn:definitions', {
         'xmlns:xsi': namespaces['xsi'],
         'xmlns:bpmn': namespaces['bpmn'],
@@ -332,13 +334,13 @@ def main():
                 st.session_state.scale = st.slider("Set scale for XML file", min_value=0.1, max_value=2.0, value=1.0, step=0.1)
 
             # Launch the prediction when the user clicks the button    
-            if st.button("Launch Prediction"):
-                st.session_state.crop_image = cropped_image
-                with st.spinner('Processing...'):
-                    perform_inference(model_object, model_arrow, st.session_state.crop_image, score_threshold)
-                    st.session_state.prediction = modif_box_pos(st.session_state.prediction, object_dict)                    
-                    st.success('Detection completed!')
-                    print('Detection completed!')
+            #if st.button("Launch Prediction"):
+            st.session_state.crop_image = cropped_image
+            with st.spinner('Processing...'):
+                perform_inference(model_object, model_arrow, st.session_state.crop_image, score_threshold)
+                st.session_state.prediction = modif_box_pos(st.session_state.prediction, object_dict)                    
+                st.success('Detection completed!')
+                print('Detection completed!')
 
 
     # If the prediction has been made and the user has uploaded an image, display the options for the user to annotate the image

eval.py

@@ -239,6 +239,10 @@ def create_links(keypoints, boxes, labels, class_dict):
         if labels[i]==list(class_dict.values()).index('sequenceFlow') or labels[i]==list(class_dict.values()).index('messageFlow'):
             closest1, point_start = find_closest_object(keypoints[i][0], boxes, labels)
             closest2, point_end = find_closest_object(keypoints[i][1], boxes, labels)
+
+            print('closest1:', closest1, 'closest2:', closest2)
+            print('point_start:', point_start, 'point_end:', point_end)
+
             if closest1 is not None and closest2 is not None:
                 best_points.append([point_start, point_end])
                 links.append([closest1, closest2])

htlm_webpage.py

@@ -65,7 +65,7 @@ def display_bpmn_xml(bpmn_xml):
         <div id="button-container">
             <button id="save-button">Save as BPMN</button>
             <button id="download-button">Save as XML</button>
-            <button id="download-button">Save as Vizi</button>
+            <button id="download-button">Save as Vizi (not available for now)</button>
         </div>
         <div id="canvas-container">
             <div id="canvas"></div>

toXML.py

@@ -187,82 +187,6 @@ def create_bpmn_object(process, bpmnplane, text_mapping, definitions, size, data
             add_diagram_elements(bpmnplane, element_id, x, y, size['timerEvent'][0], size['timerEvent'][1])
 
 
-
-# Calculate simple waypoints between two elements (this function assumes direct horizontal links for simplicity)
-def calculate_waypoints(data, size, source_id, target_id):
-    source_idx = data['BPMN_id'].index(source_id)
-    target_idx = data['BPMN_id'].index(target_id)
-    name_source = source_id.split('_')[0]
-    name_target = target_id.split('_')[0]
-
-    #Get the position of the source and target
-    source_x, source_y = data['boxes'][source_idx][:2]
-    target_x, target_y = data['boxes'][target_idx][:2]
-
-    # Calculate relative position between source and target from their centers
-    relative_x = (target_x+size[name_target][0])/2 - (source_x+size[name_source][0])/2
-    relative_y = (target_y+size[name_target][1])/2 - (source_y+size[name_source][1])/2
-
-    # Get the size of the elements
-    size_x_source = size[name_source][0]
-    size_y_source = size[name_source][1]
-    size_x_target = size[name_target][0]
-    size_y_target = size[name_target][1]
-
-    #if it going to right
-    if relative_x >= size[name_source][0]:
-        source_x += size_x_source
-        source_y += size_y_source / 2
-        target_x  = target_x
-        target_y += size_y_target / 2
-        #if the source is going up
-        if relative_y < -size[name_source][1]:
-            source_x -= size_x_source / 2
-            source_y -= size_y_source / 2
-        #if the source is going down
-        elif relative_y > size[name_source][1]:
-            source_x -= size_x_source / 2
-            source_y += size_y_source / 2
-    #if it going to left
-    elif relative_x < -size[name_source][0]:
-        source_x = source_x
-        source_y += size_y_source / 2
-        target_x += size_x_target
-        target_y += size_y_target / 2
-        #if the source is going up
-        if relative_y < -size[name_source][1]:
-            source_x += size_x_source / 2
-            source_y -= size_y_source / 2
-        #if the source is going down
-        elif relative_y > size[name_source][1]:
-            source_x += size_x_source / 2
-            source_y += size_y_source / 2    
-    #if it going up and down
-    elif -size[name_source][0] < relative_x < size[name_source][0]:
-        source_x += size_x_source / 2
-        target_x += size_x_target / 2
-        #if it's going down
-        if relative_y >= size[name_source][1]/2:
-            source_y += size_y_source
-        #if it's going up
-        elif relative_y < -size[name_source][1]/2:
-            source_y = source_y
-            target_y += size_y_target
-        else:
-            if relative_x >= 0:
-                source_x += size_x_source/2
-                source_y += size_y_source/2
-                target_x -= size_x_target/2
-                target_y += size_y_target/2
-            else:
-                source_x -= size_x_source/2
-                source_y += size_y_source/2
-                target_x += size_x_target/2
-                target_y += size_y_target/2
-
-    return [(source_x, source_y), (target_x, target_y)]
-   
-
 def calculate_pool_bounds(data, keep_elements, size):
     min_x = min_y = float('10000')
     max_x = max_y = float('0')
@@ -321,7 +245,47 @@ def calculate_pool_waypoints(idx, data, size, source_idx, target_idx, source_ele
 
     return waypoints
 
+def calculate_waypoints(data, size, current_idx, source_id, target_id):
+    best_points = data['best_points'][current_idx]
+    pos_source = best_points[0]
+    pos_target = best_points[1]
 
+    source_idx = data['BPMN_id'].index(source_id)
+    target_idx = data['BPMN_id'].index(target_id)
+    name_source = source_id.split('_')[0]
+    name_target = target_id.split('_')[0]
+
+    #Get the position of the source and target
+    source_x, source_y = data['boxes'][source_idx][:2]
+    target_x, target_y = data['boxes'][target_idx][:2]
+
+    if pos_source == 'left':
+        source_x = source_x
+        source_y += size[name_source][1]/2
+    elif pos_source == 'right':
+        source_x += size[name_source][0]
+        source_y += size[name_source][1]/2
+    elif pos_source == 'top':
+        source_x += size[name_source][0]/2
+        source_y = source_y
+    elif pos_source == 'bottom':
+        source_x += size[name_source][0]/2
+        source_y += size[name_source][1]
+
+    if pos_target == 'left':
+        target_x = target_x
+        target_y += size[name_target][1]/2
+    elif pos_target == 'right':
+        target_x += size[name_target][0]
+        target_y += size[name_target][1]/2
+    elif pos_target == 'top':
+        target_x += size[name_target][0]/2
+        target_y = target_y
+    elif pos_target == 'bottom':
+        target_x += size[name_target][0]/2
+        target_y += size[name_target][1]
+
+    return [(source_x, source_y), (target_x, target_y)]
 
 def create_flow_element(bpmn, text_mapping, idx, size, data, parent, message=False):
     source_idx, target_idx = data['links'][idx]
@@ -339,7 +303,7 @@ def create_flow_element(bpmn, text_mapping, idx, size, data, parent, message=Fal
         if target_id.split('_')[0] == 'pool':
             target_id = f"participant_{target_id.split('_')[1]}"
     else:
-        waypoints = calculate_waypoints(data, size, source_id, target_id)
+        waypoints = calculate_waypoints(data, size, idx, source_id, target_id)
         #waypoints = data['best_points'][idx]
 
     #waypoints = data['best_points'][idx]

utils.py

@@ -923,14 +923,16 @@ def find_closest_object(keypoint, boxes, labels):
         right = (x2, (y1+y2)/2)
         points = [left, top , right, bottom]
 
+        pos_dict = {0:'left', 1:'top', 2:'right', 3:'bottom'}
+
         # Calculate the distance between the keypoint and the center of the bounding box
-        for point in points:
+        for pos, (point) in enumerate(points):
             distance = np.linalg.norm(keypoint[:2] - point)
             # Update the closest object index if this object is closer
             if distance < min_distance:
                 min_distance = distance
                 closest_object_idx = i
-                best_point = point
+                best_point = pos_dict[pos]
 
     return closest_object_idx, best_point