tessl/pypi-ncempy

A comprehensive collection of algorithms and routines for electron microscopy data analysis and simulation.

—

Pending

Overview

Eval results

Files

Visualization Tools

Name: tessl/pypi-ncempy
Author: tessl

Specialized plotting functions for electron microscopy data with calibrated axes, FFT displays, interactive stack viewing, and scientific visualization tools optimized for microscopy data analysis.

Capabilities

Core Plotting Functions

Main plotting interface and basic visualization functions for microscopy data structures.

def plot(data_dict, **kwargs):
    """
    Easy plotting of data structures from ncempy readers.
    
    Parameters:
    - data_dict: dict, data structure from ncempy.io.read()
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib figure and axes objects
    """

def imsd(image, num_sd=2, **kwargs):
    """
    Display image with standard deviation scaling.
    
    Parameters:
    - image: numpy.ndarray, input image
    - num_sd: float, number of standard deviations for scaling
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib image object
    """

Calibrated Image Display

Functions for displaying images with proper spatial calibration and units.

def im_calibrated(image, pixel_size, pixel_unit='nm', **kwargs):
    """
    Display image with calibrated axes showing physical dimensions.
    
    Parameters:
    - image: numpy.ndarray, input image
    - pixel_size: list or float, pixel size for each dimension
    - pixel_unit: str or list, units for pixel size
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib image object with calibrated axes
    """

FFT and Frequency Domain Visualization

Specialized functions for displaying Fourier transforms as diffraction patterns.

def imfft(image, **kwargs):
    """
    Display 2D FFT as diffractogram with proper scaling.
    
    Parameters:
    - image: numpy.ndarray, input image
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib image object showing FFT magnitude
    """

def imrfft(image, **kwargs):
    """
    Display 2D real FFT as diffractogram.
    
    Parameters:
    - image: numpy.ndarray, input image
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib image object showing real FFT
    """

def im_and_fft(image, **kwargs):
    """
    Show image and its FFT side by side.
    
    Parameters:
    - image: numpy.ndarray, input image
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib figure with two subplots
    """

Interactive Stack Viewing

Class for interactive visualization of image stacks with slider controls.

class stack_view:
    """
    Interactive stack viewing with slider control.
    
    Attributes:
    - stack: numpy.ndarray, 3D image stack (frames, y, x)
    - fig: matplotlib.figure.Figure, figure object
    - ax: matplotlib.axes.Axes, axes object
    - slider: matplotlib.widgets.Slider, frame slider
    """
    
    def __init__(self, stack, **kwargs):
        """
        Initialize interactive stack viewer.
        
        Parameters:
        - stack: numpy.ndarray, 3D image stack
        - **kwargs: additional matplotlib arguments
        """
    
    def update_frame(self, frame_number):
        """
        Update displayed frame.
        
        Parameters:
        - frame_number: int, frame index to display
        """
    
    def show(self):
        """Display the interactive viewer."""

Peak and Point Visualization

Functions for overlaying detected features on microscopy images.

def plot_points(image, points, point_size=50, point_color='red', **kwargs):
    """
    Plot detected points overlaid on image.
    
    Parameters:
    - image: numpy.ndarray, background image
    - points: numpy.ndarray, point coordinates (N, 2)
    - point_size: float, marker size
    - point_color: str, marker color
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib figure with points overlaid
    """

Polar and Ring Analysis Visualization

Specialized plotting functions for diffraction ring analysis and polar coordinate data.

def plot_ringpolar(image, center, points, **kwargs):
    """
    Plot points in polar coordinates relative to center.
    
    Parameters:
    - image: numpy.ndarray, background image
    - center: tuple, center coordinates (y, x)
    - points: numpy.ndarray, point coordinates
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib figure with polar coordinate overlay
    """

def plot_distpolar(image, distortion_params, calibration_points, **kwargs):
    """
    Plot distortion fitting results in polar coordinates.
    
    Parameters:
    - image: numpy.ndarray, background image
    - distortion_params: dict, fitted distortion parameters
    - calibration_points: numpy.ndarray, calibration points
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib figure showing distortion correction
    """

