jarvisplot 1.0.0__py3-none-any.whl

jarvisplot/Figure/helper.py

@@ -0,0 +1,217 @@
+# jarvisplot/Figure/helper.py
+#!/usr/bin/env python3
+
+from matplotlib.axes import Axes
+import numpy as np
+
+def split_fill_kwargs(kw_all):
+    edge_kws = {
+        "edgecolor", "ec",
+        "linewidth", "lw",
+        "linestyle", "ls",
+        "joinstyle", "capstyle",
+        "alpha"
+    }
+    face_kws = {
+        "facecolor", "fc",
+        "hatch",
+        "hatch_linewidth",
+        "alpha", "edgecolor"
+    }
+    kw_edge = {}
+    kw_face = {}
+    kw_rest = {}
+    for k, v in kw_all.items():
+        if k in edge_kws:
+            kw_edge[k] = v
+        if k in face_kws:
+            kw_face[k] = v
+        else:
+            kw_rest[k] = v
+    return kw_edge, kw_face, kw_rest
+
+def plot_shapely_boundary(ax, geom, *, transform=None, **plot_kw):
+    if geom is None or geom.is_empty:
+        return []
+
+    lines = []
+    gt = geom.geom_type
+    if gt == "LineString":
+        lines = [geom]
+    elif gt == "MultiLineString":
+        lines = list(geom.geoms)
+    elif gt == "GeometryCollection":
+        for g in geom.geoms:
+            if g.geom_type == "LineString":
+                lines.append(g)
+            elif g.geom_type == "MultiLineString":
+                lines.extend(list(g.geoms))
+    else:
+        # 兜底：有时 boundary 可能给出别的类型
+        try:
+            b = geom.boundary
+            return _plot_shapely_boundary(ax, b, transform=transform, **plot_kw)
+        except Exception:
+            return []
+
+    artists = []
+    for ln in lines:
+        xs, ys = ln.coords.xy
+        artists += ax.plot(list(xs), list(ys), transform=transform, **plot_kw)
+    return artists
+
+
+# helper: convert infinite regions to finite polygons (public-domain recipe)
+# Clip polygon to rectangle extent (Sutherland-Hodgman for convex quad)
+def voronoi_finite_polygons_2d(vor, radius=None):
+    if vor.points.shape[1] != 2:
+        raise ValueError("Requires 2D input")
+    new_regions = []
+    new_vertices = vor.vertices.tolist()
+    center = vor.points.mean(axis=0)
+    if radius is None:
+        radius = np.ptp(vor.points).max() * 2
+    # Construct a map ridge_vertices -> points (pairs)
+    all_ridges = {}
+    for (p1, p2), (v1, v2) in zip(vor.ridge_points, vor.ridge_vertices):
+        all_ridges.setdefault(p1, []).append((p2, v1, v2))
+        all_ridges.setdefault(p2, []).append((p1, v1, v2))
+    # Reconstruct infinite regions
+    for p1, region_index in enumerate(vor.point_region):
+        vertices = vor.regions[region_index]
+        if -1 not in vertices:
+            new_regions.append(vertices)
+            continue
+        ridges = all_ridges[p1]
+        new_region = [v for v in vertices if v != -1]
+        for p2, v1, v2 in ridges:
+            if v2 < 0: v1, v2 = v2, v1
+            if v1 >= 0 and v2 >= 0:
+                continue
+            # Compute the missing endpoint at infinity
+            t = vor.points[p2] - vor.points[p1]
+            t /= np.linalg.norm(t)
+            n = np.array([-t[1], t[0]])  # normal
+            midpoint = vor.points[[p1, p2]].mean(axis=0)
+            direction = np.sign(np.dot(midpoint - center, n)) * n
+            far_point = vor.vertices[v2] + direction * radius
+            new_region.append(len(new_vertices))
+            new_vertices.append(far_point.tolist())
+        # Sort region vertices counterclockwise
+        vs = np.asarray([new_vertices[v] for v in new_region])
+        c = vs.mean(axis=0)
+        angles = np.arctan2(vs[:, 1] - c[1], vs[:, 0] - c[0])
+        new_region = np.array(new_region)[np.argsort(angles)].tolist()
+        new_regions.append(new_region)
+    return new_regions, np.asarray(new_vertices)
+
+
+def _clip_poly_to_rect(poly, rect):
+    # rect: (xmin, xmax, ymin, ymax)
+    xmin, xmax, ymin, ymax = rect
+    def _clip(edges, inside, intersect):
+        out = []
+        if not edges:
+            return out
+        S = edges[-1]
+        for E in edges:
+            if inside(E):
+                if inside(S):
+                    out.append(E)
+                else:
+                    out.append(intersect(S, E))
+                    out.append(E)
+            elif inside(S):
+                out.append(intersect(S, E))
+            S = E
+        return out
+    def clip_left(P):
+        return _clip(P, lambda p: p[0] >= xmin, lambda s ,e: (xmin, s[1] + (e[1 ] -s[1] ) *(xmin - s[0] ) /(e[0 ] -s[0]) ))
+    def clip_right(P):
+        return _clip(P, lambda p: p[0] <= xmax, lambda s ,e: (xmax, s[1] + (e[1 ] -s[1] ) *(xmax - s[0] ) /(e[0 ] -s[0]) ))
+    def clip_bottom(P):
+        return _clip(P, lambda p: p[1] >= ymin, lambda s ,e: (s[0] + (e[0 ] -s[0] ) *(ymin - s[1] ) /(e[1 ] -s[1]), ymin ))
+    def clip_top(P):
+        return _clip(P, lambda p: p[1] <= ymax, lambda s ,e: (s[0] + (e[0 ] -s[0] ) *(ymax - s[1] ) /(e[1 ] -s[1]), ymax ))
+    P = poly
+    for fn in (clip_left, clip_right, clip_bottom, clip_top):
+        P = fn(P)
+        if not P:
+            break
+    return P
+
+
+
+# ---- helpers for masking by extend on filled contours ----
+
+def _resolve_vlim(z, vmin=None, vmax=None, levels=None, norm=None):
+    """Derive effective vmin/vmax from norm/levels/fallback to data."""
+    import numpy as np
+    if norm is not None:
+        vmin = getattr(norm, "vmin", vmin)
+        vmax = getattr(norm, "vmax", vmax)
+    if levels is not None and np.ndim(levels) > 0:
+        vmin = levels[0] if vmin is None else vmin
+        vmax = levels[-1] if vmax is None else vmax
+    if vmin is None:
+        vmin = float(np.nanmin(z))
+    if vmax is None:
+        vmax = float(np.nanmax(z))
+    return float(vmin), float(vmax)
+
+
+def _mask_by_extend(z, *, extend="neither", vmin=None, vmax=None, levels=None, norm=None):
+    """
+    Return masked z according to extend semantics:
+      - 'min'  : mask z < vmin
+      - 'max'  : mask z > vmax
+      - 'both' : mask outside [vmin, vmax]
+      - 'neither': no masking
+    Also returns effective (vmin, vmax).
+    """
+    import numpy as np
+    z = np.asarray(z)
+    e = (extend or "neither").lower()
+    if e not in ("neither", "min", "max", "both"):
+        e = "neither"
+    vmin_eff, vmax_eff = _resolve_vlim(z, vmin=vmin, vmax=vmax, levels=levels, norm=norm)
+    mask = np.zeros_like(z, dtype=bool)
+    if e in ("min", "both"):
+        mask |= (z < vmin_eff)
+    if e in ("max", "both"):
+        mask |= (z > vmax_eff)
+    return np.ma.masked_array(z, mask=mask), vmin_eff, vmax_eff
+
+# —— 小工具：对 artist 或容器做统一 clip_path 应用 ——
+def _auto_clip(artists, ax: Axes, clip_path):
+    if clip_path is None:
+        return artists
+    def _apply_one(a):
+        try:
+            a.set_clip_path(clip_path, transform=ax.transData)
+        except Exception:
+            pass
+    # always apply to the container itself first
+    _apply_one(artists)
+    try:
+        iter(artists)
+    except TypeError:
+        return artists
+    else:
+        for item in artists:
+            # 先试 artist 本体
+            _apply_one(item)
+            # matplotlib 常见容器：collections / patches / lines
+            coll = getattr(item, "collections", None)
+            if coll:
+                for c in coll:
+                    _apply_one(c)
+            patches = getattr(item, "patches", None)
+            if patches:
+                for p in patches:
+                    _apply_one(p)
+            lines = getattr(item, "lines", None)
+            if lines:
+                for ln in lines:
+                    _apply_one(ln)
+        return artists

