Python结合wxPython实现照片标注工具的实战教学

self.annotation_mode = True
self.connection_mode = False

MODE_ANNOTATION = 'annotation'
MODE_CONNECTION = 'connection'

def normalize_mode_flags(mode):
    if mode == MODE_ANNOTATION:
        return True, False
    if mode == MODE_CONNECTION:
        return False, True
    raise ValueError(f'Unsupported mode: {mode}')

def set_mode(self, mode):
    self.annotation_mode, self.connection_mode = normalize_mode_flags(mode)
    self.connection_start = None
    self.dragging_annotation = None
    self.dragging_connection_control = None

    if mode == MODE_ANNOTATION:
        self.selected_connection = None
        self.main_frame.select_connection_in_list(None)
    else:
        self.selected_annotation = None
        self.main_frame.select_annotation_in_list(None)

    if hasattr(self.main_frame, 'sync_mode_tools'):
        self.main_frame.sync_mode_tools(mode)

    if hasattr(self.main_frame, 'update_mode_display'):
        self.main_frame.update_mode_display(mode)

    self.Refresh()

ann_bmp = make_tool_bitmap('annotation')
self.ann_tool = tool_bar.AddRadioTool(
    1002, '标注', ann_bmp, wx.NullBitmap, '标注模式'
)

conn_bmp = make_tool_bitmap('connection')
self.conn_tool = tool_bar.AddRadioTool(
    1003, '连线', conn_bmp, wx.NullBitmap, '连线模式'
)

def sync_mode_tools(self, mode):
    toolbar = self.GetToolBar()
    if not toolbar:
        return

    states = get_mode_tool_states(mode)
    toolbar.ToggleTool(1002, states[MODE_ANNOTATION])
    toolbar.ToggleTool(1003, states[MODE_CONNECTION])

self.mode_label = wx.StaticText(right_panel, label='当前模式：标注模式')
self.mode_label.SetFont(
    wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD)
)
self.mode_label.SetForegroundColour('#0066CC')

def update_mode_display(self, mode):
    if hasattr(self, 'mode_label'):
        label = '当前模式：标注模式' if mode == MODE_ANNOTATION else '当前模式：连线模式'
        self.mode_label.SetLabel(label)

def on_reset_mode(self, event):
    self.image_panel.connection_start = None
    self.image_panel.selected_connection = None
    self.image_panel.selected_annotation = None
    self.image_panel.dragging_annotation = None
    self.image_panel.dragging_connection_control = None
    self.select_annotation_in_list(None)
    self.select_connection_in_list(None)
    self.image_panel.set_mode(MODE_ANNOTATION)

def calculate_connection_endpoints(start, end, inset):
    x1, y1 = start
    x2, y2 = end
    dx, dy = x2 - x1, y2 - y1
    dist = (dx**2 + dy**2)**0.5

    if dist <= 0 or inset <= 0:
        return start, end

    usable_inset = min(inset, dist / 2)
    ux, uy = dx / dist, dy / dist

    visible_start = (x1 + ux * usable_inset, y1 + uy * usable_inset)
    visible_end = (x2 - ux * usable_inset, y2 - uy * usable_inset)

    return visible_start, visible_end

(x1, y1), (x2, y2) = calculate_connection_endpoints(
    (x1, y1), (x2, y2), endpoint_inset
)

TypeError: Point(): arguments did not match any overloaded call

def point_to_int_tuple(point):
    x, y = point
    return int(round(x)), int(round(y))

draw_x1, draw_y1 = point_to_int_tuple((x1, y1))
draw_x2, draw_y2 = point_to_int_tuple((x2, y2))

points = [
    wx.Point(draw_x1, draw_y1),
    wx.Point(int(cx), int(cy)),
    wx.Point(draw_x2, draw_y2)
]
dc.DrawSpline(points)

def calculate_curve_offset_from_point(start, end, target, base_curve):
    cx, cy, nx, ny, curve_amount = calculate_curve_control_point(
        start, end, base_curve, 0
    )

    if curve_amount <= 0:
        return 0

    target_x, target_y = target
    projected_delta = (target_x - cx) * nx + (target_y - cy) * ny
    normalized_offset = projected_delta / curve_amount

    return max(-3, min(3, normalized_offset))

python -m unittest discover -s tests

python -m py_compile photo_annotator.py