Radial Profile Visualization

Functions for displaying radial intensity profiles and fitting results.

def plot_radialprofile(radii, intensities, fit_result=None, **kwargs):
    """
    Plot radial intensity profile.
    
    Parameters:
    - radii: numpy.ndarray, radial coordinates
    - intensities: numpy.ndarray, intensity values
    - fit_result: dict, optional fitting results to overlay
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib figure with radial profile
    """

def plot_fit(x_data, y_data, fit_function, fit_params, **kwargs):
    """
    Plot experimental data with fitted function overlay.
    
    Parameters:
    - x_data: numpy.ndarray, x coordinates
    - y_data: numpy.ndarray, y values
    - fit_function: callable, fitted function
    - fit_params: dict, fitted parameters
    - **kwargs: additional matplotlib arguments
    
    Returns:
    matplotlib figure with data and fit
    """

Usage Examples

Basic Data Visualization

import ncempy
import ncempy.viz as viz
import matplotlib.pyplot as plt

# Read and plot microscopy data
data = ncempy.read('image.dm4')
viz.plot(data)
plt.title('Electron Microscopy Image')
plt.show()

# Display with calibrated axes
viz.im_calibrated(data['data'], data['pixelSize'], data['pixelUnit'])
plt.title('Calibrated Image')
plt.show()

FFT Visualization

import ncempy.viz as viz
import matplotlib.pyplot as plt

# Show image and its FFT
viz.im_and_fft(image_data)
plt.show()

# Display just the diffractogram
viz.imfft(image_data, cmap='hot')
plt.title('Diffraction Pattern')
plt.show()

Interactive Stack Viewing

import ncempy.viz as viz

# Load image stack (3D array)
stack_data = load_image_stack()  # shape: (frames, height, width)

# Create interactive viewer
viewer = viz.stack_view(stack_data)
viewer.show()

Peak Overlay Visualization

import ncempy.algo as algo
import ncempy.viz as viz
import matplotlib.pyplot as plt

# Detect peaks
peaks = algo.peakFind2D(diffraction_image)

# Plot peaks on image
viz.plot_points(diffraction_image, peaks, 
                point_size=100, point_color='yellow')
plt.title('Detected Diffraction Peaks')
plt.show()

Radial Profile Analysis

import ncempy.algo as algo
import ncempy.viz as viz
import matplotlib.pyplot as plt

# Calculate radial profile
center = (256, 256)  # image center
radii, intensities = algo.calc_radialprofile(image, center)

# Fit and plot
fit_result = algo.fit_radialprofile(radii, intensities, model_function)
viz.plot_radialprofile(radii, intensities, fit_result)
plt.title('Radial Intensity Profile')
plt.show()

Advanced Visualization with Multiple Features

import ncempy.viz as viz
import matplotlib.pyplot as plt

# Create figure with multiple subplots
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# Original image
axes[0,0].imshow(image_data)
axes[0,0].set_title('Original Image')

# FFT
viz.imfft(image_data, ax=axes[0,1])
axes[0,1].set_title('FFT')

# With detected peaks
viz.plot_points(image_data, detected_peaks, ax=axes[1,0])
axes[1,0].set_title('Detected Peaks')

# Radial profile
viz.plot_radialprofile(radii, intensities, ax=axes[1,1])
axes[1,1].set_title('Radial Profile')

plt.tight_layout()
plt.show()

Customization Options

import ncempy.viz as viz
import matplotlib.pyplot as plt

# Custom colormap and scaling
viz.imsd(image_data, num_sd=3, cmap='viridis', 
         interpolation='bilinear')

# Custom point visualization
viz.plot_points(image_data, peaks, 
                point_size=75, point_color='cyan',
                alpha=0.8, marker='x')

# Custom calibrated display
viz.im_calibrated(image_data, pixel_size=[0.1, 0.1], 
                  pixel_unit='nm', cmap='gray',
                  origin='lower')
plt.xlabel('X Position (nm)')
plt.ylabel('Y Position (nm)')
plt.show()

Install with Tessl CLI