Upload 96 files

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+images/attention.png filter=lfs diff=lfs merge=lfs -text
+images/comparison_with_others.png filter=lfs diff=lfs merge=lfs -text
+images/distribution.png filter=lfs diff=lfs merge=lfs -text
+images/mask.png filter=lfs diff=lfs merge=lfs -text
+images/network.png filter=lfs diff=lfs merge=lfs -text
+images/our_method.png filter=lfs diff=lfs merge=lfs -text
+images/rhlv.png filter=lfs diff=lfs merge=lfs -text
+images/SHRM_and_HGAM.png filter=lfs diff=lfs merge=lfs -text
+images/traditional_image_inpaint.png filter=lfs diff=lfs merge=lfs -text
+images/workflow.png filter=lfs diff=lfs merge=lfs -text

Attention/heatmap/0007_18.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c70fe8e6b89d3e406feed30c961de206ebfc17d9f71348e25f6831fdcf228f4
+size 5250286

Attention/heatmap/0007_19.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e563ebb27cd6259cd98e9c3f99f4ea3c90cfe7a48226b86f69af5cae7215ce11
+size 4993704

Attention/heatmap/0007_20.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3693893d1a7ccfa83359291b8784f6c12dca2601c0d081df31c31ef062e758a1
+size 5364097

Attention/heatmap/0007_21.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:16dcc11eb548ebdbfcc84fccb826a5707b987379b32d10e05056beba6db3fb5a
+size 5114208

Attention/heatmap/0007_22.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0a8da6028142d200104a8f747a8acaac39499d36c5a64f982d190e3f9fb194c
+size 4997935

