Run the NVision algorithm on your FSM scan data
Drag and drop your JSON scan file here, or click to browse
Supported format: JSON files containing FSM scan data
Don't have an FSM scan file?
Fluorescence Scanning Microscopy (FSM) is a technique used to image fluorescent objects, such as Nitrogen-Vacancy (NV) centers in diamond. FSM scans capture the fluorescence intensity at each point in a sample, creating a 2D image where brighter areas indicate higher fluorescence, potentially corresponding to NV centers. The NVision algorithm processes these scans in JSON format.
This interactive demo showcases the NVision algorithm's capabilities for identifying Nitrogen-Vacancy centers in FSM scans of delta-doped diamond. In a production environment, the web interface would connect to a backend service that runs the Python code from the repository.
# Core detection function from the NVision repository (gui.py)
import numpy as np
import json
import tkinter as tk
from tkinter import filedialog, ttk
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
from scipy import ndimage
import matplotlib.colors as mcolors
class NVisionGUI:
def __init__(self, root):
self.root = root
self.root.title("NVision - NV Center Detection")
self.root.geometry("1200x800")
# Data variables
self.scan_data = None
self.results = None
# Parameters
self.threshold_var = tk.DoubleVar(value=0.75)
self.min_size_var = tk.IntVar(value=3)
self.max_size_var = tk.IntVar(value=15)
self.bg_correction_var = tk.BooleanVar(value=True)
self.colormap_var = tk.StringVar(value="viridis")
self.show_markers_var = tk.BooleanVar(value=True)
self.confidence_threshold_var = tk.DoubleVar(value=0.8)
self.median_filter_var = tk.BooleanVar(value=True)
self.filter_size_var = tk.IntVar(value=3)
# Create UI
self.create_ui()
def create_ui(self):
# Main frame
main_frame = ttk.Frame(self.root)
main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Left panel (controls)
left_panel = ttk.LabelFrame(main_frame, text="Controls")
left_panel.pack(side=tk.LEFT, fill=tk.Y, padx=5, pady=5)
# File selection
file_frame = ttk.Frame(left_panel)
file_frame.pack(fill=tk.X, padx=5, pady=5)
ttk.Button(file_frame, text="Load JSON File", command=self.load_file).pack(fill=tk.X)
# Parameters frame
params_frame = ttk.LabelFrame(left_panel, text="Detection Parameters")
params_frame.pack(fill=tk.X, padx=5, pady=5)
# Threshold
ttk.Label(params_frame, text="Detection Threshold:").pack(anchor=tk.W)
threshold_scale = ttk.Scale(params_frame, from_=0, to=1, variable=self.threshold_var)
threshold_scale.pack(fill=tk.X)
# Confidence Threshold
ttk.Label(params_frame, text="Confidence Threshold:").pack(anchor=tk.W)
confidence_scale = ttk.Scale(params_frame, from_=0, to=1, variable=self.confidence_threshold_var)
confidence_scale.pack(fill=tk.X)
# Size range
size_frame = ttk.Frame(params_frame)
size_frame.pack(fill=tk.X, pady=5)
ttk.Label(size_frame, text="Min Size:").grid(row=0, column=0)
ttk.Spinbox(size_frame, from_=1, to=50, textvariable=self.min_size_var, width=5).grid(row=0, column=1)
ttk.Label(size_frame, text="Max Size:").grid(row=0, column=2, padx=(10, 0))
ttk.Spinbox(size_frame, from_=1, to=50, textvariable=self.max_size_var, width=5).grid(row=0, column=3)
# Background correction
ttk.Checkbutton(params_frame, text="Background Correction", variable=self.bg_correction_var).pack(anchor=tk.W, pady=5)
# Median filter
median_check = ttk.Checkbutton(params_frame, text="Median Filter", variable=self.median_filter_var, command=self.toggle_filter_size)
median_check.pack(anchor=tk.W)
self.filter_size_frame = ttk.Frame(params_frame)
self.filter_size_frame.pack(fill=tk.X, pady=5)
ttk.Label(self.filter_size_frame, text="Filter Size:").pack(side=tk.LEFT)
filter_combo = ttk.Combobox(self.filter_size_frame, textvariable=self.filter_size_var, values=[3, 5, 7], width=5)
filter_combo.pack(side=tk.LEFT, padx=5)
# Visualization options
viz_frame = ttk.LabelFrame(left_panel, text="Visualization")
viz_frame.pack(fill=tk.X, padx=5, pady=5)
ttk.Label(viz_frame, text="Colormap:").pack(anchor=tk.W)
colormap_combo = ttk.Combobox(viz_frame, textvariable=self.colormap_var,
values=["viridis", "plasma", "inferno", "magma", "cividis"])
colormap_combo.pack(fill=tk.X, pady=2)
ttk.Checkbutton(viz_frame, text="Show NV Center Markers", variable=self.show_markers_var).pack(anchor=tk.W, pady=5)
# Run button
ttk.Button(left_panel, text="Run Analysis", command=self.run_analysis).pack(fill=tk.X, padx=5, pady=10)
# Right panel (visualization)
right_panel = ttk.Frame(main_frame)
right_panel.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True, padx=5, pady=5)
# Tabs for different visualizations
self.tabs = ttk.Notebook(right_panel)
self.tabs.pack(fill=tk.BOTH, expand=True)
# Visualization tab
self.viz_tab = ttk.Frame(self.tabs)
self.tabs.add(self.viz_tab, text="Visualization")
# Data tab
self.data_tab = ttk.Frame(self.tabs)
self.tabs.add(self.data_tab, text="Data")
# Histogram tab
self.hist_tab = ttk.Frame(self.tabs)
self.tabs.add(self.hist_tab, text="Histogram")
# Setup visualization
self.setup_visualization()
# Status bar
self.status_var = tk.StringVar(value="Ready")
status_bar = ttk.Label(self.root, textvariable=self.status_var, relief=tk.SUNKEN, anchor=tk.W)
status_bar.pack(side=tk.BOTTOM, fill=tk.X)
def toggle_filter_size(self):
if self.median_filter_var.get():
self.filter_size_frame.pack(fill=tk.X, pady=5)
else:
self.filter_size_frame.pack_forget()
def setup_visualization(self):
# Visualization tab
self.fig_viz, self.ax_viz = plt.subplots(figsize=(6, 6))
self.canvas_viz = FigureCanvasTkAgg(self.fig_viz, master=self.viz_tab)
self.canvas_viz.get_tk_widget().pack(fill=tk.BOTH, expand=True)
# Data tab
self.data_frame = ttk.Frame(self.data_tab)
self.data_frame.pack(fill=tk.BOTH, expand=True)
# Treeview for data
columns = ("id", "x", "y", "size", "intensity", "confidence")
self.tree = ttk.Treeview(self.data_frame, columns=columns, show="headings")
# Define headings
self.tree.heading("id", text="ID")
self.tree.heading("x", text="X Position")
self.tree.heading("y", text="Y Position")
self.tree.heading("size", text="Size")
self.tree.heading("intensity", text="Intensity")
self.tree.heading("confidence", text="Confidence")
# Define columns
self.tree.column("id", width=50)
self.tree.column("x", width=100)
self.tree.column("y", width=100)
self.tree.column("size", width=80)
self.tree.column("intensity", width=100)
self.tree.column("confidence", width=100)
# Add scrollbar
scrollbar = ttk.Scrollbar(self.data_frame, orient=tk.VERTICAL, command=self.tree.yview)
self.tree.configure(yscroll=scrollbar.set)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
# Histogram tab
self.fig_hist, self.ax_hist = plt.subplots(figsize=(6, 6))
self.canvas_hist = FigureCanvasTkAgg(self.fig_hist, master=self.hist_tab)
self.canvas_hist.get_tk_widget().pack(fill=tk.BOTH, expand=True)
def load_file(self):
file_path = filedialog.askopenfilename(
title="Select JSON File",
filetypes=[("JSON files", "*.json"), ("All files", "*.*")]
)
if file_path:
try:
with open(file_path, 'r') as f:
data = json.load(f)
self.scan_data = np.array(data['scan_data'])
self.status_var.set(f"Loaded file: {file_path}")
# Display the scan data
self.display_scan()
except Exception as e:
self.status_var.set(f"Error loading file: {str(e)}")
def display_scan(self):
if self.scan_data is not None:
self.ax_viz.clear()
self.ax_viz.imshow(self.scan_data, cmap=self.colormap_var.get())
self.ax_viz.set_title("FSM Scan Data")
self.canvas_viz.draw()
def run_analysis(self):
if self.scan_data is None:
self.status_var.set("No data loaded. Please load a JSON file first.")
return
self.status_var.set("Running analysis...")
self.root.update()
# Get parameters
params = {
'threshold': self.threshold_var.get(),
'min_size': self.min_size_var.get(),
'max_size': self.max_size_var.get(),
'background_correction': self.bg_correction_var.get(),
'confidence_threshold': self.confidence_threshold_var.get(),
'median_filter': self.median_filter_var.get(),
'filter_size': self.filter_size_var.get()
}
# Process the data
processed_data = self.preprocess_data(self.scan_data, params)
# Detect NV centers
self.results = self.detect_nv_centers(processed_data, params)
# Update visualizations
self.update_visualizations()
self.status_var.set(f"Analysis complete. Detected {len(self.results['centers'])} NV centers.")
def preprocess_data(self, data, params):
# Apply median filter if enabled
if params['median_filter']:
data = ndimage.median_filter(data, size=params['filter_size'])
# Apply background correction if enabled
if params['background_correction']:
# Apply Gaussian filter to estimate background
background = ndimage.gaussian_filter(data, sigma=10)
# Subtract background from original image
corrected_data = data - background
# Clip negative values to zero
corrected_data = np.clip(corrected_data, 0, None)
return corrected_data
return data
def detect_nv_centers(self, image_data, params):
# Apply threshold to identify potential NV centers
binary_image = image_data > params['threshold'] * np.max(image_data)
# Label connected components
labeled_image, num_features = ndimage.label(binary_image)
# Filter by size
centers = []
for i in range(1, num_features + 1):
region = labeled_image == i
size = np.sum(region)
if params['min_size'] <= size <= params['max_size']:
# Calculate center of mass
y, x = ndimage.center_of_mass(region)
intensity = np.mean(image_data[region])
# Calculate confidence (example metric)
confidence = intensity / np.max(image_data)
if confidence >= params['confidence_threshold']:
centers.append({
'id': len(centers) + 1,
'x': float(x),
'y': float(y),
'size': int(size),
'intensity': float(intensity),
'confidence': float(confidence)
})
return {
'centers': centers,
'total': len(centers),
'params': params,
'binary_image': binary_image
}
def update_visualizations(self):
if self.results is None:
return
# Update visualization tab
self.ax_viz.clear()
self.ax_viz.imshow(self.scan_data, cmap=self.colormap_var.get())
if self.show_markers_var.get():
for center in self.results['centers']:
circle = plt.Circle((center['x'], center['y']),
np.sqrt(center['size']/np.pi),
fill=False,
edgecolor='white')
self.ax_viz.add_patch(circle)
self.ax_viz.set_title(f"Detected {len(self.results['centers'])} NV Centers")
self.canvas_viz.draw()
# Update data tab
for item in self.tree.get_children():
self.tree.delete(item)
for center in self.results['centers']:
self.tree.insert("", tk.END, values=(
center['id'],
f"{center['x']:.2f}",
f"{center['y']:.2f}",
center['size'],
f"{center['intensity']:.2f}",
f"{center['confidence']:.2f}"
))
# Update histogram tab
self.ax_hist.clear()
if self.results['centers']:
intensities = [center['intensity'] for center in self.results['centers']]
self.ax_hist.hist(intensities, bins=10, color='purple', alpha=0.7)
self.ax_hist.set_title("Intensity Distribution")
self.ax_hist.set_xlabel("Intensity")
self.ax_hist.set_ylabel("Count")
self.canvas_hist.draw()
if __name__ == "__main__":
root = tk.Tk()
app = NVisionGUI(root)
root.mainloop()Diamond lattice with NV centers (blue glow)