Upload 40 files

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.9
+
+WORKDIR /app
+
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+
+COPY . .
+
+
+ENV BASE_PATH=${BASE_PATH}
+ENV SESSIONS_DIR_PATH=${SESSIONS_DIR_PATH}
+
+ENV DB_USER=${DB_USER}
+ENV DB_PASS=${DB_PASS}
+ENV DB_HOST=${DB_HOST}
+ENV DB_NAME=${DB_NAME}
+
+
+EXPOSE 7860
+
+CMD ["gunicorn", "-w", "2", "app:app", "--bind", "0.0.0.0:7860"]

api/api_blueprint.py

@@ -0,0 +1,784 @@
+from flask import Blueprint, send_file, make_response, request, jsonify, Response
+from services.nifti_processor import NiftiProcessor
+from services.session_manager import SessionManager, generate_uuid
+from services.auto_segmentor import run_auto_segmentation
+from models.application_session import ApplicationSession
+from models.combined_labels import CombinedLabels
+from models.base import db
+from constants import Constants
+import zipfile
+import pandas as pd
+
+from pathlib import Path
+from io import BytesIO
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from reportlab.lib.units import cm
+
+from sqlalchemy.orm import aliased
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+import nibabel as nib
+import uuid
+
+from datetime import datetime, timedelta
+from .utils import *
+import requests  # ⭐ 只在這裡 import 一次 requests
+
+# 建立 blueprint
+api_blueprint = Blueprint("api", __name__)
+last_session_check = datetime.now()
+
+progress_tracker = {}  # {session_id: (start_time, expected_total_seconds)}
+
+
+@api_blueprint.route("/proxy-image")
+def proxy_image():
+    """
+    Proxy image requests so the browser only talks to our own origin.
+    Front-end will call: /api/proxy-image?url=<encoded_hf_url>
+    """
+    raw_url = request.args.get("url")
+    if not raw_url:
+        return Response("Missing url parameter", status=400)
+
+    # 可選安全限制：只允許 HuggingFace 來源
+    if not raw_url.startswith("https://huggingface.co/"):
+        return Response("Forbidden", status=403)
+
+    try:
+        r = requests.get(raw_url, timeout=10)
+    except Exception as e:
+        return Response(f"Upstream error: {e}", status=502)
+
+    if not r.ok:
+        return Response(f"Upstream status {r.status_code}", status=r.status_code)
+
+    content_type = r.headers.get("Content-Type", "image/jpeg")
+
+    resp = Response(r.content, status=200, mimetype=content_type)
+
+    # ⭐ 避免 COEP 再擋圖片
+    resp.headers["Cross-Origin-Resource-Policy"] = "cross-origin"
+
+    return resp
+
+
+
+from flask import request, jsonify
+import numpy as np
+import nibabel as nib
+from scipy.ndimage import distance_transform_edt, label
+from collections import defaultdict
+from constants import Constants
+import os
+from openpyxl import load_workbook
+
+
+SESSIONS_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "tmp")
+PDF_DIR = f"{Constants.PANTS_PATH}/data/pdf"
+os.makedirs(SESSIONS_DIR, exist_ok=True)
+os.makedirs(PDF_DIR, exist_ok=True)
+
+def _arg(name: str, default=None):
+    return request.args.get(name, default)
+
+@api_blueprint.route('/get_preview/<clabel_ids>', methods=['GET'])
+def get_preview(clabel_ids):
+    # get age and thumbnail
+    clabel_ids = clabel_ids.split(",")
+    wb = load_workbook(os.path.join(Constants.PANTS_PATH, "data", "metadata.xlsx"))
+    sheet = wb["PanTS_metadata"]
+    res = {
+        x: {
+            "sex": "",
+            "age": ""
+        } for x in clabel_ids
+    }
+    for clabel_id in clabel_ids:
+        for row in sheet.iter_rows(values_only=True):
+            if row[0] == get_panTS_id(clabel_id):
+                res[clabel_id]["sex"] = row[4]
+                res[clabel_id]["age"] = row[5]
+                break
+
+    return jsonify(res)
+
+# if not preloaded
+@api_blueprint.route('/get_image_preview/<clabel_id>', methods=['GET'])
+def get_image_preview(clabel_id):
+    # get age and thumbnail
+    # subfolder = "LabelTr" if int(clabel_id) < 9000 else "LabelTe"
+    subfolder = "ProfileTr" if int(clabel_id) < 9000 else "ProfileTe"
+    # path = os.path.join(Constants.PANTS_PATH, "data", subfolder, get_panTS_id(clabel_id), Constants.COMBINED_LABELS_FILENAME)
+    # if not os.path.exists(path):
+    #     print(f"File not found: {path}. Making file")
+    #     npz_processor = NpzProcessor()
+    #     npz_processor.combine_labels(int(clabel_id))
+
+    path = os.path.join(Constants.PANTS_PATH, subfolder, get_panTS_id(clabel_id), "profile.jpg")
+    # arr = np.load(path)["data"]
+    # bytes = volume_to_png(arr)
+    return send_file(
+        path,
+        mimetype="image/jpg",   
+        as_attachment=False,
+        download_name=f"{clabel_id}_slice.jpg"
+    )
+
+
+    
+
+@api_blueprint.route('/get-label-colormap/<clabel_id>', methods=['GET'])
+def get_label_colormap(clabel_id):
+    subfolder = "LabelTr" if int(clabel_id) < 9000 else "LabelTe"
+    
+    clabel_path = os.path.join(Constants.PANTS_PATH, "data", subfolder, get_panTS_id(int(clabel_id)),  'combined_labels.nii.gz')
+
+    if not os.path.exists(clabel_path):
+        print(f"File not found: {clabel_path}. Making file")
+        combine_label_npz(int(clabel_id))
+        npzProcessor = NpzProcessor()
+        npzProcessor.npz_to_nifti(int(clabel_id))
+    try:
+        clabel_array = nib.load(clabel_path)
+        clabel_array = clabel_array.get_fdata()
+        print("[DEBUG] Nifti loaded, shape =", clabel_array.shape)
+
+        filled_array = fill_voids_with_nearest_label(clabel_array)
+        print("[DEBUG] fill_voids_with_nearest_label done")
+
+        adjacency = build_adjacency_graph(filled_array)
+        print("[DEBUG] build_adjacency_graph done")
+
+        unique_labels = sorted(adjacency.keys())
+        color_map, color_usage_count = assign_colors_with_high_contrast(unique_labels, adjacency)
+        print("[DEBUG] Color map generated:", color_map, color_usage_count)
+
+        return jsonify(color_map)
+
+    except Exception as e:
+        print("[❌ EXCEPTION]", str(e))
+        return jsonify({"error": str(e)}), 500
+
+
+
+
+# @api_blueprint.before_request
+# def before_request():
+#     global last_session_check
+#     current_time = datetime.now()
+#     if current_time >= last_session_check + timedelta(minutes=Constants.SCHEDULED_CHECK_INTERVAL):
+#         session_manager = SessionManager.instance()
+#         expired = session_manager.get_expired()
+#         for app_session in expired:
+#             session_manager.terminate_session(app_session.session_id)
+        
+#         last_session_check = current_time
+
+@api_blueprint.route('/', methods=['GET'])
+def home():
+    return "api"
+
+
+@api_blueprint.route('/upload', methods=['POST'])
+def upload():
+    try:
+        session_id = request.form.get('SESSION_ID')
+        if not session_id:
+            return jsonify({"error": "No session ID provided"}), 400
+        
+        base_path = os.path.join(Constants.SESSIONS_DIR_NAME, session_id)
+        os.makedirs(base_path, exist_ok=True)
+
+        nifti_multi_dict = request.files
+        filenames = list(nifti_multi_dict)
+        main_nifti = nifti_multi_dict.get(Constants.MAIN_NIFTI_FORM_NAME)
+
+        if main_nifti:
+            main_nifti_path = os.path.join(base_path, Constants.MAIN_NIFTI_FILENAME)
+            main_nifti.save(main_nifti_path)
+            filenames.remove(Constants.MAIN_NIFTI_FORM_NAME)
+        else:
+            return jsonify({"error": "Main NIFTI file missing"}), 400
+
+        nifti_processor = NiftiProcessor.from_clabel_path(os.path.join(base_path, Constants.COMBINED_LABELS_FILENAME))
+
+        combined_labels, organ_intensities = nifti_processor.combine_labels(filenames, nifti_multi_dict, save=True)
+
+        resp = {
+            'status': "200",
+            'session_id': session_id,
+            'organ_intensities': organ_intensities
+        }
+        return jsonify(resp)
+    except Exception as e:
+        print(f"❌ [Upload Error] {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+@api_blueprint.route('/mask-data', methods=['POST'])
+def get_mask_data():
+    session_key = request.form.get('sessionKey')
+    if not session_key:
+        return jsonify({"error": "Missing sessionKey"}), 400
+
+    result = get_mask_data_internal(session_key)
+    return jsonify(result)
+
+  
+@api_blueprint.route('/get-main-nifti/<clabel_id>', methods=['GET'])
+def get_main_nifti(clabel_id):
+    subfolder = "ImageTr" if int(clabel_id) < 9000 else "ImageTe" 
+    main_nifti_path = f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(clabel_id)}/{Constants.MAIN_NIFTI_FILENAME}"
+
+    if os.path.exists(main_nifti_path):
+        response = make_response(send_file(main_nifti_path, mimetype='application/gzip'))
+
+        response.headers['Cross-Origin-Opener-Policy'] = 'same-origin'
+        response.headers['Cross-Origin-Embedder-Policy'] = 'require-corp'
+        response.headers['Content-Encoding'] = 'gzip'
+
+    else:
+        print(f"Could not find filepath: {main_nifti_path}. ")
+        return jsonify({"error": "Could not find filepath"}), 404
+        
+        # npz_path = main_nifti_path.replace(".nii.gz", ".npz")
+        # if not os.path.exists(npz_path):   
+        #     return jsonify({"error": "Could not find npz filepath"}), 404
+        # npz_processor = NpzProcessor()
+        # npz_processor.npz_to_nifti(int(clabel_id), combined_label=False, save=True)  
+        
+        # response = make_response(send_file(main_nifti_path, mimetype='application/gzip'))
+
+        # response.headers['Cross-Origin-Opener-Policy'] = 'same-origin'
+        # response.headers['Cross-Origin-Embedder-Policy'] = 'require-corp'
+        # response.headers['Content-Encoding'] = 'gzip'
+
+    return response
+
+
+
+
+@api_blueprint.route('/get-report/<id>', methods=['GET'])
+def get_report(id):
+    temp_pdf_path = f"{PDF_DIR}/temp.pdf"
+    output_pdf_path = f"{PDF_DIR}/final.pdf"
+    try:
+        try:
+            organ_metrics = get_mask_data_internal(id)
+            organ_metrics = organ_metrics.get("organ_metrics", [])
+        except Exception as e:
+            return jsonify({"error": f"Error loading organ metrics: {str(e)}"}), 500
+
+        subfolder = "ImageTr" if int(id) < 9000 else "ImageTe"
+        label_subfolder = "LabelTr" if int(id) < 9000 else "LabelTe"
+
+        base_path = f"{SESSIONS_DIR}/{id}"
+        ct_path = f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(id)}/{Constants.MAIN_NIFTI_FILENAME}"
+        masks = f"{Constants.PANTS_PATH}/data/{label_subfolder}/{get_panTS_id(id)}/{Constants.COMBINED_LABELS_NIFTI_FILENAME}"
+        
+        npz_processor = NpzProcessor()
+
+        # if (not os.path.exists(ct_path)):
+        #     npz_processor.npz_to_nifti(int(id), combined_label=False, save=True)
+
+        if (not os.path.exists(masks)): 
+            npz_processor.combine_labels(int(id), keywords={"pancrea": "pancreas"}, save=True)
+            npz_processor.npz_to_nifti(int(id), combined_label=True, save=True)
+            
+        template_pdf = os.getenv("TEMPLATE_PATH", "report_template_3.pdf")
+
+        extracted_data = None
+        column_headers = None
+        try:
+            csv_path = f"{base_path}/info.csv"
+            df = pd.read_csv(csv_path)
+            extracted_data = df.iloc[0] if len(df) > 0 else None
+            column_headers = df.columns.tolist()
+        except Exception:
+            pass
+
+        generate_pdf_with_template(
+            output_pdf=output_pdf_path,
+            folder_name=id,
+            ct_path=ct_path,
+            mask_path=masks,
+            template_pdf=template_pdf,
+            temp_pdf_path=temp_pdf_path,
+            id=id,
+            extracted_data=extracted_data,
+            column_headers=column_headers
+        )
+
+        return send_file(
+            output_pdf_path,
+            mimetype="application/pdf",
+            as_attachment=True,
+            download_name=f"report_{id}.pdf"
+        )
+
+    except Exception as e:
+        return jsonify({"error": f"Unhandled error: {str(e)}"}), 500
+
+    finally:
+        if os.path.exists(temp_pdf_path):
+            os.remove(temp_pdf_path)
+
+
+@api_blueprint.route('/get-segmentations/<combined_labels_id>', methods=['GET'])
+async def get_segmentations(combined_labels_id):
+    subfolder = "LabelTr" if int(combined_labels_id) < 9000 else "LabelTe" 
+    nifti_path = f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(combined_labels_id)}/{Constants.COMBINED_LABELS_NIFTI_FILENAME}"
+    labels = list(Constants.PREDEFINED_LABELS.values()) 
+    if not os.path.exists(nifti_path):
+        await store_files(combined_labels_id)
+        niftiProcessor = NpzProcessor()
+        niftiProcessor.nifti_combine_labels(int(combined_labels_id))
+        # print(f"Could not find filepath: {nifti_path}. Creating a new one")
+        # npz_path = nifti_path.replace(".nii.gz", ".npz")
+        # npz_processor = NpzProcessor()
+        # if not os.path.exists(npz_path):   
+        #     print(f"Could not find npz filepath: {npz_path}. Creating a new one")
+
+        #     # ! pancrea instead of pancreas to include pancreatic labels
+        #     npz_processor.combine_labels(combined_labels_id, keywords={"pancrea": "pancreas"}, save=True)
+            
+        # npz_processor.npz_to_nifti(int(combined_labels_id), combined_label=True, save=True)   
+
+    img = nib.load(nifti_path)
+    data = img.get_fdata()
+    if img.get_data_dtype() != np.uint8:
+        print("⚠️ Detected float label map, converting to uint8 for Niivue compatibility...")
+
+    try:
+        img = nib.load(nifti_path)
+        data = img.get_fdata()
+
+        if img.get_data_dtype() != np.uint8:
+            
+            data_uint8 = data.astype(np.uint8)
+            new_img = nib.Nifti1Image(data_uint8, img.affine, header=img.header)
+            new_img.set_data_dtype(np.uint8)
+
+            converted_path = nifti_path#.replace(".nii.gz", "_uint8.nii.gz")
+
+            if not os.path.exists(converted_path):
+                nib.save(new_img, converted_path)
+        else:
+            converted_path = nifti_path
+
+        response = make_response(send_file(converted_path, mimetype='application/gzip'))
+        response.headers['Cross-Origin-Opener-Policy'] = 'same-origin'
+        response.headers['Cross-Origin-Embedder-Policy'] = 'require-corp'
+        response.headers['Content-Encoding'] = 'gzip'
+
+        return response
+
+    except Exception as e:
+        print(f"❌ [get-segmentations ERROR] {e}")
+        return jsonify({"error": str(e)}), 500
+
+
+@api_blueprint.route('/download/<id>', methods=['GET'])
+def download_segmentation_zip(id):
+    try:
+        subfolder = "LabelTr" if int(id) < 9000 else "LabelTe"
+        outputs_ct_folder = Path(f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(id)}/segmentations")
+        
+        if not os.path.exists(outputs_ct_folder):
+            return jsonify({"error": "Outputs/ct folder not found"}), 404
+        
+        files = list(outputs_ct_folder.glob("*"))
+
+        zip_buffer = BytesIO()
+        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+            for file_path in files:
+                zip_file.write(file_path, arcname=file_path.name) 
+
+        zip_buffer.seek(0)  # rewind
+
+        return send_file(
+            zip_buffer,
+            mimetype="application/zip",
+            as_attachment=True,
+            download_name=f"case_{id}_segmentations.zip"
+        )
+
+
+
+    except Exception as e:
+        print(f"❌ [Download Error] {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+import threading
+import time
+
+@api_blueprint.route('/auto_segment/<session_id>', methods=['POST'])
+def auto_segment(session_id):
+
+    if 'MAIN_NIFTI' not in request.files:
+        return jsonify({"error": "No CT file provided"}), 400
+
+    ct_file = request.files['MAIN_NIFTI']
+    model_name = request.form.get("MODEL_NAME", None)
+
+    # Check if model name is valid
+    if model_name is None:
+        return {"error": "MODEL_NAME is required."}, 400
+    # Step 1: Create a unique session directory to store CT and mask
+    session_path = os.path.join(SESSIONS_DIR, session_id)
+    os.makedirs(session_path, exist_ok=True)
+
+    # Step 2: Save CT file under this session
+    input_path = os.path.join(session_path, ct_file.filename)
+    ct_file.save(input_path)
+
+    def do_segmentation_and_zip():
+        time.sleep(10)
+        output_mask_dir = run_auto_segmentation(input_path, session_dir=session_path, model=model_name)
+
+        if output_mask_dir is None or not os.path.exists(output_mask_dir):
+            print(f"❌ Auto segmentation failed for session {session_id}")
+            return ##the logic still needs to be improved in the future. when output_mask_dir is none here, no error output at user's end
+
+        zip_path = os.path.join(session_path, "auto_masks.zip")
+        with zipfile.ZipFile(zip_path, 'w') as zipf:
+            for filename in os.listdir(output_mask_dir):
+                if filename.endswith(".nii.gz"):
+                    abs_path = os.path.join(output_mask_dir, filename)
+                    zipf.write(abs_path, arcname=filename)
+
+        start_time, expected_time, _ = progress_tracker[session_id]
+        progress_tracker[session_id] = (start_time, expected_time, True)
+        progress_tracker.pop(session_id, None)
+
+        
+        
+        print(f"✅ Finished segmentation and zipping for session {session_id}")
+
+    #threading.Thread(target=do_segmentation_and_zip).start()
+    threading.Thread(target=do_segmentation_and_zip, ).start()
+    print("[Server] auto_segment request is returning now")
+    return jsonify({"message": "Segmentation started"}), 200
+
+
+
+@api_blueprint.route('/get_result/<session_id>', methods=['GET'])
+def get_result(session_id):
+    session_path = os.path.join(SESSIONS_DIR, session_id)
+    zip_path = os.path.join(session_path, "auto_masks.zip")
+
+    wait_for_file(zip_path, timeout=30)
+
+    response = send_file(
+        zip_path,
+        as_attachment=True,
+        download_name="auto_masks.zip"
+    )
+    response.headers["X-Session-Id"] = session_id
+    return response
+
+#
+#@api_blueprint.route('/progress_end/<session_id>', methods=['GET'])
+#def progress_end(session_id):
+#    progress_tracker.pop(session_id, None)
+#    return jsonify({"message": "Progress End"}), 200
+
+@api_blueprint.route('/ping', methods=['GET'])
+def ping():
+    return jsonify({"message": "pong"}), 200
+
+@api_blueprint.route("/search", methods=["GET"])
+def api_search():
+    # return jsonify({"message": "pong"}), 200
+    df = apply_filters(DF).copy()
+    sort_by  = (_arg("sort_by", "top") or "top").strip().lower()
+    sort_by  = (_arg("sort_by", "top") or "top").strip().lower()
+    df = ensure_sort_cols(df)
+
+    # ---- 排序參數 ----
+    sort_by  = (_arg("sort_by", "top") or "top").strip().lower()
+    sort_dir = (_arg("sort_dir", "asc") or "asc").strip().lower()
+
+    if sort_by in ("top", "quality"):
+        by  = ["__complete", "__spacing_sum", "__shape_sum", "__case_sortkey"]
+        asc = [False, True, False, True]
+    elif sort_by in ("id", "id_asc"):
+        by, asc = ["__case_sortkey"], [True]
+    elif sort_by == "id_desc":
+        by, asc = ["__case_sortkey"], [False]
+    elif sort_by in ("shape_desc", "shape"):
+        by, asc = ["__shape_sum", "__case_sortkey"], [False, True]
+    elif sort_by in ("spacing_asc", "spacing"):
+        by, asc = ["__spacing_sum", "__case_sortkey"], [True, True]
+    elif sort_by == "age_asc":
+        by, asc = ["__age", "__case_sortkey"], [True, True]
+    elif sort_by == "age_desc":
+        by, asc = ["__age", "__case_sortkey"], [False, True]
+    else:
+        key_map = {"id": "__case_sortkey", "spacing": "__spacing_sum", "shape": "__shape_sum"}
+        k = key_map.get(sort_by, "__case_sortkey")
+        by, asc = [k, "__case_sortkey"], [(sort_dir != "desc"), True]
+
+    # ---- 排序 ----
+    df = df.sort_values(by=by, ascending=asc, na_position="last", kind="mergesort")
+
+    # ---- 分頁：注意 total 先算完篩選後的完整筆數 ----
+    total    = int(len(df))
+    page     = max(to_int(_arg("page", "1")) or 1, 1)
+    per_page = to_int(_arg("per_page", "24")) or 24
+    per_page = max(1, min(per_page, 1_000_000))
+
+    pages = max(1, int(math.ceil(total / per_page)))
+    page  = max(1, min(page, pages))
+    start, end = (page - 1) * per_page, (page - 1) * per_page + per_page
+
+    # ---- 轉成前端想要的 items ----
+    items = [row_to_item(r) for _, r in df.iloc[start:end].iterrows()]
+    items = clean_json_list(items)
+
+    return jsonify({
+        "items": items,         # ← 前端只讀這個渲染卡片
+        "total": total,         # ← 正確的最終數量
+        "page": page,
+        "per_page": per_page,
+        "query": request.query_string.decode(errors="ignore") or ""
+    })
+
+
+def _facet_counts_with_unknown(df: pd.DataFrame, col_key: str, top_k: int = 6) -> Dict[str, Any]:
+    """Compute facet rows + unknown count, with robust handling for NaN/strings."""
+    rows: List[Dict[str, Any]] = []
+    unknown: int = 0
+
+    key_to_col = {
+        "ct_phase": ("__ct", str),
+        "manufacturer": ("__mfr", str),
+        "year": ("__year_int", int),
+        "sex": ("__sex", str),
+        "tumor": ("__tumor01", int),
+        "model": ("model", str),
+        "study_type": ("study_type", str),
+        "site_nat": ("site_nationality", str),
+        "site_nationality": ("site_nationality", str),
+    }
+    if col_key not in key_to_col:
+        return {"rows": [], "unknown": 0}
+
+    col_name, _typ = key_to_col[col_key]
+    if col_name not in df.columns:
+        return {"rows": [], "unknown": 0}
+
+    ser = df[col_name]
+
+    # ---- Year：數值化、NaN 視為 unknown ----
+    if col_key == "year":
+        s_num = pd.to_numeric(ser, errors="coerce")
+        unknown = int(s_num.isna().sum())
+        vc = s_num.dropna().astype(int).value_counts()
+        rows = [{"value": int(v), "count": int(c)} for v, c in vc.items()]
+        rows.sort(key=lambda x: (-x["count"], x["value"]))
+        if top_k and top_k > 0:
+            rows = rows[:top_k]
+        return {"rows": rows, "unknown": unknown}
+
+    # ---- 其他欄位：把空字串/unknown 類型歸入 unknown ----
+    s_str = ser.astype(str).str.strip()
+    s_lc = s_str.str.lower()
+    unknown_mask = ser.isna() | (s_str == "") | (s_lc.isin({"unknown", "nan", "none", "n/a", "na"}))
+    unknown = int(unknown_mask.sum())
+
+    vals = ser[~unknown_mask]
+    vc = vals.value_counts(dropna=False)
+
+    tmp_rows: List[Dict[str, Any]] = []
+    for v, c in vc.items():
+        if col_key == "tumor":
+            # tumor 僅接受 0/1
+            try:
+                iv = int(v)
+            except Exception:
+                continue
+            if iv not in (0, 1):
+                continue
+            tmp_rows.append({"value": iv, "count": int(c)})
+        else:
+            tmp_rows.append({"value": v, "count": int(c)})
+
+    # 排序：count desc，再 value 升（字串比較避免型別問題）
+    tmp_rows.sort(key=lambda x: (-x["count"], str(x["value"])))
+    if top_k and top_k > 0:
+        tmp_rows = tmp_rows[:top_k]
+
+    rows = tmp_rows
+    return {"rows": rows, "unknown": unknown}
+
+
+def _prune_zero_rows(rows: List[Dict[str, Any]], keep_zero: bool) -> List[Dict[str, Any]]:
+    """依需求濾掉 count<=0；當 keep_zero=True（對應 guarantee=1）則不濾。"""
+    if keep_zero:
+        return rows
+    out: List[Dict[str, Any]] = []
+    for r in rows or []:
+        try:
+            c = int(r.get("count") or 0)
+        except Exception:
+            c = 0
+        if c > 0:
+            out.append(r)
+    return out
+
+
+@api_blueprint.route("/facets", methods=["GET"])
+def api_facets():
+    try:
+        fields_raw = (_arg("fields","ct_phase,manufacturer") or "").strip()
+        fields = [f.strip().lower() for f in fields_raw.split(",") if f.strip()]
+
+        valid  = {
+            "ct_phase","manufacturer","year","sex","tumor",
+            "model","study_type","site_nat","site_nationality"
+        }
+        fields = [f for f in fields if f in valid] or ["ct_phase","manufacturer"]
+        top_k  = to_int(_arg("top_k","6")) or 6
+        guarantee = (_arg("guarantee","0") or "0").strip().lower() in ("1","true","yes","y")
+
+        # 先應用目前的過濾條件
+        df_now = apply_filters(DF)
+        base_for_ranges = df_now if len(df_now) else DF
+
+        facets: Dict[str, List[Dict[str, Any]]] = {}
+        unknown_counts: Dict[str, int] = {}
+
+        # 為每個 facet 準備自我排除的條件（避免自我影響）
+        exclude_map = {
+            "ct_phase": {"ct_phase"},
+            "manufacturer": {"manufacturer","mfr_is_null","manufacturer_is_null"},
+            "year": {"year_from","year_to"},
+            "sex": {"sex"},
+            "tumor": {"tumor"},
+            "model": {"model"},
+            "study_type": {"study_type"},
+            "site_nat": {"site_nat","site_nationality"},
+            "site_nationality": {"site_nat","site_nationality"},
+        }
+
+        for f in fields:
+            ex = exclude_map.get(f, set())
+            # 若 guarantee=1 且目前篩完為空，改用全量 DF 以「保證列出所有可能值」
+            src = (DF if (guarantee and len(df_now) == 0) else df_now)
+            df_facet = apply_filters(src, exclude=ex)
+            res = _facet_counts_with_unknown(df_facet, f, top_k=top_k)
+
+            # guarantee=0 時砍掉 count<=0 的項目
+            rows = _prune_zero_rows(res.get("rows") or [], keep_zero=guarantee)
+            facets[f] = rows
+            unknown_counts[f] = int(res.get("unknown") or 0)
+
+        # 年齡/年份範圍（原樣保留）
+        def _minmax(series: pd.Series):
+            s = series.dropna()
+            if not len(s): return (None, None)
+            return (float(s.min()), float(s.max()))
+
+        age_min = age_max = None
+        year_min = year_max = None
+        if "__age" in base_for_ranges:
+            age_min, age_max = _minmax(base_for_ranges["__age"])
+        if "__year_int" in base_for_ranges:
+            yr = base_for_ranges["__year_int"].dropna().astype(int)
+            if len(yr):
+                year_min, year_max = int(yr.min()), int(yr.max())
+
+        return jsonify({
+            "facets": facets,
+            "unknown_counts": unknown_counts,
+            "age_range": {"min": age_min, "max": age_max},
+            "year_range": {"min": year_min, "max": year_max},
+            "total": int(len(df_now)),
+        })
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400
+    
+@api_blueprint.route("/random", methods=['GET'])
+def api_random_topk_rotate_norand():
+    """
+    推薦：完整資料優先 → 取 Top-K(預設100) → 環狀位移 → 可排除最近看過
+    排序：__spacing_sum ↑, __shape_sum ↓, __case_sortkey ↑
+    """
+    try:
+        scope = (request.args.get("scope", "filtered") or "filtered").strip().lower()
+        base_df = apply_filters(DF)
+        if len(base_df) == 0 and scope == "all":
+            base_df = DF.copy()
+
+        base_df = ensure_sort_cols(base_df)
+
+        # 只取完整資料；若沒有完整的就退回全部
+        df_full = base_df[base_df["__complete"]] if "__complete" in base_df.columns else base_df
+        if len(df_full) == 0:
+            df_full = base_df
+        df = df_full.sort_values(
+            by=["__spacing_sum","__shape_sum","__case_sortkey"],
+            ascending=[True, False, True],
+            na_position="last",
+            kind="mergesort",
+        )
+
+        if len(df) == 0:
+            return jsonify({"items": [], "total": 0, "meta": {"k": 0, "used_recent": 0}}), 200
+
+        # n, k
+        try: n = int(request.args.get("n") or 3)
+        except Exception: n = 3
+        n = max(1, min(n, len(df)))
+
+        try: K = int(request.args.get("k") or 100)
+        except Exception: K = 100
+        K = max(n, min(K, len(df)))
+
+        # recent 排除
+        recent_raw = (request.args.get("recent") or "").strip()
+        used_recent = 0
+        if recent_raw:
+            recent_ids = {s.strip() for s in recent_raw.split(",") if s.strip()}
+            key = df["__case_str"].astype(str) if "__case_str" in df.columns else None
+            if key is not None:
+                mask = ~key.isin(recent_ids)
+                used_recent = int((~mask).sum())
+                df2 = df[mask]
+                if len(df2): df = df2
+
+        topk = df.iloc[:K]
+        if len(topk) == 0:
+            return jsonify({"items": [], "total": 0, "meta": {"k": 0, "used_recent": used_recent}}), 200
+
+        off_arg = request.args.get("offset")
+        if off_arg is not None:
+            try: offset = int(off_arg) % len(topk)
+            except Exception: offset = 0
+        else:
+            now = datetime.utcnow()
+            offset = ((now.minute * 60) + now.second) % len(topk)
+
+        idx = list(range(len(topk))) + list(range(len(topk)))
+        pick = idx[offset:offset + min(n, len(topk))]
+        sub = topk.iloc[pick]
+
+        items = [row_to_item(r) for _, r in sub.iterrows()]
+        resp = jsonify({
+            "items": clean_json_list(items),
+            "total": int(len(df)),
+            "meta": {"k": int(len(topk)), "used_recent": used_recent, "offset": int(offset)}
+        })
+        r = make_response(resp)
+        r.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0"
+        r.headers["Pragma"] = "no-cache"
+        r.headers["Expires"] = "0"
+        return r
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 400

api/utils.py

@@ -0,0 +1,1328 @@
+from flask import Blueprint, send_file, make_response, request, jsonify
+from services.nifti_processor import NiftiProcessor
+from services.session_manager import SessionManager, generate_uuid
+from services.auto_segmentor import run_auto_segmentation
+from models.application_session import ApplicationSession
+from models.combined_labels import CombinedLabels
+from models.base import db
+from constants import Constants
+
+from io import BytesIO
+from datetime import datetime
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+
+from typing import Any, Dict, Optional, Set, List, Tuple
+
+import os
+import uuid
+import re
+import time
+import math
+import numpy as np
+import nibabel as nib
+from scipy.ndimage import distance_transform_edt
+from collections import defaultdict
+from services.npz_processor import NpzProcessor
+from PIL import Image
+from openpyxl import load_workbook
+import requests
+import pandas as pd
+# Track last session validation time
+last_session_check = datetime.now()
+
+# Progress tracking structure: {session_id: (start_time, expected_total_seconds)}
+progress_tracker = {}
+
+def id_is_training(index):
+    return index < 9000
+
+
+
+def combine_label_npz(index: int):
+    npz_processor = NpzProcessor()
+    npz_processor.combine_labels(index)
+    return
+def get_panTS_id(index):
+    cur_case_id = str(index)
+    iter = max(0, 8 - len(str(index)))
+    for _ in range(iter):
+        cur_case_id = "0" + cur_case_id
+    cur_case_id = "PanTS_" + cur_case_id    
+    return cur_case_id
+
+def clean_nan(obj):
+    """Recursively replace NaN with None for JSON serialization."""
+    if isinstance(obj, dict):
+        return {k: clean_nan(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [clean_nan(elem) for elem in obj]
+    elif isinstance(obj, float) and math.isnan(obj):
+        return None
+    else:
+        return obj
+
+def format_value(value):
+    """Format values for display, replacing 999999 or None with 'N/A'."""
+    return "N/A" if value in [999999, None] else str(value)
+
+def organname_to_name(filename):
+    """Convert a NIfTI file name to a human-readable organ name."""
+    name = filename.replace(".nii.gz", "").replace("_", " ")
+    return name.title()
+
+def get_mask_data_internal(id, fallback=False):
+    """Retrieve or compute organ metadata from NIfTI and mask paths for a session."""
+    try:
+        subfolder = "ImageTr" if int(id) < 9000 else "ImageTe"
+        label_subfolder = "LabelTr" if int(id) < 9000 else "LabelTe"
+        main_nifti_path = f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(id)}/{Constants.MAIN_NIFTI_FILENAME}"
+        combined_labels_path = f"{Constants.PANTS_PATH}/data/{label_subfolder}/{get_panTS_id(id)}/{Constants.COMBINED_LABELS_NIFTI_FILENAME}"
+        print(f"[INFO] Processing NIFTI for id {id}")
+        organ_intensities = None
+        
+        organ_intensities_path = f"{Constants.PANTS_PATH}/data/{label_subfolder}/{get_panTS_id(id)}/{Constants.ORGAN_INTENSITIES_FILENAME}"
+        if not os.path.exists(organ_intensities_path) or not os.path.exists(combined_labels_path):
+            npz_processor = NpzProcessor()
+            labels, organ_intensities = npz_processor.combine_labels(int(id), keywords={"pancrea": "pancreas"}, save=True)
+        else: 
+            with open(organ_intensities_path, "r") as f:
+                organ_intensities = json.load(f)
+        
+        nifti_processor = NiftiProcessor(main_nifti_path, combined_labels_path)
+        nifti_processor.set_organ_intensities(organ_intensities)
+        organ_metadata = nifti_processor.calculate_metrics()
+        organ_metadata = clean_nan(organ_metadata)
+
+        return organ_metadata
+
+    except Exception as e:
+        print(f"[ERROR] get_mask_data_internal: {e}")
+        return {"error": str(e)}
+
+def generate_distinct_colors(n):
+    """Generate n visually distinct RGB colors."""
+    import colorsys
+    HSV_tuples = [(x / n, 0.7, 0.9) for x in range(n)]
+    RGB_tuples = [tuple(int(c * 255) for c in colorsys.hsv_to_rgb(*hsv)) for hsv in HSV_tuples]
+    return RGB_tuples
+
+def fill_voids_with_nearest_label(label_array):
+    """Fill all 0-valued voxels with the nearest non-zero label."""
+    mask = label_array == 0
+    if not np.any(mask):
+        return label_array
+
+    nonzero_coords = np.array(np.nonzero(label_array)).T
+    distances, indices = distance_transform_edt(mask, return_indices=True)
+    filled_array = label_array.copy()
+    filled_array[mask] = label_array[tuple(indices[:, mask])]
+    return filled_array
+
+def build_adjacency_graph(label_array):
+    """Build adjacency graph of label connectivity in 6 directions."""
+    adjacency = defaultdict(set)
+    offsets = [(-1, 0, 0), (1, 0, 0),
+               (0, -1, 0), (0, 1, 0),
+               (0, 0, -1), (0, 0, 1)]
+
+    for dx, dy, dz in offsets:
+        shifted = np.roll(label_array, shift=(dx, dy, dz), axis=(0, 1, 2))
+        mask = (label_array != shifted) & (label_array != 0) & (shifted != 0)
+        l1 = label_array[mask]
+        l2 = shifted[mask]
+        for a, b in zip(l1, l2):
+            if a != b:
+                adjacency[a].add(b)
+                adjacency[b].add(a)
+    return adjacency
+
+def assign_colors_with_high_contrast(label_ids, adjacency_graph, min_initial_colors=20, max_total_colors=50):
+    """
+    Assign colors to labels such that adjacent labels have different colors,
+    maximizing contrast and balance.
+    """
+    from itertools import combinations
+    import colorsys
+
+    def generate_distinct_colors(n):
+        HSV_tuples = [(x / n, 0.7, 0.9) for x in range(n)]
+        RGB_tuples = [tuple(int(c * 255) for c in colorsys.hsv_to_rgb(*hsv)) for hsv in HSV_tuples]
+        return RGB_tuples
+
+    def can_use_color(label, color_idx, assignments, adjacency_graph):
+        for neighbor in adjacency_graph[label]:
+            if assignments.get(neighbor) == color_idx:
+                return False
+        return True
+
+    label_ids = sorted(label_ids)
+    assignments = {}
+    num_colors = min_initial_colors
+    color_usage_count = {i: 0 for i in range(num_colors)}
+
+    while True:
+        colors = generate_distinct_colors(num_colors)
+        assignments.clear()
+        color_usage_count = {i: 0 for i in range(num_colors)}
+        success = True
+
+        for label in label_ids:
+            color_order = sorted(range(num_colors), key=lambda c: (color_usage_count[c], c))
+            for color_idx in color_order:
+                if can_use_color(label, color_idx, assignments, adjacency_graph):
+                    assignments[label] = color_idx
+                    color_usage_count[color_idx] += 1
+                    break
+            else:
+                success = False
+                break
+
+        if success:
+            break
+        elif num_colors >= max_total_colors:
+            print(f"⚠️ Warning: reached max color count {max_total_colors}, some neighbors may share color")
+            break
+        else:
+            num_colors += 1
+
+    final_colors = generate_distinct_colors(num_colors)
+    print(f"✅ Final color count used: {len(set(assignments.values()))}")
+
+    color_map = {
+        str(round(label)): {
+            "R": final_colors[color_idx][0],
+            "G": final_colors[color_idx][1],
+            "B": final_colors[color_idx][2],
+            "A": 128
+        }
+        for label, color_idx in assignments.items()
+    }
+
+    return color_map, color_usage_count
+
+def wait_for_file(filepath, timeout=30, check_interval=0.5):
+    """Wait until a file exists, or timeout is reached."""
+    start_time = time.time()
+    while not os.path.exists(filepath):
+        if time.time() - start_time > timeout:
+            raise TimeoutError(f"Timeout: File {filepath} not found after {timeout} seconds.")
+        time.sleep(check_interval)
+
+def volume_to_png(volume, axis=2, index=None):
+    if index is None:
+        index = volume.shape[axis] // 2
+    
+    slice_ = np.take(volume, index, axis=axis)
+    # window_center = 40 
+    # window_width = 400 
+    # min_val = window_center - window_width / 2
+    # max_val = window_center + window_width / 2
+
+    # slice_clipped = np.clip(slice_, min_val, max_val)
+    # slice_norm = 255 * (slice_clipped - min_val) / (max_val - min_val)
+    slice_norm = 255 * (slice_ - np.min(slice_)) / (np.max(slice_) - np.min(slice_))
+    slice_norm = slice_norm.astype(np.uint8)
+    
+    slice_norm = np.rot90(slice_norm, k=1)
+    slice_norm = np.flip(slice_norm, axis=0)
+
+    pil_img = Image.fromarray(slice_norm)
+    buf = BytesIO()
+    pil_img.save(buf, format="PNG")
+    buf.seek(0)
+    return buf
+def generate_pdf_with_template(
+    output_pdf,
+    folder_name,
+    ct_path,
+    mask_path,
+    template_pdf,
+    temp_pdf_path,
+    id,
+    extracted_data=None,
+    column_headers=None,
+):
+    import os
+    import nibabel as nib
+    import numpy as np
+    import pandas as pd
+    from PyPDF2 import PdfReader, PdfWriter
+    from PyPDF2._page import PageObject
+    from reportlab.pdfgen import canvas
+    from reportlab.lib.pagesizes import letter
+
+    LABELS = {v: k for k, v in Constants.PREDEFINED_LABELS.items()}
+    NAME_TO_ORGAN = {
+        # Pancreas and its lesions
+        "pancreas": "pancreas",
+        "pancreas_body": "pancreas",
+        "pancreas_head": "pancreas",
+        "pancreas_tail": "pancreas",
+        "pancreatic_lesion": "pancreas",
+        "pancreatic_duct": "pancreas",
+
+        # All other organs: map to self
+        "aorta": "aorta",
+        "adrenal_gland_left": "adrenal_gland_left",
+        "adrenal_gland_right": "adrenal_gland_right",
+        "bladder": "bladder",
+        "common_bile_duct": "common_bile_duct",
+        "celic_artery": "celiac_artery",
+        "colon": "colon",
+        "duodenum": "duodenum",
+        "femur_right": "femur_right",
+        "femur_left": "femur_left",
+        "gall_bladder": "gall_bladder",
+        "postcava": "postcava",
+        "kidney_left": "kidney_left",
+        "kidney_right": "kidney_right",
+        "liver": "liver",
+        "postcava": "postcava",
+        "prostate": "prostate",
+        "superior_mesenteric_artery": "superior_mesenteric_artery",
+        "intestine": "intestine",
+        "spleen": "spleen",
+        "stomach": "stomach",
+        "veins": "veins",
+    }
+
+    try:
+        temp_pdf = canvas.Canvas(temp_pdf_path, pagesize=letter)
+        width, height = letter
+        left_margin, top_margin = 50, 100
+        line_height, section_spacing = 12, 30
+        y_position = height - top_margin
+
+        def reset_page():
+            nonlocal y_position
+            temp_pdf.showPage()
+            y_position = height - 120
+            temp_pdf.setFont("Helvetica", 10)
+
+        def write_wrapped_text(x, y, content, bold=False, font_size=10, max_width=None):
+            temp_pdf.setFont("Helvetica-Bold" if bold else "Helvetica", font_size)
+            words = content.split()
+            current_line = ""
+            max_width = max_width or width - left_margin * 2
+            for word in words:
+                if temp_pdf.stringWidth(current_line + word + " ", "Helvetica", font_size) > max_width:
+                    temp_pdf.drawString(x, y, current_line.strip())
+                    y -= line_height
+                    current_line = f"{word} "
+                    if y < 50:
+                        reset_page()
+                        y = y_position
+                else:
+                    current_line += f"{word} "
+            if current_line:
+                temp_pdf.drawString(x, y, current_line.strip())
+                y -= line_height
+            return y
+
+        def safe_extract(index, default="N/A"):
+            if extracted_data is not None and index in extracted_data:
+                val = extracted_data[index]
+                return "N/A" if pd.isna(val) else val
+            return default
+        
+        wb = load_workbook(os.path.join(Constants.PANTS_PATH, "data", "metadata.xlsx"))
+        sheet = wb["PanTS_metadata"]
+        age = None
+        sex = "-"
+        contrast = ""
+        study_detail = ""
+        for row in sheet.iter_rows(values_only=True):
+            if row[0] == get_panTS_id(folder_name):
+                age = row[5]
+                sex = row[4]
+                contrast = row[3]
+                study_detail = row[8]
+                break
+
+        # Title
+        temp_pdf.setFont("Helvetica-Bold", 26)
+        title_text = "MEDICAL REPORT"
+        title_width = temp_pdf.stringWidth(title_text, "Helvetica-Bold", 26)
+        temp_pdf.drawString((width - title_width) / 2, height - 70, title_text)
+        y_position = height - 100
+
+        # Patient info
+        temp_pdf.setFont("Helvetica-Bold", 12)
+        temp_pdf.drawString(left_margin, y_position, "PATIENT INFORMATION")
+        y_position -= line_height
+
+        left_y = write_wrapped_text(left_margin, y_position, f"PANTS ID: {folder_name}")
+        right_y = write_wrapped_text(width / 2, y_position, f"Sex: {sex}")
+        y_position -= line_height
+        
+        write_wrapped_text(left_margin, y_position, f"Age: {age}")
+        
+        y_position = min(left_y, right_y) - section_spacing
+
+        # Imaging detail
+        temp_pdf.setFont("Helvetica-Bold", 12)
+        temp_pdf.drawString(left_margin, y_position, "IMAGING DETAIL")
+        y_position -= line_height
+
+        ct_nii = nib.load(ct_path)
+        spacing = ct_nii.header.get_zooms()
+        shape = ct_nii.shape
+
+        try:
+            scanner_info = str(ct_nii.header['descrip'].tobytes().decode('utf-8')).strip().replace('\x00', '')
+        except Exception:
+            scanner_info = "N/A"
+
+
+        y_position = write_wrapped_text(left_margin, y_position, f"Spacing: {spacing}")
+        y_position = write_wrapped_text(left_margin, y_position, f"Shape: {shape}")
+        y_position = write_wrapped_text(left_margin, y_position, f"Study type: {study_detail}")
+        y_position = write_wrapped_text(left_margin, y_position, f"Contrast: {contrast}")
+        y_position -= section_spacing
+
+        # Load image data
+        ct_array = ct_nii.get_fdata()
+        mask_array = nib.load(mask_path).get_fdata().astype(np.uint8)
+        voxel_volume = np.prod(nib.load(mask_path).header.get_zooms()) / 1000  # mm³ to cm³
+        print(np.unique(mask_array))
+
+        # AI Measurements
+        temp_pdf.setFont("Helvetica-Bold", 12)
+        temp_pdf.drawString(left_margin, y_position, "AI MEASUREMENTS")
+        y_position -= line_height
+
+        # Table configuration
+        headers = ["Organ", "Volume (cc)", "Mean HU"]
+        col_widths = [120, 100, 100]
+        row_height = 20
+
+        def draw_table_row(row_data, is_header=False):
+            nonlocal y_position
+            if y_position - row_height < 50:
+                reset_page()
+                temp_pdf.setFont("Helvetica-Bold", 12)
+                temp_pdf.drawString(left_margin, y_position, "AI MEASUREMENTS (continued)")
+                y_position -= line_height
+                draw_table_row(headers, is_header=True)
+            x = left_margin
+            temp_pdf.setFont("Helvetica-Bold" if is_header else "Helvetica", 9)
+            for i, cell in enumerate(row_data):
+                temp_pdf.drawString(x + 2, y_position - row_height + 5, str(cell))
+                temp_pdf.line(x, y_position, x, y_position - row_height)
+                x += col_widths[i]
+            temp_pdf.line(left_margin + sum(col_widths), y_position, left_margin + sum(col_widths), y_position - row_height)
+            temp_pdf.line(left_margin, y_position, left_margin + sum(col_widths), y_position)
+            y_position -= row_height
+            temp_pdf.line(left_margin, y_position, left_margin + sum(col_widths), y_position)
+
+        draw_table_row(headers, is_header=True)
+
+        lession_volume_dict={}
+        for organ, label_id in LABELS.items():
+            if organ in NAME_TO_ORGAN and NAME_TO_ORGAN[organ] != organ:
+                mask = (mask_array == label_id)
+                if not np.any(mask):
+                    print("none")
+                    continue
+                volume = np.sum(mask) * voxel_volume
+                mean_hu = np.mean(ct_array[mask])
+                if NAME_TO_ORGAN[organ] in lession_volume_dict:
+                    lession_volume_dict[NAME_TO_ORGAN[organ]]["number"] += 1
+                    lession_volume_dict[NAME_TO_ORGAN[organ]]["volume"] += volume
+                else:
+                    lession_volume_dict[NAME_TO_ORGAN[organ]] = {
+                        "number": 1,
+                        "volume": volume
+                    }
+                    
+        print(lession_volume_dict)
+        
+        for organ, label_id in LABELS.items():
+            if organ in NAME_TO_ORGAN and NAME_TO_ORGAN[organ] != organ:
+                continue
+            if label_id == 0:
+                continue
+            mask = (mask_array == label_id)
+            if not np.any(mask):
+                continue
+            volume = np.sum(mask) * voxel_volume
+            mean_hu = np.mean(ct_array[mask])
+            
+            if organ in lession_volume_dict:
+                row = [organ.replace('_', ' '), f"{volume:.2f}", f"{mean_hu:.1f}"]
+            else:
+                row = [organ.replace('_', ' '), f"{volume:.2f}", f"{mean_hu:.1f}"]
+            draw_table_row(row)
+
+        # y_position -= section_spacing
+
+        # === Step 2: PDAC Staging ===
+        # temp_pdf.setFont("Helvetica-Bold", 12)
+        # temp_pdf.drawString(left_margin, y_position, "PDAC STAGING")
+        # y_position -= line_height
+
+        # try:
+        #     pdac_info = get_pdac_staging(id)
+        #     print(pdac_info, id)
+        #     pdac_text = pdac_info.get("staging_description", "No staging data available.")
+        # except Exception:
+        #     pdac_text = "Error fetching PDAC staging information."
+
+        # y_position = write_wrapped_text(left_margin, y_position, pdac_text, bold=False, font_size=10)
+        # === Step 3: Key Images ===
+        
+        # include_liver = np.count_nonzero(mask_array == LABELS["liver"]) > 0
+        # include_pancreas = lession_volume_dict.get("pancreas", {}).get("number", 0) > 0
+        # include_kidney = np.count_nonzero(mask_array == LABELS["kidney_left"]) > 0 or np.count_nonzero(mask_array == LABELS["kidney_right"]) > 0
+        # print(include_liver, include_pancreas, include_kidney)
+        # if include_liver or include_pancreas or include_kidney:
+        #     def check_and_reset_page(space_needed):
+        #         nonlocal y_position
+        #         if y_position - space_needed < 50:
+        #             reset_page()
+
+        #     temp_pdf.showPage()
+        #     y_position = height - top_margin
+        #     temp_pdf.setFont("Helvetica-Bold", 14)
+        #     # temp_pdf.drawString(left_margin, y_position, "KEY IMAGES")
+        #     y_position -= section_spacing
+
+        #     organs = {
+        #         "liver": include_liver,
+        #         "pancreas": include_pancreas,
+        #         "kidney_left": include_kidney,
+        #         "kidney_right": include_kidney
+        #     }
+            # download_clean_folder(ct_path.replace("/inputs/", "/outputs/").rsplit("/", 1)[0])
+            # for organ in organs:
+            #     organ_data = lession_volume_dict.get(organ)
+            #     if not organ_data or organ_data.get("number", 0) == 0:
+            #         continue
+
+            #     header = f"{organ.replace('_', ' ').upper()} TUMORS"
+            #     check_and_reset_page(line_height)
+            #     temp_pdf.setFont("Helvetica", 12)
+            #     temp_pdf.drawString(left_margin, y_position, header)
+            #     y_position -= line_height
+            #     print(organ, organ_data)
+            #     check_and_reset_page(220)
+            #     overlay_path = f"/tmp/{organ}_overlay.png"
+            #     print(ct_path, mask_path)
+            #     organ_mask_path = mask_path.replace('combined_labels.nii.gz', 'segmentations/'+organ+'.nii.gz')
+            #     print(organ_mask_path)
+            #     if create_overlay_image(ct_path, organ_mask_path, overlay_path, color="red"):
+            #         try:
+            #             temp_pdf.drawImage(overlay_path, left_margin, y_position - 200, width=200, height=200)
+            #         except:
+            #             print(overlay_path)
+            #     check_and_reset_page(220)
+            #     zoom_path = f"/tmp/{organ}_zoomed.png"
+            #     if zoom_into_labeled_area(ct_path, organ_mask_path, zoom_path, color="red"):
+            #         temp_pdf.drawImage(zoom_path, left_margin + 250, y_position - 205, width=210, height=210)
+            #     print('521')
+            #     y_position -= 220
+
+        temp_pdf.save()
+
+        # Merge with template
+        template_reader =  PdfReader(template_pdf)
+        content_reader = PdfReader(temp_pdf_path)
+        writer = PdfWriter()
+
+        for page in content_reader.pages:
+            template_page = template_reader.pages[0]
+            merged_page = PageObject.create_blank_page(
+                width=template_page.mediabox.width,
+                height=template_page.mediabox.height
+            )
+            merged_page.merge_page(template_page)
+            merged_page.merge_page(page)
+            writer.add_page(merged_page)
+
+        with open(output_pdf, "wb") as f:
+            writer.write(f)
+
+                
+    except Exception as e:
+        raise RuntimeError(f"Error generating PDF for {folder_name}: {e}")
+    finally:
+        if os.path.exists(temp_pdf_path):
+            os.remove(temp_pdf_path)
+
+# Helper Function to Process CT and Mask
+def get_most_labeled_slice(ct_path, mask_path, output_png, contrast_min=-150, contrast_max=250):
+    """
+    Load CT and mask, ensure RAS orientation, find the most labeled slice, and generate an overlay image.
+    """
+
+    try:
+        import SimpleITK as sitk
+        import matplotlib
+        matplotlib.use('Agg')  # ✅ 关键：不再尝试调用 GUI
+
+        import matplotlib.pyplot as plt
+
+        # Load the CT scan and mask
+        ct_scan = sitk.ReadImage(ct_path)
+        print('543',mask_path)
+        mask = sitk.ReadImage(mask_path)
+        print(mask_path)
+        # Reorient to RAS
+        ct_scan = sitk.DICOMOrient(ct_scan, 'RAS')
+        mask = sitk.DICOMOrient(mask, 'RAS')
+
+        # Convert to numpy arrays
+        ct_array = sitk.GetArrayFromImage(ct_scan)
+        mask_array = sitk.GetArrayFromImage(mask)
+
+        # Check for shape mismatches
+        if ct_array.shape != mask_array.shape:
+            raise ValueError(f"Shape mismatch: CT shape {ct_array.shape}, Mask shape {mask_array.shape}")
+
+        # Find the slice with the most labels
+        slice_sums = np.sum(mask_array, axis=(1, 2))
+        most_labeled_slice_index = np.argmax(slice_sums)
+
+        # Get the CT and mask slices
+        ct_slice = ct_array[most_labeled_slice_index]
+        mask_slice = mask_array[most_labeled_slice_index]
+
+        # Apply mirroring
+        ct_slice = np.fliplr(ct_slice)
+        mask_slice = np.fliplr(mask_slice)
+
+        # Apply contrast adjustment
+        ct_slice = np.clip(ct_slice, contrast_min, contrast_max)
+        ct_slice = (ct_slice - contrast_min) / (contrast_max - contrast_min) * 255
+        ct_slice = ct_slice.astype(np.uint8)
+
+        # Overlay mask contours on CT slice
+        plt.figure(figsize=(6, 6))
+        plt.imshow(ct_slice, cmap='gray', origin='lower')
+        plt.contour(mask_slice, colors='red', linewidths=1)  # Use red contours for the mask
+        plt.axis('off')
+        plt.savefig(output_png, bbox_inches="tight", pad_inches=0)
+        plt.close()
+        print('586')
+        return True
+    except:
+        return False
+
+def create_overlay_image(ct_path, mask_path, output_path, color="red"):
+    """
+    Generate overlay images for most labeled slices using the unified RAS orientation logic.
+    """
+    return get_most_labeled_slice(ct_path, mask_path, output_path)
+
+
+# Helper Function to Zoom into Labeled Area
+def zoom_into_labeled_area(ct_path, mask_path, output_path, color="red"):
+    """
+    Create a zoomed-in view of the largest labeled area with consistent RAS orientation.
+    """
+    import SimpleITK as sitk
+    import matplotlib.pyplot as plt
+    try:
+        # Load the CT scan and mask
+        ct_scan = sitk.ReadImage(ct_path)
+        mask = sitk.ReadImage(mask_path)
+
+        # Reorient to RAS
+        ct_scan = sitk.DICOMOrient(ct_scan, 'RAS')
+        mask = sitk.DICOMOrient(mask, 'RAS')
+
+        # Convert to numpy arrays
+        ct_array = sitk.GetArrayFromImage(ct_scan)
+        mask_array = sitk.GetArrayFromImage(mask)
+
+        # Check for shape mismatches
+        if ct_array.shape != mask_array.shape:
+            raise ValueError(f"Shape mismatch: CT shape {ct_array.shape}, Mask shape {mask_array.shape}")
+
+        # Find the slice with the most labels
+        slice_sums = np.sum(mask_array, axis=(1, 2))
+        largest_slice_idx = np.argmax(slice_sums)
+        if slice_sums[largest_slice_idx] == 0:
+            raise ValueError("No labeled area found in the mask.")
+
+        # Get the mask slice and calculate the bounding box
+        mask_slice = mask_array[largest_slice_idx]
+        coords = np.array(np.where(mask_slice))
+        min_row, max_row = np.min(coords[0]), np.max(coords[0])
+        min_col, max_col = np.min(coords[1]), np.max(coords[1])
+        padding = 20
+        min_row = max(min_row - padding, 0)
+        max_row = min(max_row + padding, mask_slice.shape[0])
+        min_col = max(min_col - padding, 0)
+        max_col = min(max_col + padding, mask_slice.shape[1])
+
+        # Extract the zoomed region
+        zoomed_image = ct_array[largest_slice_idx][min_row:max_row, min_col:max_col]
+        zoomed_mask = mask_array[largest_slice_idx][min_row:max_row, min_col:max_col]
+
+        # Apply mirroring
+        zoomed_image = np.fliplr(zoomed_image)
+        zoomed_mask = np.fliplr(zoomed_mask)
+
+        # Apply contrast adjustment to the zoomed CT slice
+        zoomed_image = np.clip(zoomed_image, -150, 250)
+        zoomed_image = (zoomed_image + 150) / 400 * 255
+        zoomed_image = zoomed_image.astype(np.uint8)
+
+        # Save the zoomed-in image with overlay
+        plt.figure(figsize=(6, 6))
+        plt.imshow(zoomed_image, cmap="gray", origin="lower")
+        plt.contour(zoomed_mask, colors=color, linewidths=1)
+        plt.axis("off")
+        plt.savefig(output_path, bbox_inches="tight")
+        plt.close()
+        return True
+    except Exception as e:
+        return False
+
+def get_pdac_staging(clabel_id):
+    try:
+        subfolder = "ImageTr" if int(clabel_id) < 9000 else "ImageTe"
+        label_subfolder = "LabelTr" if int(clabel_id) < 9000 else "LabelTe"
+        main_nifti_path = f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(clabel_id)}/{Constants.MAIN_NIFTI_FILENAME}"
+        combined_labels_path = f"{Constants.PANTS_PATH}/data/{label_subfolder}/{get_panTS_id(clabel_id)}/{Constants.COMBINED_LABELS_NIFTI_FILENAME}"
+        
+        nifti_processor = NiftiProcessor(main_nifti_path, combined_labels_path)
+        staging_result = nifti_processor.calculate_pdac_sma_staging()
+
+        return {"staging_description": staging_result}
+
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return {"error": f"PDAC staging failed: {str(e)}"}
+
+import json
+def download_clean_folder(root):
+    """
+    如果文件正好匹配4个目标名，则删除其中两个，并将combined_labels.nii.gz根据dataset.json分割为独立器官文件。
+    """
+    target_files = {
+        "combined_labels.nii.gz",
+        "dataset.json",
+        "plans.json",
+        "predict_from_raw_data_args.json"
+    }
+
+    actual_files = set(os.listdir(root))
+    if actual_files == target_files:
+        # 删除 plans.json 和 predict_from_raw_data_args.json
+        for fname in ["plans.json", "predict_from_raw_data_args.json"]:
+            fpath = os.path.join(root, fname)
+            if os.path.exists(fpath):
+                os.remove(fpath)
+                print(f"🗑️ Removed during zip: {fpath}")
+
+        # 读取 dataset.json
+        dataset_json_path = os.path.join(root, "dataset.json")
+        with open(dataset_json_path, 'r') as f:
+            dataset_info = json.load(f)
+
+        labels = dataset_info["labels"]  # 获取标签名与ID的映射
+
+        # 读取 combined_labels.nii.gz
+        combined_path = os.path.join(root, "combined_labels.nii.gz")
+        combined_img = nib.load(combined_path)
+        combined_data = combined_img.get_fdata()
+        affine = combined_img.affine
+
+        # 创建 segmentations 文件夹
+        seg_folder = os.path.join(root, "segmentations")
+        os.makedirs(seg_folder, exist_ok=True)
+
+        # 为每个标签生成单独的 mask 文件
+        for label_name, label_value in labels.items():
+            mask = (combined_data == label_value).astype(np.uint8)
+            label_img = nib.Nifti1Image(mask, affine)
+            out_path = os.path.join(seg_folder, f"{label_name}.nii.gz")
+            nib.save(label_img, out_path)
+            print(f"✅ Saved: {out_path}")
+        os.remove(dataset_json_path)
+    else:
+        print("ℹ️ Folder content does not match the expected file set. Skipping cleanup and split.")
+        
+async def store_files(combined_labels_id):
+    subfolder = "LabelTr" if int(combined_labels_id) < 9000 else "LabelTe" 
+    image_subfolder = "ImageTr" if int(combined_labels_id) < 9000 else "ImageTe"
+
+    def download(url, path):
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        headers = {"User-Agent": "Mozilla/5.0"}
+        res = requests.get(url, stream=True, headers=headers, allow_redirects=True)
+        if res.status_code == 200:
+            with open(path, "wb") as f:
+                for chunk in res.iter_content(1024):
+                    f.write(chunk)
+            print(f"Saved: {path}")
+        else:
+            print(f"Failed: {url} ({res.status_code})")
+
+    # main CT
+    image_url = f"https://huggingface.co/datasets/BodyMaps/iPanTSMini/resolve/main/image_only/{get_panTS_id(combined_labels_id)}/ct.nii.gz"
+    image_path = f"{Constants.PANTS_PATH}/data/{image_subfolder}/{get_panTS_id(combined_labels_id)}/ct.nii.gz"
+    download(image_url, image_path)
+
+    # labels
+    for label in list(Constants.PREDEFINED_LABELS.values()):
+        mask_url = f"https://huggingface.co/datasets/BodyMaps/iPanTSMini/resolve/main/mask_only/{get_panTS_id(combined_labels_id)}/segmentations/{label}.nii.gz"
+        mask_path = f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(combined_labels_id)}/segmentations/{label}.nii.gz"
+        download(mask_url, mask_path)
+        
+META_FILE = f"{Constants.PANTS_PATH}/data/metadata.xlsx"
+# ---------------------------
+# Helpers
+# ---------------------------
+def _arg(name: str, default=None):
+    return request.args.get(name, default)
+
+def to_int(x) -> Optional[int]:
+    try:
+        return int(x)
+    except Exception:
+        return None
+
+def _to_float(x) -> Optional[float]:
+    try:
+        return float(x)
+    except Exception:
+        return None
+
+def _to01_query(x) -> Optional[int]:
+    if x is None: return None
+    s = str(x).strip().lower()
+    if s in ("1","true","yes","y"): return 1
+    if s in ("0","false","no","n"): return 0
+    return None
+
+def _collect_list_params(names: List[str]) -> List[str]:
+    out: List[str] = []
+    for n in names:
+        if n in request.args:
+            out += request.args.getlist(n)
+    tmp: List[str] = []
+    for s in out:
+        if "," in s:
+            tmp += [t.strip() for t in s.split(",") if t.strip()]
+        else:
+            tmp.append(s.strip())
+    return [t for t in tmp if t]
+
+def _nan2none(v):
+    try:
+        if v is None: return None
+        if pd.isna(v): return None
+    except Exception:
+        pass
+    return v
+
+def clean_json_list(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _clean(v):
+        if isinstance(v, (np.integer,)):  return int(v)
+        if isinstance(v, (np.floating,)): return float(v)
+        if isinstance(v, (np.bool_,)):    return bool(v)
+        return v
+    return [{k: _clean(v) for k, v in d.items()} for d in items]
+
+def _canon_letters_digits(s: str) -> str:
+    # 把 "LightSpeed16" 變成 "LightSpeed 16"
+    s2 = re.sub(r"([A-Za-z])(\d)", r"\1 \2", s)
+    s2 = re.sub(r"(\d)([A-Za-z])", r"\1 \2", s2)
+    return re.sub(r"\s+", " ", s2).strip()
+
+def canon_model(s: str) -> str:
+    if not s: return ""
+    base = str(s).strip()
+    # 標準化空白/底線/大小寫
+    low = re.sub(r"[_\-]+", " ", base).strip().lower()
+    low = _canon_letters_digits(low)
+    # 套用別名表
+    if low in Constants.MODEL_ALIASES:
+        return Constants.MODEL_ALIASES[low]
+    # 沒有在別名表時：維持「字母數字分隔 + 每字首大寫」的安全格式
+    spaced = _canon_letters_digits(base)
+    # 常見廠牌固定大寫
+    spaced = re.sub(r"(?i)^somatom", "SOMATOM", spaced)
+    spaced = re.sub(r"(?i)^iqon", "IQon", spaced)
+    return spaced
+
+# ---------------------------
+# Load & normalize
+# ---------------------------
+def _norm_cols(df_raw: pd.DataFrame) -> pd.DataFrame:
+    """標準化欄位，產出搜尋/排序需要的衍生欄位。"""
+    df = df_raw.copy()
+
+    # ---- Case ID ----
+    case_cols = ["PanTS ID", "PanTS_ID", "case_id", "id", "case", "CaseID"]
+    def _first_nonempty(row, cols):
+        for c in cols:
+            if c in row.index and pd.notna(row[c]) and str(row[c]).strip():
+                return str(row[c]).strip(), c
+        return "", None
+
+    cases, mapping = [], []
+    for _, r in df.iterrows():
+        s, c = _first_nonempty(r, case_cols)
+        cases.append(s); mapping.append({"case": c} if c else {})
+    df["__case_str"] = cases
+    df["_orig_cols"] = mapping
+
+    # ---- Tumor -> __tumor01 ----
+    def _canon(s: str) -> str: return re.sub(r"[^a-z]+", "", str(s).lower())
+    tumor_names = [c for c in df.columns if "tumor" in _canon(c)] or []
+    tcol = tumor_names[0] if tumor_names else None
+
+    def _to01_v(v):
+        if pd.isna(v): return np.nan
+        s = str(v).strip().lower()
+        if s in ("1","yes","y","true","t"): return 1
+        if s in ("0","no","n","false","f"): return 0
+        try:
+            iv = int(float(s))
+            return 1 if iv == 1 else (0 if iv == 0 else np.nan)
+        except Exception:
+            return np.nan
+
+    df["__tumor01"] = (df[tcol].map(_to01_v) if tcol else pd.Series([np.nan]*len(df), index=df.index))
+    if tcol:
+        df["_orig_cols"] = [{**(df["_orig_cols"].iat[i] or {}), "tumor": tcol} for i in range(len(df))]
+
+    # ---- Sex -> __sex ----
+    df["__sex"] = df.get("sex", pd.Series([""]*len(df))).astype(str).str.strip().str.upper()
+    df["__sex"] = df["__sex"].where(df["__sex"].isin(["F","M"]), "")
+
+    # ---- Generic column finder ----
+    def _find_col(prefer, keyword_sets=None):
+        for c in prefer:
+            if c in df.columns: return c
+        if keyword_sets:
+            canon_map = {c: re.sub(r"[^a-z0-9]+", "", str(c).lower()) for c in df.columns}
+            for c, cs in canon_map.items():
+                for ks in keyword_sets:
+                    if all(k in cs for k in ks): return c
+        return None
+
+    # ---- CT phase -> __ct / __ct_lc ----
+    ct_col = _find_col(
+        prefer=["ct phase","CT phase","ct_phase","CT_phase","ct"],
+        keyword_sets=[["ct","phase"],["phase"]],
+    )
+    if ct_col:
+        df["__ct"] = df[ct_col].astype(str).str.strip()
+        df["__ct_lc"] = df["__ct"].str.lower()
+        df["_orig_cols"] = [{**(df["_orig_cols"].iat[i] or {}), "ct_phase": ct_col} for i in range(len(df))]
+    else:
+        df["__ct"], df["__ct_lc"] = "", ""
+
+    # ---- Manufacturer -> __mfr / __mfr_lc ----
+    mfr_col = _find_col(
+        prefer=["manufacturer","Manufacturer","mfr","MFR","vendor","Vendor","manufacturer name","Manufacturer Name"],
+        keyword_sets=[["manufactur"],["vendor"],["brand"],["maker"]],
+    )
+    if mfr_col:
+        df["__mfr"] = df[mfr_col].astype(str).str.strip()
+        df["__mfr_lc"] = df["__mfr"].str.lower()
+        df["_orig_cols"] = [{**(df["_orig_cols"].iat[i] or {}), "manufacturer": mfr_col} for i in range(len(df))]
+    else:
+        df["__mfr"], df["__mfr_lc"] = "", ""
+
+        # ---- Manufacturer model -> model / __model_lc ----
+    model_col = _find_col(
+        prefer=["manufacturer model", "Manufacturer model", "model", "Model"],
+        keyword_sets=[["model"]],
+    )
+    if model_col:
+        # 保留原始字串以便追蹤
+        df["model_raw"] = df[model_col].astype(str).str.strip()
+        # 規則化為標準型號（大小寫、空白、數字黏在一起等）
+        df["model"] = df["model_raw"].map(canon_model)
+        df["__model_lc"] = df["model"].str.lower()
+        df["_orig_cols"] = [
+            {**(df["_orig_cols"].iat[i] or {}), "model": model_col}
+            for i in range(len(df))
+        ]
+    else:
+        # 以免前端讀不到欄位
+        df["model_raw"] = ""
+        df["model"] = ""
+        df["__model_lc"] = ""
+
+    # ---- Year -> __year_int ----
+    year_col = _find_col(prefer=["study year", "Study year", "study_year", "year", "Year"],
+                         keyword_sets=[["year"]])
+    df["__year_int"] = (
+        pd.to_numeric(df[year_col], errors="coerce")
+        if year_col else pd.Series([np.nan] * len(df), index=df.index)
+    )
+    if year_col:
+        df["_orig_cols"] = [
+            {**(df["_orig_cols"].iat[i] or {}), "year": year_col}
+            for i in range(len(df))
+        ]
+
+    # ---- Age -> __age ----
+    age_col = _find_col(prefer=["age", "Age"], keyword_sets=[["age"]])
+    df["__age"] = (
+        pd.to_numeric(df[age_col], errors="coerce")
+        if age_col else pd.Series([np.nan] * len(df), index=df.index)
+    )
+    if age_col:
+        df["_orig_cols"] = [
+            {**(df["_orig_cols"].iat[i] or {}), "age": age_col}
+            for i in range(len(df))
+        ]
+
+    # ---- Study type -> study_type / __st_lc ----
+    st_col = _find_col(
+        prefer=["study type", "Study type", "study_type", "Study_type"],
+        keyword_sets=[["study", "type"]],
+    )
+    if st_col:
+        df["study_type"] = df[st_col].astype(str)
+        df["__st_lc"] = df["study_type"].astype(str).str.strip().str.lower()
+        df["_orig_cols"] = [
+            {**(df["_orig_cols"].iat[i] or {}), "study_type": st_col}
+            for i in range(len(df))
+        ]
+    else:
+        df["study_type"] = ""
+        df["__st_lc"] = ""
+
+    # ---- Site nationality -> site_nationality / __sn_lc ----
+    sn_col = _find_col(
+        prefer=[
+            "site nationality", "Site nationality", "site_nationality", "Site_nationality",
+            "nationality", "Nationality", "site country", "Site country", "country", "Country"
+        ],
+        keyword_sets=[["site", "national"], ["nationality"], ["site", "country"], ["country"]],
+    )
+    if sn_col:
+        df["site_nationality"] = df[sn_col].astype(str)
+        df["__sn_lc"] = df["site_nationality"].astype(str).str.strip().str.lower()
+        df["_orig_cols"] = [
+            {**(df["_orig_cols"].iat[i] or {}), "site_nationality": sn_col}
+            for i in range(len(df))
+        ]
+    else:
+        df["site_nationality"] = ""
+        df["__sn_lc"] = ""
+
+    return df
+
+
+def _safe_float(x) -> Optional[float]:
+    try:
+        if x is None: return None
+        if isinstance(x, float) and np.isnan(x): return None
+        if isinstance(x, str):
+            s = x.strip().replace(",", " ")
+            if not s: return None
+            return float(s)
+        return float(x)
+    except Exception:
+        return None
+
+def _take_first_str(row, cols: List[str]) -> str:
+    for c in cols:
+        if c in row and pd.notna(row[c]) and str(row[c]).strip():
+            return str(row[c]).strip()
+    return ""
+
+def _case_key(row) -> int:
+    s = _take_first_str(row, ["PanTS ID","PanTS_ID","case_id","id","__case_str"])
+    if not s: return 0
+    m = re.search(r"(\d+)", str(s))
+    return int(m.group(1)) if m else 0
+
+def _parse_3tuple_from_row(row, name_candidates: List[str]) -> List[Optional[float]]:
+    # 3 個獨立欄
+    for base in name_candidates:
+        cx, cy, cz = f"{base}_x", f"{base}_y", f"{base}_z"
+        if cx in row and cy in row and cz in row:
+            xs = [_safe_float(row[c]) for c in (cx, cy, cz)]
+            if all(v is not None for v in xs):
+                return xs
+    # 單欄字串
+    seps = [",", "x", " ", "×", "X", ";", "|"]
+    str_cols = []
+    for base in name_candidates:
+        str_cols += [base, f"{base}_str", base.replace(" ", "_")]
+    for c in str_cols:
+        if c in row and pd.notna(row[c]):
+            s = str(row[c]).strip()
+            if not s: continue
+            s2 = re.sub(r"[\[\]\(\)\{\}]", " ", s)
+            for sep in seps:
+                s2 = s2.replace(sep, " ")
+            parts = [p for p in s2.split() if p]
+            vals = [_safe_float(p) for p in parts[:3]]
+            if len(vals) == 3 and all(v is not None for v in vals):
+                return vals
+    return [None, None, None]
+
+def _spacing_sum(row) -> Optional[float]:
+    vals = _parse_3tuple_from_row(row, ["spacing","voxel_spacing","voxel_size","pixel_spacing"])
+    if any(v is None for v in vals): return None
+    return float(vals[0] + vals[1] + vals[2])
+
+def _shape_sum(row) -> Optional[float]:
+    vals = _parse_3tuple_from_row(row, ["shape","dim","size","image_shape","resolution"])
+    if any(v is None for v in vals): return None
+    return float(vals[0] + vals[1] + vals[2])
+
+def ensure_sort_cols(df: pd.DataFrame) -> pd.DataFrame:
+    if "__case_sortkey" not in df.columns:
+        df["__case_sortkey"] = df.apply(_case_key, axis=1)
+    if "__spacing_sum" not in df.columns:
+        df["__spacing_sum"] = df.apply(_spacing_sum, axis=1)
+    if "__shape_sum" not in df.columns:
+        df["__shape_sum"] = df.apply(_shape_sum, axis=1)
+
+    # 完整度：Browse 與 top 排序會用到
+    need_cols = ["__spacing_sum", "__shape_sum", "__sex", "__age"]
+    complete = pd.Series(True, index=df.index)
+    for c in need_cols:
+        if c not in df.columns:
+            complete &= False
+        elif c == "__sex":
+            complete &= (df[c].astype(str).str.strip() != "")
+        else:
+            complete &= df[c].notna()
+    df["__complete"] = complete
+    return df
+
+# load meta
+if not os.path.exists(META_FILE):
+    raise FileNotFoundError(f"metadata not found: {META_FILE}")
+DF_RAW = pd.read_excel(META_FILE)
+DF = _norm_cols(DF_RAW)
+
+def apply_filters(base: pd.DataFrame, exclude: Optional[Set[str]] = None) -> pd.DataFrame:
+    exclude = exclude or set()
+    df = base
+
+    # --- Case ID / keyword（精準匹配） ---
+    q = (_arg("q") or _arg("caseid") or "").strip()
+    if q and "caseid" not in exclude and "__case_str" in df.columns:
+        s = df["__case_str"].astype(str)
+        if q.isdigit():
+            # 把每列所有數字 token 抓出來，做數值等號；77 不會吃 177/077（前導 0 忽略）
+            qq = int(q)
+            nums = s.str.findall(r"\d+")
+            mask_num = nums.apply(lambda xs: any(int(x) == qq for x in xs))
+            # 備援：允許 "Case 77"（不必留可刪）
+            patt = rf"(?i)\b(?:case\s*)?{re.escape(q)}\b"
+            mask_regex = s.str.contains(patt, na=False, regex=True)
+            df = df[mask_num | mask_regex]
+        else:
+            # 一般文字搜尋（忽略大小寫；避免把查詢當正則）
+            df = df[s.str.contains(re.escape(q), na=False, case=False, regex=False)]
+
+    # --- Tumor ---
+    tv = _to01_query(_arg("tumor"))
+    tnull = _to01_query(_arg("tumor_is_null"))
+    if (_arg("tumor", "").strip().lower() == "unknown"):
+        tnull, tv = 1, None
+    if "__tumor01" in df.columns and "tumor" not in exclude:
+        if tnull in (0, 1) and "tumor_is_null" not in exclude:
+            df = df[df["__tumor01"].isna()] if tnull == 1 else df[df["__tumor01"].notna()]
+        elif tv in (0, 1):
+            df = df[df["__tumor01"] == tv]
+
+    # --- Sex（多選 + Unknown）---
+    sv_list = _collect_list_params(["sex", "sex[]"])
+    snull = _to01_query(_arg("sex_is_null"))
+    if not sv_list:
+        sv = (_arg("sex", "") or "").strip().upper()
+        if sv:
+            sv_list = [sv]
+    sv_norm = []
+    for s_ in sv_list:
+        s2 = (s_ or "").strip().upper()
+        if s2 in ("M", "F"):
+            sv_norm.append(s2)
+        elif s2 in ("U", "UNKNOWN"):
+            sv_norm.append("UNKNOWN")
+    if "__sex" in df.columns and "sex" not in exclude and (sv_norm or snull in (0, 1)):
+        ser = df["__sex"].fillna("").str.strip().str.upper()
+        take = pd.Series(False, index=df.index)
+        vals = [s for s in sv_norm if s in ("F", "M")]
+        if vals:
+            take |= ser.isin(vals)
+        if ("UNKNOWN" in sv_norm) or (snull == 1):
+            take |= (ser == "")
+        df = df[take]
+
+    # --- Age：���援 age_bin[]（含 90+ / UNKNOWN），否則回退 age_from/age_to ---
+    bins = _collect_list_params(["age_bin", "age_bin[]"])
+    age_null = _to01_query(_arg("age_is_null"))
+    if "__age" in df.columns and bins:
+        age_series = pd.to_numeric(df["__age"], errors="coerce")
+        mask = pd.Series(False, index=df.index)
+        for b in bins:
+            s = (b or "").strip()
+            m_plus = re.match(r"^\s*(\d+)\s*\+\s*$", s)
+            if m_plus:
+                lo = int(m_plus.group(1))
+                mask |= (age_series >= lo)
+                continue
+            m_rng = re.match(r"^\s*(\d+)\s*[-–—]\s*(\d+)\s*$", s)
+            if m_rng:
+                lo, hi = int(m_rng.group(1)), int(m_rng.group(2))
+                mask |= age_series.between(lo, hi, inclusive="both")
+        if (age_null == 1) or any((t or "").strip().upper() == "UNKNOWN" for t in bins):
+            mask |= age_series.isna() | (df["__age"].astype(str).str.strip().str.upper() == "UNKNOWN")
+        df = df[mask]
+    elif "__age" in df.columns:
+        af = _to_float(_arg("age_from")); at = _to_float(_arg("age_to"))
+        age_series = pd.to_numeric(df["__age"], errors="coerce")
+        if "age_from" not in exclude and af is not None:
+            df = df[age_series >= af]
+        if "age_to" not in exclude and at is not None:
+            df = df[age_series <= at]
+
+    # --- CT phase ---
+    ct = (_arg("ct_phase", "") or "").strip().lower()
+    ct_list = _collect_list_params(["ct_phase", "ct_phase[]"])
+    if ct == "unknown" or any((s or "").lower() == "unknown" for s in ct_list):
+        if "__ct" in df.columns:
+            s_ct = df["__ct"].astype(str).str.strip().str.lower()
+            tokens_null_ct = {'', 'unknown', 'nan', 'n/a', 'na', 'none', '(blank)', '(null)'}
+            df = df[df["__ct"].isna() | s_ct.isin(tokens_null_ct)]
+    elif (ct or ct_list) and "__ct_lc" in df.columns:
+        parts = []
+        if ct:
+            parts += [p.strip() for p in re.split(r"[;,/]+", ct) if p.strip()]
+        parts += [p.strip().lower() for p in ct_list if p.strip()]
+        patt = "|".join(re.escape(p) for p in parts)
+        df = df[df["__ct_lc"].str.contains(patt, na=False)]
+
+    # --- Manufacturer ---
+    m_list = _collect_list_params(["manufacturer", "manufacturer[]", "mfr"])
+    m_raw = (_arg("manufacturer", "") or "").strip()
+    if m_raw and not m_list:
+        m_list = [p.strip() for p in m_raw.split(",") if p.strip()]
+    if m_list and "__mfr_lc" in df.columns:
+        m_lc = [s.lower() for s in m_list]
+        df = df[df["__mfr_lc"].isin(m_lc)]
+
+    # --- Model（canonical；可 fuzzy）---
+    model_list = _collect_list_params(["model", "model[]", "manufacturer_model"])
+    model_raw = (_arg("model", "") or "").strip()
+    if model_raw and not model_list:
+        model_list = [p.strip() for p in re.split(r"[;,/|]+", model_raw) if p.strip()]
+    if model_list and "__model_lc" in df.columns and "model" not in exclude:
+        wants = [canon_model(p).lower() for p in model_list if p]
+        wants = [w for w in wants if w]
+        fuzzy = str(_arg("model_fuzzy", "0")).lower() in ("1", "true", "yes")
+        if fuzzy:
+            patt = "|".join(re.escape(w) for w in wants)
+            df = df[df["__model_lc"].str.contains(patt, na=False)]
+        else:
+            df = df[df["__model_lc"].isin(set(wants))]
+
+    # --- Study type ---
+    st_list = _collect_list_params(["study_type", "study_type[]"])
+    st_raw = (_arg("study_type", "") or "").strip()
+    if st_raw and not st_list:
+        st_list = [p.strip() for p in re.split(r"[;,/|]+", st_raw) if p.strip()]
+    if st_list and "__st_lc" in df.columns and "study_type" not in exclude:
+        parts = [p.lower() for p in st_list]
+        patt = "|".join(re.escape(p) for p in parts)
+        df = df[df["__st_lc"].str.contains(patt, na=False)]
+
+    # --- Site nationality ---
+    nat_list = _collect_list_params(["site_nat", "site_nat[]", "site_nationality", "site_nationality[]"])
+    nat_raw = (_arg("site_nationality", "") or _arg("site_nat", "") or "").strip()
+    if nat_raw and not nat_list:
+        nat_list = [p.strip() for p in re.split(r"[;,/|]+", nat_raw) if p.strip()]
+    if nat_list and "__sn_lc" in df.columns and "site_nationality" not in exclude:
+        parts = [p.lower() for p in nat_list]
+        patt = "|".join(re.escape(p) for p in parts)
+        df = df[df["__sn_lc"].str.contains(patt, na=False)]
+
+    # --- Year（新增）---
+    # 支援 year / year[]（多選精確）、year_from / year_to（範圍）與 year_is_null（Unknown）
+    if "year" not in exclude:
+        _year_cols_pref = ["__year_int", "study_year", "Study year", "study year", "Year", "year"]
+        _found_cols = [c for c in _year_cols_pref if c in df.columns]
+        if _found_cols:
+            yser = pd.to_numeric(df[_found_cols[0]], errors="coerce")
+
+            # 1) 多選年份
+            year_list = _collect_list_params(["year", "year[]"])
+            year_raw = (_arg("year", "") or "").strip()
+            if year_raw and not year_list:
+                year_list = [p.strip() for p in re.split(r"[;,/|]+", year_raw) if p.strip()]
+
+            # 2) 範圍
+            y_from = to_int(_arg("year_from"))
+            y_to   = to_int(_arg("year_to"))
+
+            # 3) Unknown / Null
+            y_is_null = _to01_query(_arg("year_is_null"))
+            _unk_tokens = {"unknown", "nan", "none", "n/a", "na", "(blank)", "(null)"}
+            wants_unknown = (y_is_null == 1) or any(
+                (s or "").strip().lower() in _unk_tokens for s in year_list
+            )
+
+            mask = pd.Series(True, index=df.index)
+
+            # 多選精確年份
+            exact_years = []
+            for s in year_list:
+                try:
+                    exact_years.append(int(s))
+                except Exception:
+                    pass
+            if exact_years:
+                mask &= yser.isin(set(exact_years))
+
+            # 範圍條件
+            if y_from is not None:
+                mask &= (yser >= y_from)
+            if y_to is not None:
+                mask &= (yser <= y_to)
+
+            # Unknown 合併進來
+            if wants_unknown:
+                mask = mask | yser.isna()
+
+            df = df[mask]
+
+
+    return df
+
+def row_to_item(row: pd.Series) -> Dict[str, Any]:
+    cols = row.get("_orig_cols")
+    cols = cols if isinstance(cols, dict) else {}
+
+    def pick(k, fallback=None):
+        col = cols.get(k)
+        if col and col in row.index:
+            return row[col]
+        return fallback
+
+    return {
+        "PanTS ID": _nan2none(pick("case") or row.get("__case_str")),
+        "case_id":  _nan2none(pick("case") or row.get("__case_str")),
+        "tumor":    (int(row.get("__tumor01")) if pd.notna(row.get("__tumor01")) else None),
+        "sex":      _nan2none(row.get("__sex")),
+        "age":      _nan2none(row.get("__age")),
+        "ct phase": _nan2none(pick("ct_phase") or row.get("__ct")),
+        "manufacturer": _nan2none(pick("manufacturer") or row.get("__mfr")),
+        "manufacturer model": _nan2none(pick("model") or row.get("model")),
+        "study year": _nan2none(row.get("__year_int")),
+        "study type": _nan2none(pick("study_type") or row.get("study_type")),
+        "site nationality": _nan2none(pick("site_nationality") or row.get("site_nationality")),
+        # 排序輔助輸出
+        "spacing_sum": _nan2none(row.get("__spacing_sum")),
+        "shape_sum":   _nan2none(row.get("__shape_sum")),
+        "complete":    bool(row.get("__complete")) if "__complete" in row else None,
+    }

app.py

@@ -0,0 +1,73 @@
+import sys
+import os
+from werkzeug.serving import run_simple
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+from dotenv import load_dotenv
+
+load_dotenv(dotenv_path=os.path.join(os.path.dirname(__file__), ".env"))
+#print("DEBUG_ENV_LOADED:", os.environ.get("SESSIONS_DIR_PATH"))
+
+from flask import Flask
+from flask_cors import CORS
+from constants import Constants
+#print("DEBUG_CONSTANT:", Constants.SESSIONS_DIR_NAME)
+
+from api.api_blueprint import api_blueprint
+from models.base import db
+from models.combined_labels import CombinedLabels
+
+def create_session_dir():
+    if not os.path.isdir(Constants.SESSIONS_DIR_NAME):
+        os.mkdir(Constants.SESSIONS_DIR_NAME)
+
+import logging
+
+def create_app():
+    create_session_dir()
+    app = Flask(__name__)
+    app.register_blueprint(api_blueprint, url_prefix=f'{Constants.BASE_PATH}/api')
+
+    class FilterProgressRequests(logging.Filter):
+        def filter(self, record):
+            return "/api/progress/" not in record.getMessage()
+
+    logging.getLogger('werkzeug').addFilter(FilterProgressRequests())
+
+    CORS(app)
+
+    return app
+
+
+app = create_app()
+
+# ✅ SharedArrayBuffer Compatibility
+@app.after_request
+def add_security_headers(response):
+    response.headers["Cross-Origin-Opener-Policy"] = "same-origin"
+    response.headers["Cross-Origin-Embedder-Policy"] = "require-corp"
+    return response
+
+def find_watch_files():
+    watch_dirs = ['api', 'models', 'services']
+    base_path = os.path.dirname(__file__)
+    all_files = []
+    for d in watch_dirs:
+        dir_path = os.path.join(base_path, d)
+        for root, _, files in os.walk(dir_path):
+            for f in files:
+                if f.endswith('.py'):
+                    all_files.append(os.path.join(root, f))
+    return all_files
+
+if __name__ == "__main__":
+    use_ssl = os.environ.get("USE_SSL", "false").lower() == "true"
+    ssl_context = ("../certs/localhost-cert.pem", "../certs/localhost-key.pem") if use_ssl else None
+    run_simple(
+        hostname="0.0.0.0",
+        port=5001,
+        application=app,
+        use_debugger=True,
+        use_reloader=True,
+        extra_files=find_watch_files(),
+        ssl_context=ssl_context
+    )

constants.py

@@ -0,0 +1,126 @@
+import os
+from dotenv import load_dotenv
+import numpy as np
+from datetime import datetime
+
+load_dotenv(dotenv_path=os.path.join(os.path.dirname(__file__), ".env"))
+
+
+class Constants:
+    # app variables
+    SESSIONS_DIR_NAME = os.environ.get('SESSIONS_DIR_PATH', 'sessions')
+    DB_USER = os.environ.get('DB_USER')
+    DB_PASS = os.environ.get('DB_PASS')
+    DB_HOST = os.environ.get('DB_HOST')
+    DB_NAME = os.environ.get('DB_NAME')
+
+    SCHEDULED_CHECK_INTERVAL = 5  # minutes  
+
+    # api_blueprint variables
+    BASE_PATH = os.environ.get('BASE_PATH', '/')
+    PANTS_PATH = os.environ.get('PANTS_PATH')
+    MAIN_NIFTI_FORM_NAME = 'MAIN_NIFTI'
+    MAIN_NPZ_FILENAME = 'ct.npz'
+    MAIN_NIFTI_FILENAME = 'ct.nii.gz'
+    COMBINED_LABELS_FILENAME = 'combined_labels.npz'
+    COMBINED_LABELS_NIFTI_FILENAME = 'combined_labels.nii.gz'
+    ORGAN_INTENSITIES_FILENAME = 'organ_intensities.json'
+    SESSION_TIMEDELTA = 3  # in days
+
+    # NiftiProcessor Variables
+    EROSION_PIXELS = 2
+    CUBE_LEN = (2 * EROSION_PIXELS) + 1
+    STRUCTURING_ELEMENT = np.ones([CUBE_LEN, CUBE_LEN, CUBE_LEN], dtype=bool)
+
+    DECIMAL_PRECISION_VOLUME = 2
+    DECIMAL_PRECISION_HU = 1
+    VOXEL_THRESHOLD = 100
+
+    PREDEFINED_LABELS = {
+        0: "adrenal_gland_left",
+        1: "adrenal_gland_right",
+        2: "aorta",
+        3: "bladder",
+        4:"celiac_artery",
+        5: "colon",
+        6: "common_bile_duct",
+        7: "duodenum",
+        8: "femur_left",
+        9: "femur_right",
+        10: "gall_bladder",
+        11: "kidney_left",
+        12: "kidney_right",
+        13: "liver",
+        14: "lung_left",
+        15: "lung_right",
+        16: "pancreas_body",
+        17: "pancreas_head",
+        18: "pancreas_tail",
+        19: "pancreas",
+        20: "pancreatic_duct",
+        21: "pancreatic_lesion",
+        22: "postcava",
+        23: "prostate",
+        24: "spleen",
+        25: "stomach",
+        26: "superior_mesenteric_artery",
+        27: "veins"
+    }
+    
+    MODEL_ALIASES = {
+        # GE
+        "lightspeed 16": "LightSpeed 16",
+        "lightspeed16": "LightSpeed 16",
+        "lightspeed vct": "LightSpeed VCT",
+        "lightspeed qx/i": "LightSpeed QX/i",
+        "lightspeed pro 16": "LightSpeed Pro 16",
+        "lightspeed pro 32": "LightSpeed Pro 32",
+        "lightspeed plus": "LightSpeed Plus",
+        "lightspeed ultra": "LightSpeed Ultra",
+        # Siemens
+        "somatom definition as+": "SOMATOM Definition AS+",
+        "somatom definition as": "SOMATOM Definition AS",
+        "somatom definition flash": "SOMATOM Definition Flash",
+        "somatom definition edge": "SOMATOM Definition Edge",
+        "somatom force": "SOMATOM Force",
+        "somatom go.top": "SOMATOM Go.Top",
+        "somatom plus 4": "SOMATOM PLUS 4",
+        "somatom scope": "SOMATOM Scope",
+        "somatom definition": "SOMATOM Definition",
+        "sensation 4": "Sensation 4",
+        "sensation 10": "Sensation 10",
+        "sensation 16": "Sensation 16",
+        "sensation 40": "Sensation 40",
+        "sensation 64": "Sensation 64",
+        "sensation cardiac 64": "Sensation Cardiac 64",
+        "sensation open": "Sensation Open",
+        "emotion 16": "Emotion 16",
+        "emotion 6 (2007)": "Emotion 6 (2007)",
+        "perspective": "Perspective",
+        # Philips
+        "brilliance 10": "Brilliance 10",
+        "brilliance 16": "Brilliance 16",
+        "brilliance 16p": "Brilliance 16P",
+        "brilliance 40": "Brilliance 40",
+        "brilliance 64": "Brilliance 64",
+        "ingenuity core 128": "Ingenuity Core 128",
+        "iqon - spectral ct": "IQon - Spectral CT",
+        "philips ct aura": "Philips CT Aura",
+        "precedence 16p": "Precedence 16P",
+        # Canon / Toshiba
+        "aquilion one": "Aquilion ONE",
+        "aquilion": "Aquilion",
+        # GE 其他
+        "optima ct540": "Optima CT540",
+        "optima ct660": "Optima CT660",
+        "optima ct520 series": "Optima CT520 Series",
+        "revolution ct": "Revolution CT",
+        "revolution evo": "Revolution EVO",
+        "discovery st": "Discovery ST",
+        "discovery ste": "Discovery STE",
+        "discovery mi": "Discovery MI",
+        "hispeed ct/i": "HiSpeed CT/i",
+        # PET/CT
+        "biograph128": "Biograph128",
+        "biograph 128": "Biograph128",
+    }

handle.py

@@ -0,0 +1,124 @@
+import nibabel as nib
+import numpy as np
+from constants import Constants
+from utils import removeFileExt
+import scipy.ndimage as ndimage
+
+import os
+
+
+
+
+
+# def combine_labels(files, session_key):
+#     filenames = list(files.keys())
+#     filenames.remove('MAIN_NIFTI')
+#     base = os.path.join('sessions', session_key) #base dir path 
+#     os.makedirs(os.path.join(base, 'segmentations'))
+#     main_nifti = files['MAIN_NIFTI']
+#     main_nifti.save(os.path.join(base, main_nifti_filename))
+#     print(filenames)
+#     aorta = files['aorta.nii.gz']
+#     nib.Nifti1Image.from_bytes(aorta.read())
+#     return 
+
+def voxelThreshold(slice):
+    num_voxels = len(slice[slice > 0])
+    return num_voxels < Constants.VOXEL_THRESHOLD
+
+def getCalcVolumeState(img_data, organ):
+    if organ in Constants.organ_ids_volumeNA:
+        return "NA" # blood vessel, volume is NA
+    slices = [
+        img_data[:, :, 0],
+        img_data[:, :, -1],
+        img_data[0, :, :],
+        img_data[-1, :, :],
+        img_data[:, 0, :],
+        img_data[:, -1, :],
+    ]
+    for slice in slices:
+        if voxelThreshold(slice) is False:
+            return "incomplete"
+    return "complete"
+
+
+def processMasks(sessionKey):
+    data = {"data": []}
+    ct = nib.load(os.path.join('sessions', sessionKey, Constants.main_nifti_filename)).get_fdata()
+    organ_ids = os.listdir(os.path.join('sessions', sessionKey, 'segmentations'))
+    print(organ_ids)
+    for i in range(len(organ_ids)):
+        organ_data = {}
+        organ_data['id'] = removeFileExt(organ_ids[i])
+        img = nib.load(os.path.join('sessions', sessionKey, 'segmentations', organ_ids[i]))
+        img_data = img.get_fdata()
+        state = getCalcVolumeState(img_data, organ_ids[i])
+        if state == "complete":
+            volume_cm = round(float(nib.imagestats.mask_volume(img)/1000), Constants.DECIMAL_PRECISION_VOLUME)
+            organ_data['volume_cm'] = volume_cm
+        elif state == "incomplete":
+            organ_data['volume_cm'] = "Incomplete organ"
+        elif state == "NA":
+            organ_data['volume_cm'] = "N/A"
+        
+        erosion_data = ndimage.binary_erosion(img_data, structure=Constants.STRUCTURING_ELEMENT)
+        hu_values = ct[erosion_data > 0]
+        if len(hu_values) == 0:
+            organ_data['mean_hu'] = 'N/A'
+        else:
+            mean_hu = round(float(np.mean(hu_values)), Constants.DECIMAL_PRECISION_HU)
+            organ_data['mean_hu'] = mean_hu 
+
+        data['data'].append(organ_data)
+
+    return data
+
+
+# def test():
+#     for organ in organ_ids:
+#         mask = nib.load(f'dev/segmentations/{organ}.nii.gz').get_fdata()
+#         for i in range(mask.shape[2]):
+#             slice = mask[:, :, i]
+#             length = len(slice[slice > 0])
+#             if length > 0:
+#                 print(organ)
+#                 print('num voxels: ', length)
+#                 break
+#         for i in range(mask.shape[2]-1, -1, -1):
+#             slice = mask[:, :, i]
+#             length = len(slice[slice > 0])
+#             if length > 0:
+#                 print(organ)
+#                 print('num voxels: ', length)
+#                 break
+#         for i in range(mask.shape[0]):
+#             slice = mask[i, :, :]
+#             length = len(slice[slice > 0])
+#             if length > 0:
+#                 print(organ)
+#                 print('num voxels: ', length)
+#                 break
+#         for i in range(mask.shape[0]-1, -1, -1):
+#             slice = mask[i, :, :]
+#             length = len(slice[slice > 0])
+#             if length > 0:
+#                 print(organ)
+#                 print('num voxels: ', length)
+#                 break
+#         for i in range(mask.shape[1]):
+#             slice = mask[:, i, :]
+#             length = len(slice[slice > 0])
+#             if length > 0:
+#                 print(organ)
+#                 print('num voxels: ', length)
+#                 break
+#         for i in range(mask.shape[1]-1, -1, -1):
+#             slice = mask[:, i, :]
+#             length = len(slice[slice > 0])
+#             if length > 0:
+#                 print(organ)
+#                 print('num voxels: ', length)
+#                 break
+
+# test()

migrations/script.py.mako

@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

models/application_session.py

@@ -0,0 +1,24 @@
+from models.base import db
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import Integer, String, DateTime
+
+class ApplicationSession(db.Model):
+    __tablename__ = "application_session"
+
+    session_id: Mapped[str] = mapped_column(primary_key=True, unique=True, type_=String)
+    main_nifti_path: Mapped[str] = mapped_column(type_=String,  nullable=False)
+    combined_labels_id: Mapped[str] = mapped_column(unique=True, type_=String)
+    session_created: Mapped[DateTime] = mapped_column(type_=DateTime) 
+    session_expire_date: Mapped[DateTime] = mapped_column(type_=DateTime)
+
+    def __str__(self):
+        return f'''
+        ApplicationSession OBJECT:
+            session_id: {self.session_id} 
+            main_nifti_path: {self.main_nifti_path} 
+            combined_files_path: {self.combined_labels_id} 
+            session_created: {self.session_created}
+            session_expires: {self.session_expire_date}'''
+
+
+

models/base.py

@@ -0,0 +1,7 @@
+from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.orm import DeclarativeBase
+
+class ModelBase(DeclarativeBase):
+    pass
+
+db = SQLAlchemy(model_class=ModelBase)

models/combined_labels.py

@@ -0,0 +1,22 @@
+from models.base import ModelBase
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import JSON, String, Integer
+
+class CombinedLabels(ModelBase):
+
+    __tablename__ = "combined_labels"
+
+    combined_labels_id: Mapped[str] = mapped_column(primary_key=True, type_=String)
+    combined_labels_path: Mapped[str] = mapped_column(type_=String)
+    organ_intensities: Mapped[JSON] = mapped_column(type_=JSON)
+    organ_metadata: Mapped[JSON] = mapped_column(type_=JSON)
+    
+
+    def __str__(self):
+        return f"""
+        CombinedLabels object
+            id: {self.combined_labels_id}
+            path: {self.combined_labels_path}
+            organ_intensities: {self.organ_intensities}
+            organ_metadata: {self.organ_metadata}
+"""

requirements.txt

@@ -0,0 +1,35 @@
+blinker==1.8.2
+certifi==2024.8.30
+charset-normalizer==3.4.0
+click==8.1.7
+colorama==0.4.6
+dnspython==2.7.0
+Flask==3.0.3
+Flask-Cors==4.0.1
+Flask-SQLAlchemy==3.1.1
+greenlet==3.1.1
+gunicorn==23.0.0
+idna==3.10
+iniconfig==2.0.0
+itsdangerous==2.2.0
+Jinja2==3.1.4
+Mako==1.3.8
+nibabel==5.2.1
+numpy==2.0.1
+packaging==24.1
+pluggy==1.5.0
+psycopg2-binary==2.9.10
+pymongo==4.10.1
+pytest==8.3.3
+python-dotenv==1.0.1
+requests==2.32.3
+reportlab==4.4.1
+scipy==1.13.0
+setuptools==75.6.0
+SQLAlchemy==2.0.37
+typing_extensions==4.12.2
+tzlocal==5.2
+urllib3==2.2.3
+Werkzeug==3.0.3
+wheel==0.45.1
+#flupg

services/auto_segmentor.py

@@ -0,0 +1,95 @@
+import os
+import uuid
+import subprocess
+import re
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+def get_least_used_gpu(default_gpu=None):
+    if default_gpu is None:
+        try:
+            available_gpus_str = os.getenv("AVAILABLE_GPUS", "")
+            available_gpus = [int(x) for x in available_gpus_str.split(",") if x.strip().isdigit()]
+            if not available_gpus:
+                raise ValueError("No available GPUs specified.")
+
+            result = subprocess.check_output(
+                ["nvidia-smi", "--query-gpu=memory.used", "--format=csv,noheader,nounits"],
+                universal_newlines=True
+            )
+            mem_usages = [int(x) for x in result.strip().split("\n")]
+            least_used_gpu = min(available_gpus, key=lambda i: mem_usages[i])
+            return str(least_used_gpu)
+        except Exception as e:
+            print("⚠️ Failed to get GPU info, defaulting to 0:", e)
+            return "0"
+    else:
+        return str(default_gpu)
+
+
+def run_auto_segmentation(input_path, session_dir, model):
+    """
+    Run auto segmentation model using Apptainer inside the given session directory.
+    """
+    subfolder_name = "ct"
+
+    input_case_dir = os.path.join(session_dir, "inputs")
+    outputs_root = os.path.join(session_dir, "outputs")
+    input_case_ct_dir = os.path.join(input_case_dir, subfolder_name)
+    os.makedirs(input_case_ct_dir, exist_ok=True)
+    os.makedirs(outputs_root, exist_ok=True)
+
+    input_filename = os.path.basename(input_path)
+    container_input_path = os.path.join(input_case_ct_dir, input_filename)
+    os.system(f"cp {input_path} {container_input_path}")
+
+    conda_activate_cmd = ""
+
+    conda_path = os.getenv("CONDA_ACTIVATE_PATH", "/opt/anaconda3/etc/profile.d/conda.sh")
+    epai_env_name = os.getenv("CONDA_ENV_EPAI", "epai")
+    suprem_sandbox_path = os.getenv("SUPREM_SANDBOX_PATH", "")
+    epai_script_path = os.getenv("EPAI_SCRIPT_PATH", "")
+
+    if model == 'SuPreM':
+        container_path = suprem_sandbox_path
+        print(input_case_dir, outputs_root)
+
+        apptainer_cmd = [
+            "apptainer", "run", "--nv",
+            "-B", f"{input_case_dir}:/workspace/inputs",
+            "-B", f"{outputs_root}:/workspace/outputs",
+            container_path
+        ]
+    elif model == 'ePAI':
+        conda_activate_cmd = f"source {conda_path} && conda activate {epai_env_name} &&"
+        apptainer_cmd = ["bash", epai_script_path, session_dir]
+    else:
+        print(f"[ERROR] Unknown model: {model}")
+        return None
+
+    selected_gpu = get_least_used_gpu()
+    apptainer_cmd = ["CUDA_VISIBLE_DEVICES=" + selected_gpu] + apptainer_cmd
+    print(apptainer_cmd)
+    try:
+        print(f"[INFO] Running {model} auto segmentation for file: {input_filename}")
+        full_cmd = f"{conda_activate_cmd} {' '.join(apptainer_cmd)}"
+        subprocess.run(full_cmd, shell=True, executable="/bin/bash", check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"[ERROR] {model} inference failed:", e)
+        return None
+
+    if model == 'SuPreM':
+        output_path = os.path.join(outputs_root, subfolder_name, "segmentations")
+        if not os.path.exists(output_path):
+            print("[ERROR] Output mask not found at:", output_path)
+            return None
+    elif model == 'ePAI':
+        output_path = os.path.join(outputs_root, subfolder_name, "combined_labels.nii.gz")
+        if not os.path.exists(output_path):
+            print("[ERROR] Output mask not found at:", output_path)
+            return None
+        output_path = os.path.join(outputs_root, subfolder_name)
+
+    return output_path

services/nifti_processor.py

@@ -0,0 +1,214 @@
+import nibabel as nib
+import numpy as np
+from constants import Constants
+from werkzeug.datastructures import MultiDict
+import scipy.ndimage as ndimage
+import os
+import tempfile
+from scipy.ndimage import label
+
+
+def has_large_connected_component(slice_mask, threshold=8):
+    """
+    Check if there is a connected component larger than a threshold in a 2D mask.
+    """
+    labeled, num_features = label(slice_mask)
+    sizes = np.bincount(labeled.ravel())
+    sizes[0] = 0  # ignore background
+    return np.any(sizes > threshold)
+
+
+class NiftiProcessor:
+    def __init__(self, main_nifti_path, clabel_path, organ_intensities=None):
+        self._main_nifti_path = main_nifti_path
+        self._clabel_path = clabel_path
+        self.number_max = 999999
+        self._organ_intensities = organ_intensities
+    
+    def set_organ_intensities(self, organ_intensities):
+        self._organ_intensities = organ_intensities
+
+    @classmethod
+    def from_clabel_path(cls, clabel_path):
+        return cls(None, clabel_path)
+    
+    def calculate_metrics(self):    
+        """
+        Calculate volume and mean HU for each organ based on the segmentation.
+        """
+        if self._organ_intensities is None or self._clabel_path is None or self._main_nifti_path is None:
+            raise Exception("Cannot calculate metrics if self._organ_intensities, self._clabel_path, or self._main_nifti_path is None.")  
+
+        data = {"organ_metrics": []}
+
+        clabel_obj = nib.load(self._clabel_path)
+        main_nifti_obj = nib.load(self._main_nifti_path)
+
+        clabel_array = np.around(clabel_obj.get_fdata())
+        clabel_header = clabel_obj.header
+        main_nifti_array = main_nifti_obj.get_fdata()
+
+        intensities, frequencies = np.unique(clabel_array, return_counts=True)
+        int_freq = {round(intensities[i]): int(frequencies[i]) for i in range(len(intensities))}
+
+        voxel_dims_mm = clabel_header.get_zooms()
+        voxel_volume_cm3 = np.prod(voxel_dims_mm) / 1000  # convert mm³ to cm³
+        for organ, label_val in self._organ_intensities.items():
+            binary_mask = (clabel_array == label_val)
+            slice_0 = binary_mask[:, :, 0]
+            slice_last = binary_mask[:, :, -1]
+
+            
+            if has_large_connected_component(slice_0, 8) or has_large_connected_component(slice_last, 8):
+                data["organ_metrics"].append({
+                    "organ_name": organ,
+                    "volume_cm3": self.number_max,
+                    "mean_hu": self.number_max
+                })
+                continue
+            if label_val in int_freq:
+                volume_cm3 = round(float(int_freq[label_val] * voxel_volume_cm3), Constants.DECIMAL_PRECISION_VOLUME)
+            else:
+                volume_cm3 = 0
+            mean_hu = self.calculate_mean_hu_with_erosion(binary_mask, main_nifti_array)
+
+            data["organ_metrics"].append({
+                "organ_name": organ,
+                "volume_cm3": volume_cm3,
+                "mean_hu": mean_hu
+            })
+
+        return data
+
+    def calculate_mean_hu_with_erosion(self, binary_mask, ct_array):
+        """
+        Calculate mean HU using erosion to avoid edge noise.
+        """
+        erosion_array = ndimage.binary_erosion(binary_mask, structure=Constants.STRUCTURING_ELEMENT)
+        hu_values = ct_array[erosion_array > 0]
+
+        if hu_values.size == 0:
+            hu_values = ct_array[binary_mask > 0]
+
+        if hu_values.size == 0:
+            return 0
+
+        return round(float(np.mean(hu_values)), Constants.DECIMAL_PRECISION_HU)
+
+    def combine_labels(self, filenames: list[str], nifti_multi_dict: MultiDict, save=True):
+        """
+        Merge multiple label masks into one combined segmentation and re-index the labels.
+        """
+        organ_intensities = {}
+
+        if len(filenames) == 1:
+            filename = filenames[0]
+            segmentation = nifti_multi_dict[filename]
+            data = segmentation.read()
+
+            with tempfile.NamedTemporaryFile(suffix='.nii.gz', delete=False) as temp:
+                temp.write(data)
+                temp.flush()
+                temp_path = temp.name
+
+            combined_labels = nib.load(temp_path)
+            
+            combined_labels_img_data = combined_labels.get_fdata().astype(np.uint8)
+
+            unique_labels = sorted([v for v in np.unique(combined_labels_img_data) if v != 0])
+            original_to_new = {}
+
+            for new_label, original_label in enumerate(unique_labels, start=1):
+                original_to_new[int(original_label)] = new_label
+                combined_labels_img_data[combined_labels_img_data == original_label] = new_label
+
+            for original_label, new_label in original_to_new.items():
+                organ_name = Constants.PREDEFINED_LABELS.get(original_label, f"label_{original_label}")
+                organ_intensities[organ_name] = new_label
+
+            combined_labels_header = combined_labels.header
+            combined_labels_affine = combined_labels.affine
+
+            combined_labels = nib.Nifti1Image(
+                combined_labels_img_data,
+                affine=combined_labels_affine,
+                header=combined_labels_header
+            )
+            
+
+        else:
+            combined_labels_img_data = None
+            combined_labels_header = None
+            combined_labels_affine = None
+
+            for i in range(len(filenames)):
+                filename = filenames[i]
+                segmentation = nifti_multi_dict[filename]
+                data = segmentation.read()
+
+                with tempfile.NamedTemporaryFile(suffix='.nii.gz', delete=True) as temp:
+                    temp.write(data)
+                    nifti_obj = nib.load(temp.name)
+
+                    if combined_labels_header is None:
+                        combined_labels_header = nifti_obj.header
+
+                    if combined_labels_img_data is None:
+                        combined_labels_img_data = np.ndarray(shape=nifti_obj.shape, dtype=np.float64)
+
+                    if combined_labels_affine is None:
+                        combined_labels_affine = nifti_obj.affine 
+
+                    img_data = nifti_obj.get_fdata()
+                    scaled = img_data * np.float64(i + 1)
+                    combined_labels_img_data = np.maximum(combined_labels_img_data, scaled)
+
+                    organ_intensities[filename] = i + 1
+
+            combined_labels = nib.nifti1.Nifti1Image(
+                dataobj=combined_labels_img_data,
+                affine=combined_labels_affine,
+                header=combined_labels_header
+            )
+
+        if save:
+            nib.save(combined_labels, self._clabel_path)
+
+        return combined_labels, organ_intensities
+
+    def __str__(self):
+        return f"NiftiProcessor Object\n main_nifti_path: {self._main_nifti_path}\n clabel_path: {self._clabel_path}"
+
+    def calculate_pdac_sma_staging(self):
+        """
+        Determine staging of pancreatic cancer based on SMA contact ratio.
+        """
+        if self._clabel_path is None:
+            raise Exception("clabel path is not set.")
+
+        clabel_obj = nib.load(self._clabel_path)
+        clabel_data = np.around(clabel_obj.get_fdata()).astype(np.uint8)
+
+        PDAC_LABEL = 20  # pancreatic_pdac
+        SMA_LABEL = 26   # superior_mesenteric_artery
+
+        pdac_mask = (clabel_data == PDAC_LABEL)
+        sma_mask = (clabel_data == SMA_LABEL)
+
+        if np.sum(pdac_mask) == 0:
+            return "Stage T1 (No PDAC tumor present)"
+        if np.sum(sma_mask) == 0:
+            return "Unknown (SMA not found)"
+
+        pdac_dilated = ndimage.binary_dilation(pdac_mask, structure=Constants.STRUCTURING_ELEMENT)
+        contact_voxels = pdac_dilated & sma_mask
+        contact_ratio = np.sum(contact_voxels) / np.sum(sma_mask)
+
+        if contact_ratio > 0.7:
+            return "Stage T4 (SMA encasement > 180°)"
+        elif contact_ratio > 0.3:
+            return "Stage T3 (SMA encasement ~90°–180°)"
+        elif contact_ratio > 0:
+            return "Stage T2 (SMA contact < 90°)"
+        else:
+            return "Stage T1 (No SMA contact)"

services/npz_processor.py

@@ -0,0 +1,229 @@
+import nibabel as nib
+import numpy as np
+from constants import Constants
+from werkzeug.datastructures import MultiDict
+import scipy.ndimage as ndimage
+import os, sys
+import tempfile
+from scipy.ndimage import label
+import pathlib
+from openpyxl import load_workbook
+import json
+
+def get_panTS_id(index):
+    cur_case_id = str(index)
+    iter = max(0, 8 - len(str(index)))
+    for _ in range(iter):
+        cur_case_id = "0" + cur_case_id
+    cur_case_id = "PanTS_" + cur_case_id    
+    return cur_case_id
+
+def has_large_connected_component(slice_mask, threshold=8):
+    """
+    Check if there is a connected component larger than a threshold in a 2D mask.
+    """
+    labeled, num_features = label(slice_mask)
+    sizes = np.bincount(labeled.ravel())
+    sizes[0] = 0  # ignore background
+    return np.any(sizes > threshold)
+
+
+class NpzProcessor:
+    def __init__(self, main_npz_path=None, clabel_path=None, organ_intensities=None):
+        self._main_nifti_path = main_npz_path
+        self._clabel_path = clabel_path
+        self.number_max = 999999
+        self._organ_intensities = organ_intensities
+    
+    def set_organ_intensities(self, organ_intensities):
+        self._organ_intensities = organ_intensities
+
+    @classmethod
+    def from_clabel_path(cls, clabel_path):
+        
+        return cls(None, clabel_path)
+    
+    # not used
+    def calculate_mean_hu_with_erosion(self, binary_mask, ct_array):
+        """
+        Calculate mean HU using erosion to avoid edge noise.
+        """
+        erosion_array = ndimage.binary_erosion(binary_mask, structure=Constants.STRUCTURING_ELEMENT)
+        hu_values = ct_array[erosion_array > 0]
+
+        if hu_values.size == 0:
+            hu_values = ct_array[binary_mask > 0]
+
+        if hu_values.size == 0:
+            return 0
+
+        return round(float(np.mean(hu_values)), Constants.DECIMAL_PRECISION_HU)
+    
+    
+    def npz_to_nifti(self, id: int, combined_label=True, save=True, path=None):
+        subfolder = "LabelTr" if id < 9000 else "LabelTe"
+        image_subfolder = "ImageTe" if id >= 9000 else "ImageTr"
+        
+        if combined_label and path is None:    
+            dir_path = pathlib.Path(f"{Constants.PANTS_PATH}/data/{subfolder}/{get_panTS_id(id)}/{Constants.COMBINED_LABELS_FILENAME}")
+        else:
+            dir_path = pathlib.Path(path)   
+            
+        nifti_path = pathlib.Path(f"{Constants.PANTS_PATH}/data/{image_subfolder}/{get_panTS_id(id)}/{Constants.MAIN_NIFTI_FILENAME}")
+        nifti_dat = nib.load(nifti_path)
+
+        arr = np.load(dir_path)["data"].astype(np.float32)
+        img = nib.nifti1.Nifti1Image(arr, affine=nifti_dat.affine, header=nifti_dat.header)
+
+        nib.save(img, dir_path.with_suffix(".nii.gz"))
+            
+            
+    def combine_labels(self, id: int, keywords={"pancrea": "pancreas"}, save=True):   
+        """
+        Merge multiple label masks into one combined segmentation and re-index the labels.
+        """
+        organ_intensities = {}
+        segment_subfolder = "LabelTr"
+        if id >= 9000:
+            segment_subfolder = "LabelTe"   
+        
+        image_subfolder = "ImageTe" if id >= 9000 else "ImageTr"
+            
+        nifti_path = pathlib.Path(f"{Constants.PANTS_PATH}/data/{image_subfolder}/{get_panTS_id(id)}/{Constants.MAIN_NIFTI_FILENAME}")
+        nifti_dat = nib.load(nifti_path)
+        
+        dir_path = pathlib.Path(f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/segmentations")
+        npz_files = list(dir_path.glob("*.npz"))
+        
+        combined_labels_img_data = None
+        keyword_dict = {organ: None for organ in keywords.values()}
+
+        for i, file in enumerate(npz_files):
+            filename = file.name
+            data = np.load(file)["data"]
+
+            if combined_labels_img_data is None:
+                combined_labels_img_data = np.ndarray(shape=data.shape, dtype=np.float64)
+                
+            matched = False
+            for substring, organ in keywords.items():
+                if substring in filename:
+                    if keyword_dict[organ] is None:
+                        keyword_dict[organ] = np.ndarray(shape=data.shape, dtype=np.float64)
+                    scaled = data * np.float64(i + 1)
+                    keyword_dict[organ] = np.maximum(keyword_dict[organ], scaled)
+                    combined_labels_img_data = np.maximum(combined_labels_img_data, scaled)
+                    organ_intensities[organ] = i + 1
+                    matched = True
+                    break
+            
+            if not matched:  # no keyword match, still add to combined
+                scaled = data * np.float64(i + 1)
+                combined_labels_img_data = np.maximum(combined_labels_img_data, scaled)
+                organ_intensities[filename] = i + 1
+
+        if save:
+            # save each organ-specific file
+            for organ, data in keyword_dict.items():
+                if data is not None:
+                    save_path = (
+                        f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/segmentations/{organ}.nii.gz"
+                    )
+                    img = nib.Nifti1Image(data, affine=nifti_dat.affine, header=nifti_dat.header)
+                    nib.save(img, save_path)
+            
+            # save combined labels
+            if combined_labels_img_data is not None:
+                save_path = (
+                    f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/{Constants.COMBINED_LABELS_FILENAME}"
+                )
+                np.savez_compressed(save_path, data=combined_labels_img_data)
+
+            # save organ intensities
+            organ_save_path = (
+                f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/{Constants.ORGAN_INTENSITIES_FILENAME}"
+            )
+            with open(organ_save_path, "w") as f:
+                json.dump(organ_intensities, f)
+
+        return combined_labels_img_data, organ_intensities
+
+    
+    def nifti_combine_labels(self, id: int, keywords: dict[str, str] = {"pancrea": "pancreas"}, save=True):
+        """
+        Merge multiple NIfTI label masks into one combined segmentation and re-index the labels.
+        """
+
+        organ_intensities = {}
+        segment_subfolder = "LabelTr" if id < 9000 else "LabelTe"
+        image_subfolder = "ImageTr" if id < 9000 else "ImageTe"
+
+        # load main reference image (for affine/header)
+        nifti_path = pathlib.Path(
+            f"{Constants.PANTS_PATH}/data/{image_subfolder}/{get_panTS_id(id)}/{Constants.MAIN_NIFTI_FILENAME}"
+        )
+        base_nifti = nib.load(nifti_path)
+
+        # folder containing NIfTI segmentations
+        dir_path = pathlib.Path(
+            f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/segmentations"
+        )
+        nii_files = list(dir_path.glob("*.nii*"))
+
+        if not nii_files:
+            raise FileNotFoundError(f"No NIfTI label files found in {dir_path}")
+
+        combined_labels = None
+        keyword_dict = {organ: None for organ in keywords.values()}
+
+        for i, file in enumerate(sorted(nii_files)):
+            filename = file.name
+            nii = nib.load(file)
+            data = nii.get_fdata()
+
+            if combined_labels is None:
+                combined_labels = np.zeros_like(data, dtype=np.float64)
+
+            matched = False
+            for substring, organ in keywords.items():
+                if substring.lower() in filename.lower():
+                    if keyword_dict[organ] is None:
+                        keyword_dict[organ] = np.zeros_like(data, dtype=np.float64)
+                    scaled = data * float(i + 1)
+                    keyword_dict[organ] = np.maximum(keyword_dict[organ], scaled)
+                    combined_labels = np.maximum(combined_labels, scaled)
+                    organ_intensities[organ] = i + 1
+                    matched = True
+                    break
+
+            if not matched:
+                scaled = data * float(i + 1)
+                combined_labels = np.maximum(combined_labels, scaled)
+                organ_intensities[filename] = i + 1
+
+        if save:
+            # save each organ-specific mask
+            for organ, data in keyword_dict.items():
+                if data is not None:
+                    save_path = (
+                        f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/segmentations/{organ}.nii.gz"
+                    )
+                    img = nib.Nifti1Image(data, affine=base_nifti.affine, header=base_nifti.header)
+                    nib.save(img, save_path)
+
+            # save combined mask as NIfTI
+            if combined_labels is not None:
+                save_path = (
+                    f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/{Constants.COMBINED_LABELS_NIFTI_FILENAME}"
+                )
+                img = nib.Nifti1Image(combined_labels, affine=base_nifti.affine, header=base_nifti.header)
+                nib.save(img, save_path)
+
+            # save organ intensity mapping
+            organ_save_path = (
+                f"{Constants.PANTS_PATH}/data/{segment_subfolder}/{get_panTS_id(id)}/{Constants.ORGAN_INTENSITIES_FILENAME}"
+            )
+            with open(organ_save_path, "w") as f:
+                json.dump(organ_intensities, f, indent=2)
+
+        return combined_labels, organ_intensities

services/session_manager.py

@@ -0,0 +1,176 @@
+from models.base import db
+from models.application_session import ApplicationSession
+from models.combined_labels import CombinedLabels
+from datetime import datetime, timedelta
+from constants import Constants
+import uuid
+import shutil
+import os
+
+def generate_uuid():
+    return str(uuid.uuid4())
+class SessionManager(object):
+    _instance = None
+
+    def __init__(self):
+        self.active_sessions = {}  # session_id -> ApplicationSession 映射表
+
+    @classmethod
+    def instance(cls):
+        if cls._instance is None:
+            print("Creating SessionManager Instance")
+            cls._instance = cls.__new__(cls)
+            cls._instance.__init__()  # ✅ 手动调用初始化
+        return cls._instance
+
+    def get_session(self, session_id):
+        """Get ApplicationSession instance by session_id"""
+        if session_id in self.active_sessions:
+            return self.active_sessions[session_id]
+
+        # 
+        stmt = db.select(ApplicationSession).where(ApplicationSession.session_id == session_id)
+        resp = db.session.execute(stmt)
+        session = resp.scalar()
+
+        if session is not None:
+            self.active_sessions[session_id] = session  # 
+        return session
+    
+    def register_session(self, session_id):
+        """
+        只注册 session_id，暂时不创建 ApplicationSession，等待后续信息完善。
+        """
+        self.active_sessions[session_id] = {
+            "registered": True,
+            "created_at": datetime.now()
+        }
+        print(f"[SessionManager] Registered new session_id (lazy mode): {session_id}")
+
+
+    def validate_session(self, session_id):
+        pass
+        
+    def validate_clabel(self, clabel_id):
+        pass
+        
+    def terminate_session(self, session_id):
+        
+        stmt = db.select(ApplicationSession).where(ApplicationSession.session_id == session_id)
+        resp = db.session.execute(stmt)
+        app_session = resp.scalar()
+        combined_labels_id = app_session.combined_labels_id
+
+        stmt = db.select(CombinedLabels).where(CombinedLabels.combined_labels_id == combined_labels_id)
+        resp = db.session.execute(stmt)
+        combined_labels = resp.scalar()
+
+        db.session.delete(app_session)
+        db.session.delete(combined_labels)
+        db.session.commit()
+    
+
+        try:
+            print(f'removing session: {session_id}')
+            shutil.rmtree(os.path.join(Constants.SESSIONS_DIR_NAME, session_id))
+            return True
+        except:
+            return False
+
+    def get_expired(self): #can only be used with app_context
+        print("sched check")
+        current_time = datetime.now()
+        stmt = db.select(ApplicationSession).where(ApplicationSession.session_expire_date <= current_time)
+        resp = db.session.execute(stmt)
+        return resp.scalars().all()
+    def update_session_info(self, session_id, main_nifti_path=None, combined_labels_id=None):
+        """
+        更新session信息，如果数据库不存在则创建新的ApplicationSession。
+        """
+        # 尝试先从数据库拿
+        stmt = db.select(ApplicationSession).where(ApplicationSession.session_id == session_id)
+        resp = db.session.execute(stmt)
+        session = resp.scalar()
+
+        if session is None:
+            # 数据库里没有，需要新建 ApplicationSession
+            if main_nifti_path is None:
+                raise ValueError(f"Cannot create ApplicationSession for {session_id} without main_nifti_path!")
+
+            created_at = datetime.now()
+            expire_at = created_at + timedelta(days=3)
+
+            session = ApplicationSession(
+                session_id=session_id,
+                main_nifti_path=main_nifti_path,
+                combined_labels_id=combined_labels_id,
+                session_created=created_at,
+                session_expire_date=expire_at
+            )
+
+            db.session.add(session)
+            print(f"[SessionManager] Created new ApplicationSession during update: {session_id}")
+        else:
+            # 数据库已有，直接update字段
+            if main_nifti_path is not None:
+                session.main_nifti_path = main_nifti_path
+            if combined_labels_id is not None:
+                session.combined_labels_id = combined_labels_id
+            print(f"[SessionManager] Updated existing ApplicationSession: {session_id}")
+
+        db.session.commit()
+        self.active_sessions[session_id] = session
+        return session
+
+    def bind_combined_labels_to_session(self, session_id, clabel_path, organ_intensities=None):
+        """
+        根据已经存在的combined_labels_id创建CombinedLabels记录。
+        必须保证ApplicationSession已经有了combined_labels_id。
+        """
+        # 拿到 session
+        session = self.get_session(session_id)
+        if session is None:
+            raise ValueError(f"Session {session_id} not found.")
+
+        # 检查session是否已经��combined_labels_id
+        combined_labels_id = session.combined_labels_id
+        if combined_labels_id is None:
+            raise ValueError(f"Session {session_id} does not have a combined_labels_id set yet.")
+
+        # 用已有的combined_labels_id创建CombinedLabels
+        new_clabel = CombinedLabels(
+            combined_labels_id=combined_labels_id,
+            combined_labels_path=clabel_path,
+            organ_intensities=organ_intensities or {},
+            organ_metadata={}
+        )
+
+        # 保存到数据库
+        db.session.add(new_clabel)
+        db.session.commit()
+
+        print(f"[SessionManager] Bound existing CombinedLabels ID {combined_labels_id} to session {session_id}")
+        return new_clabel
+
+
+def deprecated_register_session(self, session_id, expire_minutes=60*24*3):
+        """用已有的session_id创建并注册一个ApplicationSession到数据库和缓存"""
+        created_at = datetime.now()
+        expire_at = created_at + timedelta(minutes=expire_minutes)
+        combined_labels_id =None
+        main_nifti_path = None
+        new_session = ApplicationSession(
+            session_id=session_id,
+            main_nifti_path=main_nifti_path,
+            combined_labels_id=combined_labels_id,
+            session_created=created_at,
+            session_expire_date=expire_at,
+        )
+
+        db.session.add(new_session)
+        db.session.commit()
+
+        self.active_sessions[session_id] = new_session
+
+        print(f"[SessionManager] Registered new session: {session_id}")
+        return new_session

tests/unit/test_app_session_model.py

@@ -0,0 +1,132 @@
+import unittest
+from models.application_session import ApplicationSession
+from models.base import db
+from services.session_manager import SessionManager
+from app import create_app
+from psycopg2.errors import UniqueViolation
+from datetime import datetime, timedelta
+
+
+class TestApplicationSessionModel(unittest.TestCase):
+
+    def setUp(self):
+        self.db = db
+        self.app = create_app()
+        self.app_context = self.app.app_context()
+        self.app_context.push()
+        self.session_manager = SessionManager.instance()
+        self.main_nifti_path='test-sessions/test-045'
+        self.combined_labels_id=self.session_manager.generate_uuid()
+
+        db.create_all()
+    
+    def tearDown(self):
+        self.db.session.remove()
+        self.app_context.pop()
+
+
+    def test_insert_into_table(self):
+        session_key = self.session_manager.generate_uuid()
+        now = datetime.now()
+        expire = now + timedelta(days=3)
+        new_session = ApplicationSession(
+            session_id=session_key,
+            main_nifti_path=self.main_nifti_path,
+            combined_labels_id=self.combined_labels_id,
+            session_created=now,
+            session_expire_date = expire, 
+        )
+        db.session.add(new_session)
+        db.session.commit()
+
+        stmt = db.select(ApplicationSession).where(ApplicationSession.session_id == session_key)
+        res = db.session.execute(stmt)
+        app_session = res.scalar()
+        
+        self.assertEqual(app_session.session_id, session_key)
+        self.assertEqual(app_session.main_nifti_path, self.main_nifti_path)
+        self.assertEqual(app_session.combined_labels_id, self.combined_labels_id)
+        self.assertEqual(app_session.session_created, now)
+        self.assertEqual(app_session.session_expire_date, expire)
+
+        #cleanup from DB
+        db.session.delete(app_session)
+        db.session.commit()
+    
+    def test_duplicate_session_id(self):
+        now = datetime.now()
+        session_key = self.session_manager.generate_uuid()
+        new_session = ApplicationSession(
+            session_id=session_key,
+            main_nifti_path=self.main_nifti_path,
+            combined_labels_id=self.combined_labels_id,
+            session_created=now,
+            session_expire_date = now + timedelta(days=3)
+        ) 
+
+        db.session.add(new_session)
+        db.session.commit()
+
+        now = datetime.now()
+        dup_key_session = ApplicationSession(
+            session_id=session_key, #same session_id as new_session
+            main_nifti_path="test/path",
+            combined_labels_id="unique_combined_labels_id",
+            session_created=now,
+            session_expire_date = now + timedelta(days=3)
+        ) 
+        
+        with self.assertRaises(UniqueViolation):
+
+            try:
+                db.session.add(dup_key_session)
+                db.session.commit()
+            except:
+                raise UniqueViolation
+        
+        db.session.rollback()
+        db.session.delete(new_session)
+        db.session.commit()
+    
+    def test_duplicate_combined_labels_id(self):
+        now = datetime.now()
+        session_key = self.session_manager.generate_uuid()
+        new_session = ApplicationSession(
+            session_id=session_key,
+            main_nifti_path=self.main_nifti_path,
+            combined_labels_id=self.combined_labels_id,
+            session_created=now,
+            session_expire_date = now + timedelta(days=3), 
+        ) 
+
+        db.session.add(new_session)
+        db.session.commit()
+
+        session_key2 = self.session_manager.generate_uuid()
+
+        now = datetime.now()
+        session_2 = ApplicationSession(
+            session_id=session_key,
+            main_nifti_path=self.main_nifti_path,
+            combined_labels_id=self.combined_labels_id, #same as new_session
+            session_created=now,
+            session_expire_date = now + timedelta(days=3), 
+        )
+    
+        with self.assertRaises(UniqueViolation):
+            try:
+                db.session.add(session_2)
+                db.session.commit()
+            except:
+                raise UniqueViolation
+        
+        db.session.rollback()
+        db.session.delete(new_session)
+        db.session.commit()
+ 
+                
+                
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/test_combined_labels.py

@@ -0,0 +1,77 @@
+import unittest
+from models.combined_labels import CombinedLabels
+from app import create_app
+from services.session_manager import SessionManager
+from psycopg2.errors import UniqueViolation
+from models.base import db
+
+class TestCombinedLabels(unittest.TestCase):
+
+    def setUp(self):
+        self.app = create_app()
+        self.app_context = self.app.app_context()
+        self.app_context.push()
+        self.session_manager = SessionManager.instance()
+        db.create_all()
+
+        self.combined_labels_id = self.session_manager.generate_uuid()
+        self.combined_labels_path = "session_id/combined_labels.nii.gz"
+        self.organ_intensities = {"aorta": 1}
+        self.organ_metadata = {"aorta": {"meanHU": 30, "volume": 25}}
+    
+
+    def test_insert_combined_labels(self):
+        combined_labels  = CombinedLabels(
+            combined_labels_id = self.combined_labels_id,
+            combined_labels_path = self.combined_labels_path,
+            organ_intensities = self.organ_intensities,
+            organ_metadata = self.organ_metadata
+        )
+
+
+        db.session.add(combined_labels)
+        db.session.commit()
+
+        stmt = db.select(CombinedLabels).where(CombinedLabels.combined_labels_id == self.combined_labels_id)
+        resp = db.session.execute(stmt)
+        clabel = resp.scalar()
+
+        self.assertEqual(clabel.combined_labels_id, self.combined_labels_id)
+        self.assertEqual(clabel.combined_labels_path, self.combined_labels_path)
+        self.assertEqual(clabel.organ_intensities, self.organ_intensities)
+        self.assertEqual(clabel.organ_metadata, self.organ_metadata)
+
+        db.session.delete(clabel)
+        db.session.commit()
+    
+    def test_duplicated_unique_id(self):
+        combined_labels  = CombinedLabels(
+            combined_labels_id = self.combined_labels_id,
+            combined_labels_path = self.combined_labels_path,
+            organ_intensities = self.organ_intensities,
+            organ_metadata = self.organ_metadata
+        )
+
+        db.session.add(combined_labels)
+        db.session.commit()
+
+        new_clabel = CombinedLabels(
+            combined_labels_id = self.combined_labels_id,
+            combined_labels_path = "path",
+            organ_intensities = {},
+            organ_metadata = {} 
+        )
+
+        with self.assertRaises(UniqueViolation):
+            try:
+                db.session.add(new_clabel)
+                db.session.commit()
+            except:
+                raise UniqueViolation
+
+        db.session.rollback()
+        db.session.delete(combined_labels)
+        db.session.commit() 
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/test_nifti_combine.py

@@ -0,0 +1,156 @@
+import unittest
+import os
+import nibabel as nib
+import numpy as np
+import io
+
+from app import create_app
+from services.nifti_processor import NiftiProcessor
+from werkzeug.datastructures import MultiDict, FileStorage
+
+
+"""
+Each test session has 
+
+    ct.nii.gz 
+        - Main nifti/CT Scan file
+
+    /combined_labels_ANS/combined_labels.nii.gz
+        - segmentation files combined into one (TESTING CREATED ONE AGAINST THIS ONE)
+
+    /combined_labels.nii.gz 
+        - segmentation file that NiftiProcessor will create and store here (FILE THAT NEEDS TO BE TESTED)
+
+    /segmentations - Directory containing 9 nifti segmentation files, which are:
+        - aorta.nii.gz
+        - gall_bladder.nii.gz
+        - kidney_left.nii.gz
+        - kidney_right.nii.gz
+        - liver.nii.gz
+        - pancreas.nii.gz
+        - postcava.nii.gz
+        - spleen.nii.gz
+        - stomach.nii.gz
+
+    test-045:
+        ct.nii.gz ~ 17 mb
+        combined_labels ~ 151kb
+    
+    test-050
+        ct.nii.gz ~ 13mb
+        combined_labels ~ 116kb
+
+    test-338
+        ct.nii.gz ~ 16mb
+        combined_labels ~ 204kb
+"""
+def create_nifti_multi_dict(seg_filenames: list[str], segmentation_path: str):
+    
+    nifti_multi_dict = MultiDict()
+    for filename in seg_filenames:
+        path = os.path.join(segmentation_path, filename)
+        
+        with open(path, 'rb') as file_stream:
+            file_storage = FileStorage(stream=io.BytesIO(file_stream.read()), filename=filename, content_type='application/gzip')
+            nifti_multi_dict.add(key=filename, value=file_storage)
+    
+    return nifti_multi_dict
+
+
+class TestNiftiProcessorFunctions(unittest.TestCase):
+
+    def setUp(self):
+        self.test_case: str = ''
+        self.combined_labels_ANS: nib.nifti1.Nifti1Image = None
+        self.organ_intensities_ANS: dict = {'aorta.nii.gz': 1, 'spleen.nii.gz': 2, 
+                                            'pancreas.nii.gz': 3, 'kidney_left.nii.gz': 4, 
+                                            'postcava.nii.gz': 5, 'gall_bladder.nii.gz': 6, 
+                                            'liver.nii.gz': 7, 'stomach.nii.gz': 8, 
+                                            'kidney_right.nii.gz': 9}
+
+    def tearDown(self):
+        self.test_case = ''
+        self.combined_labels_ANS = None
+
+    def test_case_045(self):
+        print('test case 045')
+        self.test_case = 'test-045'
+        session_path = os.path.join('test-sessions', self.test_case)
+        self.combined_labels_ANS = nib.load(os.path.join(session_path, 'combined_labels_ANS', 'combined_labels.nii.gz'))
+        segmentation_path = os.path.join(session_path, 'segmentations')
+        seg_filenames = os.listdir(segmentation_path)
+
+        nifti_multi_dict = create_nifti_multi_dict(seg_filenames, segmentation_path)
+
+        nifti_processor = NiftiProcessor(main_nifti_path=None, clabel_path=os.path.join(session_path, 'combined_labels.nii.gz'))
+        combined_labels, organ_intensities = nifti_processor.combine_labels(seg_filenames, nifti_multi_dict, save=False)
+
+        differences = combined_labels.get_fdata() == self.combined_labels_ANS.get_fdata()
+        error_voxels = len(differences[differences == False])
+        dims = combined_labels.shape
+        total_voxels = dims[0] * dims[1] * dims[2]
+        error_percent = error_voxels / total_voxels
+        print(f'Number of Inaccurate Voxels: {error_voxels} Total Voxels: {total_voxels}')
+        print(f'Accuracy: {1 - error_percent}')
+        self.assertEqual(combined_labels.header, self.combined_labels_ANS.header)
+        self.assertEqual(organ_intensities, self.organ_intensities_ANS)
+
+
+        print(np.unique(combined_labels.get_fdata()))
+        
+
+    def test_case_050(self):
+        print("test_case_050")
+        self.test_case = 'test-050'
+        session_path = os.path.join('test-sessions', self.test_case)
+        self.combined_labels_ANS = nib.load(os.path.join(session_path, 'combined_labels_ANS', 'combined_labels.nii.gz'))
+        segmentation_path = os.path.join(session_path, 'segmentations')
+        seg_filenames = os.listdir(segmentation_path)
+
+        nifti_multi_dict = create_nifti_multi_dict(seg_filenames, segmentation_path)
+
+        nifti_processor = NiftiProcessor(main_nifti_path=None, clabel_path=os.path.join(session_path, 'combined_labels.nii.gz'))
+        combined_labels, organ_intensities = nifti_processor.combine_labels(seg_filenames, nifti_multi_dict, save=False)
+        # print(combined_labels)
+
+        differences = combined_labels.get_fdata() == self.combined_labels_ANS.get_fdata()
+        error_voxels = len(differences[differences == False])
+        dims = combined_labels.shape
+        total_voxels = dims[0] * dims[1] * dims[2]
+        error_percent = error_voxels / total_voxels
+        print(f'Number of Inaccurate Voxels: {error_voxels} Total Voxels: {total_voxels}')
+        print(f'Accuracy: {1 - error_percent}')
+        self.assertEqual(combined_labels.header, self.combined_labels_ANS.header)
+        self.assertEqual(organ_intensities, self.organ_intensities_ANS)
+
+        print(np.unique(combined_labels.get_fdata()))
+
+    def test_case_0338(self):
+        print("test_case_338")
+        self.test_case = 'test-338'
+        session_path = os.path.join('test-sessions', self.test_case)
+        self.combined_labels_ANS = nib.load(os.path.join(session_path, 'combined_labels_ANS', 'combined_labels.nii.gz'))
+        segmentation_path = os.path.join(session_path, 'segmentations')
+        seg_filenames = os.listdir(segmentation_path)
+
+        nifti_multi_dict = create_nifti_multi_dict(seg_filenames, segmentation_path)
+
+        nifti_processor = NiftiProcessor(main_nifti_path=None, clabel_path=os.path.join(session_path, 'combined_labels.nii.gz'))
+        combined_labels, organ_intensities = nifti_processor.combine_labels(seg_filenames, nifti_multi_dict, save=False)
+        # print(combined_labels)
+
+        differences = combined_labels.get_fdata() == self.combined_labels_ANS.get_fdata()
+        error_voxels = len(differences[differences == False])
+        dims = combined_labels.shape
+        total_voxels = dims[0] * dims[1] * dims[2]
+        error_percent = error_voxels / total_voxels
+        print(f'Number of Inaccurate Voxels: {error_voxels} Total Voxels: {total_voxels}')
+        print(f'Accuracy: {1 - error_percent}')
+        self.assertEqual(combined_labels.header, self.combined_labels_ANS.header)
+        self.assertEqual(organ_intensities, self.organ_intensities_ANS)
+
+        print(np.unique(combined_labels.get_fdata()))
+        
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/test_nifti_processing.py

@@ -0,0 +1,111 @@
+import unittest
+from services.nifti_processor import NiftiProcessor
+
+"""
+Each test session has 
+
+    ct.nii.gz 
+        - Main nifti/CT Scan file
+
+    /combined_labels_ANS/combined_labels.nii.gz
+        - segmentation files combined into one (TESTING CREATED ONE AGAINST THIS ONE)
+
+    /combined_labels.nii.gz 
+        - segmentation file that NiftiProcessor will create and store here (FILE THAT NEEDS TO BE TESTED)
+
+    /segmentations - Directory containing 9 nifti segmentation files, which are:
+        - aorta.nii.gz
+        - gall_bladder.nii.gz
+        - kidney_left.nii.gz
+        - kidney_right.nii.gz
+        - liver.nii.gz
+        - pancreas.nii.gz
+        - postcava.nii.gz
+        - spleen.nii.gz
+        - stomach.nii.gz
+
+    test-045:
+        ct.nii.gz ~ 17 mb
+        combined_labels ~ 151kb
+    
+    test-050
+        ct.nii.gz ~ 13mb
+        combined_labels ~ 116kb
+
+    test-338
+        ct.nii.gz ~ 16mb
+        combined_labels ~ 204kb
+    
+        
+    organ_intensities =  {
+    aorta: 1,
+    gall_bladder: 2,
+    kidney_left: 3,
+    kidney_right: 4,
+    liver: 5,
+    pancreas: 6,
+    postcava: 7, 
+    spleen: 8, 
+    stomach: 9
+    }
+"""
+
+
+
+class TestNiftiProcessing(unittest.TestCase):
+
+    def setUp(self):
+        self.clabel_path = None #overload this
+        self.main_nifti_path = None # overload this
+
+        self.organ_intensities = {"aorta": 1, 
+                                  "gall_bladder": 2, 
+                                  "kidney_left": 3, 
+                                  "kidney_right": 4, 
+                                  "liver": 5, 
+                                  "pancreas": 6, 
+                                  "postcava": 7,  
+                                  "spleen": 8,  
+                                  "stomach": 9 }
+    
+
+    def test_case_045(self):
+        print("testcase 045")
+        self.clabel_path = "./test-sessions/test-045/combined_labels_ANS/combined_labels.nii.gz"
+        self.main_nifti_path = "./test-sessions/test-045/ct.nii.gz"
+        nifti_processor = NiftiProcessor(self.main_nifti_path, self.clabel_path)
+        nifti_processor.set_organ_intensities(self.organ_intensities)
+        #print(nip._organ_intensities)
+        organ_metrics = nifti_processor.calculate_metrics()
+
+        self.assertNotEqual(organ_metrics, None)
+    
+
+    def test_case_050(self):
+        print("testcase 050")
+        self.clabel_path = "./test-sessions/test-050/combined_labels_ANS/combined_labels.nii.gz"
+        self.main_nifti_path = "./test-sessions/test-050/ct.nii.gz"
+
+        nifti_processor = NiftiProcessor(self.main_nifti_path, self.clabel_path)
+        nifti_processor.set_organ_intensities(self.organ_intensities)
+        #print(nip._organ_intensities)
+        organ_metrics = nifti_processor.calculate_metrics()
+
+        self.assertNotEqual(organ_metrics, None)
+    
+ 
+    def test_case_338(self):
+        print("testcase 338")
+        self.clabel_path = "./test-sessions/test-050/combined_labels_ANS/combined_labels.nii.gz"
+        self.main_nifti_path = "./test-sessions/test-050/ct.nii.gz"
+
+
+
+        nifti_processor = NiftiProcessor(self.main_nifti_path, self.clabel_path)
+        nifti_processor.set_organ_intensities(self.organ_intensities)
+        #print(nip._organ_intensities)
+        organ_metrics = nifti_processor.calculate_metrics()
+
+        self.assertNotEqual(organ_metrics, None)
+    
+ 

tests/unit/test_scheduled_check.py

@@ -0,0 +1,58 @@
+import unittest
+from models.base import db
+from models.application_session import ApplicationSession
+from models.combined_labels import CombinedLabels
+from services.session_manager import SessionManager
+from app import app
+from datetime import datetime
+
+
+class TestScheduledCheck(unittest.TestCase):
+
+    def setUp(self):
+        self.app = app
+        self.app_context = app.app_context()
+        self.app_context.push()
+    
+
+    def test_scheduled_check(self):
+        session_manager = SessionManager.instance()
+
+        clabel_id = session_manager.generate_uuid()
+        app_session = ApplicationSession(
+            session_id = session_manager.generate_uuid(),
+            main_nifti_path = "path", 
+            combined_labels_id = clabel_id, 
+            session_created = datetime(2025, 1, 7),
+            session_expire_date = datetime(2025, 1, 12)
+        )
+
+        clabel = CombinedLabels(
+            combined_labels_id = clabel_id, 
+            combined_labels_path = "path",
+            organ_intensities = {},
+            organ_metadata = {}
+        )
+
+        db.session.add(app_session)
+        db.session.add(clabel)
+        db.session.commit()
+
+        expired = session_manager.get_expired()
+
+        for app_session in expired:
+            print(app_session.session_id)
+            print(session_manager.terminate_session(app_session.session_id))
+        
+        self.assertEqual(4, 4)
+    
+    
+
+
+
+
+
+
+
+if __name__ == "__main__":
+    unittest.main()

utils.py

@@ -0,0 +1,14 @@
+
+
+class Utils:
+    @classmethod
+    def removeFileExt(cls, filename):
+        return filename[:filename.index('.')]
+
+
+
+#from services.session_manager import SessionManager
+
+#s = SessionManager.instance()
+#uuid = str(s.generate_session_key())
+#print(uuid, type(uuid))