nnUNetv1在自己数据集上训练

1
git clone https://github.com/MIC-DKFZ/nnUNet.git  # 下载代码
2
cd nnUNet  # 切换目录
3
conda create -n myenv python=3.9  # 注意nnUNetv2需要python>=3.9
4
conda activate myenv
5
pip install nnunet
6
pip install -e .  #最后这个点也不能忽略

1
注意：'../'需要替换为本地路径！！！
2
export nnUNet_raw_data_base="../nnUNet/nnUNetFrame/DATASET/nnUNet_raw"
3
export nnUNet_preprocessed="../nnUNet/nnUNetFrame/DATASET/nnUNet_preprocessed"
4
export RESULTS_FOLDER="../nnUNet/nnUNetFrame/DATASET/nnUNet_trained_models"

1
source .bashrc

1
nnUNet_convert_decathlon_task -i Task01_XXX的绝对路径

1
nnUNet_plan_and_preprocess -t 1 --verify_dataset_integrity
2
“1 表示任务代号，即Task001”
3
AI写代码python运行12

1
CUDA_VISIBLE_DEVICES=1 nnUNet_train 2d nnUNetTrainerV2 Task001_XXX 0  --npz
2
CUDA_VISIBLE_DEVICES=1 nnUNet_train 2d nnUNetTrainerV2 Task001_XXX 1  --npz
3
CUDA_VISIBLE_DEVICES=1 nnUNet_train 2d nnUNetTrainerV2 Task001_XXX 2  --npz
4
CUDA_VISIBLE_DEVICES=1 nnUNet_train 2d nnUNetTrainerV2 Task001_XXX 3  --npz
5
CUDA_VISIBLE_DEVICES=1 nnUNet_train 2d nnUNetTrainerV2 Task001_XXX 4  --npz

1
nnUNet_find_best_configuration -m 2d -t 001 –strict
2
# 001是任务编号

1
nnUNet_predict -i FOLDER_WITH_TEST_CASES -o OUTPUT_FOLDER_MODEL1 -tr nnUNetTrainerV2 -ctr nnUNetTrainerV2CascadeFullRes -m 2d -p nnUNetPlansv2.1 -t Task001_XXX
2
# FOLDER_WITH_TEST_CASES 输入文件路径
3
# OUTPUT_FOLDER_MODEL1  输出文件路径
4
# Task001_XXX  预测任务名

1
import os
2
import nibabel as nib
3
import numpy as np
4
from PIL import Image
5

6
def convert_nii_to_png(input_folder, output_folder):
7
    # 确保输出文件夹存在
8
    os.makedirs(output_folder, exist_ok=True)
9

10
    # 遍历输入文件夹中的所有文件
11
    for filename in os.listdir(input_folder):
12
        if filename.endswith('.nii.gz'):
13
            # 构建完整的文件路径
14
            file_path = os.path.join(input_folder, filename)
15
            # 读取 NIfTI 文件
16
            nii_image = nib.load(file_path)
17
            image_data = nii_image.get_fdata()
18

19
            # 选择中间的切片
20
            slice_idx = image_data.shape[2] // 2
21
            slice_data = image_data[:, :, slice_idx]
22

23
            # 转换为8位图像格式
24
            slice_normalized = (slice_data - np.min(slice_data)) / (np.max(slice_data) - np.min(slice_data))
25
            image_8bit = (slice_normalized * 255).astype(np.uint8)
26
            image = Image.fromarray(image_8bit)
27

28
            # 保存图像
29
            output_filename = filename.replace('.nii.gz', '.png')
30
            image.save(os.path.join(output_folder, output_filename))
31
            print(f"Converted {filename} to {output_filename}")
32
input_folder = ''  # nii.gz文件路径
33
output_folder = ''  # png文件路径
34
convert_nii_to_png(input_folder, output_folder)

1
import os
2
import shutil
3
import json
4
import nibabel as nib
5
import numpy as np
6
from collections import OrderedDict
7

8
def convert_brats2019_to_nnunet(brats_root, nnunet_raw_data_base):
9
    """
10
    将BraTS2019数据集转换为nnUNet格式，处理标签映射
11

12
    Args:
13
        brats_root: BraTS2019原始数据根目录路径
14
        nnunet_raw_data_base: nnUNet原始数据基础目录路径
15
    """
16

17
    # 设置路径
18
    task_name = "Task001_BraTS2019"
19
    task_folder = os.path.join(nnunet_raw_data_base, "nnUNet_raw_data", task_name)
20

21
    # 创建必要的目录
22
    imagesTr_folder = os.path.join(task_folder, "imagesTr")
23
    imagesTs_folder = os.path.join(task_folder, "imagesTs")
24
    labelsTr_folder = os.path.join(task_folder, "labelsTr")
25
    labelsTs_folder = os.path.join(task_folder, "labelsTs")
26

27
    for folder in [imagesTr_folder, imagesTs_folder, labelsTr_folder, labelsTs_folder]:
28
        os.makedirs(folder, exist_ok=True)
29

30
    # 获取训练数据和测试数据路径
31
    hgg_folder = os.path.join(brats_root, "HGG")
32
    lgg_folder = os.path.join(brats_root, "LGG")
33

34
    # 收集所有训练病例
35
    train_cases = []
36

37
    # 处理HGG数据
38
    if os.path.exists(hgg_folder):
