add curve for sequence flow

modules/OCR.py

@@ -352,6 +352,18 @@ def mapping_text(full_pred, text_pred, print_sentences=False,percentage_thresh=0
                 text_mapping[full_pred['BPMN_id'][j]]=grouped_sentences[i]
 
     # Map the grouped sentences to the corresponding pool
+    for key, elements in full_pred['pool_dict'].items():
+        if len(elements) > 0:
+            continue
+        else:
+            for i in range(len(info_boxes)):
+                #find the position of the key in BPMN_id
+                position = list(full_pred['BPMN_id']).index(key)
+                if proportion_inside(info_boxes[i], boxes[position])>iou_threshold:
+                    text_mapping[key] = info_texts[i]
+                    info_texts[i] = ''  # Clear the text to avoid re-use
+
+
     for i in range(len(info_boxes)):
         if is_vertical(info_boxes[i]):
             for j in range(len(boxes)):

modules/eval.py

@@ -427,11 +427,6 @@ def develop_prediction(boxes, labels, scores, keypoints, class_dict, correction=
     
     #give a link to event to allow the creation of the BPMN id with start, indermediate and end event
     flow_links = give_link_to_element(flow_links, labels)
-
-    #change every datastore to dataobject [TO DO: change it to make the dataStore work]
-    for i in range(len(labels)):
-        if labels[i] == list(class_dict.values()).index('dataStore'):
-            labels[i] = list(class_dict.values()).index('dataObject')
     
     boxes,labels,scores,keypoints,bpmn_id, flow_links,best_points,pool_dict = last_correction(boxes,labels,scores,keypoints,bpmn_id,flow_links,best_points, pool_dict)  
 

modules/toXML.py

@@ -248,6 +248,7 @@ def create_XML(full_pred, text_mapping, size_scale, scale):
 
     return pretty_xml_as_string
 
+# Function that creates a single pool with all elements
 def create_big_pool(full_pred, text_mapping):
     # If no pools or lanes are detected, create a single pool with all elements
     new_pool_index = 'pool_1'
@@ -262,6 +263,7 @@ def create_big_pool(full_pred, text_mapping):
     print(f"Created a big pool index {new_pool_index} with elements: {elements_pool}")
     return full_pred, text_mapping
 
+# Function that gives the size of the elements
 def get_size_elements(size_scale):
     size_elements = {
         'event': (size_scale*43.2, size_scale*43.2),
@@ -286,10 +288,13 @@ def rescale(scale, boxes):
                             boxes[i][3]*scale]
     return boxes
 
+#Function to create the unique BPMN_id
 def create_BPMN_id(labels,pool_dict):
 
     BPMN_id = [class_dict[labels[i]] for i in range(len(labels))] 
 
+    data_counter = 1
+
     enums = {
         'event': 1,
         'task': 1,
@@ -300,8 +305,6 @@ def create_BPMN_id(labels,pool_dict):
         'parallelGateway': 1,
         'dataAssociation': 1,
         'pool': 1,
-        'dataObject': 1,
-        'dataStore': 1,
         'timerEvent': 1,
         'eventBasedGateway': 1
     }
@@ -326,8 +329,12 @@ def create_BPMN_id(labels,pool_dict):
         }.get(Bpmn_id, None)
 
         if key:
-            BPMN_id[idx] = f'{key}_{enums[key]}'
-            enums[key] += 1
+            if key in ['dataObject', 'dataStore']:
+                BPMN_id[idx] = f'{key}_{data_counter}'
+                data_counter += 1
+            else:
+                BPMN_id[idx] = f'{key}_{enums[key]}'
+                enums[key] += 1
         
     # Update the pool_dict keys with their corresponding BPMN_id values
     updated_pool_dict = {}
@@ -450,8 +457,10 @@ def create_bpmn_object(process, bpmnplane, text_mapping, definitions, size, data
                         dataObject_idx = links[dataAssociation_idx][0]
                         dataObject_name = elements[dataObject_idx]
                         dataObject_ref = f'DataObjectReference_{dataObject_name.split("_")[1]}'
+                        ET.SubElement(element, 'bpmn:property', id=f'Property_{dataAssociation_idx}_{dataObject_ref.split("_")[1]}', name='__targetRef_placeholder')
                         sub_element = ET.SubElement(element, 'bpmn:dataInputAssociation', id=f'dataInAsso_{dataAssociation_idx}_{dataObject_ref.split("_")[1]}')
                         ET.SubElement(sub_element, 'bpmn:sourceRef').text = dataObject_ref
+                        ET.SubElement(sub_element, 'bpmn:targetRef').text = f"Property_{dataAssociation_idx}_{dataObject_ref.split('_')[1]}"
                         create_data_Association(bpmnplane, data, size, sub_element.attrib['id'], dataAssociation_idx, dataObject_name, element_id)
 
                     # Handle Data Output Association
@@ -533,8 +542,11 @@ def create_bpmn_object(process, bpmnplane, text_mapping, definitions, size, data
             #print('ici dataObject', element_id)
             dataObject_idx = element_id.split('_')[1]
             dataObject_ref = f'DataObjectReference_{dataObject_idx}'
-            element = ET.SubElement(process, 'bpmn:dataObjectReference', id=dataObject_ref, dataObjectRef=element_id, name=text_mapping[element_id])
-            ET.SubElement(process, f'bpmn:{element_type}', id=element_id)
+            if element_type == 'dataObject':
+                ET.SubElement(process, 'bpmn:dataObjectReference', id=dataObject_ref, dataObjectRef=element_id, name=text_mapping[element_id])
+                ET.SubElement(process, f'bpmn:{element_type}', id=element_id)
+            elif element_type == 'dataStore':
+                ET.SubElement(process, 'bpmn:dataStoreReference', id=dataObject_ref, name=text_mapping[element_id])
             add_diagram_elements(bpmnplane, dataObject_ref, x, y, size[element_type][0], size[element_type][1])
 
         # Timer Event
@@ -610,6 +622,68 @@ def calculate_pool_waypoints(idx, data, size, source_idx, target_idx, source_ele
 
     return waypoints
 
+def add_curve(waypoints, pos_source, pos_target, threshold=30):
+    """
+    Add a single curve to the sequence flow by introducing a control point.
+    The control point is added at an offset from the midpoint of the original waypoints.
+    """
+    if len(waypoints) < 2:
+        return waypoints
+
+    # Extract start and end points
+    start_point = waypoints[0]
+    end_point = waypoints[1]
+
+    start_x, start_y = start_point
+    end_x, end_y = end_point
+
+    pos_horizontal = ['left', 'right']
+    pos_vertical = ['top', 'bottom']
+
+    if abs(start_x - end_x) < threshold or abs(start_y - end_y) < threshold:
+        return waypoints
+
+    # Calculate the control point
+    if pos_source in pos_horizontal and pos_target in pos_horizontal:
+        control_point = None
+    elif pos_source in pos_vertical and pos_target in pos_vertical:
+        control_point = None
+    elif pos_source in pos_horizontal and pos_target in pos_vertical:
+        control_point = (end_x, start_y)
+    elif pos_source in pos_vertical and pos_target in pos_horizontal:
+        control_point = (start_x, end_y)
+    else:
+        control_point = None
+    
+
+    # Create the curved path
+    if control_point is not None:
+        curved_waypoints = [start_point, control_point, end_point]
+    else:
+        curved_waypoints = [start_point, end_point]
+
+    return curved_waypoints
+
+
+def check_for_obstacles(waypoints, data, margin=10):
+    """
+    Check if the curved path intersects with any existing elements.
+    """
+    object_boxes = []
+    for idx, element in enumerate(data['boxes']):
+        if idx >= len(data['labels']):
+            continue
+        if data['labels'][idx] <= 12 and data['labels'][idx] != 7 and data['labels'][idx] != 6:
+            object_boxes.append(element)
+
+    for box in object_boxes:
+        x1, y1, x2, y2 = box
+        for point in waypoints:
+            x, y = point
+            if (x1 - margin < x < x2 + margin) and (y1 - margin < y < y2 + margin):
+                return True
+    return False
+
 def calculate_waypoints(data, size, current_idx, source_id, target_id):
     best_points = data['best_points'][current_idx]
     pos_source = best_points[0]
@@ -618,20 +692,18 @@ def calculate_waypoints(data, size, current_idx, source_id, target_id):
     source_idx = data['BPMN_id'].index(source_id)
     target_idx = data['BPMN_id'].index(target_id)
 
-    if source_idx==target_idx:
+    if source_idx == target_idx:
         warning()
-        #return [data['keypoints'][current_idx][0][:2], data['keypoints'][current_idx][1][:2]]
         return None
 
     if source_idx is None or target_idx is None:
         warning()
-        return [(source_x, source_y), (target_x, target_y)]
-
+        return None
 
     name_source = source_id.split('_')[0]
     name_target = target_id.split('_')[0]
 
-    #Get the position of the source and target
+    # 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]
 
@@ -641,31 +713,38 @@ def calculate_waypoints(data, size, current_idx, source_id, target_id):
 
     if pos_source == 'left':
         source_x = source_x
-        source_y += size[name_source][1]/2
+        source_y += size[name_source][1] / 2
     elif pos_source == 'right':
         source_x += size[name_source][0]
-        source_y += size[name_source][1]/2
+        source_y += size[name_source][1] / 2
     elif pos_source == 'top':
-        source_x += size[name_source][0]/2
+        source_x += size[name_source][0] / 2
         source_y = source_y
     elif pos_source == 'bottom':
-        source_x += size[name_source][0]/2
+        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
+        target_y += size[name_target][1] / 2
     elif pos_target == 'right':
         target_x += size[name_target][0]
-        target_y += size[name_target][1]/2
+        target_y += size[name_target][1] / 2
     elif pos_target == 'top':
-        target_x += size[name_target][0]/2
+        target_x += size[name_target][0] / 2
         target_y = target_y
     elif pos_target == 'bottom':
-        target_x += size[name_target][0]/2
+        target_x += size[name_target][0] / 2
         target_y += size[name_target][1]
 
-    return [(source_x, source_y), (target_x, target_y)]
+    waypoints = [(source_x, source_y), (target_x, target_y)]
+
+    # Add curve if no obstacles are in the path
+    if data['labels'][current_idx] == list(class_dict.values()).index('sequenceFlow'):
+        waypoints = add_curve(waypoints, pos_source, pos_target)
+
+    return waypoints
+
 
 def create_flow_element(bpmn, text_mapping, idx, size, data, parent, message=False):  
     source_idx, target_idx = data['links'][idx]