jarvisplot/Figure/load_data.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3 
+
+import numpy as np 
+import pandas as pd 
+import json
+from copy import deepcopy
+
+def eval_series(df: pd.DataFrame, set: dict, logger):
+    """
+    Evaluate an expression/column name against df safely.
+    - If expr is a direct column name, returns that series.
+    - If expr is a python expression, eval with df columns in scope.
+    """
+    try: 
+        logger.debug("Loading variable expression -> {}".format(set['expr'])) 
+    except: 
+        pass 
+    if not "expr" in set.keys():
+        raise ValueError(f"expr need for axes {set}.")
+    if set["expr"] in df.columns:
+        arr = df[set["expr"]].values
+        if np.isnan(arr).sum() and "fillna" in set.keys():
+            arr = np.where(np.isnan(arr), float(set['fillna']), arr)
+    else: 
+        # safe-ish eval with only df columns in locals
+        local_vars = df.to_dict("series")
+        import math
+        from ..inner_func import update_funcs
+        allowed_globals = update_funcs({"np": np, "math": math})
+        arr = eval(set["expr"], allowed_globals, local_vars)
+        if np.isnan(arr).sum() and "fillna" in set.keys():
+            arr = np.where(np.isnan(arr), float(set['fillna']), arr)
+    return np.asarray(arr)
+
+
+def profiling(df, prof, logger):
+    def profile_bridson_sorted(idx, xx, yy, zz, radius, msk):
+        for i in range(len(idx)):
+            if not msk[i]:
+                continue
+            dx = xx[idx > idx[i]] - xx[i]
+            dy = yy[idx > idx[i]] - yy[i]
+            dz = zz[idx > idx[i]] - zz[i]
+            dist0 = (dx**2 + dy**2)**0.5
+            dist1 = (dx**2 + dy**2 + dz**2)**0.5
+            near0 = (dist0 < 0.707 * radius) | (dist0 < radius) & (dist1 > radius)
+            sel = (idx > idx[i])
+            msk[sel] &= ~near0                     
+        return msk
+            
+    bin     = prof.get("bin", 100)
+    coors   = prof.get("coordinates", {})
+    obj     = prof.get("objective", "max")
+    grid    = prof.get("grid_points", "rect")
+    gdata   = None 
+
+    radius  = 1 / bin 
+    if "expr" in coors['x'].keys():
+        x = eval_series(df, coors['x'], logger)
+    else: 
+        x = df['x']
+    
+    if "expr" in coors['y'].keys():
+        y = eval_series(df, coors['y'], logger)
+    else: 
+        y = df['y']
+        
+    if "expr" in coors['z'].keys():
+        z = eval_series(df, coors['z'], logger)
+    else: 
+        z = df['z']
+
+    logger.debug("After loading profiling x, y, z. ")
+
+    if grid == "ternary":
+        xlim = coors['x'].get("lim", [0, 1])
+        ylim = coors['y'].get("lim", [0, 1])
+        zlim = coors['z'].get("lim", [np.min(z), np.max(z)])
+        xscale = coors['x'].get("scale", "linear")
+        yscale = coors['y'].get("scale", "linear")
+        zscale = coors['z'].get("scale", "linear")
+        zind   = coors['z'].get("name", "z")
+        xind   = coors['x'].get("name", "x")
+        yind   = coors['y'].get("name", "y")
+    elif grid == "rect":
+        xlim = coors['x'].get("lim", [np.min(x), np.max(x)])
+        ylim = coors['y'].get("lim", [np.min(y), np.max(y)])
+        zlim = coors['z'].get("lim", [np.min(z), np.max(z)])
+
+        xscale = coors['x'].get("scale", "linear")
+        yscale = coors['y'].get("scale", "linear")
+        zscale = coors['z'].get("scale", "linear")
+
+        zind = coors['z'].get("name", "z")
+        xind = coors['x'].get("name", "x")
+        yind = coors['y'].get("name", "y") 
+
+
+    # profiling will add new columns into dataframe, so that can be used in the next step
+    df[xind] = x 
+    df[yind] = y
+    df[zind] = z
+            # print(x.min(), x.max(), y.min(), y.max(), z.min(), z.max())
+
+
+    if grid == "ternary":
+        bb = np.linspace(0, 1, bin + 1)
+        rr = np.linspace(0, 1, bin + 1)
+        Bg, Rg = np.meshgrid(bb, rr)
+        r = Rg.ravel()
+        b = Bg.ravel() 
+        l = 1.0 - b - r
+        mask = (l >= 0) & (b >= 0) & (r >= 0)
+        x = b + 0.5 * r 
+        y = r 
+        xxg, yyg = x[mask], y[mask]
+        llg, bbg, rrg, = l[mask], b[mask], r[mask]
+        gdata = pd.DataFrame({
+            xind: xxg, 
+            yind: yyg, 
+            zind: np.ones(xxg.shape) * (np.min(z) - 0.1)
+        })
+
+    elif grid == "rect":
+        xx = np.linspace(xlim[0], xlim[1], bin+1)
+        yy = np.linspace(ylim[0], ylim[1], bin+1)
+        xg, yg = np.meshgrid(xx, yy)
+
+        gdata = pd.DataFrame({
+            xind: xg.ravel(),
+            yind: yg.ravel(),
+            zind: np.ones(xg.ravel().shape) * (np.min(z) - 0.1)
+        })
+
+    if obj == "max":    
+        df = df.sort_values(zind, ascending=False).reset_index(drop=True)
+    elif obj == "min":
+        df = df.sort_values(zind, ascending=True).reset_index(drop=True)
+    else:
+        df = df.sort_values(zind, ascending=False).reset_index(drop=True)
+        logger.error("Sort dataset method: objective: {} not support, using default value -> 'max'".format(obj))
+    df = pd.concat([df, gdata], ignore_index=True)
+                        
+    idx = deepcopy(np.array(df.index))
+    xx  = deepcopy(np.array(df[xind]))
+    yy  = deepcopy(np.array(df[yind]))
+    zz  = deepcopy(np.array(df[zind]))
+            # mapping xx, yy, zz to range [0, 1]
+    if xscale == "log":
+        xx = (np.log(xx) - np.log(xlim[0])) / (np.log(xlim[1]) - np.log(xlim[0]))
+    else:  # linear scale
+        xx = (xx - xlim[0]) / (xlim[1] - xlim[0])
+
+    if yscale == "log":
+        yy = (np.log(yy) - np.log(ylim[0])) / (np.log(ylim[1]) - np.log(ylim[0]))
+    else:  # linear scale
+        yy = (yy - ylim[0]) / (ylim[1] - ylim[0])
+
+    if zscale == "log":
+        zz = (np.log(zz) - np.log(zlim[0])) / (np.log(zlim[1]) - np.log(zlim[0]))
+    else:  # linear scale
+        zz = (zz - zlim[0]) / (zlim[1] - zlim[0])
+
+    # (removed print(radius))
+    msk = np.full(idx.shape, True)
+    msk = profile_bridson_sorted(idx, xx, yy, zz, radius, msk)
+    df = df.iloc[idx[msk]]
+
+    return df 
+
+
+    
+        
+
+
+def filter(df, condition, logger):
+    try:
+        if isinstance(condition, bool):
+            return df.copy() if condition else df.iloc[0:0].copy()
+        if isinstance(condition, (int, float)) and condition in (0, 1):
+            return df.copy() if int(condition) == 1 else df.iloc[0:0].copy()
+        
+        if isinstance(condition, str):
+            s = condition.strip()
+            low = s.lower()
+            if low in {"true", "t", "yes", "y"}:
+                return df.copy()
+            if low in {"false", "f", "no", "n"}:
+                return df.iloc[0:0].copy()
+            s = s.replace("&&", " & ").replace("||", " | ")
+            condition = s
+        else:
+            raise TypeError(f"Unsupported condition type: {type(condition)}")
+
+        from ..inner_func import update_funcs
+        import math
+        allowed_globals = update_funcs({"np": np, "math": math})
+        local_vars = df.to_dict("series")
+        mask = eval(condition, allowed_globals, local_vars)
+
+        if isinstance(mask, (bool, np.bool_, int, float)):
+            return df.copy() if bool(mask) else df.iloc[0:0].copy()
+        if not isinstance(mask, pd.Series):
+            mask = pd.Series(mask, index=df.index)
+        mask = mask.astype(bool)
+        return df[mask].copy()
+    except Exception as e:
+        logger.error(f"Errors when evaluating condition -> {condition}:\n\t{e}")
+        return pd.DataFrame(index=df.index).iloc[0:0].copy()
+
+def addcolumn(df, adds, logger):
+    try: 
+        name = adds.get("name", False)
+        expr = adds.get("expr", False)
+        if not (name and expr):
+            logger.error("Error in loading add_column -> {}".format(adds))
+        from ..inner_func import update_funcs
+        import math
+        allowed_globals = update_funcs({"np": np, "math": math})
+        local_vars = df.to_dict("series") 
+        value = eval(str(expr), allowed_globals, local_vars)
+        df[name] = value 
+        return df
+    except Exception as e: 
+        logger.error("Errors when add new column -> {}:\n\t{}".format(adds, json.dumps(e)))   
+        return df               
+        
+def sortby(df, expr, logger):
+    try:
+        return sort_df_by_expr(df, expr)
+    except Exception as e:
+        logger.warning(f"sortby failed for expr={expr}: {e}")
+        return df
+
+def sort_df_by_expr(self, df: pd.DataFrame, expr: str, logger) -> pd.DataFrame:
+    """
+    Sort the dataframe by evaluating the given expression.
+    The expression can be a column name or a valid expression understood by _eval_series.
+    Returns a new DataFrame sorted ascending by the evaluated values.
+    """
+    if df is None or expr is None:
+        return df
+    try:
+        # Try evaluate as expression (could be column or expression)
+        values = eval_series(df, {"expr": expr}, logger)
+        df = df.assign(__sortkey__=values)
+        df = df.sort_values(by="__sortkey__", ascending=True)
+        df = df.drop(columns=["__sortkey__"])
+        return df
+    except Exception as e:
+        logger.warning(f"LB: sortby failed for expr={expr}: {e}")
+        return df   