39
        hgg_cases = [d for d in os.listdir(hgg_folder) if os.path.isdir(os.path.join(hgg_folder, d))]
40
        for case in hgg_cases:
41
            train_cases.append(("HGG", case))
42

43
    # 处理LGG数据
44
    if os.path.exists(lgg_folder):
45
        lgg_cases = [d for d in os.listdir(lgg_folder) if os.path.isdir(os.path.join(lgg_folder, d))]
46
        for case in lgg_cases:
47
            train_cases.append(("LGG", case))
48

49
    print(f"找到 {len(train_cases)} 个训练病例")
50

51
    # 模态映射
52
    modality_mapping = {
53
        'flair': '0000',
54
        't1ce': '0001',
55
        't1': '0002',
56
        't2': '0003'
57
    }
58

59
    def process_label(label_path, output_path):
60
        """
61
        处理BraTS标签，将原始标签映射为连续的标签
62
        BraTS原始标签: 0(背景), 1(坏死/非增强肿瘤), 2(水肿), 4(增强肿瘤)
63
        映射后标签: 0(背景), 1(坏死/非增强肿瘤), 2(水肿), 3(增强肿瘤)
64
        """
65
        # 加载标签数据
66
        label_nii = nib.load(label_path)
67
        label_data = label_nii.get_fdata().astype(np.uint8)
68

69
        # 检查原始标签值
70
        unique_labels = np.unique(label_data)
71
        print(f"处理 {os.path.basename(label_path)}，原始标签值: {unique_labels}")
72

73
        # 创建新的标签数组
74
        new_label_data = np.zeros_like(label_data)
75

76
        # 标签映射: 0->0, 1->1, 2->2, 4->3
77
        new_label_data[label_data == 0] = 0  # 背景
78
        new_label_data[label_data == 1] = 1  # 坏死和非增强肿瘤
79
        new_label_data[label_data == 2] = 2  # 水肿
80
        new_label_data[label_data == 4] = 3  # 增强肿瘤
81

82
        # 检查映射后的标签值
83
        new_unique_labels = np.unique(new_label_data)
84
        print(f"映射后标签值: {new_unique_labels}")
85

86
        # 保存新的标签文件
87
        new_label_nii = nib.Nifti1Image(new_label_data, label_nii.affine, label_nii.header)
88
        nib.save(new_label_nii, output_path)
89

90
    training_cases = []
91
    test_cases = []
92

93
    for i, (grade, case_name) in enumerate(train_cases):
94
        case_folder = os.path.join(brats_root, grade, case_name)
95

96
        if not os.path.exists(case_folder):
97
            print(f"警告: 病例文件夹不存在 {case_folder}")
98
            continue
99

100
        # 检查所有必需的文件是否存在
101
        required_files = {
102
            'flair': f"{case_name}_flair.nii",
103
            't1ce': f"{case_name}_t1ce.nii",
104
            't1': f"{case_name}_t1.nii",
105
            't2': f"{case_name}_t2.nii",
106
            'seg': f"{case_name}_seg.nii"
107
        }
108

109
        # 检查.nii.gz格式
110
        for key, filename in required_files.items():
111
            if not os.path.exists(os.path.join(case_folder, filename)):
112
                # 尝试.nii.gz格式
113
                gz_filename = filename + ".gz"
114
                if os.path.exists(os.path.join(case_folder, gz_filename)):
115
                    required_files[key] = gz_filename
116
                else:
117
                    print(f"警告: 文件 {filename} 或 {gz_filename} 不存在于 {case_folder}")
118
                    break
119
        else:
120
            # 所有文件都存在，处理这个病例
121

122
            # 决定这个病例是用于训练还是测试（这里简单地将前80%用于训练）
123
            if i < len(train_cases) * 0.8:
124
                # 训练数据
125
                for modality, suffix in modality_mapping.items():
126
                    src_file = os.path.join(case_folder, required_files[modality])
127
                    dst_file = os.path.join(imagesTr_folder, f"{case_name}_{suffix}.nii.gz")
128

129
                    # 如果源文件不是.gz格式，需要压缩
130
                    if not src_file.endswith('.gz'):
131
                        img = nib.load(src_file)
132
                        nib.save(img, dst_file)
133
                    else:
134
                        shutil.copy2(src_file, dst_file)
135

136
                # 处理分割标签（重要：进行标签映射）
137
                src_seg = os.path.join(case_folder, required_files['seg'])
138
                dst_seg = os.path.join(labelsTr_folder, f"{case_name}.nii.gz")
139
                process_label(src_seg, dst_seg)
140

141
                training_cases.append(case_name)
142

143
            else:
144
                # 测试数据
145
                for modality, suffix in modality_mapping.items():
146
                    src_file = os.path.join(case_folder, required_files[modality])
147
                    dst_file = os.path.join(imagesTs_folder, f"{case_name}_{suffix}.nii.gz")
148

149
                    if not src_file.endswith('.gz'):
150
                        img = nib.load(src_file)
151
                        nib.save(img, dst_file)
152
                    else:
153
                        shutil.copy2(src_file, dst_file)
154

155
                # 测试数据的标签（同样进行标签映射）
156
                src_seg = os.path.join(case_folder, required_files['seg'])
157
                dst_seg = os.path.join(labelsTs_folder, f"{case_name}.nii.gz")
158
                process_label(src_seg, dst_seg)
