1138 lines
40 KiB
Python
1138 lines
40 KiB
Python
import base64
|
||
import json
|
||
import os
|
||
import shutil
|
||
import threading
|
||
import time
|
||
import traceback
|
||
import uuid
|
||
import zipfile
|
||
from email.parser import BytesParser
|
||
from email.policy import default
|
||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||
from io import BytesIO
|
||
from pathlib import Path
|
||
from urllib.parse import parse_qs, quote, unquote, urlparse
|
||
|
||
os.environ.setdefault("MPLCONFIGDIR", "/tmp/head_ct_morph_matplotlib")
|
||
|
||
import pydicom
|
||
from pydicom.multival import MultiValue
|
||
from PIL import Image, ImageDraw
|
||
|
||
from generate_head_extension_video import generate_video
|
||
from head_extension_app import (
|
||
APP_DIR,
|
||
crop_head_neck,
|
||
ct_window,
|
||
draw_cutoff_line,
|
||
fit_image,
|
||
load_dicom_volume,
|
||
preview_deform_2d,
|
||
run_deformation,
|
||
sagittal_mip,
|
||
safe_mkdir,
|
||
)
|
||
|
||
|
||
HOST = "0.0.0.0"
|
||
PORT = 8787
|
||
JOBS = {}
|
||
JOBS_LOCK = threading.Lock()
|
||
DICOM_FILE_CACHE = {}
|
||
LIBRARY_DIR = APP_DIR / "web_library"
|
||
LIBRARY_META = LIBRARY_DIR / "library.json"
|
||
RESULT_DIR = APP_DIR / "web_results"
|
||
JOBS_META = RESULT_DIR / "jobs.json"
|
||
USER_TASKS_META = RESULT_DIR / "user_tasks.json"
|
||
PREVIEW_CACHE_DIR = LIBRARY_DIR / "_preview_cache"
|
||
|
||
|
||
def json_default(value):
|
||
if isinstance(value, Path):
|
||
return str(value.resolve())
|
||
return str(value)
|
||
|
||
|
||
def now_date():
|
||
return time.strftime("%Y-%m-%d")
|
||
|
||
|
||
def safe_filename(name):
|
||
return "".join(char if char.isalnum() or char in "._-" else "_" for char in Path(name).name)
|
||
|
||
|
||
def normalized_username(username):
|
||
username = str(username or "").strip()
|
||
return username or "anonymous"
|
||
|
||
|
||
def read_json_file(path, default):
|
||
path = Path(path)
|
||
if not path.exists():
|
||
return default
|
||
try:
|
||
return json.loads(path.read_text(encoding="utf-8"))
|
||
except Exception:
|
||
return default
|
||
|
||
|
||
def write_json_file(path, value):
|
||
path = Path(path)
|
||
safe_mkdir(path.parent)
|
||
path.write_text(json.dumps(value, ensure_ascii=False, indent=2, default=json_default), encoding="utf-8")
|
||
|
||
|
||
def read_library_meta():
|
||
safe_mkdir(LIBRARY_DIR)
|
||
if LIBRARY_META.exists():
|
||
return json.loads(LIBRARY_META.read_text(encoding="utf-8"))
|
||
return []
|
||
|
||
|
||
def write_library_meta(items):
|
||
safe_mkdir(LIBRARY_DIR)
|
||
LIBRARY_META.write_text(json.dumps(items, ensure_ascii=False, indent=2), encoding="utf-8")
|
||
|
||
|
||
def folder_size_mb(path):
|
||
total = 0
|
||
for file_path in Path(path).glob("*.dcm"):
|
||
total += file_path.stat().st_size
|
||
return round(total / 1024 / 1024)
|
||
|
||
|
||
def build_library_record(item_id, patient_id, dicom_path, source="upload", version="DICOM-LIB"):
|
||
dicom_dir = Path(dicom_path).resolve()
|
||
file_count = len(list(dicom_dir.glob("*.dcm")))
|
||
return {
|
||
"id": item_id,
|
||
"patientId": patient_id,
|
||
"date": now_date(),
|
||
"version": version,
|
||
"status": "processed",
|
||
"size": folder_size_mb(dicom_dir),
|
||
"previewColor": "bg-slate-900" if source == "upload" else "bg-slate-800",
|
||
"dicomPath": str(dicom_dir),
|
||
"fileCount": file_count,
|
||
"source": source,
|
||
}
|
||
|
||
|
||
def list_library():
|
||
items = [
|
||
item for item in read_library_meta()
|
||
if item.get("source") != "seed" and item.get("id") != "seed_ori_head_ct"
|
||
]
|
||
|
||
live_items = []
|
||
changed = False
|
||
for item in items:
|
||
dicom_path = Path(item.get("dicomPath", ""))
|
||
if dicom_path.exists():
|
||
item["fileCount"] = len(list(dicom_path.glob("*.dcm")))
|
||
item["size"] = folder_size_mb(dicom_path)
|
||
live_items.append(item)
|
||
else:
|
||
changed = True
|
||
if changed:
|
||
write_library_meta(live_items)
|
||
return live_items
|
||
|
||
|
||
def sort_key_for_dicom(path):
|
||
path = Path(path)
|
||
try:
|
||
ds = pydicom.dcmread(str(path), stop_before_pixels=True, force=True)
|
||
return (0, int(getattr(ds, "InstanceNumber", 0)), path.name)
|
||
except Exception:
|
||
stem = path.stem
|
||
return (1, int(stem) if stem.isdigit() else 0, path.name)
|
||
|
||
|
||
def sorted_dicom_files(dicom_dir):
|
||
dicom_dir = Path(dicom_dir).resolve()
|
||
files = list(dicom_dir.glob("*.dcm"))
|
||
signature = (
|
||
str(dicom_dir),
|
||
len(files),
|
||
max((file_path.stat().st_mtime for file_path in files), default=0),
|
||
)
|
||
cached = DICOM_FILE_CACHE.get(str(dicom_dir))
|
||
if cached and cached["signature"] == signature:
|
||
return cached["files"]
|
||
|
||
sorted_files = sorted(files, key=sort_key_for_dicom)
|
||
DICOM_FILE_CACHE[str(dicom_dir)] = {
|
||
"signature": signature,
|
||
"files": sorted_files,
|
||
}
|
||
return sorted_files
|
||
|
||
|
||
def find_library_item(item_id):
|
||
return next((item for item in list_library() if item["id"] == item_id), None)
|
||
|
||
|
||
def make_library_slice_preview(item_id, index):
|
||
item = find_library_item(item_id)
|
||
if not item:
|
||
raise RuntimeError("影像库中没有找到该数据。")
|
||
|
||
dicom_files = sorted_dicom_files(item["dicomPath"])
|
||
if not dicom_files:
|
||
raise RuntimeError("该影像数据没有可预览的 .dcm 文件。")
|
||
|
||
count = len(dicom_files)
|
||
index = max(0, min(int(index), count - 1))
|
||
cache_dir = PREVIEW_CACHE_DIR / item_id
|
||
safe_mkdir(cache_dir)
|
||
preview_path = cache_dir / f"slice_{index:04d}.png"
|
||
if not preview_path.exists():
|
||
ds = pydicom.dcmread(str(dicom_files[index]), force=True)
|
||
image = ds.pixel_array.astype("float32")
|
||
image = image * float(getattr(ds, "RescaleSlope", 1))
|
||
image = image + float(getattr(ds, "RescaleIntercept", 0))
|
||
|
||
preview = Image.fromarray(ct_window(image)).convert("RGB")
|
||
preview = fit_image(preview, 720, 520)
|
||
preview.save(preview_path, format="PNG")
|
||
|
||
neighbors = [value for value in [index - 1, index + 1] if 0 <= value < count]
|
||
return {
|
||
"imageUrl": f"/api/file?path={quote(str(preview_path.resolve()), safe='')}",
|
||
"index": index,
|
||
"count": count,
|
||
"file": dicom_files[index].name,
|
||
"patientId": item["patientId"],
|
||
"neighbors": [
|
||
f"/api/library/preview?id={item_id}&index={neighbor}"
|
||
for neighbor in neighbors
|
||
],
|
||
}
|
||
|
||
|
||
def dicom_value(ds, name, fallback="-"):
|
||
value = getattr(ds, name, fallback)
|
||
if value in [None, ""]:
|
||
return fallback
|
||
if isinstance(value, (list, tuple, MultiValue)):
|
||
return " / ".join(str(item) for item in value)
|
||
return str(value)
|
||
|
||
|
||
def dicom_date(value):
|
||
value = str(value or "")
|
||
if len(value) == 8 and value.isdigit():
|
||
return f"{value[0:4]}-{value[4:6]}-{value[6:8]}"
|
||
return value or "-"
|
||
|
||
|
||
def dicom_time(value):
|
||
value = str(value or "")
|
||
if len(value) >= 6 and value[:6].isdigit():
|
||
return f"{value[0:2]}:{value[2:4]}:{value[4:6]}"
|
||
return value or "-"
|
||
|
||
|
||
def make_library_info(item_id):
|
||
item = find_library_item(item_id)
|
||
if not item:
|
||
raise RuntimeError("影像库中没有找到该数据。")
|
||
|
||
dicom_files = sorted_dicom_files(item["dicomPath"])
|
||
if not dicom_files:
|
||
raise RuntimeError("该影像数据没有可读取的 .dcm 文件。")
|
||
|
||
first = pydicom.dcmread(str(dicom_files[0]), stop_before_pixels=True, force=True)
|
||
last = pydicom.dcmread(str(dicom_files[-1]), stop_before_pixels=True, force=True)
|
||
pixel_spacing = dicom_value(first, "PixelSpacing")
|
||
matrix = f"{dicom_value(first, 'Columns')} x {dicom_value(first, 'Rows')}"
|
||
instance_range = f"{dicom_value(first, 'InstanceNumber')} - {dicom_value(last, 'InstanceNumber')}"
|
||
|
||
return {
|
||
"id": item["id"],
|
||
"patientId": item["patientId"],
|
||
"fileCount": len(dicom_files),
|
||
"groups": [
|
||
{
|
||
"title": "患者信息",
|
||
"items": [
|
||
{"label": "患者姓名", "value": dicom_value(first, "PatientName")},
|
||
{"label": "患者 ID", "value": dicom_value(first, "PatientID")},
|
||
{"label": "性别", "value": dicom_value(first, "PatientSex")},
|
||
{"label": "年龄", "value": dicom_value(first, "PatientAge")},
|
||
],
|
||
},
|
||
{
|
||
"title": "检查信息",
|
||
"items": [
|
||
{"label": "检查日期", "value": dicom_date(getattr(first, "StudyDate", ""))},
|
||
{"label": "检查时间", "value": dicom_time(getattr(first, "StudyTime", ""))},
|
||
{"label": "检查描述", "value": dicom_value(first, "StudyDescription")},
|
||
{"label": "检查号", "value": dicom_value(first, "AccessionNumber")},
|
||
{"label": "机构", "value": dicom_value(first, "InstitutionName")},
|
||
],
|
||
},
|
||
{
|
||
"title": "序列信息",
|
||
"items": [
|
||
{"label": "模态", "value": dicom_value(first, "Modality")},
|
||
{"label": "部位", "value": dicom_value(first, "BodyPartExamined")},
|
||
{"label": "序列描述", "value": dicom_value(first, "SeriesDescription")},
|
||
{"label": "序列号", "value": dicom_value(first, "SeriesNumber")},
|
||
{"label": "制造商", "value": dicom_value(first, "Manufacturer")},
|
||
],
|
||
},
|
||
{
|
||
"title": "图像参数",
|
||
"items": [
|
||
{"label": "切片数", "value": str(len(dicom_files))},
|
||
{"label": "Instance 范围", "value": instance_range},
|
||
{"label": "矩阵", "value": matrix},
|
||
{"label": "像素间距", "value": pixel_spacing},
|
||
{"label": "层厚", "value": dicom_value(first, "SliceThickness")},
|
||
{"label": "层间距", "value": dicom_value(first, "SpacingBetweenSlices")},
|
||
{"label": "卷积核", "value": dicom_value(first, "ConvolutionKernel")},
|
||
],
|
||
},
|
||
{
|
||
"title": "扫描参数",
|
||
"items": [
|
||
{"label": "KVP", "value": dicom_value(first, "KVP")},
|
||
{"label": "管电流", "value": dicom_value(first, "XRayTubeCurrent")},
|
||
{"label": "曝光时间", "value": dicom_value(first, "ExposureTime")},
|
||
{"label": "重建直径", "value": dicom_value(first, "ReconstructionDiameter")},
|
||
],
|
||
},
|
||
],
|
||
}
|
||
|
||
|
||
def parse_multipart(headers, body):
|
||
content_type = headers.get("content-type", "")
|
||
message = BytesParser(policy=default).parsebytes(
|
||
f"Content-Type: {content_type}\r\nMIME-Version: 1.0\r\n\r\n".encode("utf-8") + body
|
||
)
|
||
fields = {}
|
||
files = []
|
||
for part in message.iter_parts():
|
||
name = part.get_param("name", header="content-disposition")
|
||
filename = part.get_filename()
|
||
payload = part.get_payload(decode=True) or b""
|
||
if filename:
|
||
files.append((name, filename, payload))
|
||
elif name:
|
||
fields[name] = payload.decode("utf-8", errors="replace")
|
||
return fields, files
|
||
|
||
|
||
def write_dicom_payload(target_dir, filename, payload, index):
|
||
output_name = safe_filename(filename) or f"{index}.dcm"
|
||
output_path = target_dir / output_name
|
||
if output_path.exists():
|
||
output_path = target_dir / f"{index}_{output_name}"
|
||
output_path.write_bytes(payload)
|
||
|
||
|
||
def add_dicom_from_zip(target_dir, zip_filename, payload, start_index):
|
||
count = 0
|
||
try:
|
||
with zipfile.ZipFile(BytesIO(payload)) as archive:
|
||
for member in archive.infolist():
|
||
if member.is_dir():
|
||
continue
|
||
member_name = member.filename.replace("\\", "/")
|
||
if Path(member_name).suffix.lower() != ".dcm":
|
||
continue
|
||
if Path(member_name).is_absolute() or ".." in Path(member_name).parts:
|
||
continue
|
||
count += 1
|
||
with archive.open(member) as member_file:
|
||
write_dicom_payload(
|
||
target_dir,
|
||
f"{Path(zip_filename).stem}_{Path(member_name).name}",
|
||
member_file.read(),
|
||
start_index + count,
|
||
)
|
||
except zipfile.BadZipFile as exc:
|
||
raise RuntimeError(f"{zip_filename} 不是有效的 zip 压缩包。") from exc
|
||
return count
|
||
|
||
|
||
def validate_single_dicom_series(dicom_dir):
|
||
series_counts = {}
|
||
for dicom_path in Path(dicom_dir).glob("*.dcm"):
|
||
try:
|
||
ds = pydicom.dcmread(str(dicom_path), stop_before_pixels=True, force=True)
|
||
except Exception as exc:
|
||
raise RuntimeError(f"{dicom_path.name} 不是可读取的 DICOM 文件。") from exc
|
||
series_uid = str(getattr(ds, "SeriesInstanceUID", "") or "NO_SERIES_UID")
|
||
series_counts[series_uid] = series_counts.get(series_uid, 0) + 1
|
||
|
||
if len(series_counts) > 1:
|
||
series_summary = ", ".join(str(count) for count in sorted(series_counts.values(), reverse=True))
|
||
raise RuntimeError(
|
||
"上传内容包含多个 DICOM 序列，不能作为一个影像库数据集导入。"
|
||
f"检测到 {len(series_counts)} 个序列，分别约 {series_summary} 张。"
|
||
"请上传单个序列文件夹/ZIP。"
|
||
)
|
||
|
||
|
||
def reset_demo_environment():
|
||
source_dir = APP_DIR / "Ori_Head_CT"
|
||
source_zip = APP_DIR / "Ori_Head_CT.zip"
|
||
demo_root = LIBRARY_DIR / "demo_ori_head_ct"
|
||
demo_dicom_dir = demo_root / "dicom"
|
||
|
||
if not source_dir.exists() and not source_zip.exists():
|
||
raise RuntimeError("未找到 Ori_Head_CT 或 Ori_Head_CT.zip，无法恢复演示环境。")
|
||
|
||
safe_mkdir(LIBRARY_DIR)
|
||
for child in LIBRARY_DIR.iterdir():
|
||
if child.is_dir():
|
||
shutil.rmtree(child)
|
||
else:
|
||
child.unlink()
|
||
|
||
safe_mkdir(demo_dicom_dir)
|
||
copied = 0
|
||
if source_dir.exists():
|
||
for dicom_path in sorted(source_dir.glob("*.dcm")):
|
||
shutil.copy2(dicom_path, demo_dicom_dir / dicom_path.name)
|
||
copied += 1
|
||
else:
|
||
with zipfile.ZipFile(source_zip) as archive:
|
||
for member in archive.infolist():
|
||
if member.is_dir():
|
||
continue
|
||
member_name = member.filename.replace("\\", "/")
|
||
if Path(member_name).suffix.lower() != ".dcm":
|
||
continue
|
||
if Path(member_name).is_absolute() or ".." in Path(member_name).parts:
|
||
continue
|
||
copied += 1
|
||
with archive.open(member) as member_file:
|
||
write_dicom_payload(demo_dicom_dir, Path(member_name).name, member_file.read(), copied)
|
||
|
||
if copied == 0:
|
||
shutil.rmtree(demo_root)
|
||
raise RuntimeError("Ori_Head_CT 中没有找到 .dcm 文件。")
|
||
|
||
validate_single_dicom_series(demo_dicom_dir)
|
||
record = build_library_record(
|
||
"demo_ori_head_ct",
|
||
"Ori_Head_CT",
|
||
demo_dicom_dir,
|
||
source="upload",
|
||
version="DICOM-DEMO",
|
||
)
|
||
write_library_meta([record])
|
||
DICOM_FILE_CACHE.clear()
|
||
|
||
if RESULT_DIR.exists():
|
||
shutil.rmtree(RESULT_DIR)
|
||
safe_mkdir(RESULT_DIR)
|
||
with JOBS_LOCK:
|
||
JOBS.clear()
|
||
persist_jobs_locked()
|
||
write_json_file(USER_TASKS_META, {})
|
||
|
||
return {
|
||
"ok": True,
|
||
"message": "演示环境已恢复出厂设置。",
|
||
"items": [record],
|
||
}
|
||
|
||
|
||
def upload_library_item(headers, body):
|
||
fields, files = parse_multipart(headers, body)
|
||
dicom_files = [
|
||
(filename, payload)
|
||
for _, filename, payload in files
|
||
if Path(filename).suffix.lower() == ".dcm"
|
||
]
|
||
zip_files = [
|
||
(filename, payload)
|
||
for _, filename, payload in files
|
||
if Path(filename).suffix.lower() == ".zip"
|
||
]
|
||
if not dicom_files and not zip_files:
|
||
raise RuntimeError("上传内容里没有找到 .dcm 文件或 .zip 压缩包。")
|
||
|
||
item_id = time.strftime("%Y%m%d_%H%M%S_") + uuid.uuid4().hex[:8]
|
||
first_upload_name = (dicom_files[0][0] if dicom_files else zip_files[0][0])
|
||
default_patient_id = Path(first_upload_name).stem.upper() if zip_files else f"WEB_{item_id[-8:].upper()}"
|
||
patient_id = fields.get("patientId") or default_patient_id
|
||
target_dir = LIBRARY_DIR / item_id / "dicom"
|
||
reset_dir(target_dir)
|
||
|
||
for index, (filename, payload) in enumerate(dicom_files, start=1):
|
||
write_dicom_payload(target_dir, filename, payload, index)
|
||
|
||
zip_dicom_count = 0
|
||
for filename, payload in zip_files:
|
||
zip_dicom_count += add_dicom_from_zip(
|
||
target_dir,
|
||
filename,
|
||
payload,
|
||
len(dicom_files) + zip_dicom_count,
|
||
)
|
||
|
||
total_dicom_count = len(dicom_files) + zip_dicom_count
|
||
if total_dicom_count == 0:
|
||
shutil.rmtree(target_dir.parent)
|
||
raise RuntimeError("压缩包里没有找到 .dcm 文件。")
|
||
try:
|
||
validate_single_dicom_series(target_dir)
|
||
except Exception:
|
||
shutil.rmtree(target_dir.parent)
|
||
raise
|
||
|
||
record = build_library_record(
|
||
item_id,
|
||
patient_id,
|
||
target_dir,
|
||
source="upload",
|
||
version="DICOM-ZIP" if zip_files and not dicom_files else "DICOM-LIB",
|
||
)
|
||
items = [record, *list_library()]
|
||
write_library_meta(items)
|
||
return record
|
||
|
||
|
||
def reset_dir(path):
|
||
path = Path(path)
|
||
if path.exists():
|
||
shutil.rmtree(path)
|
||
path.mkdir(parents=True, exist_ok=True)
|
||
|
||
|
||
def zip_folder(source_dir, zip_path):
|
||
source_dir = Path(source_dir).resolve()
|
||
zip_path = Path(zip_path).resolve()
|
||
safe_mkdir(zip_path.parent)
|
||
if zip_path.exists():
|
||
zip_path.unlink()
|
||
with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
|
||
for file_path in source_dir.rglob("*"):
|
||
if file_path.is_file():
|
||
archive.write(file_path, file_path.relative_to(source_dir))
|
||
return zip_path
|
||
|
||
|
||
def read_user_tasks():
|
||
tasks = read_json_file(USER_TASKS_META, {})
|
||
return tasks if isinstance(tasks, dict) else {}
|
||
|
||
|
||
def write_user_tasks(tasks):
|
||
write_json_file(USER_TASKS_META, tasks)
|
||
|
||
|
||
def set_user_task(username, kind, job_id):
|
||
username = normalized_username(username)
|
||
tasks = read_user_tasks()
|
||
tasks.setdefault(username, {})[kind] = job_id
|
||
write_user_tasks(tasks)
|
||
|
||
|
||
def get_user_task_job(username, kind):
|
||
username = normalized_username(username)
|
||
tasks = read_user_tasks()
|
||
job_id = tasks.get(username, {}).get(kind)
|
||
if not job_id:
|
||
return None
|
||
return get_job(job_id)
|
||
|
||
|
||
def persist_jobs_locked():
|
||
write_json_file(JOBS_META, JOBS)
|
||
|
||
|
||
def load_persisted_jobs():
|
||
saved_jobs = read_json_file(JOBS_META, {})
|
||
if not isinstance(saved_jobs, dict):
|
||
return
|
||
now_text = time.strftime("%Y-%m-%d %H:%M:%S")
|
||
with JOBS_LOCK:
|
||
for job_id, job in saved_jobs.items():
|
||
if not isinstance(job, dict):
|
||
continue
|
||
if job.get("status") == "running":
|
||
job = {
|
||
**job,
|
||
"status": "failed",
|
||
"message": "后端已重启，运行中的任务已中断。",
|
||
"error": "后端服务重启后无法继续运行中的任务，请重新提交。",
|
||
"updatedAt": now_text,
|
||
}
|
||
JOBS[job_id] = job
|
||
persist_jobs_locked()
|
||
|
||
|
||
def deformation_progress_for_message(message):
|
||
if "已复制" in message:
|
||
return 20
|
||
if "正在生成四种状态" in message:
|
||
return 35
|
||
if "正在应用形变" in message:
|
||
return 55
|
||
if "正在写出四种状态" in message:
|
||
return 72
|
||
if "正在生成四状态过程对比图" in message:
|
||
return 82
|
||
return None
|
||
|
||
|
||
def set_job(job_id, **updates):
|
||
with JOBS_LOCK:
|
||
job = JOBS[job_id]
|
||
job.update(updates)
|
||
job["updatedAt"] = time.strftime("%Y-%m-%d %H:%M:%S")
|
||
persist_jobs_locked()
|
||
|
||
|
||
def get_job(job_id):
|
||
with JOBS_LOCK:
|
||
job = JOBS.get(job_id)
|
||
return dict(job) if job else None
|
||
|
||
|
||
def start_job(kind, worker, owner=None, params=None, remember_user_task=True):
|
||
job_id = uuid.uuid4().hex[:12]
|
||
owner = normalized_username(owner)
|
||
with JOBS_LOCK:
|
||
JOBS[job_id] = {
|
||
"id": job_id,
|
||
"kind": kind,
|
||
"owner": owner,
|
||
"status": "running",
|
||
"message": "任务已启动。",
|
||
"progress": 1,
|
||
"params": params or {},
|
||
"result": None,
|
||
"error": None,
|
||
"createdAt": time.strftime("%Y-%m-%d %H:%M:%S"),
|
||
"updatedAt": time.strftime("%Y-%m-%d %H:%M:%S"),
|
||
}
|
||
persist_jobs_locked()
|
||
if remember_user_task:
|
||
set_user_task(owner, kind, job_id)
|
||
|
||
def run():
|
||
try:
|
||
result = worker(job_id)
|
||
set_job(job_id, status="completed", message="任务完成。", progress=100, result=result)
|
||
except Exception as exc:
|
||
set_job(
|
||
job_id,
|
||
status="failed",
|
||
message="任务失败。",
|
||
error=str(exc),
|
||
traceback=traceback.format_exc(),
|
||
)
|
||
|
||
threading.Thread(target=run, daemon=True).start()
|
||
return get_job(job_id)
|
||
|
||
|
||
def make_preview(
|
||
input_dir,
|
||
angle_degrees,
|
||
show_cutoff_line=True,
|
||
transition_width=90,
|
||
mode="soft_transition",
|
||
gaussian_sigma=3,
|
||
):
|
||
if mode not in {"hard_boundary", "gaussian_smooth", "soft_transition"}:
|
||
mode = "soft_transition"
|
||
volume = load_dicom_volume(input_dir)
|
||
before = crop_head_neck(sagittal_mip(volume))
|
||
before_display = draw_cutoff_line(before, volume.shape[0]) if show_cutoff_line else before
|
||
after = preview_deform_2d(
|
||
before_display,
|
||
float(angle_degrees),
|
||
mode,
|
||
transition_width=float(transition_width),
|
||
gaussian_sigma=float(gaussian_sigma),
|
||
)
|
||
|
||
canvas_image = Image.new("RGB", (1440, 520), (0, 0, 0))
|
||
canvas_image.paste(fit_image(before_display, 700, 520), (0, 0))
|
||
canvas_image.paste(fit_image(after, 700, 520), (740, 0))
|
||
|
||
panels = [
|
||
("Original", before_display),
|
||
(
|
||
"Hard boundary",
|
||
preview_deform_2d(before_display, float(angle_degrees), "hard_boundary"),
|
||
),
|
||
(
|
||
"Gaussian smooth",
|
||
preview_deform_2d(
|
||
before_display,
|
||
float(angle_degrees),
|
||
"gaussian_smooth",
|
||
gaussian_sigma=float(gaussian_sigma),
|
||
),
|
||
),
|
||
(
|
||
"Soft transition",
|
||
preview_deform_2d(
|
||
before_display,
|
||
float(angle_degrees),
|
||
"soft_transition",
|
||
transition_width=float(transition_width),
|
||
),
|
||
),
|
||
]
|
||
process_image = Image.new("RGB", (1440, 430), (0, 0, 0))
|
||
process_draw = ImageDraw.Draw(process_image)
|
||
panel_width = 330
|
||
panel_height = 300
|
||
margin = 35
|
||
gap = 20
|
||
for index, (label, panel) in enumerate(panels):
|
||
x = margin + index * (panel_width + gap)
|
||
process_draw.text((x, 28), label, fill=(230, 230, 230))
|
||
process_image.paste(fit_image(panel, panel_width, panel_height), (x, 70))
|
||
process_draw.text(
|
||
(margin, 390),
|
||
f"Angle {float(angle_degrees):.1f} deg",
|
||
fill=(170, 170, 170),
|
||
)
|
||
|
||
canvas = BytesIO()
|
||
canvas_image.save(canvas, format="PNG")
|
||
encoded = base64.b64encode(canvas.getvalue()).decode("ascii")
|
||
process_canvas = BytesIO()
|
||
process_image.save(process_canvas, format="PNG")
|
||
process_encoded = base64.b64encode(process_canvas.getvalue()).decode("ascii")
|
||
return {
|
||
"image": f"data:image/png;base64,{encoded}",
|
||
"processImage": f"data:image/png;base64,{process_encoded}",
|
||
"source": str(Path(input_dir).resolve()),
|
||
"angleDegrees": float(angle_degrees),
|
||
}
|
||
|
||
|
||
def serialize_outputs(output_paths, preview_paths):
|
||
return {
|
||
"outputs": {key: str(Path(value).resolve()) for key, value in output_paths.items()},
|
||
"previews": {
|
||
"comparison": str(Path(preview_paths["comparison"]).resolve()),
|
||
"screenshots": str(Path(preview_paths["screenshots"]).resolve()),
|
||
},
|
||
"zip": None,
|
||
"stateZips": {},
|
||
}
|
||
|
||
|
||
def file_metadata(file_path):
|
||
file_path = Path(file_path).resolve()
|
||
return {
|
||
"path": str(file_path),
|
||
"name": file_path.name,
|
||
"size": file_path.stat().st_size,
|
||
}
|
||
|
||
|
||
def zip_selected_deformation_outputs(job_root, outputs, previews, package_options):
|
||
dicom_keys = package_options.get("dicom") or []
|
||
image_keys = package_options.get("images") or []
|
||
if not dicom_keys and not image_keys:
|
||
raise RuntimeError("请至少选择一个要打包的内容。")
|
||
|
||
zip_path = Path(job_root) / f"head_ct_morph_selected_{Path(job_root).name}.zip"
|
||
if zip_path.exists():
|
||
zip_path.unlink()
|
||
|
||
dicom_names = {
|
||
"original": "dicom/ct_original",
|
||
"hard_boundary": "dicom/ct_hard_boundary",
|
||
"gaussian_smooth": "dicom/ct_gaussian_smooth",
|
||
"soft_transition": "dicom/ct_soft_transition",
|
||
}
|
||
image_files = {
|
||
"comparison": Path(previews.get("comparison", "")),
|
||
"original": Path(previews.get("screenshots", "")) / "original.png",
|
||
"hard_boundary": Path(previews.get("screenshots", "")) / "hard_boundary.png",
|
||
"gaussian_smooth": Path(previews.get("screenshots", "")) / "gaussian_smooth.png",
|
||
"soft_transition": Path(previews.get("screenshots", "")) / "soft_transition.png",
|
||
}
|
||
image_names = {
|
||
"comparison": "images/process_comparison_4states.png",
|
||
"original": "images/original.png",
|
||
"hard_boundary": "images/hard_boundary.png",
|
||
"gaussian_smooth": "images/gaussian_smooth.png",
|
||
"soft_transition": "images/soft_transition.png",
|
||
}
|
||
|
||
with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
|
||
for key in dicom_keys:
|
||
if key not in dicom_names:
|
||
continue
|
||
source_dir = Path(outputs.get(key, ""))
|
||
if not source_dir.exists():
|
||
raise RuntimeError(f"{key} 的 DICOM 输出目录不存在。")
|
||
for file_path in source_dir.rglob("*"):
|
||
if file_path.is_file():
|
||
archive.write(file_path, Path(dicom_names[key]) / file_path.relative_to(source_dir))
|
||
|
||
for key in image_keys:
|
||
if key not in image_files:
|
||
continue
|
||
source_file = image_files[key]
|
||
if not source_file.exists():
|
||
raise RuntimeError(f"{key} 的图片输出不存在。")
|
||
archive.write(source_file, image_names[key])
|
||
|
||
return zip_path
|
||
|
||
|
||
def prepare_deformation_zip(job_id, target, package_options=None):
|
||
job = get_job(job_id)
|
||
if not job:
|
||
raise RuntimeError("任务不存在。")
|
||
if job.get("kind") != "deformation":
|
||
raise RuntimeError("该任务不是四状态生成任务。")
|
||
if job.get("status") != "completed":
|
||
raise RuntimeError("四状态任务尚未完成，无法下载。")
|
||
|
||
result = job.get("result") or {}
|
||
outputs = result.get("outputs") or {}
|
||
previews = result.get("previews") or {}
|
||
job_root = RESULT_DIR / job_id
|
||
if target == "all":
|
||
if package_options:
|
||
return zip_selected_deformation_outputs(job_root, outputs, previews, package_options)
|
||
output_dir = job_root / "four_state_output"
|
||
if not output_dir.exists():
|
||
raise RuntimeError("四状态输出目录不存在。")
|
||
return zip_folder(output_dir, job_root / f"head_ct_morph_{job_id}.zip")
|
||
|
||
state_labels = {
|
||
"original": "original",
|
||
"hard_boundary": "hard_boundary",
|
||
"gaussian_smooth": "gaussian_smooth",
|
||
"soft_transition": "soft_transition",
|
||
}
|
||
if target not in state_labels:
|
||
raise RuntimeError("未知的四状态下载类型。")
|
||
|
||
source_dir = Path(outputs.get(target, ""))
|
||
if not source_dir.exists():
|
||
raise RuntimeError("该状态的 DICOM 输出目录不存在。")
|
||
return zip_folder(source_dir, job_root / f"{target}_{job_id}.zip")
|
||
|
||
|
||
class Handler(BaseHTTPRequestHandler):
|
||
def log_message(self, format, *args):
|
||
print("%s - %s" % (self.address_string(), format % args))
|
||
|
||
def do_OPTIONS(self):
|
||
self.send_response(204)
|
||
self.send_cors_headers()
|
||
self.end_headers()
|
||
|
||
def do_GET(self):
|
||
parsed = urlparse(self.path)
|
||
if parsed.path == "/api/health":
|
||
self.send_json({"ok": True, "service": "Head CT Morph backend"})
|
||
return
|
||
|
||
if parsed.path == "/api/defaults":
|
||
self.send_json(
|
||
{
|
||
"backend": f"http://127.0.0.1:{PORT}",
|
||
}
|
||
)
|
||
return
|
||
|
||
if parsed.path == "/api/library":
|
||
self.send_json({"items": list_library()})
|
||
return
|
||
|
||
if parsed.path == "/api/library/preview":
|
||
params = parse_qs(parsed.query)
|
||
item_id = params.get("id", [""])[0]
|
||
index = params.get("index", ["0"])[0]
|
||
self.send_json(make_library_slice_preview(item_id, index))
|
||
return
|
||
|
||
if parsed.path == "/api/library/info":
|
||
params = parse_qs(parsed.query)
|
||
item_id = params.get("id", [""])[0]
|
||
self.send_json(make_library_info(item_id))
|
||
return
|
||
|
||
if parsed.path == "/api/job":
|
||
params = parse_qs(parsed.query)
|
||
job_id = params.get("id", [""])[0]
|
||
job = get_job(job_id)
|
||
if not job:
|
||
self.send_json({"error": "任务不存在。"}, status=404)
|
||
return
|
||
self.send_json(job)
|
||
return
|
||
|
||
if parsed.path == "/api/user/job":
|
||
params = parse_qs(parsed.query)
|
||
username = params.get("username", [""])[0]
|
||
kind = params.get("kind", ["deformation"])[0]
|
||
if kind not in ["deformation", "video"]:
|
||
self.send_json({"error": "未知任务类型。"}, status=400)
|
||
return
|
||
self.send_json({"job": get_user_task_job(username, kind)})
|
||
return
|
||
|
||
if parsed.path == "/api/deformation/download":
|
||
params = parse_qs(parsed.query)
|
||
job_id = params.get("job", [""])[0]
|
||
target = params.get("target", ["all"])[0]
|
||
try:
|
||
zip_path = prepare_deformation_zip(job_id, target)
|
||
self.send_file(zip_path, "application/zip", as_attachment=True)
|
||
except Exception as exc:
|
||
self.send_json({"error": str(exc)}, status=400)
|
||
return
|
||
|
||
if parsed.path == "/api/file":
|
||
params = parse_qs(parsed.query)
|
||
file_path = Path(unquote(params.get("path", [""])[0])).resolve()
|
||
if not file_path.exists() or not file_path.is_file():
|
||
self.send_json({"error": "文件不存在。"}, status=404)
|
||
return
|
||
content_type = "application/octet-stream"
|
||
if file_path.suffix.lower() in [".png", ".jpg", ".jpeg"]:
|
||
content_type = "image/png" if file_path.suffix.lower() == ".png" else "image/jpeg"
|
||
elif file_path.suffix.lower() == ".mp4":
|
||
content_type = "video/mp4"
|
||
elif file_path.suffix.lower() == ".zip":
|
||
content_type = "application/zip"
|
||
self.send_file(
|
||
file_path,
|
||
content_type,
|
||
as_attachment=file_path.suffix.lower() == ".zip",
|
||
)
|
||
return
|
||
|
||
self.send_json({"error": "接口不存在。"}, status=404)
|
||
|
||
def do_POST(self):
|
||
parsed = urlparse(self.path)
|
||
try:
|
||
if parsed.path == "/api/library/upload":
|
||
body = self.read_bytes()
|
||
self.send_json(upload_library_item(self.headers, body), status=201)
|
||
return
|
||
|
||
body = self.read_json()
|
||
if parsed.path == "/api/demo/reset":
|
||
self.send_json(reset_demo_environment())
|
||
return
|
||
|
||
if parsed.path == "/api/preview":
|
||
self.send_json(
|
||
make_preview(
|
||
body["inputDir"],
|
||
body.get("angleDegrees", 12),
|
||
bool(body.get("showCutoffLine", True)),
|
||
body.get("transitionWidth", 90),
|
||
body.get("mode", "soft_transition"),
|
||
body.get("gaussianSigma", 3),
|
||
)
|
||
)
|
||
return
|
||
|
||
if parsed.path == "/api/deformation/package":
|
||
source_job_id = body["jobId"]
|
||
target = body.get("target", "all")
|
||
package_options = body.get("packageOptions")
|
||
username = normalized_username(body.get("username"))
|
||
|
||
def worker(job_id):
|
||
label = "四状态总 ZIP" if target == "all" else "本状态 DICOM ZIP"
|
||
set_job(job_id, message=f"正在打包{label}...", progress=10)
|
||
zip_path = prepare_deformation_zip(source_job_id, target, package_options)
|
||
set_job(job_id, message="打包完成，准备下载...", progress=95)
|
||
return {"file": file_metadata(zip_path)}
|
||
|
||
self.send_json(
|
||
start_job(
|
||
"zip",
|
||
worker,
|
||
owner=username,
|
||
params={
|
||
"sourceJobId": source_job_id,
|
||
"target": target,
|
||
"packageOptions": package_options,
|
||
},
|
||
remember_user_task=False,
|
||
),
|
||
status=202,
|
||
)
|
||
return
|
||
|
||
if parsed.path == "/api/deformation":
|
||
input_dir = body["inputDir"]
|
||
angle_degrees = float(body.get("angleDegrees", 12))
|
||
transition_width = int(body.get("transitionWidth", 90))
|
||
username = normalized_username(body.get("username"))
|
||
|
||
def worker(job_id):
|
||
job_root = RESULT_DIR / job_id
|
||
output_dir = job_root / "four_state_output"
|
||
reset_dir(job_root)
|
||
|
||
def progress(message):
|
||
progress_value = deformation_progress_for_message(message)
|
||
updates = {"message": message}
|
||
if progress_value is not None:
|
||
updates["progress"] = progress_value
|
||
set_job(job_id, **updates)
|
||
|
||
output_paths, preview_paths = run_deformation(
|
||
input_dir,
|
||
output_dir,
|
||
angle_degrees,
|
||
transition_width,
|
||
progress,
|
||
)
|
||
return serialize_outputs(output_paths, preview_paths)
|
||
|
||
self.send_json(
|
||
start_job(
|
||
"deformation",
|
||
worker,
|
||
owner=username,
|
||
params={
|
||
"inputDir": input_dir,
|
||
"angleDegrees": angle_degrees,
|
||
"transitionWidth": transition_width,
|
||
},
|
||
),
|
||
status=202,
|
||
)
|
||
return
|
||
|
||
if parsed.path == "/api/video":
|
||
input_dir = body["inputDir"]
|
||
max_angle = float(body.get("maxAngle", 20))
|
||
duration = float(body.get("durationSeconds", 6))
|
||
show_arrow = bool(body.get("showArrow", True))
|
||
mode = body.get("mode", "hard_boundary")
|
||
if mode not in {"hard_boundary", "gaussian_smooth", "soft_transition"}:
|
||
mode = "hard_boundary"
|
||
|
||
def worker(job_id):
|
||
job_root = RESULT_DIR / job_id
|
||
reset_dir(job_root)
|
||
output_file = job_root / f"head_extension_{mode}_{job_id}.mp4"
|
||
set_job(job_id, message=f"正在生成 {mode} 视频。")
|
||
output = generate_video(input_dir, output_file, max_angle, duration, show_arrow, mode)
|
||
output = Path(output).resolve()
|
||
return {
|
||
"video": {
|
||
"path": str(output),
|
||
"name": output.name,
|
||
"size": output.stat().st_size,
|
||
}
|
||
}
|
||
|
||
self.send_json(start_job("video", worker), status=202)
|
||
return
|
||
|
||
self.send_json({"error": "接口不存在。"}, status=404)
|
||
except Exception as exc:
|
||
self.send_json(
|
||
{
|
||
"error": str(exc),
|
||
"traceback": traceback.format_exc(),
|
||
},
|
||
status=500,
|
||
)
|
||
|
||
def do_DELETE(self):
|
||
parsed = urlparse(self.path)
|
||
if parsed.path != "/api/library":
|
||
self.send_json({"error": "接口不存在。"}, status=404)
|
||
return
|
||
|
||
params = parse_qs(parsed.query)
|
||
item_id = params.get("id", [""])[0]
|
||
items = list_library()
|
||
target = next((item for item in items if item["id"] == item_id), None)
|
||
if not target:
|
||
self.send_json({"error": "影像不存在。"}, status=404)
|
||
return
|
||
|
||
remaining = [item for item in items if item["id"] != item_id]
|
||
write_library_meta(remaining)
|
||
upload_root = Path(target["dicomPath"]).resolve().parent
|
||
if upload_root.exists() and upload_root.is_relative_to(LIBRARY_DIR.resolve()):
|
||
DICOM_FILE_CACHE.pop(str(Path(target["dicomPath"]).resolve()), None)
|
||
shutil.rmtree(upload_root)
|
||
preview_cache = PREVIEW_CACHE_DIR / item_id
|
||
if preview_cache.exists():
|
||
shutil.rmtree(preview_cache)
|
||
self.send_json({"ok": True, "items": remaining})
|
||
|
||
def read_bytes(self):
|
||
length = int(self.headers.get("content-length", "0"))
|
||
if length == 0:
|
||
return b""
|
||
return self.rfile.read(length)
|
||
|
||
def read_json(self):
|
||
body = self.read_bytes()
|
||
if not body:
|
||
return {}
|
||
return json.loads(body.decode("utf-8"))
|
||
|
||
def send_file(self, file_path, content_type="application/octet-stream", as_attachment=False):
|
||
file_path = Path(file_path).resolve()
|
||
if not file_path.exists() or not file_path.is_file():
|
||
self.send_json({"error": "文件不存在。"}, status=404)
|
||
return
|
||
|
||
self.send_response(200)
|
||
self.send_cors_headers()
|
||
self.send_header("Content-Type", content_type)
|
||
if as_attachment:
|
||
self.send_header("Content-Disposition", f'attachment; filename="{file_path.name}"')
|
||
self.send_header("Content-Length", str(file_path.stat().st_size))
|
||
self.end_headers()
|
||
with file_path.open("rb") as file_handle:
|
||
shutil.copyfileobj(file_handle, self.wfile)
|
||
|
||
def send_cors_headers(self):
|
||
self.send_header("Access-Control-Allow-Origin", "*")
|
||
self.send_header("Access-Control-Allow-Methods", "GET,POST,OPTIONS")
|
||
self.send_header("Access-Control-Allow-Headers", "Content-Type")
|
||
|
||
def send_json(self, payload, status=200):
|
||
data = json.dumps(payload, ensure_ascii=False, default=json_default).encode("utf-8")
|
||
self.send_response(status)
|
||
self.send_cors_headers()
|
||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||
self.send_header("Content-Length", str(len(data)))
|
||
self.end_headers()
|
||
self.wfile.write(data)
|
||
|
||
|
||
def main():
|
||
safe_mkdir(APP_DIR / "app_output")
|
||
safe_mkdir(APP_DIR / "ppt_video")
|
||
safe_mkdir(LIBRARY_DIR)
|
||
safe_mkdir(RESULT_DIR)
|
||
load_persisted_jobs()
|
||
server = ThreadingHTTPServer((HOST, PORT), Handler)
|
||
print(f"Head CT Morph backend running at http://{HOST}:{PORT}")
|
||
server.serve_forever()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|