调整工程架构，增补了几种算法，初步添加神经网路训练拟合代码

base_optimizer/optimizer_interface.py

@@ -0,0 +1,96 @@
+# 用于提供对外接口
+from base_optimizer.optimizer_scanbased import *
+from base_optimizer.optimizer_celldivision import *
+from base_optimizer.optimizer_hybridgenetic import *
+from base_optimizer.optimizer_feederpriority import *
+from base_optimizer.optimizer_aggregation import *
+from base_optimizer.optimizer_twophase import *
+from base_optimizer.optimizer_mathmodel import *
+
+from base_optimizer.result_analysis import *
+
+
+def base_optimizer(machine_index, pcb_data, component_data, feeder_data=None, method='', hinter=False):
+
+    if method == 'cell_division':  # 基于元胞分裂的遗传算法
+        component_result, cycle_result, feeder_slot_result = optimizer_celldivision(pcb_data, component_data,
+                                                                                    hinter=False)
+        placement_result, head_sequence = greedy_placement_route_generation(component_data, pcb_data, component_result,
+                                                                            cycle_result, feeder_slot_result)
+    elif method == 'feeder_scan':  # 基于基座扫描的供料器优先算法
+        # 第1步：分配供料器位置
+        nozzle_pattern = feeder_allocate(component_data, pcb_data, feeder_data, figure=False)
+        # 第2步：扫描供料器基座，确定元件拾取的先后顺序
+        component_result, cycle_result, feeder_slot_result = feeder_base_scan(component_data, pcb_data, feeder_data,
+                                                                              nozzle_pattern)
+
+        # 第3步：贴装路径规划
+        placement_result, head_sequence = greedy_placement_route_generation(component_data, pcb_data, component_result,
+                                                                            cycle_result, feeder_slot_result)
+        # placement_result, head_sequence = beam_search_for_route_generation(component_data, pcb_data, component_result,
+        #                                                                    cycle_result, feeder_slot_result)
+
+    elif method == 'hybrid_genetic':  # 基于拾取组的混合遗传算法
+        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_hybrid_genetic(
+            pcb_data, component_data, hinter=False)
+
+    elif method == 'aggregation':  # 基于batch-level的整数规划 + 启发式算法
+        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_aggregation(
+            component_data, pcb_data)
+    elif method == 'genetic_scanning':
+        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_genetic_scanning(
+            component_data, pcb_data, hinter=False)
+    elif method == 'mip_model':
+        component_result, cycle_result, feeder_slot_result, placement_result, head_sequence = optimizer_mathmodel(
+            component_data, pcb_data, hinter=True)
+    elif method == "two_phase":
+        component_result, feeder_slot_result, cycle_result = gurobi_optimizer(pcb_data, component_data, feeder_data,
+                                                                              initial=True, partition=True,
+                                                                              reduction=True, hinter=hinter)
+
+        placement_result, head_sequence = scan_based_placement_route_generation(component_data, pcb_data,
+                                                                                component_result, cycle_result)
+    else:
+        raise 'method is not existed'
+
+    info = OptInfo()
+    assigned_nozzle = ['' if idx == -1 else component_data.loc[idx]['nz'] for idx in component_result[0]]
+    info.cycle_counter = sum(cycle_result)
+
+    for cycle in range(len(cycle_result)):
+        pick_slot = set()
+        for head in range(max_head_index):
+            idx = component_result[cycle][head]
+            if idx == -1:
+                continue
+
+            nozzle = component_data.loc[idx]['nz']
+            if nozzle != assigned_nozzle[head]:
+                if assigned_nozzle[head] != '':
+                    info.nozzle_change_counter += 1
+                assigned_nozzle[head] = nozzle
+
+            pick_slot.add(feeder_slot_result[cycle][head] - head * interval_ratio)
+        info.pickup_counter += len(pick_slot) * cycle_result[cycle]
+
+        pick_slot = list(pick_slot)
+        pick_slot.sort()
+        for idx in range(len(pick_slot) - 1):
+            info.pickup_movement += abs(pick_slot[idx + 1] - pick_slot[idx])
+
+    if hinter:
+        optimization_assign_result(component_data, pcb_data, component_result, cycle_result, feeder_slot_result,
+                                   nozzle_hinter=True, component_hinter=False, feeder_hinter=True)
+
+        print('----- Placement machine ' + str(machine_index) + ' ----- ')
+        print('-Cycle counter: {}'.format(info.cycle_counter))
+
+        print('-Nozzle change counter: {}'.format(info.nozzle_change_counter))
+        print('-Pick operation counter: {}'.format(info.pickup_counter))
+        print('-Pick movement: {}'.format(info.pickup_movement))
+        print('------------------------------ ')
+
+    # 估算贴装用时
+    info.placement_time = placement_time_estimate(component_data, pcb_data, component_result, cycle_result,
+                                                  feeder_slot_result, placement_result, head_sequence, hinter=False)
+    return info