Compare commits

...

6 Commits

Author SHA1 Message Date
kl3z 29e6355413 Modificar README.md 2026-10-27 17:41:17 +00:00
kl3z 75031c666b RGB 2026-10-27 17:35:51 +00:00
kl3z00 d986498816 new readme 2026-10-27 10:54:12 +00:00
kl3z00 f16e71c72b atualização inglês 2026-10-27 10:12:25 +00:00
kl3z00 5deb660813 atualização final 2026-10-27 09:28:01 +00:00
kl3z00 06b8812a2b novas bibliotecas 2026-10-27 09:14:16 +00:00
22 changed files with 697 additions and 264 deletions
+319 -127
View File
@@ -1,172 +1,364 @@
\# SpectralForensics
# SpectralForensics
SpectralForensics is a Python library for explainable digital image forensics.
It extracts interpretable descriptors from the frequency, spatial, and
residual-noise domains and provides interactive tools for exploring the
resulting data.
The library contains two complementary extraction paths:
SpectralForensics is an open-source Python library for image forensic analysis using \*\*Fast Fourier Transform (FFT)\*\* and frequency-domain feature extraction.
- **RGB extraction** preserves the three color channels, computes
channel-wise descriptors, and aggregates them into image-level values.
- **Grayscale extraction** converts the image to one luminance plane and
reproduces the original SpectralForensics formulation.
The project is being developed to support research into AI-generated image
detection, synthetic-media analysis, diffusion-model fingerprints, and
explainable machine-learning pipelines.
> [!NOTE]
> SpectralForensics is under active development. The public API and extracted
> features may change before the first stable release.
The library was designed to support research in digital image forensics, synthetic media detection, diffusion model analysis, and explainable artificial intelligence (XAI).
## Features
### Spectral analysis
- Spectral entropy
- Directional anisotropy
- Dominant radial frequency
- Energy density and mean energy
- High-frequency energy ratio
- Normalized FFT spectra for visualization
\## Features
### Spatial analysis
- Mean brightness and darkness
- Sobel gradient magnitude
- Local entropy
- Local variance
- Normalized visual maps
### Residual-noise analysis
SpectralForensics extracts a set of interpretable spectral descriptors from images:
- Residual-noise energy
- Residual-noise standard deviation
- Global residual standard deviation in RGB mode
- Mean absolute residual noise
- Raw and normalized residual-noise maps
### Dataset and visualization tools
- RGB or grayscale extraction from one image or a complete folder
- Sequential renaming of real and AI-generated image datasets
- Optional CSV export
- JPG, JPEG, PNG, BMP, TIFF, and WebP support
- Interactive line, bar, scatter, box, and correlation plots
- Dynamic variable and category filtering
\- Spectral Entropy
\- Anisotropy
\- Dominant Frequency
\- Energy Density
\- High Frequency Ratio
\- Mean Spectral Energy
These descriptors can be used for:
\- AI-generated image detection
\- Deepfake forensics
\- Diffusion model fingerprinting
\- Frequency-domain analysis
\- Explainable machine learning pipelines
\## Installation
\### Local installation
## Requirements
- Python 3.10 or newer
- A graphical desktop environment for interactive plotting
- Tkinter, normally included with standard Python installations
## Installation
```bash
py -m pip install -e .
\\### Future PyPI installation
pip install spectralforensics
\\## Quick Start
\\### Extract Features from a Single Image
```python
from spectralforensics import extract\\\_spectral\\\_features
features = extract\\\_spectral\\\_features("image.jpg")
print(features)
git clone https://gittea.kl3z00.com/kl3z/spectralforensics
cd spectralforensics
python -m pip install -e .
```
The package is not yet advertised as a stable PyPI release.
## Public extraction API
\### Example Output
| Function | Input | Color mode | Default size |
| --- | --- | --- | --- |
| `extract_features` | Image or folder | Selected with `color_mode` | RGB: `1024x1024`; grayscale: `255x255` |
| `extract_rgb_features` | Single image | RGB | `1024x1024` |
| `extract_grayscale_features` | Single image | Grayscale | `255x255` |
`extract_features` is the high-level dataset function. RGB remains its default
mode for backward compatibility with the current library.
## Quick start
### Extract RGB features from one image
```python
from spectralforensics import extract_rgb_features
{
\  "filename": "image.jpg",
\  "spectral\\\_entropy": 2.31,
\  "anisotropy": 0.021,
\  "dominant\\\_frequency": 12.7,
\  "energy\\\_density": 58210.3,
\  "high\\\_frequency\\\_ratio": 0.000091,
\  "mean\\\_energy": 58210.3
}
rgb_features = extract_rgb_features("images/sample.jpg",output="quantitative",)
print(rgb_features["color_mode"])
print(rgb_features["spectral_entropy"])
print(rgb_features["mean_gradient"])
print(rgb_features["residual_noise_std_global"])
```
\---
\### Extract Features from an Entire Folder
### Extract grayscale features from one image
```python
from spectralforensics import extract_grayscale_features
from spectralforensics import extract\\\_features\\\_from\\\_folder
df = extract\\\_features\\\_from\\\_folder(
\  folder\\\_path="dataset",
\  output\\\_csv="results.csv"
)
print(df.head())
grayscale_features = extract_grayscale_features("images/sample.jpg",output="quantitative",)
print(grayscale_features["color_mode"])
print(grayscale_features["spectral_entropy"])
print(grayscale_features["mean_gradient"])
print(grayscale_features["residual_noise_std"])
```
Both direct extraction functions return a dictionary containing metadata and
the requested descriptors.
### Process a folder in either mode
\### Example Output
```python
from spectralforensics import extract_features
rgb_data = extract_features("images/",color_mode="rgb",output="quantitative",output_csv="rgb_features.csv",)
grayscale_data = extract_features("images/",color_mode="grayscale",output="quantitative",output_csv="grayscale_features.csv",)
```
For a folder, `extract_features` returns a pandas `DataFrame`. Folder traversal
is non-recursive. Set `show_progress=False` to disable the progress bar.
| filename | spectral\_entropy | anisotropy | dominant\_frequency | energy\_density | high\_frequency\_ratio |
The optional `image_size` argument uses Pillow's `(width, height)` convention.
If omitted, the mode-specific default shown above is used.
|-----------|----------------|------------|-------------------|----------------|---------------------|
### Prepare image filenames
| real\_001.jpg | 1.21 | 0.012 | 11.0 | 91327 | 0.000037 |
```python
from spectralforensics import rename_generated_images, rename_real_images
| dalle\_001.png | 2.50 | 0.034 | 16.0 | 68150 | 0.000177 |
real_files = rename_real_images("dataset/real")
generated_files = rename_generated_images("dataset/generated")
```
| flux\_001.jpg | 2.51 | 0.019 | 6.0 | 61004 | 0.000064 |
The resulting filenames follow the `real1.jpg`, `real2.png`, `gen1.jpg`, and
`gen2.png` patterns. Each function returns the new paths. Renaming is
non-recursive, preserves each image format, and uses temporary unique names to
avoid collisions.
## Extraction modes
The `output` argument controls which values are calculated and returned:
| Mode | Result |
| --- | --- |
| `"all"` | All quantitative descriptors and visual maps |
| `"spectral"` | Spectral descriptors only |
| `"spatial"` | Spatial descriptors only |
| `"residual"` | Residual-noise descriptors only |
| `"quantitative"` | All numerical descriptors without visual maps |
| `"visual"` | Visual maps without quantitative descriptors |
Additional extraction parameters:
| Parameter | Description | Default |
| --- | --- | --- |
| `high_freq_threshold` | Normalized radial threshold for high-frequency energy | `0.65` |
| `center_exclusion` | Half-width of the square excluded around the FFT center | `5` |
| `image_size` | Resized image dimensions as `(width, height)` | Mode-specific |
## RGB and grayscale behavior
### Grayscale path
`features_grayscale.py` converts the input with `Image.convert("L")`. Every
descriptor is therefore computed from one normalized image
`I(x, y) in [0, 1]`.
### RGB path
`features.py` converts the input with `Image.convert("RGB")`, producing
`I(x, y, c)` for `c in {R, G, B}`. The FFT, Sobel gradient, local entropy,
local variance, and median residual are calculated independently for each
channel.
For a channel-wise descriptor `d_c`, the public image-level RGB descriptor is
the arithmetic mean:
```text
d_RGB = (d_R + d_G + d_B) / 3
```
Brightness, darkness, gradient, local entropy, local variance, residual energy,
and mean absolute residual are equivalent to averaging over all pixels and all
three channels. When `R = G = B`, the aggregated RGB descriptors match the
grayscale descriptors up to floating-point precision.
## Extracted metadata and features
### Metadata
| Variable | Description |
| --- | --- |
| `filename` | Name of the processed image file |
| `path` | Original image path |
| `target` | Convenience label inferred from the filename |
| `color_mode` | `"rgb"` or `"grayscale"` |
If a filename contains `gen`, `target` is set to `"0"`. If it contains `real`,
`target` is set to `"1"`. Otherwise it is `None`. This convention is not a
trusted provenance mechanism; research datasets should maintain authoritative
labels separately.
### Spectral descriptors
| Variable | Description |
| --- | --- |
| `spectral_entropy` | Shannon entropy of the normalized Fourier power |
| `anisotropy` | Relative difference between horizontal and vertical central-band energy |
| `dominant_frequency` | Radial FFT-bin distance of the maximum-energy component outside the excluded center |
| `energy_density` | Total spectral energy divided by the number of spatial coefficients |
| `high_frequency_ratio` | Fraction of spectral energy beyond the configured radial threshold |
| `mean_energy` | Mean Fourier power |
In RGB mode, each value is first computed independently for R, G, and B and
then averaged across channels.
### Spatial descriptors
| Variable | Description |
| --- | --- |
| `mean_brightness` | Mean normalized intensity over pixels and available channels |
| `mean_darkness` | Mean intensity complement; equal to `1 - mean_brightness` |
| `mean_gradient` | Mean channel-wise Sobel-gradient magnitude |
| `mean_local_entropy` | Mean local entropy using a disk footprint of radius 3 |
| `mean_local_variance` | Mean local variance using a `7x7` spatial neighborhood |
### Residual-noise descriptors
| Variable | Modes | Description |
| --- | --- | --- |
| `residual_noise_energy` | Both | Mean squared median-filter residual |
| `residual_noise_std` | Both | Grayscale residual standard deviation, or mean of the three channel standard deviations in RGB |
| `residual_noise_std_global` | RGB only | Standard deviation over all RGB residual values jointly |
| `residual_noise_mean_absolute` | Both | Mean absolute residual magnitude |
The median filter uses a `3x3` spatial neighborhood. In RGB mode its channel
size is one, so color channels are never mixed.
## Explainable feature maps
| Variable | Grayscale shape | RGB shape | Description |
| --- | --- | --- | --- |
| `fft_spectrum` | `(H, W)` | `(H, W)` | Normalized aggregate logarithmic spectrum |
| `fft_spectrum_channels` | Not returned | `(H, W, 3)` | Independently normalized R, G, and B logarithmic spectra |
| `brightness_map` | `(H, W)` | `(H, W, 3)` | Normalized image intensities |
| `darkness_map` | `(H, W)` | `(H, W, 3)` | Intensity complements |
| `gradient_map` | `(H, W)` | `(H, W)` | Normalized gradient; RGB channels are averaged before display normalization |
| `local_entropy_map` | `(H, W)` | `(H, W)` | Normalized local entropy; RGB channels are averaged |
| `local_variance_map` | `(H, W)` | `(H, W)` | Normalized local variance; RGB channels are averaged |
| `residual_noise_raw` | `(H, W)` | `(H, W, 3)` | Signed median-filter residual |
| `residual_noise` | `(H, W)` | `(H, W, 3)` | Square-root-enhanced residual visualization |
Visual normalization does not alter the quantitative descriptors.
## Output summary
| Mode | Quantitative descriptors | Visual maps |
| --- | ---: | ---: |
| Grayscale | 14 | 8 |
| RGB | 15 | 9 |
These counts exclude the four metadata fields.
## Interactive visualizations
The plotting functions accept dictionaries, pandas `DataFrame` objects, and
other inputs supported by `pandas.DataFrame`.
```python
from spectralforensics import box_plot, line_plot
data = {"sample": [1, 2, 3, 4, 5],"spectral_entropy": [2.1, 2.5, 2.2, 2.9, 2.6],"anisotropy": [0.10, 0.30, 0.20, 0.40, 0.25],}
line_plot(data, x="sample", y="spectral_entropy")
box_plot(data, x="sample", y="anisotropy")
```
![SpectralForensics line plot](img/lines2.jpg)
![SpectralForensics box plot](img/boxplot.jpg)
Available plotting functions:
```python
from spectralforensics import (bar_plot,box_plot,correlation_plot,line_plot,scatter_plot,)
```
### Correlation analysis
```python
from spectralforensics import correlation_plot
correlation_data = {"spectral_entropy": [2.1, 2.5, 2.2, 2.9, 2.6],"anisotropy": [0.10, 0.30, 0.20, 0.40, 0.25],"target": [0, 1, 0, 1, 1],}
correlation_plot(correlation_data,correlation_columns=["spectral_entropy", "anisotropy", "target"],method="pearson",target="target",kind="barh",)
```
![SpectralForensics correlation plot](img/correlation.jpg)
Set `show=False` to return the Matplotlib figure, axes, and correlation tables
without opening the interactive window.
## Interactive chart controls
The chart interface supports:
- X-axis and multiple Y-variable selection
- Category filtering
- Zooming and panning
- Navigation through previous views
- Resetting the current view
- Copying or saving a plot
![SpectralForensics top controls](img/lines.jpg)
![SpectralForensics navigation toolbar](img/menu.jpg)
## Examples
```bash
python examples/line_plot.py
python examples/bar_plot.py
python examples/scatter_plot.py
python examples/box_plot.py
python examples/correlation_plot.py
```
## Project structure
```text
spectralforensics/
|-- examples/ # Plotting examples
|-- img/ # README screenshots
|-- src/
| `-- spectralforensics/
| |-- dataset.py # File and folder processing
| |-- features.py # RGB feature extraction
| |-- features_grayscale.py # Grayscale feature extraction
| |-- plotting*.py # Interactive visualizations
| `-- assets/ # Interface assets
|-- pyproject.toml # Package metadata and dependencies
`-- README.md
```
## Research scope
SpectralForensics is a research and experimentation toolkit. Its descriptors can support statistical analysis and machine-learning models, but they should not be treated as standalone proof that an image is authentic or generated.
## Authors
- Jose Garcia University of Leiria and Oeste (ULO)
- Patricio Rodrigues University of Leiria and Oeste (ULO)
- Carlos Grilo University of Leiria and Oeste (ULO)
- Rolando Miragaia University of Leiria and Oeste (ULO)
## Contributing
Contribuições?
## Citation
Artigo?
+1 -1
View File
@@ -7,5 +7,5 @@ if __name__ == "__main__":
"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",
title="Spectral analysis — bar plot",
)
+1 -1
View File
@@ -7,5 +7,5 @@ if __name__ == "__main__":
"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",
title="Spectral analysis — scatter plot",
)
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 131 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 357 KiB

BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 25 KiB

BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 134 KiB

BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 5.8 KiB

+2 -1
View File
@@ -27,7 +27,8 @@ dependencies = [
"scipy",
"matplotlib",
"seaborn>=0.13",
"scikit-image"
"scikit-image",
"tqdm"
]
[tool.setuptools]
+19 -2
View File
@@ -1,8 +1,25 @@
from .dataset import extract_features
from .dataset import (
extract_features,
rename_generated_images,
rename_real_images,
)
from .features import extract_features as extract_rgb_features
from .features_grayscale import extract_grayscale_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", "line_plot", "bar_plot", "scatter_plot", "correlation_plot", "box_plot"]
__all__ = [
"extract_features",
"extract_rgb_features",
"extract_grayscale_features",
"rename_real_images",
"rename_generated_images",
"line_plot",
"bar_plot",
"scatter_plot",
"correlation_plot",
"box_plot",
]
+45 -5
View File
@@ -1,28 +1,68 @@
from pathlib import Path
from uuid import uuid4
import pandas as pd
from .features import extract_features as extract_image_features
from .features import extract_features as extract_rgb_image_features
from .features_grayscale import extract_grayscale_features
from tqdm import tqdm
support_ext = {".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff", ".webp"}
def _rename_images(folder_path, prefix):
folder = Path(folder_path)
if not folder.exists():
raise FileNotFoundError(f"Folder not found: {folder}")
if not folder.is_dir():
raise NotADirectoryError(f"Expected a folder: {folder}")
images = sorted((file for file in folder.iterdir()if file.is_file() and file.suffix.lower() in support_ext),
key=lambda file: file.name.lower(),)
staged_images = []
for image in images:
temporary_path = folder / f".spectralforensics-{uuid4().hex}{image.suffix}"
image.rename(temporary_path)
staged_images.append((temporary_path, image.suffix.lower()))
renamed_images = []
for index, (temporary_path, suffix) in enumerate(staged_images, start=1):
new_path = folder / f"{prefix}{index}{suffix}"
temporary_path.rename(new_path)
renamed_images.append(new_path)
print(f"{len(renamed_images)} images renamed with the '{prefix}' prefix.")
return renamed_images
def extract_features(path, output_csv=None, image_size=(255, 255), high_freq_threshold=0.65, output="all", show_progress=True):
def rename_real_images(folder_path):
return _rename_images(folder_path, "real")
def rename_generated_images(folder_path):
return _rename_images(folder_path, "gen")
def extract_features(path,output_csv=None,image_size=None,high_freq_threshold=0.65,center_exclusion=5,
output="all",show_progress=True, color_mode="rgb",):
path = Path(path)
color_mode = str(color_mode).lower()
extractors = {"rgb": extract_rgb_image_features,"grayscale": extract_grayscale_features,}
if color_mode not in extractors:
raise ValueError("color_mode must be either 'rgb' or 'grayscale'")
extractor = extractors[color_mode]
if image_size is None:
image_size = (1024, 1024) if color_mode == "rgb" else (255, 255)
if not path.exists():
raise FileNotFoundError(f"Path not found: {path}")
if path.is_file():
if path.suffix.lower() not in support_ext:
raise ValueError(f"Unsupported image format: {path.suffix}")
return extract_image_features(path, image_size=image_size, high_freq_threshold=high_freq_threshold, output=output)
return extractor(path,image_size=image_size,high_freq_threshold=high_freq_threshold,center_exclusion=center_exclusion,output=output,)
image_files = [file for file in path.iterdir() if file.is_file() and file.suffix.lower() in support_ext]
iterator = (tqdm(image_files,total=len(image_files),desc="Extracting features",unit="image") if show_progress else image_files)
results = []
for image_file in iterator:
try:
features = extract_image_features(image_file, image_size=image_size, high_freq_threshold=high_freq_threshold, output=output)
features = extractor(image_file,
image_size=image_size,
high_freq_threshold=high_freq_threshold,
center_exclusion=center_exclusion,
output=output,)
results.append(features)
except Exception as e:
results.append({"filename": image_file.name, "path": str(image_file), "error": str(e)})
df = pd.DataFrame(results)
if output_csv:
df.to_csv(output_csv, index=False, encoding="utf-8-sig")
return df
return df
+127 -76
View File
@@ -5,20 +5,21 @@ from scipy.ndimage import median_filter, sobel, uniform_filter
from skimage.filters.rank import entropy
from skimage.morphology import disk
def extract_features(image_path, image_size=(255, 255), high_freq_threshold=0.65, center_exclusion=5, output="all"):
def extract_features(image_path,image_size=(1024, 1024),high_freq_threshold=0.65,center_exclusion=5,output="all"):
image_path = Path(image_path)
output = str(output).lower()
valid_outputs = {"all", "spectral", "spatial", "residual", "quantitative", "visual"}
valid_outputs = {"all", "spectral", "spatial","residual", "quantitative", "visual"}
if output not in valid_outputs:
raise ValueError("output must be one of: 'all', 'spectral', 'spatial', 'residual', 'quantitative', 'visual'")
raise ValueError("output must be one of: 'all', 'spectral', ""'spatial', 'residual', 'quantitative', 'visual'")
if not image_path.exists():
raise FileNotFoundError(f"Image not found: {image_path}")
if not image_path.is_file():
raise ValueError(f"Expected an image file: {image_path}")
image = Image.open(image_path).convert("L")
image = image.resize(image_size)
img_array = np.asarray(image, dtype=np.float32) / np.float32(255.0)
with Image.open(image_path) as image:
image = image.convert("RGB")
image = image.resize(image_size)
img_array = np.asarray(image, dtype=np.float32) / np.float32(255.0)
height, width, channels = img_array.shape
filename_lower = image_path.name.lower()
if "gen" in filename_lower:
target = "0"
@@ -26,7 +27,7 @@ def extract_features(image_path, image_size=(255, 255), high_freq_threshold=0.65
target = "1"
else:
target = None
results = {"filename": image_path.name,"path": str(image_path),"target": target}
results = {"filename": image_path.name,"path": str(image_path),"target": target,"color_mode": "rgb",}
calculate_spectral = output in {"all", "spectral", "quantitative", "visual"}
calculate_spatial = output in {"all", "spatial", "quantitative", "visual"}
calculate_residual = output in {"all", "residual", "quantitative", "visual"}
@@ -34,53 +35,74 @@ def extract_features(image_path, image_size=(255, 255), high_freq_threshold=0.65
return_spatial_values = output in {"all", "spatial", "quantitative"}
return_residual_values = output in {"all", "residual", "quantitative"}
return_visual_maps = output in {"all", "visual"}
eps = 1e-12
if calculate_spectral:
fft = np.fft.fft2(img_array)
fft_shift = np.fft.fftshift(fft)
fft = np.fft.fft2(img_array, axes=(0, 1))
fft_shift = np.fft.fftshift(fft, axes=(0, 1))
magnitude = np.abs(fft_shift).astype(np.float32)
energy = np.square(magnitude, dtype=np.float32)
total_energy = float(np.sum(energy, dtype=np.float64)) + 1e-12
height, width = energy.shape
center_y = height // 2
center_x = width // 2
y_indices, x_indices = np.indices((height, width), dtype=np.float32)
radius = np.sqrt((x_indices - center_x) ** 2 + (y_indices - center_y) ** 2).astype(np.float32)
maximum_radius = np.max(radius)
high_frequency_mask = (radius > high_freq_threshold * maximum_radius)
if return_spectral_values:
probability = energy / total_energy
spectral_entropy = -np.sum(probability * np.log2(probability + 1e-12), dtype=np.float64)
horizontal_energy = np.sum(energy[max(0, center_y - 2):min(height, center_y + 3), :], dtype=np.float64)
vertical_energy = np.sum(energy[:, max(0, center_x - 2):min(width, center_x + 3)], dtype=np.float64)
anisotropy = abs(horizontal_energy - vertical_energy) / (horizontal_energy + vertical_energy + 1e-12)
energy_no_center = energy.copy()
y_start = max(0, center_y - center_exclusion)
y_end = min(height, center_y + center_exclusion + 1)
x_start = max(0, center_x - center_exclusion)
x_end = min(width, center_x + center_exclusion + 1)
energy_no_center[y_start:y_end, x_start:x_end] = 0
dominant_position = np.unravel_index(np.argmax(energy_no_center), energy_no_center.shape)
dominant_frequency = radius[dominant_position]
energy_density = total_energy / (height * width)
maximum_radius = np.max(radius)
high_frequency_mask = radius > high_freq_threshold * maximum_radius
high_frequency_energy = np.sum(energy[high_frequency_mask], dtype=np.float64)
high_frequency_ratio = high_frequency_energy / total_energy
mean_energy = np.mean(energy, dtype=np.float64)
results.update({
"spectral_entropy": float(spectral_entropy),
"anisotropy": float(anisotropy),
"dominant_frequency": float(dominant_frequency),
"energy_density": float(energy_density),
"high_frequency_ratio": float(high_frequency_ratio),
"mean_energy": float(mean_energy)})
del probability
del energy_no_center
spectral_entropy_channels = []
anisotropy_channels = []
dominant_frequency_channels = []
energy_density_channels = []
high_frequency_ratio_channels = []
mean_energy_channels = []
for c in range(channels):
energy_c = energy[:, :, c]
total_energy_c = float(np.sum(energy_c, dtype=np.float64)) + eps
probability_c = energy_c / total_energy_c
spectral_entropy_c = -np.sum(probability_c * np.log2(probability_c + eps),dtype=np.float64)
horizontal_energy_c = np.sum(energy_c[max(0, center_y - 2):
min(height, center_y + 3), :],dtype=np.float64)
vertical_energy_c = np.sum(energy_c[:,max(0, center_x - 2):
min(width, center_x + 3)],dtype=np.float64)
anisotropy_c = (abs(horizontal_energy_c - vertical_energy_c) / (horizontal_energy_c +vertical_energy_c + eps))
energy_no_center = energy_c.copy()
y_start = max(0, center_y - center_exclusion)
y_end = min(height, center_y + center_exclusion + 1)
x_start = max(0, center_x - center_exclusion)
x_end = min(width, center_x + center_exclusion + 1)
energy_no_center[y_start:y_end,x_start:x_end] = 0
dominant_position = np.unravel_index(np.argmax(energy_no_center),energy_no_center.shape)
dominant_frequency_c = float(radius[dominant_position])
energy_density_c = (total_energy_c / (height * width))
high_frequency_energy_c = np.sum(energy_c[high_frequency_mask],dtype=np.float64)
high_frequency_ratio_c = (high_frequency_energy_c /total_energy_c)
mean_energy_c = np.mean(energy_c, dtype=np.float64)
spectral_entropy_channels.append(spectral_entropy_c)
anisotropy_channels.append(anisotropy_c)
dominant_frequency_channels.append(dominant_frequency_c)
energy_density_channels.append(energy_density_c)
high_frequency_ratio_channels.append(high_frequency_ratio_c)
mean_energy_channels.append(mean_energy_c)
results.update({"spectral_entropy": float(np.mean(spectral_entropy_channels)),
"anisotropy": float(np.mean(anisotropy_channels)),
"dominant_frequency": float(np.mean(dominant_frequency_channels)),
"energy_density": float(np.mean(energy_density_channels)),
"high_frequency_ratio": float(np.mean(high_frequency_ratio_channels)),
"mean_energy": float(np.mean(mean_energy_channels))})
if return_visual_maps:
fft_spectrum_raw = np.log1p(magnitude)
fft_minimum = fft_spectrum_raw.min()
fft_maximum = fft_spectrum_raw.max()
fft_spectrum = (255.0 * (fft_spectrum_raw - fft_minimum) / (fft_maximum - fft_minimum + 1e-12)).astype(np.uint8)
results["fft_spectrum"] = fft_spectrum
del fft_spectrum_raw
fft_spectrum_channels = np.empty((height, width, channels),dtype=np.uint8)
for c in range(channels):
spectrum_c = fft_spectrum_raw[:, :, c]
spectrum_min = spectrum_c.min()
spectrum_max = spectrum_c.max()
fft_spectrum_channels[:, :, c] = (255.0 *(spectrum_c - spectrum_min) / (spectrum_max - spectrum_min + eps)).astype(np.uint8)
aggregated_energy = np.mean(energy, axis=2, dtype=np.float64)
aggregated_magnitude = np.sqrt(aggregated_energy)
aggregated_spectrum_raw = np.log1p(aggregated_magnitude)
spectrum_min = aggregated_spectrum_raw.min()
spectrum_max = aggregated_spectrum_raw.max()
fft_spectrum = (255.0 *(aggregated_spectrum_raw - spectrum_min) / (spectrum_max - spectrum_min + eps)).astype(np.uint8)
results.update({"fft_spectrum_channels": fft_spectrum_channels,"fft_spectrum": fft_spectrum})
del fft
del fft_shift
del magnitude
@@ -88,35 +110,55 @@ def extract_features(image_path, image_size=(255, 255), high_freq_threshold=0.65
del radius
del y_indices
del x_indices
if calculate_spatial:
gradient_x = sobel(img_array, axis=1, mode="reflect").astype(np.float32)
gradient_y = sobel(img_array, axis=0, mode="reflect").astype(np.float32)
gradient_x = np.empty_like(img_array)
gradient_y = np.empty_like(img_array)
for c in range(channels):
gradient_x[:, :, c] = sobel(
img_array[:, :, c], axis=1, mode="reflect"
)
gradient_y[:, :, c] = sobel(
img_array[:, :, c], axis=0, mode="reflect"
)
gradient_raw = np.sqrt(gradient_x ** 2 + gradient_y ** 2).astype(np.float32)
local_mean = uniform_filter(img_array, size=7, mode="reflect").astype(np.float32)
local_squared_mean = uniform_filter(np.square(img_array, dtype=np.float32), size=7, mode="reflect").astype(np.float32)
local_variance_raw = np.maximum(local_squared_mean - local_mean ** 2, 0).astype(np.float32)
image_uint8 = (img_array * 255).astype(np.uint8)
local_entropy_raw = entropy(image_uint8, footprint=disk(3)).astype(np.float32)
local_mean = uniform_filter(img_array,size=(7, 7, 1),mode="reflect").astype(np.float32)
local_squared_mean = uniform_filter(np.square(img_array, dtype=np.float32),size=(7, 7, 1),mode="reflect").astype(np.float32)
local_variance_raw = np.maximum(local_squared_mean - local_mean ** 2,0).astype(np.float32)
image_uint8 = np.asarray(np.clip(np.rint(img_array * 255.0), 0, 255),dtype=np.uint8)
local_entropy_raw = np.empty((height, width, channels),dtype=np.float32)
entropy_footprint = disk(3)
for c in range(channels):
local_entropy_raw[:, :, c] = entropy(image_uint8[:, :, c],footprint=entropy_footprint).astype(np.float32)
if return_spatial_values:
results.update({
"mean_brightness": float(np.mean(img_array, dtype=np.float64)),
results.update({"mean_brightness": float(np.mean(img_array, dtype=np.float64)),
"mean_darkness": float(np.mean(1.0 - img_array, dtype=np.float64)),
"mean_gradient": float(np.mean(gradient_raw, dtype=np.float64)),
"mean_local_entropy": float(np.mean(local_entropy_raw, dtype=np.float64)),
"mean_local_variance": float(np.mean(local_variance_raw, dtype=np.float64))})
if return_visual_maps:
brightness_map = img_array.copy()
darkness_map = (1.0 - img_array).astype(np.float32)
gradient_minimum = gradient_raw.min()
gradient_maximum = gradient_raw.max()
gradient_map = ((gradient_raw - gradient_minimum) / (gradient_maximum - gradient_minimum + 1e-12)).astype(np.float32)
entropy_minimum = local_entropy_raw.min()
entropy_maximum = local_entropy_raw.max()
local_entropy_map = ((local_entropy_raw - entropy_minimum) / (entropy_maximum - entropy_minimum + 1e-12)).astype(np.float32)
variance_minimum = local_variance_raw.min()
variance_maximum = local_variance_raw.max()
local_variance_map = ((local_variance_raw - variance_minimum) / (variance_maximum - variance_minimum + 1e-12)).astype(np.float32)
results.update({"brightness_map": brightness_map,"darkness_map": darkness_map,"gradient_map": gradient_map,"local_entropy_map": local_entropy_map,"local_variance_map": local_variance_map})
gradient_aggregated = np.mean(gradient_raw, axis=2)
entropy_aggregated = np.mean(local_entropy_raw, axis=2)
variance_aggregated = np.mean(local_variance_raw, axis=2)
gradient_minimum = gradient_aggregated.min()
gradient_maximum = gradient_aggregated.max()
gradient_map = ((gradient_aggregated - gradient_minimum) /(gradient_maximum - gradient_minimum + eps)).astype(np.float32)
entropy_minimum = entropy_aggregated.min()
entropy_maximum = entropy_aggregated.max()
local_entropy_map = ((entropy_aggregated - entropy_minimum) /(entropy_maximum - entropy_minimum + eps)).astype(np.float32)
variance_minimum = variance_aggregated.min()
variance_maximum = variance_aggregated.max()
local_variance_map = ((variance_aggregated - variance_minimum) /(variance_maximum - variance_minimum + eps)).astype(np.float32)
results.update({
"brightness_map": brightness_map,
"darkness_map": darkness_map,
"gradient_map": gradient_map,
"local_entropy_map": local_entropy_map,
"local_variance_map": local_variance_map })
del gradient_x
del gradient_y
del gradient_raw
@@ -125,24 +167,33 @@ def extract_features(image_path, image_size=(255, 255), high_freq_threshold=0.65
del local_variance_raw
del local_entropy_raw
del image_uint8
if calculate_residual:
denoised_image = median_filter(img_array, size=3).astype(np.float32)
denoised_image = median_filter(img_array,size=(3, 3, 1),mode="reflect").astype(np.float32)
residual_noise_raw = (img_array - denoised_image).astype(np.float32)
if return_residual_values:
results.update({
"residual_noise_energy": float(np.mean(np.square(residual_noise_raw, dtype=np.float32), dtype=np.float64)),
"residual_noise_std": float(np.std(residual_noise_raw, dtype=np.float64)),
"residual_noise_mean_absolute": float(np.mean(np.abs(residual_noise_raw), dtype=np.float64))})
residual_noise_energy = np.mean(
np.square(residual_noise_raw,dtype=np.float32),dtype=np.float64)
residual_std_channels = np.std(residual_noise_raw,axis=(0, 1),dtype=np.float64)
residual_noise_std = np.mean(residual_std_channels)
residual_noise_std_global = np.std(residual_noise_raw,dtype=np.float64)
residual_noise_mean_absolute = np.mean(np.abs(residual_noise_raw),dtype=np.float64)
results.update({"residual_noise_energy": float(residual_noise_energy),
"residual_noise_std": float(residual_noise_std),
"residual_noise_std_global": float(residual_noise_std_global),
"residual_noise_mean_absolute": float(residual_noise_mean_absolute)})
if return_visual_maps:
residual_absolute = np.abs(residual_noise_raw).astype(np.float32)
residual_minimum = residual_absolute.min()
residual_maximum = residual_absolute.max()
residual_noise_display = np.sqrt((residual_absolute - residual_minimum) / (residual_maximum - residual_minimum + 1e-12)).astype(np.float32)
results.update({
"residual_noise_raw": residual_noise_raw,
"residual_noise": residual_noise_display})
residual_noise_display = np.empty_like(residual_absolute)
for c in range(channels):
residual_c = residual_absolute[:, :, c]
residual_minimum = residual_c.min()
residual_maximum = residual_c.max()
residual_noise_display[:, :, c] = np.sqrt((residual_c - residual_minimum) / (residual_maximum - residual_minimum + eps)).astype(np.float32)
results.update({"residual_noise_raw": residual_noise_raw,"residual_noise": residual_noise_display})
del residual_absolute
del denoised_image
if not return_visual_maps:
del residual_noise_raw
return results
return results
+132
View File
@@ -0,0 +1,132 @@
from pathlib import Path
import numpy as np
from PIL import Image
from scipy.ndimage import median_filter, sobel, uniform_filter
from skimage.filters.rank import entropy
from skimage.morphology import disk
def extract_grayscale_features(image_path,image_size=(255, 255),high_freq_threshold=0.65,center_exclusion=5,output="all",):
image_path = Path(image_path)
output = str(output).lower()
valid_outputs = {"all","spectral","spatial","residual","quantitative","visual",}
if output not in valid_outputs:
raise ValueError("output must be one of: 'all', 'spectral', 'spatial', 'residual', 'quantitative', 'visual'")
if not image_path.exists():
raise FileNotFoundError(f"Image not found: {image_path}")
if not image_path.is_file():
raise ValueError(f"Expected an image file: {image_path}")
with Image.open(image_path) as image:
image = image.convert("L")
image = image.resize(image_size)
img_array = np.asarray(image, dtype=np.float32) / np.float32(255.0)
filename_lower = image_path.name.lower()
if "gen" in filename_lower:
target = "0"
elif "real" in filename_lower:
target = "1"
else:
target = None
results = {"filename": image_path.name,"path": str(image_path),"target": target,"color_mode": "grayscale",}
calculate_spectral = output in {"all", "spectral", "quantitative", "visual"}
calculate_spatial = output in {"all", "spatial", "quantitative", "visual"}
calculate_residual = output in {"all", "residual", "quantitative", "visual"}
return_spectral_values = output in {"all", "spectral", "quantitative"}
return_spatial_values = output in {"all", "spatial", "quantitative"}
return_residual_values = output in {"all", "residual", "quantitative"}
return_visual_maps = output in {"all", "visual"}
eps = 1e-12
if calculate_spectral:
fft = np.fft.fft2(img_array)
fft_shift = np.fft.fftshift(fft)
magnitude = np.abs(fft_shift).astype(np.float32)
energy = np.square(magnitude, dtype=np.float32)
total_energy = float(np.sum(energy, dtype=np.float64)) + eps
height, width = energy.shape
center_y = height // 2
center_x = width // 2
y_indices, x_indices = np.indices((height, width), dtype=np.float32)
radius = np.sqrt((x_indices - center_x) ** 2 + (y_indices - center_y) ** 2).astype(np.float32)
if return_spectral_values:
probability = energy / total_energy
spectral_entropy = -np.sum(probability * np.log2(probability + eps), dtype=np.float64)
horizontal_energy = np.sum(energy[max(0, center_y - 2) : min(height, center_y + 3), :],dtype=np.float64,)
vertical_energy = np.sum(energy[:, max(0, center_x - 2) : min(width, center_x + 3)],dtype=np.float64,)
anisotropy = abs(horizontal_energy - vertical_energy) / (horizontal_energy + vertical_energy + eps)
energy_no_center = energy.copy()
y_start = max(0, center_y - center_exclusion)
y_end = min(height, center_y + center_exclusion + 1)
x_start = max(0, center_x - center_exclusion)
x_end = min(width, center_x + center_exclusion + 1)
energy_no_center[y_start:y_end, x_start:x_end] = 0
dominant_position = np.unravel_index(np.argmax(energy_no_center), energy_no_center.shape)
dominant_frequency = radius[dominant_position]
energy_density = total_energy / (height * width)
maximum_radius = np.max(radius)
high_frequency_mask = radius > high_freq_threshold * maximum_radius
high_frequency_energy = np.sum(energy[high_frequency_mask], dtype=np.float64)
high_frequency_ratio = high_frequency_energy / total_energy
mean_energy = np.mean(energy, dtype=np.float64)
results.update({"spectral_entropy": float(spectral_entropy),
"anisotropy": float(anisotropy),
"dominant_frequency": float(dominant_frequency),
"energy_density": float(energy_density),
"high_frequency_ratio": float(high_frequency_ratio),
"mean_energy": float(mean_energy),})
if return_visual_maps:
fft_spectrum_raw = np.log1p(magnitude)
fft_minimum = fft_spectrum_raw.min()
fft_maximum = fft_spectrum_raw.max()
fft_spectrum = (255.0* (fft_spectrum_raw - fft_minimum)/ (fft_maximum - fft_minimum + eps)).astype(np.uint8)
results["fft_spectrum"] = fft_spectrum
if calculate_spatial:
gradient_x = sobel(img_array, axis=1, mode="reflect").astype(np.float32)
gradient_y = sobel(img_array, axis=0, mode="reflect").astype(np.float32)
gradient_raw = np.sqrt(gradient_x**2 + gradient_y**2).astype(np.float32)
local_mean = uniform_filter(img_array, size=7, mode="reflect").astype(np.float32)
local_squared_mean = uniform_filter(np.square(img_array, dtype=np.float32), size=7, mode="reflect").astype(np.float32)
local_variance_raw = np.maximum(local_squared_mean - local_mean**2, 0).astype(np.float32)
image_uint8 = (img_array * 255).astype(np.uint8)
local_entropy_raw = entropy(image_uint8, footprint=disk(3)).astype(np.float32)
if return_spatial_values:
results.update({"mean_brightness": float(np.mean(img_array, dtype=np.float64)),
"mean_darkness": float(np.mean(1.0 - img_array, dtype=np.float64)),
"mean_gradient": float(np.mean(gradient_raw, dtype=np.float64)),
"mean_local_entropy": float(np.mean(local_entropy_raw, dtype=np.float64)),
"mean_local_variance": float(np.mean(local_variance_raw, dtype=np.float64)),})
if return_visual_maps:
brightness_map = img_array.copy()
darkness_map = (1.0 - img_array).astype(np.float32)
gradient_minimum = gradient_raw.min()
gradient_maximum = gradient_raw.max()
gradient_map = ((gradient_raw - gradient_minimum)/ (gradient_maximum - gradient_minimum + eps)).astype(np.float32)
entropy_minimum = local_entropy_raw.min()
entropy_maximum = local_entropy_raw.max()
local_entropy_map = ((local_entropy_raw - entropy_minimum)/ (entropy_maximum - entropy_minimum + eps)).astype(np.float32)
variance_minimum = local_variance_raw.min()
variance_maximum = local_variance_raw.max()
local_variance_map = ((local_variance_raw - variance_minimum)/ (variance_maximum - variance_minimum + eps)).astype(np.float32)
results.update({"brightness_map": brightness_map,
"darkness_map": darkness_map,
"gradient_map": gradient_map,
"local_entropy_map": local_entropy_map,
"local_variance_map": local_variance_map,})
if calculate_residual:
denoised_image = median_filter(img_array, size=3, mode="reflect").astype(np.float32)
residual_noise_raw = (img_array - denoised_image).astype(np.float32)
if return_residual_values:
results.update({"residual_noise_energy": float(np.mean(
np.square(residual_noise_raw, dtype=np.float32),
dtype=np.float64,)),
"residual_noise_std": float(np.std(residual_noise_raw, dtype=np.float64)),
"residual_noise_mean_absolute": float(np.mean(np.abs(residual_noise_raw), dtype=np.float64)),})
if return_visual_maps:
residual_absolute = np.abs(residual_noise_raw).astype(np.float32)
residual_minimum = residual_absolute.min()
residual_maximum = residual_absolute.max()
residual_noise_display = np.sqrt((residual_absolute - residual_minimum)/ (residual_maximum - residual_minimum + eps)).astype(np.float32)
results.update({"residual_noise_raw": residual_noise_raw,"residual_noise": residual_noise_display,})
return results
+20 -20
View File
@@ -24,7 +24,7 @@ def _clip_segment(a, b):
def _copy_canvas(canvas):
if sys.platform != "win32":
raise RuntimeError("A cópia de imagem está disponível no Windows.")
raise RuntimeError("Image copying is only available on Windows.")
canvas.update_idletasks()
x, y = canvas.winfo_rootx(), canvas.winfo_rooty()
image = ImageGrab.grab((x, y, x + canvas.winfo_width(),
@@ -44,20 +44,20 @@ def _copy_canvas(canvas):
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.")
raise RuntimeError("Could not allocate memory for the image.")
try:
pointer = kernel.GlobalLock(handle)
if not pointer:
raise RuntimeError("Não foi possível preparar a imagem.")
raise RuntimeError("Could not prepare the image.")
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.")
raise RuntimeError("The clipboard is busy. Please try again.")
try:
if not user.EmptyClipboard() or not user.SetClipboardData(8, handle):
raise RuntimeError("Não foi possível copiar a imagem.")
raise RuntimeError("Could not copy the image.")
handle = None
finally:
user.CloseClipboard()
@@ -172,7 +172,7 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
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(
ttk.Label(controls, text="Y" if kind == "box" else "Multiple Y").grid(
row=0, column=2, padx=(0, 6), sticky="w")
quantitative_filter.grid(row=0, column=3, sticky="ew")
@@ -181,7 +181,7 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
("☑ " 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")
or "Select Y variables")
update_quantitative_choices()
if kind == "box":
@@ -190,7 +190,7 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
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,
ttk.Checkbutton(box_options, text="Fill boxes", 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,
@@ -205,7 +205,7 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
state="readonly", width=18)
palette_selector.pack(side="left")
palette_selector.bind("<<ComboboxSelected>>", lambda event: schedule())
filter_label = ttk.Label(controls, text="Categorias")
filter_label = ttk.Label(controls, text="Categories")
status = ttk.Label(controls)
category_var = tk.StringVar(window)
category_selector = CheckCombobox(controls, textvariable=category_var,
@@ -217,17 +217,17 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
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 all_selected else "☐ ") + "Select all",
*[("☑ " 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."))
status.configure(text=f"{len(selected_categories)}/{len(category_labels)} categories selected; "
+ ("all values shown as bars." if kind == "bar"
else "distribution by category." if kind == "box"
else "all observations shown as points." if kind == "scatter"
else "all points shown per line."))
category_var.set(", ".join(label for index, label in enumerate(category_labels)
if index in selected_categories)
or "Selecionar categorias")
or "Select categories")
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from matplotlib.ticker import MaxNLocator, FixedLocator, FormatStrFormatter
@@ -292,9 +292,9 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
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()
axes.set_xlabel("Observation by category — " + 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",
axes.set_ylabel(variables[0] if len(variables) == 1 else "Quantitative variables",
color="#edf2fa")
axes.set_axisbelow(True)
axes.grid(axis="y", color="#29364a")
@@ -310,7 +310,7 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
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",
axes.text(.5, .5, "No valid pairs in the selected categories",
ha="center", va="center", transform=axes.transAxes, color="#edf2fa")
else:
group_width = None
@@ -397,7 +397,7 @@ def _interactive_plot(data, x=None, y=None, *, title="SpectralForensics", sort_x
window.update_idletasks()
_copy_canvas(canvas.get_tk_widget())
except Exception as error:
messagebox.showerror("Copiar gráfico", str(error), parent=window)
messagebox.showerror("Copy plot", str(error), parent=window)
actions = ttk.Frame(controls)
actions.grid(row=1, column=3, sticky="ew", padx=(0, 18), pady=(8, 0))
+2 -2
View File
@@ -9,14 +9,14 @@ def _draw_boxplot(axes, frame, x, y, categories, selected, *, fill, gap, palette
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",
axes.text(.5, .5, "Select categories and a Y variable", 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",
axes.text(.5, .5, "No valid values in the selected categories",
ha="center", va="center", transform=axes.transAxes, color="#edf2fa")
return
colors = sns.color_palette(palette, n_colors=len(categories))
+29 -29
View File
@@ -14,7 +14,7 @@ __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",
figsize=None, title="Feature Correlation Matrix",
target_title=None, show=False, page="matrix"):
frame = pd.DataFrame(data)
if not frame.columns.is_unique:
@@ -64,8 +64,8 @@ def _correlation_figure(data, correlation_columns=None, *, method="pearson",
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}"
method_name = method.capitalize() if isinstance(method, str) else "Custom"
correlation_label = f"Correlation ({method_name}) with {target}"
if kind == "barh":
target_ax.set_xlabel(correlation_label)
target_ax.set_ylabel("Feature")
@@ -76,7 +76,7 @@ def _correlation_figure(data, correlation_columns=None, *, method="pearson",
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}")
target_ax.set_title(target_title or f"Feature Correlation with {target}")
figure.tight_layout()
return {"figure": figure,
"axes": {"heatmap": heatmap_ax, "target": target_ax},
@@ -84,7 +84,7 @@ def _correlation_figure(data, correlation_columns=None, *, method="pearson",
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",
figsize=None, title="Feature Correlation Matrix",
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,
@@ -119,12 +119,12 @@ def correlation_plot(data, correlation_columns=None, *, method="pearson",
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")
method_var = tk.StringVar(window, method if isinstance(method, str) else "Custom")
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)
target_var = tk.StringVar(window, "(No 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)
@@ -158,15 +158,15 @@ def correlation_plot(data, correlation_columns=None, *, method="pearson",
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")
page_label = tk.StringVar(window, "1/2 — Correlation matrix" if target is not None
else "Correlation matrix")
def update_plot():
nonlocal pending, page
pending = None
try:
chosen_target = None if target_var.get() == "(Sem target)" else target_var.get()
chosen_target = None if target_var.get() == "(No 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_method = method if method_var.get() == "Custom" else method_var.get()
current = _correlation_figure(
frame, [name for name in columns if name in selected],
method=current_method, cmap=cmap_var.get(),
@@ -188,10 +188,10 @@ def correlation_plot(data, correlation_columns=None, *, method="pearson",
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.")
page_label.set(("1/2 — Correlation matrix" if page == "matrix"
else "2/2 — Target correlation") if chosen_target is not None
else "Correlation matrix")
status.set("Updated.")
def schedule(event=None):
nonlocal pending
if pending is not None:
@@ -209,9 +209,9 @@ def correlation_plot(data, correlation_columns=None, *, method="pearson",
features = combo("Features", feature_var, [], 0, 0, multiple=True)
def refresh_features():
features.configure(values=[
("☑ " if len(selected) == len(columns) else "☐ ") + "Selecionar todos",
("☑ " if len(selected) == len(columns) else "☐ ") + "Select all",
*[("☑ " if name in selected else "☐ ") + str(name) for name in columns]])
feature_var.set(f"{len(selected)}/{len(columns)} features selecionadas")
feature_var.set(f"{len(selected)}/{len(columns)} features selected")
def select_feature(event=None):
index = features.current()
if index == 0:
@@ -229,20 +229,20 @@ def correlation_plot(data, correlation_columns=None, *, method="pearson",
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)
combo("Method", method_var,
["pearson", "spearman", "kendall"] + (["Custom"] if callable(method) else []), 0, 2)
combo("Color map", cmap_var, sorted(colormaps), 0, 4)
target_selector = combo("Target", target_var, ["(No target)", *columns], 1, 0)
combo("Plot type", kind_var, ["bar", "barh"], 1, 2)
by_selector = combo("Sort 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()
value = "" if target_var.get() == "(No 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)):
for label, variable, column in (("Center (empty = automatic)", center_var, 0),
("Format (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)
@@ -250,15 +250,15 @@ def correlation_plot(data, correlation_columns=None, *, method="pearson",
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")
ttk.Checkbutton(checks, text="Annotations", variable=annot_var, command=schedule).pack(side="left")
ttk.Checkbutton(checks, text="Ascending order", 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)
messagebox.showerror("Copy plot", str(error), parent=window)
actions = ttk.Frame(controls)
actions.grid(row=3, column=0, columnspan=6, sticky="w", pady=(8, 0))
def navigate(destination):