densitty 0.8.2__py3-none-any.whl

densitty/ansi.py

@@ -0,0 +1,109 @@
+"""ANSI code/color support"""
+
+# <pedantic> that the 256-color support here is not actually ANSI X3.64, though it uses ANSI-ish
+# escape sequences. I believe it was originally done in Xterm. And 4b colors (16-color)
+# are really an aixterm extension to the ANSI-specified 8-color standard. </pedantic>
+
+from typing import Optional, Sequence
+
+from .util import nearest
+
+
+RESET = "\033[0m"
+
+
+def compose(codes: Sequence[str]) -> str:
+    """Given a list of individual color codes, produce the full escape sequence."""
+    return f"\033[{';'.join(codes)}m"
+
+
+def colormap_16(colors):
+    """Produce a function that returns closest 4b/16color ANSI color codes from colormap.
+    Parameters
+    ----------
+    colors: Sequence[int]
+            Ordered 16-color ANSI colors corresponding to the 0.0..1.0 range
+    """
+
+    def as_colorcodes(bg_frac: Optional[float], fg_frac: Optional[float]) -> str:
+        """Return ANSI color code for 16-color value(s)
+        Parameters
+        ----------
+        fg_frac: Optional[float]
+                 Value 0.0..1.0 for foreground, or None if background-only
+        fg_frac: Optional[float]
+                 Value 0.0..1.0 for background, or None for foreground-only
+        """
+        codes = []
+        if fg_frac is not None:
+            codes += [f"{30 + nearest(colors, fg_frac)}"]
+        if bg_frac is not None:
+            codes += [f"{40 + nearest(colors, bg_frac)}"]
+        return compose(codes)
+
+    return as_colorcodes
+
+
+def colormap_256(colors):
+    """Produce a function that returns closest 8b/256color ANSI color codes from colormap.
+    Parameters
+    ----------
+    colors: Sequence[int]
+            Ordered 256-color ANSI colors corresponding to the 0.0..1.0 range
+    """
+
+    def as_colorcodes(bg_frac: Optional[float], fg_frac: Optional[float]):
+        """Return ANSI color code for 256-color value(s)
+        Parameters
+        ----------
+        fg_frac: Optional[float]
+                 Value 0.0..1.0 for foreground, or None if background-only
+        fg_frac: Optional[float]
+                 Value 0.0..1.0 for background, or None for foreground-only
+        """
+        codes = []
+        if fg_frac is not None:
+            fg = nearest(colors, fg_frac)
+            codes += [f"38;5;{fg}"]
+        if bg_frac is not None:
+            bg = nearest(colors, bg_frac)
+            codes += [f"48;5;{bg}"]
+        return compose(codes)
+
+    return as_colorcodes
+
+
+########################################################
+# Colormaps. Assumed 256-color unless suffixed with _16
+# pylint: disable=invalid-name
+
+
+# ANSI 16-color map colors in ROYGBIV order: Red, Yellow, Green, Cyan, Blue
+RAINBOW_16 = colormap_16((5, 1, 3, 2, 6))
+
+# ANSI 16-color 'rainbow', Reversed:
+REV_RAINBOW_16 = colormap_16((6, 2, 3, 1, 5))
+
+# ANSI 16-color map colors: Black, Blue, Cyan, Green, Yellow, Red, Magenta, White
+FADE_IN_16 = colormap_16((0, 4, 6, 2, 3, 1, 5, 7))
+
+# ANSI 256-color map colors in a grayscale black->white
+GRAYSCALE = colormap_256([0] + list(range(232, 256)) + [15])
+
+rainbow_256_colors = (
+    # fmt: off
+    (196, 202, 208, 214, 220, 190, 154, 118, 82, 46, 47, 48, 43, 80, 81, 39, 27, 21, 56, 91)
+    # fmt: on
+)
+RAINBOW = colormap_256(rainbow_256_colors)
+REV_RAINBOW = colormap_256(tuple(reversed(rainbow_256_colors)))
+
+BLUE_RED = colormap_256((21, 56, 91, 126, 161, 196))
+FADE_IN = colormap_256(
+    # fmt: off
+    (16, 53, 54, 55, 56, 57, 21, 21, 27, 39, 81, 80, 43, 48, 47,
+     46, 82, 118, 154, 190, 220, 214, 208, 202, 196)
+    # fmt: on
+)
+HOT = colormap_256((16, 52, 88, 124, 160, 196, 202, 208, 214, 220, 226, 227, 228, 229, 230, 231))
+COOL = colormap_256((50, 81, 111, 141, 171, 201))

