Data Evaluation

def line_profile(image, start, end, linewidth=1, order=1):
    """
    Extract line profile from image along specified path.
    
    Parameters:
    - image: numpy.ndarray, input 2D image
    - start: tuple, starting coordinates (y, x)
    - end: tuple, ending coordinates (y, x)  
    - linewidth: int, width of profile extraction region
    - order: int, interpolation order
    
    Returns:
    dict: Dictionary containing:
        - 'profile': numpy.ndarray, intensity values along line
        - 'coordinates': numpy.ndarray, coordinate positions
        - 'distance': numpy.ndarray, distance along line
    """

def _gen_line(start, end, num_points=None):
    """
    Generate line coordinates between two points.
    
    Parameters:
    - start: tuple, starting coordinates (y, x)
    - end: tuple, ending coordinates (y, x)
    - num_points: int, number of points along line
    
    Returns:
    numpy.ndarray: Coordinate arrays for line points
    """

def get_settings():
    """
    Get current ring diffraction analysis settings.
    
    Returns:
    dict: Current analysis settings including:
        - center: tuple, diffraction center coordinates
        - radii_range: tuple, (min_radius, max_radius)
        - angular_sectors: int, number of angular sectors
        - background_method: str, background subtraction method
    """

def put_settings(settings_dict):
    """
    Save ring diffraction analysis settings.
    
    Parameters:
    - settings_dict: dict, analysis settings to save
    """

def run_sglgroup(image, settings, group_name):
    """
    Process single diffraction ring group.
    
    Parameters:
    - image: numpy.ndarray, diffraction pattern image
    - settings: dict, analysis settings from get_settings()
    - group_name: str, identifier for this analysis group
    
    Returns:
    dict: Analysis results including:
        - radial_profile: numpy.ndarray, integrated radial intensity
        - peak_positions: numpy.ndarray, detected ring positions
        - d_spacings: numpy.ndarray, calculated d-spacings
        - intensities: numpy.ndarray, integrated intensities
    """

def put_sglgroup(results, group_name, output_path):
    """
    Save results from single group analysis.
    
    Parameters:
    - results: dict, analysis results from run_sglgroup()
    - group_name: str, group identifier
    - output_path: str, path for saving results
    """

def run_all(image_list, settings, output_path):
    """
    Process all diffraction groups in batch.
    
    Parameters:
    - image_list: list, list of diffraction pattern images
    - settings: dict, analysis settings
    - output_path: str, path for saving batch results
    
    Returns:
    dict: Combined results from all groups
    """

def stack_align(image_stack, reference_frame=0, method='cross_correlation'):
    """
    Align image stack with alignment quality evaluation.
    
    Parameters:
    - image_stack: numpy.ndarray, 3D array (frames, y, x)
    - reference_frame: int, reference frame index
    - method: str, alignment method ('cross_correlation', 'phase_correlation')
    
    Returns:
    dict: Dictionary containing:
        - 'aligned_stack': numpy.ndarray, aligned image stack
        - 'shifts': numpy.ndarray, calculated shifts for each frame
        - 'correlation_scores': numpy.ndarray, alignment quality scores
        - 'reference_frame': int, used reference frame
        - 'alignment_method': str, used alignment method
    """

def multicorr(image_stack, template=None, correlation_method='normalized'):
    """
    Multi-correlation analysis for template matching.
    
    Parameters:
    - image_stack: numpy.ndarray, 3D array (frames, y, x)
    - template: numpy.ndarray, template image for matching
    - correlation_method: str, correlation computation method
    
    Returns:
    dict: Dictionary containing:
        - 'correlation_maps': numpy.ndarray, correlation maps for each frame
        - 'peak_positions': numpy.ndarray, detected correlation peaks
        - 'correlation_scores': numpy.ndarray, correlation strength values  
        - 'template_used': numpy.ndarray, template image used
        - 'tracking_results': dict, feature tracking results
    """

import ncempy.eval as eval
import matplotlib.pyplot as plt

# Extract line profile across crystal boundary
image = microscopy_data['data']
start_point = (100, 50)   # (y, x) coordinates
end_point = (100, 200)

profile_data = eval.line_profile(image, start_point, end_point, linewidth=3)

# Plot the profile
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.imshow(image, cmap='gray')
plt.plot([start_point[1], end_point[1]], [start_point[0], end_point[0]], 'r-', linewidth=2)
plt.title('Line Profile Location')

plt.subplot(1, 2, 2)
plt.plot(profile_data['distance'], profile_data['profile'])
plt.xlabel('Distance (pixels)')
plt.ylabel('Intensity')
plt.title('Intensity Profile')
plt.show()

import ncempy.eval.ring_diff as ring_diff

# Set up analysis parameters
settings = {
    'center': (256, 256),
    'radii_range': (50, 200),
    'angular_sectors': 36,
    'background_method': 'polynomial'
}

# Save settings
ring_diff.put_settings(settings)

# Analyze single diffraction pattern
diffraction_image = load_diffraction_data()
results = ring_diff.run_sglgroup(diffraction_image, settings, 'sample_001')

# Display results
print(f"Detected {len(results['peak_positions'])} diffraction rings")
print(f"D-spacings: {results['d_spacings']}")