159

160
                test_cases.append(case_name)
161

162
    print(f"处理完成: {len(training_cases)} 个训练病例, {len(test_cases)} 个测试病例")
163

164
    # 创建dataset.json文件
165
    dataset_json = OrderedDict()
166
    dataset_json['name'] = "BraTS2019"
167
    dataset_json['description'] = "Brain Tumor Segmentation Challenge 2019"
168
    dataset_json['tensorImageSize'] = "4D"
169
    dataset_json['reference'] = "https://www.med.upenn.edu/cbica/brats2019/"
170
    dataset_json['licence'] = "see BraTS2019 website"
171
    dataset_json['release'] = "1.0"
172

173
    # 模态信息
174
    dataset_json['modality'] = {
175
        "0": "FLAIR",
176
        "1": "T1ce",
177
        "2": "T1",
178
        "3": "T2"
179
    }
180

181
    # 标签信息 - 修正为包含所有必要的标签
182
    dataset_json['labels'] = {
183
        "0": "background",
184
        "1": "necrotic/non-enhancing tumor",
185
        "2": "edema",
186
        "3": "enhancing tumor"
187
    }
188

189
    # 训练和测试数据列表
190
    dataset_json['numTraining'] = len(training_cases)
191
    dataset_json['numTest'] = len(test_cases)
192

193
    dataset_json['training'] = []
194
    for case in training_cases:
195
        case_dict = {
196
            "image": f"./imagesTr/{case}.nii.gz",
197
            "label": f"./labelsTr/{case}.nii.gz"
198
        }
199
        dataset_json['training'].append(case_dict)
200

201
    dataset_json['test'] = []
202
    for case in test_cases:
203
        dataset_json['test'].append(f"./imagesTs/{case}.nii.gz")
204

205
    # 保存dataset.json
206
    json_file_path = os.path.join(task_folder, "dataset.json")
207
    with open(json_file_path, 'w') as f:
208
        json.dump(dataset_json, f, indent=4)
209

210
    print(f"dataset.json 已保存到: {json_file_path}")
211
    print("数据转换完成！标签已正确映射：0(背景) -> 0, 1(坏死) -> 1, 2(水肿) -> 2, 4(增强肿瘤) -> 3")
212

213
    return task_folder
214

215
# 使用示例
216
if __name__ == "__main__":
217
    # 设置路径
218
    brats_root = "/root/autodl-tmp/nnUNet_raw_data_base/BraTS2019"  # 您的BraTS2019数据根目录
219
    nnunet_raw_data_base = "/root/autodl-tmp/nnUNet_raw_data_base"  # nnUNet原始数据基础目录
220

221
    # 执行转换
222
    convert_brats2019_to_nnunet(brats_root, nnunet_raw_data_base)

1
import os
2
import shutil
3
import json
4
import nibabel as nib
5
import numpy as np
6
from collections import OrderedDict
7

8
def convert_brats2023_to_nnunet(brats_root, nnunet_raw_data_base):
9
    """
10
    将BraTS2023数据集转换为nnUNet格式，保持原始标签不变
11

12
    Args:
13
        brats_root: BraTS2023原始数据根目录路径
14
        nnunet_raw_data_base: nnUNet原始数据基础目录路径
15
    """
16

17
    # 错误记录列表
18
    errors = []
19

20
    # 设置路径
21
    task_name = "Task001_BraTS2023"
22
    task_folder = os.path.join(nnunet_raw_data_base, "nnUNet_raw_data", task_name)
23

24
    # 创建必要的目录
25
    imagesTr_folder = os.path.join(task_folder, "imagesTr")
26
    imagesTs_folder = os.path.join(task_folder, "imagesTs")
27
    labelsTr_folder = os.path.join(task_folder, "labelsTr")
28
    labelsTs_folder = os.path.join(task_folder, "labelsTs")
29

30
    for folder in [imagesTr_folder, imagesTs_folder, labelsTr_folder, labelsTs_folder]:
31
        os.makedirs(folder, exist_ok=True)
32

33
    # 收集所有病例文件夹
34
    all_cases = []
35
    for item in os.listdir(brats_root):
36
        case_path = os.path.join(brats_root, item)
37
        if os.path.isdir(case_path) and item.startswith('BraTS-GLI-'):
38
            all_cases.append(item)
39

40
    all_cases.sort()  # 确保顺序一致
41
    print(f"找到 {len(all_cases)} 个病例")
42

43
    # 模态映射 - BraTS2023使用t1c而不是t1ce
44
    modality_mapping = {
45
        't1n': '0000',  # T1 native (非增强T1)
46
        't1c': '0001',  # T1 contrast enhanced (增强T1)
47
        't2f': '0002',  # T2 FLAIR
48
        't2w': '0003'   # T2 weighted
49
    }
50

51
    def safe_copy_image(src_path, dst_path, case_name, modality):
52
        """
53
        安全地复制图像文件，处理可能的错误
54
        """
55
        try:
56
            if not src_path.endswith('.gz'):
57
                img = nib.load(src_path)
58
                nib.save(img, dst_path)
59
            else:
60
                shutil.copy2(src_path, dst_path)
61
            return True
62
        except Exception as e:
63
            error_msg = f"复制图像失败 - 病例: {case_name}, 模态: {modality}, 文件: {src_path}, 错误: {str(e)}"
64
            print(f"错误: {error_msg}")
