docs: def get_rx_distance(self, mesh):
          """
          Compute distance between each point of mesh and surface's great circle
          arc.
  
          Distance is measured perpendicular to the rupture strike, from
          the surface projection of the updip edge of the rupture, with
          the down dip direction being positive (this distance is usually
          called ``Rx``).
  
          In other words, is the horizontal distance to top edge of rupture
          measured perpendicular to the strike. Values on the hanging wall
          are positive, values on the footwall are negative.
  
          :param mesh:
              :class:`~openquake.hazardlib.geo.mesh.Mesh` of points to calculate
              Rx-distance to.
          :returns:
              Numpy array of distances in km.
          """
          top_edge = self.mesh[0:1]
  
          dists = []
          if top_edge.lons.shape[1] < 3:
  
              i = 0
              p1 = Point(
                  top_edge.lons[0, i],
                  top_edge.lats[0, i],
                  top_edge.depths[0, i]
              )
              p2 = Point(
                  top_edge.lons[0, i + 1], top_edge.lats[0, i + 1],
                  top_edge.depths[0, i + 1]
              )
              azimuth = p1.azimuth(p2)
              dists.append(
                  geodetic.distance_to_arc(
                      p1.longitude, p1.latitude, azimuth,
                      mesh.lons, mesh.lats
                  )
              )
  
          else:
  
              for i in range(top_edge.lons.shape[1] - 1):
                  p1 = Point(
                      top_edge.lons[0, i],
                      top_edge.lats[0, i],
                      top_edge.depths[0, i]
                  )
                  p2 = Point(
                      top_edge.lons[0, i + 1],
                      top_edge.lats[0, i + 1],
                      top_edge.depths[0, i + 1]
                  )
                  # Swapping
                  if i == 0:
                      pt = p1
                      p1 = p2
                      p2 = pt
  
                  # Computing azimuth and distance
                  if i == 0 or i == top_edge.lons.shape[1] - 2:
                      azimuth = p1.azimuth(p2)
                      tmp = geodetic.distance_to_semi_arc(p1.longitude,
                                                          p1.latitude,
                                                          azimuth,
                                                          mesh.lons, mesh.lats)
                  else:
                      tmp = geodetic.min_distance_to_segment(
                          numpy.array([p1.longitude, p2.longitude]),
                          numpy.array([p1.latitude, p2.latitude]),
                          mesh.lons, mesh.lats)
                  # Correcting the sign of the distance
                  if i == 0:
                      tmp *= -1
                  dists.append(tmp)
  
          # Computing distances
          dists = numpy.array(dists)
          iii = abs(dists).argmin(axis=0)
          dst = dists[iii, list(range(dists.shape[1]))]
  
          return dst