# Save results
ring_diff.put_sglgroup(results, 'sample_001', './analysis_results/')

import ncempy.eval as eval
import numpy as np
import matplotlib.pyplot as plt

# Load image stack (time series or tilt series)
stack = load_image_stack()  # shape: (frames, height, width)

# Perform alignment with evaluation
alignment_results = eval.stack_align(stack, reference_frame=0, 
                                   method='cross_correlation')

aligned_stack = alignment_results['aligned_stack']
shifts = alignment_results['shifts']
scores = alignment_results['correlation_scores']

# Plot alignment results
plt.figure(figsize=(12, 4))

plt.subplot(1, 3, 1)
plt.imshow(stack[0], cmap='gray')
plt.title('Original Frame 0')

plt.subplot(1, 3, 2)  
plt.imshow(aligned_stack[0], cmap='gray')
plt.title('Aligned Frame 0')

plt.subplot(1, 3, 3)
plt.plot(scores)
plt.xlabel('Frame Number')
plt.ylabel('Correlation Score')
plt.title('Alignment Quality')
plt.show()

# Display shift information
print(f"Maximum shift: {np.max(np.abs(shifts))} pixels")
print(f"Average alignment score: {np.mean(scores):.3f}")

import ncempy.eval as eval
import matplotlib.pyplot as plt

# Load image sequence
image_sequence = load_time_series()

# Define template from first frame
template_region = image_sequence[0, 100:150, 100:150]  # 50x50 template

# Perform multi-correlation tracking
tracking_results = eval.multicorr(image_sequence, template=template_region)

correlation_maps = tracking_results['correlation_maps']
peak_positions = tracking_results['peak_positions']
scores = tracking_results['correlation_scores']

# Plot tracking results
plt.figure(figsize=(15, 5))

# Show template
plt.subplot(1, 3, 1)
plt.imshow(template_region, cmap='gray')
plt.title('Template')

# Show correlation map for frame 10
plt.subplot(1, 3, 2)
plt.imshow(correlation_maps[10], cmap='hot')
plt.title('Correlation Map (Frame 10)')

# Plot tracking trajectory
plt.subplot(1, 3, 3)
plt.plot(peak_positions[:, 1], peak_positions[:, 0], 'b-o')
plt.xlabel('X Position')
plt.ylabel('Y Position')
plt.title('Feature Trajectory')
plt.axis('equal')
plt.show()

print(f"Tracked feature across {len(peak_positions)} frames")
print(f"Average correlation score: {np.mean(scores):.3f}")

import ncempy.eval.ring_diff as ring_diff
import glob

# Set up analysis settings
settings = ring_diff.get_settings()
settings.update({
    'center': (256, 256),
    'radii_range': (30, 250),
    'angular_sectors': 72
})
ring_diff.put_settings(settings)

# Process multiple diffraction patterns
diffraction_files = glob.glob('diffraction_data/*.dm4')
image_list = [ncempy.read(f)['data'] for f in diffraction_files]

# Run batch analysis
batch_results = ring_diff.run_all(image_list, settings, './batch_results/')

# Analyze batch statistics
all_d_spacings = []
for result in batch_results.values():
    all_d_spacings.extend(result['d_spacings'])

print(f"Processed {len(image_list)} diffraction patterns")
print(f"Total rings detected: {len(all_d_spacings)}")
print(f"D-spacing range: {min(all_d_spacings):.3f} - {max(all_d_spacings):.3f} Å")

import ncempy.eval as eval
import ncempy.algo as algo
import ncempy.viz as viz

# Load and preprocess data
raw_data = ncempy.read('sample.dm4')['data']

# 1. Align if it's a stack
if raw_data.ndim == 3:
    alignment_results = eval.stack_align(raw_data)
    processed_data = alignment_results['aligned_stack']
    print(f"Stack aligned with average score: {np.mean(alignment_results['correlation_scores']):.3f}")
else:
    processed_data = raw_data

# 2. Extract line profiles for analysis
center_line = eval.line_profile(processed_data, (0, 128), (255, 128))
cross_line = eval.line_profile(processed_data, (128, 0), (128, 255))

# 3. Visualize results
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# Original data
axes[0,0].imshow(processed_data, cmap='gray')
axes[0,0].set_title('Processed Data')

# Line profile locations
viz.plot_points(processed_data, [(128, 128)], ax=axes[0,1])
axes[0,1].plot([0, 255], [128, 128], 'r-', alpha=0.7)
axes[0,1].plot([128, 128], [0, 255], 'b-', alpha=0.7)
axes[0,1].set_title('Line Profile Locations')

# Profile plots
axes[1,0].plot(center_line['distance'], center_line['profile'], 'r-')
axes[1,0].set_title('Horizontal Profile')
axes[1,0].set_xlabel('Distance (pixels)')
axes[1,0].set_ylabel('Intensity')

axes[1,1].plot(cross_line['distance'], cross_line['profile'], 'b-')
axes[1,1].set_title('Vertical Profile')
axes[1,1].set_xlabel('Distance (pixels)')
axes[1,1].set_ylabel('Intensity')

plt.tight_layout()
plt.show()