65
            errors.append(error_msg)
66
            return False
67

68
    def safe_copy_label(src_path, dst_path, case_name):
69
        """
70
        安全地复制标签文件，处理可能的错误
71
        """
72
        try:
73
            # 加载标签数据以检查标签值
74
            label_nii = nib.load(src_path)
75
            label_data = label_nii.get_fdata().astype(np.uint8)
76

77
            # 检查原始标签值
78
            unique_labels = np.unique(label_data)
79
            print(f"处理 {os.path.basename(src_path)}，标签值: {unique_labels}")
80

81
            # 直接保存，不进行任何修改
82
            if not src_path.endswith('.gz'):
83
                # 如果源文件不是.gz格式，保存为.gz格式
84
                nib.save(label_nii, dst_path)
85
            else:
86
                # 如果已经是.gz格式，直接复制
87
                shutil.copy2(src_path, dst_path)
88
            return True
89
        except Exception as e:
90
            error_msg = f"复制标签失败 - 病例: {case_name}, 文件: {src_path}, 错误: {str(e)}"
91
            print(f"错误: {error_msg}")
92
            errors.append(error_msg)
93
            return False
94

95
    def check_file_validity(file_path):
96
        """
97
        检查文件是否有效（非空且可读取）
98
        """
99
        try:
100
            if not os.path.exists(file_path):
101
                return False, "文件不存在"
102

103
            if os.path.getsize(file_path) == 0:
104
                return False, "文件为空"
105

106
            # 尝试加载文件头信息
107
            nib.load(file_path)
108
            return True, "文件有效"
109
        except Exception as e:
110
            return False, f"文件无效: {str(e)}"
111

112
    training_cases = []
113
    test_cases = []
114
    skipped_cases = []
115

116
    for i, case_name in enumerate(all_cases):
117
        case_folder = os.path.join(brats_root, case_name)
118

119
        if not os.path.exists(case_folder):
120
            error_msg = f"病例文件夹不存在: {case_folder}"
121
            print(f"警告: {error_msg}")
122
            errors.append(error_msg)
123
            skipped_cases.append(case_name)
124
            continue
125

126
        # 构建文件名模式 - 根据BraTS2023的命名规范
127
        base_name = case_name  # BraTS-GLI-00000-000
128

129
        required_files = {
130
            't1n': f"{base_name}-t1n.nii",
131
            't1c': f"{base_name}-t1c.nii",
132
            't2f': f"{base_name}-t2f.nii",
133
            't2w': f"{base_name}-t2w.nii",
134
            'seg': f"{base_name}-seg.nii"
135
        }
136

137
        # 检查文件存在性，支持.nii和.nii.gz格式
138
        files_exist = True
139
        invalid_files = []
140

141
        for key, filename in required_files.items():
142
            file_path = os.path.join(case_folder, filename)
143
            gz_file_path = file_path + ".gz"
144

145
            if os.path.exists(file_path):
146
                # 检查文件有效性
147
                is_valid, msg = check_file_validity(file_path)
148
                if not is_valid:
149
                    invalid_files.append(f"{filename}: {msg}")
150
                    files_exist = False
151
            elif os.path.exists(gz_file_path):
152
                required_files[key] = filename + ".gz"
153
                # 检查文件有效性
154
                is_valid, msg = check_file_validity(gz_file_path)
155
                if not is_valid:
156
                    invalid_files.append(f"{filename}.gz: {msg}")
157
                    files_exist = False
158
            else:
159
                error_msg = f"文件缺失 - 病例: {case_name}, 文件: {filename} 或 {filename}.gz"
160
                print(f"警告: {error_msg}")
161
                errors.append(error_msg)
162
                files_exist = False
163

164
        if invalid_files:
165
            for invalid_file in invalid_files:
166
                error_msg = f"文件无效 - 病例: {case_name}, {invalid_file}"
167
                print(f"警告: {error_msg}")
168
                errors.append(error_msg)
169

170
        if not files_exist:
171
            skipped_cases.append(case_name)
172
            continue
173

174
        # 决定这个病例是用于训练还是测试（前80%用于训练）
175
        case_success = True
176

177
        if i < len(all_cases) * 0.8:
178
            # 训练数据
179
            print(f"处理训练病例: {case_name}")
180

181
            # 复制图像文件
182
            for modality, suffix in modality_mapping.items():
183
                src_file = os.path.join(case_folder, required_files[modality])
184
                dst_file = os.path.join(imagesTr_folder, f"{case_name}_{suffix}.nii.gz")
185

186
                if not safe_copy_image(src_file, dst_file, case_name, modality):
187
                    case_success = False
188

189
            # 复制分割标签
190
            src_seg = os.path.join(case_folder, required_files['seg'])
191
            dst_seg = os.path.join(labelsTr_folder, f"{case_name}.nii.gz")
192
            if not safe_copy_label(src_seg, dst_seg, case_name):
193
                case_success = False
194

195
            if case_success:
196
                training_cases.append(case_name)
197
                print(f"训练病例 {case_name} 处理成功")
198
            else:
199
                skipped_cases.append(case_name)
200
                print(f"训练病例 {case_name} 处理失败，已跳过")
201

202
        else:
203
            # 测试数据
204
            print(f"处理测试病例: {case_name}")
205

206
            # 复制图像文件
207
            for modality, suffix in modality_mapping.items():
