diff --git a/examples/bar_plot.py b/examples/bar_plot.py new file mode 100644 index 0000000..ed10def --- /dev/null +++ b/examples/bar_plot.py @@ -0,0 +1,11 @@ +from spectralforensics import bar_plot + + +if __name__ == "__main__": + bar_plot( + {"model": ["A", "B", "A", "B"], + "spectral_entropy": [2.1, 2.5, 2.2, 2.9], + "anisotropy": [0.1, -0.3, 0.2, 0.4]}, + x="model", y="spectral_entropy", + title="Análise espectral — barras", + ) diff --git a/examples/box_plot.py b/examples/box_plot.py new file mode 100644 index 0000000..c2a3b88 --- /dev/null +++ b/examples/box_plot.py @@ -0,0 +1,8 @@ +from spectralforensics import box_plot + + +if __name__ == "__main__": + dataset = {"income": ["<=50K", "<=50K", "<=50K", ">50K", ">50K", ">50K"], + "hours-per-week": [30, 40, 45, 40, 50, 60]} + box_plot(dataset, x="income", y="hours-per-week", + fill=False, gap=.1, palette="pastel") diff --git a/examples/correlation_plot.py b/examples/correlation_plot.py new file mode 100644 index 0000000..63620a1 --- /dev/null +++ b/examples/correlation_plot.py @@ -0,0 +1,12 @@ +from spectralforensics import correlation_plot + + +if __name__ == "__main__": + result = correlation_plot( + {"entropy": [2.1, 2.5, 2.2, 2.9, 2.6], + "anisotropy": [0.1, 0.3, 0.2, 0.4, 0.25], + "target": [0, 1, 0, 1, 1]}, + correlation_columns=["entropy", "anisotropy", "target"], + method="pearson", cmap="coolwarm", center=0, annot=True, fmt=".2f", + target="target", kind="barh", by="target", + ) diff --git a/examples/line_plot.py b/examples/line_plot.py new file mode 100644 index 0000000..3c5b27d --- /dev/null +++ b/examples/line_plot.py @@ -0,0 +1,10 @@ +from spectralforensics import line_plot + + +if __name__ == "__main__": + line_plot( + {"sample": [1, 2, 3, 4, 5], + "spectral_entropy": [2.1, 2.5, 2.2, 2.9, 2.6], + "anisotropy": [0.1, 0.3, 0.2, 0.4, 0.25]}, + x="sample", y="spectral_entropy", + ) diff --git a/examples/scatter_plot.py b/examples/scatter_plot.py new file mode 100644 index 0000000..3fd7c1a --- /dev/null +++ b/examples/scatter_plot.py @@ -0,0 +1,11 @@ +from spectralforensics import scatter_plot + + +if __name__ == "__main__": + scatter_plot( + {"dominant_frequency": [1, 2, 2, 3, 4], + "anisotropy": [0.1, 0.3, 0.2, 0.4, 0.25], + "spectral_entropy": [2.1, 2.5, 2.2, 2.9, 2.6]}, + x="dominant_frequency", y="anisotropy", + title="Análise espectral — dispersão", + ) diff --git a/pyproject.toml b/pyproject.toml index ced86e3..ff56a01 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -26,12 +26,16 @@ dependencies = [ "pandas", "scipy", "matplotlib", + "seaborn>=0.13", "scikit-image" ] [tool.setuptools] package-dir = {"" = "src"} +[tool.setuptools.package-data] +spectralforensics = ["assets/*.png"] + [tool.setuptools.packages.find] where = ["src"] -include = ["spectralforensics*"] \ No newline at end of file +include = ["spectralforensics*"] diff --git a/src/spectralforensics/__init__.py b/src/spectralforensics/__init__.py index 78f4077..19d900d 100644 --- a/src/spectralforensics/__init__.py +++ b/src/spectralforensics/__init__.py @@ -1,3 +1,8 @@ from .dataset import extract_features +from .plotting import line_plot +from .plotting_bars import bar_plot +from .plotting_scatter import scatter_plot +from .plotting_correlation import correlation_plot +from .plotting_box import box_plot -__all__ = ["extract_features"] \ No newline at end of file +__all__ = ["extract_features", "line_plot", "bar_plot", "scatter_plot", "correlation_plot", "box_plot"] diff --git a/src/spectralforensics/__pycache__/__init__.cpython-312.pyc b/src/spectralforensics/__pycache__/__init__.cpython-312.pyc index b6bd92b..d63a3ab 100644 Binary files a/src/spectralforensics/__pycache__/__init__.cpython-312.pyc and b/src/spectralforensics/__pycache__/__init__.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/__init__.cpython-314.pyc b/src/spectralforensics/__pycache__/__init__.cpython-314.pyc index 6540247..7505a5e 100644 Binary files a/src/spectralforensics/__pycache__/__init__.cpython-314.pyc and b/src/spectralforensics/__pycache__/__init__.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/_widgets.cpython-312.pyc b/src/spectralforensics/__pycache__/_widgets.cpython-312.pyc new file mode 100644 index 0000000..85b294f Binary files /dev/null and b/src/spectralforensics/__pycache__/_widgets.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/_widgets.cpython-314.pyc b/src/spectralforensics/__pycache__/_widgets.cpython-314.pyc new file mode 100644 index 0000000..d77d40f Binary files /dev/null and b/src/spectralforensics/__pycache__/_widgets.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/dataset.cpython-312.pyc b/src/spectralforensics/__pycache__/dataset.cpython-312.pyc index f20cdfd..51e6d5e 100644 Binary files a/src/spectralforensics/__pycache__/dataset.cpython-312.pyc and b/src/spectralforensics/__pycache__/dataset.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/dataset.cpython-314.pyc b/src/spectralforensics/__pycache__/dataset.cpython-314.pyc index 43f8d30..d04df57 100644 Binary files a/src/spectralforensics/__pycache__/dataset.cpython-314.pyc and b/src/spectralforensics/__pycache__/dataset.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/features.cpython-312.pyc b/src/spectralforensics/__pycache__/features.cpython-312.pyc index ec91699..d42aed2 100644 Binary files a/src/spectralforensics/__pycache__/features.cpython-312.pyc and b/src/spectralforensics/__pycache__/features.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/features.cpython-314.pyc b/src/spectralforensics/__pycache__/features.cpython-314.pyc index 8e66905..acfc462 100644 Binary files a/src/spectralforensics/__pycache__/features.cpython-314.pyc and b/src/spectralforensics/__pycache__/features.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting.cpython-312.pyc b/src/spectralforensics/__pycache__/plotting.cpython-312.pyc new file mode 100644 index 0000000..cdb8554 Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting.cpython-314.pyc b/src/spectralforensics/__pycache__/plotting.cpython-314.pyc new file mode 100644 index 0000000..bc1db7e Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_bars.cpython-312.pyc b/src/spectralforensics/__pycache__/plotting_bars.cpython-312.pyc new file mode 100644 index 0000000..cb43131 Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_bars.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_bars.cpython-314.pyc b/src/spectralforensics/__pycache__/plotting_bars.cpython-314.pyc new file mode 100644 index 0000000..0a21614 Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_bars.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_box.cpython-312.pyc b/src/spectralforensics/__pycache__/plotting_box.cpython-312.pyc new file mode 100644 index 0000000..9a6939e Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_box.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_box.cpython-314.pyc b/src/spectralforensics/__pycache__/plotting_box.cpython-314.pyc new file mode 100644 index 0000000..62f28c8 Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_box.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_correlation.cpython-312.pyc b/src/spectralforensics/__pycache__/plotting_correlation.cpython-312.pyc new file mode 100644 index 0000000..afe074f Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_correlation.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_correlation.cpython-314.pyc b/src/spectralforensics/__pycache__/plotting_correlation.cpython-314.pyc new file mode 100644 index 0000000..ad1ee00 Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_correlation.cpython-314.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_scatter.cpython-312.pyc b/src/spectralforensics/__pycache__/plotting_scatter.cpython-312.pyc new file mode 100644 index 0000000..4a64f71 Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_scatter.cpython-312.pyc differ diff --git a/src/spectralforensics/__pycache__/plotting_scatter.cpython-314.pyc b/src/spectralforensics/__pycache__/plotting_scatter.cpython-314.pyc new file mode 100644 index 0000000..b92a87f Binary files /dev/null and b/src/spectralforensics/__pycache__/plotting_scatter.cpython-314.pyc differ diff --git a/src/spectralforensics/_widgets.py b/src/spectralforensics/_widgets.py new file mode 100644 index 0000000..f567826 --- /dev/null +++ b/src/spectralforensics/_widgets.py @@ -0,0 +1,128 @@ +import tkinter as tk +from tkinter import ttk + +class CheckCombobox(ttk.Combobox): + + def __init__(self, *args, **kwargs): + self._popup = None + self._list = None + self._index = -1 + super().__init__(*args, **kwargs) + self.bind("", self._toggle_popup) + self.bind("", self._open) + self.bind("", self._open) + self.bind("", self._close) + self.bind("", self._destroyed, add="+") + + def current(self, newindex=None): + if newindex is not None: + self._index = newindex + return super().current(newindex) + return self._index + + def configure(self, cnf=None, **kwargs): + result = super().configure(cnf, **kwargs) + if self._popup is not None and ("values" in kwargs or + isinstance(cnf, dict) and "values" in cnf): + position = self._list.yview()[0] + self._list.delete(0, "end") + for value in self["values"]: + self._list.insert("end", value) + if 0 <= self._index < self._list.size(): + self._list.selection_set(self._index) + self._list.activate(self._index) + self._list.yview_moveto(position) + return result + + config = configure + + def _toggle_popup(self, event=None): + if self._popup is None: + return self._open(event) + return self._close(event) + + def _open(self, event=None): + if "disabled" in self.state() or self._popup is not None: + return "break" + values = self["values"] + if not values: + return "break" + popup = self._popup = tk.Toplevel(self) + popup.withdraw() + popup.overrideredirect(True) + popup.transient(self.winfo_toplevel()) + container = ttk.Frame(popup, borderwidth=1, relief="solid") + container.pack(fill="both", expand=True) + choices = self._list = tk.Listbox(container, height=min(12, len(values)), + exportselection=False, activestyle="dotbox") + scrollbar = ttk.Scrollbar(container, orient="vertical", command=choices.yview) + choices.configure(yscrollcommand=scrollbar.set) + scrollbar.pack(side="right", fill="y") + choices.pack(side="left", fill="both", expand=True) + for value in values: + choices.insert("end", value) + popup.update_idletasks() + width = max(self.winfo_width(), popup.winfo_reqwidth()) + height = popup.winfo_reqheight() + x = max(0, min(self.winfo_rootx(), self.winfo_screenwidth() - width)) + y = self.winfo_rooty() + self.winfo_height() + if y + height > self.winfo_screenheight(): + y = max(0, self.winfo_rooty() - height) + popup.geometry(f"{width}x{height}+{x}+{y}") + choices.bind("", self._click) + choices.bind("", self._choose) + choices.bind("", self._choose) + popup.bind("", self._close) + popup.bind("", self._outside) + popup.bind("", self._focus_out) + popup.deiconify() + popup.grab_set() + choices.focus_set() + return "break" + + def _click(self, event): + index = self._list.nearest(event.y) + bounds = self._list.bbox(index) + if bounds and bounds[1] <= event.y < bounds[1] + bounds[3]: + self._choose(index=index) + return "break" + + def _choose(self, event=None, index=None): + if self._list is None or not self._list.size(): + return "break" + self._index = self._list.index("active") if index is None else index + self._list.selection_clear(0, "end") + self._list.selection_set(self._index) + self._list.activate(self._index) + self.event_generate("<>") + return "break" + + def _outside(self, event): + popup = self._popup + if popup is not None and not (popup.winfo_rootx() <= event.x_root < + popup.winfo_rootx() + popup.winfo_width() and + popup.winfo_rooty() <= event.y_root < + popup.winfo_rooty() + popup.winfo_height()): + self._close() + + def _focus_out(self, event): + self.after_idle(self._check_focus) + + def _check_focus(self): + if self._popup is not None: + focus = self.focus_get() + if focus is None or not str(focus).startswith(str(self._popup) + "."): + self._close() + + def _close(self, event=None): + if self._popup is not None: + popup, self._popup = self._popup, None + self._list = None + if popup.winfo_exists(): + popup.grab_release() + popup.destroy() + return "break" + + def _destroyed(self, event): + if event.widget is self: + self._close() diff --git a/src/spectralforensics/assets/copy.png b/src/spectralforensics/assets/copy.png new file mode 100644 index 0000000..a9368a6 Binary files /dev/null and b/src/spectralforensics/assets/copy.png differ diff --git a/src/spectralforensics/assets/refresh-page-option.png b/src/spectralforensics/assets/refresh-page-option.png new file mode 100644 index 0000000..eb140a8 Binary files /dev/null and b/src/spectralforensics/assets/refresh-page-option.png differ diff --git a/src/spectralforensics/assets/undo.png b/src/spectralforensics/assets/undo.png new file mode 100644 index 0000000..9ac3cdb Binary files /dev/null and b/src/spectralforensics/assets/undo.png differ diff --git a/src/spectralforensics/plotting.py b/src/spectralforensics/plotting.py new file mode 100644 index 0000000..0f091d0 --- /dev/null +++ b/src/spectralforensics/plotting.py @@ -0,0 +1,454 @@ +import numpy as np +import pandas as pd +import colorsys, ctypes, io, sys +from pathlib import Path +from PIL import Image, ImageTk, ImageGrab +from ctypes import wintypes +from tkinter import messagebox +from ._widgets import CheckCombobox + +def _clip_segment(a, b): + delta = b - a + start, end = 0., 1. + for axis in range(2): + if delta[axis] == 0: + if not 0 <= a[axis] <= 1: + return None + else: + lo, hi = sorted(((0 - a[axis]) / delta[axis], + (1 - a[axis]) / delta[axis])) + start, end = max(start, lo), min(end, hi) + if start > end: + return None + return np.array([a + start * delta, a + end * delta]) + +def _copy_canvas(canvas): + if sys.platform != "win32": + raise RuntimeError("A cópia de imagem está disponível no Windows.") + canvas.update_idletasks() + x, y = canvas.winfo_rootx(), canvas.winfo_rooty() + image = ImageGrab.grab((x, y, x + canvas.winfo_width(), + y + canvas.winfo_height()), all_screens=True) + buffer = io.BytesIO() + image.convert("RGB").save(buffer, "BMP") + data = buffer.getvalue()[14:] + kernel, user = ctypes.windll.kernel32, ctypes.windll.user32 + kernel.GlobalAlloc.argtypes = [wintypes.UINT, ctypes.c_size_t] + kernel.GlobalAlloc.restype = wintypes.HGLOBAL + kernel.GlobalLock.argtypes = [wintypes.HGLOBAL] + kernel.GlobalLock.restype = ctypes.c_void_p + kernel.GlobalUnlock.argtypes = [wintypes.HGLOBAL] + kernel.GlobalFree.argtypes = [wintypes.HGLOBAL] + user.OpenClipboard.argtypes = [wintypes.HWND] + user.SetClipboardData.argtypes = [wintypes.UINT, wintypes.HANDLE] + user.SetClipboardData.restype = wintypes.HANDLE + handle = kernel.GlobalAlloc(0x0002, len(data)) + if not handle: + raise RuntimeError("Não foi possível reservar memória para a imagem.") + try: + pointer = kernel.GlobalLock(handle) + if not pointer: + raise RuntimeError("Não foi possível preparar a imagem.") + try: + ctypes.memmove(pointer, data, len(data)) + finally: + kernel.GlobalUnlock(handle) + if not user.OpenClipboard(canvas.winfo_id()): + raise RuntimeError("A área de transferência está ocupada. Tente novamente.") + try: + if not user.EmptyClipboard() or not user.SetClipboardData(8, handle): + raise RuntimeError("Não foi possível copiar a imagem.") + handle = None + finally: + user.CloseClipboard() + finally: + if handle: + kernel.GlobalFree(handle) + +def _category_color(index): + rgb = colorsys.hsv_to_rgb((0.46 + index * 0.61803398875) % 1, .65, .95) + return "#" + "".join(f"{round(channel * 255):02x}" for channel in rgb) + +def _category_palette(count): + """Assign unique colors across the full set, independent of active filters.""" + if count > 256 ** 3: + raise ValueError("Too many categories for distinct RGB colors.") + palette, used = [], set() + for index in range(count): + rgb = colorsys.hsv_to_rgb((.46 + index / count) % 1, .65, .95) + value = int("".join(f"{round(channel * 255):02x}" for channel in rgb), 16) + # RGB rounding can merge colors when there are very many categories. + while value in used: + value = (value + 1) % (256 ** 3) + used.add(value) + palette.append(f"#{value:06x}") + return palette + +def _category_lines(values, labels, selected): + lines = [] + ordered = values[np.argsort(values[:, 0], kind="stable")] + for index in selected: + start, end = np.searchsorted(ordered[:, 0], [index, index + 1]) + ys = ordered[start:end, 1] + lines.append((labels[index], _category_color(index), + np.column_stack((np.arange(1, len(ys) + 1), ys)))) + return lines + +def _line_segments(points): + finite = np.isfinite(points).all(axis=1) + boundaries = np.flatnonzero(np.diff(np.r_[False, finite, False])) + return [points[start:end] for start, end in boundaries.reshape(-1, 2)] + +def _prepare_data(data, x, y): + frame = pd.DataFrame(data).copy(deep=False) + if not frame.columns.is_unique or not all(isinstance(c, str) for c in frame.columns): + raise ValueError("Column names must be unique strings.") + columns = [c for c in frame if pd.api.types.is_numeric_dtype(frame[c]) + and not pd.api.types.is_bool_dtype(frame[c]) + and not pd.api.types.is_complex_dtype(frame[c])] + if not columns or frame.empty: + raise ValueError("Provide non-empty data with at least one numeric column.") + x = frame.columns[0] if x is None else x + y = columns[min(1, len(columns) - 1)] if y is None else y + if x not in frame.columns or y not in columns: + raise ValueError("x must name a column in data; y must name a numeric column.") + return frame, columns, x, y + +def _plot_values(frame, x, y, sort_x=False): + series = frame[x] + numeric = (pd.api.types.is_numeric_dtype(series) + and not pd.api.types.is_bool_dtype(series) + and not pd.api.types.is_complex_dtype(series)) + labels = None + if numeric: + xs = series.to_numpy(dtype=float, na_value=np.nan) + else: + codes, categories = pd.factorize(series, sort=sort_x) + xs = codes.astype(float) + xs[codes < 0] = np.nan + labels = [str(value) for value in categories] + values = np.column_stack((xs, frame[y].to_numpy(dtype=float, na_value=np.nan))) + if sort_x: + values = values[np.argsort(values[:, 0], kind="stable")] + return values, labels +def line_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x=True, + master=None, block=None, max_categories=8): + return _interactive_plot(data, x, y, title=title, sort_x=sort_x, + master=master, block=block, max_categories=max_categories) + +def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x=False, + master=None, block=None, max_categories=8, kind="line", + fill=False, gap=.1, palette="pastel"): + if not isinstance(max_categories, int) or max_categories < 1: + raise ValueError("max_categories must be a positive integer") + if block is None: + block = master is None + if master is None: + try: + from IPython import get_ipython + shell = get_ipython() + except ImportError: + shell = None + if shell is not None and getattr(shell, "kernel", None) is not None: + shell.enable_gui("tk") + block = False + frame, columns, x, y = _prepare_data(data, x, y) + import tkinter as tk + from tkinter import ttk + window = tk.Tk() if master is None else tk.Toplevel(master) + window.title(title) + window.geometry("960x600") + window.minsize(540, 360) + controls = ttk.Frame(window, padding=12) + controls.pack(fill="x") + x_var = tk.StringVar(window, x) + ttk.Label(controls, text="X").grid(row=0, column=0, padx=(0, 6)) + x_selector = ttk.Combobox(controls, textvariable=x_var, values=list(frame.columns), + state="readonly", width=26) + x_selector.grid(row=0, column=1, sticky="ew", padx=(0, 18)) + controls.columnconfigure(1, weight=1) + controls.columnconfigure(3, weight=1) + selected_variables = {y} + quantitative_var = tk.StringVar(window, y) + quantitative_filter = CheckCombobox( + controls, textvariable=quantitative_var, state="readonly", width=28) + ttk.Label(controls, text="Y" if kind == "box" else "Y múltiplos").grid( + row=0, column=2, padx=(0, 6), sticky="w") + quantitative_filter.grid(row=0, column=3, sticky="ew") + + def update_quantitative_choices(): + quantitative_filter.configure(values=[ + ("☑ " if name in selected_variables else "☐ ") + name + for name in columns]) + quantitative_var.set(", ".join(name for name in columns if name in selected_variables) + or "Selecionar variáveis Y") + + update_quantitative_choices() + if kind == "box": + fill_var = tk.BooleanVar(window, fill) + gap_var = tk.StringVar(window, str(gap)) + palette_var = tk.StringVar(window, palette) + box_options = ttk.Frame(controls) + box_options.grid(row=3, column=0, columnspan=4, sticky="w", pady=(8, 0)) + ttk.Checkbutton(box_options, text="Preencher caixas", variable=fill_var, + command=lambda: schedule()).pack(side="left", padx=(0, 12)) + ttk.Label(box_options, text="Gap").pack(side="left", padx=(0, 6)) + gap_selector = ttk.Combobox(box_options, textvariable=gap_var, + values=[0, .05, .1, .2, .3, .4, .5, .75], + state="readonly", width=6) + gap_selector.pack(side="left", padx=(0, 12)) + gap_selector.bind("<>", lambda event: schedule()) + ttk.Label(box_options, text="Palette").pack(side="left", padx=(0, 6)) + palette_selector = ttk.Combobox(box_options, textvariable=palette_var, + values=list(dict.fromkeys([palette, "pastel", "deep", + "muted", "bright", "colorblind", "Set2", "husl"])), + state="readonly", width=18) + palette_selector.pack(side="left") + palette_selector.bind("<>", lambda event: schedule()) + filter_label = ttk.Label(controls, text="Categorias") + status = ttk.Label(controls) + category_var = tk.StringVar(window) + category_selector = CheckCombobox(controls, textvariable=category_var, + state="readonly", width=26) + selected_categories = set() + category_labels = [] + category_colors = [] + + def update_category_choices(): + all_selected = bool(category_labels) and len(selected_categories) == len(category_labels) + category_selector.configure(values=[ + ("☑ " if all_selected else "☐ ") + "Selecionar todos", + *[("☑ " if index in selected_categories else "☐ ") + label + for index, label in enumerate(category_labels)]]) + status.configure(text=f"{len(selected_categories)}/{len(category_labels)} categorias selecionadas; " + + ("todos os valores em barras." if kind == "bar" + else "distribuição por categoria." if kind == "box" + else "todas as observações em pontos." if kind == "scatter" + else "todos os pontos por linha.")) + category_var.set(", ".join(label for index, label in enumerate(category_labels) + if index in selected_categories) + or "Selecionar categorias") + from matplotlib.figure import Figure + from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk + from matplotlib.ticker import MaxNLocator, FixedLocator, FormatStrFormatter + + plot_area = ttk.Frame(window) + plot_area.pack(fill="both", expand=True) + figure = Figure(figsize=(9.6, 6), facecolor="#101827", layout="constrained") + axes = figure.subplots() + canvas = FigureCanvasTkAgg(figure, master=plot_area) + toolbar = NavigationToolbar2Tk(canvas, plot_area, pack_toolbar=False) + toolbar.pack(side="bottom", fill="x") + canvas.get_tk_widget().pack(fill="both", expand=True) + filter_column = None + cache_key, cache = None, None + window.figure = figure + window.axes = axes + + def draw(event=None): + nonlocal filter_column, cache_key, cache + variables = [name for name in columns if name in selected_variables] + variables = variables[:max_categories] + key = (x_var.get(), tuple(variables)) + if key != cache_key: + cache = {name: _plot_values(frame, key[0], name, sort_x) + for name in variables} + cache_key = key + labels = (cache[variables[0]][1] if variables else + _plot_values(frame, key[0], y, sort_x)[1]) + if kind == "box": + _, box_categories = pd.factorize(frame[key[0]], sort=sort_x) + labels = [str(value) for value in box_categories] + if filter_column != x_var.get(): + filter_column = x_var.get() + selected_categories.clear() + category_labels[:] = labels if labels is not None else [] + category_colors[:] = _category_palette(len(category_labels)) + if labels is not None: + selected_categories.update(range(len(labels))) + update_category_choices() + filter_label.grid(row=1, column=0, sticky="w", padx=(0, 6), pady=(8, 0)) + category_selector.grid(row=1, column=1, sticky="ew", padx=(0, 18), pady=(8, 0)) + status.grid(row=2, column=1, columnspan=3, sticky="w", pady=(4, 0)) + else: + filter_label.grid_remove() + category_selector.grid_remove() + status.grid_remove() + if labels is not None: + selected = sorted(selected_categories) + lines = [] + for name in variables: + chosen = selected + grouped = _category_lines(cache[name][0], labels, chosen) + for index, line in zip(chosen, grouped): + label = f"{line[0]} · {name}" if len(variables) > 1 else line[0] + lines.append((label, category_colors[index], line[2])) + else: + lines = [(name, _category_color(columns.index(name)), cache[name][0]) + for name in variables] + axes.clear() + axes.set_facecolor("#101827") + axes.tick_params(colors="#b9c7db") + for spine in axes.spines.values(): + spine.set_color("#b9c7db") + axes.set_title(title, color="#edf2fa") + axes.set_xlabel("Observação por categoria — " + x_var.get() + if labels is not None else x_var.get(), color="#edf2fa") + axes.set_ylabel(variables[0] if len(variables) == 1 else "Variáveis quantitativas", + color="#edf2fa") + axes.set_axisbelow(True) + axes.grid(axis="y", color="#29364a") + if kind == "box": + from .plotting_box import _draw_boxplot + _draw_boxplot(axes, frame, key[0], variables[0] if variables else None, + box_categories, selected_categories, fill=fill_var.get(), + gap=float(gap_var.get()), palette=palette_var.get()) + toolbar.update() + canvas.draw_idle() + return + values = (np.concatenate([line[2] for line in lines]) if lines + else np.empty((0, 2))) + finite = values[np.isfinite(values).all(axis=1)] + if not len(finite): + axes.text(.5, .5, "Sem pares válidos nas categorias selecionadas", + ha="center", va="center", transform=axes.transAxes, color="#edf2fa") + else: + group_width = None + bar_handles = [] + if kind == "bar": + xs = np.unique(finite[:, 0]) + group_width = .8 * (np.diff(xs).min() if len(xs) > 1 else 1) + for index, (label, color, points) in enumerate(lines): + if kind == "line": + # NaNs keep the gaps between observations with missing data. + clean = points.copy() + clean[~np.isfinite(clean).all(axis=1)] = np.nan + axes.plot(clean[:, 0], clean[:, 1], color=color, label=label, + linewidth=1.5, marker="." if len(points) == 1 else None) + else: + points = points[np.isfinite(points).all(axis=1)] + if kind == "scatter": + axes.scatter(points[:, 0], points[:, 1], color=color, label=label, s=20) + else: + width = group_width / len(lines) + offset = -group_width / 2 + (index + .5) * width + from .plotting_bars import _draw_bars + bar_handles.append(_draw_bars( + axes, points[:, 0] + offset, points[:, 1], width * .9, + color=color, label=label)) + if labels is not None: + axes.xaxis.set_major_locator(MaxNLocator(integer=True)) + elif kind == "bar" and frame[key[0]].dropna().isin([0, 1]).all(): + axes.xaxis.set_major_locator(FixedLocator([0, 1])) + axes.xaxis.set_major_formatter(FormatStrFormatter("%d")) + axes.set_xlim(-.4, 1.4) + if kind == "bar": + # Avoid scanning every rectangle to find the "best" legend position. + legend = axes.legend(handles=bar_handles, loc="upper right", + facecolor="#101827", edgecolor="#29364a") + else: + legend = axes.legend(facecolor="#101827", edgecolor="#29364a") + for text in legend.get_texts(): + text.set_color("#edf2fa") + toolbar.update() + canvas.draw_idle() + + pending = None + def render(): + nonlocal pending + pending = None + draw() + + def schedule(event=None): + nonlocal pending + if pending is not None: + window.after_cancel(pending) + pending = window.after(120, render) + + def close(): + if pending is not None: + window.after_cancel(pending) + figure.clear() + window.destroy() + + def reset_zoom(): + toolbar.home() + + def scroll_zoom(event): + if event.inaxes is not axes or event.xdata is None or event.ydata is None: + return + if not event.step: + return + toolbar.push_current() + factor = 1 / 1.2 if event.step > 0 else 1.2 + for getter, setter, anchor in ((axes.get_xlim, axes.set_xlim, event.xdata), + (axes.get_ylim, axes.set_ylim, event.ydata)): + bounds = np.asarray(getter()) + setter(anchor + (bounds - anchor) * factor) + toolbar.push_current() + canvas.draw_idle() + + canvas.mpl_connect("scroll_event", scroll_zoom) + + def copy_plot(): + try: + window.lift() + canvas.draw() + window.update_idletasks() + _copy_canvas(canvas.get_tk_widget()) + except Exception as error: + messagebox.showerror("Copiar gráfico", str(error), parent=window) + + actions = ttk.Frame(controls) + actions.grid(row=1, column=3, sticky="ew", padx=(0, 18), pady=(8, 0)) + for filename, command in (("copy.png", copy_plot), ("undo.png", reset_zoom)): + with Image.open(Path(__file__).parent / "assets" / filename) as icon: + button_icon = ImageTk.PhotoImage( + icon.convert("RGBA").resize((24, 24), Image.Resampling.LANCZOS), + master=window) + button = ttk.Button(actions, image=button_icon, command=command, padding=5) + button.image = button_icon + button.pack(side="left", padx=(0, 8)) + window.protocol("WM_DELETE_WINDOW", close) + def select_quantitative(event=None): + index = quantitative_filter.current() + if index < 0: + return + name = columns[index] + if kind == "box": + selected_variables.clear() + selected_variables.add(name) + elif name in selected_variables: + selected_variables.remove(name) + elif len(selected_variables) < max_categories: + selected_variables.add(name) + else: + window.bell() + update_quantitative_choices() + schedule() + + x_selector.bind("<>", schedule) + quantitative_filter.bind("<>", select_quantitative) + def select_category(event=None): + index = category_selector.current() + if index < 0: + return + if index == 0: + if len(selected_categories) == len(category_labels): + selected_categories.clear() + else: + selected_categories.update(range(len(category_labels))) + else: + index -= 1 + if index in selected_categories: + selected_categories.remove(index) + else: + selected_categories.add(index) + update_category_choices() + schedule() + + category_selector.bind("<>", select_category) + schedule() + if block and master is None: + window.mainloop() + return window diff --git a/src/spectralforensics/plotting_bars.py b/src/spectralforensics/plotting_bars.py new file mode 100644 index 0000000..d25fc3b --- /dev/null +++ b/src/spectralforensics/plotting_bars.py @@ -0,0 +1,27 @@ +from .plotting import _interactive_plot +import numpy as np + +__all__ = ["bar_plot"] + +def _draw_bars(axes, x, y, width, *, color, label): + """Batch rectangles so large datasets do not create thousands of artists.""" + from matplotlib.collections import PolyCollection + from matplotlib.patches import Patch + + x, y = np.asarray(x, dtype=float), np.asarray(y, dtype=float) + left, right = x - width / 2, x + width / 2 + vertices = np.empty((len(x), 4, 2), dtype=float) + vertices[:, 0, 0] = vertices[:, 1, 0] = left + vertices[:, 2, 0] = vertices[:, 3, 0] = right + vertices[:, 0, 1] = vertices[:, 3, 1] = 0 + vertices[:, 1, 1] = vertices[:, 2, 1] = y + collection = PolyCollection(vertices, facecolors=color, edgecolors="none") + axes.add_collection(collection) + axes.autoscale_view() + return Patch(facecolor=color, label=label) + +def bar_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x=False, + master=None, block=None, max_categories=8): + return _interactive_plot(data, x, y, title=title, sort_x=sort_x, + master=master, block=block, + max_categories=max_categories, kind="bar") diff --git a/src/spectralforensics/plotting_box.py b/src/spectralforensics/plotting_box.py new file mode 100644 index 0000000..fabf096 --- /dev/null +++ b/src/spectralforensics/plotting_box.py @@ -0,0 +1,43 @@ +import numpy as np +import pandas as pd +import seaborn as sns + +__all__ = ["box_plot"] + +def _draw_boxplot(axes, frame, x, y, categories, selected, *, fill, gap, palette): + axes.set_xlabel(x, color="#edf2fa") + axes.set_ylabel(y or "Y", color="#edf2fa") + chosen = sorted(selected) + if y is None or not chosen: + axes.text(.5, .5, "Selecione categorias e uma variável Y", ha="center", + va="center", transform=axes.transAxes, color="#edf2fa") + return + codes = pd.Categorical(frame[x], categories=categories).codes + values = frame[y].to_numpy(dtype=float, na_value=np.nan) + valid = np.isin(codes, chosen) & np.isfinite(values) + if not valid.any(): + axes.text(.5, .5, "Sem valores válidos nas categorias selecionadas", + ha="center", va="center", transform=axes.transAxes, color="#edf2fa") + return + colors = sns.color_palette(palette, n_colors=len(categories)) + data = pd.DataFrame({"category": codes[valid], "value": values[valid]}) + sns.boxplot(data=data, x="category", y="value", hue="category", + order=chosen, hue_order=chosen, + palette={index: colors[index] for index in chosen}, + fill=fill, gap=gap, dodge=False, legend=False, ax=axes) + axes.set_xticks(range(len(chosen)), labels=[str(categories[index]) for index in chosen]) + axes.set_xlabel(x, color="#edf2fa") + axes.set_ylabel(y, color="#edf2fa") + +def box_plot(data, x=None, y=None, *, title="SpectralForensics — Boxplot", + fill=False, gap=.1, palette="pastel", sort_x=False, + master=None, block=None): + from .plotting import _interactive_plot + if not 0 <= gap < 1: + raise ValueError("gap must be between 0 (inclusive) and 1 (exclusive).") + if not isinstance(palette, str): + raise ValueError("palette must be a seaborn or Matplotlib palette name.") + sns.color_palette(palette) + return _interactive_plot(data, x, y, title=title, sort_x=sort_x, + master=master, block=block, max_categories=1, + kind="box", fill=fill, gap=gap, palette=palette) diff --git a/src/spectralforensics/plotting_correlation.py b/src/spectralforensics/plotting_correlation.py new file mode 100644 index 0000000..716d776 --- /dev/null +++ b/src/spectralforensics/plotting_correlation.py @@ -0,0 +1,298 @@ +import pandas as pd +from ._widgets import CheckCombobox +from matplotlib.figure import Figure +import seaborn as sns +import tkinter as tk +from tkinter import ttk, messagebox +from pathlib import Path +from PIL import Image, ImageTk +from matplotlib import colormaps +from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk +from .plotting import _copy_canvas +__all__ = ["correlation_plot"] + +def _correlation_figure(data, correlation_columns=None, *, method="pearson", + cmap="coolwarm", center=0, annot=True, fmt=".2f", + target=None, kind="barh", by=None, ascending=True, + figsize=None, title="Matriz de Correlação das Features", + target_title=None, show=False, page="matrix"): + frame = pd.DataFrame(data) + if not frame.columns.is_unique: + raise ValueError("Column names must be unique.") + if kind not in ("bar", "barh"): + raise ValueError("kind must be 'bar' or 'barh'.") + if target is None and by is not None: + raise ValueError("Provide target when using by.") + if target is not None and by is not None and by != target: + raise ValueError("by must name the target correlation column.") + columns = (frame.select_dtypes(include=["number", "bool"]).columns.tolist() + if correlation_columns is None else list(correlation_columns)) + if target is not None and target not in columns: + columns.append(target) + if not columns or len(set(columns)) != len(columns): + raise ValueError("Provide a non-empty selection of unique numeric columns.") + missing = [column for column in columns if column not in frame.columns] + if missing: + raise ValueError(f"Unknown columns: {missing}") + invalid = [column for column in columns + if not (pd.api.types.is_numeric_dtype(frame[column]) + or pd.api.types.is_bool_dtype(frame[column])) + or pd.api.types.is_complex_dtype(frame[column])] + if invalid: + raise ValueError(f"Correlation requires numeric or boolean columns: {invalid}") + if frame.empty: + raise ValueError("Provide non-empty data.") + if target is not None and len(columns) < 2: + raise ValueError("Provide at least one feature besides the target.") + corr_complete = frame[columns].corr(method=method) + corr_target = None + if target is not None: + corr_target = (corr_complete[[target]].drop(index=target) + .sort_values(by=target if by is None else by, + ascending=ascending)) + if page not in ("matrix", "target"): + raise ValueError("page must be 'matrix' or 'target'.") + if page == "target" and target is None: + raise ValueError("Select a target to display its bar plot.") + figure = Figure(figsize=figsize or (14, 11)) + ax = figure.subplots() + heatmap_ax = ax if page == "matrix" else None + target_ax = ax if page == "target" else None + if heatmap_ax is not None: + sns.heatmap(corr_complete, annot=annot, fmt=fmt, cmap=cmap, + center=center, vmin=-1, vmax=1, ax=heatmap_ax) + heatmap_ax.set_title(title) + if target_ax is not None: + corr_target.plot(kind=kind, ax=target_ax, legend=False) + method_name = method.capitalize() if isinstance(method, str) else "personalizada" + correlation_label = f"Correlação ({method_name}) com {target}" + if kind == "barh": + target_ax.set_xlabel(correlation_label) + target_ax.set_ylabel("Feature") + target_ax.axvline(0, linewidth=1, color="gray") + target_ax.set_xlim(-1, 1) + else: + target_ax.set_ylabel(correlation_label) + target_ax.set_xlabel("Feature") + target_ax.axhline(0, linewidth=1, color="gray") + target_ax.set_ylim(-1, 1) + target_ax.set_title(target_title or f"Correlação das Features com {target}") + figure.tight_layout() + return {"figure": figure, + "axes": {"heatmap": heatmap_ax, "target": target_ax}, + "corr_complete": corr_complete, "corr_target": corr_target} +def correlation_plot(data, correlation_columns=None, *, method="pearson", + cmap="coolwarm", center=0, annot=True, fmt=".2f", + target=None, kind="barh", by=None, ascending=True, + figsize=None, title="Matriz de Correlação das Features", + target_title=None, show=True, master=None, block=None): + options = dict(method=method, cmap=cmap, center=center, annot=annot, fmt=fmt, + target=target, kind=kind, by=by, ascending=ascending, + figsize=figsize, title=title, target_title=target_title) + # Validate and render before creating a window. + result = _correlation_figure(data, correlation_columns, **options) + if not show: + return result + + if block is None: + block = master is None + if master is None: + try: + from IPython import get_ipython + shell = get_ipython() + except ImportError: + shell = None + if shell is not None and getattr(shell, "kernel", None) is not None: + shell.enable_gui("tk") + block = False + frame = pd.DataFrame(data) + columns = [name for name in frame + if (pd.api.types.is_numeric_dtype(frame[name]) + or pd.api.types.is_bool_dtype(frame[name])) + and not pd.api.types.is_complex_dtype(frame[name])] + selected = set(columns if correlation_columns is None else correlation_columns) + window = tk.Tk() if master is None else tk.Toplevel(master) + window.title(title) + window.geometry("1200x800") + window.minsize(800, 540) + controls = ttk.Frame(window, padding=12) + controls.pack(fill="x") + status = tk.StringVar(window) + feature_var = tk.StringVar(window) + method_var = tk.StringVar(window, method if isinstance(method, str) else "Personalizado") + cmap_var = tk.StringVar(window, cmap if isinstance(cmap, str) else cmap.name) + center_var = tk.StringVar(window, "" if center is None else str(center)) + annot_var = tk.BooleanVar(window, annot) + fmt_var = tk.StringVar(window, fmt) + target_var = tk.StringVar(window, "(Sem target)" if target is None else target) + kind_var = tk.StringVar(window, kind) + by_var = tk.StringVar(window, "" if target is None else target) + ascending_var = tk.BooleanVar(window, ascending) + plot_area = ttk.Frame(window) + plot_area.pack(fill="both", expand=True) + window.result = result + class CorrelationToolbar(NavigationToolbar2Tk): + def back(self, *args): + if window.result["axes"]["target"] is not None: + navigate("matrix") + + def forward(self, *args): + if (window.result["axes"]["heatmap"] is not None + and window.result["corr_target"] is not None): + navigate("target") + + def set_history_buttons(self): + buttons = getattr(self, "_buttons", {}) + on_target = window.result["axes"]["target"] is not None + if "Back" in buttons: + buttons["Back"].configure(state="normal" if on_target else "disabled") + if "Forward" in buttons: + buttons["Forward"].configure( + state="normal" if not on_target and window.result["corr_target"] is not None + else "disabled") + canvas = FigureCanvasTkAgg(result["figure"], master=plot_area) + toolbar = CorrelationToolbar(canvas, plot_area, pack_toolbar=False) + toolbar.pack(side="bottom", fill="x") + canvas.get_tk_widget().pack(fill="both", expand=True) + canvas.draw() + window.result = result + pending = None + page = "matrix" + page_label = tk.StringVar(window, "1/2 — Matriz de correlação" if target is not None + else "Matriz de correlação") + def update_plot(): + nonlocal pending, page + pending = None + try: + chosen_target = None if target_var.get() == "(Sem target)" else target_var.get() + current_page = page if chosen_target is not None else "matrix" + current_method = method if method_var.get() == "Personalizado" else method_var.get() + current = _correlation_figure( + frame, [name for name in columns if name in selected], + method=current_method, cmap=cmap_var.get(), + center=float(center_var.get()) if center_var.get().strip() else None, + annot=annot_var.get(), fmt=fmt_var.get(), target=chosen_target, + kind=kind_var.get(), by=by_var.get() or None, + ascending=ascending_var.get(), figsize=figsize, title=title, + target_title=target_title, page=current_page) + except Exception as error: + status.set(str(error)) + return + old_figure = canvas.figure + canvas.figure = current["figure"] + canvas.figure.set_canvas(canvas) + canvas.figure.set_size_inches(old_figure.get_size_inches(), forward=False) + toolbar.update() + canvas.draw() + old_figure.clear() + window.result = current + page = current_page + toolbar.set_history_buttons() + page_label.set(("1/2 — Matriz de correlação" if page == "matrix" + else "2/2 — Correlação com o target") if chosen_target is not None + else "Matriz de correlação") + status.set("Atualizado.") + def schedule(event=None): + nonlocal pending + if pending is not None: + window.after_cancel(pending) + pending = window.after(200, update_plot) + def combo(label, variable, values, row, column, readonly=True, multiple=False): + ttk.Label(controls, text=label).grid(row=row, column=column, sticky="w", padx=5, pady=4) + widget_type = CheckCombobox if multiple else ttk.Combobox + widget = widget_type(controls, textvariable=variable, values=values, + state="readonly" if readonly else "normal", width=22) + widget.grid(row=row, column=column + 1, sticky="ew", padx=5, pady=4) + widget.bind("<>", schedule) + widget.bind("", schedule) + return widget + features = combo("Features", feature_var, [], 0, 0, multiple=True) + def refresh_features(): + features.configure(values=[ + ("☑ " if len(selected) == len(columns) else "☐ ") + "Selecionar todos", + *[("☑ " if name in selected else "☐ ") + str(name) for name in columns]]) + feature_var.set(f"{len(selected)}/{len(columns)} features selecionadas") + def select_feature(event=None): + index = features.current() + if index == 0: + if len(selected) == len(columns): + selected.clear() + else: + selected.update(columns) + elif index > 0: + name = columns[index - 1] + if name in selected: + selected.remove(name) + else: + selected.add(name) + refresh_features() + schedule() + features.bind("<>", select_feature) + refresh_features() + combo("Método", method_var, + ["pearson", "spearman", "kendall"] + (["Personalizado"] if callable(method) else []), 0, 2) + combo("Cmap", cmap_var, sorted(colormaps), 0, 4) + target_selector = combo("Target", target_var, ["(Sem target)", *columns], 1, 0) + combo("Kind", kind_var, ["bar", "barh"], 1, 2) + by_selector = combo("Ordenar por (by)", by_var, [] if target is None else [target], 1, 4) + def change_target(event=None): + value = "" if target_var.get() == "(Sem target)" else target_var.get() + by_var.set(value) + by_selector.configure(values=[value] if value else []) + schedule() + target_selector.bind("<>", change_target) + for label, variable, column in (("Centro (vazio = automático)", center_var, 0), + ("Formato (fmt)", fmt_var, 2)): + ttk.Label(controls, text=label).grid(row=2, column=column, sticky="w", padx=5) + entry = ttk.Entry(controls, textvariable=variable, width=22) + entry.grid(row=2, column=column + 1, sticky="ew", padx=5) + entry.bind("", schedule) + entry.bind("", schedule) + checks = ttk.Frame(controls) + checks.grid(row=2, column=4, columnspan=2, sticky="w") + ttk.Checkbutton(checks, text="Annot", variable=annot_var, command=schedule).pack(side="left") + ttk.Checkbutton(checks, text="Ordem crescente", variable=ascending_var, command=schedule).pack(side="left") + def copy_plot(): + try: + window.lift() + canvas.draw() + _copy_canvas(canvas.get_tk_widget()) + except Exception as error: + messagebox.showerror("Copiar gráfico", str(error), parent=window) + actions = ttk.Frame(controls) + actions.grid(row=3, column=0, columnspan=6, sticky="w", pady=(8, 0)) + def navigate(destination): + nonlocal page, pending + if pending is not None: + window.after_cancel(pending) + pending = None + old_page = page + page = destination + update_plot() + if window.result["axes"]["heatmap"] is not None and page == "target": + page = old_page + elif window.result["axes"]["target"] is not None and page == "matrix": + page = old_page + ttk.Label(actions, textvariable=page_label).pack(side="left", padx=5) + for filename, command in (("refresh-page-option.png", update_plot), + ("copy.png", copy_plot), ("undo.png", toolbar.home)): + with Image.open(Path(__file__).parent / "assets" / filename) as icon: + button_icon = ImageTk.PhotoImage( + icon.convert("RGBA").resize((24, 24), Image.Resampling.LANCZOS), + master=window) + button = ttk.Button(actions, image=button_icon, command=command, padding=5) + button.image = button_icon + button.pack(side="left", padx=5) + ttk.Label(controls, textvariable=status, wraplength=1050).grid( + row=4, column=0, columnspan=6, sticky="w", padx=5, pady=(5, 0)) + for column in (1, 3, 5): + controls.columnconfigure(column, weight=1) + def close(): + if pending is not None: + window.after_cancel(pending) + window.result["figure"].clear() + window.destroy() + window.protocol("WM_DELETE_WINDOW", close) + if block and master is None: + window.mainloop() + return window diff --git a/src/spectralforensics/plotting_scatter.py b/src/spectralforensics/plotting_scatter.py new file mode 100644 index 0000000..b9d2709 --- /dev/null +++ b/src/spectralforensics/plotting_scatter.py @@ -0,0 +1,8 @@ +from .plotting import _interactive_plot +__all__ = ["scatter_plot"] + +def scatter_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x=False, + master=None, block=None, max_categories=8): + return _interactive_plot(data, x, y, title=title, sort_x=sort_x, + master=master, block=block, + max_categories=max_categories, kind="scatter")