napari-nifti-viewer 0.1.0__py3-none-any.whl

napari_nifti_viewer/__init__.py

@@ -0,0 +1,22 @@
+import os
+import sys
+import logging
+from pathlib import Path
+
+
+if sys.platform == 'darwin':
+    os.environ['QT_MAC_WANTS_LAYER'] = '1'
+   
+    class QtWarningFilter(logging.Filter):
+        def filter(self, record):
+            return not (record.getMessage().find("Layer-backing is always enabled") >= 0)
+    
+    logging.getLogger().addFilter(QtWarningFilter())
+    
+    import warnings
+    warnings.filterwarnings("ignore", message="Layer-backing is always enabled")
+
+from napari_nifti_viewer._version import __version__
+from napari_nifti_viewer._widget import NiftiViewerWidget
+
+__all__ = ["NiftiViewerWidget", "__version__"] 

napari_nifti_viewer/_nifti_loader.py

@@ -0,0 +1,371 @@
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple, Union, Any
+import numpy as np
+import nibabel as nib
+import json
+
+class NiftiLoader:
+    """Specialized loader for NIfTI files, extracting data, metadata, labels, etc."""
+    
+    def __init__(self):
+        self.supported_formats = {'.nii', '.nii.gz'}
+        self.current_file = None
+        self.current_nii = None
+        
+    def load_file(self, file_path: Union[str, Path]) -> Tuple[np.ndarray, Dict]:
+        """Load NIfTI file and extract all information
+        
+        Args:
+            file_path: Path to NIfTI file
+            
+        Returns:
+            (image data, complete metadata dictionary)
+        """
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"File does not exist: {file_path}")
+        
+        # Check file format
+        if not self._is_nifti_file(file_path):
+            raise ValueError(f"Unsupported file format, only .nii and .nii.gz are supported")
+        
+        # Load NIfTI file
+        self.current_file = file_path
+        self.current_nii = nib.load(str(file_path))
+        
+        # Extract data
+        data = self.current_nii.get_fdata()
+        
+        # Extract all metadata
+        metadata = self._extract_all_metadata()
+        
+        return data, metadata
+    
+    def _is_nifti_file(self, file_path: Path) -> bool:
+        """Check if file is a NIfTI file"""
+        suffixes = [s.lower() for s in file_path.suffixes]
+        
+        # Check .nii.gz
+        if len(suffixes) >= 2 and suffixes[-2] == '.nii' and suffixes[-1] == '.gz':
+            return True
+        
+        # Check .nii
+        if file_path.suffix.lower() == '.nii':
+            return True
+            
+        return False
+    
+    def _extract_all_metadata(self) -> Dict:
+        """Extract all metadata information from NIfTI file"""
+        if self.current_nii is None:
+            return {}
+        
+        metadata = {}
+        
+        # Basic file information
+        metadata['file_info'] = self._extract_file_info()
+        
+        # Header information
+        metadata['header'] = self._extract_header_info()
+        
+        # Affine transformation matrix
+        metadata['affine'] = self._extract_affine_info()
+        
+        # Data information
+        metadata['data_info'] = self._extract_data_info()
+        
+        # Coordinate system information
+        metadata['coordinate_system'] = self._extract_coordinate_info()
+        
+        # Label information (if exists)
+        metadata['labels'] = self._extract_label_info()
+        
+        # Extension header information (if exists)
+        metadata['extensions'] = self._extract_extensions()
+        
+        return metadata
+    
+    def _extract_file_info(self) -> Dict:
+        """Extract basic file information"""
+        return {
+            'file_path': str(self.current_file),
+            'file_name': self.current_file.name,
+            'file_size': self.current_file.stat().st_size,
+            'format': 'NIfTI',
+            'version': self.current_nii.header.get('sizeof_hdr', 348),
+        }
+    
+    def _extract_header_info(self) -> Dict:
+        """Extract detailed NIfTI header information"""
+        header = self.current_nii.header
+        
+        header_info = {}
+        
+        # Basic header fields
+        basic_fields = [
+            'sizeof_hdr', 'data_type', 'db_name', 'extents', 'session_error',
+            'regular', 'dim_info', 'dim', 'intent_p1', 'intent_p2', 'intent_p3',
+            'intent_code', 'datatype', 'bitpix', 'slice_start', 'pixdim',
+            'vox_offset', 'scl_slope', 'scl_inter', 'slice_end', 'slice_code',
+            'xyzt_units', 'cal_max', 'cal_min', 'slice_duration', 'toffset',
+            'glmax', 'glmin', 'descrip', 'aux_file', 'qform_code', 'sform_code',
+            'quatern_b', 'quatern_c', 'quatern_d', 'qoffset_x', 'qoffset_y',
+            'qoffset_z', 'srow_x', 'srow_y', 'srow_z', 'intent_name', 'magic'
+        ]
+        
+        for field in basic_fields:
+            try:
+                value = header.get(field)
+                if value is not None:
+                    # Convert numpy types to Python native types for JSON serialization
+                    if isinstance(value, np.ndarray):
+                        header_info[field] = value.tolist()
+                    elif isinstance(value, (np.integer, np.floating)):
+                        header_info[field] = value.item()
+                    elif isinstance(value, bytes):
+                        header_info[field] = value.decode('utf-8', errors='ignore').strip('\x00')
+                    else:
+                        header_info[field] = value
+            except Exception as e:
+                header_info[field] = f"Extraction failed: {str(e)}"
+        
+        # Add explanatory information
+        header_info['explanations'] = self._get_header_explanations(header_info)
+        
+        return header_info
+    
+    def _extract_affine_info(self) -> Dict:
+        """Extract affine transformation matrix information"""
+        affine = self.current_nii.affine
+        
+        return {
+            'affine_matrix': affine.tolist(),
+            'translation': affine[:3, 3].tolist(),
+            'rotation_scaling': affine[:3, :3].tolist(),
+            'determinant': float(np.linalg.det(affine[:3, :3])),
+            'is_orthogonal': bool(np.allclose(np.dot(affine[:3, :3], affine[:3, :3].T), np.eye(3))),
+        }
+    
+    def _extract_data_info(self) -> Dict:
+        """Extract data statistics information"""
+        data = self.current_nii.get_fdata()
+        
+        return {
+            'shape': list(data.shape),
+            'ndim': data.ndim,
+            'dtype': str(data.dtype),
+            'min_value': float(np.min(data)),
+            'max_value': float(np.max(data)),
+            'mean_value': float(np.mean(data)),
+            'std_value': float(np.std(data)),
+            'median_value': float(np.median(data)),
+            'unique_values_count': int(len(np.unique(data))),
+            'non_zero_count': int(np.count_nonzero(data)),
+            'zero_count': int(np.sum(data == 0)),
+            'nan_count': int(np.sum(np.isnan(data))),
+            'inf_count': int(np.sum(np.isinf(data))),
+        }
+    
+    def _extract_coordinate_info(self) -> Dict:
+        """Extract coordinate system information"""
+        header = self.current_nii.header
+        
+        # Get voxel size
+        pixdim = header.get_zooms()
+        
+        # Get unit information
+        xyzt_units = header.get('xyzt_units', 0)
+        spatial_unit = xyzt_units & 0x07
+        temporal_unit = (xyzt_units & 0x38) >> 3
+        
+        spatial_units_map = {
+            0: 'Unknown',
+            1: 'meters (m)',
+            2: 'millimeters (mm)',
+            3: 'micrometers (μm)',
+        }
+        
+        temporal_units_map = {
+            0: 'Unknown',
+            8: 'seconds (s)',
+            16: 'milliseconds (ms)',
+            24: 'microseconds (μs)',
+        }
+        
+        return {
+            'voxel_size': list(pixdim) if pixdim else [],
+            'spatial_unit': spatial_units_map.get(spatial_unit, f'Unknown unit ({spatial_unit})'),
+            'temporal_unit': temporal_units_map.get(temporal_unit, f'Unknown unit ({temporal_unit})'),
+            'qform_code': int(header.get('qform_code', 0)),
+            'sform_code': int(header.get('sform_code', 0)),
+            'slice_code': int(header.get('slice_code', 0)),
+        }
+    
+    def _extract_label_info(self) -> Dict:
+        """Extract label information (if it exists)"""
+        data = self.current_nii.get_fdata()
+        
+        # Check if this might be a label image
+        unique_values = np.unique(data)
+        
+        label_info = {
+            'unique_values': unique_values.tolist(),
+            'is_likely_labels': self._is_likely_label_image(data, unique_values),
+            'label_count': len(unique_values),
+        }
+        
+        # If likely a label image, extract more information
+        if label_info['is_likely_labels']:
+            label_info['label_statistics'] = {}
+            for label_val in unique_values:
+                mask = data == label_val
+                label_info['label_statistics'][str(float(label_val))] = {
+                    'voxel_count': int(np.sum(mask)),
+                    'percentage': float(np.sum(mask) / data.size * 100),
+                }
+        
+        return label_info
+    
+    def _is_likely_label_image(self, data: np.ndarray, unique_values: np.ndarray) -> bool:
+        """Determine if this is likely a label image"""
+        # Heuristic rules for label detection
+        
+        # 1. If unique values are few and integers
+        if len(unique_values) <= 50 and np.allclose(unique_values, unique_values.astype(int)):
+            return True
+        
+        # 2. If data type is integer
+        if np.issubdtype(data.dtype, np.integer):
+            return True
+        
+        # 3. If all values are integers (even if data type is float)
+        if np.allclose(data, np.round(data)):
+            return True
+            
+        return False
+    
+    def _extract_extensions(self) -> List[Dict]:
+        """Extract NIfTI extension information"""
+        extensions = []
+        
+        if hasattr(self.current_nii, 'extra') and self.current_nii.extra:
+            for i, ext in enumerate(self.current_nii.extra):
+                ext_info = {
+                    'index': i,
+                    'esize': ext.get('esize', 0),
+                    'ecode': ext.get('ecode', 0),
+                }
+                
+                # Try to decode extension data
+                if 'edata' in ext:
+                    try:
+                        ext_info['edata'] = ext['edata'].decode('utf-8', errors='ignore')
+                    except:
+                        ext_info['edata'] = f"Binary data (length: {len(ext['edata'])})"
+                
+                extensions.append(ext_info)
+        
+        return extensions
+    
+    def _get_header_explanations(self, header_info: Dict) -> Dict:
+        """Provide explanations for header fields"""
+        explanations = {}
+        
+        # Data type explanations
+        datatype_map = {
+            2: 'Unsigned char (uint8)',
+            4: 'Signed short (int16)',
+            8: 'Signed int (int32)',
+            16: 'Single precision float (float32)',
+            64: 'Double precision float (float64)',
+            256: 'Signed char (int8)',
+            512: 'Unsigned short (uint16)',
+            768: 'Unsigned int (uint32)',
+        }
+        
+        if 'datatype' in header_info:
+            explanations['datatype'] = datatype_map.get(
+                header_info['datatype'], 
+                f"Unknown datatype ({header_info['datatype']})"
+            )
+        
+        # Intent code explanations
+        intent_map = {
+            0: 'No special intent',
+            2: 'Correlation coefficient',
+            3: 'T-statistic',
+            4: 'F-statistic',
+            5: 'Z-score',
+        }
+        
+        if 'intent_code' in header_info:
+            explanations['intent_code'] = intent_map.get(
+                header_info['intent_code'],
+                f"Other intent ({header_info['intent_code']})"
+            )
+        
+        return explanations
+    
+    def get_metadata_summary(self, metadata: Dict) -> str:
+        """Generate human-readable metadata summary"""
+        summary = []
+        
+        # File information
+        if 'file_info' in metadata:
+            info = metadata['file_info']
+            summary.append(f"Filename: {info.get('file_name', 'Unknown')}")
+            summary.append(f"File size: {info.get('file_size', 0) / 1024 / 1024:.2f} MB")
+        
+        # Data information
+        if 'data_info' in metadata:
+            data = metadata['data_info']
+            summary.append(f"Data shape: {data.get('shape', [])}")
+            summary.append(f"Data type: {data.get('dtype', 'Unknown')}")
+            summary.append(f"Value range: [{data.get('min_value', 0):.3f}, {data.get('max_value', 0):.3f}]")
+            summary.append(f"Mean value: {data.get('mean_value', 0):.3f}")
+            summary.append(f"Std deviation: {data.get('std_value', 0):.3f}")
+        
+        # Coordinate system information
+        if 'coordinate_system' in metadata:
+            coord = metadata['coordinate_system']
+            if coord.get('voxel_size'):
+                summary.append(f"Voxel size: {[f'{v:.3f}' for v in coord['voxel_size']]} {coord.get('spatial_unit', '')}")
+        
+        # Label information
+        if 'labels' in metadata and metadata['labels'].get('is_likely_labels'):
+            labels = metadata['labels']
+            summary.append(f"Label image: Yes")
+            summary.append(f"Label count: {labels.get('label_count', 0)}")
+        
+        return "\n".join(summary)
+    
+    def export_metadata_to_json(self, metadata: Dict, output_path: Union[str, Path]) -> None:
+        """Export metadata to JSON file"""
+        output_path = Path(output_path)
+        
+        # Ensure output directory exists
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Deep copy and convert numpy types to JSON serializable types
+        def convert_numpy_types(obj):
+            if isinstance(obj, dict):
+                return {key: convert_numpy_types(value) for key, value in obj.items()}
+            elif isinstance(obj, list):
+                return [convert_numpy_types(item) for item in obj]
+            elif isinstance(obj, np.ndarray):
+                return obj.tolist()
+            elif isinstance(obj, (np.integer, np.floating)):
+                return obj.item()
+            elif isinstance(obj, np.bool_):
+                return bool(obj)
+            elif isinstance(obj, bytes):
+                return obj.decode('utf-8', errors='ignore').strip('\x00')
+            else:
+                return obj
+        
+        json_serializable_metadata = convert_numpy_types(metadata)
+        
+        # Write JSON file
+        with open(output_path, 'w', encoding='utf-8') as f:
+            json.dump(json_serializable_metadata, f, ensure_ascii=False, indent=2) 