densitty/ascii_art.py

@@ -0,0 +1,24 @@
+"""ASCII-art support"""
+
+from typing import Callable, Sequence
+
+from .util import nearest
+
+
+def color_map(values: Sequence[str]) -> Callable:
+    """Returns the closest ascii-art pixel."""
+
+    def compute_pixel_value(frac: float, _=None) -> str:
+        return nearest(values, frac)
+
+    return compute_pixel_value
+
+
+#
+# Some example/useful color scales
+# Character (glyph) density is dependent on font choice, unfortunately
+
+# Allow the all-caps colormap names:
+# pylint: disable=invalid-name
+DEFAULT = color_map(" .:-=+*#%@")
+EXTENDED = color_map(" .'`^\",:;Il!i>~+?[{1(|/o*#MW&8%B$@")

densitty/axis.py

@@ -0,0 +1,265 @@
+"""Axis-generation support."""
+
+import dataclasses
+from decimal import Decimal
+import itertools
+import math
+from typing import Optional
+
+from . import lineart
+from .util import FloatLike, ValueRange, pick_step_size
+
+MIN_X_TICKS_PER_LABEL = 4
+MIN_Y_TICKS_PER_LABEL = 2
+DEFAULT_X_COLS_PER_TICK = 4
+DEFAULT_Y_ROWS_PER_TICK = 2
+
+
+@dataclasses.dataclass
+class BorderChars:
+    """Characters to use for X/Y border"""
+
+    first: str
+    middle: str
+    last: str
+
+
+y_border = {False: BorderChars(" ", " ", " "), True: BorderChars("╷", "│", "╵")}
+x_border = {False: BorderChars(" ", " ", " "), True: BorderChars("╶", "─", "╴")}
+
+###############################################
+# Helper functions used by the Axis class below
+
+
+def add_label(line: list[str], label: str, ctr_pos: int):
+    """Adds the label string to the output line, centered at specified position
+    The output line is a list of single-character strings, to make this kind of thing
+    straightforward"""
+    width = len(label)
+    start_col = max(ctr_pos - width // 2, 0)
+    end_col = start_col + width
+    line[start_col:end_col] = list(label)
+
+
+def gen_tick_values(value_range, tick_step):
+    """Produce tick values in the specified range. Basically numpy.arange"""
+
+    tick = math.ceil(value_range.min / tick_step) * tick_step
+    while tick <= value_range.max:
+        yield tick
+        tick += tick_step
+
+
+def gen_labels(
+    value_range: ValueRange, num_ticks, min_ticks_per_label, fmt, label_end_ticks=False
+):
+    """Generate positions for labels (plain ticks & ticks with value)"""
+    tick_step, label_step = pick_step_size(value_range, num_ticks, min_ticks_per_label)
+
+    ticks = list(gen_tick_values(value_range, tick_step))
+    label_values = list(gen_tick_values(value_range, label_step))
+    if label_end_ticks or len(label_values) <= 2:
+        # ensure that first & last ticks have labels:
+        if label_values[0] != ticks[0]:
+            label_values = ticks[:1] + label_values
+        if label_values[-1] != ticks[-1]:
+            label_values += ticks[-1:]
+
+    # sanity: if all but one ticks have labels, just label them all
+    if len(label_values) >= len(ticks) - 1:
+        label_values = ticks
+
+    ticks_only = {value: "" for value in ticks}
+    labeled_ticks = {value: fmt.format(value) for value in label_values}
+
+    return ticks_only | labeled_ticks
+
+
+def calc_edges(value_range, num_bins, values_are_edges):
+    """Calculate the top/bottom or left/right values for each of 'num_bins' bins
+
+    Parameters
+    ----------
+    value_range: util.ValueRange
+                 Coordinate values for first/last bin
+                 Can be center of bin, or outside edge (see values_are_edges)
+    num_bins:    int
+                 Number of bins/intervals to produce edges for
+    values_are_edges: bool
+                 Indicates that value_range specifies outside edges rather than bin centers
+    """
+    if values_are_edges:
+        bin_delta = (value_range.max - value_range.min) / num_bins
+        first_bin_min = value_range.min
+    else:
+        bin_delta = (value_range.max - value_range.min) / (num_bins - 1)
+        first_bin_min = value_range.min - (bin_delta / 2)
+    bin_edges = tuple(first_bin_min + i * bin_delta for i in range(num_bins + 1))
+    return itertools.pairwise(bin_edges)
+
+
+###############################################
+# The User-facing interface: the Axis class
+
+
+@dataclasses.dataclass
+class Axis:
+    """Options for axis generation."""
+
+    value_range: ValueRange  # can also specify as a tuple of (min, max)
+    labels: Optional[dict[float, str]] = None  # map axis value to label (plus tick) at that value
+    label_fmt: str = "{}"  # format for generated labels
+    border_line: bool = False  # embed ticks in a horizontal X-axis or vertical Y-axis line
+    values_are_edges: bool = False  # N+1 values, indicating boundaries between pixels, not centers
+    fractional_tick_pos: bool = False  # Use "▔", "▁", or "╱╲" for non-centered ticks
+
+    def __init__(
+        self,
+        value_range: ValueRange | tuple[FloatLike, FloatLike],
+        labels: Optional[dict[float, str]] = None,
+        label_fmt: str = "{}",
+        border_line: bool = False,
+        values_are_edges: bool = False,
+        fractional_tick_pos: bool = False,
+        # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ):
+        # Sanitize value_range: allow user to provide it as a tuple of FloatLike (without
+        # needing to import ValueRange), and convert to ValueRange(Decimal, Decimal)
+        self.value_range = ValueRange(
+            Decimal(float(value_range[0])), Decimal(float(value_range[1]))
+        )
+        self.labels = labels
+        self.label_fmt = label_fmt
+        self.border_line = border_line
+        self.values_are_edges = values_are_edges
+        self.fractional_tick_pos = fractional_tick_pos
+
+    def _unjustified_y_axis(self, num_rows: int):
+        """Returns the Y axis string for each line of the plot"""
+        if self.labels is None:
+            labels = gen_labels(
+                self.value_range,
+                num_rows // DEFAULT_Y_ROWS_PER_TICK,
+                MIN_Y_TICKS_PER_LABEL,
+                self.label_fmt,
+            )
+        else:
+            labels = self.labels
+
+        label_values = sorted(labels.keys())
+        bins = calc_edges(self.value_range, num_rows, self.values_are_edges)
+
+        use_combining = self.border_line and self.fractional_tick_pos
+        for row_min, row_max in bins:
+            if label_values and row_min <= label_values[0] <= row_max:
+                label_str = labels[label_values[0]]
+
+                offset_frac = (label_values[0] - row_min) / (row_max - row_min)
+                if offset_frac < 0.25 and self.fractional_tick_pos:
+                    tick_char = "▔"
+                elif offset_frac > 0.75 and self.fractional_tick_pos:
+                    tick_char = "▁"
+                else:
+                    tick_char = "─"
+                label_str += lineart.merge_chars(
+                    tick_char,
+                    y_border[self.border_line].middle,
+                    use_combining_unicode=use_combining,
+                )
+                yield label_str
+                label_values = label_values[1:]
+            else:
+                yield y_border[self.border_line].middle
+
+    def render_as_y(self, num_rows: int, pad_top: bool, pad_bot: bool, flip: bool):
+        """Create a Y axis as a list of strings for the left margin of a plot
+
+        Parameters
+        ----------
+        num_rows: int
+                  Number of data rows
+        pad_top:  bool
+                  Emit a line for an X axis line/row at the top
+        pad_bot:  bool
+                  Emit a line for an X axis line/row at the bottom
+        flip:     bool
+                  Put the minimum Y on the last line rather than the first
+        """
+        unpadded_labels = list(self._unjustified_y_axis(num_rows))
+        if flip:
+            unpadded_labels = [
+                s.translate(lineart.flip_vertical) for s in reversed(unpadded_labels)
+            ]
+
+        if pad_top:
+            unpadded_labels = [y_border[self.border_line].first] + unpadded_labels
+        if pad_bot:
+            unpadded_labels = unpadded_labels + [y_border[self.border_line].last]
+
+        lengths = [lineart.display_len(label_str) for label_str in unpadded_labels]
+        max_width = max(lengths)
+        pad_lengths = [max_width - length for length in lengths]
+        padded_labels = [
+            " " * pad_length + label_str
+            for (label_str, pad_length) in zip(unpadded_labels, pad_lengths)
+        ]
+        return padded_labels
+
+    def render_as_x(self, num_cols: int, left_margin: int):
+        """Generate X tick line and X label line.
+
+        Parameters
+        ----------
+        num_cols:    int
+                     Number of data columns
+        left_margin: int
+                     chars to the left of leftmost data col. May have Labels/border-line.
+        """
+
+        if self.labels is None:
+            labels = gen_labels(
+                self.value_range,
+                num_cols // DEFAULT_X_COLS_PER_TICK,
+                MIN_X_TICKS_PER_LABEL,
+                self.label_fmt,
+            )
+        else:
+            labels = self.labels
+
+        label_values = sorted(labels.keys())
+
+        bins = calc_edges(self.value_range, num_cols, self.values_are_edges)
+
+        tick_line = list(
+            " " * (left_margin - 1)
+            + x_border[self.border_line].first
+            + x_border[self.border_line].middle * num_cols
+            + x_border[self.border_line].last
+        )
+
+        label_line = [" "] * len(tick_line)  # labels under the ticks
+
+        for col_idx, (col_min, col_max) in enumerate(bins):
+            # use Decimal.next_plus to accomodate rounding error/truncation
+            if label_values and col_min <= label_values[0] <= col_max.next_plus():
+                add_label(label_line, labels[label_values[0]], col_idx + left_margin)
+                tick_idx = left_margin + col_idx
+                offset_frac = (label_values[0] - col_min) / (col_max - col_min)
+                if self.fractional_tick_pos and offset_frac < 0.25:
+                    if col_idx == 0:
+                        tick_line[tick_idx - 1] = lineart.merge_chars("│", tick_line[tick_idx - 1])
+                    else:
+                        tick_line[tick_idx - 1] = "╱"
+                    tick_line[tick_idx] = "╲"
+                elif self.fractional_tick_pos and offset_frac > 0.75:
+                    tick_line[tick_idx] = "╱"
+                    if col_idx < num_cols - 1:
+                        tick_line[tick_idx + 1] = "╲"
+                    else:
+                        tick_line[tick_idx + 1] = lineart.merge_chars("│", tick_line[tick_idx + 1])
+                else:
+                    tick_line[tick_idx] = lineart.merge_chars("│", tick_line[tick_idx])
+
+                label_values = label_values[1:]  # pop that first label since we added it
+
+        return "".join(tick_line), "".join(label_line)

densitty/binning.py

@@ -0,0 +1,240 @@
+"""Bin point data for a 2-D histogram"""
+
+import math
+from bisect import bisect_right
+from decimal import Decimal
+from typing import Optional, Sequence
+
+from .axis import Axis
+from .util import FloatLike, ValueRange
+from .util import clamp, decimal_value_range, most_round, round_up_ish
+
+
+def bin_edges(
+    points: Sequence[tuple[FloatLike, FloatLike]],
+    x_edges: Sequence[FloatLike],
+    y_edges: Sequence[FloatLike],
+    drop_outside: bool = True,
+) -> Sequence[Sequence[int]]:
+    """Bin points into a 2-D histogram given bin edges
+
+    Parameters
+    ----------
+    points:  Sequence of (X,Y) tuples: the points to bin
+    x_edges: Sequence of values: Edges of the bins in X (N+1 values for N bins)
+    y_edges: Sequence of values: Edges of the bins in Y (N+1 values for N bins)
+    drop_outside: bool (default: True)
+             True: Drop any data points outside the ranges
+             False: Put any outside points in closest bin (i.e. edge bins include outliers)
+    """
+    num_x_bins = len(x_edges) - 1
+    num_y_bins = len(y_edges) - 1
+    out = [[0 for x in range(num_x_bins)] for y in range(num_y_bins)]
+    for x, y in points:
+        x_idx = bisect_right(x_edges, x) - 1
+        y_idx = bisect_right(y_edges, y) - 1
+        if drop_outside:
+            if 0 <= x_idx < num_x_bins and 0 <= y_idx < num_y_bins:
+                out[y_idx][x_idx] += 1
+        else:
+            out[clamp(y_idx, 0, num_y_bins - 1)][clamp(x_idx, 0, num_x_bins - 1)] += 1
+    return out
+
+
+def calc_value_range(values: Sequence[FloatLike]) -> ValueRange:
+    """Calculate a value range from data values"""
+    if not values:
+        # Could raise an exception here, but for now just return _something_
+        return ValueRange(0, 1)
+
+    # bins are closed on left and open on right: i.e. left_edge <= values < right_edge
+    # so, the right-most bin edge needs to be larger than the largest data value:
+    max_value = max(values)
+    range_top = max_value + math.ulp(max_value)  # increase by smallest representable amount
+    return ValueRange(min(values), range_top)
+
+
+def pick_edges(
+    num_bins: int,
+    value_range: ValueRange,
+    align=True,
+) -> Sequence[FloatLike]:
+    """Pick bin edges based on data values.
+
+    Parameters
+    ----------
+    values: Sequence of data values
+    num_bins: int
+              Number of bins to partition into
+    value_range: ValueRange
+              Min/Max of the values to be binned
+    align: bool
+              Adjust the range somewhat to put bin size & edges on "round" values
+    """
+    value_range = decimal_value_range(value_range)  # coerce into Decimal if not already
+
+    min_step_size = (value_range.max - value_range.min) / num_bins
+    if align:
+        step_size = round_up_ish(min_step_size)
+        first_edge = math.floor(Decimal(value_range.min) / step_size) * step_size
+        if first_edge + num_bins * step_size < value_range.max:
+            # Uh oh: even though we rounded up the bin size, shifting the first edge
+            # down to a multiple has shifted the last edge down too far. Bump up the step size:
+            step_size = round_up_ish(step_size * Decimal(1.015625))
+            first_edge = math.floor(Decimal(value_range.min) / step_size) * step_size
+        # we now have a round step size, and a first edge that the highest possible multiple of it
+        # Test to see if any lower multiples of it will still include the whole ranges,
+        # and be "nicer" i.e. if data is all in 1.1..9.5 range with 10 bins, we now have bins
+        # covering 1-11, but could have 0-10
+        last_edge = first_edge + step_size * num_bins
+        num_trials = int((last_edge - value_range.max) // step_size + 1)
+        offsets = (step_size * i for i in range(num_trials))
+        edge_pairs = ((first_edge - offset, last_edge - offset) for offset in offsets)
+        first_edge = most_round(edge_pairs)[0]
+
+    else:
+        step_size = min_step_size
+        first_edge = value_range.min
+
+    num_edges = num_bins + 1
+    return tuple(first_edge + step_size * i for i in range(num_edges))
+
+
+def edge_range(start: FloatLike, end: FloatLike, step: FloatLike, align: bool):
+    """Similar to range/np.arange, but includes "end" in the output if appropriate"""
+    if align:
+        v = math.floor(start / step) * step
+    else:
+        v = start
+    while v < end + step:
+        if align:
+            yield round(v / step) * step
+        else:
+            yield v
+        v += step
+
+
+def bin_with_size(
+    points: Sequence[tuple[FloatLike, FloatLike]],
+    bin_sizes: FloatLike | tuple[FloatLike, FloatLike],
+    ranges: Optional[tuple[ValueRange, ValueRange]] = None,
+    align=True,
+    drop_outside=True,
+    **axis_args,
+) -> tuple[Sequence[Sequence[int]], Axis, Axis]:
+    """Bin points into a 2-D histogram, given bin sizes
+
+    Parameters
+    ----------
+    points: Sequence of (X,Y) tuples: the points to bin
+    bin_sizes: float or tuple(float, float)
+                Size(s) of (X,Y) bins to partition into
+    ranges: Optional (ValueRange, ValueRange)
+                ((x_min, x_max), (y_min, y_max)) for the bins. Default: take from data.
+    align: bool (default: True)
+                Force bin edges to be at a multiple of the bin size
+    drop_outside: bool (default: True)
+                True: Drop any data points outside the ranges
+                False: Put any outside points in closest bin (i.e. edge bins include outliers)
+    axis_args: Extra arguments to pass through to Axis constructor
+
+    returns: Sequence[Sequence[int]], (x-)Axis, (y-)Axis
+    """
+
+    if ranges is None:
+        x_range = calc_value_range(tuple(x for x, _ in points))
+        y_range = calc_value_range(tuple(y for _, y in points))
+    else:
+        x_range, y_range = ValueRange(*ranges[0]), ValueRange(*ranges[1])
+
+    if not isinstance(bin_sizes, tuple):
+        # given just a single bin size: replicate it for both axes:
+        bin_sizes = (bin_sizes, bin_sizes)
+
+    x_edges = tuple(edge_range(x_range.min, x_range.max, bin_sizes[0], align))
+    y_edges = tuple(edge_range(y_range.min, y_range.max, bin_sizes[1], align))
+
+    x_axis = Axis(x_range, values_are_edges=True, **axis_args)
+    y_axis = Axis(y_range, values_are_edges=True, **axis_args)
+
+    return (bin_edges(points, x_edges, y_edges, drop_outside=drop_outside), x_axis, y_axis)
+
+
+def histogram2d(
+    points: Sequence[tuple[FloatLike, FloatLike]],
+    bins: (
+        int
+        | tuple[int, int]
+        | Sequence[FloatLike]
+        | tuple[Sequence[FloatLike], Sequence[FloatLike]]
+    ) = 10,
+    ranges: Optional[tuple[Optional[ValueRange], Optional[ValueRange]]] = None,
+    align=True,
+    drop_outside=True,
+    **axis_args,
+) -> tuple[Sequence[Sequence[int]], Axis, Axis]:
+    """Bin points into a 2-D histogram, given number of bins, or bin edges
+
+    Parameters
+    ----------
+    points: Sequence of (X,Y) tuples: the points to bin
+    bins: int or (int, int) or [float,...] or ([float,...], [float,...])
+                int: number of bins for both X & Y (default: 10)
+                (int,int): number of bins in X, number of bins in Y
+                list[float]: bin edges for both X & Y
+                (list[float], list[float]): bin edges for X, bin edges for Y
+    ranges: Optional (ValueRange, ValueRange)
+                ((x_min, x_max), (y_min, y_max)) for the bins if # of bins is provided
+                Default: take from data.
+    align: bool (default: True)
+                pick bin edges at 'round' values if # of bins is provided
+    drop_outside: bool (default: True)
+                True: Drop any data points outside the ranges
+                False: Put any outside points in closest bin (i.e. edge bins include outliers)
+    axis_args: Extra arguments to pass through to Axis constructor
+
+    returns: Sequence[Sequence[int]], (x-)Axis, (y-)Axis
+    """
+
+    if isinstance(bins, int):
+        # we were given a single # of bins
+        bins = (bins, bins)
+
+    if isinstance(bins, Sequence) and len(bins) > 2:
+        # we were given a single list of bin edges: replicate it
+        bins = (bins, bins)
+
+    if isinstance(bins[0], int):
+        # we were given the number of bins for X. Calculate the edges:
+        if ranges is None or ranges[0] is None:
+            x_range = calc_value_range(tuple(x for x, _ in points))
+        else:
+            x_range = ValueRange(*ranges[0])
+
+        x_edges = pick_edges(bins[0], x_range, align)
+    else:
+        # we were given the bin edges already
+        if ranges is not None and ranges[0] is not None:
+            raise ValueError("Both bin edges and bin ranges provided, pick one or the other")
+        assert isinstance(bins[0], Sequence)
+        x_edges = bins[0]
+
+    if isinstance(bins[1], int):
+        # we were given the number of bins. Calculate the edges:
+        if ranges is None or ranges[1] is None:
+            y_range = calc_value_range(tuple(y for _, y in points))
+        else:
+            y_range = ValueRange(*ranges[1])
+
+        y_edges = pick_edges(bins[1], y_range, align)
+    else:
+        # we were given the bin edges already
+        if ranges is not None and ranges[1] is not None:
+            raise ValueError("Both bin edges and bin ranges provided, pick one or the other")
+        assert isinstance(bins[1], Sequence)
+        y_edges = bins[1]
+
+    x_axis = Axis((x_edges[0], x_edges[-1]), values_are_edges=True, **axis_args)
+    y_axis = Axis((y_edges[0], y_edges[-1]), values_are_edges=True, **axis_args)
+
+    return (bin_edges(points, x_edges, y_edges, drop_outside), x_axis, y_axis)