bibliotecas

This commit is contained in:
kl3z00
2026-10-26 16:07:39 +00:00
parent 861242b3e7
commit 8b91a01e60
34 changed files with 1021 additions and 2 deletions
+11
View File
@@ -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",
)
+8
View File
@@ -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")
+12
View File
@@ -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",
)
+10
View File
@@ -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",
)
+11
View File
@@ -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",
)
+5 -1
View File
@@ -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*"]
include = ["spectralforensics*"]
+6 -1
View File
@@ -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"]
__all__ = ["extract_features", "line_plot", "bar_plot", "scatter_plot", "correlation_plot", "box_plot"]
+128
View File
@@ -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("<Button-1>", self._toggle_popup)
self.bind("<Down>", self._open)
self.bind("<space>", self._open)
self.bind("<Escape>", self._close)
self.bind("<Destroy>", 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("<Button-1>", self._click)
choices.bind("<space>", self._choose)
choices.bind("<Return>", self._choose)
popup.bind("<Escape>", self._close)
popup.bind("<Button-1>", self._outside)
popup.bind("<FocusOut>", 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("<<ComboboxSelected>>")
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()
Binary file not shown.

After

Width:  |  Height:  |  Size: 4.0 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 7.1 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 12 KiB

+454
View File
@@ -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("<<ComboboxSelected>>", 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("<<ComboboxSelected>>", 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("<<ComboboxSelected>>", schedule)
quantitative_filter.bind("<<ComboboxSelected>>", 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("<<ComboboxSelected>>", select_category)
schedule()
if block and master is None:
window.mainloop()
return window
+27
View File
@@ -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")
+43
View File
@@ -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)
@@ -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("<<ComboboxSelected>>", schedule)
widget.bind("<Return>", 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("<<ComboboxSelected>>", 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("<<ComboboxSelected>>", 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("<Return>", schedule)
entry.bind("<FocusOut>", 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
@@ -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")