napari_nifti_viewer/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0" 

napari_nifti_viewer/_widget.py

@@ -0,0 +1,450 @@
+from typing import Dict, List, Optional, Tuple, Union
+import os
+import sys
+from pathlib import Path
+import numpy as np
+import napari
+from qtpy.QtWidgets import (
+    QWidget, QVBoxLayout, QHBoxLayout, QTabWidget,
+    QPushButton, QLabel, QLineEdit, QTextEdit, QGroupBox,
+    QFileDialog, QMessageBox, QScrollArea, QTreeWidget,
+    QTreeWidgetItem, QSplitter, QTableWidget, QTableWidgetItem
+)
+from qtpy.QtCore import Qt
+
+# 抑制 macOS 上的 Qt layer-backing 警告
+if sys.platform == 'darwin':
+    os.environ['QT_MAC_WANTS_LAYER'] = '1'
+    import warnings
+    warnings.filterwarnings("ignore", message="Layer-backing is always enabled")
+
+from ._nifti_loader import NiftiLoader
+
+class NiftiViewerWidget(QWidget):
+    """Main interface for NIfTI file viewer"""
+    
+    def __init__(self, napari_viewer):
+        super().__init__()
+        self.viewer = napari_viewer
+        self.nifti_loader = NiftiLoader()
+        self.current_data = None
+        self.current_metadata = None
+        
+        # 设置界面
+        self.setup_ui()
+        
+    def setup_ui(self):
+        """设置用户界面"""
+        layout = QVBoxLayout()
+        
+        # File loading area
+        load_group = QGroupBox("File Loading")
+        load_layout = QVBoxLayout()
+        
+        # File selection
+        file_layout = QHBoxLayout()
+        self.file_path = QLineEdit()
+        self.file_path.setReadOnly(True)
+        self.file_path.setPlaceholderText("Select a .nii or .nii.gz file...")
+        
+        browse_btn = QPushButton("Browse...")
+        browse_btn.clicked.connect(self.load_file)
+        
+        load_btn = QPushButton("Load to Napari")
+        load_btn.clicked.connect(self.load_to_napari)
+        load_btn.setEnabled(False)
+        self.load_btn = load_btn
+        
+        file_layout.addWidget(QLabel("File:"))
+        file_layout.addWidget(self.file_path, 1)
+        file_layout.addWidget(browse_btn)
+        file_layout.addWidget(load_btn)
+        
+        load_layout.addLayout(file_layout)
+        load_group.setLayout(load_layout)
+        layout.addWidget(load_group)
+        
+        # Create tabbed interface
+        self.tabs = QTabWidget()
+        
+        # File overview tab (merge basic info + data statistics)
+        self.setup_overview_tab()
+        
+        # Detailed info tab (merge header info + metadata)
+        self.setup_detailed_info_tab()
+        
+        # Label analysis tab
+        self.setup_labels_tab()
+        
+        layout.addWidget(self.tabs)
+        
+        # 导出按钮
+        export_layout = QHBoxLayout()
+        export_btn = QPushButton("Export Metadata as JSON")
+        export_btn.clicked.connect(self.export_metadata)
+        export_btn.setEnabled(False)
+        self.export_btn = export_btn
+        
+        export_layout.addStretch()
+        export_layout.addWidget(export_btn)
+        layout.addLayout(export_layout)
+        
+        self.setLayout(layout)
+        
+    def setup_overview_tab(self):
+        """Set up file overview tab (merge basic info and data statistics)"""
+        overview_tab = QWidget()
+        layout = QVBoxLayout()
+        
+        # Basic file information
+        file_group = QGroupBox("File Information")
+        file_layout = QVBoxLayout()
+        
+        self.file_info_text = QTextEdit()
+        self.file_info_text.setReadOnly(True)
+        self.file_info_text.setMaximumHeight(120)
+        file_layout.addWidget(self.file_info_text)
+        file_group.setLayout(file_layout)
+        
+        # Data statistics information (using table)
+        stats_group = QGroupBox("Data Statistics")
+        stats_layout = QVBoxLayout()
+        
+        self.overview_stats_table = QTableWidget()
+        self.overview_stats_table.setColumnCount(2)
+        self.overview_stats_table.setHorizontalHeaderLabels(["Property", "Value"])
+        self.overview_stats_table.horizontalHeader().setStretchLastSection(True)
+        self.overview_stats_table.verticalHeader().setVisible(False)  # Hide row numbers
+        self.overview_stats_table.setMaximumHeight(200)
+        
+        stats_layout.addWidget(self.overview_stats_table)
+        stats_group.setLayout(stats_layout)
+        
+        # Coordinate system and affine transformation
+        transform_group = QGroupBox("Coordinate System & Transform")
+        transform_layout = QVBoxLayout()
+        
+        self.transform_text = QTextEdit()
+        self.transform_text.setReadOnly(True)
+        self.transform_text.setMaximumHeight(150)
+        transform_layout.addWidget(self.transform_text)
+        transform_group.setLayout(transform_layout)
+        
+        layout.addWidget(file_group)
+        layout.addWidget(stats_group)
+        layout.addWidget(transform_group)
+        layout.addStretch()
+        
+        overview_tab.setLayout(layout)
+        self.tabs.addTab(overview_tab, "File Overview")
+        
+    def setup_detailed_info_tab(self):
+        """Set up detailed info tab (merge NIfTI header info and complete metadata)"""
+        detailed_tab = QWidget()
+        layout = QVBoxLayout()
+        
+        # 创建水平分割器
+        splitter = QSplitter(Qt.Horizontal)
+        
+        # Left side: NIfTI header fields
+        left_widget = QWidget()
+        left_layout = QVBoxLayout()
+        left_layout.addWidget(QLabel("NIfTI Header Fields"))
+        
+        self.header_tree = QTreeWidget()
+        self.header_tree.setHeaderLabels(["Field", "Value", "Description"])
+        self.header_tree.setAlternatingRowColors(False)  # Turn off alternating row colors
+        self.header_tree.setRootIsDecorated(False)  # Don't show root node decoration
+        
+        # Set better styling
+        self.header_tree.setStyleSheet("""
+            QTreeWidget {
+                background-color: #2b2b2b;
+                color: white;
+                border: 1px solid #555;
+                selection-background-color: #404040;
+            }
+            QTreeWidget::item {
+                padding: 4px;
+                border-bottom: 1px solid #404040;
+            }
+            QTreeWidget::item:selected {
+                background-color: #404040;
+            }
+            QHeaderView::section {
+                background-color: #3c3c3c;
+                color: white;
+                padding: 6px;
+                border: 1px solid #555;
+                font-weight: bold;
+            }
+        """)
+        left_layout.addWidget(self.header_tree)
+        left_widget.setLayout(left_layout)
+        
+        # Right side: Complete metadata JSON
+        right_widget = QWidget()
+        right_layout = QVBoxLayout()
+        right_layout.addWidget(QLabel("Complete Metadata (JSON Format)"))
+        
+        self.raw_metadata_text = QTextEdit()
+        self.raw_metadata_text.setReadOnly(True)
+        self.raw_metadata_text.setFont(self.raw_metadata_text.font())  # 使用等宽字体
+        right_layout.addWidget(self.raw_metadata_text)
+        right_widget.setLayout(right_layout)
+        
+        splitter.addWidget(left_widget)
+        splitter.addWidget(right_widget)
+        splitter.setSizes([1, 1])  # 平分空间
+        
+        layout.addWidget(splitter)
+        detailed_tab.setLayout(layout)
+        self.tabs.addTab(detailed_tab, "Detailed Info")
+        
+    def setup_labels_tab(self):
+        """Set up label information tab"""
+        labels_tab = QWidget()
+        layout = QVBoxLayout()
+        
+        # Label detection results
+        detection_group = QGroupBox("Label Detection")
+        detection_layout = QVBoxLayout()
+        
+        self.label_detection_text = QTextEdit()
+        self.label_detection_text.setReadOnly(True)
+        self.label_detection_text.setMaximumHeight(100)
+        detection_layout.addWidget(self.label_detection_text)
+        detection_group.setLayout(detection_layout)
+        
+        # Label statistics table
+        label_stats_group = QGroupBox("Label Statistics")
+        label_stats_layout = QVBoxLayout()
+        
+        self.label_stats_table = QTableWidget()
+        self.label_stats_table.setColumnCount(3)
+        self.label_stats_table.setHorizontalHeaderLabels(["Label Value", "Voxel Count", "Percentage (%)"])
+        self.label_stats_table.horizontalHeader().setStretchLastSection(True)
+        self.label_stats_table.verticalHeader().setVisible(False)  # Hide row numbers
+        
+        label_stats_layout.addWidget(self.label_stats_table)
+        label_stats_group.setLayout(label_stats_layout)
+        
+        layout.addWidget(detection_group)
+        layout.addWidget(label_stats_group)
+        layout.addStretch()
+        
+        labels_tab.setLayout(layout)
+        self.tabs.addTab(labels_tab, "Label Analysis")
+        
+    def load_file(self):
+        """Load NIfTI file"""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,
+            "Select NIfTI File",
+            "",
+            "NIfTI Files (*.nii *.nii.gz);;All Files (*.*)"
+        )
+        
+        if file_path:
+            try:
+                # 加载文件和元数据
+                data, metadata = self.nifti_loader.load_file(file_path)
+                self.current_data = data
+                self.current_metadata = metadata
+                
+                # 更新界面
+                self.file_path.setText(file_path)
+                self.update_all_displays()
+                
+                # 启用按钮
+                self.load_btn.setEnabled(True)
+                self.export_btn.setEnabled(True)
+                
+                QMessageBox.information(self, "Success", "File loaded successfully!")
+                
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Error loading file: {str(e)}")
+                
+    def load_to_napari(self):
+        """Load data into Napari viewer"""
+        if self.current_data is not None:
+            try:
+                # 根据数据特征选择合适的显示方式
+                file_name = Path(self.file_path.text()).name
+                
+                # 检查是否可能是标签图像
+                is_labels = (self.current_metadata.get('labels', {}).get('is_likely_labels', False) 
+                           if self.current_metadata else False)
+                
+                if is_labels:
+                    # Add as label layer
+                    self.viewer.add_labels(
+                        self.current_data.astype(np.int32),
+                        name=f"Labels: {file_name}"
+                    )
+                else:
+                    # Add as image layer
+                    self.viewer.add_image(
+                        self.current_data,
+                        name=f"Image: {file_name}"
+                    )
+                
+                QMessageBox.information(self, "Success", "Data added to Napari viewer!")
+                
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Error adding data to Napari: {str(e)}")
+    
+    def update_all_displays(self):
+        """更新所有显示内容"""
+        if self.current_metadata is None:
+            return
+            
+        self.update_overview()
+        self.update_detailed_info()
+        self.update_labels_info()
+        
+    def update_overview(self):
+        """更新文件概览显示"""
+        metadata = self.current_metadata
+        
+        # File information
+        if 'file_info' in metadata:
+            file_info = metadata['file_info']
+            file_text = f"""Filename: {file_info.get('file_name', 'Unknown')}
+File Size: {file_info.get('file_size', 0) / 1024 / 1024:.2f} MB
+Format: {file_info.get('format', 'Unknown')} (Version: {file_info.get('version', 'Unknown')})"""
+            self.file_info_text.setText(file_text)
+        
+        # Data statistics table
+        if 'data_info' in metadata:
+            data_info = metadata['data_info']
+            
+            stats_items = [
+                ('Data Shape', str(data_info.get('shape', []))),
+                ('Data Type', str(data_info.get('dtype', 'Unknown'))),
+                ('Min Value', f"{data_info.get('min_value', 0):.6f}"),
+                ('Max Value', f"{data_info.get('max_value', 0):.6f}"),
+                ('Mean Value', f"{data_info.get('mean_value', 0):.6f}"),
+                ('Std Deviation', f"{data_info.get('std_value', 0):.6f}"),
+                ('Unique Values', str(data_info.get('unique_values_count', 0))),
+                ('Non-zero Voxels', str(data_info.get('non_zero_count', 0))),
+            ]
+            
+            self.overview_stats_table.setRowCount(len(stats_items))
+            for i, (name, value) in enumerate(stats_items):
+                self.overview_stats_table.setItem(i, 0, QTableWidgetItem(name))
+                self.overview_stats_table.setItem(i, 1, QTableWidgetItem(value))
+        
+        # 坐标系统和仿射变换
+        transform_parts = []
+        
+        if 'coordinate_system' in metadata:
+            coord_info = metadata['coordinate_system']
+            transform_parts.append(f"Voxel Size: {coord_info.get('voxel_size', [])} {coord_info.get('spatial_unit', '')}")
+            transform_parts.append(f"Transform Codes: QForm={coord_info.get('qform_code', 0)}, SForm={coord_info.get('sform_code', 0)}")
+        
+        if 'affine' in metadata:
+            affine_info = metadata['affine']
+            affine_matrix = np.array(affine_info['affine_matrix'])
+            transform_parts.append(f"\nAffine Transform Matrix:\n{affine_matrix}")
+            transform_parts.append(f"Translation Vector: {affine_info.get('translation', [])}")
+            transform_parts.append(f"Determinant: {affine_info.get('determinant', 0):.6f}")
+        
+        self.transform_text.setText('\n'.join(transform_parts))
+    
+    def update_detailed_info(self):
+        """更新详细信息显示"""
+        # 更新头部信息树
+        self.header_tree.clear()
+        
+        if 'header' in self.current_metadata:
+            header_info = self.current_metadata['header']
+            explanations = header_info.get('explanations', {})
+            
+            for key, value in header_info.items():
+                if key == 'explanations':
+                    continue
+                    
+                item = QTreeWidgetItem(self.header_tree)
+                item.setText(0, key)
+                item.setText(1, str(value))
+                item.setText(2, explanations.get(key, ''))
+            
+            # 调整列宽
+            self.header_tree.resizeColumnToContents(0)
+            self.header_tree.resizeColumnToContents(1)
+        
+        # Update complete metadata JSON
+        try:
+            # Use the same type conversion logic as export
+            def convert_numpy_types(obj):
+                if isinstance(obj, dict):
+                    return {key: convert_numpy_types(value) for key, value in obj.items()}
+                elif isinstance(obj, list):
+                    return [convert_numpy_types(item) for item in obj]
+                elif isinstance(obj, np.ndarray):
+                    return obj.tolist()
+                elif isinstance(obj, (np.integer, np.floating)):
+                    return obj.item()
+                elif isinstance(obj, np.bool_):
+                    return bool(obj)
+                elif isinstance(obj, bytes):
+                    return obj.decode('utf-8', errors='ignore').strip('\x00')
+                else:
+                    return obj
+            
+            json_serializable_metadata = convert_numpy_types(self.current_metadata)
+            
+            import json
+            json_text = json.dumps(json_serializable_metadata, ensure_ascii=False, indent=2)
+            self.raw_metadata_text.setText(json_text)
+        except Exception as e:
+            self.raw_metadata_text.setText(f"JSON serialization failed: {str(e)}")
+    
+    def update_labels_info(self):
+        """Update label information display"""
+        if 'labels' not in self.current_metadata:
+            return
+            
+        labels_info = self.current_metadata['labels']
+        
+        # Label detection results
+        is_labels = labels_info.get('is_likely_labels', False)
+        label_count = labels_info.get('label_count', 0)
+        
+        detection_text = f"""Label Image Detection: {'Yes' if is_labels else 'No'}
+Label Count: {label_count}
+All Unique Values: {labels_info.get('unique_values', [])}"""
+        self.label_detection_text.setText(detection_text)
+        
+        # Label statistics table
+        if 'label_statistics' in labels_info:
+            stats = labels_info['label_statistics']
+            
+            self.label_stats_table.setRowCount(len(stats))
+            for i, (label_val, label_stats) in enumerate(stats.items()):
+                self.label_stats_table.setItem(i, 0, QTableWidgetItem(label_val))
+                self.label_stats_table.setItem(i, 1, QTableWidgetItem(str(label_stats['voxel_count'])))
+                self.label_stats_table.setItem(i, 2, QTableWidgetItem(f"{label_stats['percentage']:.2f}"))
+        else:
+            self.label_stats_table.setRowCount(0)
+    
+    def export_metadata(self):
+        """Export metadata to JSON file"""
+        if self.current_metadata is None:
+            QMessageBox.warning(self, "Warning", "No metadata to export")
+            return
+            
+        file_path, _ = QFileDialog.getSaveFileName(
+            self,
+            "Save Metadata",
+            f"{Path(self.file_path.text()).stem}_metadata.json",
+            "JSON Files (*.json);;All Files (*.*)"
+        )
+        
+        if file_path:
+            try:
+                self.nifti_loader.export_metadata_to_json(self.current_metadata, file_path)
+                QMessageBox.information(self, "Success", f"Metadata saved to: {file_path}")
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Error saving metadata: {str(e)}") 

