code: def manual_tracking(
      clip, t1=None, t2=None, fps=None, n_objects=1, savefile=None
  ):
      """Manual tracking of objects in videoclips using the mouse.
  
      Allows manual tracking of an object(s) in the video clip between
      times `t1` and `t2`. This displays the clip frame by frame
      and you must click on the object(s) in each frame. If ``t2=None``
      only the frame at ``t1`` is taken into account.
  
      Returns a list ``[(t1, x1, y1), (t2, x2, y2)...]`` if there is one
      object per frame, else returns a list whose elements are of the
      form ``(ti, [(xi1, yi1), (xi2, yi2)...])``.
  
  
      Parameters
      ----------
  
      clip : video.VideoClip.VideoClip
        MoviePy video clip to track.
  
      t1 : float or str or tuple, optional
        Start time to to track (defaults is start of the clip). Can be expressed
        in seconds like ``15.35``, in ``(min, sec)``, in ``(hour, min, sec)``,
        or as a string: ``"01:03:05.35"``.
  
      t2 : float or str or tuple, optional
        End time to to track (defaults is end of the clip). Can be expressed
        in seconds like ``15.35``, in ``(min, sec)``, in ``(hour, min, sec)``,
        or as a string: ``"01:03:05.35"``.
  
      fps : int, optional
        Number of frames per second to freeze on. If None, the clip's
        fps attribute is used instead.
  
      n_objects : int, optional
        Number of objects to click on each frame.
  
      savefile : str, optional
        If provided, the result is saved to a file, which makes it easier to edit
        and re-use later.
  
  
      Examples
      --------
  
      >>> from moviepy import VideoFileClip
      >>> from moviepy.video.tools.tracking import manual_tracking
      >>>
      >>> clip = VideoFileClip("media/chaplin.mp4")
      >>>
      >>> # manually indicate 3 trajectories, save them to a file
      >>> trajectories = manual_tracking(clip, start_time=5, t2=7, fps=5,
      ...                                nobjects=3, savefile="track.text")
      >>>
      >>> # ...
      >>> # later, in another script, recover these trajectories
      >>> from moviepy.video.tools.tracking import Trajectory
      >>>
      >>> traj1, traj2, traj3 = Trajectory.load_list('track.text')
      >>>
      >>> # If ever you only have one object being tracked, recover it with
      >>> traj, =  Trajectory.load_list('track.text')
      """
      import pygame as pg
  
      screen = pg.display.set_mode(clip.size)
      step = 1.0 / fps
      if (t1 is None) and (t2 is None):
          t1, t2 = 0, clip.duration
      elif t2 is None:
          t2 = t1 + step / 2
      t = t1
      txy_list = []
  
      def gatherClicks(t):
          imdisplay(clip.get_frame(t), screen)
          objects_to_click = n_objects
          clicks = []
          while objects_to_click:
              for event in pg.event.get():
                  if event.type == pg.KEYDOWN:
                      if event.key == pg.K_BACKSLASH:
                          return "return"
                      elif event.key == pg.K_ESCAPE:
                          raise KeyboardInterrupt()
  
                  elif event.type == pg.MOUSEBUTTONDOWN:
                      x, y = pg.mouse.get_pos()
                      clicks.append((x, y))
                      objects_to_click -= 1
  
          return clicks
  
      while t < t2:
          clicks = gatherClicks(t)
          if clicks == "return":
              txy_list.pop()
              t -= step
          else:
              txy_list.append((t, clicks))
              t += step
  
      tt, xylist = zip(*txy_list)
      result = []
      for i in range(n_objects):
          xys = [e[i] for e in xylist]
          xx, yy = zip(*xys)
          result.append(Trajectory(tt, xx, yy))
  
      if savefile is not None:
          Trajectory.save_list(result, savefile)
      return result
  
imports: import numpy
  from moviepy.decorators import convert_parameter_to_seconds, use_clip_fps_by_default
  from moviepy.video.io.preview import imdisplay
  from moviepy.video.tools.interpolators import Trajectory
label_desc: Use image node_id 1 for calling a global function with example usage: manual_tracking(clip, t1, t2, fps, n_objects, savefile) and returns: result, clicks, str