208
                src_file = os.path.join(case_folder, required_files[modality])
209
                dst_file = os.path.join(imagesTs_folder, f"{case_name}_{suffix}.nii.gz")
210

211
                if not safe_copy_image(src_file, dst_file, case_name, modality):
212
                    case_success = False
213

214
            # 复制测试数据的标签
215
            src_seg = os.path.join(case_folder, required_files['seg'])
216
            dst_seg = os.path.join(labelsTs_folder, f"{case_name}.nii.gz")
217
            if not safe_copy_label(src_seg, dst_seg, case_name):
218
                case_success = False
219

220
            if case_success:
221
                test_cases.append(case_name)
222
                print(f"测试病例 {case_name} 处理成功")
223
            else:
224
                skipped_cases.append(case_name)
225
                print(f"测试病例 {case_name} 处理失败，已跳过")
226

227
    print(f"处理完成: {len(training_cases)} 个训练病例, {len(test_cases)} 个测试病例")
228
    print(f"跳过的病例数量: {len(skipped_cases)}")
229

230
    # 写入错误日志
231
    error_file_path = os.path.join(os.path.dirname(__file__), "error.txt")
232
    with open(error_file_path, 'w', encoding='utf-8') as f:
233
        f.write(f"BraTS2023数据转换错误报告\n")
234
        f.write(f"生成时间: {str(os.path.getctime(error_file_path)) if os.path.exists(error_file_path) else 'N/A'}\n")
235
        f.write(f"="*80 + "\n\n")
236
        f.write(f"总计处理: {len(all_cases)} 个病例\n")
237
        f.write(f"成功处理: {len(training_cases) + len(test_cases)} 个病例\n")
238
        f.write(f"跳过病例: {len(skipped_cases)} 个病例\n")
239
        f.write(f"错误数量: {len(errors)} 个错误\n\n")
240

241
        if skipped_cases:
242
            f.write("跳过的病例列表:\n")
243
            for case in skipped_cases:
244
                f.write(f"  - {case}\n")
245
            f.write("\n")
246

247
        if errors:
248
            f.write("详细错误信息:\n")
249
            for i, error in enumerate(errors, 1):
250
                f.write(f"{i}. {error}\n")
251
        else:
252
            f.write("没有发现错误。\n")
253

254
    print(f"错误日志已保存到: {error_file_path}")
255

256
    # 只有成功处理的病例数量大于0时才创建dataset.json
257
    if len(training_cases) + len(test_cases) > 0:
258
        # 创建dataset.json文件
259
        dataset_json = OrderedDict()
260
        dataset_json['name'] = "BraTS2023"
261
        dataset_json['description'] = "Brain Tumor Segmentation Challenge 2023"
262
        dataset_json['tensorImageSize'] = "4D"
263
        dataset_json['reference'] = "https://www.synapse.org/#!Synapse:syn51156910"
264
        dataset_json['licence'] = "see BraTS2023 website"
265
        dataset_json['release'] = "1.0"
266

267
        # 模态信息 - 更新为BraTS2023的模态
268
        dataset_json['modality'] = {
269
            "0": "T1n",    # T1 native
270
            "1": "T1c",    # T1 contrast enhanced
271
            "2": "T2f",    # T2 FLAIR
272
            "3": "T2w"     # T2 weighted
273
        }
274

275
        # 标签信息 - 保持BraTS原始标签值
276
        dataset_json['labels'] = {
277
            "0": "background",
278
            "1": "necrotic/non-enhancing tumor",
279
            "2": "edema",
280
            "3": "enhancing tumor"  # 保持原始标签值3
281
        }
282

283
        # 训练和测试数据列表
284
        dataset_json['numTraining'] = len(training_cases)
285
        dataset_json['numTest'] = len(test_cases)
286

287
        dataset_json['training'] = []
288
        for case in training_cases:
289
            case_dict = {
290
                "image": f"./imagesTr/{case}.nii.gz",
291
                "label": f"./labelsTr/{case}.nii.gz"
292
            }
293
            dataset_json['training'].append(case_dict)
294

295
        dataset_json['test'] = []
296
        for case in test_cases:
297
            dataset_json['test'].append(f"./imagesTs/{case}.nii.gz")
298

299
        # 保存dataset.json
300
        json_file_path = os.path.join(task_folder, "dataset.json")
301
        with open(json_file_path, 'w') as f:
302
            json.dump(dataset_json, f, indent=4)
303

304
        print(f"dataset.json 已保存到: {json_file_path}")
305
        print("BraTS2023数据转换完成！标签保持原始值不变：0(背景), 1(坏死), 2(水肿), 4(增强肿瘤)")
306

307
        return task_folder
308
    else:
309
        print("警告: 没有成功处理任何病例，未生成dataset.json文件")
310
        return None
311

312
# 使用示例
313
if __name__ == "__main__":
314
    # 设置路径
315
    brats_root = "/root/autodl-tmp/nnUNet_raw_data_base/BraTS2023"  # 您的BraTS2023数据根目录
316
    nnunet_raw_data_base = "/root/autodl-tmp/nnUNet_raw_data_base"  # nnUNet原始数据基础目录
317

318
    # 执行转换
319
    try:
320
        result = convert_brats2023_to_nnunet(brats_root, nnunet_raw_data_base)
321
        if result:
322
            print(f"\n转换成功完成！输出目录: {result}")