jarvisplot/cards/a4paper/1x1/ternary.json

@@ -0,0 +1,6 @@
+{
+    "Figure":   {
+        "figsize": []
+    },
+    "Style":    {}
+}

jarvisplot/cards/a4paper/2x1/rect.json

@@ -0,0 +1,106 @@
+{
+    "Frame": {
+        "figure": {
+            "figsize": [
+                3.3,
+                2.75
+            ]
+        },
+        "axes": {
+            "axlogo": {
+                "rect": [
+                    0.01,
+                    0.01,
+                    0.06,
+                    0.072
+                ],
+                "frameon": false,
+                "yticks": [],
+                "xticks": [],
+                "xlim": [
+                    0,
+                    1024
+                ],
+                "ylim": [
+                    1024,
+                    0
+                ]
+            },
+            "ax": {
+                "rect": [
+                    0.140,
+                    0.168,
+                    0.840,
+                    0.775
+                ]
+            }
+        },
+        "ax": {
+            "frame": {
+                "linewidth": 0.8,
+                "solid_capstyle": "projecting",
+                "solid_joinstyle": "miter",
+                "clip_on": false,
+                "c": "#21171A",
+                "zorder": 100
+            },
+            "grid": {
+                "sep": 0.1,
+                "style": {
+                    "color": "#C2C2C269",
+                    "linewidth": 0.3,
+                    "linestyle": "--"
+                }
+            },
+            "ticks": {
+                "both": {
+                    "labelsize": 6,
+                    "direction": "in",
+                    "labelfontfamily": "sans",
+                    "top": true,
+                    "left": true,
+                    "right": true,
+                    "bottom": true,
+                    "which": "both"
+                },
+                "major": {
+                    "which": "major",
+                    "length": 4,
+                    "width": 0.4,
+                    "color": "black"
+                },
+                "minor": {
+                    "which": "minor",
+                    "length": 2,
+                    "width": 0.4,
+                    "color": "black"
+                }
+            },
+            "labels": {
+                "xlabel": {
+                    "loc": "right",
+                    "fontsize": 12,
+                    "fontfamily": "STIXGeneral"
+                },
+                "ylabel": {
+                    "loc": "top",
+                    "fontsize": 12,
+                    "fontfamily": "STIXGeneral"
+                }
+            }
+        },
+        "axlogo": {
+            "file": "&JP/jarvisplot/cards/icons/JarvisHEP.png"
+        }
+    },
+    "Style": {
+        "scatter": {
+            "s": 1.0,
+            "marker": "^",
+            "linewidths": 0.02,
+            "alpha": 1.0,
+            "zorder": 30,
+            "edgecolor": "white"
+        }
+    }
+}