code: def get_parallels(bezier2, width):
      """
      Given the quadratic Bézier control points *bezier2*, returns
      control points of quadratic Bézier lines roughly parallel to given
      one separated by *width*.
      """
  
      # The parallel Bezier lines are constructed by following ways.
      #  c1 and c2 are control points representing the start and end of the
      #  Bezier line.
      #  cm is the middle point
  
      c1x, c1y = bezier2[0]
      cmx, cmy = bezier2[1]
      c2x, c2y = bezier2[2]
  
      parallel_test = check_if_parallel(
          c1x - cmx, c1y - cmy, cmx - c2x, cmy - c2y
      )
  
      if parallel_test == -1:
          _api.warn_external(
              "Lines do not intersect. A straight line is used instead."
          )
          cos_t1, sin_t1 = get_cos_sin(c1x, c1y, c2x, c2y)
          cos_t2, sin_t2 = cos_t1, sin_t1
      else:
          # t1 and t2 is the angle between c1 and cm, cm, c2.  They are
          # also an angle of the tangential line of the path at c1 and c2
          cos_t1, sin_t1 = get_cos_sin(c1x, c1y, cmx, cmy)
          cos_t2, sin_t2 = get_cos_sin(cmx, cmy, c2x, c2y)
  
      # find c1_left, c1_right which are located along the lines
      # through c1 and perpendicular to the tangential lines of the
      # Bezier path at a distance of width. Same thing for c2_left and
      # c2_right with respect to c2.
      c1x_left, c1y_left, c1x_right, c1y_right = get_normal_points(
          c1x, c1y, cos_t1, sin_t1, width
      )
      c2x_left, c2y_left, c2x_right, c2y_right = get_normal_points(
          c2x, c2y, cos_t2, sin_t2, width
      )
  
      # find cm_left which is the intersecting point of a line through
      # c1_left with angle t1 and a line through c2_left with angle
      # t2. Same with cm_right.
      try:
          cmx_left, cmy_left = get_intersection(
              c1x_left,
              c1y_left,
              cos_t1,
              sin_t1,
              c2x_left,
              c2y_left,
              cos_t2,
              sin_t2,
          )
          cmx_right, cmy_right = get_intersection(
              c1x_right,
              c1y_right,
              cos_t1,
              sin_t1,
              c2x_right,
              c2y_right,
              cos_t2,
              sin_t2,
          )
      except ValueError:
          # Special case straight lines, i.e., angle between two lines is
          # less than the threshold used by get_intersection (we don't use
          # check_if_parallel as the threshold is not the same).
          cmx_left, cmy_left = (
              0.5 * (c1x_left + c2x_left),
              0.5 * (c1y_left + c2y_left),
          )
          cmx_right, cmy_right = (
              0.5 * (c1x_right + c2x_right),
              0.5 * (c1y_right + c2y_right),
          )
  
      # the parallel Bezier lines are created with control points of
      # [c1_left, cm_left, c2_left] and [c1_right, cm_right, c2_right]
      path_left = [
          (c1x_left, c1y_left),
          (cmx_left, cmy_left),
          (c2x_left, c2y_left),
      ]
      path_right = [
          (c1x_right, c1y_right),
          (cmx_right, cmy_right),
          (c2x_right, c2y_right),
      ]
  
      return path_left, path_right
  
imports: from functools import lru_cache
  import math
  import warnings
  import numpy
  from matplotlib import _api
label_desc: Use image node_id 12 for calling a global function with example usage: get_parallels(bezier2, width) and returns: path_left,  path_right