323
            print("可以继续进行nnUNet的预处理和训练步骤。")
324
        else:
325
            print("\n转换失败，请查看错误日志了解详细信息。")
326
    except Exception as e:
327
        print(f"程序执行失败: {str(e)}")
328
        # 即使主程序失败，也要记录错误
329
        error_file_path = os.path.join(os.path.dirname(__file__), "error.txt")
330
        with open(error_file_path, 'w', encoding='utf-8') as f:
331
            f.write(f"程序执行失败: {str(e)}\n")
332
        print(f"错误已记录到: {error_file_path}")

1
import os
2
import shutil
3
import json
4
import nibabel as nib
5
import numpy as np
6
from collections import OrderedDict
7

8
def convert_brats2024_to_nnunet(brats_root, nnunet_raw_data_base):
9
    """
10
    将BraTS2024数据集转换为nnUNet格式，保持原始标签不变
11
    包含新的切除腔（RC）标签
12

13
    Args:
14
        brats_root: BraTS2024原始数据根目录路径
15
        nnunet_raw_data_base: nnUNet原始数据基础目录路径
16
    """
17

18
    # 错误记录列表
19
    errors = []
20

21
    # 设置路径
22
    task_name = "Task001_BraTS2024"
23
    task_folder = os.path.join(nnunet_raw_data_base, "nnUNet_raw", task_name)
24

25
    # 创建必要的目录
26
    imagesTr_folder = os.path.join(task_folder, "imagesTr")
27
    imagesTs_folder = os.path.join(task_folder, "imagesTs")
28
    labelsTr_folder = os.path.join(task_folder, "labelsTr")
29
    labelsTs_folder = os.path.join(task_folder, "labelsTs")
30

31
    for folder in [imagesTr_folder, imagesTs_folder, labelsTr_folder, labelsTs_folder]:
32
        os.makedirs(folder, exist_ok=True)
33

34
    # 收集所有病例文件夹
35
    all_cases = []
36
    for item in os.listdir(brats_root):
37
        case_path = os.path.join(brats_root, item)
38
        if os.path.isdir(case_path) and item.startswith('BraTS-'):
39
            all_cases.append(item)
40

41
    all_cases.sort()  # 确保顺序一致
42
    print(f"找到 {len(all_cases)} 个病例")
43

44
    # 模态映射 - BraTS2024模态
45
    modality_mapping = {
46
        't1n': '0000',  # T1 native (非增强T1)
47
        't1c': '0001',  # T1 contrast enhanced (增强T1)
48
        't2f': '0002',  # T2 FLAIR
49
        't2w': '0003'   # T2 weighted
50
    }
51

52
    def safe_copy_image(src_path, dst_path, case_name, modality):
53
        """
54
        安全地复制图像文件，处理可能的错误
55
        """
56
        try:
57
            if not src_path.endswith('.gz'):
58
                img = nib.load(src_path)
59
                nib.save(img, dst_path)
60
            else:
61
                shutil.copy2(src_path, dst_path)
62
            return True
63
        except Exception as e:
64
            error_msg = f"复制图像失败 - 病例: {case_name}, 模态: {modality}, 文件: {src_path}, 错误: {str(e)}"
65
            print(f"错误: {error_msg}")
66
            errors.append(error_msg)
67
            return False
68

69
    def safe_copy_label(src_path, dst_path, case_name):
70
        """
71
        安全地复制标签文件，处理可能的错误
72
        检查并记录BraTS2024的标签值分布
73
        """
74
        try:
75
            # 加载标签数据以检查标签值
76
            label_nii = nib.load(src_path)
77
            label_data = label_nii.get_fdata().astype(np.uint8)
78

79
            # 检查原始标签值
80
            unique_labels = np.unique(label_data)
81
            print(f"处理 {os.path.basename(src_path)}，标签值: {unique_labels}")
82

83
            # 验证标签值是否符合BraTS2024规范（0, 1, 2, 3, 4）
84
            valid_labels = {0, 1, 2, 3, 4}
85
            unexpected_labels = set(unique_labels) - valid_labels
86
            if unexpected_labels:
87
                warning_msg = f"发现意外标签值 - 病例: {case_name}, 标签值: {unexpected_labels}"
88
                print(f"警告: {warning_msg}")
89
                errors.append(warning_msg)
90

91
            # 统计各标签的体素数量
92
            label_counts = {}
93
            for label in unique_labels:
94
                count = np.sum(label_data == label)
95
                label_counts[int(label)] = count
96

97
            print(f"  标签分布: {label_counts}")
98

99
            # 直接保存，不进行任何修改
100
            if not src_path.endswith('.gz'):
101
                # 如果源文件不是.gz格式，保存为.gz格式
102
                nib.save(label_nii, dst_path)
103
            else:
104
                # 如果已经是.gz格式，直接复制
105
                shutil.copy2(src_path, dst_path)
106
            return True
107
        except Exception as e:
108
            error_msg = f"复制标签失败 - 病例: {case_name}, 文件: {src_path}, 错误: {str(e)}"
109
            print(f"错误: {error_msg}")
110
            errors.append(error_msg)
111
            return False
112

113
    def check_file_validity(file_path):
114
        """
115
        检查文件是否有效（非空且可读取）
116
        """
117
        try:
118
            if not os.path.exists(file_path):
119
                return False, "文件不存在"
