import numpy as np

import matplotlib.pyplot as plt

def find_neighbors(x_array, y_array, value):
    diff = x_array - value
    negative = diff[diff <= 0]
    positive = diff[diff >= 0]
    least_negative = negative.argmax()
    least_positive = positive.argmin()
    x_array_negative_mask = x_array[diff <= 0]
    x_array_positive_mask = x_array[diff >= 0]
    y_array_negative_mask = y_array[diff <= 0]
    y_array_positive_mask = y_array[diff >= 0]
    left_neighbor_x = x_array_negative_mask[least_negative]
    right_neighbor_x = x_array_positive_mask[least_positive]
    left_neighbor_y = y_array_negative_mask[least_negative]
    right_neighbor_y = y_array_positive_mask[least_positive]
    return left_neighbor_x, right_neighbor_x, left_neighbor_y, right_neighbor_y

Mplot = np.array(range(5, 25))
Qplot = Mplot**2

def interpolate(value, left_neighbor_x, right_neighbor_x, left_neighbor_y, right_neighbor_y):
    diff_left = np.abs(value - left_neighbor_x)
    diff_right = np.abs(value - right_neighbor_x)
    diff = np.abs(right_neighbor_x - left_neighbor_x)
    if diff != 0:
        result = left_neighbor_y * diff_right / diff + right_neighbor_y * diff_left / diff
    else:
        result = left_neighbor_y * 0.5 + right_neighbor_y * 0.5
    return result

plt.figure()
plt.plot(Mplot, Qplot, marker="o")
for x_val in list(np.linspace(Mplot.min(), Mplot.max(), 4)):
    y_val = interpolate(x_val, *find_neighbors(Mplot, Qplot, x_val))
    plt.plot(x_val, y_val, color="red", marker=(3, 0, 90), markersize=15)

import numpy as np

import matplotlib.pyplot as plt

np.random.seed(50)
Mplot = np.array(sorted(list(np.random.random(200)*100)))
Qplot = Mplot**3

plt.figure(figsize=(15,10))
plot = plt.plot(Mplot, Qplot, marker=">", markevery=(0.1, 0.1), color="red", linestyle="-", markersize=15)

from numbers import Integral, Number, Real
from matplotlib.lines import _mark_every_path, Path

def _slice_or_none(in_v, slc):
    """Helper function to cope with `codes` being an ndarray or `None`."""
    if in_v is None:
        return None
    return in_v[slc]

def get_markevery_path(plot):
    tpath, affine = plot[0]._get_transformed_path().get_transformed_points_and_affine()
    ax_transform = plot[0].axes.transAxes
    start, step = (0.1, 0.1)
    disp_coords = affine.transform(tpath.vertices)
    codes, verts = tpath.codes, tpath.vertices
    delta = np.empty((len(disp_coords), 2))
    delta[0, :] = 0
    delta[1:, :] = disp_coords[1:, :] - disp_coords[:-1, :]
    delta = np.hypot(*delta.T).cumsum()
    # calc distance between markers along path based on the axes
    # bounding box diagonal being a distance of unity:
    (x0, y0), (x1, y1) = ax_transform.transform([[0, 0], [1, 1]])
    scale = np.hypot(x1 - x0, y1 - y0)
    marker_delta = np.arange(start * scale, delta[-1], step * scale)
    # find closest actual data point that is closest to
    # the theoretical distance along the path:
    inds = np.abs(delta[np.newaxis, :] - marker_delta[:, np.newaxis])
    inds = inds.argmin(axis=1)
    inds = np.unique(inds)
    # return, we are done here
    markevery_path = Path(verts[inds], _slice_or_none(codes, inds))
    return markevery_path.vertices.T

x_mark, y_mark = get_markevery_path(plot)

plt.plot(x_mark, y_mark, linestyle="", marker=">")

 
version: '3' 
services: 
  jira:
    container_name: jira 
    image: atlassian/jira-software:latest 
    environment:
     - ATL_PROXY_NAME=jira.internal
     - ATL_PROXY_PORT=80
     - ATL_TOMCAT_SCHEME=http 
 
  confluence: 
    container_name: confluence
    image: atlassian/confluence-server:latest
    environment: 
     - ATL_PROXY_NAME=confluence.internal
     - ATL_PROXY_PORT=80
     - ATL_TOMCAT_SCHEME=http
 
  bitbucket: 
    container_name: bitbucket 
    image: atlassian/bitbucket-server:latest 
    environment: 
     - SERVER_PROXY_NAME=bitbucket.internal
     - SERVER_PROXY_PORT=80
     - SERVER_SCHEME=http 
 
  nginx: 
    container_name: nginx 
    image: nginx:latest 
    volumes:
     - ./nginx.conf:/etc/nginx/nginx.conf 
    depends_on: 
     - jira 
     - confluence 
     - bitbucket 
    ports: 
     - "80:80" 
    networks: 
      default: 
        aliases:
         - jira.internal
         - confluence.internal
         - bitbucket.internal 
      

 
events {} 
http {
 server {
   server_name jira.internal;
   proxy_read_timeout 600s;
   location / {
     proxy_set_header X-Forwarded-Host $host;
     proxy_set_header X-Forwarded-Server $host;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_pass [URL]http://jira:8080;[/URL]
     client_max_body_size 10M;
   }
 }
 server {
   server_name confluence.internal;
   proxy_read_timeout 600s;
   location / {
     proxy_set_header X-Forwarded-Host $host;
     proxy_set_header X-Forwarded-Server $host;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_pass [URL]http://confluence:8090;[/URL]
     client_max_body_size 10M;
   }
 }
 server {
   server_name bitbucket.internal;
   proxy_read_timeout 600s;
   location / {
     proxy_set_header X-Forwarded-Host $host;
     proxy_set_header X-Forwarded-Server $host;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_pass [URL]http://bitbucket:7990;[/URL]
     client_max_body_size 10M;
   }
 }
}