def METHOD_NAME(self, sx, sy, gx, gy):
    """
    dijkstra path search
    input:
        s_x: start x position [m]
        s_y: start y position [m]
        gx: goal x position [m]
        gx: goal x position [m]
    output:
        rx: x position list of the final path
        ry: y position list of the final path
    """
    start_node = self.Node(self.calc_xy_index(sx, self.min_x),
                           self.calc_xy_index(sy, self.min_y), 0.0, -1)
    goal_node = self.Node(self.calc_xy_index(gx, self.min_x),
                          self.calc_xy_index(gy, self.min_y), 0.0, -1)
    open_set, closed_set = dict(), dict()
    open_set[self.calc_index(start_node)] = start_node
    while True:
        c_id = min(open_set, key=lambda o: open_set[o].cost)
        current = open_set[c_id]
        # show graph
        if show_animation:  # pragma: no cover
            plt.plot(self.calc_position(current.x, self.min_x),
                     self.calc_position(current.y, self.min_y), "xc")
            # for stopping simulation with the esc key.
            plt.gcf().canvas.mpl_connect(
                'key_release_event',
                lambda event: [exit(0) if event.key == 'escape' else None])
            if len(closed_set.keys()) % 10 == 0:
                plt.pause(0.001)
        if current.x == goal_node.x and current.y == goal_node.y:
            print("Find goal")
            goal_node.parent_index = current.parent_index
            goal_node.cost = current.cost
            break
        # Remove the item from the open set
        del open_set[c_id]
        # Add it to the closed set
        closed_set[c_id] = current
        # expand search grid based on motion model
        for move_x, move_y, move_cost in self.motion:
            node = self.Node(current.x + move_x,
                             current.y + move_y,
                             current.cost + move_cost, c_id)
            n_id = self.calc_index(node)
            if n_id in closed_set:
                continue
            if not self.verify_node(node):
                continue
            if n_id not in open_set:
                open_set[n_id] = node  # Discover a new node
            else:
                if open_set[n_id].cost >= node.cost:
                    # This path is the best until now. record it!
                    open_set[n_id] = node
    rx, ry = self.calc_final_path(goal_node, closed_set)
    return rx, ry