120

121
            if os.path.getsize(file_path) == 0:
122
                return False, "文件为空"
123

124
            # 尝试加载文件头信息
125
            nib.load(file_path)
126
            return True, "文件有效"
127
        except Exception as e:
128
            return False, f"文件无效: {str(e)}"
129

130
    training_cases = []
131
    test_cases = []
132
    skipped_cases = []
133

134
    for i, case_name in enumerate(all_cases):
135
        case_folder = os.path.join(brats_root, case_name)
136

137
        if not os.path.exists(case_folder):
138
            error_msg = f"病例文件夹不存在: {case_folder}"
139
            print(f"警告: {error_msg}")
140
            errors.append(error_msg)
141
            skipped_cases.append(case_name)
142
            continue
143

144
        # 构建文件名模式 - 根据BraTS2024的命名规范
145
        base_name = case_name  # 例如: BraTS-GLI-00000-000 或 BraTS-MET-00001-000
146

147
        required_files = {
148
            't1n': f"{base_name}-t1n.nii",
149
            't1c': f"{base_name}-t1c.nii",
150
            't2f': f"{base_name}-t2f.nii",
151
            't2w': f"{base_name}-t2w.nii",
152
            'seg': f"{base_name}-seg.nii"
153
        }
154

155
        # 检查文件存在性，支持.nii和.nii.gz格式
156
        files_exist = True
157
        invalid_files = []
158

159
        for key, filename in required_files.items():
160
            file_path = os.path.join(case_folder, filename)
161
            gz_file_path = file_path + ".gz"
162

163
            if os.path.exists(file_path):
164
                # 检查文件有效性
165
                is_valid, msg = check_file_validity(file_path)
166
                if not is_valid:
167
                    invalid_files.append(f"{filename}: {msg}")
168
                    files_exist = False
169
            elif os.path.exists(gz_file_path):
170
                required_files[key] = filename + ".gz"
171
                # 检查文件有效性
172
                is_valid, msg = check_file_validity(gz_file_path)
173
                if not is_valid:
174
                    invalid_files.append(f"{filename}.gz: {msg}")
175
                    files_exist = False
176
            else:
177
                error_msg = f"文件缺失 - 病例: {case_name}, 文件: {filename} 或 {filename}.gz"
178
                print(f"警告: {error_msg}")
179
                errors.append(error_msg)
180
                files_exist = False
181

182
        if invalid_files:
183
            for invalid_file in invalid_files:
184
                error_msg = f"文件无效 - 病例: {case_name}, {invalid_file}"
185
                print(f"警告: {error_msg}")
186
                errors.append(error_msg)
187

188
        if not files_exist:
189
            skipped_cases.append(case_name)
190
            continue
191

192
        # 决定这个病例是用于训练还是测试（前80%用于训练）
193
        case_success = True
194

195
        if i < len(all_cases) * 0.8:
196
            # 训练数据
197
            print(f"处理训练病例: {case_name}")
198

199
            # 复制图像文件
200
            for modality, suffix in modality_mapping.items():
201
                src_file = os.path.join(case_folder, required_files[modality])
202
                dst_file = os.path.join(imagesTr_folder, f"{case_name}_{suffix}.nii.gz")
203

204
                if not safe_copy_image(src_file, dst_file, case_name, modality):
205
                    case_success = False
206

207
            # 复制分割标签
208
            src_seg = os.path.join(case_folder, required_files['seg'])
209
            dst_seg = os.path.join(labelsTr_folder, f"{case_name}.nii.gz")
210
            if not safe_copy_label(src_seg, dst_seg, case_name):
211
                case_success = False
212

213
            if case_success:
214
                training_cases.append(case_name)
215
                print(f"训练病例 {case_name} 处理成功")
216
            else:
217
                skipped_cases.append(case_name)
218
                print(f"训练病例 {case_name} 处理失败，已跳过")
219

220
        else:
221
            # 测试数据
222
            print(f"处理测试病例: {case_name}")
223

224
            # 复制图像文件
225
            for modality, suffix in modality_mapping.items():
226
                src_file = os.path.join(case_folder, required_files[modality])
227
                dst_file = os.path.join(imagesTs_folder, f"{case_name}_{suffix}.nii.gz")
228

229
                if not safe_copy_image(src_file, dst_file, case_name, modality):
230
                    case_success = False
231

232
            # 复制测试数据的标签
233
            src_seg = os.path.join(case_folder, required_files['seg'])
234
            dst_seg = os.path.join(labelsTs_folder, f"{case_name}.nii.gz")
235
            if not safe_copy_label(src_seg, dst_seg, case_name):
236
                case_success = False
237

238
            if case_success:
239
                test_cases.append(case_name)
240
                print(f"测试病例 {case_name} 处理成功")
241
            else:
242
                skipped_cases.append(case_name)
243
                print(f"测试病例 {case_name} 处理失败，已跳过")
244

245
    print(f"处理完成: {len(training_cases)} 个训练病例, {len(test_cases)} 个测试病例")
246
    print(f"跳过的病例数量: {len(skipped_cases)}")
247

248
    # 写入错误日志
249
    error_file_path = os.path.join(os.path.dirname(__file__), "error.txt")
250
    with open(error_file_path, 'w', encoding='utf-8') as f:
251
        f.write(f"BraTS2024数据转换错误报告\n")