napari_nifti_viewer/napari.yaml

@@ -0,0 +1,10 @@
+name: napari-nifti-viewer
+display_name: NIfTI Viewer
+contributions:
+  commands:
+    - id: napari-nifti-viewer.make_widget
+      python_name: napari_nifti_viewer._widget:NiftiViewerWidget
+      title: Open NIfTI Viewer
+  widgets:
+    - command: napari-nifti-viewer.make_widget
+      display_name: NIfTI Viewer 

napari_nifti_viewer-0.1.0.dist-info/METADATA

@@ -0,0 +1,248 @@
+Metadata-Version: 2.4
+Name: napari-nifti-viewer
+Version: 0.1.0
+Summary: A comprehensive napari plugin for NIfTI file analysis and visualization
+Home-page: https://github.com/yohanchiu/napari-nifti-viewer
+Author: Yohanchiu
+Author-email: Your Name <your.email@example.com>
+Maintainer-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yohanchiu/napari-nifti-viewer
+Project-URL: Bug Tracker, https://github.com/yohanchiu/napari-nifti-viewer/issues
+Project-URL: Documentation, https://github.com/yohanchiu/napari-nifti-viewer/wiki
+Project-URL: Source Code, https://github.com/yohanchiu/napari-nifti-viewer
+Project-URL: Changelog, https://github.com/yohanchiu/napari-nifti-viewer/blob/main/CHANGELOG.md
+Keywords: napari,nifti,neuroimaging,medical imaging,visualization,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: napari
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: napari>=0.4.18
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: nibabel>=5.2.1
+Requires-Dist: qtpy>=2.0.0
+Requires-Dist: magicgui>=0.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# napari-nifti-viewer
+
+A powerful napari plugin for comprehensive NIfTI file analysis and visualization.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![napari hub](https://img.shields.io/endpoint?url=https://api.napari-hub.org/shields/napari-nifti-viewer)](https://napari-hub.org/plugins/napari-nifti-viewer)
+
+## Overview
+
+napari-nifti-viewer is a comprehensive napari plugin specifically designed for reading, analyzing, and visualizing NIfTI (.nii/.nii.gz) files. It provides detailed metadata extraction, intelligent label detection, and seamless integration with napari's visualization capabilities.
+
+## Features
+
+### 🔍 **Complete NIfTI Support**
+- Read .nii and .nii.gz format files
+- Support for NIfTI-1 standard
+- Compatible with both image and label data
+
+### 📊 **Comprehensive Metadata Analysis**
+- Extract complete NIfTI header information (40+ fields)
+- Display affine transformation matrices
+- Show coordinate system information
+- Analyze voxel spacing and orientation
+
+### 🏷️ **Intelligent Label Detection**
+- Automatic label image detection
+- Statistical analysis of label distributions
+- Label value counting and percentage calculations
+
+### 📈 **Data Statistics**
+- Complete data shape and type information
+- Statistical measures (min, max, mean, std)
+- Non-zero voxel counting
+- Unique value analysis
+
+### 💾 **Export Capabilities**
+- Export complete metadata as JSON
+- Preserve all numerical precision
+- Human-readable format
+
+### 🎨 **User-Friendly Interface**
+- Clean, organized tabbed interface
+- Real-time data loading
+- Seamless napari integration
+
+## Interface
+
+The plugin provides a clean, organized interface with three main tabs:
+
+### 📋 File Overview Tab
+Displays basic file information and data statistics including file size, format, data shape, and statistical measures.
+
+### 📊 Detailed Information Tab  
+Shows complete NIfTI header fields and metadata in an organized table format, alongside full JSON metadata export.
+
+### 🏷️ Label Analysis Tab
+Provides intelligent label detection and statistical analysis with automatic identification of label images and distribution analysis.
+
+## Installation
+
+### From PyPI (Recommended)
+```bash
+pip install napari-nifti-viewer
+```
+
+### From Source
+```bash
+git clone https://github.com/yohanchiu/napari-nifti-viewer.git
+cd napari-nifti-viewer
+pip install -e .
+```
+
+## Quick Start
+
+1. **Launch napari** with the plugin installed
+2. **Open the plugin** from the Plugins menu → napari-nifti-viewer
+3. **Load a file** by clicking "Browse..." and selecting a .nii/.nii.gz file
+4. **Explore the data** across three informative tabs:
+   - **File Overview**: Basic information and statistics
+   - **Detailed Info**: Complete NIfTI headers and metadata
+   - **Label Analysis**: Label detection and analysis
+5. **Visualize in napari** by clicking "Load to Napari"
+
+## Usage Examples
+
+### Loading a Medical Image
+```python
+import napari
+from napari_nifti_viewer import NiftiViewerWidget
+
+# Create napari viewer
+viewer = napari.Viewer()
+
+# The plugin will be available in the Plugins menu
+# Or you can add it programmatically:
+widget = NiftiViewerWidget(viewer)
+viewer.window.add_dock_widget(widget, name="NIfTI Viewer")
+```
+
+### Exporting Metadata
+The plugin allows you to export complete metadata including:
+- File information (size, format, version)
+- NIfTI header fields (all 40+ standard fields)
+- Data statistics (shape, type, value ranges)
+- Coordinate system information
+- Affine transformation matrices
+
+## Requirements
+
+- **napari** >= 0.4.18
+- **nibabel** >= 5.2.1
+- **numpy** >= 1.21.0
+- **qtpy** >= 2.0.0
+- **magicgui** >= 0.7.0
+- **Python** >= 3.8
+
+## Supported File Formats
+
+- `.nii` - Uncompressed NIfTI files
+- `.nii.gz` - Compressed NIfTI files
+- Compatible with NIfTI-1 standard
+- Support for both neuroimaging and medical imaging data
+
+## Development
+
+### Setting up Development Environment
+
+```bash
+# Clone the repository
+git clone https://github.com/yohanchiu/napari-nifti-viewer.git
+cd napari-nifti-viewer
+
+# Create virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Run tests
+python -m pytest
+```
+
+### Running Tests
+
+```bash
+# Basic functionality test
+python test_plugin.py
+
+# Test with napari interface
+python test_plugin.py --napari
+```
+
+## Contributing
+
+We welcome contributions! Please see our [Contributing Guidelines](CONTRIBUTING.md) for details.
+
+### Ways to Contribute
+- 🐛 Report bugs
+- 💡 Suggest new features
+- 📝 Improve documentation
+- 🔧 Submit pull requests
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this plugin in your research, please consider citing:
+
+```bibtex
+@software{napari_nifti_viewer,
+  title={napari-nifti-viewer: Comprehensive NIfTI Analysis for napari},
+  author={Qiu Yuheng},
+  year={2024},
+  url={https://github.com/yohanchiu/napari-nifti-viewer}
+}
+```
+
+## Acknowledgments
+
+- Built with [napari](https://napari.org/) - a fast, interactive, multi-dimensional image viewer
+- Uses [nibabel](https://nipy.org/nibabel/) for NIfTI file handling
+- Inspired by the neuroimaging and medical imaging communities
+
+## Support
+
+- 📖 [Documentation](https://github.com/yohanchiu/napari-nifti-viewer/wiki)
+- 🐛 [Issue Tracker](https://github.com/yohanchiu/napari-nifti-viewer/issues)
+- 💬 [Discussions](https://github.com/yohanchiu/napari-nifti-viewer/discussions)
+
+---
+
+Made with ❤️ for the napari and neuroimaging communities 

napari_nifti_viewer-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+napari_nifti_viewer/__init__.py,sha256=upx6vlxvZOUHRc9IU3EYeNRXeoO4EzJ8PVVcBo5lJIM,630
+napari_nifti_viewer/_nifti_loader.py,sha256=iU6ABtYBnhgS_6Qkik4iN6kENTKJ2Z9l9pNAseavnmU,14233
+napari_nifti_viewer/_version.py,sha256=P6PH3l7fy5t1OWdcXmQlxIPx-A6KH00qwtSk1yhMJXA,22
+napari_nifti_viewer/_widget.py,sha256=O1V04RZ-6tMU2iKOLr2fOhlPkZ8TsOQsj7di2CQRtu8,17876
+napari_nifti_viewer/napari.yaml,sha256=GFTP3qRNvs_TjMP9Oam3vehr-oHgVK-Wd8XgNGfUTCY,309
+napari_nifti_viewer-0.1.0.dist-info/METADATA,sha256=zhRAqslWI_VB83YsPmMb8O3Iw35xcffWgEE85FU5h10,8037
+napari_nifti_viewer-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+napari_nifti_viewer-0.1.0.dist-info/entry_points.txt,sha256=tgdov62uBBpxLcafWsh3E6-nj8y-dt-hK-dh8NyWkgM,72
+napari_nifti_viewer-0.1.0.dist-info/top_level.txt,sha256=PDphr8Xssxi-YtMuvhhU_Lcd4lS6wrVu-_LEdOdnWCw,20
+napari_nifti_viewer-0.1.0.dist-info/RECORD,,

napari_nifti_viewer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

napari_nifti_viewer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[napari.manifest]
+napari-nifti-viewer = napari_nifti_viewer:napari.yaml

napari_nifti_viewer-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+napari_nifti_viewer