Attention/heatmap/0007_23.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4d9b6c372b30477a4875dec40409cde9f0112df8359521942c5f95a7990d0ee
+size 4989910

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Qi Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,202 @@
----
-license: cc-by-nc-sa-4.0
----
+# HealthiVert-GAN: Pseudo-Healthy Vertebral Image Synthesis for Interpretable Compression Fracture Grading
+
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+**HealthiVert-GAN** is a novel framework for synthesizing pseudo-healthy vertebral CT images from fractured vertebrae. By simulating pre-fracture states, it enables interpretable quantification of vertebral compression fractures (VCFs) through **Relative Height Loss of Vertebrae (RHLV)**. The model integrates a two-stage GAN architecture with anatomical consistency modules, achieving state-of-the-art performance on both public and private datasets.
+
+---
+
+## 🚀 Key Features
+- **Two-Stage Synthesis**: Coarse-to-fine generation with 2.5D sagittal/coronal fusion.
+- **Anatomic Modules**:
+  - **Edge-Enhancing Module (EEM)**: Captures precise vertebral morphology.
+  - **Self-adaptive Height Restoration Module (SHRM)**: Predicts healthy vertebral height adaptively.
+  - **HealthiVert-Guided Attention Module (HGAM)**: Focuses on non-fractured regions via Grad-CAM++.
+- **Iterative Synthesis**: Generates adjacent vertebrae first to minimize fracture interference.
+- **RHLV Quantification**: Measures height loss in anterior/middle/posterior regions for SVM-based Genant grading.
+
+---
+
+## 🛠️ Architecture
+
+![Workflow](images/workflow.png)
+
+### Workflow
+1. **Preprocessing**: 
+   - **Spine Straightening**: Align vertebrae vertically using SCNet segmentation.
+   - **De-pedicle**: Remove vertebral arches for body-focused analysis.
+   - **Masking**: Replace target vertebra with a fixed-height mask (40mm).
+   
+2. **Two-Stage Generation**:
+   - **Coarse Generator**: Outputs initial CT and segments adjacent vertebrae.
+   - **Refinement Generator**: Enhances details with contextual attention and edge loss.
+
+3. **Iterative Synthesis**:
+   - Step 1: Synthesize adjacent vertebrae.
+   - Step 2: Generate target vertebra using Step 1 results.
+
+4. **RHLV Calculation**:
+   ```math
+   RHLV = \frac{H_{syn} - H_{ori}}{H_{syn}}
+   ```
+   Segments vertebra into anterior/middle/posterior regions for detailed analysis.
+
+   **SVM Classification**: Uses RHLV values to classify fractures into mild/moderate/severe.
+
+### 🔑 Key Contributions
+![comparisons](images/comparison_with_others.png)
+1. **Interpretable Quantification Beyond Black-Box Models**  
+   Traditional end-to-end fracture classification models suffer from class imbalance and lack interpretability. HealthiVert-GAN addresses these by synthesizing pseudo-healthy vertebrae and quantifying height loss (RHLV) between generated and original vertebrae. This approach achieves superior performance (e.g., **72.3% Macro-F1** on Verse2019) while providing transparent metrics for clinical decisions.
+
+2. **Height Loss Distribution Mapping for Surgical Planning**  
+   HealthiVert-GAN generates cross-sectional height loss heatmaps that visualize compression patterns (wedge/biconcave/crush fractures). Clinicians can use these maps to assess fracture stability and plan interventions (e.g., vertebroplasty) with precision unmatched by single-slice methods.
+
+3. **Anatomic Prior Integration**  
+   Unlike conventional inpainting models, HealthiVert-GAN introduces adjacent vertebrae height variations as prior knowledge. The **Self-adaptive Height Restoration Module (SHRM)** dynamically adjusts generated vertebral heights based on neighboring healthy vertebrae, improving both interpretability and anatomic consistency.
+
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+git clone https://github.com/zhibaishouheilab/HealthiVert-GAN.git
+cd HealthiVert-GAN
+pip install -r requirements.txt  # PyTorch, NiBabel, SimpleITK, OpenCV
+```
+
+### Data Preparation
+
+#### Dataset Structure
+Organize data as:
+
+```
+/dataset/
+  ├── raw
+      ├── 0001/
+      │   ├── 0001.nii.gz    # Original CT
+      │   └── 0001_msk.nii.gz   # Vertebrae segmentation
+      └── 0002/
+          ├── 0002.nii.gz
+          └── 0002_msk.nii.gz
+```
+**Note**: You have to segment the vertebra firstly. Refer to [CTSpine1K-nnUNet](https://github.com/MIRACLE-Center/CTSpine1K) to obtain how to segment using nnU-Net.
+
+#### Preprocessing
+
+**Spine Straightening**:
+
+```bash
+python straighten/location_json_local.py  # Generate vertebral centroids
+python straighten/straighten_mask_3d.py   # Output: ./dataset/straightened/
+```
+
+**Attention Map Generation**:
+
+```bash
+python Attention/grad_CAM_3d_sagittal.py  # Output: ./Attention/heatmap/
+```
+
+### Training
+
+**Configure JSON**:
+
+Update `vertebra_data.json` with patient IDs, labels, and paths.
+
+**Train Model**:
+
+```bash
+python train.py \
+  --dataroot ./dataset/straightened \
+  --name HealthiVert_experiment \
+  --model pix2pix \
+  --direction BtoA \
+  --batch_size 16 \
+  --n_epochs 1000
+```
+
+Checkpoints saved in `./checkpoints/HealthiVert_experiment`.
+The pretrained weights will be released later.
+
+### Inference
+
+**Generate Pseudo-Healthy Vertebrae**:
+
+```bash
+python eval_3d_sagittal_twostage.py # define the parameters in the code file
+```
+
+Outputs: `./output/CT_fake/` and `./output/label_fake/`.
+
+**Fracture Grading**
+
+**Calculate RHLV**:
+
+```bash
+python evaluation/RHLV_quantification.py 
+```
+
+**Train SVM Classifier**:
+
+```bash
+python evaluation/SVM_grading.py
+```
+
+**Evaluate generation results**:
+```bash
+python evaluation/generation_eval_sagittal.py
+```
+---
+
+## 📊 Results
+
+### Qualitative Comparison
+The generation visulization of different masking strategies.
+![different strategies](images/mask.png)
+
+The visulization heatmap of vertebral height loss distribution in axial view, and the curve of height loss.
+![distribution](images/distribution.png)
+
+### Quantitative Performance (Verse2019 Dataset)
+
+| Metric      | HealthiVert-GAN |   AOT-GAN |3D SupCon-SENet|
+|-------------|-----------------|--------------|------------------|
+| Macro-P     | 0.727           | 0.710        | 0.710            |
+| Macro-R     | 0.753           | 0.707        | 0.636            |
+| Macro-F1    | 0.723           | 0.692        | 0.667            |
+
+Comparison model codes:
+[AOT-GAN](https://github.com/researchmm/AOT-GAN-for-Inpainting)
+[3D SupCon-SENet](https://github.com/wxwxwwxxx/VertebralFractureGrading)
+
+---
+
+## 📜 Citation
+
+```bibtex
+@misc{zhang2025healthivertgannovelframeworkpseudohealthy,
+      title={HealthiVert-GAN: A Novel Framework of Pseudo-Healthy Vertebral Image Synthesis for Interpretable Compression Fracture Grading}, 
+      author={Qi Zhang and Shunan Zhang and Ziqi Zhao and Kun Wang and Jun Xu and Jianqi Sun},
+      year={2025},
+      eprint={2503.05990},
+      archivePrefix={arXiv},
+      primaryClass={eess.IV},
+      url={https://arxiv.org/abs/2503.05990}, 
+}
+```
+
+## 📧 Contact
+If you have any questions about the codes or paper, please let us know via [[email protected]]([email protected]).
+
+---
+
+## 🙇‍ Acknowledgment
+- Thank Febian's [nnUnet](https://github.com/MIC-DKFZ/nnUNet).
+- Thank Deng's shared dataset [CTSpine 1K](https://github.com/MIRACLE-Center/CTSpine1K?tab=readme-ov-file) and their pretrained nnUNet's weights.
+- Thank [NeuroML](https://github.com/neuro-ml/straighten) that released the spine straightening algorithm.
+
+## 📄 License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE) for details.

data/__init__.py

@@ -0,0 +1,93 @@
+"""This package includes all the modules related to data loading and preprocessing
+
+ To add a custom dataset class called 'dummy', you need to add a file called 'dummy_dataset.py' and define a subclass 'DummyDataset' inherited from BaseDataset.
+ You need to implement four functions:
+    -- <__init__>:                      initialize the class, first call BaseDataset.__init__(self, opt).
+    -- <__len__>:                       return the size of dataset.
+    -- <__getitem__>:                   get a data point from data loader.
+    -- <modify_commandline_options>:    (optionally) add dataset-specific options and set default options.
+
+Now you can use the dataset class by specifying flag '--dataset_mode dummy'.
+See our template dataset class 'template_dataset.py' for more details.
+"""
+import importlib
+import torch.utils.data
+from data.base_dataset import BaseDataset
+
+
+def find_dataset_using_name(dataset_name):
+    """Import the module "data/[dataset_name]_dataset.py".
+
+    In the file, the class called DatasetNameDataset() will
+    be instantiated. It has to be a subclass of BaseDataset,
+    and it is case-insensitive.
+    """
+    dataset_filename = "data." + dataset_name + "_dataset"
+    datasetlib = importlib.import_module(dataset_filename)
+
+    dataset = None
+    target_dataset_name = dataset_name.replace('_', '') + 'dataset'
+    for name, cls in datasetlib.__dict__.items():
+        if name.lower() == target_dataset_name.lower() \
+           and issubclass(cls, BaseDataset):
+            dataset = cls
+
+    if dataset is None:
+        raise NotImplementedError("In %s.py, there should be a subclass of BaseDataset with class name that matches %s in lowercase." % (dataset_filename, target_dataset_name))
+
+    return dataset
+
+
+def get_option_setter(dataset_name):
+    """Return the static method <modify_commandline_options> of the dataset class."""
+    dataset_class = find_dataset_using_name(dataset_name)
+    return dataset_class.modify_commandline_options
+
+
+def create_dataset(opt):
+    """Create a dataset given the option.
+
+    This function wraps the class CustomDatasetDataLoader.
+        This is the main interface between this package and 'train.py'/'test.py'
+
+    Example:
+        >>> from data import create_dataset
+        >>> dataset = create_dataset(opt)
+    """
+    data_loader = CustomDatasetDataLoader(opt)
+    dataset = data_loader.load_data()
+    return dataset
+
+
+class CustomDatasetDataLoader():
+    """Wrapper class of Dataset class that performs multi-threaded data loading"""
+
+    def __init__(self, opt):
+        """Initialize this class
+
+        Step 1: create a dataset instance given the name [dataset_mode]
+        Step 2: create a multi-threaded data loader.
+        """
+        self.opt = opt
+        dataset_class = find_dataset_using_name(opt.dataset_mode)
+        self.dataset = dataset_class(opt)
+        print("dataset [%s] was created" % type(self.dataset).__name__)
+        self.dataloader = torch.utils.data.DataLoader(
+            self.dataset,
+            batch_size=opt.batch_size,
+            shuffle=not opt.serial_batches,
+            num_workers=int(opt.num_threads))
+
+    def load_data(self):
+        return self
+
+    def __len__(self):
+        """Return the number of data in the dataset"""
+        return min(len(self.dataset), self.opt.max_dataset_size)
+
+    def __iter__(self):
+        """Return a batch of data"""
+        for i, data in enumerate(self.dataloader):
+            if i * self.opt.batch_size >= self.opt.max_dataset_size:
+                break
+            yield data

data/aligned_dataset.py

@@ -0,0 +1,300 @@
+#假设读入的数据是nii格式的
+# 用于coronal角度数据的读取
+
+import os
+from data.base_dataset import BaseDataset, get_params, get_transform
+from data.image_folder import make_dataset
+from PIL import Image
+import numpy as np
+import torch
+from .mask_extract import process_spine_data, process_spine_data_aug
+import json
+import nibabel as nib
+import random
+import torchvision.transforms as transforms
+from scipy.ndimage import label, find_objects
+
+def remove_small_connected_components(input_array, min_size):
+
+
+    # 识别连通域
+    structure = np.ones((3, 3), dtype=np.int32)  # 定义连通性结构
+    labeled, ncomponents = label(input_array, structure)
+
+    # 遍历所有连通域，如果连通域大小小于阈值，则去除
+    for i in range(1, ncomponents + 1):
+        if np.sum(labeled == i) < min_size:
+            input_array[labeled == i] = 0
+
+    # 如果输入是张量，则转换回张量
+
+    return input_array
+
+
+class AlignedDataset(BaseDataset):
+    """A dataset class for paired image dataset.
+
+    It assumes that the directory '/path/to/data/train' contains image pairs in the form of {A,B}.
+    During test time, you need to prepare a directory '/path/to/data/test'.
+    """
+
+    def __init__(self, opt):
+        """Initialize this dataset class.
+
+        Parameters:
+            opt (Option class) -- stores all the experiment flags; needs to be a subclass of BaseOptions
+        """
+        BaseDataset.__init__(self, opt)
+        
+        # 读取json文件来选择训练集、测试集和验证集
+        with open('/home/zhangqi/Project/pytorch-CycleGAN-and-pix2pix-master/data/vertebra_data.json', 'r') as file:
+            vertebra_set = json.load(file)
+            self.normal_vert_list = []
+            self.abnormal_vert_list = []
+        # 初始化存储normal和abnormal vertebrae的字典
+        self.normal_vert_dict = {}
+        self.abnormal_vert_dict = {}
+
+        for patient_vert_id in vertebra_set[opt.phase].keys():
+        # 分离patient id和vert id
+            patient_id, vert_id = patient_vert_id.rsplit('_',1)
+        
+        # 判断该vertebra是normal还是abnormal
+            if int(vertebra_set[opt.phase][patient_vert_id]) <= 1:
+                self.normal_vert_list.append(patient_vert_id)
+            # 如果是normal，添加到normal_vert_dict
+                if patient_id not in self.normal_vert_dict:
+                    self.normal_vert_dict[patient_id] = [vert_id]
+                else:
+                    self.normal_vert_dict[patient_id].append(vert_id)
+            else:
+                self.abnormal_vert_list.append(patient_vert_id)
+            # 如果是abnormal，添加到abnormal_vert_dict
+                if patient_id not in self.abnormal_vert_dict:
+                    self.abnormal_vert_dict[patient_id] = [vert_id]
+                else:
+                    self.abnormal_vert_dict[patient_id].append(vert_id)
+            if opt.vert_class=="normal":
+                self.vertebra_id = np.array(self.normal_vert_list)
+            elif opt.vert_class=="abnormal":
+                self.vertebra_id = np.array(self.abnormal_vert_list)
+            else:
+                print("No vert class is set.")
+                self.vertebra_id = None
+    
+        #self.dir_AB = os.path.join(opt.dataroot, opt.phase)  # get the image directory
+        self.dir_AB = opt.dataroot
+        #self.dir_mask = os.path.join(opt.dataroot,'mask',opt.phase) 
+        #self.AB_paths = sorted(make_dataset(self.dir_AB, opt.max_dataset_size))  # get image paths
+        #self.mask_paths = sorted(make_dataset(self.dir_mask, opt.max_dataset_size)) 
+        assert(self.opt.load_size >= self.opt.crop_size)   # crop_size should be smaller than the size of loaded image
+        self.input_nc = self.opt.output_nc if self.opt.direction == 'BtoA' else self.opt.input_nc
+        self.output_nc = self.opt.input_nc if self.opt.direction == 'BtoA' else self.opt.output_nc
+        
+    def numpy_to_pil(self,img_np):
+        # 假设 img_np 是一个灰度图像的 NumPy 数组，值域在0到255
+        if img_np.dtype != np.uint8:
+            raise ValueError("NumPy array should have uint8 data type.")
+        # 转换为灰度PIL图像
+        img_pil = Image.fromarray(img_np)
+        return img_pil
+    
+
+
+    # 按照金字塔概率选择一个slice，毕竟中间的slice包含的信息是最多的，因此尽量选择中间的slice
+    # 按照金字塔概率选择一个slice，毕竟中间的slice包含的信息是最多的，因此尽量选择中间的slice
+    def get_weighted_random_slice(self,z0, z1):
+        # 计算新的范围，限制为原来范围的2/3
+        range_length = z1 - z0 + 1
+        new_range_length = int(range_length * 4 / 5)
+    
+    # 计算新范围的起始和结束索引
+        new_z0 = z0 + (range_length - new_range_length) // 2
+        new_z1 = new_z0 + new_range_length - 1
+    
+    # 计算中心索引
+        center_index = (new_z0 + new_z1) // 2
+    
+    # 计算每个索引的权重
+        weights = [1 - abs(i - center_index) / (new_z1 - new_z0) for i in range(new_z0, new_z1 + 1)]
+    
+        # 归一化权重使得总和为1
+        total_weight = sum(weights)
+        normalized_weights = [w / total_weight for w in weights]
+    
+    # 根据权重随机选择一个层
+        random_index = np.random.choice(range(new_z0, new_z1 + 1), p=normalized_weights)
+        index_ratio = abs(random_index-center_index)/range_length*2
+    
+        return random_index,index_ratio
+    
+    def get_valid_slice(self,vert_label, z0, z1,maxheight):
+        """
+        尝试随机选取一个非空的slice。
+        """
+        max_attempts = 100  # 设定最大尝试次数以避免无限循环
+        attempts = 0
+        while attempts < max_attempts:
+            slice_index,index_ratio = self.get_weighted_random_slice(z0, z1)
+            vert_label[:, slice_index, :] = remove_small_connected_components(vert_label[:, slice_index, :],50)
+
+            if np.sum(vert_label[:, slice_index, :])>50:  # 检查切片是否非空
+                coords = np.argwhere(vert_label[:, slice_index, :])
+                x1, x2 = min(coords[:, 0]), max(coords[:, 0])
+                if x2-x1<maxheight:
+                    return slice_index,index_ratio
+            attempts += 1
+        raise ValueError("Failed to find a non-empty slice after {} attempts.".format(max_attempts))
+
+
+    def __getitem__(self, index):
+        """Return a data point and its metadata information.
+
+        Parameters:
+            index - - a random integer for data indexing
+
+        Returns a dictionary that contains A, B, A_paths and B_paths
+            A (tensor) - - an image in the input domain
+            B (tensor) - - its corresponding image in the target domain
+            A_paths (str) - - image paths
+            B_paths (str) - - image paths (same as A_paths)
+        """
+        # read a image given a random integer index
+        CAM_folder = '/home/zhangqi/Project/VertebralFractureGrading/heatmap/straighten_coronal/binaryclass_1'
+        CAM_path_0 = os.path.join(CAM_folder, self.vertebra_id[index]+'_0.nii.gz')
+        CAM_path_1 = os.path.join(CAM_folder, self.vertebra_id[index]+'_1.nii.gz')
+        if not os.path.exists(CAM_path_0):
+            CAM_path = CAM_path_1
+        else:
+            CAM_path = CAM_path_0
+        CAM_data = nib.load(CAM_path).get_fdata() * 255
+        
+
+        patient_id, vert_id = self.vertebra_id[index].rsplit('_', 1)
+        vert_id = int(vert_id)
+        normal_vert_list = self.normal_vert_dict[patient_id]
+
+
+        ct_path = os.path.join(self.dir_AB,"CT",self.vertebra_id[index]+'.nii.gz')
+
+        label_path = os.path.join(self.dir_AB,"label",self.vertebra_id[index]+'.nii.gz')
+
+        ct_data = nib.load(ct_path).get_fdata()
+        label_data = nib.load(label_path).get_fdata()
+        vert_label = np.zeros_like(label_data)
+        vert_label[label_data==vert_id]=1
+        
+        normal_vert_label = label_data.copy()
+        if normal_vert_list:
+            for normal_vert in normal_vert_list:
+                normal_vert_label[normal_vert_label==int(normal_vert)]=255
+            normal_vert_label[normal_vert_label!=255]=0
+        else:
+            normal_vert_label = np.zeros_like(label_data)
+
+        loc = np.where(vert_label)
+    
+        # 冠状面选择
+        z0 = min(loc[1])
+        z1 = max(loc[1])
+        maxheight = 40
+        
+        try:
+            slice,slice_ratio = self.get_valid_slice(vert_label, z0, z1, maxheight)
+            #vert_label[:, :, slice] = remove_small_connected_components(vert_label[:, :, slice],50)
+            coords = np.argwhere(vert_label[:, slice, :])
+            x1, x2 = min(coords[:, 0]), max(coords[:, 0])
+        except ValueError as e:
+            print(e)
+        width,length = vert_label[:,slice,:].shape
+        
+        height = x2-x1
+        mask_x = (x1+x2)//2
+        h2 = maxheight
+        if height>h2:
+            print(slice,ct_path)
+        if mask_x<=h2//2:
+            min_x = 0
+            max_x = min_x + h2
+        elif width-mask_x<=h2/2:
+            max_x = width
+            min_x = max_x -h2
+        else:
+            min_x = mask_x-h2//2
+            max_x = min_x + h2
+
+        
+        # 创建256x256的空白数组
+        target_A = np.zeros((256, 256))
+        target_B = np.zeros((256, 256))
+        target_A1 = np.zeros((256, 256))
+        target_normal_vert_label = np.zeros((256, 256))
+        target_mask = np.zeros((256, 256))
+        target_CAM = np.zeros((256, 256))
+
+# 定位原切片放置的起始和结束列
+        start_col = (256 - 64) // 2
+        end_col = start_col + 64
+
+# 对于A，直接从ct_data中取切片，然后放置到target_A中
+        
+        target_B[:min_x, start_col:end_col] = ct_data[(x1-min_x):x1, slice, :]
+        target_B[max_x:, start_col:end_col] = ct_data[x2:x2+(width-max_x), slice, :]
+        
+        target_A[:, start_col:end_col] = ct_data[:,slice,:]
+
+# ���理A1，将label_data中特定ID的位置设为255，其他为0
+        A1 = np.zeros_like(label_data[:, slice, :])
+        A1[label_data[:, slice, :] == vert_id] = 255
+        target_A1[:, start_col:end_col] = A1
+
+# 处理normal_vert_label
+        target_normal_vert_label[:min_x, start_col:end_col] = normal_vert_label[(x1-min_x):x1, slice, :]
+        target_normal_vert_label[max_x:, start_col:end_col] = normal_vert_label[x2:x2+(width-max_x), slice, :]
+
+# 处理mask
+        target_mask[min_x:max_x, start_col:end_col] = 255
+        target_CAM[:min_x, start_col:end_col] = CAM_data[(x1-min_x):x1, slice, :]
+        target_CAM[max_x:, start_col:end_col] = CAM_data[x2:x2+(width-max_x), slice, :]
+        
+        target_A = target_A.astype(np.uint8)
+        target_B = target_B.astype(np.uint8)
+        target_A1 = target_A1.astype(np.uint8)
+        target_normal_vert_label = target_normal_vert_label.astype(np.uint8)
+        target_mask = target_mask.astype(np.uint8)
+        target_CAM = target_CAM.astype(np.uint8)
+        
+
+        target_A = self.numpy_to_pil(target_A)
+        target_B = self.numpy_to_pil(target_B)
+        target_A1 = self.numpy_to_pil(target_A1)
+        target_mask = self.numpy_to_pil(target_mask)
+        target_normal_vert_label = self.numpy_to_pil(target_normal_vert_label)
+        target_CAM = self.numpy_to_pil(target_CAM)
+            
+        # apply the same transform to both A and B
+        A_transform =transforms.Compose([
+            transforms.Grayscale(1),
+            transforms.ToTensor(),
+            transforms.Normalize((0.5,), (0.5,))
+        ])
+        
+        mask_transform = transforms.Compose([
+            transforms.ToTensor()
+        ])
+
+        target_A = A_transform(target_A)
+        target_B = A_transform(target_B)
+        target_A1 = mask_transform(target_A1)
+        target_mask = mask_transform(target_mask)
+        target_normal_vert_label = mask_transform(target_normal_vert_label)
+        target_CAM = mask_transform(target_CAM)
+
+        
+        
+        return {'A': target_A, 'A_mask': target_A1, 'mask':target_mask,'B':target_B,'height':height,'x1':x1,'x2':x2,
+                'h2':h2,'slice_ratio':slice_ratio,'normal_vert':target_normal_vert_label,'CAM':target_CAM,'A_paths': ct_path, 'B_paths': ct_path}
+
+    def __len__(self):
+        """Return the total number of images in the dataset."""
+        return len(self.vertebra_id)

data/base_dataset.py

@@ -0,0 +1,169 @@
+"""This module implements an abstract base class (ABC) 'BaseDataset' for datasets.
+
+It also includes common transformation functions (e.g., get_transform, __scale_width), which can be later used in subclasses.
+"""
+import random
+import numpy as np
+import torch.utils.data as data
+from PIL import Image
+import torchvision.transforms as transforms
+from abc import ABC, abstractmethod
+import torch
+
+
+class BaseDataset(data.Dataset, ABC):
+    """This class is an abstract base class (ABC) for datasets.
+
+    To create a subclass, you need to implement the following four functions:
+    -- <__init__>:                      initialize the class, first call BaseDataset.__init__(self, opt).
+    -- <__len__>:                       return the size of dataset.
+    -- <__getitem__>:                   get a data point.
+    -- <modify_commandline_options>:    (optionally) add dataset-specific options and set default options.
+    """
+
+    def __init__(self, opt):
+        """Initialize the class; save the options in the class
+
+        Parameters:
+            opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
+        """
+        self.opt = opt
+        self.root = opt.dataroot
+
+    @staticmethod
+    def modify_commandline_options(parser, is_train):
+        """Add new dataset-specific options, and rewrite default values for existing options.
+
+        Parameters:
+            parser          -- original option parser
+            is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.
+
+        Returns:
+            the modified parser.
+        """
+        return parser
+
+    @abstractmethod
+    def __len__(self):
+        """Return the total number of images in the dataset."""
+        return 0
+
+    @abstractmethod
+    def __getitem__(self, index):
+        """Return a data point and its metadata information.
+
+        Parameters:
+            index - - a random integer for data indexing
+
+        Returns:
+            a dictionary of data with their names. It ususally contains the data itself and its metadata information.
+        """
+        pass
+
+
+def get_params(opt, size):
+    w, h = size
+    new_h = h
+    new_w = w
+    if opt.preprocess == 'resize_and_crop':
+        new_h = new_w = opt.load_size
+    elif opt.preprocess == 'scale_width_and_crop':
+        new_w = opt.load_size
+        new_h = opt.load_size * h // w
+
+    x = random.randint(0, np.maximum(0, new_w - opt.crop_size))
+    y = random.randint(0, np.maximum(0, new_h - opt.crop_size))
+
+    flip = random.random() > 0.5
+
+    return {'crop_pos': (x, y), 'flip': flip}
+
+
+def get_transform(opt, params=None, grayscale=False, method=transforms.InterpolationMode.BICUBIC, convert=True,normalize=True):
+    transform_list = []
+    if grayscale:
+        transform_list.append(transforms.Grayscale(1))
+    if 'resize' in opt.preprocess:
+        osize = [opt.load_size, opt.load_size]
+        transform_list.append(transforms.Resize(osize, method))
+    elif 'scale_width' in opt.preprocess:
+        transform_list.append(transforms.Lambda(lambda img: __scale_width(img, opt.load_size, opt.crop_size, method)))
+
+    if 'crop' in opt.preprocess:
+        if params is None:
+            transform_list.append(transforms.RandomCrop(opt.crop_size))
+        else:
+            transform_list.append(transforms.Lambda(lambda img: __crop(img, params['crop_pos'], opt.crop_size)))
+
+    if opt.preprocess == 'none':
+        transform_list.append(transforms.Lambda(lambda img: __make_power_2(img, base=4, method=method)))
+
+    if not opt.no_flip:
+        if params is None:
+            transform_list.append(transforms.RandomHorizontalFlip())
+        elif params['flip']:
+            transform_list.append(transforms.Lambda(lambda img: __flip(img, params['flip'])))
+
+    if convert:
+        transform_list += [transforms.ToTensor()]
+        if normalize:
+            if grayscale:
+                transform_list += [transforms.Normalize((0.5,), (0.5,))]
+            else:
+                transform_list += [transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]
+    return transforms.Compose(transform_list)
+
+
+def __transforms2pil_resize(method):
+    mapper = {transforms.InterpolationMode.BILINEAR: Image.BILINEAR,
+              transforms.InterpolationMode.BICUBIC: Image.BICUBIC,
+              transforms.InterpolationMode.NEAREST: Image.NEAREST,
+              transforms.InterpolationMode.LANCZOS: Image.LANCZOS,}
+    return mapper[method]
+
+
+def __make_power_2(img, base, method=transforms.InterpolationMode.BICUBIC):
+    method = __transforms2pil_resize(method)
+    ow, oh = img.size
+    h = int(round(oh / base) * base)
+    w = int(round(ow / base) * base)
+    if h == oh and w == ow:
+        return img
+
+    __print_size_warning(ow, oh, w, h)
+    return img.resize((w, h), method)
+
+
+def __scale_width(img, target_size, crop_size, method=transforms.InterpolationMode.BICUBIC):
+    method = __transforms2pil_resize(method)
+    ow, oh = img.size
+    if ow == target_size and oh >= crop_size:
+        return img
+    w = target_size
+    h = int(max(target_size * oh / ow, crop_size))
+    return img.resize((w, h), method)
+
+
+def __crop(img, pos, size):
+    ow, oh = img.size
+    x1, y1 = pos
+    tw = th = size
+    if (ow > tw or oh > th):
+        return img.crop((x1, y1, x1 + tw, y1 + th))
+    return img
+
+
+def __flip(img, flip):
+    if flip:
+        return img.transpose(Image.FLIP_LEFT_RIGHT)
+    return img
+
+
+def __print_size_warning(ow, oh, w, h):
+    """Print warning information about image size(only print once)"""
+    if not hasattr(__print_size_warning, 'has_printed'):
+        print("The image size needs to be a multiple of 4. "
+              "The loaded image size was (%d, %d), so it was adjusted to "
+              "(%d, %d). This adjustment will be done to all images "
+              "whose sizes are not multiples of 4" % (ow, oh, w, h))
+        __print_size_warning.has_printed = True

data/image_folder.py

@@ -0,0 +1,65 @@
+"""A modified image folder class
+
+We modify the official PyTorch image folder (https://github.com/pytorch/vision/blob/master/torchvision/datasets/folder.py)
+so that this class can load images from both current directory and its subdirectories.
+"""
+
+import torch.utils.data as data
+
+from PIL import Image
+import os
+
+IMG_EXTENSIONS = [
+    '.jpg', '.JPG', '.jpeg', '.JPEG',
+    '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP',
+    '.tif', '.TIF', '.tiff', '.TIFF',
+]
+
+
+def is_image_file(filename):
+    return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
+
+
+def make_dataset(dir, max_dataset_size=float("inf")):
+    images = []
+    assert os.path.isdir(dir), '%s is not a valid directory' % dir
+
+    for root, _, fnames in sorted(os.walk(dir)):
+        for fname in fnames:
+            if is_image_file(fname) and "_label" not in fname:
+                path = os.path.join(root, fname)
+                images.append(path)
+    return images[:min(max_dataset_size, len(images))]
+
+
+def default_loader(path):
+    return Image.open(path).convert('RGB')
+
+
+class ImageFolder(data.Dataset):
+
+    def __init__(self, root, transform=None, return_paths=False,
+                 loader=default_loader):
+        imgs = make_dataset(root)
+        if len(imgs) == 0:
+            raise(RuntimeError("Found 0 images in: " + root + "\n"
+                               "Supported image extensions are: " + ",".join(IMG_EXTENSIONS)))
+
+        self.root = root
+        self.imgs = imgs
+        self.transform = transform
+        self.return_paths = return_paths
+        self.loader = loader
+
+    def __getitem__(self, index):
+        path = self.imgs[index]
+        img = self.loader(path)
+        if self.transform is not None:
+            img = self.transform(img)
+        if self.return_paths:
+            return img, path
+        else:
+            return img
+
+    def __len__(self):
+        return len(self.imgs)

data/mask_extract.py

@@ -0,0 +1,346 @@
+#coding:utf-8
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
+import numpy as np
+import nibabel as nib
+from PIL import Image
+from skimage import morphology
+from skimage.transform import resize
+import cv2
+import os
+import numpy as np
+from skimage import measure
+import skimage
+import numpy.random as npr
+
+def get_vertbody(seg0):
+    y = []
+    count = []
+    seg = skimage.morphology.dilation(seg0, skimage.morphology.square(2))
+    label, num = measure.label(seg, connectivity=2, background=0, return_num=True)
+    out = np.zeros(label.shape)
+    loc_list = []
+    for i in range(1, num + 1):
+        loc = np.where(label == i)
+        loc_list.append(loc)
+        count.append(loc[0].shape[0])
+        y.append(min(list(loc[1])))
+    if num == 1:
+        print("number=1")
+        Num = 0
+        countbody = np.sum(label)
+    else:
+        i = np.argsort(np.array(count))
+        if y[i[-1]] < y[i[-2]] or count[i[-2]] < 30:
+
+            Num = i[-1]
+            countbody = count[i[-1]]
+        else:
+            Num = i[-2]
+            countbody = count[i[-2]]
+
+    out[loc_list[Num]] = 1
+    xx = np.max(loc_list[Num][0])
+    xi = np.min(loc_list[Num][0])
+    yx = np.max(loc_list[Num][1])
+    yi = np.min(loc_list[Num][1])
+    xm = np.mean(loc_list[Num][0])
+    ym = np.mean(loc_list[Num][1])
+    out2 = np.zeros((60,60))
+    out = out*seg0
+    out2[2:3+xx-xi,2:3+yx-yi] = out[xi:xx+1,yi:yx+1]
+    return out2,out,np.array([xm,ym])
+
+def window(img,win_min,win_max):
+    #骨窗窗宽窗位
+    imgmax = np.max(img)
+    imgmin = np.min(img)
+    if imgmax<win_max and imgmin>win_min:
+        return img
+    for i in range(img.shape[0]):
+        img[i] = 255.0 * (img[i] - win_min) / (win_max - win_min)
+        min_index = img[i] < 0
+        img[i][min_index] = 0
+        max_index = img[i] > 255
+        img[i][max_index] = 255
+    return img
+
+# 采取最小旋转矩形框，使用固定scale即不进行扩增
+def process_spine_data(ct_path,label_path,label_id,output_size):
+
+        # 读取CT数据和标注数据
+        #ct_data = nib.load(ct_path).get_fdata()
+        #label_data = nib.load(label_path).get_fdata()
+        ct_data = np.load(ct_path)
+        label_data = np.load(label_path)
+        binary_label = label_data.copy()
+        binary_label[binary_label!=0]=255
+        
+        
+        # 进行归一化并*255
+        ct_data =  window(ct_data, -300, 800)
+
+        label = int(label_id)
+            
+        
+        loc = np.where(label_data == label)
+        
+        #if np.isnan(loc[2]):
+        #    print(ct_path,label)
+
+        try:
+            center_z = int(np.mean(loc[2]))
+        except:
+            print("发生 ValueError 异常")
+            print("loc 的值为:", loc)
+            print(ct_path,label)
+        _, _, center_z = np.array(np.where(label_data == label)).mean(axis=1).astype(int)
+
+            
+        # 对中间层面的椎体去除横突
+        label_binary = np.zeros(label_data.shape)
+        label_binary[loc] = 1
+        y0 = min(loc[1])
+        y1 = max(loc[1])
+        z0 = min(loc[0])
+        z1 = max(loc[0])
+
+        img2d = label_binary[z0:z1 + 1, y0:y1 + 1, center_z]
+            
+        _, img2d_vertbody, center_point = get_vertbody(img2d)
+
+            
+        img2d_vertbody_points = np.where(img2d_vertbody==1)
+        img2d_vertbody_aligned=np.zeros_like(label_data[:,:,0], np.uint8)
+        # 如果将GT改为生成椎体mask，这样子就不需要纹理灰度信息了
+        img2d_vertbody_aligned[img2d_vertbody_points[0]+z0,img2d_vertbody_points[1]+y0]=1
+            
+        # 计算椎体的中心位置
+        center_y,center_x = int(np.mean(img2d_vertbody_points[0])+z0),int(np.mean(img2d_vertbody_points[1])+y0)
+
+        # 截取224x224的矩形框在中心层面
+        center_slice = ct_data[:, :, center_z].copy()
+        center_label_slice = binary_label[:, :, center_z].copy()
+ 
+        # 创建224x224的矩形框
+        rect_slice = np.zeros(output_size, dtype=np.uint8)
+        rect_label_slice = np.zeros(output_size, dtype=np.uint8)
+
+        # 计算矩形框的位置
+        min_y, max_y = max(0, output_size[0]//2 - center_y), min(output_size[0], output_size[0]//2 + (center_slice.shape[0] - center_y))
+        min_x, max_x = max(0, output_size[0]//2 - center_x), min(output_size[0], output_size[0]//2 + (center_slice.shape[1] - center_x))
+
+        # 将rect_slice放在中间
+        rect_slice[min_y:max_y, min_x:max_x] = center_slice[max(center_y - output_size[0]//2, 0):min(center_y + output_size[0]//2, center_slice.shape[0]),
+                                                                max(center_x - output_size[0]//2, 0):min(center_x +output_size[0]//2, center_slice.shape[1])]
+            
+        rect_label_slice[min_y:max_y, min_x:max_x] = center_label_slice[max(center_y - output_size[0]//2, 0):min(center_y + output_size[0]//2, center_slice.shape[0]),
+                                                                max(center_x - output_size[0]//2, 0):min(center_x + output_size[0]//2, center_slice.shape[1])]
+
+        # 获取椎体主体的最小旋转矩形
+        contours, _ = cv2.findContours(img2d_vertbody_aligned.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        rect = cv2.minAreaRect(contours[0])
+            
+        # 将最小旋转矩形的四个顶点转换为整数坐标
+        rect_points = np.int0(cv2.boxPoints(rect))
+        # 对该最小矩形进行缩放
+        # 缩放因子
+        scale_factor = 1.2
+        center = rect[0]
+        scaled_rect_points = ((rect_points - center) * scale_factor) + center
+        scaled_rect_points = np.int0(scaled_rect_points)
+
+        # 创建包围椎体的最小矩形
+        bbox_image = np.zeros_like(label_data[:,:,0], np.uint8)
+        bbox_cv2 = cv2.cvtColor(bbox_image, cv2.COLOR_GRAY2BGR)
+            
+        cv2.fillPoly(bbox_cv2, [scaled_rect_points], [255,255,255])
+        bbox_cv2 = cv2.cvtColor(bbox_cv2, cv2.COLOR_BGR2GRAY)
+
+        for other_label in range(8, 26):  # 假设label范围为1到25
+            if other_label != label:
+            # 找到其他label的区域
+                other_label_locs = np.where(label_data[:,:,center_z] == other_label)
+        
+            # 检查这些区域是否在bbox内，如果在，则将这部分的masked_label设为0
+                for y, x in zip(*other_label_locs):
+                    if bbox_cv2[y, x] == 255:  # 如果在bbox内
+                        bbox_cv2[y, x] = 0  # 将其他label区域设置为0
+            
+
+
+        masked_image = center_slice.copy()
+        masked_image[np.where(bbox_cv2==255)[0],np.where(bbox_cv2==255)[1]] = 0
+        masked_label = center_label_slice.copy()
+        masked_label[np.where(bbox_cv2==255)[0],np.where(bbox_cv2==255)[1]] = 0
+
+        masked_slice = np.zeros(output_size, dtype=np.uint8)
+        masked_slice[min_y:max_y, min_x:max_x] =masked_image[max(center_y - output_size[0]//2, 0):min(center_y + output_size[0]//2, center_slice.shape[0]),
+                                                                max(center_x - output_size[0]//2, 0):min(center_x +output_size[0]//2, center_slice.shape[1])]
+           
+        masked_label_slice = np.zeros(output_size, dtype=np.uint8)
+        masked_label_slice[min_y:max_y, min_x:max_x] = masked_label[max(center_y - output_size[0]//2, 0):min(center_y + output_size[0]//2, center_slice.shape[0]),
+                                                                max(center_x - output_size[0]//2, 0):min(center_x +output_size[0]//2, center_slice.shape[1])]
+            
+        # 保存mask区域的二值化图像
+        mask_binary = np.zeros(output_size, dtype=np.uint8)
+        mask_binary[min_y:max_y, min_x:max_x] = bbox_cv2[max(center_y - output_size[0]//2, 0):min(center_y + output_size[0]//2, center_slice.shape[0]),
+                                                                max(center_x - output_size[0]//2, 0):min(center_x +output_size[0]//2, center_slice.shape[1])]
+        
+        return rect_slice,rect_label_slice,mask_binary,masked_slice,masked_label_slice
+
+
+def process_spine_data_aug(ct_path,label_path,label_id,output_size):
+
+        ct_data = np.load(ct_path)
+        label_data = np.load(label_path)
+        binary_label = label_data.copy()
+        binary_label[binary_label!=0]=255
+        
+        
+        # 进行归一化并*255
+        ct_data =  window(ct_data, -300, 800)
+        
+        label = int(label_id)
+   
+        loc = np.where(label_data == label)
+        
+        try:
+            center_z = int(np.mean(loc[2]))
+        except:
+            print("发生 ValueError 异常")
+            print("loc 的值为:", loc)
+            print(label_path,label)
+        _, _, center_z = np.array(np.where(label_data == label)).mean(axis=1).astype(int)
+
+        # 对中间层面的椎体去除横突
+        label_binary = np.zeros(label_data.shape)
+        label_binary[loc] = 1
+        y0 = min(loc[1])
+        y1 = max(loc[1])
+        z0 = min(loc[0])
+        z1 = max(loc[0])
+
+        img2d = label_binary[z0:z1 + 1, y0:y1 + 1, center_z]
+            
+        _, img2d_vertbody, center_point = get_vertbody(img2d)
+
+            
+        img2d_vertbody_points = np.where(img2d_vertbody==1)
+        img2d_vertbody_aligned=np.zeros_like(label_data[:,:,0], np.uint8)
+        # 如果将GT改为生成椎体mask，这样子就不需要纹理灰度信息了
+        img2d_vertbody_aligned[img2d_vertbody_points[0]+z0,img2d_vertbody_points[1]+y0]=1
+            
+            # 计算椎体的中心位置
+        center_y,center_x = int(np.mean(img2d_vertbody_points[0])+z0),int(np.mean(img2d_vertbody_points[1])+y0)
+
+        # 截取224x224的矩形框在中心层面
+        center_slice = ct_data[:, :, center_z].copy()
+        center_label_slice = binary_label[:, :, center_z].copy()
+            #center_slice[img2d_vertbody_aligned==1]=255
+
+        crop_height, crop_width = output_size
+             # 计算椎体中心点相对于原始图像边界的最���可移动距离
+        max_shift_y = min(center_y, center_slice.shape[0] - center_y, crop_height//2)/2
+        max_shift_x = min(center_x, center_slice.shape[1] - center_x, crop_width//2)/2
+            
+            # 随机选择偏移量，保证椎体完全在裁剪图像内
+        shift_y = npr.randint(-max_shift_y, max_shift_y + 1)
+        shift_x = npr.randint(-max_shift_x, max_shift_x + 1)
+
+            # 计算随机化后的裁剪起始点
+        start_y = center_y + shift_y - crop_height // 2
+        start_x = center_x + shift_x - crop_width // 2
+
+            # 确定裁剪区域在原始图像内的实际位置
+        actual_start_y = max(start_y, 0)
+        actual_start_x = max(start_x, 0)
+        actual_end_y = min(start_y + crop_height, center_slice.shape[0])
+        actual_end_x = min(start_x + crop_width, center_slice.shape[1])
+            
+            # 创建224x224的矩形框
+        rect_slice = np.zeros(output_size, dtype=np.uint8)
+        rect_label_slice = np.zeros(output_size, dtype=np.uint8)
+
+            # 将原始图像的相应区域复制到裁剪后的图像
+        rect_slice[max(-start_y, 0):max(-start_y, 0)+actual_end_y-actual_start_y, 
+                    max(-start_x, 0):max(-start_x, 0)+actual_end_x-actual_start_x] = \
+                    center_slice[actual_start_y:actual_end_y, actual_start_x:actual_end_x]
+        rect_label_slice[max(-start_y, 0):max(-start_y, 0)+actual_end_y-actual_start_y, 
+                    max(-start_x, 0):max(-start_x, 0)+actual_end_x-actual_start_x] = \
+                        center_label_slice[actual_start_y:actual_end_y, actual_start_x:actual_end_x]
+
+            # 获取椎体主体的最小旋转矩形
+        contours, _ = cv2.findContours(img2d_vertbody_aligned.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        rect = cv2.minAreaRect(contours[0])
+        contour = contours[0]
+            
+            # 将最小旋转矩形的四个顶点转换为整数坐标
+        rect_points = np.int0(cv2.boxPoints(rect))         
+            
+            # 对该最小矩形进行缩放
+            # 缩放因子
+            # 对最小旋转矩形进行1.2-1.4之间的随机缩放
+        scale_factor = npr.uniform(1.1, 1.3)
+        center = rect[0]
+        scaled_rect_points = ((rect_points - center) * scale_factor) + center
+        scaled_rect_points = np.int0(scaled_rect_points)
+            # 创建包围椎体的最小矩形
+        bbox_image = np.zeros_like(label_data[:,:,0], np.uint8)
+        bbox_cv2 = cv2.cvtColor(bbox_image, cv2.COLOR_GRAY2BGR)
+            
+        cv2.fillPoly(bbox_cv2, [scaled_rect_points], [255,255,255])
+        bbox_cv2 = cv2.cvtColor(bbox_cv2, cv2.COLOR_BGR2GRAY)
+
+            
+            # 获取最小外接圆
+            #(xc, yc), radius = cv2.minEnclosingCircle(contour)
+            #center_circle = (int(xc), int(yc))
+            #radius = int(radius*scale_factor)
+            
+            # 绘制最小外接圆到 bbox_cv2 上
+            #cv2.circle(bbox_cv2, center_circle, radius, (255), -1)  # 用白色填充圆形
+            
+            # 获取最小外接矩形（非旋转）
+            #x, y, w, h = cv2.boundingRect(contour)
+            # 绘制最小外接矩形到 bbox_cv2 上
+            #cv2.rectangle(bbox_cv2, (x, y), (x + w, y + h), (255), -1)  # 用白色填充矩形
+            
+            # 应用bbox_cv2后，对label_data进行检查和处理
+            # 将bbox内其他label的区域设置为0
+        for other_label in range(8, 26):  # 假设label范围为1到25
+            if other_label != label:
+                # 找到其他label的区域
+                other_label_locs = np.where(label_data[:,:,center_z] == other_label)
+        
+                # 检查这些区域是否在bbox内，如果在，则将这部分的masked_label设为0
+                for y, x in zip(*other_label_locs):
+                    if bbox_cv2[y, x] == 255:  # 如果在bbox内
+                        bbox_cv2[y, x] = 0  # 将其他label区域设置为0
+            
+
+            # 将椎体mask掉
+        masked_image = center_slice.copy()
+        masked_image[np.where(bbox_cv2==255)[0],np.where(bbox_cv2==255)[1]] = 0
+        masked_label = center_label_slice.copy()
+        masked_label[np.where(bbox_cv2==255)[0],np.where(bbox_cv2==255)[1]] = 0
+
+        masked_slice = np.zeros(output_size, dtype=np.uint8)
+        masked_slice[max(-start_y, 0):max(-start_y, 0)+actual_end_y-actual_start_y, 
+                    max(-start_x, 0):max(-start_x, 0)+actual_end_x-actual_start_x] =\
+                        masked_image[actual_start_y:actual_end_y, actual_start_x:actual_end_x]
+           
+        masked_label_slice = np.zeros(output_size, dtype=np.uint8)
+        masked_label_slice[max(-start_y, 0):max(-start_y, 0)+actual_end_y-actual_start_y, 
+                    max(-start_x, 0):max(-start_x, 0)+actual_end_x-actual_start_x] = \
+                        masked_label[actual_start_y:actual_end_y, actual_start_x:actual_end_x]
+            
+            # 保存mask区域的二值化图像
+        mask_binary = np.zeros(output_size, dtype=np.uint8)
+        mask_binary[max(-start_y, 0):max(-start_y, 0)+actual_end_y-actual_start_y, 
+                    max(-start_x, 0):max(-start_x, 0)+actual_end_x-actual_start_x] = \
+            bbox_cv2[actual_start_y:actual_end_y, actual_start_x:actual_end_x]
+                
+        return rect_slice,rect_label_slice,mask_binary,masked_slice,masked_label_slice
+
+            

data/vertebra_data.json

@@ -0,0 +1,1468 @@
+{
+    "test": {
+        "sub-verse012_17": 0,
+        "sub-verse012_18": 0,
+        "sub-verse012_19": 0,
+        "sub-verse012_20": 3,
+        "sub-verse012_21": 0,
+        "sub-verse012_22": 1,
+        "sub-verse020_8": 0,
+        "sub-verse020_9": 0,
+        "sub-verse020_10": 0,
+        "sub-verse020_11": 0,
+        "sub-verse020_12": 1,
+        "sub-verse020_13": 2,
+        "sub-verse020_14": 0,
+        "sub-verse020_15": 3,
+        "sub-verse020_16": 3,
+        "sub-verse020_17": 0,
+        "sub-verse020_18": 3,
+        "sub-verse020_19": 0,
+        "sub-verse020_20": 3,
+        "sub-verse020_21": 2,
+        "sub-verse020_22": 2,
+        "sub-verse020_23": 0,
+        "sub-verse020_24": 0,
+        "sub-verse029_8": 0,
+        "sub-verse029_9": 0,
+        "sub-verse029_10": 0,
+        "sub-verse029_11": 0,
+        "sub-verse029_12": 0,
+        "sub-verse029_13": 0,
+        "sub-verse029_14": 0,
+        "sub-verse029_15": 0,
+        "sub-verse029_16": 0,
+        "sub-verse029_17": 0,
+        "sub-verse029_18": 0,
+        "sub-verse029_19": 0,
+        "sub-verse029_20": 0,
+        "sub-verse029_21": 0,
+        "sub-verse029_22": 0,
+        "sub-verse029_23": 0,
+        "sub-verse029_24": 0,
+        "sub-verse032_19": 0,
+        "sub-verse032_20": 0,
+        "sub-verse032_21": 0,
+        "sub-verse032_22": 0,
+        "sub-verse032_23": 0,
+        "sub-verse038_18": 0,
+        "sub-verse038_19": 0,
+        "sub-verse038_20": 0,
+        "sub-verse038_21": 0,
+        "sub-verse038_22": 0,
+        "sub-verse038_23": 2,
+        "sub-verse038_24": 0,
+        "sub-verse040_16": 0,
+        "sub-verse040_17": 0,
+        "sub-verse040_18": 0,
+        "sub-verse040_19": 1,
+        "sub-verse040_20": 3,
+        "sub-verse040_21": 1,
+        "sub-verse040_22": 1,
+        "sub-verse040_23": 0,
+        "sub-verse050_8": 0,
+        "sub-verse050_9": 0,
+        "sub-verse050_10": 0,
+        "sub-verse050_11": 0,
+        "sub-verse050_12": 0,
+        "sub-verse050_13": 0,
+        "sub-verse050_14": 0,
+        "sub-verse050_15": 0,
+        "sub-verse050_16": 0,
+        "sub-verse050_17": 0,
+        "sub-verse050_18": 0,
+        "sub-verse050_19": 0,
+        "sub-verse050_20": 0,
+        "sub-verse050_21": 0,
+        "sub-verse050_22": 0,
+        "sub-verse050_23": 0,
+        "sub-verse050_24": 0,
+        "sub-verse053_20": 0,
+        "sub-verse053_21": 2,
+        "sub-verse053_22": 0,
+        "sub-verse054_20": 0,
+        "sub-verse054_21": 2,
+        "sub-verse054_22": 1,
+        "sub-verse054_23": 0,
+        "sub-verse054_24": 2,
+        "sub-verse055_14": 0,
+        "sub-verse055_15": 0,
+        "sub-verse055_16": 0,
+        "sub-verse055_17": 0,
+        "sub-verse055_18": 0,
+        "sub-verse055_19": 0,
+        "sub-verse055_20": 0,
+        "sub-verse055_21": 0,
+        "sub-verse055_22": 0,
+        "sub-verse055_23": 0,
+        "sub-verse055_24": 0,
+        "sub-verse059_14": 0,
+        "sub-verse059_15": 0,
+        "sub-verse059_16": 2,
+        "sub-verse059_17": 0,
+        "sub-verse059_18": 0,
+        "sub-verse059_19": 2,
+        "sub-verse059_20": 1,
+        "sub-verse066_20": 1,
+        "sub-verse066_21": 0,
+        "sub-verse066_22": 0,
+        "sub-verse066_23": 0,
+        "sub-verse066_24": 0,
+        "sub-verse070_16": 0,
+        "sub-verse070_17": 0,
+        "sub-verse070_18": 1,
+        "sub-verse070_19": 1,
+        "sub-verse070_20": 3,
+        "sub-verse070_21": 0,
+        "sub-verse070_22": 0,
+        "sub-verse070_23": 0,
+        "sub-verse070_24": 0,
+        "sub-verse081_18": 1,
+        "sub-verse081_19": 1,
+        "sub-verse081_20": 3,
+        "sub-verse081_21": 1,
+        "sub-verse083_20": 1,
+        "sub-verse083_21": 0,
+        "sub-verse083_22": 0,
+        "sub-verse083_23": 1,
+        "sub-verse083_24": 0,
+        "sub-verse083_25": 0,
+        "sub-verse085_20": 1,
+        "sub-verse085_21": 1,
+        "sub-verse085_22": 0,
+        "sub-verse085_23": 0,
+        "sub-verse085_24": 0,
+        "sub-verse089_18": 0,
+        "sub-verse089_19": 0,
+        "sub-verse089_20": 0,
+        "sub-verse089_21": 0,
+        "sub-verse089_22": 0,
+        "sub-verse089_23": 1,
+        "sub-verse089_24": 0,
+        "sub-verse092_8": 0,
+        "sub-verse092_9": 0,
+        "sub-verse092_10": 0,
+        "sub-verse092_11": 0,
+        "sub-verse092_12": 0,
+        "sub-verse092_13": 0,
+        "sub-verse092_14": 0,
+        "sub-verse092_15": 0,
+        "sub-verse092_16": 0,
+        "sub-verse092_17": 2,
+        "sub-verse092_18": 3,
+        "sub-verse092_19": 1,
+        "sub-verse092_20": 0,
+        "sub-verse092_21": 0,
+        "sub-verse092_22": 0,
+        "sub-verse092_23": 0,
+        "sub-verse092_24": 0,
+        "sub-verse101_8": 0,
+        "sub-verse101_9": 0,
+        "sub-verse101_10": 0,
+        "sub-verse101_11": 0,
+        "sub-verse101_12": 0,
+        "sub-verse101_13": 0,
+        "sub-verse101_14": 0,
+        "sub-verse101_15": 0,
+        "sub-verse101_16": 0,
+        "sub-verse101_17": 0,
+        "sub-verse101_18": 0,
+        "sub-verse101_19": 0,
+        "sub-verse101_20": 0,
+        "sub-verse101_21": 0,
+        "sub-verse101_22": 0,
+        "sub-verse101_23": 0,
+        "sub-verse101_24": 0,
+        "sub-verse108_8": 0,
+        "sub-verse108_9": 0,
+        "sub-verse108_10": 0,
+        "sub-verse108_11": 0,
+        "sub-verse108_12": 0,
+        "sub-verse108_13": 0,
+        "sub-verse108_14": 0,
+        "sub-verse108_15": 0,
+        "sub-verse108_16": 0,
+        "sub-verse108_17": 0,
+        "sub-verse108_18": 0,
+        "sub-verse108_19": 0,
+        "sub-verse108_20": 0,
+        "sub-verse108_21": 0,
+        "sub-verse108_22": 0,
+        "sub-verse108_23": 0,
+        "sub-verse108_24": 0,
+        "sub-verse119_8": 0,
+        "sub-verse119_9": 0,
+        "sub-verse119_10": 1,
+        "sub-verse119_11": 1,
+        "sub-verse119_12": 0,
+        "sub-verse119_13": 0,
+        "sub-verse119_14": 1,
+        "sub-verse119_15": 2,
+        "sub-verse119_16": 0,
+        "sub-verse119_17": 0,
+        "sub-verse119_18": 0,
+        "sub-verse119_19": 2,
+        "sub-verse119_20": 0,
+        "sub-verse130_15": 0,
+        "sub-verse130_16": 0,
+        "sub-verse130_17": 2,
+        "sub-verse130_18": 1,
+        "sub-verse130_19": 3,
+        "sub-verse130_20": 0,
+        "sub-verse130_21": 2,
+        "sub-verse130_22": 0,
+        "sub-verse130_23": 0,
+        "sub-verse130_24": 0,
+        "sub-verse131_17": 0,
+        "sub-verse131_18": 0,
+        "sub-verse131_19": 1,
+        "sub-verse131_20": 2,
+        "sub-verse131_21": 0,
+        "sub-verse131_22": 0,
+        "sub-verse131_23": 0,
+        "sub-verse131_24": 0,
+        "sub-verse131_25": 0,
+        "sub-verse138_16": 0,
+        "sub-verse138_17": 0,
+        "sub-verse138_18": 0,
+        "sub-verse138_19": 0,
+        "sub-verse138_20": 0,
+        "sub-verse138_21": 0,
+        "sub-verse138_22": 0,
+        "sub-verse138_23": 0,
+        "sub-verse138_24": 0,
+        "sub-verse143_20": 0,
+        "sub-verse143_21": 2,
+        "sub-verse143_22": 0,
+        "sub-verse143_23": 0,
+        "sub-verse143_24": 0,
+        "sub-verse144_16": 0,
+        "sub-verse144_17": 0,
+        "sub-verse144_21": 3,
+        "sub-verse144_22": 2,
+        "sub-verse147_20": 1,
+        "sub-verse147_21": 0,
+        "sub-verse147_22": 2,
+        "sub-verse147_23": 0,
+        "sub-verse147_24": 0,
+        "sub-verse149_17": 0,
+        "sub-verse149_18": 0,
+        "sub-verse149_19": 3,
+        "sub-verse149_20": 2,
+        "sub-verse149_21": 1,
+        "sub-verse149_22": 2,
+        "sub-verse149_23": 2,
+        "sub-verse149_24": 0,
+        "sub-verse154_16": 0,
+        "sub-verse154_17": 0,
+        "sub-verse154_18": 0,
+        "sub-verse154_19": 0,
+        "sub-verse154_20": 0,
+        "sub-verse154_21": 0,
+        "sub-verse154_22": 0,
+        "sub-verse154_23": 0,
+        "sub-verse154_24": 0,
+        "sub-verse236_8": 0,
+        "sub-verse236_9": 0,
+        "sub-verse236_10": 0,
+        "sub-verse236_11": 1,
+        "sub-verse236_12": 1,
+        "sub-verse236_13": 0,
+        "sub-verse236_14": 0,
+        "sub-verse236_15": 0,
+        "sub-verse236_16": 0,
+        "sub-verse236_17": 0,
+        "sub-verse236_18": 0,
+        "sub-verse236_19": 0,
+        "sub-verse236_20": 0,
+        "sub-verse236_21": 0,
+        "sub-verse236_22": 0,
+        "sub-verse236_23": 0,
+        "sub-verse236_24": 0,
+        "sub-verse260_9": 1,
+        "sub-verse260_10": 1,
+        "sub-verse260_11": 0,
+        "sub-verse260_12": 0,
+        "sub-verse260_13": 0,
+        "sub-verse260_14": 0,
+        "sub-verse260_15": 0,
+        "sub-verse260_16": 1,
+        "sub-verse260_17": 0,
+        "sub-verse260_18": 1,
+        "sub-verse260_19": 0,
+        "sub-verse260_20": 0,
+        "sub-verse260_21": 1,
+        "sub-verse260_22": 0,
+        "sub-verse260_23": 0,
+        "sub-verse260_24": 0,
+        "sub-verse271_8": 0,
+        "sub-verse271_9": 0,
+        "sub-verse271_10": 0,
+        "sub-verse271_11": 0,
+        "sub-verse271_12": 0,
+        "sub-verse271_13": 0,
+        "sub-verse271_14": 0,
+        "sub-verse271_15": 0,
+        "sub-verse271_16": 0,
+        "sub-verse271_17": 0,
+        "sub-verse271_18": 0,
+        "sub-verse271_19": 0,
+        "sub-verse271_20": 2,
+        "sub-verse271_21": 0,
+        "sub-verse271_22": 0,
+        "sub-verse271_23": 0,
+        "sub-verse271_24": 0,
+        "sub-verse414_series1_8": 0,
+        "sub-verse414_series1_9": 0,
+        "sub-verse414_series1_10": 0,
+        "sub-verse414_series1_11": 0,
+        "sub-verse414_series1_12": 0,
+        "sub-verse414_series1_13": 0,
+        "sub-verse414_series1_14": 1,
+        "sub-verse414_series1_15": 1,
+        "sub-verse414_series1_16": 0,
+        "sub-verse414_series1_17": 0,
+        "sub-verse414_series1_18": 0,
+        "sub-verse414_series1_19": 0,
+        "sub-verse414_series1_20": 0,
+        "sub-verse414_series1_21": 0,
+        "sub-verse414_series1_22": 0,
+        "sub-verse414_series1_23": 0,
+        "sub-verse414_series1_24": 0,
+        "sub-verse417_series0_8": 0,
+        "sub-verse417_series0_9": 0,
+        "sub-verse417_series0_10": 0,
+        "sub-verse417_series0_11": 0,
+        "sub-verse417_series0_12": 0,
+        "sub-verse417_series0_13": 0,
+        "sub-verse417_series0_14": 0,
+        "sub-verse417_series0_15": 0,
+        "sub-verse417_series0_16": 0,
+        "sub-verse417_series0_17": 0,
+        "sub-verse417_series0_18": 0,
+        "sub-verse417_series0_19": 0,
+        "sub-verse417_series0_20": 0,
+        "sub-verse417_series1_18": 0,
+        "sub-verse417_series1_19": 0,
+        "sub-verse417_series1_20": 0,
+        "sub-verse417_series1_21": 0,
+        "sub-verse417_series1_22": 0,
+        "sub-verse417_series1_23": 0,
+        "sub-verse417_series1_24": 0,
+        "sub-verse416_series1_8": 1,
+        "sub-verse416_series1_9": 1,
+        "sub-verse416_series1_10": 1,
+        "sub-verse416_series1_11": 0,
+        "sub-verse416_series1_12": 0,
+        "sub-verse416_series1_13": 0,
+        "sub-verse416_series1_14": 0,
+        "sub-verse416_series1_15": 0,
+        "sub-verse416_series1_16": 0,
+        "sub-verse416_series1_17": 0,
+        "sub-verse416_series1_18": 0,
+        "sub-verse416_series1_19": 0,
+        "sub-verse416_series1_20": 0,
+        "sub-verse416_series1_21": 0,
+        "sub-verse416_series1_22": 0,
+        "sub-verse416_series1_23": 0,
+        "sub-verse416_series1_24": 0
+    },
+    "train": {
+        "sub-verse004_16": 2,
+        "sub-verse004_17": 2,
+        "sub-verse004_18": 0,
+        "sub-verse004_19": 0,
+        "sub-verse004_20": 3,
+        "sub-verse004_21": 0,
+        "sub-verse004_22": 0,
+        "sub-verse005_20": 1,
+        "sub-verse005_21": 1,
+        "sub-verse005_22": 1,
+        "sub-verse005_23": 1,
+        "sub-verse005_24": 0,
+        "sub-verse006_23": 0,
+        "sub-verse006_24": 0,
+        "sub-verse007_16": 0,
+        "sub-verse007_17": 0,
+        "sub-verse007_18": 0,
+        "sub-verse007_19": 2,
+        "sub-verse007_20": 2,
+        "sub-verse007_21": 0,
+        "sub-verse007_22": 0,
+        "sub-verse008_19": 0,
+        "sub-verse008_20": 0,
+        "sub-verse008_21": 2,
+        "sub-verse008_22": 0,
+        "sub-verse008_23": 0,
+        "sub-verse008_24": 0,
+        "sub-verse009_9": 0,
+        "sub-verse009_10": 0,
+        "sub-verse009_11": 0,
+        "sub-verse009_12": 3,
+        "sub-verse009_13": 0,
+        "sub-verse009_14": 1,
+        "sub-verse009_15": 1,
+        "sub-verse009_16": 0,
+        "sub-verse009_17": 0,
+        "sub-verse009_18": 0,
+        "sub-verse009_19": 0,
+        "sub-verse009_20": 1,
+        "sub-verse009_21": 1,
+        "sub-verse009_22": 3,
+        "sub-verse009_23": 2,
+        "sub-verse009_24": 2,
+        "sub-verse014_20": 0,
+        "sub-verse014_21": 0,
+        "sub-verse014_22": 0,
+        "sub-verse014_23": 0,
+        "sub-verse014_24": 0,
+        "sub-verse015_19": 0,
+        "sub-verse015_20": 0,
+        "sub-verse015_21": 0,
+        "sub-verse031_20": 2,
+        "sub-verse031_21": 0,
+        "sub-verse031_22": 0,
+        "sub-verse031_23": 3,
+        "sub-verse031_24": 2,
+        "sub-verse033_8": 0,
+        "sub-verse033_9": 0,
+        "sub-verse033_10": 0,
+        "sub-verse033_11": 0,
+        "sub-verse033_12": 0,
+        "sub-verse033_13": 2,
+        "sub-verse033_14": 2,
+        "sub-verse033_15": 3,
+        "sub-verse033_16": 2,
+        "sub-verse033_17": 1,
+        "sub-verse033_18": 3,
+        "sub-verse033_19": 2,
+        "sub-verse033_20": 1,
+        "sub-verse033_21": 2,
+        "sub-verse033_22": 0,
+        "sub-verse033_23": 0,
+        "sub-verse033_24": 0,
+        "sub-verse034_17": 0,
+        "sub-verse034_18": 0,
+        "sub-verse034_19": 0,
+        "sub-verse034_20": 0,
+        "sub-verse034_21": 0,
+        "sub-verse034_22": 0,
+        "sub-verse034_23": 0,
+        "sub-verse034_24": 0,
+        "sub-verse036_21": 1,
+        "sub-verse043_9": 0,
+        "sub-verse043_10": 0,
+        "sub-verse043_11": 0,
+        "sub-verse043_12": 0,
+        "sub-verse043_13": 0,
+        "sub-verse043_14": 0,
+        "sub-verse043_15": 0,
+        "sub-verse043_16": 0,
+        "sub-verse043_17": 0,
+        "sub-verse043_18": 0,
+        "sub-verse043_19": 2,
+        "sub-verse043_20": 0,
+        "sub-verse043_21": 0,
+        "sub-verse043_22": 0,
+        "sub-verse043_23": 0,
+        "sub-verse043_24": 0,
+        "sub-verse046_20": 0,
+        "sub-verse046_21": 0,
+        "sub-verse046_22": 1,
+        "sub-verse046_23": 1,
+        "sub-verse046_24": 0,
+        "sub-verse048_21": 0,
+        "sub-verse048_22": 0,
+        "sub-verse048_23": 0,
+        "sub-verse048_24": 0,
+        "sub-verse051_17": 0,
+        "sub-verse051_18": 0,
+        "sub-verse051_19": 0,
+        "sub-verse051_20": 0,
+        "sub-verse051_21": 0,
+        "sub-verse051_22": 0,
+        "sub-verse051_23": 0,
+        "sub-verse051_24": 0,
+        "sub-verse056_18": 0,
+        "sub-verse056_19": 2,
+        "sub-verse056_23": 2,
+        "sub-verse060_19": 0,
+        "sub-verse060_20": 2,
+        "sub-verse060_21": 1,
+        "sub-verse060_22": 2,
+        "sub-verse060_23": 1,
+        "sub-verse060_24": 3,
+        "sub-verse061_17": 0,
+        "sub-verse061_18": 0,
+        "sub-verse061_19": 0,
+        "sub-verse061_20": 2,
+        "sub-verse061_21": 2,
+        "sub-verse061_22": 0,
+        "sub-verse061_23": 0,
+        "sub-verse061_24": 0,
+        "sub-verse063_20": 0,
+        "sub-verse064_9": 0,
+        "sub-verse064_10": 0,
+        "sub-verse064_11": 0,
+        "sub-verse064_12": 0,
+        "sub-verse064_13": 1,
+        "sub-verse064_14": 0,
+        "sub-verse064_15": 0,
+        "sub-verse064_16": 0,
+        "sub-verse064_17": 0,
+        "sub-verse064_18": 0,
+        "sub-verse064_19": 0,
+        "sub-verse064_20": 0,
+        "sub-verse064_21": 2,
+        "sub-verse064_22": 0,
+        "sub-verse064_23": 0,
+        "sub-verse064_24": 0,
+        "sub-verse065_21": 0,
+        "sub-verse065_22": 0,
+        "sub-verse065_23": 0,
+        "sub-verse065_24": 0,
+        "sub-verse068_16": 0,
+        "sub-verse068_17": 0,
+        "sub-verse068_18": 0,
+        "sub-verse068_19": 0,
+        "sub-verse068_20": 3,
+        "sub-verse068_21": 3,
+        "sub-verse068_22": 0,
+        "sub-verse068_23": 0,
+        "sub-verse068_24": 0,
+        "sub-verse072_19": 0,
+        "sub-verse072_20": 0,
+        "sub-verse072_21": 1,
+        "sub-verse072_22": 0,
+        "sub-verse072_23": 0,
+        "sub-verse072_24": 0,
+        "sub-verse074_8": 0,
+        "sub-verse074_9": 0,
+        "sub-verse074_10": 0,
+        "sub-verse074_11": 0,
+        "sub-verse074_12": 0,
+        "sub-verse074_13": 0,
+        "sub-verse074_14": 0,
+        "sub-verse074_15": 0,
+        "sub-verse074_16": 0,
+        "sub-verse074_17": 0,
+        "sub-verse074_18": 0,
+        "sub-verse074_19": 0,
+        "sub-verse074_20": 0,
+        "sub-verse074_21": 0,
+        "sub-verse074_22": 0,
+        "sub-verse074_23": 0,
+        "sub-verse074_24": 0,
+        "sub-verse075_16": 0,
+        "sub-verse075_17": 0,
+        "sub-verse075_18": 0,
+        "sub-verse075_19": 0,
+        "sub-verse075_20": 0,
+        "sub-verse075_21": 0,
+        "sub-verse075_22": 0,
+        "sub-verse076_20": 0,
+        "sub-verse076_21": 0,
+        "sub-verse076_22": 1,
+        "sub-verse076_23": 1,
+        "sub-verse076_24": 0,
+        "sub-verse082_8": 0,
+        "sub-verse082_9": 0,
+        "sub-verse082_10": 1,
+        "sub-verse082_11": 0,
+        "sub-verse082_12": 1,
+        "sub-verse082_13": 0,
+        "sub-verse082_14": 0,
+        "sub-verse082_15": 0,
+        "sub-verse082_16": 0,
+        "sub-verse082_17": 1,
+        "sub-verse082_18": 0,
+        "sub-verse082_19": 3,
+        "sub-verse082_20": 2,
+        "sub-verse082_21": 1,
+        "sub-verse082_22": 1,
+        "sub-verse082_23": 3,
+        "sub-verse082_24": 2,
+        "sub-verse088_16": 0,
+        "sub-verse088_17": 0,
+        "sub-verse088_18": 0,
+        "sub-verse088_19": 0,
+        "sub-verse088_20": 0,
+        "sub-verse088_21": 0,
+        "sub-verse088_22": 0,
+        "sub-verse088_23": 0,
+        "sub-verse088_24": 0,
+        "sub-verse091_8": 0,
+        "sub-verse091_9": 0,
+        "sub-verse091_10": 0,
+        "sub-verse091_11": 0,
+        "sub-verse091_12": 0,
+        "sub-verse091_13": 0,
+        "sub-verse091_14": 0,
+        "sub-verse091_15": 1,
+        "sub-verse091_16": 0,
+        "sub-verse091_17": 0,
+        "sub-verse091_18": 0,
+        "sub-verse091_19": 1,
+        "sub-verse091_20": 1,
+        "sub-verse091_21": 0,
+        "sub-verse091_22": 1,
+        "sub-verse091_23": 1,
+        "sub-verse091_24": 0,
+        "sub-verse096_8": 0,
+        "sub-verse096_9": 0,
+        "sub-verse096_10": 0,
+        "sub-verse096_11": 0,
+        "sub-verse096_12": 0,
+        "sub-verse096_13": 0,
+        "sub-verse096_14": 0,
+        "sub-verse096_15": 0,
+        "sub-verse096_16": 0,
+        "sub-verse096_17": 0,
+        "sub-verse096_18": 0,
+        "sub-verse096_19": 0,
+        "sub-verse096_20": 0,
+        "sub-verse096_21": 0,
+        "sub-verse096_22": 0,
+        "sub-verse096_23": 0,
+        "sub-verse096_24": 0,
+        "sub-verse097_8": 0,
+        "sub-verse097_9": 1,
+        "sub-verse097_10": 3,
+        "sub-verse097_11": 1,
+        "sub-verse097_12": 1,
+        "sub-verse097_13": 1,
+        "sub-verse097_14": 1,
+        "sub-verse097_15": 1,
+        "sub-verse097_16": 1,
+        "sub-verse097_17": 1,
+        "sub-verse097_18": 0,
+        "sub-verse097_19": 0,
+        "sub-verse097_20": 2,
+        "sub-verse097_21": 1,
+        "sub-verse097_22": 2,
+        "sub-verse097_23": 0,
+        "sub-verse097_24": 0,
+        "sub-verse100_16": 0,
+        "sub-verse100_17": 0,
+        "sub-verse100_18": 0,
+        "sub-verse100_19": 0,
+        "sub-verse100_20": 0,
+        "sub-verse100_21": 0,
+        "sub-verse100_22": 0,
+        "sub-verse100_23": 0,
+        "sub-verse102_20": 0,
+        "sub-verse102_21": 0,
+        "sub-verse102_22": 2,
+        "sub-verse102_23": 0,
+        "sub-verse102_24": 0,
+        "sub-verse104_9": 0,
+        "sub-verse104_10": 0,
+        "sub-verse104_11": 0,
+        "sub-verse104_12": 0,
+        "sub-verse104_13": 0,
+        "sub-verse104_14": 0,
+        "sub-verse104_15": 0,
+        "sub-verse104_16": 0,
+        "sub-verse104_17": 0,
+        "sub-verse104_18": 0,
+        "sub-verse104_19": 2,
+        "sub-verse104_20": 0,
+        "sub-verse104_21": 2,
+        "sub-verse104_22": 1,
+        "sub-verse104_23": 2,
+        "sub-verse104_24": 0,
+        "sub-verse105_9": 0,
+        "sub-verse105_10": 0,
+        "sub-verse105_11": 0,
+        "sub-verse105_12": 0,
+        "sub-verse105_13": 2,
+        "sub-verse105_14": 3,
+        "sub-verse105_15": 2,
+        "sub-verse105_16": 0,
+        "sub-verse105_17": 0,
+        "sub-verse107_19": 0,
+        "sub-verse107_20": 0,
+        "sub-verse107_21": 0,
+        "sub-verse107_22": 0,
+        "sub-verse107_23": 0,
+        "sub-verse107_24": 0,
+        "sub-verse111_18": 0,
+        "sub-verse111_19": 0,
+        "sub-verse111_20": 0,
+        "sub-verse111_21": 2,
+        "sub-verse111_22": 3,
+        "sub-verse111_23": 2,
+        "sub-verse111_24": 0,
+        "sub-verse112_8": 0,
+        "sub-verse112_9": 0,
+        "sub-verse112_10": 0,
+        "sub-verse112_11": 0,
+        "sub-verse112_12": 0,
+        "sub-verse112_13": 0,
+        "sub-verse112_14": 0,
+        "sub-verse112_15": 0,
+        "sub-verse112_16": 0,
+        "sub-verse112_17": 0,
+        "sub-verse112_18": 0,
+        "sub-verse112_19": 0,
+        "sub-verse112_20": 0,
+        "sub-verse112_21": 0,
+        "sub-verse112_22": 0,
+        "sub-verse112_23": 0,
+        "sub-verse112_24": 0,
+        "sub-verse113_21": 0,
+        "sub-verse113_22": 0,
+        "sub-verse113_23": 1,
+        "sub-verse113_24": 3,
+        "sub-verse113_25": 0,
+        "sub-verse122_8": 0,
+        "sub-verse122_9": 0,
+        "sub-verse122_10": 0,
+        "sub-verse122_11": 0,
+        "sub-verse122_12": 1,
+        "sub-verse122_13": 2,
+        "sub-verse122_14": 3,
+        "sub-verse122_15": 0,
+        "sub-verse122_16": 0,
+        "sub-verse122_17": 0,
+        "sub-verse122_19": 0,
+        "sub-verse122_20": 3,
+        "sub-verse122_21": 2,
+        "sub-verse122_22": 1,
+        "sub-verse122_23": 2,
+        "sub-verse122_24": 0,
+        "sub-verse127_8": 0,
+        "sub-verse127_9": 0,
+        "sub-verse127_10": 0,
+        "sub-verse127_11": 0,
+        "sub-verse127_12": 0,
+        "sub-verse127_13": 0,
+        "sub-verse127_14": 0,
+        "sub-verse127_15": 0,
+        "sub-verse127_16": 0,
+        "sub-verse127_17": 0,
+        "sub-verse127_18": 2,
+        "sub-verse127_19": 0,
+        "sub-verse127_20": 0,
+        "sub-verse127_21": 0,
+        "sub-verse127_22": 0,
+        "sub-verse127_23": 0,
+        "sub-verse127_24": 0,
+        "sub-verse133_16": 0,
+        "sub-verse133_17": 0,
+        "sub-verse133_18": 1,
+        "sub-verse133_19": 0,
+        "sub-verse133_20": 0,
+        "sub-verse133_21": 0,
+        "sub-verse133_22": 0,
+        "sub-verse133_23": 0,
+        "sub-verse133_24": 0,
+        "sub-verse134_19": 0,
+        "sub-verse134_20": 0,
+        "sub-verse134_21": 0,
+        "sub-verse134_22": 0,
+        "sub-verse134_23": 0,
+        "sub-verse134_24": 0,
+        "sub-verse135_8": 0,
+        "sub-verse135_9": 0,
+        "sub-verse135_10": 1,
+        "sub-verse135_11": 0,
+        "sub-verse135_12": 1,
+        "sub-verse135_13": 0,
+        "sub-verse135_14": 0,
+        "sub-verse135_15": 0,
+        "sub-verse135_16": 0,
+        "sub-verse135_17": 0,
+        "sub-verse135_18": 0,
+        "sub-verse135_19": 0,
+        "sub-verse135_20": 0,
+        "sub-verse135_21": 0,
+        "sub-verse135_22": 2,
+        "sub-verse135_23": 0,
+        "sub-verse135_24": 2,
+        "sub-verse137_19": 0,
+        "sub-verse137_20": 0,
+        "sub-verse137_21": 0,
+        "sub-verse137_22": 0,
+        "sub-verse137_24": 3,
+        "sub-verse139_20": 0,
+        "sub-verse139_21": 0,
+        "sub-verse139_22": 0,
+        "sub-verse139_23": 0,
+        "sub-verse139_24": 2,
+        "sub-verse141_8": 0,
+        "sub-verse141_9": 0,
+        "sub-verse141_10": 0,
+        "sub-verse141_11": 0,
+        "sub-verse141_12": 0,
+        "sub-verse141_13": 0,
+        "sub-verse141_14": 0,
+        "sub-verse141_15": 0,
+        "sub-verse141_16": 0,
+        "sub-verse141_17": 0,
+        "sub-verse141_18": 2,
+        "sub-verse141_19": 0,
+        "sub-verse141_20": 0,
+        "sub-verse141_21": 0,
+        "sub-verse141_22": 0,
+        "sub-verse141_23": 0,
+        "sub-verse141_24": 0,
+        "sub-verse145_8": 1,
+        "sub-verse145_9": 0,
+        "sub-verse145_10": 0,
+        "sub-verse145_11": 0,
+        "sub-verse145_12": 0,
+        "sub-verse145_13": 0,
+        "sub-verse145_14": 1,
+        "sub-verse145_15": 0,
+        "sub-verse145_16": 0,
+        "sub-verse145_17": 0,
+        "sub-verse145_18": 0,
+        "sub-verse145_19": 0,
+        "sub-verse145_20": 0,
+        "sub-verse145_21": 0,
+        "sub-verse145_22": 0,
+        "sub-verse145_23": 0,
+        "sub-verse145_24": 0,
+        "sub-verse146_22": 0,
+        "sub-verse146_23": 0,
+        "sub-verse151_9": 0,
+        "sub-verse151_10": 0,
+        "sub-verse151_11": 0,
+        "sub-verse151_12": 0,
+        "sub-verse151_13": 0,
+        "sub-verse151_14": 0,
+        "sub-verse151_15": 0,
+        "sub-verse151_16": 0,
+        "sub-verse151_17": 0,
+        "sub-verse151_18": 0,
+        "sub-verse151_19": 2,
+        "sub-verse151_20": 0,
+        "sub-verse151_21": 0,
+        "sub-verse151_22": 0,
+        "sub-verse151_23": 0,
+        "sub-verse151_24": 0,
+        "sub-verse152_19": 1,
+        "sub-verse152_20": 2,
+        "sub-verse152_21": 1,
+        "sub-verse152_22": 1,
+        "sub-verse152_23": 1,
+        "sub-verse152_24": 0,
+        "sub-verse401_series0_8": 0,
+        "sub-verse401_series0_9": 0,
+        "sub-verse402_series0_8": 0,
+        "sub-verse207_8": 0,
+        "sub-verse403_series0_8": 0,
+        "sub-verse403_series0_9": 0,
+        "sub-verse405_series0_8": 0,
+        "sub-verse405_series0_9": 0,
+        "sub-verse406_series0_8": 0,
+        "sub-verse406_series0_9": 0,
+        "sub-verse408_series0_8": 0,
+        "sub-verse409_series0_8": 0,
+        "sub-verse409_series0_9": 0,
+        "sub-verse410_series0_8": 0,
+        "sub-verse411_series0_8": 0,
+        "sub-verse413_series0_8": 0,
+        "sub-verse413_series0_9": 0,
+        "sub-verse413_series0_10": 0,
+        "sub-verse413_series0_11": 0,
+        "sub-verse415_series0_8": 0,
+        "sub-verse402_series1_8": 0,
+        "sub-verse402_series1_9": 0,
+        "sub-verse402_series1_10": 0,
+        "sub-verse402_series1_11": 0,
+        "sub-verse402_series1_12": 0,
+        "sub-verse402_series1_13": 0,
+        "sub-verse402_series1_14": 0,
+        "sub-verse402_series1_15": 0,
+        "sub-verse402_series1_16": 0,
+        "sub-verse402_series1_17": 0,
+        "sub-verse402_series1_18": 0,
+        "sub-verse402_series1_19": 0,
+        "sub-verse402_series1_20": 0,
+        "sub-verse402_series1_21": 0,
+        "sub-verse402_series1_22": 0,
+        "sub-verse402_series1_23": 0,
+        "sub-verse402_series1_24": 0,
+        "sub-verse401_series1_10": 0,
+        "sub-verse401_series1_11": 0,
+        "sub-verse401_series1_12": 0,
+        "sub-verse401_series1_13": 0,
+        "sub-verse401_series1_14": 0,
+        "sub-verse401_series1_15": 0,
+        "sub-verse401_series1_16": 0,
+        "sub-verse401_series1_17": 0,
+        "sub-verse401_series1_18": 1,
+        "sub-verse401_series1_19": 1,
+        "sub-verse401_series1_20": 0,
+        "sub-verse401_series1_21": 0,
+        "sub-verse401_series1_22": 0,
+        "sub-verse401_series1_23": 0,
+        "sub-verse401_series1_24": 0,
+        "sub-verse254_8": 0,
+        "sub-verse254_9": 0,
+        "sub-verse254_10": 0,
+        "sub-verse254_11": 0,
+        "sub-verse254_12": 0,
+        "sub-verse254_13": 0,
+        "sub-verse254_14": 0,
+        "sub-verse254_15": 0,
+        "sub-verse254_16": 0,
+        "sub-verse254_17": 0,
+        "sub-verse254_18": 0,
+        "sub-verse254_19": 0,
+        "sub-verse254_20": 0,
+        "sub-verse254_21": 0,
+        "sub-verse254_22": 0,
+        "sub-verse254_23": 0,
+        "sub-verse254_24": 0,
+        "sub-verse403_series1_8": 0,
+        "sub-verse403_series1_9": 0,
+        "sub-verse403_series1_10": 0,
+        "sub-verse403_series1_11": 0,
+        "sub-verse403_series1_12": 0,
+        "sub-verse403_series1_13": 1,
+        "sub-verse403_series1_14": 1,
+        "sub-verse403_series1_15": 1,
+        "sub-verse403_series1_16": 1,
+        "sub-verse403_series1_17": 0,
+        "sub-verse403_series1_18": 0,
+        "sub-verse403_series1_19": 0,
+        "sub-verse403_series1_20": 0,
+        "sub-verse403_series1_21": 0,
+        "sub-verse403_series1_22": 0,
+        "sub-verse403_series1_23": 0,
+        "sub-verse403_series1_24": 0,
+        "sub-verse403_series1_25": 0,
+        "sub-verse257_17": 0,
+        "sub-verse257_18": 0,
+        "sub-verse257_19": 0,
+        "sub-verse257_20": 0,
+        "sub-verse257_21": 0,
+        "sub-verse257_22": 0,
+        "sub-verse257_23": 0,
+        "sub-verse257_24": 0,
+        "sub-verse405_series1_8": 0,
+        "sub-verse405_series1_9": 0,
+        "sub-verse405_series1_10": 0,
+        "sub-verse405_series1_11": 0,
+        "sub-verse405_series1_12": 0,
+        "sub-verse405_series1_13": 0,
+        "sub-verse405_series1_14": 0,
+        "sub-verse405_series1_15": 0,
+        "sub-verse405_series1_16": 0,
+        "sub-verse405_series1_17": 0,
+        "sub-verse405_series1_18": 0,
+        "sub-verse405_series1_19": 0,
+        "sub-verse405_series2_20": 1,
+        "sub-verse405_series2_21": 2,
+        "sub-verse405_series2_22": 0,
+        "sub-verse405_series2_23": 0,
+        "sub-verse405_series2_24": 0,
+        "sub-verse406_series1_8": 0,
+        "sub-verse406_series1_9": 0,
+        "sub-verse406_series1_10": 0,
+        "sub-verse406_series1_11": 0,
+        "sub-verse406_series1_12": 0,
+        "sub-verse406_series1_13": 0,
+        "sub-verse406_series1_14": 0,
+        "sub-verse406_series1_15": 0,
+        "sub-verse406_series1_16": 0,
+        "sub-verse406_series1_17": 0,
+        "sub-verse406_series1_18": 0,
+        "sub-verse406_series1_19": 0,
+        "sub-verse406_series1_20": 0,
+        "sub-verse406_series1_21": 0,
+        "sub-verse406_series1_22": 0,
+        "sub-verse406_series1_23": 0,
+        "sub-verse406_series1_24": 0,
+        "sub-verse406_series1_25": 0,
+        "sub-verse407_series1_8": 0,
+        "sub-verse407_series1_9": 0,
+        "sub-verse407_series1_10": 0,
+        "sub-verse407_series1_11": 0,
+        "sub-verse407_series1_12": 0,
+        "sub-verse407_series1_13": 0,
+        "sub-verse407_series1_14": 0,
+        "sub-verse407_series1_15": 0,
+        "sub-verse407_series1_16": 0,
+        "sub-verse407_series1_17": 0,
+        "sub-verse407_series1_18": 0,
+        "sub-verse407_series1_19": 0,
+        "sub-verse407_series1_20": 0,
+        "sub-verse407_series1_21": 0,
+        "sub-verse407_series1_22": 0,
+        "sub-verse407_series1_23": 0,
+        "sub-verse407_series1_24": 0,
+        "sub-verse408_series1_8": 0,
+        "sub-verse408_series1_9": 0,
+        "sub-verse408_series1_10": 0,
+        "sub-verse408_series1_11": 0,
+        "sub-verse408_series1_12": 0,
+        "sub-verse408_series1_13": 0,
+        "sub-verse408_series1_14": 0,
+        "sub-verse408_series1_15": 0,
+        "sub-verse408_series1_16": 0,
+        "sub-verse408_series1_17": 0,
+        "sub-verse408_series1_18": 0,
+        "sub-verse408_series1_19": 2,
+        "sub-verse408_series1_20": 3,
+        "sub-verse408_series1_21": 1,
+        "sub-verse408_series1_22": 0,
+        "sub-verse408_series1_23": 2,
+        "sub-verse408_series1_24": 0,
+        "sub-verse409_series1_8": 0,
+        "sub-verse409_series1_9": 0,
+        "sub-verse409_series1_10": 0,
+        "sub-verse409_series1_11": 0,
+        "sub-verse409_series1_12": 0,
+        "sub-verse409_series1_13": 0,
+        "sub-verse409_series1_14": 0,
+        "sub-verse409_series1_15": 0,
+        "sub-verse409_series1_16": 0,
+        "sub-verse409_series1_17": 0,
+        "sub-verse409_series1_18": 0,
+        "sub-verse409_series1_19": 2,
+        "sub-verse409_series1_20": 2,
+        "sub-verse409_series1_21": 3,
+        "sub-verse409_series1_22": 3,
+        "sub-verse409_series1_23": 3,
+        "sub-verse409_series1_24": 1,
+        "sub-verse410_series1_8": 0,
+        "sub-verse410_series1_9": 0,
+        "sub-verse410_series1_10": 0,
+        "sub-verse410_series1_11": 0,
+        "sub-verse410_series1_12": 0,
+        "sub-verse410_series1_13": 0,
+        "sub-verse410_series1_14": 0,
+        "sub-verse410_series1_15": 0,
+        "sub-verse410_series1_16": 0,
+        "sub-verse410_series1_17": 0,
+        "sub-verse410_series1_18": 0,
+        "sub-verse410_series1_19": 1,
+        "sub-verse410_series1_20": 1,
+        "sub-verse410_series1_21": 2,
+        "sub-verse410_series1_22": 0,
+        "sub-verse410_series1_23": 0,
+        "sub-verse410_series1_24": 0,
+        "sub-verse411_series1_8": 0,
+        "sub-verse411_series1_9": 0,
+        "sub-verse411_series1_10": 0,
+        "sub-verse411_series1_11": 0,
+        "sub-verse411_series1_12": 0,
+        "sub-verse411_series1_13": 0,
+        "sub-verse411_series1_14": 0,
+        "sub-verse411_series1_15": 0,
+        "sub-verse411_series1_16": 0,
+        "sub-verse411_series1_17": 0,
+        "sub-verse411_series1_18": 0,
+        "sub-verse411_series1_19": 0,
+        "sub-verse411_series1_20": 0,
+        "sub-verse411_series1_21": 0,
+        "sub-verse411_series1_22": 0,
+        "sub-verse411_series1_23": 0,
+        "sub-verse411_series1_24": 0,
+        "sub-verse413_series1_8": 0,
+        "sub-verse413_series1_9": 0,
+        "sub-verse413_series1_10": 0,
+        "sub-verse413_series1_11": 0,
+        "sub-verse413_series1_12": 0,
+        "sub-verse413_series1_13": 0,
+        "sub-verse413_series1_14": 0,
+        "sub-verse413_series1_15": 0,
+        "sub-verse413_series1_16": 0,
+        "sub-verse413_series1_17": 0,
+        "sub-verse413_series1_18": 0,
+        "sub-verse413_series1_19": 0,
+        "sub-verse413_series1_20": 0,
+        "sub-verse413_series1_21": 0,
+        "sub-verse413_series1_22": 0,
+        "sub-verse413_series1_23": 0,
+        "sub-verse413_series1_24": 0,
+        "sub-verse415_series1_8": 0,
+        "sub-verse415_series1_9": 0,
+        "sub-verse415_series1_10": 0,
+        "sub-verse415_series1_11": 0,
+        "sub-verse415_series1_12": 0,
+        "sub-verse415_series1_13": 0,
+        "sub-verse415_series1_14": 0,
+        "sub-verse415_series1_15": 0,
+        "sub-verse415_series1_16": 0,
+        "sub-verse415_series1_17": 0,
+        "sub-verse415_series1_18": 0,
+        "sub-verse415_series1_19": 0,
+        "sub-verse415_series1_20": 0,
+        "sub-verse415_series1_21": 1,
+        "sub-verse415_series1_22": 0,
+        "sub-verse415_series1_23": 0,
+        "sub-verse415_series1_24": 0
+    },
+    "val": {
+        "sub-verse010_20": 3,
+        "sub-verse010_21": 0,
+        "sub-verse010_22": 0,
+        "sub-verse010_23": 0,
+        "sub-verse010_24": 0,
+        "sub-verse011_8": 1,
+        "sub-verse011_9": 0,
+        "sub-verse011_10": 1,
+        "sub-verse011_11": 0,
+        "sub-verse011_12": 0,
+        "sub-verse011_13": 3,
+        "sub-verse011_14": 1,
+        "sub-verse011_15": 3,
+        "sub-verse011_16": 0,
+        "sub-verse011_17": 0,
+        "sub-verse011_18": 0,
+        "sub-verse011_19": 0,
+        "sub-verse013_9": 0,
+        "sub-verse013_10": 0,
+        "sub-verse013_11": 0,
+        "sub-verse013_12": 0,
+        "sub-verse013_13": 0,
+        "sub-verse013_14": 0,
+        "sub-verse013_15": 0,
+        "sub-verse013_16": 0,
+        "sub-verse013_17": 0,
+        "sub-verse013_18": 0,
+        "sub-verse013_19": 0,
+        "sub-verse013_20": 3,
+        "sub-verse013_21": 2,
+        "sub-verse013_22": 1,
+        "sub-verse013_23": 1,
+        "sub-verse013_24": 1,
+        "sub-verse016_8": 0,
+        "sub-verse016_9": 0,
+        "sub-verse016_10": 0,
+        "sub-verse016_11": 0,
+        "sub-verse016_12": 0,
+        "sub-verse016_13": 0,
+        "sub-verse016_14": 1,
+        "sub-verse016_15": 0,
+        "sub-verse016_16": 0,
+        "sub-verse016_17": 0,
+        "sub-verse016_18": 0,
+        "sub-verse016_19": 0,
+        "sub-verse016_20": 0,
+        "sub-verse016_21": 0,
+        "sub-verse016_22": 0,
+        "sub-verse016_23": 0,
+        "sub-verse016_24": 0,
+        "sub-verse018_8": 0,
+        "sub-verse018_9": 0,
+        "sub-verse018_10": 0,
+        "sub-verse018_11": 0,
+        "sub-verse018_12": 0,
+        "sub-verse018_13": 0,
+        "sub-verse018_14": 0,
+        "sub-verse018_15": 0,
+        "sub-verse018_16": 0,
+        "sub-verse018_17": 0,
+        "sub-verse018_18": 0,
+        "sub-verse018_19": 0,
+        "sub-verse018_20": 0,
+        "sub-verse018_21": 0,
+        "sub-verse018_22": 0,
+        "sub-verse018_23": 0,
+        "sub-verse022_20": 0,
+        "sub-verse022_21": 0,
+        "sub-verse022_22": 3,
+        "sub-verse022_23": 2,
+        "sub-verse022_24": 0,
+        "sub-verse023_18": 0,
+        "sub-verse023_19": 0,
+        "sub-verse023_20": 1,
+        "sub-verse023_21": 0,
+        "sub-verse023_22": 0,
+        "sub-verse023_23": 0,
+        "sub-verse023_24": 1,
+        "sub-verse023_25": 0,
+        "sub-verse024_15": 0,
+        "sub-verse024_16": 0,
+        "sub-verse024_17": 0,
+        "sub-verse024_18": 0,
+        "sub-verse024_19": 1,
+        "sub-verse024_20": 3,
+        "sub-verse024_21": 0,
+        "sub-verse024_22": 0,
+        "sub-verse024_23": 0,
+        "sub-verse024_24": 0,
+        "sub-verse026_14": 0,
+        "sub-verse026_15": 1,
+        "sub-verse026_16": 0,
+        "sub-verse026_17": 0,
+        "sub-verse026_18": 0,
+        "sub-verse026_19": 3,
+        "sub-verse026_20": 1,
+        "sub-verse026_21": 0,
+        "sub-verse026_22": 0,
+        "sub-verse026_23": 2,
+        "sub-verse026_24": 2,
+        "sub-verse030_20": 2,
+        "sub-verse030_21": 1,
+        "sub-verse030_22": 1,
+        "sub-verse030_23": 0,
+        "sub-verse030_24": 0,
+        "sub-verse041_8": 0,
+        "sub-verse041_9": 0,
+        "sub-verse041_10": 0,
+        "sub-verse041_11": 0,
+        "sub-verse041_12": 0,
+        "sub-verse041_13": 0,
+        "sub-verse041_14": 0,
+        "sub-verse041_15": 0,
+        "sub-verse041_16": 0,
+        "sub-verse041_17": 0,
+        "sub-verse041_18": 0,
+        "sub-verse041_19": 0,
+        "sub-verse041_20": 0,
+        "sub-verse041_21": 0,
+        "sub-verse041_22": 0,
+        "sub-verse041_23": 0,
+        "sub-verse041_24": 0,
+        "sub-verse047_8": 0,
+        "sub-verse047_9": 0,
+        "sub-verse047_10": 0,
+        "sub-verse047_11": 0,
+        "sub-verse047_12": 0,
+        "sub-verse047_13": 0,
+        "sub-verse047_14": 3,
+        "sub-verse047_15": 0,
+        "sub-verse047_16": 0,
+        "sub-verse047_17": 0,
+        "sub-verse047_18": 1,
+        "sub-verse047_19": 0,
+        "sub-verse047_20": 0,
+        "sub-verse047_21": 0,
+        "sub-verse047_22": 0,
+        "sub-verse047_23": 0,
+        "sub-verse047_24": 0,
+        "sub-verse058_19": 0,
+        "sub-verse058_20": 0,
+        "sub-verse058_21": 0,
+        "sub-verse058_22": 0,
+        "sub-verse058_23": 0,
+        "sub-verse058_24": 0,
+        "sub-verse067_15": 0,
+        "sub-verse067_16": 0,
+        "sub-verse067_17": 0,
+        "sub-verse067_18": 0,
+        "sub-verse067_19": 0,
+        "sub-verse067_20": 0,
+        "sub-verse067_21": 0,
+        "sub-verse067_22": 0,
+        "sub-verse067_23": 0,
+        "sub-verse067_24": 0,
+        "sub-verse071_20": 0,
+        "sub-verse071_21": 0,
+        "sub-verse071_22": 0,
+        "sub-verse071_23": 0,
+        "sub-verse071_24": 0,
+        "sub-verse073_20": 0,
+        "sub-verse073_21": 0,
+        "sub-verse073_22": 0,
+        "sub-verse073_23": 0,
+        "sub-verse073_24": 0,
+        "sub-verse078_19": 0,
+        "sub-verse078_20": 3,
+        "sub-verse078_21": 0,
+        "sub-verse078_22": 0,
+        "sub-verse078_23": 0,
+        "sub-verse078_24": 0,
+        "sub-verse080_11": 2,
+        "sub-verse080_12": 0,
+        "sub-verse080_13": 0,
+        "sub-verse080_14": 1,
+        "sub-verse080_15": 1,
+        "sub-verse080_16": 2,
+        "sub-verse080_17": 0,
+        "sub-verse080_18": 0,
+        "sub-verse080_19": 0,
+        "sub-verse080_20": 2,
+        "sub-verse080_21": 1,
+        "sub-verse080_22": 0,
+        "sub-verse080_23": 2,
+        "sub-verse080_24": 1,
+        "sub-verse093_16": 0,
+        "sub-verse093_17": 0,
+        "sub-verse093_20": 3,
+        "sub-verse093_23": 2,
+        "sub-verse093_24": 0,
+        "sub-verse095_8": 0,
+        "sub-verse095_9": 0,
+        "sub-verse095_10": 0,
+        "sub-verse095_11": 2,
+        "sub-verse095_12": 0,
+        "sub-verse095_13": 0,
+        "sub-verse095_14": 0,
+        "sub-verse095_15": 0,
+        "sub-verse095_16": 0,
+        "sub-verse095_17": 0,
+        "sub-verse095_18": 0,
+        "sub-verse095_19": 0,
+        "sub-verse095_20": 0,
+        "sub-verse095_21": 0,
+        "sub-verse095_22": 1,
+        "sub-verse095_23": 2,
+        "sub-verse095_24": 0,
+        "sub-verse116_24": 0,
+        "sub-verse124_20": 1,
+        "sub-verse124_21": 2,
+        "sub-verse124_22": 2,
+        "sub-verse124_23": 2,
+        "sub-verse124_24": 1,
+        "sub-verse125_9": 0,
+        "sub-verse125_10": 1,
+        "sub-verse125_11": 0,
+        "sub-verse125_12": 0,
+        "sub-verse125_13": 3,
+        "sub-verse125_14": 0,
+        "sub-verse125_15": 0,
+        "sub-verse125_16": 1,
+        "sub-verse125_17": 1,
+        "sub-verse125_18": 1,
+        "sub-verse125_19": 2,
+        "sub-verse125_20": 2,
+        "sub-verse150_16": 0,
+        "sub-verse150_17": 0,
+        "sub-verse150_18": 1,
+        "sub-verse150_20": 3,
+        "sub-verse150_21": 0,
+        "sub-verse153_16": 1,
+        "sub-verse153_17": 2,
+        "sub-verse153_18": 2,
+        "sub-verse153_19": 1,
+        "sub-verse153_20": 3,
+        "sub-verse153_21": 1,
+        "sub-verse153_22": 1,
+        "sub-verse153_23": 2,
+        "sub-verse153_24": 0,
+        "sub-verse400_series1_10": 0,
+        "sub-verse400_series1_11": 0,
+        "sub-verse400_series1_12": 0,
+        "sub-verse400_series1_13": 0,
+        "sub-verse400_series1_14": 3,
+        "sub-verse400_series1_15": 0,
+        "sub-verse400_series1_16": 3,
+        "sub-verse400_series1_17": 0,
+        "sub-verse400_series1_18": 0,
+        "sub-verse400_series1_19": 0,
+        "sub-verse400_series1_20": 2,
+        "sub-verse400_series1_21": 2,
+        "sub-verse400_series1_22": 3,
+        "sub-verse400_series1_23": 0,
+        "sub-verse400_series1_24": 0,
+        "sub-verse404_series0_8": 0,
+        "sub-verse404_series0_9": 0,
+        "sub-verse221_8": 0,
+        "sub-verse221_9": 0,
+        "sub-verse225_8": 0,
+        "sub-verse225_9": 0,
+        "sub-verse230_8": 0,
+        "sub-verse230_9": 0,
+        "sub-verse412_series0_8": 0,
+        "sub-verse412_series0_9": 0,
+        "sub-verse242_8": 0,
+        "sub-verse252_8": 0,
+        "sub-verse252_9": 0,
+        "sub-verse252_10": 0,
+        "sub-verse252_11": 0,
+        "sub-verse252_12": 0,
+        "sub-verse252_13": 0,
+        "sub-verse252_14": 0,
+        "sub-verse252_15": 0,
+        "sub-verse252_16": 0,
+        "sub-verse252_17": 0,
+        "sub-verse252_18": 0,
+        "sub-verse252_19": 0,
+        "sub-verse252_20": 0,
+        "sub-verse252_21": 0,
+        "sub-verse252_22": 0,
+        "sub-verse252_23": 0,
+        "sub-verse404_series1_8": 0,
+        "sub-verse404_series1_9": 0,
+        "sub-verse404_series1_10": 0,
+        "sub-verse404_series1_11": 0,
+        "sub-verse404_series1_12": 0,
+        "sub-verse404_series1_13": 0,
+        "sub-verse404_series1_14": 0,
+        "sub-verse404_series1_15": 0,
+        "sub-verse404_series1_16": 0,
+        "sub-verse404_series1_17": 0,
+        "sub-verse404_series1_18": 0,
+        "sub-verse404_series1_19": 0,
+        "sub-verse404_series1_20": 0,
+        "sub-verse404_series1_21": 0,
+        "sub-verse404_series1_22": 0,
+        "sub-verse404_series1_23": 0,
+        "sub-verse404_series1_24": 0,
+        "sub-verse264_8": 0,
+        "sub-verse264_9": 0,
+        "sub-verse264_10": 0,
+        "sub-verse264_11": 0,
+        "sub-verse264_12": 0,
+        "sub-verse264_13": 0,
+        "sub-verse264_14": 0,
+        "sub-verse264_15": 0,
+        "sub-verse264_16": 0,
+        "sub-verse264_17": 0,
+        "sub-verse264_18": 0,
+        "sub-verse264_19": 0,
+        "sub-verse264_20": 3,
+        "sub-verse264_21": 0,
+        "sub-verse264_22": 0,
+        "sub-verse264_23": 0,
+        "sub-verse264_24": 0,
+        "sub-verse269_9": 0,
+        "sub-verse269_10": 0,
+        "sub-verse269_11": 0,
+        "sub-verse269_12": 0,
+        "sub-verse269_13": 0,
+        "sub-verse269_14": 0,
+        "sub-verse269_15": 0,
+        "sub-verse269_16": 1,
+        "sub-verse269_17": 1,
+        "sub-verse269_18": 0,
+        "sub-verse269_19": 0,
+        "sub-verse269_20": 0,
+        "sub-verse269_21": 0,
+        "sub-verse269_22": 1,
+        "sub-verse269_23": 1,
+        "sub-verse269_24": 0,
+        "sub-verse276_8": 0,
+        "sub-verse276_9": 0,
+        "sub-verse276_10": 0,
+        "sub-verse276_11": 0,
+        "sub-verse276_12": 0,
+        "sub-verse276_13": 0,
+        "sub-verse276_14": 0,
+        "sub-verse276_15": 0,
+        "sub-verse276_16": 0,
+        "sub-verse276_17": 0,
+        "sub-verse276_18": 0,
+        "sub-verse276_19": 1,
+        "sub-verse276_20": 0,
+        "sub-verse276_21": 0,
+        "sub-verse276_22": 0,
+        "sub-verse276_23": 0,
+        "sub-verse276_24": 0,
+        "sub-verse412_series1_8": 0,
+        "sub-verse412_series1_9": 0,
+        "sub-verse412_series1_10": 0,
+        "sub-verse412_series1_11": 0,
+        "sub-verse412_series1_12": 0,
+        "sub-verse412_series1_13": 0,
+        "sub-verse412_series1_14": 0,
+        "sub-verse412_series1_15": 1,
+        "sub-verse412_series1_16": 1,
+        "sub-verse412_series1_17": 0,
+        "sub-verse412_series1_18": 0,
+        "sub-verse412_series1_19": 2,
+        "sub-verse412_series1_20": 1,
+        "sub-verse412_series1_21": 2,
+        "sub-verse412_series1_22": 1,
+        "sub-verse412_series1_23": 0,
+        "sub-verse412_series1_24": 0
+    }
+}

datasets/raw/0007/0007.json

@@ -0,0 +1,50 @@
+[
+    {
+        "label": 17,
+        "X": 4.949121881359765,
+        "Y": 105.01303987337002,
+        "Z": 98.28936458882943
+    },
+    {
+        "label": 18,
+        "X": 22.963917117592715,
+        "Y": 104.28135145836083,
+        "Z": 98.88407021248516
+    },
+    {
+        "label": 19,
+        "X": 50.349900730980956,
+        "Y": 102.38405829798755,
+        "Z": 100.23161267033662
+    },
+    {
+        "label": 20,
+        "X": 77.50633167353335,
+        "Y": 102.35106033415059,
+        "Z": 100.20703687789096
+    },
+    {
+        "label": 21,
+        "X": 104.47138613177349,
+        "Y": 95.11139257996913,
+        "Z": 101.01669622089676
+    },
+    {
+        "label": 22,
+        "X": 132.90240595760932,
+        "Y": 87.06807332442239,
+        "Z": 99.48401756730952
+    },
+    {
+        "label": 23,
+        "X": 161.00800884787003,
+        "Y": 80.13662713092559,
+        "Z": 96.85088288013425
+    },
+    {
+        "label": 24,
+        "X": 188.4172078227643,
+        "Y": 75.91908069343272,
+        "Z": 93.20695691456322
+    }
+]

datasets/raw/0007/0007.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a357509a09b696b94ce923775e3638204df5097cc077cc3c4b95686e3bb34a39
+size 13843578

datasets/raw/0007/0007_msk.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c319b8334a76518466e3aa914860f7e30becd157c6f7e544198ed097f2a0b97a
+size 195059

datasets/straightened/CT/0007_18.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f5b6d714c03a37603a9b04b04a4859db4ae62cb3845346c25ff1fb26f3bad11
+size 9363428

datasets/straightened/CT/0007_19.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:81dd9cc077b7145db893634323652f9f82843924c15f0f7726a86cbbaf41ed2b
+size 10986869

datasets/straightened/CT/0007_20.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:759bd6f239efeb4e054408b2be3098ff797168e561ad588d2848cd4a6f06295f
+size 12616657

datasets/straightened/CT/0007_21.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9e25b4a26709f67bf9a980e46437b6686d88f990d78e31a63af4f7aaebc9a4e3
+size 13103420

datasets/straightened/CT/0007_22.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd84db5a2a0e6e8808a1e5750dee51650b0e217957cde314f0e3b428a2712ad1
+size 12793166

datasets/straightened/CT/0007_23.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6bb2b54b6ad32536e189f3209fbb041d95f1eb7d259c71ed8caa2047f66e92ea
+size 11081586

datasets/straightened/label/0007_18.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:beb2e06f38bbf1cc695b7cde3b59f40fa67215eca2bfd7b49a384de125f40700
+size 222229

datasets/straightened/label/0007_19.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:316b886125a6f9323c08f21ab91cc93da414ea1a6ae2225eb30479921e64ab34
+size 238415

datasets/straightened/label/0007_20.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:24e7bab70bdb78cb2f7f6eaf43edd91f44ae0ed342c9c07988661a1970508d49
+size 252946

datasets/straightened/label/0007_21.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2002efa3e5482c8ca7803cd92f9506bbaed086006f3409c7888fb3626901dc8
+size 253722

datasets/straightened/label/0007_22.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32b1c5705bc3d2c5aefa28d17d597a454093a67d44c0152ed8b75476b895526e
+size 249093

datasets/straightened/label/0007_23.nii.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bd43be84dcdd4482f9b0e3670cb287619fab7fa9a1983ddf2f84696a16dc1f5
+size 234749

eval_3d_sagittal_twostage.py

@@ -0,0 +1,263 @@
+#先生成目标椎体上下的椎体，再对目标椎体做生成
+
+import torch
+import numpy as np
+import nibabel as nib
+import os
+from options.test_options import TestOptions
+from models import create_model
+import torchvision.transforms as transforms
+from PIL import Image
+from models.inpaint_networks import Generator
+import torch.nn.functional as F
+import math
+from scipy.ndimage import label
+
+def remove_small_connected_components(input_array, min_size):
+
+
+    # 识别连通域
+    structure = np.ones((3, 3), dtype=np.int32)  # 定义连通性结构
+    labeled, ncomponents = label(input_array, structure)
+
+    # 遍历所有连通域，如果连通域大小小于阈值，则去除
+    for i in range(1, ncomponents + 1):
+        if np.sum(labeled == i) < min_size:
+            input_array[labeled == i] = 0
+
+    # 如果输入是张量，则转换回张量
+
+    return input_array
+
+def load_model(model_path, netG_params, device):
+    model = Generator(netG_params, True)
+    if os.path.exists(model_path):
+        model.load_state_dict(torch.load(model_path, map_location=device))
+        model.eval()
+    model.to(device)
+    return model
+
+def numpy_to_pil(img_np):
+    if img_np.dtype != np.uint8:
+        raise ValueError("NumPy array should have uint8 data type.")
+    img_pil = Image.fromarray(img_np)
+    return img_pil
+
+def run_model(model,CAM_data,label_data,ct_data,vert_id,index_ratio,A_transform,mask_transform,device,maxheight=40):
+    vert_label_slice = np.zeros_like(label_data)
+    vert_label_slice[label_data==vert_id]=1
+    
+    vert_label_slice = remove_small_connected_components(vert_label_slice,50)
+    coords = np.argwhere(vert_label_slice)
+    if coords.size==0:
+        return None
+    x1, x2 = min(coords[:, 0]), max(coords[:, 0])
+    width,length = vert_label_slice.shape
+    height = x2-x1
+    if height>maxheight:
+        x_mean = int(np.mean(coords[:, 0]))
+        x1 = x_mean-20
+        x2 = x1+40
+                
+    mask_x = (x1+x2)//2
+    h2 = maxheight
+    if mask_x<=h2//2:
+        min_x = 0
+        max_x = min_x + h2
+    elif width-mask_x<=h2/2:
+        max_x = width
+        min_x = max_x -h2
+    else:
+        min_x = mask_x-h2//2
+        max_x = min_x + h2
+        
+    mask_slice = np.zeros_like(vert_label_slice).astype(np.uint8)
+    mask_slice[min_x:max_x+1] = 255
+    ct_data_slice = np.zeros_like(mask_slice).astype(np.uint8)
+    ct_data_slice[:min_x,:] = ct_data[(x1-min_x):x1,:]
+    ct_data_slice[max_x:,:] = ct_data[x2:x2+(width-max_x),:]
+                
+    CAM_slice = np.zeros_like(mask_slice).astype(np.uint8)
+    CAM_slice[:min_x,:] = CAM_data[(x1-min_x):x1,:]
+    CAM_slice[max_x:,:] = CAM_data[x2:x2+(width-max_x),:]
+
+    ct_batch = numpy_to_pil(ct_data_slice)
+    ct_batch = A_transform(ct_batch)
+                
+    ori_ct = numpy_to_pil(ct_data.astype(np.uint8))
+    ori_ct = A_transform(ori_ct)
+                
+    mask_batch = numpy_to_pil(mask_slice)
+    mask_batch = mask_transform(mask_batch)
+                
+    CAM = numpy_to_pil(CAM_slice)
+    CAM = mask_transform(CAM)
+
+    ct_batch = ct_batch.unsqueeze(0).to(device)
+    mask_batch = mask_batch.unsqueeze(0).to(device)
+    CAM = CAM.unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        _, fake_B_mask_sigmoid, _, fake_B_raw, _,_,pred_h = model(ct_batch, mask_batch, 1-CAM,index_ratio)
+                    #print(pred_h)
+    pred_h = math.ceil(pred_h[0]*maxheight)
+
+    fake_B_mask_raw = torch.where(fake_B_mask_sigmoid > 0.5, torch.ones_like(fake_B_mask_sigmoid), torch.zeros_like(fake_B_mask_sigmoid))
+    #fake_B_mask_raw = fake_B_mask_raw.squeeze().cpu().numpy()*int(vert_id)
+
+    if pred_h<height:
+        pred_h = height
+    height_diff = pred_h-height
+    x_upper = x1-height_diff//2
+    x_bottom = x_upper+pred_h
+    single_image = torch.zeros_like(fake_B_raw)
+    single_image[:,:,x_upper:x_bottom,:] = fake_B_raw[:,:,x_upper:x_bottom,:]
+    ct_upper = torch.zeros_like(single_image)
+    ct_upper[0,:,:x_upper,:] = ori_ct[:, height_diff//2:x1, :]
+    ct_bottom = torch.zeros_like(single_image)
+    ct_bottom[0,:,x_bottom:,:] = ori_ct[:, x2:x2+256-x_bottom, :]
+    interpolated_image = single_image+ct_upper+ct_bottom
+    fake_B = interpolated_image.squeeze().cpu().numpy()
+    fake_B = (fake_B+1)*127.5
+    
+    mid_seg = np.zeros_like(fake_B_mask_raw.squeeze().cpu().numpy())
+    mid_seg[x_upper:x_bottom,:] = fake_B_mask_raw[:,:,x_upper:x_bottom,:].squeeze().cpu().numpy()*vert_id
+    seg_upper = np.zeros_like(mid_seg)
+    seg_upper[:x_upper,:] = label_data[height_diff//2:x1, :]
+    seg_bottom = np.zeros_like(mid_seg)
+    seg_bottom[x_bottom:,:] = label_data[x2:x2+256-x_bottom, :]
+    interpolated_seg = mid_seg+seg_upper+seg_bottom
+    fake_B_mask_raw = interpolated_seg
+    
+    
+    return fake_B_mask_raw,fake_B,height
+    
+
+def process_nii_files(folder_path,CAM_folder, model, output_folder, device):
+    A_transform = transforms.Compose([
+        transforms.Grayscale(1),
+        transforms.ToTensor(),
+        transforms.Normalize((0.5,), (0.5,))
+    ])
+
+    mask_transform = transforms.Compose([
+        transforms.ToTensor()
+    ])
+
+    if not os.path.exists(os.path.join(output_folder, 'CT')):
+        os.makedirs(os.path.join(output_folder, 'CT'))
+    if not os.path.exists(os.path.join(output_folder, 'label')):
+        os.makedirs(os.path.join(output_folder, 'label'))
+
+    count = 0
+    for file_name in os.listdir(folder_path):
+        #if file_name!="sub-verse013_22.nii.gz":
+        #    continue
+        if file_name.endswith('.nii.gz'):
+            if os.path.exists(os.path.join(output_folder, 'CT_fake', file_name)):
+                continue
+            #if file_name!="sub-verse004_20.nii.gz":
+            #    continue
+            file_path = os.path.join(folder_path, file_name)
+            label_path = file_path.replace('CT', 'label')
+            ct_nii = nib.load(file_path)
+            ct_data = ct_nii.get_fdata()
+            label_nii = nib.load(label_path)
+            label_data = label_nii.get_fdata()
+            patient_id, vert_id = file_name[:-7].rsplit('_', 1)
+            vert_id = int(vert_id)
+
+            CAM_path_0 = os.path.join(CAM_folder, file_name[:-7]+'_0.nii.gz')
+            CAM_path_1 = os.path.join(CAM_folder, file_name[:-7]+'_1.nii.gz')
+            CAM_path_2 = os.path.join(CAM_folder, file_name[:-7]+'.nii.gz')
+            if os.path.exists(CAM_path_0):
+                CAM_path = CAM_path_0
+            elif os.path.exists(CAM_path_1):
+                CAM_path = CAM_path_1
+            else:
+                CAM_path = CAM_path_2
+            
+            #print(CAM_path)
+            CAM_data = nib.load(CAM_path).get_fdata() * 255
+            
+            vert_label = np.zeros_like(label_data)
+            vert_label[label_data==vert_id]=1
+            
+            loc = np.where(vert_label)
+    
+            z0 = min(loc[2])
+            z1 = max(loc[2])
+            range_length = z1 - z0 + 1
+            new_range_length = int(range_length * 4 / 5)
+            new_z0 = z0 + (range_length - new_range_length) // 2
+            new_z1 = new_z0 + new_range_length - 1
+
+            output_ct_data = np.zeros_like(ct_data)
+            output_seg_data = np.zeros_like(ct_data)
+            center_index = (new_z0 + new_z1) // 2
+            
+            maxheight = 40
+            
+            for z in range(new_z0, new_z1 + 1):
+                index_ratio = abs(z-center_index)/range_length*2
+                index_ratio = torch.tensor([index_ratio])
+                if int(vert_id)>8 and np.sum(label_data[:, :, z]==int(vert_id)-1)>200:
+                    #print("upper exists and sum=",np.sum(label_data[:, :, z]==int(vert_id)-1))
+                    vert_id_upper = int(vert_id)-1
+                    #print("upper exists")
+                    fake_B_mask_upper,fake_B_ct_upper,_ = run_model(model,CAM_data[:, :, z],label_data[:, :, z],ct_data[:, :, z],vert_id_upper,index_ratio,\
+                    A_transform,mask_transform,device,maxheight)
+                else:
+                    fake_B_mask_upper,fake_B_ct_upper = label_data[:, :, z],ct_data[:, :, z]
+                    #print("upper dont exists and sum=",np.sum(label_data[:, :, z]==int(vert_id)-1))
+                if int(vert_id)<24 and np.sum(label_data[:, :, z]==int(vert_id)+1)>200:
+                    #print("bottom exists and sum=",np.sum(label_data[:, :, z]==int(vert_id)+1))
+                    vert_id_bottom = int(vert_id)+1
+                    #print("bottom exists")
+                    fake_B_mask_bottom,fake_B_ct_bottom,_ = run_model(model,CAM_data[:, :, z],fake_B_mask_upper,fake_B_ct_upper,vert_id_bottom,index_ratio,\
+                    A_transform,mask_transform,device,maxheight)
+                else:
+                    fake_B_mask_bottom,fake_B_ct_bottom = fake_B_mask_upper,fake_B_ct_upper
+                    #print("bottom dont exists and sum=",np.sum(label_data[:, :, z]==int(vert_id)+1))
+
+                    
+                output = run_model(model,CAM_data[:, :, z],fake_B_mask_bottom,fake_B_ct_bottom,int(vert_id),index_ratio,\
+                    A_transform,mask_transform,device,maxheight)
+                if output==None:
+                    continue
+                else:
+                    fake_B_mask_raw,fake_B,height = output
+                    if height>maxheight:
+                        print("Height exceeds in %s, in slice %d"%(file_name,z))
+                
+                output_seg_data[:, :, z] = fake_B_mask_raw
+                output_ct_data[:, :, z] = fake_B
+
+            new_ct_nii = nib.Nifti1Image(output_ct_data, ct_nii.affine)
+            nib.save(new_ct_nii, os.path.join(output_folder, 'CT_fake', file_name))
+            new_label_nii = nib.Nifti1Image(output_seg_data, ct_nii.affine)
+            nib.save(new_label_nii, os.path.join(output_folder, 'label_fake', file_name))
+            print(f"Now {file_name} has been generateed in {output_folder}")
+            count+=1
+            
+
+def main():
+    model_path = '/home/zhangqi/Project/pytorch-CycleGAN-and-pix2pix-master/checkpoints/0421_adaptive_sagittal/latest_net_G.pth'
+    netG_params = {'input_dim': 1, 'ngf': 16}
+    #folder_path = '/home/zhangqi/Project/pytorch-CycleGAN-and-pix2pix-master/datasets/straighten/revised/CT'
+    #CAM_folder = '/home/zhangqi/Project/VertebralFractureGrading/heatmap/straighten_sagittal/binaryclass_1'
+    #output_folder = '/home/zhangqi/Project/pytorch-CycleGAN-and-pix2pix-master/output_3d/sagittal/fine'
+    folder_path = '/home/zhangqi/Project/pytorch-CycleGAN-and-pix2pix-master/datasets/local/straighten/CT'
+    CAM_folder = '/home/zhangqi/Project/VertebralFractureGrading/heatmap/local_sagittal_0508/binaryclass_1'
+    output_folder = '/home/zhangqi/Project/pytorch-CycleGAN-and-pix2pix-master/output_3d/local_dataset/sagittal/fine'
+    if not os.path.exists(output_folder+'/CT_fake'):
+        os.makedirs(output_folder+'/CT_fake')
+    if not os.path.exists(output_folder+'/label_fake'):
+        os.makedirs(output_folder+'/label_fake')
+    device = 'cuda:0'
+
+    model = load_model(model_path, netG_params, device)
+    process_nii_files(folder_path,CAM_folder, model, output_folder, device)
+
+if __name__ == "__main__":
+    main()

evaluation/RHLV_quantification.py

@@ -0,0 +1,212 @@
+import json
+import numpy as np
+import os
+import nibabel as nib
+import matplotlib.pyplot as plt
+import cv2
+import pandas as pd
+from sklearn.model_selection import ParameterGrid
+
+def rotate_image_to_horizontal(binary_image):
+    """
+    Rotates the image to make the major axis of the object horizontal.
+    """
+    # 寻找轮廓
+    binary_image = binary_image.astype(np.uint8)
+    contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # 假设最大的轮廓是椎体
+    contour = max(contours, key=cv2.contourArea)
+
+    # 获取轮廓的最小外接矩形
+    rect = cv2.minAreaRect(contour)
+    box = cv2.boxPoints(rect)
+    box = np.int0(box)
+
+    # 计算旋转角度
+    angle = rect[2]
+    if angle < -45:
+        angle += 90
+    if angle > 45:
+        angle-=90
+
+    # 旋转图像
+    (h, w) = binary_image.shape[:2]
+    center = (w // 2, h // 2)
+    M = cv2.getRotationMatrix2D(center, angle, 1.0)
+    rotated_image = cv2.warpAffine(binary_image, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_CONSTANT)
+
+    return rotated_image
+
+def calculate_heights(segmentation_fake,segmentation_label,height_threshold):
+    all_heights_fake = []
+    all_heights_label = []
+    pre_heights_fake = []
+    pre_heights_label = []
+    mid_heights_fake = []
+    mid_heights_label = []
+    post_heights_fake = []
+    post_heights_label = []
+    # 遍历z轴上的每个层
+    for z in range(segmentation_label.shape[2]):
+        if np.any(segmentation_label[:, :, z]) and np.any(segmentation_fake[:, :, z]):
+            segmentation_label_slice = segmentation_label[:, :, z]
+            segmentation_fake_slice = segmentation_fake[:, :, z]
+            
+            loc = np.where(segmentation_fake_slice)[1]
+            y_min = int(np.min(loc))
+            y_max = int(np.max(loc))
+            y_range = y_max-y_min
+            one_third_y = int(y_min + y_range/3)
+            two_third_y = int(y_min + 2*y_range/3)
+            center_height_fake = np.count_nonzero(segmentation_fake_slice[:, int(np.mean(loc))])
+            all_height_fake = np.count_nonzero(segmentation_fake_slice, axis=0)
+            pre_height_fake = np.count_nonzero(segmentation_fake_slice[:,:one_third_y], axis=0)
+            mid_height_fake = np.count_nonzero(segmentation_fake_slice[:,one_third_y:two_third_y], axis=0)
+            post_height_fake = np.count_nonzero(segmentation_fake_slice[:, two_third_y:], axis=0)
+            
+            loc = np.where(segmentation_label[:, :, z])[1]
+            center_height_label = np.count_nonzero(segmentation_label_slice[:, int(np.mean(loc))])
+            all_height_label = np.count_nonzero(segmentation_label_slice, axis=0)
+            pre_height_label = np.count_nonzero(segmentation_label_slice[:, :one_third_y], axis=0)
+            mid_height_label = np.count_nonzero(segmentation_label_slice[:, one_third_y:two_third_y], axis=0)
+            post_height_label = np.count_nonzero(segmentation_label_slice[:, two_third_y:], axis=0)
+            
+
+            all_scale_ratio = 1
+            pre_scale_ratio = 1
+            mid_scale_ratio = 1
+            post_scale_ratio = 1
+            if all_height_label.size > 0 and all_height_fake.size > 0:
+                if all_height_label.max()>all_height_fake.max():
+                    all_scale_ratio = all_height_label.max()/(all_height_fake.max()+1e-6)
+            if pre_height_label.size > 0 and pre_height_fake.size > 0:
+                if pre_height_label.max()>pre_height_fake.max():
+                    pre_scale_ratio = pre_height_label.max()/(pre_height_fake.max()+1e-6)
+            if mid_height_label.size > 0 and mid_height_fake.size > 0:
+                if mid_height_label.max()>mid_height_fake.max():
+                    mid_scale_ratio = mid_height_label.max()/(mid_height_fake.max()+1e-6)
+            if post_height_label.size > 0 and post_height_fake.size > 0:
+                if post_height_label.max()>post_height_fake.max():
+                    post_scale_ratio = post_height_label.max()/(post_height_fake.max()+1e-6)
+                
+            all_height_fake = all_height_fake*all_scale_ratio
+            center_height_fake = center_height_fake*all_scale_ratio
+            pre_height_fake = pre_height_fake*pre_scale_ratio
+            mid_height_fake = mid_height_fake*mid_scale_ratio
+            post_height_fake = post_height_fake*post_scale_ratio
+                
+            all_heights_fake.extend(all_height_fake[all_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            all_heights_label.extend(all_height_label[all_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+            pre_heights_fake.extend(pre_height_fake[pre_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            pre_heights_label.extend(pre_height_label[pre_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+            mid_heights_fake.extend(mid_height_fake[mid_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            mid_heights_label.extend(mid_height_label[mid_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+            post_heights_fake.extend(post_height_fake[post_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            post_heights_label.extend(post_height_label[post_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+    
+    # 将heights转换为numpy数组以便使用numpy的功能
+    all_heights_fake = np.array(all_heights_fake)
+    all_heights_label = np.array(all_heights_label)
+    pre_heights_fake = np.array(pre_heights_fake)
+    pre_heights_label = np.array(pre_heights_label)
+    mid_heights_fake = np.array(mid_heights_fake)
+    mid_heights_label = np.array(mid_heights_label)
+    post_heights_fake = np.array(post_heights_fake)
+    post_heights_label = np.array(post_heights_label)
+
+    return all_heights_fake, all_heights_label,pre_heights_fake, pre_heights_label,mid_heights_fake, mid_heights_label,post_heights_fake, post_heights_label
+
+
+def calculate_rhlv(segmentation_fake, segmentation_label, center_z, length,vertebra,height_threshold):
+    """
+    Calculate the Relative Height Loss Value (RHLV) between fake and label segmentations.
+    """
+    seg_fake_filtered = segmentation_fake[:, :, center_z-length:center_z+length]
+    seg_label_filtered = segmentation_label[:, :, center_z-length:center_z+length]
+
+    all_heights_fake, all_heights_label,pre_heights_fake, pre_heights_label,mid_heights_fake, mid_heights_label,post_heights_fake, post_heights_label\
+        = calculate_heights(seg_fake_filtered, seg_label_filtered,height_threshold)
+    all_height_fake = np.mean(all_heights_fake) if all_heights_fake.size > 0 else 0
+    all_height_label = np.mean(all_heights_label) if all_heights_label.size > 0 else 0
+    pre_height_fake = np.mean(pre_heights_fake) if pre_heights_fake.size > 0 else 0
+    pre_height_label = np.mean(pre_heights_label) if pre_heights_label.size > 0 else 0
+    mid_height_fake = np.mean(mid_heights_fake) if mid_heights_fake.size > 0 else 0
+    mid_height_label = np.mean(mid_heights_label) if mid_heights_label.size > 0 else 0
+    post_height_fake = np.mean(post_heights_fake) if post_heights_fake.size > 0 else 0
+    post_height_label = np.mean(post_heights_label) if post_heights_label.size > 0 else 0
+    
+    all_rhlv = (all_height_fake - all_height_label) / (all_height_fake +1e-6)
+    pre_rhlv = (pre_height_fake - pre_height_label) / (pre_height_fake +1e-6)
+    mid_rhlv = (mid_height_fake - mid_height_label) / (mid_height_fake +1e-6)
+    post_rhlv = (post_height_fake - post_height_label) / (post_height_fake +1e-6)
+    min_height = min(pre_height_label,mid_height_label,post_height_label)
+    max_height = max(pre_height_label,mid_height_label,post_height_label)
+    relative_height_label = min_height/(max_height+1e-6)
+
+    return all_rhlv,pre_rhlv,mid_rhlv,post_rhlv,relative_height_label
+
+def process_datasets_to_excel(dataset_info, label_folder, fake_folder, output_file,length_divisor=5, height_threshold=0.64):
+    results = []
+    for dataset_type, data in dataset_info.items():
+        for vertebra, label in data.items():
+            label_path = os.path.join(label_folder, vertebra + '.nii.gz')
+            fake_path = os.path.join(fake_folder, vertebra + '.nii.gz')
+
+            if not os.path.exists(label_path) or not os.path.exists(fake_path):
+                continue
+
+            segmentation_label_temp = nib.load(label_path).get_fdata()
+            segmentation_label = np.zeros_like(segmentation_label_temp)
+            
+            segmentation_fake_temp = nib.load(fake_path).get_fdata()
+            segmentation_fake = np.zeros_like(segmentation_fake_temp)
+            
+            label_index = int(vertebra.split('_')[-1])
+            segmentation_label[segmentation_label_temp == label_index] = 1
+            segmentation_fake[segmentation_fake_temp == label_index] = 1
+            
+            loc = np.where(segmentation_label)[2]
+            if loc.size == 0:
+                continue  # Skip if no label index found
+
+            min_z = np.min(loc)
+            max_z = np.max(loc)
+            center_z = int(np.mean(loc))
+            length = (max_z - min_z) // length_divisor  # Divisor adjusted based on your setup
+            
+
+            all_rhlv, pre_rhlv, mid_rhlv, post_rhlv, relative_height_label = calculate_rhlv(
+                segmentation_fake, segmentation_label, center_z, length, vertebra,height_threshold
+            )
+            results.append({
+                "Vertebra": vertebra,
+                "Label": label,
+                "Dataset": dataset_type,
+                "All RHLV": all_rhlv,
+                "Pre RHLV": pre_rhlv,
+                "Mid RHLV": mid_rhlv,
+                "Post RHLV": post_rhlv,
+                "Relative Height Label": relative_height_label
+            })
+
+    # Create a DataFrame from results and save to Excel
+    df = pd.DataFrame(results)
+    df.to_excel(output_file, index=False)
+
+def main():
+    with open('vertebra_data_local.json', 'r') as file:
+       json_data = json.load(file)
+    
+    label_folder = '/dssg/home/acct-milesun/zhangqi/Dataset/HealthiVert_straighten/label'
+    output_folder = '/dssg/home/acct-milesun/zhangqi/Project/HealthiVert-GAN_eval/output'
+    result_folder = '/dssg/home/acct-milesun/zhangqi/Project/HealthiVert-GAN_eval/evaluation/RHLV_quantification'
+    for root, dirs, files in os.walk(output_folder):
+        for dir in dirs:
+            exp_folder = os.path.join(root,dir)
+            fake_folder = os.path.join(exp_folder,'label_fake')
+            result_file = os.path.join(result_folder,dir+'.xlsx')
+            process_datasets_to_excel(json_data, label_folder, fake_folder, result_file, length_divisor=5, height_threshold=0.7)
+
+if __name__ == "__main__":
+    main()

evaluation/RHLV_quantification_coronal.py

@@ -0,0 +1,218 @@
+import json
+import numpy as np
+import os
+import nibabel as nib
+import matplotlib.pyplot as plt
+import cv2
+import pandas as pd
+from sklearn.model_selection import ParameterGrid
+
+def rotate_image_to_horizontal(binary_image):
+    """
+    Rotates the image to make the major axis of the object horizontal.
+    """
+    # 寻找轮廓
+    binary_image = binary_image.astype(np.uint8)
+    contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    # 假设最大的轮廓是椎体
+    contour = max(contours, key=cv2.contourArea)
+
+    # 获取轮廓的最小外接矩形
+    rect = cv2.minAreaRect(contour)
+    box = cv2.boxPoints(rect)
+    box = np.int0(box)
+
+    # 计算旋转角度
+    angle = rect[2]
+    if angle < -45:
+        angle += 90
+    if angle > 45:
+        angle-=90
+
+    # 旋转图像
+    (h, w) = binary_image.shape[:2]
+    center = (w // 2, h // 2)
+    M = cv2.getRotationMatrix2D(center, angle, 1.0)
+    rotated_image = cv2.warpAffine(binary_image, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_CONSTANT)
+
+    return rotated_image
+
+def calculate_heights(segmentation_fake,segmentation_label,height_threshold):
+    all_heights_fake = []
+    all_heights_label = []
+    pre_heights_fake = []
+    pre_heights_label = []
+    mid_heights_fake = []
+    mid_heights_label = []
+    post_heights_fake = []
+    post_heights_label = []
+    # 遍历z轴上的每个层
+    for z in range(segmentation_label.shape[1]):
+        if np.any(segmentation_label[:, z, :]) and np.any(segmentation_fake[:, z, :]):
+            segmentation_label_slice = segmentation_label[:, z, :]
+            segmentation_fake_slice = segmentation_fake[:, z, :]
+            
+            loc = np.where(segmentation_fake_slice)[1]
+            y_min = int(np.min(loc))
+            y_max = int(np.max(loc))
+            y_range = y_max-y_min
+            one_third_y = int(y_min + y_range/3)
+            two_third_y = int(y_min + 2*y_range/3)
+            center_height_fake = np.count_nonzero(segmentation_fake_slice[:, int(np.mean(loc))])
+            all_height_fake = np.count_nonzero(segmentation_fake_slice, axis=0)
+            pre_height_fake = np.count_nonzero(segmentation_fake_slice[:,:one_third_y], axis=0)
+            mid_height_fake = np.count_nonzero(segmentation_fake_slice[:,one_third_y:two_third_y], axis=0)
+            post_height_fake = np.count_nonzero(segmentation_fake_slice[:, two_third_y:], axis=0)
+            
+            loc = np.where(segmentation_label_slice)[1]
+            center_height_label = np.count_nonzero(segmentation_label_slice[:, int(np.mean(loc))])
+            all_height_label = np.count_nonzero(segmentation_label_slice, axis=0)
+            pre_height_label = np.count_nonzero(segmentation_label_slice[:, :one_third_y], axis=0)
+            mid_height_label = np.count_nonzero(segmentation_label_slice[:, one_third_y:two_third_y], axis=0)
+            post_height_label = np.count_nonzero(segmentation_label_slice[:, two_third_y:], axis=0)
+            
+
+            if all_height_label.max()>all_height_fake.max():
+                all_scale_ratio = all_height_label.max()/all_height_fake.max()
+            else:
+                all_scale_ratio = 1
+            if pre_height_label.max()>pre_height_fake.max():
+                pre_scale_ratio = pre_height_label.max()/pre_height_fake.max()
+            else:
+                pre_scale_ratio = 1
+            if mid_height_label.max()>mid_height_fake.max():
+                mid_scale_ratio = mid_height_label.max()/mid_height_fake.max()
+            else:
+                mid_scale_ratio = 1
+            if post_height_label.max()>post_height_fake.max():
+                post_scale_ratio = post_height_label.max()/post_height_fake.max()
+            else:
+                post_scale_ratio = 1
+                
+            all_height_fake = all_height_fake*all_scale_ratio
+            center_height_fake = center_height_fake*all_scale_ratio
+            pre_height_fake = pre_height_fake*pre_scale_ratio
+            mid_height_fake = mid_height_fake*mid_scale_ratio
+            post_height_fake = post_height_fake*post_scale_ratio
+                
+            all_heights_fake.extend(all_height_fake[all_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            all_heights_label.extend(all_height_label[all_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+            pre_heights_fake.extend(pre_height_fake[pre_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            pre_heights_label.extend(pre_height_label[pre_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+            mid_heights_fake.extend(mid_height_fake[mid_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            mid_heights_label.extend(mid_height_label[mid_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+            post_heights_fake.extend(post_height_fake[post_height_fake > (center_height_fake*height_threshold)])  # 仅添加非零高度
+            post_heights_label.extend(post_height_label[post_height_label > (center_height_label*height_threshold)])  # 仅添加非零高度
+    
+    # 将heights转换为numpy数组以便使用numpy的功能
+    all_heights_fake = np.array(all_heights_fake)
+    all_heights_label = np.array(all_heights_label)
+    pre_heights_fake = np.array(pre_heights_fake)
+    pre_heights_label = np.array(pre_heights_label)
+    mid_heights_fake = np.array(mid_heights_fake)
+    mid_heights_label = np.array(mid_heights_label)
+    post_heights_fake = np.array(post_heights_fake)
+    post_heights_label = np.array(post_heights_label)
+
+    return all_heights_fake, all_heights_label,pre_heights_fake, pre_heights_label,mid_heights_fake, mid_heights_label,post_heights_fake, post_heights_label
+
+
+def calculate_rhlv(segmentation_fake, segmentation_label, center_z, length,vertebra,height_threshold):
+    """
+    Calculate the Relative Height Loss Value (RHLV) between fake and label segmentations.
+    """
+    seg_fake_filtered = segmentation_fake[:, center_z-length:center_z+length, :]
+    seg_label_filtered = segmentation_label[:, center_z-length:center_z+length, :]
+
+    all_heights_fake, all_heights_label,pre_heights_fake, pre_heights_label,mid_heights_fake, mid_heights_label,post_heights_fake, post_heights_label\
+        = calculate_heights(seg_fake_filtered, seg_label_filtered,height_threshold)
+    all_height_fake = np.mean(all_heights_fake) if all_heights_fake.size > 0 else 0
+    all_height_label = np.mean(all_heights_label) if all_heights_label.size > 0 else 0
+    pre_height_fake = np.mean(pre_heights_fake) if pre_heights_fake.size > 0 else 0
+    pre_height_label = np.mean(pre_heights_label) if pre_heights_label.size > 0 else 0
+    mid_height_fake = np.mean(mid_heights_fake) if mid_heights_fake.size > 0 else 0
+    mid_height_label = np.mean(mid_heights_label) if mid_heights_label.size > 0 else 0
+    post_height_fake = np.mean(post_heights_fake) if post_heights_fake.size > 0 else 0
+    post_height_label = np.mean(post_heights_label) if post_heights_label.size > 0 else 0
+    
+    all_rhlv = (all_height_fake - all_height_label) / (all_height_fake +1e-6)
+    pre_rhlv = (pre_height_fake - pre_height_label) / (pre_height_fake +1e-6)
+    mid_rhlv = (mid_height_fake - mid_height_label) / (mid_height_fake +1e-6)
+    post_rhlv = (post_height_fake - post_height_label) / (post_height_fake +1e-6)
+    min_height = min(pre_height_label,mid_height_label,post_height_label)
+    max_height = max(pre_height_label,mid_height_label,post_height_label)
+    relative_height_label = min_height/(max_height+1e-6)
+
+    return all_rhlv,pre_rhlv,mid_rhlv,post_rhlv,relative_height_label
+
+def process_datasets_to_excel(dataset_info, label_folder, fake_folder, output_file,length_divisor=5, height_threshold=0.64):
+    results = []
+    for dataset_type, data in dataset_info.items():
+        for vertebra, label in data.items():
+            label_path = os.path.join(label_folder, vertebra + '.nii.gz')
+            fake_path = os.path.join(fake_folder, vertebra + '.nii.gz')
+
+            if not os.path.exists(label_path) or not os.path.exists(fake_path):
+                continue
+
+            segmentation_label_temp = nib.load(label_path).get_fdata()
+            segmentation_label = np.zeros_like(segmentation_label_temp)
+            
+            segmentation_fake_temp = nib.load(fake_path).get_fdata()
+            segmentation_fake = np.zeros_like(segmentation_fake_temp)
+            
+            label_index = int(vertebra.split('_')[-1])
+            segmentation_label[segmentation_label_temp == label_index] = 1
+            segmentation_fake[segmentation_fake_temp == label_index] = 1
+            
+            loc = np.where(segmentation_label)[1]
+            if loc.size == 0:
+                continue  # Skip if no label index found
+
+            min_z = np.min(loc)
+            max_z = np.max(loc)
+            center_z = int(np.mean(loc))
+            length = (max_z - min_z) // length_divisor  # Divisor adjusted based on your setup
+            
+
+            all_rhlv, pre_rhlv, mid_rhlv, post_rhlv, relative_height_label = calculate_rhlv(
+                segmentation_fake, segmentation_label, center_z, length, vertebra,height_threshold
+            )
+            print(pre_rhlv,mid_rhlv,post_rhlv)
+            results.append({
+                "Vertebra": vertebra,
+                "Label": label,
+                "Dataset": dataset_type,
+                "All RHLV": all_rhlv,
+                "Pre RHLV": pre_rhlv,
+                "Mid RHLV": mid_rhlv,
+                "Post RHLV": post_rhlv,
+                "Relative Height Label": relative_height_label
+            })
+
+    # Create a DataFrame from results and save to Excel
+    df = pd.DataFrame(results)
+    df.to_excel(output_file, index=False)
+
+def main():
+    with open('vertebra_data.json', 'r') as file:
+       json_data = json.load(file)
+    
+    label_folder ="datasets/straighten/revised/label"
+    output_folder = 'output_3d/coronal'
+    result_folder = 'RHLV_quantification'
+    if not os.path.exists(result_folder):
+        os.makedirs(result_folder)
+    for root, dirs, files in os.walk(output_folder):
+        for dir in dirs:
+            if dir!='fine':
+                continue
+            
+            exp_folder = os.path.join(root,dir)
+            fake_folder = os.path.join(exp_folder,'label_fake')
+            result_file = os.path.join(result_folder,dir+'.xlsx')
+            process_datasets_to_excel(json_data, label_folder, fake_folder, result_file, length_divisor=5, height_threshold=0.7)
+
+if __name__ == "__main__":
+    main()

evaluation/SVM_grading.py

@@ -0,0 +1,96 @@
+import pandas as pd
+from sklearn.model_selection import StratifiedKFold
+from sklearn.svm import SVC
+from sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score, confusion_matrix
+from sklearn.preprocessing import StandardScaler
+import numpy as np
+import os
+
+def evaluate_svm(filepath, features, output_txt='evaluation_results.txt'):
+    # 加载数据
+    data = pd.read_excel(filepath)
+    train_test_data = data[data['Dataset'].isin(['train', 'test'])]
+    val_data = data[data['Dataset'] == 'val']
+
+    # 准备输入和标签
+    X_train_test = train_test_data[features]
+    y_train_test = train_test_data['Label']
+    X_val = val_data[features]
+    y_val = val_data['Label']
+
+    # 数据标准化
+    scaler = StandardScaler()
+    X_train_test_scaled = scaler.fit_transform(X_train_test)
+    X_val_scaled = scaler.transform(X_val)
+
+    # 初始化 SVM 分类器
+    svm_classifier = SVC(kernel='linear', class_weight='balanced')
+
+    # 设置五折交叉验证
+    skf = StratifiedKFold(n_splits=5)
+
+    # 存储每次验证的结果
+    results = []
+    f1_list, precision_list, recall_list, accuracy_list = [], [], [], []
+
+    for train_index, test_index in skf.split(X_train_test_scaled, y_train_test):
+        X_train, X_test = X_train_test_scaled[train_index], X_train_test_scaled[test_index]
+        y_train, y_test = y_train_test[train_index], y_train_test[test_index]
+        
+        svm_classifier.fit(X_train, y_train)
+        y_pred_val = svm_classifier.predict(X_val_scaled)
+        cm = confusion_matrix(y_val, y_pred_val)
+        f1 = f1_score(y_val, y_pred_val, average='macro')
+        precision = precision_score(y_val, y_pred_val, average='macro')
+        recall = recall_score(y_val, y_pred_val, average='macro')
+        accuracy = accuracy_score(y_val, y_pred_val)
+        
+        results.append((cm, f1, precision, recall, accuracy))
+        f1_list.append(f1)
+        precision_list.append(precision)
+        recall_list.append(recall)
+        accuracy_list.append(accuracy)
+
+    # 写入结果到文件
+    with open(output_txt, 'w') as file:
+        for i, (cm, f1, precision, recall, accuracy) in enumerate(results):
+            file.write(f"Fold {i+1}:\n")
+            file.write("Confusion Matrix:\n")
+            file.write(f"{cm}\n")
+            file.write(f"F1 Score: {f1}, Precision: {precision}, Recall: {recall}, Accuracy: {accuracy}\n")
+            file.write("\n")
+        
+        # 计算平均分数和方差
+        average_f1 = np.mean(f1_list)
+        average_precision = np.mean(precision_list)
+        average_recall = np.mean(recall_list)
+        average_accuracy = np.mean(accuracy_list)
+        variance_f1 = np.var(f1_list)
+        variance_precision = np.var(precision_list)
+        variance_recall = np.var(recall_list)
+        variance_accuracy = np.var(accuracy_list)
+
+        file.write("Average Scores:\n")
+        file.write(f"Average F1 Score: {average_f1} (Variance: {variance_f1})\n")
+        file.write(f"Average Precision: {average_precision} (Variance: {variance_precision})\n")
+        file.write(f"Average Recall: {average_recall} (Variance: {variance_recall})\n")
+        file.write(f"Average Accuracy: {average_accuracy} (Variance: {variance_accuracy})\n")
+
+    print(f"Results saved to {output_txt}")
+
+def main():
+    result_folder = 'evaluation/RHLV_quantification'
+    grading_folder = 'evaluation/classification_metric'
+    if not os.path.exists(grading_folder):
+        os.makedirs(grading_folder)
+    features = ['Pre RHLV', 'Mid RHLV', 'Post RHLV']
+    for xlsx_file in os.listdir(result_folder):
+        #if xlsx_file != 'Exp_1_wo_straighten_sagittal.xlsx':
+        #    continue
+        xlsx_path = os.path.join(result_folder, xlsx_file)
+        xlsx_name = xlsx_file.split('.')[0]
+        saveTxT_path = os.path.join(grading_folder, xlsx_name + '.txt')
+        evaluate_svm(xlsx_path, features, saveTxT_path)
+
+if __name__ == "__main__":
+    main()

evaluation/SVM_grading_2.5d.py

@@ -0,0 +1,100 @@
+import pandas as pd
+from sklearn.model_selection import StratifiedKFold
+from sklearn.svm import SVC
+from sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score, confusion_matrix
+from sklearn.preprocessing import StandardScaler
+import numpy as np
+import os
+
+def evaluate_svm(file1, file2, features, output_txt='evaluation_results.txt'):
+    # 加载数据
+    data1 = pd.read_excel(file1)
+    data2 = pd.read_excel(file2)
+
+    # 重命名第二个文件的特征，以避免冲突
+    rename_dict = {f: f"{f}_2" for f in features}
+    data2.rename(columns=rename_dict, inplace=True)
+
+    # 确保数据有一个共同的列来合并（例如 ID）
+    combined_data = pd.merge(data1, data2, on="Vertebra")
+    print(combined_data)
+
+    # 选取参与训练和测试的数据
+    train_test_data = combined_data[combined_data['Dataset_x'].isin(['train', 'test'])]
+    val_data = combined_data[combined_data['Dataset_x'] == 'val']
+
+    # 准备输入和标签
+    combined_features = features + [f"{f}_2" for f in features]
+    X_train_test = train_test_data[combined_features]
+    y_train_test = train_test_data['Label_x']
+    X_val = val_data[combined_features]
+    y_val = val_data['Label_x']
+
+    # 数据标准化
+    scaler = StandardScaler()
+    X_train_test_scaled = scaler.fit_transform(X_train_test)
+    X_val_scaled = scaler.transform(X_val)
+
+    # 初始化 SVM 分类器
+    svm_classifier = SVC(kernel='linear', class_weight='balanced')
+
+    # 设置五折交叉验证
+    skf = StratifiedKFold(n_splits=5)
+
+    # 存储每次验证的结果
+    results = []
+
+    for train_index, test_index in skf.split(X_train_test_scaled, y_train_test):
+        X_train, X_test = X_train_test_scaled[train_index], X_train_test_scaled[test_index]
+        y_train, y_test = y_train_test[train_index], y_train_test[test_index]
+        
+        svm_classifier.fit(X_train, y_train)
+        y_pred_val = svm_classifier.predict(X_val_scaled)
+        cm = confusion_matrix(y_val, y_pred_val)
+        f1 = f1_score(y_val, y_pred_val, average='macro')
+        precision = precision_score(y_val, y_pred_val, average='macro')
+        recall = recall_score(y_val, y_pred_val, average='macro')
+        accuracy = accuracy_score(y_val, y_pred_val)
+        
+        results.append((cm, f1, precision, recall, accuracy))
+
+    # 写入结果到文件
+    with open(output_txt, 'w') as file:
+        for i, (cm, f1, precision, recall, accuracy) in enumerate(results):
+            file.write(f"Fold {i+1}:\n")
+            file.write("Confusion Matrix:\n")
+            file.write(f"{cm}\n")
+            file.write(f"F1 Score: {f1:.3f}, Precision: {precision:.3f}, Recall: {recall:.3f}, Accuracy: {accuracy:.3f}\n")
+            file.write("\n")
+        
+        # 计算平均分数
+        average_f1 = np.mean([r[1] for r in results])
+        average_precision = np.mean([r[2] for r in results])
+        average_recall = np.mean([r[3] for r in results])
+        average_accuracy = np.mean([r[4] for r in results])
+
+        file.write("Average Scores:\n")
+        file.write(f"Average F1 Score: {average_f1:.3f}\n")
+        file.write(f"Average Precision: {average_precision:.3f}\n")
+        file.write(f"Average Recall: {average_recall:.3f}\n")
+        file.write(f"Average Accuracy: {average_accuracy:.3f}\n")
+
+    print(f"Results saved to {output_txt}")
+
+def main():
+    result_folder = 'RHLV_quantification'
+    grading_folder = 'classification_metric'
+    if not os.path.exists(grading_folder):
+        os.makedirs(grading_folder)
+    
+    file_1 = os.path.join(result_folder,'fine.xlsx')
+    #file_1 = 'twostage_output.xlsx'
+    file_2 = 'twostage_output.xlsx'
+    features = ['Pre RHLV', 'Mid RHLV', 'Post RHLV']  # 特征
+
+    output_txt_path = os.path.join(grading_folder, 'test.txt')
+    evaluate_svm(file_1, file_2, features, output_txt_path)
+    
+if __name__ == "__main__":
+    main()
+

evaluation/generation_eval_coronal.py

@@ -0,0 +1,175 @@
+import os
+import nibabel as nib
+import numpy as np
+from skimage.metrics import peak_signal_noise_ratio as compare_psnr
+from skimage.metrics import structural_similarity as compare_ssim
+import json
+import pandas as pd
+from sklearn.model_selection import ParameterGrid
+import math
+
+def calculate_iou(ori_seg, fake_seg):
+    intersection = np.sum(ori_seg * fake_seg)
+    union = np.sum(ori_seg + fake_seg > 0)
+    if union == 0:
+        return 0
+    else:
+        return intersection / union
+    
+def calculate_dice(ori_seg, fake_seg):
+    # 计算两个分割之间的交集
+    intersection = np.sum(ori_seg * fake_seg)
+    # 计算两个分割之间的并集
+    union = np.sum(ori_seg) + np.sum(fake_seg)
+    # 如果并集为零，返回0，否则返回Dice系数
+    if union == 0:
+        return 0
+    else:
+        return 2.0 * intersection / union
+
+
+def relative_volume_difference(ori_seg, fake_seg):
+    volume_ori = np.sum(ori_seg)
+    volume_fake = np.sum(fake_seg)
+    if volume_ori == 0:
+        return 0
+    else:
+        return np.abs(volume_ori - volume_fake) / volume_ori
+
+def process_images(ori_ct_path, fake_ct_path, ori_seg_path, fake_seg_path):
+    ori_ct = nib.load(ori_ct_path).get_fdata()
+    fake_ct = nib.load(fake_ct_path).get_fdata()
+    ori_seg_temp = nib.load(ori_seg_path).get_fdata()
+    ori_seg = np.zeros_like(ori_seg_temp)
+    fake_seg_temp = nib.load(fake_seg_path).get_fdata()
+    fake_seg = np.zeros_like(fake_seg_temp)
+    
+    label = int(ori_seg_path[:-7].split('_')[-1])
+    ori_seg[ori_seg_temp==label] = 1
+    fake_seg[fake_seg_temp==label] = 1
+
+    patch_psnr_list = []
+    patch_ssim_list = []
+    global_psnr_list = []
+    global_ssim_list = []
+    
+    iou_value = calculate_iou(ori_seg, fake_seg)
+    dice_value = calculate_dice(ori_seg, fake_seg)
+    rv_diff = relative_volume_difference(ori_seg, fake_seg)
+    
+    loc = np.where(ori_seg)
+    z0 = min(loc[1])
+    z1 = max(loc[1])
+    range_length = z1 - z0 + 1
+    new_range_length = int(range_length * 4 / 5)
+    new_z0 = z0 + (range_length - new_range_length) // 2
+    new_z1 = new_z0 + new_range_length - 1
+    
+
+
+    for z in range(new_z0, new_z1 + 1):
+        if np.sum(ori_seg[:,z,:]) > 400:
+            coords = np.argwhere(ori_seg[:,z,:])
+            x1, x2 = min(coords[:, 0]), max(coords[:, 0])
+
+            crop_ori_ct = ori_ct[x1:x2+1, z, :]
+            crop_fake_ct = fake_ct[x1:x2+1, z, :]
+
+            psnr_value = compare_psnr(crop_ori_ct, crop_fake_ct, data_range=crop_ori_ct.max() - crop_ori_ct.min())
+            ssim_value = compare_ssim(crop_ori_ct, crop_fake_ct, data_range=crop_ori_ct.max() - crop_ori_ct.min())
+
+            if not np.isnan(psnr_value):
+                patch_psnr_list.append(psnr_value)
+            if not np.isnan(ssim_value):
+                patch_ssim_list.append(ssim_value)
+            
+    for z in range(new_z0, new_z1 + 1):
+        if np.sum(ori_seg[:,z,:]) > 400:
+            psnr_value = compare_psnr(ori_ct[:,z,:], fake_ct[:,z,:], data_range=ori_ct[:,z,:].max() - ori_ct[:,z,:].min())
+            ssim_value = compare_ssim(ori_ct[:,z,:], fake_ct[:,z,:], data_range=ori_ct[:,z,:].max() - ori_ct[:,z,:].min())
+
+            if not np.isnan(psnr_value):
+                global_psnr_list.append(psnr_value)
+            if not np.isnan(ssim_value):
+                global_ssim_list.append(ssim_value)
+            
+    avg_patch_psnr = np.mean(patch_psnr_list) if patch_psnr_list else 0  # 检查列表是否为空
+    avg_patch_ssim = np.mean(patch_ssim_list) if patch_ssim_list else 0  # 检查列表是否为空
+    avg_global_psnr = np.mean(global_psnr_list) if global_psnr_list else 0  # 检查列表是否为空
+    avg_global_ssim = np.mean(global_ssim_list) if global_ssim_list else 0  # 检查列表是否为空
+
+
+
+    return avg_global_psnr, avg_global_ssim, avg_patch_psnr, avg_patch_ssim, iou_value, rv_diff, dice_value
+
+def average_metrics(lists):
+    return np.mean(lists)
+
+def main():
+    ori_ct_folder = '/home/ubuntu/Project/HealthiVert-GAN/datasets/straighten/CT'
+    ori_seg_folder = '/home/ubuntu/Project/HealthiVert-GAN/datasets/straighten/label'
+    json_path = 'vertebra_data.json'
+    save_folder = "evaluation/generation_metric"
+    output_folder = '/home/ubuntu/Project/HealthiVert-GAN_eval/output'
+    with open(json_path, 'r') as file:
+       vertebra_set = json.load(file)
+    val_normal_vert = []
+    for patient_vert_id in vertebra_set['val'].keys():
+        if int(vertebra_set['val'][patient_vert_id]) == 0:
+            val_normal_vert.append(patient_vert_id)
+
+    if not os.path.exists(save_folder):
+        os.makedirs(save_folder)
+        
+    first_level_directories = []
+    for root, dirs, files in os.walk(output_folder):
+        first_level_directories.extend([os.path.join(root, d) for d in dirs])
+        break  # 退出循环以避免进入更深层次的目录
+    print(first_level_directories)
+        
+    for root, dirs, files in os.walk(output_folder):
+        for dir in dirs:
+            #if dir != 'Exp_3_mask3ver':
+            #    continue
+            if 'coronal' not in dir:
+                continue
+            exp_folder = os.path.join(root,dir)
+            fake_seg_folder = os.path.join(exp_folder,'label_fake')
+            fake_ct_folder = os.path.join(exp_folder,'CT_fake')
+            
+            metrics_lists = {'global_psnr': [], 'global_ssim': [], 'patch_psnr': [], 'patch_ssim': [], 'iou': [], 'rv_diff': [], 'dice':[]}
+            count=0
+            for filename in os.listdir(ori_ct_folder):
+
+                if filename.endswith(".nii.gz") and filename[:-7] in val_normal_vert:
+                    ori_ct_path = os.path.join(ori_ct_folder, filename)
+                    fake_ct_path = os.path.join(fake_ct_folder, filename)
+                    ori_seg_path = os.path.join(ori_seg_folder, filename)
+                    fake_seg_path = os.path.join(fake_seg_folder, filename)
+
+                    global_psnr, global_ssim, patch_psnr, patch_ssim, iou, rv_diff, dice = process_images(
+                        ori_ct_path, fake_ct_path, ori_seg_path, fake_seg_path)
+                    if math.isnan(patch_psnr) or math.isnan(patch_ssim):
+                        print("PSNR or SSIM returned NaN, skipping this set of images.")
+                        continue
+                    if patch_psnr==0 or patch_ssim==0:
+                        print("PSNR or SSIM returned 0, skipping this set of images.")
+                        continue
+                    metrics_lists['global_psnr'].append(global_psnr)
+                    metrics_lists['global_ssim'].append(global_ssim)
+                    metrics_lists['patch_psnr'].append(patch_psnr)
+                    metrics_lists['patch_ssim'].append(patch_ssim)
+                    metrics_lists['iou'].append(iou)
+                    metrics_lists['rv_diff'].append(rv_diff)
+                    metrics_lists['dice'].append(dice)
+                    count+=1
+
+            # 计算总平均
+            avg_metrics = {key: average_metrics(value) for key, value in metrics_lists.items()}
+            
+            with open(os.path.join(save_folder,dir+".txt"), "w") as file:
+                for metric, value in avg_metrics.items():
+                    file.write(f"Average {metric.upper()}: {value}\n")
+
+if __name__ == "__main__":
+    main()

evaluation/generation_eval_sagittal.py

@@ -0,0 +1,165 @@
+import os
+import nibabel as nib
+import numpy as np
+from skimage.metrics import peak_signal_noise_ratio as compare_psnr
+from skimage.metrics import structural_similarity as compare_ssim
+import json
+import pandas as pd
+from sklearn.model_selection import ParameterGrid
+import math
+
+def calculate_iou(ori_seg, fake_seg):
+    intersection = np.sum(ori_seg * fake_seg)
+    union = np.sum(ori_seg + fake_seg > 0)
+    if union == 0:
+        return 0
+    else:
+        return intersection / union
+    
+def calculate_dice(ori_seg, fake_seg):
+    # 计算两个分割之间的交集
+    intersection = np.sum(ori_seg * fake_seg)
+    # 计算两个分割之间的并集
+    union = np.sum(ori_seg) + np.sum(fake_seg)
+    # 如果并集为零，返回0，否则返回Dice系数
+    if union == 0:
+        return 0
+    else:
+        return 2.0 * intersection / union
+
+
+def relative_volume_difference(ori_seg, fake_seg):
+    volume_ori = np.sum(ori_seg)
+    volume_fake = np.sum(fake_seg)
+    if volume_ori == 0:
+        return 0
+    else:
+        return np.abs(volume_ori - volume_fake) / volume_ori
+
+def process_images(ori_ct_path, fake_ct_path, ori_seg_path, fake_seg_path):
+    ori_ct = nib.load(ori_ct_path).get_fdata()
+    fake_ct = nib.load(fake_ct_path).get_fdata()
+    ori_seg_temp = nib.load(ori_seg_path).get_fdata()
+    ori_seg = np.zeros_like(ori_seg_temp)
+    fake_seg_temp = nib.load(fake_seg_path).get_fdata()
+    fake_seg = np.zeros_like(fake_seg_temp)
+    
+    label = int(ori_seg_path[:-7].split('_')[-1])
+    ori_seg[ori_seg_temp==label] = 1
+    fake_seg[fake_seg_temp==label] = 1
+
+    patch_psnr_list = []
+    patch_ssim_list = []
+    global_psnr_list = []
+    global_ssim_list = []
+    
+    iou_value = calculate_iou(ori_seg, fake_seg)
+    dice_value = calculate_dice(ori_seg, fake_seg)
+    rv_diff = relative_volume_difference(ori_seg, fake_seg)
+    
+    loc = np.where(ori_seg)
+    z0 = min(loc[2])
+    z1 = max(loc[2])
+    range_length = z1 - z0 + 1
+    new_range_length = int(range_length * 4 / 5)
+    new_z0 = z0 + (range_length - new_range_length) // 2
+    new_z1 = new_z0 + new_range_length - 1
+    
+
+
+    for z in range(new_z0, new_z1 + 1):
+        if np.sum(ori_seg[:,:,z]) > 400:
+            coords = np.argwhere(ori_seg[:,:,z])
+            x1, x2 = min(coords[:, 0]), max(coords[:, 0])
+
+            crop_ori_ct = ori_ct[x1:x2+1, :, z]
+            crop_fake_ct = fake_ct[x1:x2+1, :, z]
+
+            psnr_value = compare_psnr(crop_ori_ct, crop_fake_ct, data_range=crop_ori_ct.max() - crop_ori_ct.min())
+            ssim_value = compare_ssim(crop_ori_ct, crop_fake_ct, data_range=crop_ori_ct.max() - crop_ori_ct.min())
+
+            if not np.isnan(psnr_value):
+                patch_psnr_list.append(psnr_value)
+            if not np.isnan(ssim_value):
+                patch_ssim_list.append(ssim_value)
+            
+    for z in range(new_z0, new_z1 + 1):
+        if np.sum(ori_seg[:,:,z]) > 400:
+            psnr_value = compare_psnr(ori_ct[:,:,z], fake_ct[:,:,z], data_range=ori_ct[:,:,z].max() - ori_ct[:,:,z].min())
+            ssim_value = compare_ssim(ori_ct[:,:,z], fake_ct[:,:,z], data_range=ori_ct[:,:,z].max() - ori_ct[:,:,z].min())
+
+            if not np.isnan(psnr_value):
+                global_psnr_list.append(psnr_value)
+            if not np.isnan(ssim_value):
+                global_ssim_list.append(ssim_value)
+            
+    avg_patch_psnr = np.mean(patch_psnr_list) if patch_psnr_list else 0  # 检查列表是否为空
+    avg_patch_ssim = np.mean(patch_ssim_list) if patch_ssim_list else 0  # 检查列表是否为空
+    avg_global_psnr = np.mean(global_psnr_list) if global_psnr_list else 0  # 检查列表是否为空
+    avg_global_ssim = np.mean(global_ssim_list) if global_ssim_list else 0  # 检查列表是否为空
+
+
+
+    return avg_global_psnr, avg_global_ssim, avg_patch_psnr, avg_patch_ssim, iou_value, rv_diff, dice_value
+
+def average_metrics(lists):
+    return np.mean(lists)
+
+def main():
+    ori_ct_folder = '/dssg/home/acct-milesun/zhangqi/Dataset/HealthiVert_straighten/CT'
+    ori_seg_folder = '/dssg/home/acct-milesun/zhangqi/Dataset/HealthiVert_straighten/label'
+    json_path = 'vertebra_data.json'
+    save_folder = "evaluation/generation_metric"
+    output_folder = '/dssg/home/acct-milesun/zhangqi/Project/HealthiVert-GAN_eval/output'
+    with open(json_path, 'r') as file:
+       vertebra_set = json.load(file)
+    val_normal_vert = []
+    for patient_vert_id in vertebra_set['val'].keys():
+        if int(vertebra_set['val'][patient_vert_id]) == 0:
+            val_normal_vert.append(patient_vert_id)
+
+    if not os.path.exists(save_folder):
+        os.makedirs(save_folder)
+        
+    for root, dirs, files in os.walk(output_folder):
+        for dir in dirs:
+            exp_folder = os.path.join(root,dir)
+            fake_seg_folder = os.path.join(exp_folder,'label_fake')
+            fake_ct_folder = os.path.join(exp_folder,'CT_fake')
+            
+            metrics_lists = {'global_psnr': [], 'global_ssim': [], 'patch_psnr': [], 'patch_ssim': [], 'iou': [], 'rv_diff': [], 'dice':[]}
+            count=0
+            for filename in os.listdir(ori_ct_folder):
+
+                if filename.endswith(".nii.gz") and filename[:-7] in val_normal_vert:
+                    ori_ct_path = os.path.join(ori_ct_folder, filename)
+                    fake_ct_path = os.path.join(fake_ct_folder, filename)
+                    ori_seg_path = os.path.join(ori_seg_folder, filename)
+                    fake_seg_path = os.path.join(fake_seg_folder, filename)
+
+                    global_psnr, global_ssim, patch_psnr, patch_ssim, iou, rv_diff, dice = process_images(
+                        ori_ct_path, fake_ct_path, ori_seg_path, fake_seg_path)
+                    if math.isnan(patch_psnr) or math.isnan(patch_ssim):
+                        print("PSNR or SSIM returned NaN, skipping this set of images.")
+                        continue
+                    if patch_psnr==0 or patch_ssim==0:
+                        print("PSNR or SSIM returned 0, skipping this set of images.")
+                        continue
+                    metrics_lists['global_psnr'].append(global_psnr)
+                    metrics_lists['global_ssim'].append(global_ssim)
+                    metrics_lists['patch_psnr'].append(patch_psnr)
+                    metrics_lists['patch_ssim'].append(patch_ssim)
+                    metrics_lists['iou'].append(iou)
+                    metrics_lists['rv_diff'].append(rv_diff)
+                    metrics_lists['dice'].append(dice)
+                    count+=1
+
+            # 计算总平均
+            avg_metrics = {key: average_metrics(value) for key, value in metrics_lists.items()}
+            
+            with open(os.path.join(save_folder,dir+".txt"), "w") as file:
+                for metric, value in avg_metrics.items():
+                    file.write(f"Average {metric.upper()}: {value}\n")
+
+if __name__ == "__main__":
+    main()