252
        f.write(f"生成时间: {str(os.path.getctime(error_file_path)) if os.path.exists(error_file_path) else 'N/A'}\n")
253
        f.write(f"="*80 + "\n\n")
254
        f.write(f"总计处理: {len(all_cases)} 个病例\n")
255
        f.write(f"成功处理: {len(training_cases) + len(test_cases)} 个病例\n")
256
        f.write(f"跳过病例: {len(skipped_cases)} 个病例\n")
257
        f.write(f"错误数量: {len(errors)} 个错误\n\n")
258

259
        if skipped_cases:
260
            f.write("跳过的病例列表:\n")
261
            for case in skipped_cases:
262
                f.write(f"  - {case}\n")
263
            f.write("\n")
264

265
        if errors:
266
            f.write("详细错误信息:\n")
267
            for i, error in enumerate(errors, 1):
268
                f.write(f"{i}. {error}\n")
269
        else:
270
            f.write("没有发现错误。\n")
271

272
    print(f"错误日志已保存到: {error_file_path}")
273

274
    # 只有成功处理的病例数量大于0时才创建dataset.json
275
    if len(training_cases) + len(test_cases) > 0:
276
        # 创建dataset.json文件
277
        dataset_json = OrderedDict()
278
        dataset_json['name'] = "BraTS2024"
279
        dataset_json['description'] = "Brain Tumor Segmentation Challenge 2024"
280
        dataset_json['tensorImageSize'] = "4D"
281
        dataset_json['reference'] = "https://www.synapse.org/#!Synapse:syn53708249"
282
        dataset_json['licence'] = "see BraTS2024 website"
283
        dataset_json['release'] = "1.0"
284

285
        # 模态信息 - BraTS2024的模态
286
        dataset_json['modality'] = {
287
            "0": "T1n",    # T1 native (非增强T1)
288
            "1": "T1c",    # T1 contrast enhanced (增强T1)
289
            "2": "T2f",    # T2 FLAIR
290
            "3": "T2w"     # T2 weighted
291
        }
292

293
        # 标签信息 - BraTS2024包含新的切除腔标签
294
        dataset_json['labels'] = {
295
            "0": "background",
296
            "1": "NETC (Non-Enhancing Tumor Core)",      # 非增强肿瘤核心
297
            "2": "SNFH (Surrounding Non-enhancing FLAIR Hyperintensity)",  # 周围非增强FLAIR高信号（水肿）
298
            "3": "ET (Enhancing Tumor)",                 # 增强肿瘤
299
            "4": "RC (Resection Cavity)"                 # 切除腔（BraTS2024新增）
300
        }
301

302
        # 训练和测试数据列表
303
        dataset_json['numTraining'] = len(training_cases)
304
        dataset_json['numTest'] = len(test_cases)
305

306
        dataset_json['training'] = []
307
        for case in training_cases:
308
            case_dict = {
309
                "image": f"./imagesTr/{case}.nii.gz",
310
                "label": f"./labelsTr/{case}.nii.gz"
311
            }
312
            dataset_json['training'].append(case_dict)
313

314
        dataset_json['test'] = []
315
        for case in test_cases:
316
            dataset_json['test'].append(f"./imagesTs/{case}.nii.gz")
317

318
        # 保存dataset.json
319
        json_file_path = os.path.join(task_folder, "dataset.json")
320
        with open(json_file_path, 'w') as f:
321
            json.dump(dataset_json, f, indent=4)
322

323
        print(f"dataset.json 已保存到: {json_file_path}")
324
        print("BraTS2024数据转换完成！标签保持原始值不变：")
325
        print("  0 - background (背景)")
326
        print("  1 - NETC (Non-Enhancing Tumor Core) - 非增强肿瘤核心")
327
        print("  2 - SNFH (Surrounding Non-enhancing FLAIR Hyperintensity) - 周围非增强FLAIR高信号")
328
        print("  3 - ET (Enhancing Tumor) - 增强肿瘤")
329
        print("  4 - RC (Resection Cavity) - 切除腔")
330

331
        return task_folder
332
    else:
333
        print("警告: 没有成功处理任何病例，未生成dataset.json文件")
334
        return None
335

336
# 使用示例
337
if __name__ == "__main__":
338
    # 设置路径
339
    brats_root = "BraTS2024"  # 您的BraTS2024数据根目录
340
    nnunet_raw_data_base = "DATASET"  # nnUNet原始数据基础目录
341

342
    # 执行转换
343
    try:
344
        result = convert_brats2024_to_nnunet(brats_root, nnunet_raw_data_base)
345
        if result:
346
            print(f"\n转换成功完成！输出目录: {result}")
347
            print("可以继续进行nnUNet的预处理和训练步骤。")
348
            print("\n注意：BraTS2024引入了新的切除腔（RC）标签（标签值4），")
349
            print("这是与之前BraTS版本的主要区别。")
350
        else:
351
            print("\n转换失败，请查看错误日志了解详细信息。")
352
    except Exception as e:
353
        print(f"程序执行失败: {str(e)}")
354
        # 即使主程序失败，也要记录错误
355
        error_file_path = os.path.join(os.path.dirname(__file__), "error.txt")
356
        with open(error_file_path, 'w', encoding='utf-8') as f:
357
            f.write(f"程序执行失败: {str(e)}\n")
358
        print(f"错误已记录到: {error_file_path}")