NVision Interactive Demo

Run the NVision algorithm on your FSM scan data

Upload 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?

What is an FSM scan?

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.

How This Demo Works

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.

The NVision Algorithm (gui.py)

# 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()

Quantum Visualization

Diamond lattice with NV centers (blue glow)