# GimnTools
[](https://python.org)
[](LICENSE)
[](https://gimntools.readthedocs.io/)
[](https://pypi.org/project/gimntools/)
## Introdução e Visão Geral
A GimnTools é uma biblioteca Python de código aberto projetada para o processamento de imagens médicas e reconstrução tomográfica. Ela oferece um conjunto de ferramentas robustas para manipulação de imagens, geração de sinogramas, aplicação de filtros e implementação de algoritmos de reconstrução. O objetivo desta documentação é fornecer um guia completo e exaustivo para desenvolvedores e pesquisadores que desejam utilizar a GimnTools em seus projetos.
## ✨ Principais Funcionalidades
### 🔬 Reconstrução Tomográfica
- **Algoritmos de Reconstrução**: MLEM, OSEM, FBP (Filtered Back-Projection)
- **Reconstrução por Integrais de Linha**: Implementação otimizada com Numba
- **Matriz de Sistema**: Suporte para reconstrução baseada em matriz de sistema
- **Correções**: Atenuação, dispersão e normalização
### 📊 Processamento de Sinogramas
- **Geração de Sinogramas**: Suporte para cristais monolíticos e segmentados
- **Conversão de Coordenadas**: Transformação entre espaços de cristais e pixels
- **Configuração de Sistema**: Gerenciamento flexível de geometrias de detectores
### 🖼️ Processamento de Imagens
- **Filtros Espaciais**: Convolução, filtros de vizinhança otimizados
- **Filtros de Frequência**: Transformada de Fourier e filtragem espectral
- **Filtros Morfológicos**: Operações de abertura, fechamento, erosão e dilatação
- **Interpolação**: Métodos de reconstrução e reamostragem
### 🎯 Fantomas e Simulação
- **Fantoma de Derenzo**: Geração paramétrica de fantomas de teste
- **Geometrias Customizadas**: Criação de formas geométricas diversas
- **Fantomas Aleatórios**: Geração procedural para testes variados
### 📁 I/O de Imagens Médicas
- **DICOM**: Leitura e escrita usando SimpleITK e ITK
- **Normalização**: Conversão entre tipos de dados e escalas
- **Metadados**: Preservação de informações de espaçamento, origem e orientação
## 🚀 Instalação Rápida
### Requisitos
- Python 3.8 ou superior
- Sistema operacional: Windows, macOS ou Linux
### Instalação via pip
```bash
pip install GimnTools
```
### Instalação para Desenvolvimento
```bash
git clone https://github.com/usuario/GimnTools.git
cd GimnTools
pip install -e ".[dev]"
```
### Usando Scripts de Instalação
```bash
# Clone o repositório
git clone https://github.com/usuario/GimnTools.git
cd GimnTools
# Execute o script de instalação
python scripts/install.py --mode development --jupyter
# Ou use o Makefile (Linux/macOS)
make install-dev
```
## 🛠️ Scripts de Build e Deploy
A biblioteca inclui scripts automatizados para facilitar o desenvolvimento:
### Scripts Disponíveis
#### Script de Instalação (`scripts/install.py`)
```bash
# Instalação básica
python scripts/install.py
# Instalação para desenvolvimento
python scripts/install.py --mode development --jupyter --docs
# Criar ambiente virtual
python scripts/install.py --venv
```
### Usando Makefile (Linux/macOS)
```bash
# Instalar para usuario
make install
# Instalar para desenvolvimento
make install-dev
# Executar testes
make test
# Build completo
make build
# Deploy para PyPI de teste
make upload
# Limpar arquivos temporários
make clean
```
## 📁 Estrutura do Projeto
```
GimnTools/
├── GimnTools/ # Pacote principal
│ ├── __init__.py
│ └── ImaGIMN/ # Módulo principal
│ ├── image.py # Classe base para imagens
│ ├── IO/ # Entrada e saída
│ │ ├── MIIO.py # I/O de imagens médicas
│ │ └── GimnIO.py # I/O geral
│ ├── sinogramer/ # Geração de sinogramas
│ │ ├── sinogramer.py
│ │ ├── conf.py
│ │ └── systemSpace.py
│ ├── gimnRec/ # Reconstrução
│ │ ├── reconstructors/
│ │ ├── backprojectors.py
│ │ ├── projectors.py
│ │ └── corrections.py
│ ├── processing/ # Processamento
│ │ ├── filters/ # Filtros
│ │ ├── interpolators/
│ │ ├── tools/ # Ferramentas matemáticas
│ │ └── ploter/ # Visualização
│ └── phantoms/ # Fantomas
│ ├── derenzzo.py
│ ├── random.py
│ └── geometries/
├── scripts/ # Scripts de automação
│ ├── build.py # Script de build
│ ├── install.py # Script de instalação
│ └── deploy.py # Script de deploy
├── docs/ # Documentação
├── tests/ # Testes
├── examples/ # Exemplos
├── setup.py # Configuração setuptools
├── pyproject.toml # Configuração moderna
├── requirements.txt # Dependências
├── requirements-dev.txt # Dependências dev
├── Makefile # Automação (Unix)
└── README.md # Este arquivo
```
## 🔧 Dependências
### Principais
- **numpy** (≥1.20.0): Computação numérica
- **scipy** (≥1.7.0): Algoritmos científicos
- **matplotlib** (≥3.3.0): Visualização
- **numba** (≥0.54.0): Compilação JIT para performance
- **SimpleITK** (≥2.1.0): Processamento de imagens médicas
- **itk** (≥5.2.0): Toolkit de imagens
- **Pillow** (≥8.0.0): Manipulação de imagens
- **scikit-image** (≥0.18.0): Processamento de imagens
- **h5py** (≥3.1.0): Armazenamento HDF5
- **tqdm** (≥4.60.0): Barras de progresso
### Dependências de Desenvolvimento
- **pytest**: Framework de testes
- **sphinx**: Geração de documentação
- **black**: Formatação de código
- **flake8**: Linting
- **mypy**: Verificação de tipos
## 📚 Documentação
A documentação completa está disponível em:
- **Online**: [https://gimntools.readthedocs.io/](https://gimntools.readthedocs.io/)
- **Local**: Execute `make docs` para gerar localmente
### Tópicos da Documentação
- **Guia do Usuário**: Introdução e conceitos básicos
- **API Reference**: Documentação detalhada de todas as funções
- **Tutoriais**: Exemplos passo a passo
- **Guia do Desenvolvedor**: Como contribuir para o projeto
## Documentação Detalhada dos Módulos
### 1. `ImaGIMN.IO`
Responsável pelas operações de entrada e saída.
* **`MIIO.py`**: Classe de alto nível para manipulação de I/O de imagens médicas, especialmente DICOM. Usa `SimpleITK` e `ITK` como backend. Fornece funcionalidades essenciais como leitura, escrita e normalização de imagens.
* **`GimnIO.py`**: Utilitários de I/O de baixo nível, como criação de pastas e salvamento de arquivos JSON.
### 2. `ImaGIMN.gimnRec`
Contém os algoritmos e componentes para a reconstrução tomográfica.
* **`reconstruction_filters.py`**: Implementa filtros usados na reconstrução FBP (Filtered Back-Projection), como Ram-Lak, Shepp-Logan, etc.
* **`projectors.py`**: Contém funções para a projeção (forward projection), que simula a aquisição de dados (cria um sinograma a partir de uma imagem).
* **`backprojectors.py`**: Contém funções para a retroprojeção (back-projection), o processo inverso da projeção, usado em algoritmos como FBP e iterativos.
* **`corrections.py`**: Funções para aplicar correções necessárias durante a reconstrução, como a correção do centro de rotação.
#### 2.1. `ImaGIMN.gimnRec.reconstructors`
Implementações concretas de algoritmos de reconstrução.
* **`line_integral_reconstructor.py`**: Reconstrutor principal que implementa algoritmos baseados em integral de linha, como FBP, MLEM e OSEM. É uma classe versátil e de uso geral.
* **`rotation_reconstruction.py`**: Implementação que realiza a reconstrução baseada em rotações sucessivas da imagem. Serve como uma classe base ou alternativa para os reconstrutores.
* **`system_matrix_reconstruction.py`**: Reconstrutor que utiliza uma matriz de sistema pré-calculada para realizar as projeções e retroprojeções. Pode ser mais lento para gerar a matriz, mas mais rápido para iterar. Versão para CPU.
* **`system_matrix_reconstruction2.py`**: Uma segunda implementação (possivelmente experimental ou com otimizações diferentes) do reconstrutor baseado em matriz de sistema.
### 3. `ImaGIMN.processing`
Ferramentas para processamento e análise de imagens.
#### 3.1. `ImaGIMN.processing.filters`
* **`spatial_filters.py`**: Contém filtros que operam diretamente na matriz de pixels. Inclui funções para convolução 2D, aplicação de filtros separáveis e extração de vizinhanças de pixels.
* **`frequency_filters.py`**: Implementa filtros no domínio da frequência, como o filtro Gaussiano e o Butterworth. Útil para suavização e realce de bordas.
* **`morphological_filters.py`**: Funções para morfologia matemática (Erosão, Dilatação, Abertura e Fechamento), usadas para análise de formas e estruturas na imagem.
#### 3.2. `ImaGIMN.processing.interpolators`
* **`reconstruction.py`**: Fornece diferentes métodos de interpolação (Vizinho Mais Próximo, Bilinear, Spline Beta) que são cruciais para algoritmos de rotação e reconstrução, garantindo a precisão ao acessar valores de pixels em coordenadas não inteiras.
#### 3.3. `ImaGIMN.processing.tools`
* **`kernels.py`**: Funções para gerar kernels (matrizes) usados em filtros de convolução, como kernels Gaussianos e Butterworth de diferentes tipos (passa-baixa, passa-alta).
* **`math.py`**: Funções matemáticas essenciais, como convolução e deconvolução no domínio da frequência (via FFT) e rotação de imagem com diferentes interpoladores.
* **`utils.py`**: Utilitários diversos, com destaque para a função de redimensionamento de imagem (`resize`) que suporta múltiplos métodos de interpolação.
#### 3.4. `ImaGIMN.processing.ploter`
* **`ploter.py`**: Ferramenta de visualização para plotar múltiplos slices de um volume 3D (como um sinograma ou uma imagem reconstruída) em uma grade, facilitando a inspeção visual.
### 4. `ImaGIMN.phantoms`
* **`derenzzo.py`**: Contém classes para a geração de phantoms de Derenzo, que são padrões de teste padrão em imagem médica para avaliar a resolução espacial de um sistema.
## Exemplos de Uso Práticos
### Exemplo 1: Criação de imagens Aleatórias
```python
from GimnTools.ImaGIMN.phantoms.random import generate_random_image
"""Generates a random image for testing purposes."""
import matplotlib.pyplot as plt
pixels = 128 # size off the image
number_of_figures = 10 # number of figures in the image
# Generate a random image with specified number of figures using generate_random_image function
# This function creates an image with random geometric figures like stars, ellipses, and polygons.
# The figures are randomly placed and sized within the image.
img = generate_random_image(pixels, number_of_figures)
path = "./output/"
# Ensure the output directory exists
# If it doesn't exist, create it
Path(path).mkdir(parents=True, exist_ok=True)
# Save the generated image to a file
# The image is saved in PNG format with a specific filename
filename = path + "random_image_test.png"
# Display the image using matplotlib
plt.figure(figsize=(6, 6))
plt.clf()
plt.axis('off')
plt.imshow(img, cmap='jet')
plt.title("Random Image Test")
plt.savefig(filename, bbox_inches='tight', pad_inches=0.1)
plt.show()
print(f"Random image saved to {filename}")
```
### Exemplo 2: Teste Shepp-Logan Phantom
```python
from skimage.data import shepp_logan_phantom
# Generate the Shepp-Logan phantom
img = shepp_logan_phantom()
# Resize the image to 128x128 pixels
img = resize(img, (128, 128), anti_aliasing=True)
noiser = noise_level
resized_image = img * noiser
noisy_image = np.random.poisson(resized_image).astype(np.float64)
# Save the image to a file
path = "./output/"
Path(path).mkdir(parents=True, exist_ok=True)
filename = path + "shepp_logan_phantom_test.png"
plt.figure(figsize=(6, 6))
plt.clf()
plt.axis('off')
plt.imshow(noisy_image, cmap='jet')
plt.title("Shepp-Logan Phantom")
plt.savefig(filename, bbox_inches='tight', pad_inches=0.1)
plt.show()
print(f"Shepp-Logan phantom saved to {filename}")
```
### Exemplo 3: Gerar Fantoma de Derenzo
```python
from GimnTools.ImaGIMN.phantoms.derenzzo import DerenzoPhantomSlice
"""
Generates a Derenzo phantom image, resizes it, and saves it as a PNG file.
"""
import matplotlib.pyplot as plt
# Teste do código adaptado
radius = 29.0 / 2
num_sections = 4
well_counts = (6, 6, 10, 15)
well_diameters = (2.5, 2.0, 1.5, 1.0)
well_separations = (2.5, 2.0, 1.5, 1.0)
section_offsets = (0.00000001, 0.01, 0.01, 0.1) # Offset personalizado para cada seção
circle_value = 1
well_value = 10
image_size = 128
my_phantom = DerenzoPhantomSlice(radius, num_sections, well_counts, well_diameters, well_separations, section_offsets,
image_size=image_size, circle_value=circle_value, well_value=well_value)
#my_phantom.save_image('derenzo_phantom_with_offsets.png')
# Obter a matriz da imagem contendo apenas o círculo de fundo
circle_image_matrix = my_phantom.draw_only_circle()
# Obter a matriz completa do fantoma
phantom_matrix = my_phantom.get_image_matrix()
noisy_image = np.random.poisson(phantom_matrix*noise_factor).astype(np.float64)
plt.imshow (noisy_image, cmap='jet')
plt.title('Derenzo Phantom with Noise')
plt.colorbar()
print(f"✅ Imagem simulada de um fantoma derenzo de raio {radius}mm e poços com diametros {well_diameters} mm com ruído foi criada e tem dimensões: {noisy_image.shape}")
path = "./output/"
Path(path).mkdir(parents=True, exist_ok=True)
plt.savefig(path + "derenzo_phantom_test.png", bbox_inches='tight', pad_inches=0.1)
```
### Exemplo 3: Reconstrução usando reconstrutor com projetor baseado na rotação da imagem
```python
from GimnTools.ImaGIMN.gimnRec.reconstructors.rotation_reconstruction import rotation_reconstructor
from GimnTools.ImaGIMN.processing.interpolators.reconstruction import beta_spline_interpolation, bilinear_interpolation, nearest_neighbor_interpolation
from GimnTools.ImaGIMN.gimnRec.reconstruction_filters import ramLak
from GimnTools.ImaGIMN.gimnRec.projectors import radon_m, projector, direct_radon
pixels = 128 # Size of the image
number_of_angles = pixels # Number of angles for the sinogram
number_of_slices = 2 # Number of slices in the stack
# Generate a derenzo phantom image with noise
noisy_image = derenzo_phantom_test(noise_factor=0.3)
angles = np.linspace(0, 180, number_of_angles, endpoint=True)
sinogram = direct_radon(noisy_image, angles)
stack = np.asarray([sinogram for _ in range(number_of_slices)])
reconstructor = rotation_reconstructor()
reconstructor.set_sinogram(stack)
#reconstructor.set_sinogram(sino)
iterations = 3
subsets = 8 #2, 4, 8, 16
angles_here = angles+180
recon_osem_rot = reconstructor.osem(iterations,subsets, bilinear_interpolation, angles=angles_here, verbose=False)
recon_mlem_rot = reconstructor.mlem(iterations*subsets, bilinear_interpolation, angles=angles_here, verbose=False)
recon_fbp_rot= reconstructor.fbp(bilinear_interpolation, ramLak, angles=angles_here)
cmap = 'jet'
# Display the reconstructed images
plt.figure(figsize=(12, 8))
plt.subplot(1, 3, 1)
plt.imshow(recon_osem_rot[0], cmap=cmap)
plt.title('OSEM Reconstruction (Rotation)')
plt.axis('off')
plt.subplot(1, 3, 2)
plt.imshow(recon_mlem_rot[0], cmap=cmap)
plt.title('MLEM Reconstruction (Rotation)')
plt.axis('off')
plt.subplot(1, 3, 3)
plt.imshow(recon_fbp_rot[0], cmap=cmap)
plt.title('FBP Reconstruction (Rotation)')
plt.axis('off')
plt.tight_layout()
# Save the reconstructed images
path = "./output/"
Path(path).mkdir(parents=True, exist_ok=True)
plt.savefig(path + "rotation_reconstructor_test.png", bbox_inches='tight', pad_inches=0.1)
print(f"✅ Rotation reconstructor test completed successfully. Images saved to {path}rotation_reconstructor_test.png")
```
### Exemplo 3: Reconstrutor baseado na integral da linha de projeção
```python
from GimnTools.ImaGIMN.gimnRec.reconstructors.line_integral_reconstructor import line_integral_reconstructor
import matplotlib.pyplot as plt
pixels = 128 # Size of the image
number_of_angles = pixels # Number of angles for the sinogram
number_of_slices = 2 # Number of slices in the stack
# Generate a derenzo phantom image with noise
noisy_image = derenzo_phantom_test(noise_factor=0.3)
angles = np.linspace(0, 180, number_of_angles, endpoint=True)
sinogram = direct_radon(noisy_image, angles)
stack = np.asarray([sinogram for _ in range(number_of_slices)])
reconstructor = rotation_reconstructor()
reconstructor.set_sinogram(stack)
#reconstructor.set_sinogram(sino)
iterations = 3
subsets = 8 #2, 4, 8, 16
#==========================================================
# Reconstruir Line Integral
#==========================================================
#para este deve ser slice/bins/angle
angles_m1 = np.linspace(0, 180, number_of_angles, endpoint=True)
# angles_sm = np.linspace(180,0 , number_of_angles, endpoint=False)
reconstructor = line_integral_reconstructor(stack)
# recon_osem_li = reconstructor.osem(iterations,subsets, angles_m1, verbose=False)
# recon_mlem_li = reconstructor.mlem(iterations*subsets, angles_m1, verbose=False)
# recon_fbp_li = reconstructor.fbp( ramLak, angles)
# reconstructor.set_sinogram(stack)
iterations = [5]
subsets = [32]
pilha = []
for i in range(stack.shape[0]):
for iter in iterations:
for subset in subsets:
print(f'Processing - iteration: {iter}\tsubset: {subset}')
sino = stack[i:i+1, :, :]
reconstructor.set_sinogram(sino)
# Cria o dicionário com a estrutura especificada
recon = {}
recon["iterative_method"] = "OSEM/MLEM"
recon["iteration"] = iter
recon["subset"] = subset
recon["total_iterations"] = iter * subset
recon["sinogram"] = i + 1
recon ["image_OSEM"] = reconstructor.osem(iter, subset, angles_m1, verbose=False)
recon ["image_MLEM"] = reconstructor.mlem(iter * subset, angles_m1)
recon["analytic_method"] = "FBP"
recon["fbp_image"] = reconstructor.fbp(ramLak, angles)
pilha.append(deepcopy(recon))
plt.figure(figsize=(12, 8))
plt.subplot(1, 3, 1)
cmap = 'jet'
plt.imshow(pilha[0]["image_MLEM"][0], cmap=cmap)
plt.title('Line Integral MLEM Reconstruction')
plt.axis('off')
plt.subplot(1, 3, 2)
plt.imshow(pilha[0]["image_OSEM"][0], cmap=cmap)
plt.title('Line Integral OSEM Reconstruction')
plt.axis('off')
plt.subplot(1, 3, 3)
plt.imshow(pilha[0]["fbp_image"][0], cmap=cmap)
plt.title('Line Integral FBP Reconstruction')
plt.axis('off')
plt.tight_layout()
# Display the reconstructed image
# Save the reconstructed images
path = "./output/"
Path(path).mkdir(parents=True, exist_ok=True)
plt.savefig(path + "line_integral_reconstructor_test.png", bbox_inches='tight',
pad_inches=0.1)
print(f"✅ Line integral reconstructor test completed successfully. Images saved to {path}line_integral_reconstructor_test.png")
```
### Exemplo 3: Reconstrutor System Matrix
```python
from GimnTools.ImaGIMN.gimnRec.reconstructors.system_matrix_reconstruction import reconstructor_system_matrix_cpu
import matplotlib.pyplot as plt
pixels = 128 # Size of the image
number_of_angles = pixels # Number of angles for the sinogram
number_of_slices = 2 # Number of slices in the stack
# Generate a derenzo phantom image with noise
noisy_image = derenzo_phantom_test(noise_factor=0.3)
angles = np.linspace(0, 180, number_of_angles, endpoint=True)
sinogram = direct_radon(noisy_image, angles)
stack = np.asarray([sinogram for _ in range(number_of_slices)])
# neste reconstrutor os angulos tem que ser invertidos linspace(180,0)
# Para este cara deve ser Slice/Angle/bins
angles_sm = np.linspace(180,0 , number_of_angles, endpoint=False)
stk = np.transpose(stack, (0, 2, 1))
iterations = 3
subsets = 8
reconstructor = reconstructor_system_matrix_cpu(stk)
recon_osem_sm = reconstructor.osem(iterations,subsets, angles_sm, show_images=False)
recon_mlem_sm = reconstructor.mlem(iterations*subsets, angles_sm)
cmap = 'jet'
plt.figure(figsize=(12, 8))
plt.subplot(1, 3, 1)
plt.imshow(noisy_image, cmap=cmap)
plt.title('Original Derenzo Phantom with Noise')
plt.axis('off')
plt.subplot(1, 3, 2)
plt.imshow(recon_osem_sm[0], cmap=cmap)
plt.title('System Matrix OSEM Reconstruction')
plt.axis('off')
plt.subplot(1, 3, 3)
plt.imshow(recon_mlem_sm[0], cmap=cmap)
plt.title('System Matrix MLEM Reconstruction')
plt.axis('off')
plt.tight_layout()
# Save the reconstructed images
path = "./output/"
Path(path).mkdir(parents=True, exist_ok=True)
plt.savefig(path + "system_matrix_reconstructor_test.png", bbox_inches='tight', pad_inches=0.1)
print(f"✅ System matrix reconstructor test completed successfully. Images saved to {path}system_matrix_reconstructor_test.png")
```
## API Reference
### `ImaGIMN.IO.MIIO`
| Classe/Método | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `MIIO` | Classe para I/O de imagens DICOM. | - | `MIIO object` |
| `renormalize` | Normaliza a imagem para um tipo de dado. | `image` (ndarray), `dtype` (type) | `tuple` (ndarray, dict) |
| `save_dicom` | Salva um array como arquivo DICOM. | `image` (ndarray), `nome_arquivo` (str), `origin` (tuple), `spacing` (tuple), `save_json` (bool) | - |
### `ImaGIMN.phantoms.derenzzo.DerenzoPhantomSlice`
| Método/Propriedade | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `__init__` | Inicializa o phantom. | `radius`, `num_sections`, `well_counts`, `well_diameters`, `well_separations`, `section_offsets`, etc. | - |
| `save_image` | Salva o phantom como imagem. | `filename` (str) | - |
| `get_image_matrix` | Retorna a matriz de pixels do phantom. | - | `numpy.ndarray` |
### `ImaGIMN.processing.interpolators.reconstruction`
| Função | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `beta_spline_interpolation` | Interpolação Spline Beta. | `p00`, `p01`, `p10`, `p11` (float), `dx` (float), `dy` (float) | `float` |
| `bilinear_interpolation` | Interpolação Bilinear. | `p00`, `p01`, `p10`, `p11` (float), `dx` (float), `dy` (float) | `float` |
| `nearest_neighbor_interpolation` | Interpolação do Vizinho Mais Próximo. | `p00`, `p01`, `p10`, `p11` (float), `dx` (float), `dy` (float) | `float` |
### `ImaGIMN.processing.tools.kernels`
| Função | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `generate_gaussian_kernel_in_mm`| Gera um kernel Gaussiano. | `size` (int), `sigma_mm` (float), `pixel_size_mm` (float) | `ndarray` |
| `butterworth_kernel` | Gera um kernel Butterworth. | `size` (int), `order` (int), `cutoff` (float), `pixel_size_mm` (float) | `ndarray` |
| `butterworth_kernel_high_pass`| Gera um kernel Butterworth passa-alta. | `size` (int), `order` (int), `cutoff` (float), `pixel_size_mm` (float) | `ndarray` |
| `butterworth_kernel_low_pass` | Gera um kernel Butterworth passa-baixa.| `size` (int), `order` (int), `cutoff` (float), `pixel_size_mm` (float) | `ndarray` |
### `ImaGIMN.processing.tools.math`
| Função | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `deconvolution` | Deconvolução no domínio da frequência. | `image` (ndarray), `function` (ndarray) | `ndarray` |
| `convolution` | Convolução no domínio da frequência. | `image` (ndarray), `kernel` (ndarray) | `ndarray` |
| `rotate` | Rotaciona uma imagem. | `image` (ndarray), `angle` (float), `interpolation_func` (function), `center` (tuple) | `ndarray` |
### `ImaGIMN.processing.tools.utils`
| Função | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `resize` | Redimensiona uma imagem. | `input_img` (ndarray), `mx` (int), `my` (int), `interpolation` (str) | `ndarray` |
### `ImaGIMN.processing.ploter.ploter`
| Função | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `plot_slices` | Plota slices de um volume 3D. | `sinogram` (ndarray), `n_slices` (int), `x_extent` (tuple), `y_extent` (tuple), `rows` (int), `cols` (int), etc. | - |
### `ImaGIMN.gimnRec.reconstructors.rotation_reconstruction.rotation_reconstructor`
| Método | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `mlem` | Reconstrução MLEM baseada em rotação. | `iterations` (int), `interpolation` (function), `angles` (ndarray), `verbose` (bool) | `ndarray` |
| `osem` | Reconstrução OSEM baseada em rotação. | `iterations` (int), `subsets_n` (int), `interpolation` (function), `angles` (ndarray), `verbose` (bool) | `ndarray` |
### `ImaGIMN.gimnRec.reconstructors.system_matrix_reconstruction2.reconstructor_system_matrix_cpu`
*Nota: Esta classe herda de `line_integral_reconstructor`, então possui os mesmos métodos base.*
| Método | Descrição | Parâmetros | Retorno |
| --- | --- | --- | --- |
| `mlem_tv` | MLEM com regularização Total Variation. | `iterations` (int), `beta` (float), `angles` (ndarray), `verbose` (bool) | `ndarray` |
## 🤝 Contribuindo
Contribuições são bem-vindas! Para contribuir:
1. **Fork** o projeto
2. **Clone** seu fork: `git clone https://github.com/seu-usuario/GimnTools.git`
3. **Crie uma branch**: `git checkout -b feature/nova-funcionalidade`
4. **Instale para desenvolvimento**: `make install-dev`
5. **Faça suas alterações** e adicione testes
6. **Execute testes**: `make test`
7. **Formate o código**: `make format`
8. **Commit**: `git commit -m "Adiciona nova funcionalidade"`
9. **Push**: `git push origin feature/nova-funcionalidade`
10. **Abra um Pull Request**
### Diretrizes de Contribuição
- Siga os padrões de código (black, flake8)
- Adicione testes para novas funcionalidades
- Atualize a documentação quando necessário
- Use mensagens de commit descritivas
## 📄 Licença
Este projeto está licenciado sob a licença Apache 2.0. Veja o arquivo [LICENSE](LICENSE) para detalhes.
## 🆘 Suporte
- **Issues**: [GitHub Issues](https://github.com/usuario/GimnTools/issues)
- **Discussões**: [GitHub Discussions](https://github.com/usuario/GimnTools/discussions)
- **Email**: contato@gimntools.com
**GimnTools** - Ferramentas avançadas para imagens médicas em Python.
Raw data
{
"_id": null,
"home_page": "https://github.com/michelraed/GimnTools.git",
"name": "GimnTools",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "medical imaging, tomography, reconstruction, sinogram, DICOM, image processing, PET, SPECT",
"author": "Desenvolvedor GimnTools",
"author_email": "michelraed@gmail.com",
"download_url": "https://files.pythonhosted.org/packages/a9/d9/b71f04a379f1f527083d3c7509fcc18b4798b7ac8ff09f56c2277323dae9/gimntools-1.0.0.0.tar.gz",
"platform": "any",
"description": "# GimnTools\n\n[](https://python.org)\n[](LICENSE)\n[](https://gimntools.readthedocs.io/)\n[](https://pypi.org/project/gimntools/)\n\n## Introdu\u00e7\u00e3o e Vis\u00e3o Geral\n\nA GimnTools \u00e9 uma biblioteca Python de c\u00f3digo aberto projetada para o processamento de imagens m\u00e9dicas e reconstru\u00e7\u00e3o tomogr\u00e1fica. Ela oferece um conjunto de ferramentas robustas para manipula\u00e7\u00e3o de imagens, gera\u00e7\u00e3o de sinogramas, aplica\u00e7\u00e3o de filtros e implementa\u00e7\u00e3o de algoritmos de reconstru\u00e7\u00e3o. O objetivo desta documenta\u00e7\u00e3o \u00e9 fornecer um guia completo e exaustivo para desenvolvedores e pesquisadores que desejam utilizar a GimnTools em seus projetos.\n\n## \u2728 Principais Funcionalidades\n\n### \ud83d\udd2c Reconstru\u00e7\u00e3o Tomogr\u00e1fica\n- **Algoritmos de Reconstru\u00e7\u00e3o**: MLEM, OSEM, FBP (Filtered Back-Projection)\n- **Reconstru\u00e7\u00e3o por Integrais de Linha**: Implementa\u00e7\u00e3o otimizada com Numba\n- **Matriz de Sistema**: Suporte para reconstru\u00e7\u00e3o baseada em matriz de sistema\n- **Corre\u00e7\u00f5es**: Atenua\u00e7\u00e3o, dispers\u00e3o e normaliza\u00e7\u00e3o\n\n### \ud83d\udcca Processamento de Sinogramas\n- **Gera\u00e7\u00e3o de Sinogramas**: Suporte para cristais monol\u00edticos e segmentados\n- **Convers\u00e3o de Coordenadas**: Transforma\u00e7\u00e3o entre espa\u00e7os de cristais e pixels\n- **Configura\u00e7\u00e3o de Sistema**: Gerenciamento flex\u00edvel de geometrias de detectores\n\n### \ud83d\uddbc\ufe0f Processamento de Imagens\n- **Filtros Espaciais**: Convolu\u00e7\u00e3o, filtros de vizinhan\u00e7a otimizados\n- **Filtros de Frequ\u00eancia**: Transformada de Fourier e filtragem espectral\n- **Filtros Morfol\u00f3gicos**: Opera\u00e7\u00f5es de abertura, fechamento, eros\u00e3o e dilata\u00e7\u00e3o\n- **Interpola\u00e7\u00e3o**: M\u00e9todos de reconstru\u00e7\u00e3o e reamostragem\n\n### \ud83c\udfaf Fantomas e Simula\u00e7\u00e3o\n- **Fantoma de Derenzo**: Gera\u00e7\u00e3o param\u00e9trica de fantomas de teste\n- **Geometrias Customizadas**: Cria\u00e7\u00e3o de formas geom\u00e9tricas diversas\n- **Fantomas Aleat\u00f3rios**: Gera\u00e7\u00e3o procedural para testes variados\n\n### \ud83d\udcc1 I/O de Imagens M\u00e9dicas\n- **DICOM**: Leitura e escrita usando SimpleITK e ITK\n- **Normaliza\u00e7\u00e3o**: Convers\u00e3o entre tipos de dados e escalas\n- **Metadados**: Preserva\u00e7\u00e3o de informa\u00e7\u00f5es de espa\u00e7amento, origem e orienta\u00e7\u00e3o\n\n## \ud83d\ude80 Instala\u00e7\u00e3o R\u00e1pida\n\n### Requisitos\n- Python 3.8 ou superior\n- Sistema operacional: Windows, macOS ou Linux\n\n### Instala\u00e7\u00e3o via pip\n```bash\npip install GimnTools\n```\n\n### Instala\u00e7\u00e3o para Desenvolvimento\n```bash\ngit clone https://github.com/usuario/GimnTools.git\ncd GimnTools\npip install -e \".[dev]\"\n```\n\n### Usando Scripts de Instala\u00e7\u00e3o\n```bash\n# Clone o reposit\u00f3rio\ngit clone https://github.com/usuario/GimnTools.git\ncd GimnTools\n\n# Execute o script de instala\u00e7\u00e3o\npython scripts/install.py --mode development --jupyter\n\n# Ou use o Makefile (Linux/macOS)\nmake install-dev\n```\n\n## \ud83d\udee0\ufe0f Scripts de Build e Deploy\n\nA biblioteca inclui scripts automatizados para facilitar o desenvolvimento:\n\n### Scripts Dispon\u00edveis\n\n\n#### Script de Instala\u00e7\u00e3o (`scripts/install.py`)\n```bash\n# Instala\u00e7\u00e3o b\u00e1sica\npython scripts/install.py\n\n# Instala\u00e7\u00e3o para desenvolvimento\npython scripts/install.py --mode development --jupyter --docs\n\n# Criar ambiente virtual\npython scripts/install.py --venv\n```\n\n\n### Usando Makefile (Linux/macOS)\n\n```bash\n# Instalar para usuario\t\nmake install\n\n# Instalar para desenvolvimento\nmake install-dev\n\n# Executar testes\nmake test\n\n# Build completo\nmake build\n\n# Deploy para PyPI de teste\nmake upload\n\n# Limpar arquivos tempor\u00e1rios\nmake clean\n```\n\n## \ud83d\udcc1 Estrutura do Projeto\n\n```\nGimnTools/\n\u251c\u2500\u2500 GimnTools/ # Pacote principal\n\u2502 \u251c\u2500\u2500 __init__.py\n\u2502 \u2514\u2500\u2500 ImaGIMN/ # M\u00f3dulo principal\n\u2502 \u251c\u2500\u2500 image.py # Classe base para imagens\n\u2502 \u251c\u2500\u2500 IO/ # Entrada e sa\u00edda\n\u2502 \u2502 \u251c\u2500\u2500 MIIO.py # I/O de imagens m\u00e9dicas\n\u2502 \u2502 \u2514\u2500\u2500 GimnIO.py # I/O geral\n\u2502 \u251c\u2500\u2500 sinogramer/ # Gera\u00e7\u00e3o de sinogramas\n\u2502 \u2502 \u251c\u2500\u2500 sinogramer.py\n\u2502 \u2502 \u251c\u2500\u2500 conf.py\n\u2502 \u2502 \u2514\u2500\u2500 systemSpace.py\n\u2502 \u251c\u2500\u2500 gimnRec/ # Reconstru\u00e7\u00e3o\n\u2502 \u2502 \u251c\u2500\u2500 reconstructors/\n\u2502 \u2502 \u251c\u2500\u2500 backprojectors.py\n\u2502 \u2502 \u251c\u2500\u2500 projectors.py\n\u2502 \u2502 \u2514\u2500\u2500 corrections.py\n\u2502 \u251c\u2500\u2500 processing/ # Processamento\n\u2502 \u2502 \u251c\u2500\u2500 filters/ # Filtros\n\u2502 \u2502 \u251c\u2500\u2500 interpolators/\n\u2502 \u2502 \u251c\u2500\u2500 tools/ # Ferramentas matem\u00e1ticas\n\u2502 \u2502 \u2514\u2500\u2500 ploter/ # Visualiza\u00e7\u00e3o\n\u2502 \u2514\u2500\u2500 phantoms/ # Fantomas\n\u2502 \u251c\u2500\u2500 derenzzo.py\n\u2502 \u251c\u2500\u2500 random.py\n\u2502 \u2514\u2500\u2500 geometries/\n\u251c\u2500\u2500 scripts/ # Scripts de automa\u00e7\u00e3o\n\u2502 \u251c\u2500\u2500 build.py # Script de build\n\u2502 \u251c\u2500\u2500 install.py # Script de instala\u00e7\u00e3o\n\u2502 \u2514\u2500\u2500 deploy.py # Script de deploy\n\u251c\u2500\u2500 docs/ # Documenta\u00e7\u00e3o\n\u251c\u2500\u2500 tests/ # Testes\n\u251c\u2500\u2500 examples/ # Exemplos\n\u251c\u2500\u2500 setup.py # Configura\u00e7\u00e3o setuptools\n\u251c\u2500\u2500 pyproject.toml # Configura\u00e7\u00e3o moderna\n\u251c\u2500\u2500 requirements.txt # Depend\u00eancias\n\u251c\u2500\u2500 requirements-dev.txt # Depend\u00eancias dev\n\u251c\u2500\u2500 Makefile # Automa\u00e7\u00e3o (Unix)\n\u2514\u2500\u2500 README.md # Este arquivo\n```\n\n## \ud83d\udd27 Depend\u00eancias\n\n### Principais\n- **numpy** (\u22651.20.0): Computa\u00e7\u00e3o num\u00e9rica\n- **scipy** (\u22651.7.0): Algoritmos cient\u00edficos\n- **matplotlib** (\u22653.3.0): Visualiza\u00e7\u00e3o\n- **numba** (\u22650.54.0): Compila\u00e7\u00e3o JIT para performance\n- **SimpleITK** (\u22652.1.0): Processamento de imagens m\u00e9dicas\n- **itk** (\u22655.2.0): Toolkit de imagens\n- **Pillow** (\u22658.0.0): Manipula\u00e7\u00e3o de imagens\n- **scikit-image** (\u22650.18.0): Processamento de imagens\n- **h5py** (\u22653.1.0): Armazenamento HDF5\n- **tqdm** (\u22654.60.0): Barras de progresso\n\n### Depend\u00eancias de Desenvolvimento\n- **pytest**: Framework de testes\n- **sphinx**: Gera\u00e7\u00e3o de documenta\u00e7\u00e3o\n- **black**: Formata\u00e7\u00e3o de c\u00f3digo\n- **flake8**: Linting\n- **mypy**: Verifica\u00e7\u00e3o de tipos\n\n## \ud83d\udcda Documenta\u00e7\u00e3o\n\nA documenta\u00e7\u00e3o completa est\u00e1 dispon\u00edvel em:\n- **Online**: [https://gimntools.readthedocs.io/](https://gimntools.readthedocs.io/)\n- **Local**: Execute `make docs` para gerar localmente\n\n### T\u00f3picos da Documenta\u00e7\u00e3o\n- **Guia do Usu\u00e1rio**: Introdu\u00e7\u00e3o e conceitos b\u00e1sicos\n- **API Reference**: Documenta\u00e7\u00e3o detalhada de todas as fun\u00e7\u00f5es\n- **Tutoriais**: Exemplos passo a passo\n- **Guia do Desenvolvedor**: Como contribuir para o projeto\n\n\n\n## Documenta\u00e7\u00e3o Detalhada dos M\u00f3dulos\n\n### 1. `ImaGIMN.IO`\n\nRespons\u00e1vel pelas opera\u00e7\u00f5es de entrada e sa\u00edda.\n\n* **`MIIO.py`**: Classe de alto n\u00edvel para manipula\u00e7\u00e3o de I/O de imagens m\u00e9dicas, especialmente DICOM. Usa `SimpleITK` e `ITK` como backend. Fornece funcionalidades essenciais como leitura, escrita e normaliza\u00e7\u00e3o de imagens.\n* **`GimnIO.py`**: Utilit\u00e1rios de I/O de baixo n\u00edvel, como cria\u00e7\u00e3o de pastas e salvamento de arquivos JSON.\n\n### 2. `ImaGIMN.gimnRec`\n\nCont\u00e9m os algoritmos e componentes para a reconstru\u00e7\u00e3o tomogr\u00e1fica.\n\n* **`reconstruction_filters.py`**: Implementa filtros usados na reconstru\u00e7\u00e3o FBP (Filtered Back-Projection), como Ram-Lak, Shepp-Logan, etc.\n* **`projectors.py`**: Cont\u00e9m fun\u00e7\u00f5es para a proje\u00e7\u00e3o (forward projection), que simula a aquisi\u00e7\u00e3o de dados (cria um sinograma a partir de uma imagem).\n* **`backprojectors.py`**: Cont\u00e9m fun\u00e7\u00f5es para a retroproje\u00e7\u00e3o (back-projection), o processo inverso da proje\u00e7\u00e3o, usado em algoritmos como FBP e iterativos.\n* **`corrections.py`**: Fun\u00e7\u00f5es para aplicar corre\u00e7\u00f5es necess\u00e1rias durante a reconstru\u00e7\u00e3o, como a corre\u00e7\u00e3o do centro de rota\u00e7\u00e3o.\n\n#### 2.1. `ImaGIMN.gimnRec.reconstructors`\n\nImplementa\u00e7\u00f5es concretas de algoritmos de reconstru\u00e7\u00e3o.\n\n* **`line_integral_reconstructor.py`**: Reconstrutor principal que implementa algoritmos baseados em integral de linha, como FBP, MLEM e OSEM. \u00c9 uma classe vers\u00e1til e de uso geral.\n* **`rotation_reconstruction.py`**: Implementa\u00e7\u00e3o que realiza a reconstru\u00e7\u00e3o baseada em rota\u00e7\u00f5es sucessivas da imagem. Serve como uma classe base ou alternativa para os reconstrutores.\n* **`system_matrix_reconstruction.py`**: Reconstrutor que utiliza uma matriz de sistema pr\u00e9-calculada para realizar as proje\u00e7\u00f5es e retroproje\u00e7\u00f5es. Pode ser mais lento para gerar a matriz, mas mais r\u00e1pido para iterar. Vers\u00e3o para CPU.\n* **`system_matrix_reconstruction2.py`**: Uma segunda implementa\u00e7\u00e3o (possivelmente experimental ou com otimiza\u00e7\u00f5es diferentes) do reconstrutor baseado em matriz de sistema.\n\n### 3. `ImaGIMN.processing`\n\nFerramentas para processamento e an\u00e1lise de imagens.\n\n#### 3.1. `ImaGIMN.processing.filters`\n\n* **`spatial_filters.py`**: Cont\u00e9m filtros que operam diretamente na matriz de pixels. Inclui fun\u00e7\u00f5es para convolu\u00e7\u00e3o 2D, aplica\u00e7\u00e3o de filtros separ\u00e1veis e extra\u00e7\u00e3o de vizinhan\u00e7as de pixels.\n* **`frequency_filters.py`**: Implementa filtros no dom\u00ednio da frequ\u00eancia, como o filtro Gaussiano e o Butterworth. \u00datil para suaviza\u00e7\u00e3o e realce de bordas.\n* **`morphological_filters.py`**: Fun\u00e7\u00f5es para morfologia matem\u00e1tica (Eros\u00e3o, Dilata\u00e7\u00e3o, Abertura e Fechamento), usadas para an\u00e1lise de formas e estruturas na imagem.\n\n#### 3.2. `ImaGIMN.processing.interpolators`\n\n* **`reconstruction.py`**: Fornece diferentes m\u00e9todos de interpola\u00e7\u00e3o (Vizinho Mais Pr\u00f3ximo, Bilinear, Spline Beta) que s\u00e3o cruciais para algoritmos de rota\u00e7\u00e3o e reconstru\u00e7\u00e3o, garantindo a precis\u00e3o ao acessar valores de pixels em coordenadas n\u00e3o inteiras.\n\n#### 3.3. `ImaGIMN.processing.tools`\n\n* **`kernels.py`**: Fun\u00e7\u00f5es para gerar kernels (matrizes) usados em filtros de convolu\u00e7\u00e3o, como kernels Gaussianos e Butterworth de diferentes tipos (passa-baixa, passa-alta).\n* **`math.py`**: Fun\u00e7\u00f5es matem\u00e1ticas essenciais, como convolu\u00e7\u00e3o e deconvolu\u00e7\u00e3o no dom\u00ednio da frequ\u00eancia (via FFT) e rota\u00e7\u00e3o de imagem com diferentes interpoladores.\n* **`utils.py`**: Utilit\u00e1rios diversos, com destaque para a fun\u00e7\u00e3o de redimensionamento de imagem (`resize`) que suporta m\u00faltiplos m\u00e9todos de interpola\u00e7\u00e3o.\n\n#### 3.4. `ImaGIMN.processing.ploter`\n\n* **`ploter.py`**: Ferramenta de visualiza\u00e7\u00e3o para plotar m\u00faltiplos slices de um volume 3D (como um sinograma ou uma imagem reconstru\u00edda) em uma grade, facilitando a inspe\u00e7\u00e3o visual.\n\n### 4. `ImaGIMN.phantoms`\n\n* **`derenzzo.py`**: Cont\u00e9m classes para a gera\u00e7\u00e3o de phantoms de Derenzo, que s\u00e3o padr\u00f5es de teste padr\u00e3o em imagem m\u00e9dica para avaliar a resolu\u00e7\u00e3o espacial de um sistema.\n\n\n## Exemplos de Uso Pr\u00e1ticos\n\n### Exemplo 1: Cria\u00e7\u00e3o de imagens Aleat\u00f3rias\n\n```python\n \nfrom GimnTools.ImaGIMN.phantoms.random import generate_random_image\n\n\"\"\"Generates a random image for testing purposes.\"\"\"\nimport matplotlib.pyplot as plt\npixels = 128 # size off the image\nnumber_of_figures = 10 # number of figures in the image\n\n# Generate a random image with specified number of figures using generate_random_image function\n# This function creates an image with random geometric figures like stars, ellipses, and polygons.\n# The figures are randomly placed and sized within the image.\nimg = generate_random_image(pixels, number_of_figures)\npath = \"./output/\"\n\n# Ensure the output directory exists\n# If it doesn't exist, create it\nPath(path).mkdir(parents=True, exist_ok=True)\n\n# Save the generated image to a file\n# The image is saved in PNG format with a specific filename\nfilename = path + \"random_image_test.png\"\n\n# Display the image using matplotlib\nplt.figure(figsize=(6, 6))\nplt.clf()\nplt.axis('off')\nplt.imshow(img, cmap='jet')\nplt.title(\"Random Image Test\")\nplt.savefig(filename, bbox_inches='tight', pad_inches=0.1)\nplt.show()\nprint(f\"Random image saved to {filename}\")\n\n\n```\n\n### Exemplo 2: Teste Shepp-Logan Phantom\n\n```python\nfrom skimage.data import shepp_logan_phantom\n\n# Generate the Shepp-Logan phantom\nimg = shepp_logan_phantom()\n\n# Resize the image to 128x128 pixels\nimg = resize(img, (128, 128), anti_aliasing=True)\n\nnoiser = noise_level\nresized_image = img * noiser\nnoisy_image = np.random.poisson(resized_image).astype(np.float64)\n\n# Save the image to a file\npath = \"./output/\"\nPath(path).mkdir(parents=True, exist_ok=True)\nfilename = path + \"shepp_logan_phantom_test.png\"\n\nplt.figure(figsize=(6, 6))\nplt.clf()\nplt.axis('off')\nplt.imshow(noisy_image, cmap='jet')\nplt.title(\"Shepp-Logan Phantom\")\nplt.savefig(filename, bbox_inches='tight', pad_inches=0.1)\nplt.show()\nprint(f\"Shepp-Logan phantom saved to {filename}\")\n\n```\n\n### Exemplo 3: Gerar Fantoma de Derenzo\n\n```python\n\nfrom GimnTools.ImaGIMN.phantoms.derenzzo import DerenzoPhantomSlice\n\n\"\"\"\nGenerates a Derenzo phantom image, resizes it, and saves it as a PNG file.\n\"\"\"\nimport matplotlib.pyplot as plt\n\n# Teste do c\u00f3digo adaptado\nradius = 29.0 / 2\nnum_sections = 4\nwell_counts = (6, 6, 10, 15)\nwell_diameters = (2.5, 2.0, 1.5, 1.0)\nwell_separations = (2.5, 2.0, 1.5, 1.0)\nsection_offsets = (0.00000001, 0.01, 0.01, 0.1) # Offset personalizado para cada se\u00e7\u00e3o\ncircle_value = 1\nwell_value = 10\nimage_size = 128\nmy_phantom = DerenzoPhantomSlice(radius, num_sections, well_counts, well_diameters, well_separations, section_offsets,\n image_size=image_size, circle_value=circle_value, well_value=well_value)\n\n#my_phantom.save_image('derenzo_phantom_with_offsets.png')\n\n# Obter a matriz da imagem contendo apenas o c\u00edrculo de fundo\ncircle_image_matrix = my_phantom.draw_only_circle()\n# Obter a matriz completa do fantoma\nphantom_matrix = my_phantom.get_image_matrix()\n\nnoisy_image = np.random.poisson(phantom_matrix*noise_factor).astype(np.float64)\n\nplt.imshow (noisy_image, cmap='jet')\nplt.title('Derenzo Phantom with Noise')\nplt.colorbar()\nprint(f\"\u2705 Imagem simulada de um fantoma derenzo de raio {radius}mm e po\u00e7os com diametros {well_diameters} mm com ru\u00eddo foi criada e tem dimens\u00f5es: {noisy_image.shape}\")\n\npath = \"./output/\"\nPath(path).mkdir(parents=True, exist_ok=True)\nplt.savefig(path + \"derenzo_phantom_test.png\", bbox_inches='tight', pad_inches=0.1)\n```\n\n### Exemplo 3: Reconstru\u00e7\u00e3o usando reconstrutor com projetor baseado na rota\u00e7\u00e3o da imagem\n\n```python\n\nfrom GimnTools.ImaGIMN.gimnRec.reconstructors.rotation_reconstruction import rotation_reconstructor\nfrom GimnTools.ImaGIMN.processing.interpolators.reconstruction import beta_spline_interpolation, bilinear_interpolation, nearest_neighbor_interpolation\nfrom GimnTools.ImaGIMN.gimnRec.reconstruction_filters import ramLak\nfrom GimnTools.ImaGIMN.gimnRec.projectors import radon_m, projector, direct_radon\n\n\n\npixels = 128 # Size of the image\nnumber_of_angles = pixels # Number of angles for the sinogram\nnumber_of_slices = 2 # Number of slices in the stack\n\n# Generate a derenzo phantom image with noise\nnoisy_image = derenzo_phantom_test(noise_factor=0.3)\nangles = np.linspace(0, 180, number_of_angles, endpoint=True)\nsinogram = direct_radon(noisy_image, angles)\nstack = np.asarray([sinogram for _ in range(number_of_slices)])\n\n\nreconstructor = rotation_reconstructor()\nreconstructor.set_sinogram(stack)\n#reconstructor.set_sinogram(sino) \n\niterations = 3\nsubsets = 8 #2, 4, 8, 16\n\nangles_here = angles+180\nrecon_osem_rot = reconstructor.osem(iterations,subsets, bilinear_interpolation, angles=angles_here, verbose=False)\nrecon_mlem_rot = reconstructor.mlem(iterations*subsets, bilinear_interpolation, angles=angles_here, verbose=False)\nrecon_fbp_rot= reconstructor.fbp(bilinear_interpolation, ramLak, angles=angles_here)\n\ncmap = 'jet'\n# Display the reconstructed images \nplt.figure(figsize=(12, 8))\nplt.subplot(1, 3, 1)\nplt.imshow(recon_osem_rot[0], cmap=cmap)\nplt.title('OSEM Reconstruction (Rotation)')\nplt.axis('off')\nplt.subplot(1, 3, 2)\nplt.imshow(recon_mlem_rot[0], cmap=cmap)\nplt.title('MLEM Reconstruction (Rotation)')\nplt.axis('off')\nplt.subplot(1, 3, 3)\nplt.imshow(recon_fbp_rot[0], cmap=cmap)\nplt.title('FBP Reconstruction (Rotation)')\nplt.axis('off') \nplt.tight_layout()\n# Save the reconstructed images\npath = \"./output/\"\nPath(path).mkdir(parents=True, exist_ok=True)\nplt.savefig(path + \"rotation_reconstructor_test.png\", bbox_inches='tight', pad_inches=0.1)\nprint(f\"\u2705 Rotation reconstructor test completed successfully. Images saved to {path}rotation_reconstructor_test.png\")\n \n\n```\n\n### Exemplo 3: Reconstrutor baseado na integral da linha de proje\u00e7\u00e3o\n\n```python\nfrom GimnTools.ImaGIMN.gimnRec.reconstructors.line_integral_reconstructor import line_integral_reconstructor\nimport matplotlib.pyplot as plt\n\n\npixels = 128 # Size of the image\nnumber_of_angles = pixels # Number of angles for the sinogram\nnumber_of_slices = 2 # Number of slices in the stack\n\n# Generate a derenzo phantom image with noise\nnoisy_image = derenzo_phantom_test(noise_factor=0.3)\nangles = np.linspace(0, 180, number_of_angles, endpoint=True)\nsinogram = direct_radon(noisy_image, angles)\nstack = np.asarray([sinogram for _ in range(number_of_slices)])\n\n\nreconstructor = rotation_reconstructor()\nreconstructor.set_sinogram(stack)\n#reconstructor.set_sinogram(sino) \n\niterations = 3\nsubsets = 8 #2, 4, 8, 16\n\n#==========================================================\n# Reconstruir Line Integral\n#==========================================================\n#para este deve ser slice/bins/angle\nangles_m1 = np.linspace(0, 180, number_of_angles, endpoint=True)\n# angles_sm = np.linspace(180,0 , number_of_angles, endpoint=False)\n\nreconstructor = line_integral_reconstructor(stack)\n# recon_osem_li = reconstructor.osem(iterations,subsets, angles_m1, verbose=False)\n# recon_mlem_li = reconstructor.mlem(iterations*subsets, angles_m1, verbose=False)\n# recon_fbp_li = reconstructor.fbp( ramLak, angles)\n# reconstructor.set_sinogram(stack)\n\niterations = [5]\nsubsets = [32] \npilha = []\n\nfor i in range(stack.shape[0]):\n for iter in iterations:\n for subset in subsets:\n print(f'Processing - iteration: {iter}\\tsubset: {subset}')\n sino = stack[i:i+1, :, :]\n\n reconstructor.set_sinogram(sino)\n # Cria o dicion\u00e1rio com a estrutura especificada\n recon = {}\n recon[\"iterative_method\"] = \"OSEM/MLEM\"\n recon[\"iteration\"] = iter\n recon[\"subset\"] = subset\n recon[\"total_iterations\"] = iter * subset\n recon[\"sinogram\"] = i + 1\n recon [\"image_OSEM\"] = reconstructor.osem(iter, subset, angles_m1, verbose=False)\n recon [\"image_MLEM\"] = reconstructor.mlem(iter * subset, angles_m1) \n recon[\"analytic_method\"] = \"FBP\"\n recon[\"fbp_image\"] = reconstructor.fbp(ramLak, angles)\n pilha.append(deepcopy(recon))\n\nplt.figure(figsize=(12, 8))\nplt.subplot(1, 3, 1)\ncmap = 'jet'\nplt.imshow(pilha[0][\"image_MLEM\"][0], cmap=cmap)\nplt.title('Line Integral MLEM Reconstruction')\nplt.axis('off')\nplt.subplot(1, 3, 2)\nplt.imshow(pilha[0][\"image_OSEM\"][0], cmap=cmap)\nplt.title('Line Integral OSEM Reconstruction')\nplt.axis('off')\nplt.subplot(1, 3, 3)\nplt.imshow(pilha[0][\"fbp_image\"][0], cmap=cmap)\nplt.title('Line Integral FBP Reconstruction')\nplt.axis('off')\nplt.tight_layout()\n# Display the reconstructed image\n# Save the reconstructed images\npath = \"./output/\"\nPath(path).mkdir(parents=True, exist_ok=True)\nplt.savefig(path + \"line_integral_reconstructor_test.png\", bbox_inches='tight',\n pad_inches=0.1) \nprint(f\"\u2705 Line integral reconstructor test completed successfully. Images saved to {path}line_integral_reconstructor_test.png\")\n```\n\n### Exemplo 3: Reconstrutor System Matrix\n\n```python\n\nfrom GimnTools.ImaGIMN.gimnRec.reconstructors.system_matrix_reconstruction import reconstructor_system_matrix_cpu\nimport matplotlib.pyplot as plt\npixels = 128 # Size of the image\nnumber_of_angles = pixels # Number of angles for the sinogram\nnumber_of_slices = 2 # Number of slices in the stack\n\n# Generate a derenzo phantom image with noise\nnoisy_image = derenzo_phantom_test(noise_factor=0.3)\nangles = np.linspace(0, 180, number_of_angles, endpoint=True)\nsinogram = direct_radon(noisy_image, angles)\nstack = np.asarray([sinogram for _ in range(number_of_slices)])\n\n\n# neste reconstrutor os angulos tem que ser invertidos linspace(180,0)\n# Para este cara deve ser Slice/Angle/bins\nangles_sm = np.linspace(180,0 , number_of_angles, endpoint=False)\nstk = np.transpose(stack, (0, 2, 1)) \n\niterations = 3 \nsubsets = 8 \n\nreconstructor = reconstructor_system_matrix_cpu(stk)\nrecon_osem_sm = reconstructor.osem(iterations,subsets, angles_sm, show_images=False)\nrecon_mlem_sm = reconstructor.mlem(iterations*subsets, angles_sm)\n\ncmap = 'jet'\nplt.figure(figsize=(12, 8))\nplt.subplot(1, 3, 1)\nplt.imshow(noisy_image, cmap=cmap)\nplt.title('Original Derenzo Phantom with Noise')\nplt.axis('off')\nplt.subplot(1, 3, 2)\nplt.imshow(recon_osem_sm[0], cmap=cmap)\nplt.title('System Matrix OSEM Reconstruction')\nplt.axis('off')\nplt.subplot(1, 3, 3)\nplt.imshow(recon_mlem_sm[0], cmap=cmap) \nplt.title('System Matrix MLEM Reconstruction')\nplt.axis('off')\nplt.tight_layout()\n# Save the reconstructed images\npath = \"./output/\"\nPath(path).mkdir(parents=True, exist_ok=True)\nplt.savefig(path + \"system_matrix_reconstructor_test.png\", bbox_inches='tight', pad_inches=0.1)\nprint(f\"\u2705 System matrix reconstructor test completed successfully. Images saved to {path}system_matrix_reconstructor_test.png\")\n\n```\n\n\n## API Reference\n\n### `ImaGIMN.IO.MIIO`\n\n| Classe/M\u00e9todo | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `MIIO` | Classe para I/O de imagens DICOM. | - | `MIIO object` |\n| `renormalize` | Normaliza a imagem para um tipo de dado. | `image` (ndarray), `dtype` (type) | `tuple` (ndarray, dict) |\n| `save_dicom` | Salva um array como arquivo DICOM. | `image` (ndarray), `nome_arquivo` (str), `origin` (tuple), `spacing` (tuple), `save_json` (bool) | - |\n\n### `ImaGIMN.phantoms.derenzzo.DerenzoPhantomSlice`\n\n| M\u00e9todo/Propriedade | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `__init__` | Inicializa o phantom. | `radius`, `num_sections`, `well_counts`, `well_diameters`, `well_separations`, `section_offsets`, etc. | - |\n| `save_image` | Salva o phantom como imagem. | `filename` (str) | - |\n| `get_image_matrix` | Retorna a matriz de pixels do phantom. | - | `numpy.ndarray` |\n\n### `ImaGIMN.processing.interpolators.reconstruction`\n\n| Fun\u00e7\u00e3o | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `beta_spline_interpolation` | Interpola\u00e7\u00e3o Spline Beta. | `p00`, `p01`, `p10`, `p11` (float), `dx` (float), `dy` (float) | `float` |\n| `bilinear_interpolation` | Interpola\u00e7\u00e3o Bilinear. | `p00`, `p01`, `p10`, `p11` (float), `dx` (float), `dy` (float) | `float` |\n| `nearest_neighbor_interpolation` | Interpola\u00e7\u00e3o do Vizinho Mais Pr\u00f3ximo. | `p00`, `p01`, `p10`, `p11` (float), `dx` (float), `dy` (float) | `float` |\n\n### `ImaGIMN.processing.tools.kernels`\n\n| Fun\u00e7\u00e3o | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `generate_gaussian_kernel_in_mm`| Gera um kernel Gaussiano. | `size` (int), `sigma_mm` (float), `pixel_size_mm` (float) | `ndarray` |\n| `butterworth_kernel` | Gera um kernel Butterworth. | `size` (int), `order` (int), `cutoff` (float), `pixel_size_mm` (float) | `ndarray` |\n| `butterworth_kernel_high_pass`| Gera um kernel Butterworth passa-alta. | `size` (int), `order` (int), `cutoff` (float), `pixel_size_mm` (float) | `ndarray` |\n| `butterworth_kernel_low_pass` | Gera um kernel Butterworth passa-baixa.| `size` (int), `order` (int), `cutoff` (float), `pixel_size_mm` (float) | `ndarray` |\n\n### `ImaGIMN.processing.tools.math`\n\n| Fun\u00e7\u00e3o | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `deconvolution` | Deconvolu\u00e7\u00e3o no dom\u00ednio da frequ\u00eancia. | `image` (ndarray), `function` (ndarray) | `ndarray` |\n| `convolution` | Convolu\u00e7\u00e3o no dom\u00ednio da frequ\u00eancia. | `image` (ndarray), `kernel` (ndarray) | `ndarray` |\n| `rotate` | Rotaciona uma imagem. | `image` (ndarray), `angle` (float), `interpolation_func` (function), `center` (tuple) | `ndarray` |\n\n### `ImaGIMN.processing.tools.utils`\n\n| Fun\u00e7\u00e3o | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `resize` | Redimensiona uma imagem. | `input_img` (ndarray), `mx` (int), `my` (int), `interpolation` (str) | `ndarray` |\n\n### `ImaGIMN.processing.ploter.ploter`\n\n| Fun\u00e7\u00e3o | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `plot_slices` | Plota slices de um volume 3D. | `sinogram` (ndarray), `n_slices` (int), `x_extent` (tuple), `y_extent` (tuple), `rows` (int), `cols` (int), etc. | - |\n\n### `ImaGIMN.gimnRec.reconstructors.rotation_reconstruction.rotation_reconstructor`\n\n| M\u00e9todo | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `mlem` | Reconstru\u00e7\u00e3o MLEM baseada em rota\u00e7\u00e3o. | `iterations` (int), `interpolation` (function), `angles` (ndarray), `verbose` (bool) | `ndarray` |\n| `osem` | Reconstru\u00e7\u00e3o OSEM baseada em rota\u00e7\u00e3o. | `iterations` (int), `subsets_n` (int), `interpolation` (function), `angles` (ndarray), `verbose` (bool) | `ndarray` |\n\n### `ImaGIMN.gimnRec.reconstructors.system_matrix_reconstruction2.reconstructor_system_matrix_cpu`\n\n*Nota: Esta classe herda de `line_integral_reconstructor`, ent\u00e3o possui os mesmos m\u00e9todos base.*\n\n| M\u00e9todo | Descri\u00e7\u00e3o | Par\u00e2metros | Retorno |\n| --- | --- | --- | --- |\n| `mlem_tv` | MLEM com regulariza\u00e7\u00e3o Total Variation. | `iterations` (int), `beta` (float), `angles` (ndarray), `verbose` (bool) | `ndarray` |\n\n\n## \ud83e\udd1d Contribuindo\n\nContribui\u00e7\u00f5es s\u00e3o bem-vindas! Para contribuir:\n\n1. **Fork** o projeto\n2. **Clone** seu fork: `git clone https://github.com/seu-usuario/GimnTools.git`\n3. **Crie uma branch**: `git checkout -b feature/nova-funcionalidade`\n4. **Instale para desenvolvimento**: `make install-dev`\n5. **Fa\u00e7a suas altera\u00e7\u00f5es** e adicione testes\n6. **Execute testes**: `make test`\n7. **Formate o c\u00f3digo**: `make format`\n8. **Commit**: `git commit -m \"Adiciona nova funcionalidade\"`\n9. **Push**: `git push origin feature/nova-funcionalidade`\n10. **Abra um Pull Request**\n\n### Diretrizes de Contribui\u00e7\u00e3o\n- Siga os padr\u00f5es de c\u00f3digo (black, flake8)\n- Adicione testes para novas funcionalidades\n- Atualize a documenta\u00e7\u00e3o quando necess\u00e1rio\n- Use mensagens de commit descritivas\n\n## \ud83d\udcc4 Licen\u00e7a\n\nEste projeto est\u00e1 licenciado sob a licen\u00e7a Apache 2.0. Veja o arquivo [LICENSE](LICENSE) para detalhes.\n\n## \ud83c\udd98 Suporte\n\n- **Issues**: [GitHub Issues](https://github.com/usuario/GimnTools/issues)\n- **Discuss\u00f5es**: [GitHub Discussions](https://github.com/usuario/GimnTools/discussions)\n- **Email**: contato@gimntools.com\n\n\n\n\n**GimnTools** - Ferramentas avan\u00e7adas para imagens m\u00e9dicas em Python.\n\n\n\n\n",
"bugtrack_url": null,
"license": "Apache-2.0",
"summary": "Biblioteca Python para processamento de imagens m\u00e9dicas e reconstru\u00e7\u00e3o tomogr\u00e1fica",
"version": "1.0.0.0",
"project_urls": {
"Homepage": "https://github.com/michelraed/GimnTools.git",
"Source": "https://github.com/michelraed/GimnTools.git"
},
"split_keywords": [
"medical imaging",
" tomography",
" reconstruction",
" sinogram",
" dicom",
" image processing",
" pet",
" spect"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "2efeba17b0176fd51add42b62ec9daaeb276691ad8622f64872689f3843ed0d4",
"md5": "4f9459e57e4d1a2add33d14c7b131d70",
"sha256": "157088f8a3b2fe8b9b82e93ffe4270f4756d645f860678aee6d8c21dd65aa7c9"
},
"downloads": -1,
"filename": "gimntools-1.0.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "4f9459e57e4d1a2add33d14c7b131d70",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 71947,
"upload_time": "2025-08-16T00:12:25",
"upload_time_iso_8601": "2025-08-16T00:12:25.387371Z",
"url": "https://files.pythonhosted.org/packages/2e/fe/ba17b0176fd51add42b62ec9daaeb276691ad8622f64872689f3843ed0d4/gimntools-1.0.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "a9d9b71f04a379f1f527083d3c7509fcc18b4798b7ac8ff09f56c2277323dae9",
"md5": "8897b568596fff01c2ef907973d3693b",
"sha256": "bcff458dc7ccf699ca6d20039790d67e4bdeab2eb035635be3555b20720bbed3"
},
"downloads": -1,
"filename": "gimntools-1.0.0.0.tar.gz",
"has_sig": false,
"md5_digest": "8897b568596fff01c2ef907973d3693b",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 770777,
"upload_time": "2025-08-16T00:12:27",
"upload_time_iso_8601": "2025-08-16T00:12:27.538943Z",
"url": "https://files.pythonhosted.org/packages/a9/d9/b71f04a379f1f527083d3c7509fcc18b4798b7ac8ff09f56c2277323dae9/gimntools-1.0.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-16 00:12:27",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "michelraed",
"github_project": "GimnTools",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"requirements": [
{
"name": "numpy",
"specs": [
[
">=",
"1.20.0"
]
]
},
{
"name": "scipy",
"specs": [
[
">=",
"1.7.0"
]
]
},
{
"name": "numba",
"specs": [
[
">=",
"0.54.0"
]
]
},
{
"name": "pandas",
"specs": [
[
">=",
"1.3.0"
]
]
},
{
"name": "awkward",
"specs": [
[
">=",
"1.2.0"
]
]
},
{
"name": "uproot",
"specs": [
[
">=",
"5.0.0"
]
]
},
{
"name": "matplotlib",
"specs": [
[
">=",
"3.3.0"
]
]
},
{
"name": "SimpleITK",
"specs": [
[
">=",
"2.1.0"
]
]
},
{
"name": "itk",
"specs": [
[
">=",
"5.2.0"
]
]
},
{
"name": "scikit-image",
"specs": [
[
">=",
"0.18.0"
]
]
},
{
"name": "Pillow",
"specs": [
[
">=",
"8.0.0"
]
]
},
{
"name": "h5py",
"specs": [
[
">=",
"3.1.0"
]
]
},
{
"name": "tqdm",
"specs": [
[
">=",
"4.60.0"
]
]
},
{
"name": "pandas",
"specs": [
[
">=",
"1.3.0"
]
]
},
{
"name": "seaborn",
"specs": [
[
">=",
"0.11.0"
]
]
},
{
"name": "jupyter",
"specs": [
[
">=",
"1.0.0"
]
]
},
{
"name": "ipywidgets",
"specs": [
[
">=",
"7.6.0"
]
]
},
{
"name": "jupyterlab",
"specs": [
[
">=",
"3.0.0"
]
]
},
{
"name": "plotly",
"specs": [
[
">=",
"5.0.0"
]
]
},
{
"name": "seaborn",
"specs": [
[
">=",
"0.11.0"
]
]
}
],
"lcname": "gimntools"
}
JSON
