ctbodycomp 0.1.1__py3-none-any.whl

ctbodycomp/__init__.py

@@ -0,0 +1,9 @@
+"""CT body composition: select base features, then normalize morphometry."""
+from .extractor import BodyCompositionExtractor
+from .normalization import FeatureNormalizer
+from .definitions import get_feature_catalog
+from .normalized_composite import NormalizedCompositeCalculator, get_normalized_composite_catalog
+
+__version__ = "0.1.1"
+__all__ = ["BodyCompositionExtractor", "FeatureNormalizer", "get_feature_catalog",
+           "NormalizedCompositeCalculator", "get_normalized_composite_catalog"]

ctbodycomp/batch.py

@@ -0,0 +1,132 @@
+"""Separate CSV workflows for extraction and normalization."""
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+
+def read_csv(path):
+    return pd.read_csv(path, dtype=str, keep_default_na=False, encoding="utf-8-sig")
+
+
+def resolve_path(value, directory):
+    path = Path(value.strip()).expanduser()
+    return path if path.is_absolute() else directory / path
+
+
+def protect_output(input_csv, output_csv, paths=()):
+    output = Path(output_csv).resolve()
+    if output == Path(input_csv).resolve() or any(output == Path(path).resolve() for path in paths):
+        raise ValueError("输出不能覆盖输入CSV、影像或mask")
+
+
+def validate_new_columns(frame, columns):
+    overlap = set(frame.columns).intersection(columns)
+    if overlap:
+        raise ValueError(f"输入列与结果列重名，请更名后重试：{sorted(overlap)}")
+
+
+def extract_csv(input_csv, output_csv, extractor):
+    frame = read_csv(input_csv)
+    if not {"Image", "Mask"}.issubset(frame.columns):
+        raise ValueError("提取CSV必须包含Image、Mask列，可选SpineMask和ID列")
+    directory = Path(input_csv).resolve().parent
+    image_paths = [resolve_path(value, directory) for column in ("Image", "Mask", "SpineMask")
+                   if column in frame for value in frame[column] if value.strip()]
+    protect_output(input_csv, output_csv, image_paths)
+    names = extractor.get_feature_names()
+    extra = ["diagnostics_scope", "diagnostics_slices", "extraction_status", "extraction_error"]
+    validate_new_columns(frame, names + extra)
+    rows = []
+    for source in frame.to_dict(orient="records"):
+        row = {**source, **dict.fromkeys(names, np.nan), **dict.fromkeys(extra, "")}
+        try:
+            if not source["Image"].strip() or not source["Mask"].strip():
+                raise ValueError("Image和Mask不能为空")
+            spine = source.get("SpineMask", "").strip()
+            row.update(extractor.execute(resolve_path(source["Image"], directory),
+                                         resolve_path(source["Mask"], directory),
+                                         resolve_path(spine, directory) if spine else None))
+            row.update(diagnostics_scope=extractor.last_diagnostics["scope"],
+                       diagnostics_slices=json.dumps(extractor.last_diagnostics["selected_slices"]),
+                       extraction_status="success")
+        except Exception as error:
+            row.update(extraction_status="failed", extraction_error=str(error))
+        rows.append(row)
+    result = pd.DataFrame(rows, columns=list(frame.columns) + names + extra)
+    result.to_csv(output_csv, index=False, encoding="utf-8-sig")
+    return result
+
+
+def normalize_csv(input_csv, output_csv, normalizer, height_cm=None, weight_kg=None, bsa_m2=None):
+    frame = read_csv(input_csv)
+    directory = Path(input_csv).resolve().parent
+    image_paths = [resolve_path(value, directory) for column in ("Image", "Mask", "SpineMask")
+                   if column in frame for value in frame[column] if value.strip()]
+    protect_output(input_csv, output_csv, image_paths)
+    shape_columns = [column for column in frame if column.startswith("morphometry_")]
+    mean_columns = ([column for column in frame if column.startswith("firstorder_") and column.endswith("_Mean")]
+                    if normalizer.include_composite else [])
+    names = normalizer.get_feature_names(dict.fromkeys(shape_columns, np.nan))
+    extra = ["normalization_status", "normalization_error", "normalization_bsa_source"]
+    validate_new_columns(frame, names + extra)
+    defaults = {"Height_cm": height_cm, "Weight_kg": weight_kg, "BSA_m2": bsa_m2}
+    rows = []
+    for source in frame.to_dict(orient="records"):
+        row = {**source, **dict.fromkeys(names, np.nan), **dict.fromkeys(extra, "")}
+        try:
+            if source.get("extraction_status") == "failed":
+                raise ValueError("该病例基础提取失败，不能校正")
+            needed_means = {f"firstorder_{t}_Mean" for t in normalizer._targets(dict.fromkeys(shape_columns))}
+            selected_means = [key for key in mean_columns if key in needed_means]
+            features = {key: float(source[key]) if source[key].strip() else np.nan
+                        for key in shape_columns + selected_means}
+            subject = {key: source.get(key, "").strip() or value for key, value in defaults.items()}
+            row.update(normalizer.execute(features, height_cm=subject["Height_cm"],
+                                          weight_kg=subject["Weight_kg"], bsa_m2=subject["BSA_m2"]))
+            row.update(normalization_status="success",
+                       normalization_bsa_source=normalizer.last_diagnostics["bsa_source"] or "")
+        except Exception as error:
+            row.update(normalization_status="failed", normalization_error=str(error))
+        rows.append(row)
+    result = pd.DataFrame(rows, columns=list(frame.columns) + names + extra)
+    result.to_csv(output_csv, index=False, encoding="utf-8-sig")
+    return result
+
+
+def normalized_composite_csv(input_csv, output_csv, calculator):
+    """Read a normalized CSV with mean-HU columns; preserve all previous results."""
+    frame = read_csv(input_csv)
+    directory = Path(input_csv).resolve().parent
+    image_paths = [resolve_path(value, directory) for column in ("Image", "Mask", "SpineMask")
+                   if column in frame for value in frame[column] if value.strip()]
+    protect_output(input_csv, output_csv, image_paths)
+    index_columns = [column for column in frame if column.startswith("normalization_") and
+                     column not in ("normalization_status", "normalization_error", "normalization_bsa_source")]
+    mean_columns = [column for column in frame if column.startswith("firstorder_") and column.endswith("_Mean")]
+    names = calculator.get_feature_names(dict.fromkeys(index_columns, np.nan))
+    selected_names = set(names)
+    dependencies = [metadata for methods in calculator.catalog.values() for metadata in methods.values()
+                    if metadata["key"] in selected_names]
+    index_columns = list(dict.fromkeys(metadata["index_key"] for metadata in dependencies))
+    needed_means = {metadata["mean_key"] for metadata in dependencies}
+    mean_columns = [column for column in mean_columns if column in needed_means]
+    extra = ["normalized_composite_status", "normalized_composite_error"]
+    validate_new_columns(frame, names + extra)
+    rows = []
+    for source in frame.to_dict(orient="records"):
+        row = {**source, **dict.fromkeys(names, np.nan), **dict.fromkeys(extra, "")}
+        try:
+            if source.get("extraction_status") == "failed" or source.get("normalization_status") == "failed":
+                raise ValueError("该病例基础提取或校正失败，不能计算校正复合特征")
+            indices = {key: float(source[key]) if source[key].strip() else np.nan for key in index_columns}
+            means = {key: float(source[key]) if source[key].strip() else np.nan for key in mean_columns}
+            row.update(calculator.execute(indices, means))
+            row["normalized_composite_status"] = "success"
+        except Exception as error:
+            row.update(normalized_composite_status="failed", normalized_composite_error=str(error))
+        rows.append(row)
+    result = pd.DataFrame(rows, columns=list(frame.columns) + names + extra)
+    result.to_csv(output_csv, index=False, encoding="utf-8-sig")
+    return result

ctbodycomp/cli.py

@@ -0,0 +1,72 @@
+import argparse
+import json
+from pathlib import Path
+
+from .batch import extract_csv, normalize_csv, normalized_composite_csv
+from .definitions import get_feature_catalog
+from .extractor import BodyCompositionExtractor
+from .normalization import FeatureNormalizer, METHODS
+from .normalized_composite import NormalizedCompositeCalculator, get_normalized_composite_catalog
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description="CT体成分：选择基础特征提取，再独立校正")
+    commands = parser.add_subparsers(dest="command", required=True)
+    listing = commands.add_parser("features", help="列出四类可选基础特征及单位")
+    listing.add_argument("--mode", choices=["2D", "3D"], default="3D")
+    listing.add_argument("--normalized-composite", action="store_true", help="列出可选校正复合特征及其依赖")
+    extract = commands.add_parser("extract", help="提取所选基础特征")
+    extract.add_argument("input_csv")
+    extract.add_argument("output_csv")
+    extract.add_argument("--mode", choices=["2D", "3D"], default="3D")
+    extract.add_argument("--label", type=int, help="2D有SpineMask时需要单个标签")
+    extract.add_argument("--spine-range", type=int, nargs=2, default=[7, 18])
+    extract.add_argument("--config", help="JSON文件，内容为类别到特征列表的映射；[]表示该类全部")
+    normalize = commands.add_parser("normalize", help="对已提取的第一类形态指标进行校正")
+    normalize.add_argument("input_csv")
+    normalize.add_argument("output_csv")
+    normalize.add_argument("--mode", choices=["2D", "3D"], default="3D")
+    normalize.add_argument("--methods", nargs="+", choices=METHODS, required=True)
+    normalize.add_argument("--tissues", nargs="+")
+    normalize.add_argument("--height-cm", type=float)
+    normalize.add_argument("--weight-kg", type=float)
+    normalize.add_argument("--bsa-m2", type=float)
+    normalize.add_argument("--include-composite", action="store_true", help="同时输出校正指数×同组织Mean，与校正指数相邻排列")
+    composite = commands.add_parser("normalized-composite", help="校正指数乘同组织平均HU，不重新读取影像")
+    composite.add_argument("input_csv", help="包含校正指数和firstorder_*_Mean列的CSV")
+    composite.add_argument("output_csv")
+    composite.add_argument("--mode", choices=["2D", "3D"], default="3D")
+    composite.add_argument("--methods", nargs="+", choices=METHODS, required=True)
+    composite.add_argument("--tissues", nargs="+")
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "features":
+            catalog = (get_normalized_composite_catalog(args.mode) if args.normalized_composite
+                       else get_feature_catalog(args.mode))
+            print(json.dumps(catalog, ensure_ascii=False, indent=2))
+            return 0
+        if args.command == "extract":
+            config = json.loads(Path(args.config).read_text(encoding="utf-8")) if args.config else None
+            extractor = BodyCompositionExtractor(args.mode, features=config, spine_label=args.label,
+                                                  spine_range=args.spine_range)
+            result = extract_csv(args.input_csv, args.output_csv, extractor)
+            status = "extraction_status"
+        elif args.command == "normalize":
+            normalizer = FeatureNormalizer(args.mode, methods=args.methods, tissues=args.tissues,
+                                           include_composite=args.include_composite)
+            result = normalize_csv(args.input_csv, args.output_csv, normalizer, args.height_cm,
+                                   args.weight_kg, args.bsa_m2)
+            status = "normalization_status"
+        else:
+            calculator = NormalizedCompositeCalculator(args.mode, methods=args.methods, tissues=args.tissues)
+            result = normalized_composite_csv(args.input_csv, args.output_csv, calculator)
+            status = "normalized_composite_status"
+        failures = int((result[status] == "failed").sum())
+        print(f"已输出{len(result)}个病例，失败{failures}个：{args.output_csv}")
+        return 1 if failures else 0
+    except (ValueError, TypeError, OSError) as error:
+        parser.error(str(error))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

ctbodycomp/definitions.py

@@ -0,0 +1,61 @@
+"""Feature definitions shared by 2D and 3D extraction."""
+
+TISSUES = {
+    "SM": ("骨骼肌", (1,)), "SF": ("皮下脂肪", (4,)),
+    "IMF": ("肌间脂肪", (2,)), "VF": ("其余内脏脂肪", (3,)),
+    "PVAT": ("血管周围脂肪", (6,)), "EAT": ("心外膜脂肪", (7,)),
+    "AorticPVAT": ("主动脉周围脂肪", (8,)), "Bone": ("骨", (5,)),
+    "CVF": ("心血管相关脂肪", (6, 7, 8)),
+    "VF_total": ("总内脏脂肪", (3, 6, 7, 8)),
+    "TF": ("总脂肪", (2, 3, 4, 6, 7, 8)),
+}
+STATISTICS = ("Mean", "SD", "P10", "P50", "P90", "IQR")
+COMPOSITION = {
+    "SF_to_SM": ("皮下脂肪与肌肉比", "SF", ("SM",)),
+    "VF_total_to_SM": ("总内脏脂肪与肌肉比", "VF_total", ("SM",)),
+    "TF_to_SM": ("总脂肪与肌肉比", "TF", ("SM",)),
+    "VF_total_to_SF": ("总内脏脂肪与皮下脂肪比", "VF_total", ("SF",)),
+    "MFF": ("肌间脂肪占比", "IMF", ("SM", "IMF")),
+    "SF_fraction": ("皮下脂肪占总脂肪比例", "SF", ("TF",)),
+    "IMF_fraction": ("肌间脂肪占总脂肪比例", "IMF", ("TF",)),
+    "VF_fraction": ("总内脏脂肪占总脂肪比例", "VF_total", ("TF",)),
+    "VF_fraction_of_VF_total": ("其余内脏脂肪占总内脏脂肪比例", "VF", ("VF_total",)),
+    "PVAT_fraction_of_VF_total": ("血管周围脂肪占总内脏脂肪比例", "PVAT", ("VF_total",)),
+    "EAT_fraction_of_VF_total": ("心外膜脂肪占总内脏脂肪比例", "EAT", ("VF_total",)),
+    "AorticPVAT_fraction_of_VF_total": ("主动脉周围脂肪占总内脏脂肪比例", "AorticPVAT", ("VF_total",)),
+}
+
+
+def validate_mode(mode):
+    if mode not in ("2D", "3D"):
+        raise ValueError("mode必须为'2D'或'3D'")
+    return mode
+
+
+def size_name(mode):
+    return "Area" if validate_mode(mode) == "2D" else "Volume"
+
+
+def size_unit(mode):
+    return "cm²" if validate_mode(mode) == "2D" else "cm³"
+
+
+def morphology_key(tissue, mode):
+    return f"morphometry_{tissue}_{size_name(mode)}"
+
+
+def get_feature_catalog(mode="3D"):
+    """返回四类可选特征的名称、输出键及单位；每次返回独立字典。"""
+    kind, unit = size_name(mode), size_unit(mode)
+    catalog = {name: {} for name in ("morphometry", "firstorder", "composition", "composite")}
+    for tissue, (name, _) in TISSUES.items():
+        catalog["morphometry"][f"{tissue}_{kind}"] = {"name": name, "unit": unit}
+        for statistic in STATISTICS:
+            catalog["firstorder"][f"{tissue}_{statistic}"] = {"name": f"{name} {statistic}", "unit": "HU"}
+        catalog["composite"][f"{tissue}_{kind}Mean"] = {"name": f"{name} {kind} × Mean", "unit": f"{unit}·HU"}
+    for feature, (name, _, _) in COMPOSITION.items():
+        catalog["composition"][feature] = {"name": name, "unit": "%"}
+    for group, features in catalog.items():
+        for feature, metadata in features.items():
+            metadata["key"] = f"{group}_{feature}"
+    return catalog

ctbodycomp/extractor.py

@@ -0,0 +1,84 @@
+"""PyRadiomics-style feature selection for body composition."""
+from collections.abc import Mapping
+import numpy as np
+
+from .definitions import get_feature_catalog, validate_mode
+from .features import calculate_selected
+from .image import load_image, positive_label, read_mask, select_region, slice_axis
+
+
+class BodyCompositionExtractor:
+    def __init__(self, mode="3D", features=None, spine_label=None, spine_range=(7, 18)):
+        self.mode = validate_mode(mode)
+        self.catalog = get_feature_catalog(mode)
+        self.spine_label = None if spine_label is None else positive_label(spine_label)
+        if len(spine_range) != 2:
+            raise ValueError("spine_range必须包含起始和结束标签")
+        self.spine_range = tuple(positive_label(value) for value in spine_range)
+        if self.spine_range[0] > self.spine_range[1]:
+            raise ValueError("spine_range起始标签不能大于结束标签")
+        self.enabledFeatures = {}
+        self.last_diagnostics = {}
+        if features is None:
+            self.enableAllFeatures()
+        else:
+            if not isinstance(features, Mapping):
+                raise TypeError("features必须为类别到特征名称列表的映射")
+            self.enableFeaturesByName(**features)
+
+    def disableAllFeatures(self):
+        self.enabledFeatures = {}
+        return self
+
+    def enableAllFeatures(self):
+        self.enabledFeatures = {group: list(features) for group, features in self.catalog.items()}
+        return self
+
+    def enableFeatureClassByName(self, featureClass, enabled=True):
+        if featureClass not in self.catalog:
+            raise ValueError(f"未知特征类别：{featureClass}")
+        if enabled:
+            self.enabledFeatures[featureClass] = list(self.catalog[featureClass])
+        else:
+            self.enabledFeatures.pop(featureClass, None)
+        return self
+
+    def enableFeaturesByName(self, **features):
+        updates = {}
+        for group, names in features.items():
+            if group not in self.catalog:
+                raise ValueError(f"未知特征类别：{group}")
+            if names is None:
+                names = []
+            if not isinstance(names, (list, tuple)):
+                raise TypeError(f"{group}需要特征名称列表；[]表示该类全部特征")
+            unknown = [name for name in names if name not in self.catalog[group]]
+            if unknown:
+                raise ValueError(f"{group}中存在未知特征：{unknown}")
+            updates[group] = list(dict.fromkeys(names)) if names else list(self.catalog[group])
+        self.enabledFeatures.update(updates)
+        return self
+
+    def get_feature_names(self):
+        return [f"{group}_{name}" for group, names in self.enabledFeatures.items() for name in names]
+
+    def execute(self, image, mask, spine_mask=None):
+        """返回所选原始特征；不进行身高、体重、BSA或骨参照校正。"""
+        self.last_diagnostics = {}
+        img = load_image(image)
+        slice_axis(img)
+        bc = read_mask(mask, img, "BC mask", maximum=8)
+        spine = read_mask(spine_mask, img, "Spine mask") if spine_mask is not None else None
+        axis, selected, element_size, metadata = select_region(
+            img, spine, self.mode, self.spine_label, self.spine_range)
+        ct = img.get_fdata()
+        if self.mode == "3D":
+            crop = [slice(None)] * 3
+            crop[axis] = slice(int(selected[0]), int(selected[-1]) + 1)
+            result = calculate_selected(ct[tuple(crop)], bc[tuple(crop)], element_size, self.mode, self.enabledFeatures)
+        else:
+            results = [calculate_selected(np.take(ct, i, axis=axis), np.take(bc, i, axis=axis),
+                                          element_size, self.mode, self.enabledFeatures) for i in selected]
+            result = {key: float(np.mean([row[key] for row in results])) for key in results[0]}
+        self.last_diagnostics = metadata
+        return result

ctbodycomp/features.py

@@ -0,0 +1,71 @@
+"""Only evaluate the requested features and their numerical dependencies."""
+import numpy as np
+
+from .definitions import COMPOSITION, TISSUES, size_name
+
+
+def safe_ratio(numerator, denominator):
+    if not np.isfinite(denominator) or denominator <= 0:
+        return float("nan")
+    return float(numerator / denominator)
+
+
+class FeatureContext:
+    def __init__(self, image, mask, element_size, mode):
+        self.image, self.mask = image, mask
+        self.scale = element_size / (100 if mode == "2D" else 1000)
+        self.counts, self.sizes, self.values, self.statistics = {}, {}, {}, {}
+
+    def size(self, tissue):
+        if tissue not in self.sizes:
+            labels = TISSUES[tissue][1]
+            for label in labels:
+                if label not in self.counts:
+                    self.counts[label] = int(np.count_nonzero(self.mask == label))
+            self.sizes[tissue] = sum(self.counts[label] for label in labels) * self.scale
+        return self.sizes[tissue]
+
+    def hu(self, tissue):
+        if tissue not in self.values:
+            values = self.image[np.isin(self.mask, TISSUES[tissue][1])]
+            self.values[tissue] = values[np.isfinite(values)]
+        return self.values[tissue]
+
+    def statistic(self, tissue, statistic):
+        key = (tissue, statistic)
+        if key not in self.statistics:
+            hu = self.hu(tissue)
+            if not hu.size:
+                value = np.nan
+            elif statistic == "Mean":
+                value = np.mean(hu)
+            elif statistic == "SD":
+                value = np.std(hu, ddof=0)
+            elif statistic == "IQR":
+                q25, q75 = np.percentile(hu, [25, 75], method="linear")
+                value = q75 - q25
+            else:
+                value = np.percentile(hu, int(statistic[1:]), method="linear")
+            self.statistics[key] = float(value)
+        return self.statistics[key]
+
+
+def calculate_selected(image, mask, element_size, mode, enabled):
+    ctx = FeatureContext(image, mask, element_size, mode)
+    kind = size_name(mode)
+    result = {}
+    for group, features in enabled.items():
+        for feature in features:
+            if group == "morphometry":
+                value = ctx.size(feature.removesuffix(f"_{kind}"))
+            elif group == "firstorder":
+                tissue, statistic = feature.rsplit("_", 1)
+                value = ctx.statistic(tissue, statistic)
+            elif group == "composition":
+                _, numerator, denominator = COMPOSITION[feature]
+                value = safe_ratio(ctx.size(numerator), sum(ctx.size(t) for t in denominator)) * 100
+            else:
+                tissue = feature.removesuffix(f"_{kind}Mean")
+                value = ctx.size(tissue) * ctx.statistic(tissue, "Mean")
+            result[f"{group}_{feature}"] = float(value)
+    return result

ctbodycomp/image.py

@@ -0,0 +1,74 @@
+"""Load matching NIfTI images and select a physical slice direction."""
+import os
+import nibabel as nib
+import numpy as np
+
+
+def load_image(value):
+    if isinstance(value, (str, os.PathLike)):
+        return nib.load(os.fspath(value))
+    if isinstance(value, nib.spatialimages.SpatialImage):
+        return value
+    raise TypeError("影像输入必须为文件路径或nibabel图像对象")
+
+
+def slice_axis(image):
+    if len(image.shape) != 3 or any(size <= 0 for size in image.shape):
+        raise ValueError("CT必须为非空3D图像")
+    if not np.all(np.isfinite(image.affine)) or np.linalg.matrix_rank(image.affine[:3, :3]) < 3:
+        raise ValueError("CT的affine必须有限且可逆")
+    axes = np.flatnonzero(nib.orientations.io_orientation(image.affine)[:, 0] == 2)
+    if axes.size != 1:
+        raise ValueError("无法确定CT的上下方向")
+    return int(axes[0])
+
+
+def read_mask(value, image, name, maximum=None):
+    mask = load_image(value)
+    if mask.shape != image.shape or not np.allclose(mask.affine, image.affine, rtol=0, atol=1e-4):
+        raise ValueError(f"{name}与CT空间不一致")
+    data = mask.get_fdata()
+    if not np.all(np.isfinite(data)) or np.any(data != np.rint(data)) or np.any(data < 0):
+        raise ValueError(f"{name}必须为有限非负整数标签")
+    if maximum is not None and np.any(data > maximum):
+        raise ValueError(f"{name}标签必须为0–{maximum}")
+    return data
+
+
+def positive_label(value):
+    if not isinstance(value, (int, np.integer)) or isinstance(value, (bool, np.bool_)) or value <= 0:
+        raise ValueError("脊柱标签必须为正整数")
+    return int(value)
+
+
+def select_region(image, spine, mode, spine_label, spine_range):
+    axis = slice_axis(image)
+    if spine is None:
+        candidates = np.arange(image.shape[axis])
+        scope = "full_image"
+    else:
+        if mode == "2D":
+            target = spine == positive_label(spine_label)
+            scope = f"spine_label_{spine_label}"
+        else:
+            lower, upper = spine_range
+            target = (spine >= lower) & (spine <= upper)
+            scope = f"spine_range_{lower}_{upper}"
+        occupied = np.any(target, axis=tuple(a for a in range(3) if a != axis))
+        candidates = np.flatnonzero(occupied)
+        if not candidates.size:
+            raise ValueError("Spine mask中未找到请求的脊柱标签")
+    if mode == "2D":
+        middle = candidates.size // 2
+        selected = candidates[middle:middle + 1] if candidates.size % 2 else candidates[middle - 1:middle + 1]
+        plane_axes = [a for a in range(3) if a != axis]
+        basis = image.affine[:3, plane_axes]
+        element_size = float(np.linalg.norm(np.cross(basis[:, 0], basis[:, 1])))
+    else:
+        selected = np.arange(candidates[0], candidates[-1] + 1)
+        element_size = float(abs(np.linalg.det(image.affine[:3, :3])))
+    if not np.isfinite(element_size) or element_size <= 0:
+        raise ValueError("像素面积或体素体积无效")
+    metadata = {"mode": mode, "scope": scope, "slice_axis": axis,
+                "candidate_slices": int(candidates.size), "selected_slices": selected.tolist()}
+    return axis, selected, element_size, metadata

ctbodycomp/normalization.py

@@ -0,0 +1,131 @@
+"""Normalize first-class morphology features without reading images."""
+import math
+from collections.abc import Mapping
+
+from .definitions import TISSUES, morphology_key, size_name, size_unit, validate_mode
+
+METHODS = ("height", "weight", "bsa", "bone")
+
+
+def positive_number(value, name):
+    if value is None or isinstance(value, bool):
+        raise ValueError(f"{name}必须为有限正数")
+    try:
+        value = float(value)
+    except (ValueError, TypeError) as error:
+        raise ValueError(f"{name}必须为有限正数") from error
+    if not math.isfinite(value) or value <= 0:
+        raise ValueError(f"{name}必须为有限正数")
+    return value
+
+
+class FeatureNormalizer:
+    """height: size / height(m)^2; weight: size/kg; bsa: size/m²; bone: size/bone size.
+
+    骨校正可用于所有非骨组织；不输出恒为1的Bone/Bone。
+    两层2D输入必须先完成形态指标的逐层平均，再调用本校正器。
+    """
+    def __init__(self, mode="3D", methods=METHODS, tissues=None, include_composite=False):
+        self.mode = validate_mode(mode)
+        if isinstance(methods, str) or not isinstance(methods, (tuple, list)):
+            raise TypeError("methods必须为校正方式列表")
+        unknown = [method for method in methods if method not in METHODS]
+        if unknown:
+            raise ValueError(f"未知校正方式：{unknown}")
+        self.methods = tuple(dict.fromkeys(methods))
+        if tissues is not None:
+            if not isinstance(tissues, (list, tuple)):
+                raise TypeError("tissues必须为组织代码列表")
+            unknown = [tissue for tissue in tissues if tissue not in TISSUES]
+            if unknown:
+                raise ValueError(f"未知组织：{unknown}")
+            tissues = tuple(dict.fromkeys(tissues))
+        self.tissues = tissues
+        if not isinstance(include_composite, bool):
+            raise TypeError("include_composite必须为布尔值")
+        self.include_composite = include_composite
+        self.last_diagnostics = {}
+
+    def _targets(self, features):
+        if not isinstance(features, Mapping):
+            raise TypeError("features必须为已提取特征的字典")
+        targets = self.tissues
+        if targets is None:
+            targets = tuple(t for t in TISSUES if morphology_key(t, self.mode) in features)
+        if self.methods and not targets:
+            raise ValueError("请先提取第一类形态指标；输入中没有匹配当前2D/3D模式的面积或体积")
+        for tissue in targets:
+            if morphology_key(tissue, self.mode) not in features:
+                raise ValueError(f"缺少第一类指标：{morphology_key(tissue, self.mode)}")
+        return targets
+
+    def get_feature_names(self, features):
+        targets = self._targets(features)
+        names = []
+        for method in self.methods:
+            for tissue in targets:
+                if method == "bone" and tissue == "Bone":
+                    continue
+                names.append(f"normalization_{method}_{tissue}_{size_name(self.mode)}")
+                if self.include_composite:
+                    names.append(f"normalized_composite_{method}_{tissue}_{size_name(self.mode)}Mean")
+        return names
+
+    def get_units(self, features):
+        units = {"height": f"{size_unit(self.mode)}/m²", "weight": f"{size_unit(self.mode)}/kg",
+                 "bsa": f"{size_unit(self.mode)}/m²", "bone": "1"}
+        result = {}
+        for key in self.get_feature_names(features):
+            if key.startswith("normalized_composite_"):
+                method = key.split("_")[2]
+                result[key] = "HU" if method == "bone" else units[method].replace("/", "·HU/")
+            else:
+                result[key] = units[key.split("_")[1]]
+        return result
+
+    def execute(self, features, height_cm=None, weight_kg=None, bsa_m2=None):
+        """返回校正指数，可同时附带指数×Mean；不修改原始特征或读取影像。"""
+        self.last_diagnostics = {}
+        targets = self._targets(features)
+        denominator = {}
+        bsa_source = None
+        if "height" in self.methods:
+            denominator["height"] = (positive_number(height_cm, "height_cm") / 100) ** 2
+        if "weight" in self.methods:
+            denominator["weight"] = positive_number(weight_kg, "weight_kg")
+        if "bsa" in self.methods:
+            if bsa_m2 is None:
+                denominator["bsa"] = math.sqrt(positive_number(height_cm, "height_cm") *
+                                               positive_number(weight_kg, "weight_kg") / 3600)
+                bsa_source = "Mosteller"
+            else:
+                denominator["bsa"] = positive_number(bsa_m2, "bsa_m2")
+                bsa_source = "provided"
+        if "bone" in self.methods and any(t != "Bone" for t in targets):
+            bone_key = morphology_key("Bone", self.mode)
+            if bone_key not in features:
+                raise ValueError(f"骨校正需要先提取{bone_key}；骨必须与目标组织来自相同范围")
+            denominator["bone"] = float(features[bone_key])
+        output = {}
+        for method in self.methods:
+            for tissue in targets:
+                if method == "bone" and tissue == "Bone":
+                    continue
+                key = f"normalization_{method}_{tissue}_{size_name(self.mode)}"
+                numerator = float(features[morphology_key(tissue, self.mode)])
+                if math.isfinite(numerator) and numerator < 0:
+                    raise ValueError("面积或体积不能为负数")
+                divisor = denominator[method]
+                output[key] = (numerator / divisor if math.isfinite(numerator) and
+                               math.isfinite(divisor) and divisor > 0 else float("nan"))
+        if self.include_composite:
+            from .normalized_composite import NormalizedCompositeCalculator
+            calculator = NormalizedCompositeCalculator(self.mode, methods=self.methods, tissues=targets)
+            output.update(calculator.execute(output, features))
+            # 同一校正方式/组织的指数与复合项相邻，字典和CSV使用相同顺序。
+            output = {key: output[key] for key in self.get_feature_names(features)}
+        self.last_diagnostics = {"mode": self.mode, "methods": list(self.methods),
+                                 "height_power": 2, "bsa_source": bsa_source,
+                                 "include_composite": self.include_composite,
+                                 "denominators": denominator}
+        return output

ctbodycomp/normalized_composite.py

@@ -0,0 +1,88 @@
+"""Optional corrected morphology indices multiplied by matching mean HU."""
+import math
+from collections.abc import Mapping
+
+from .definitions import TISSUES, size_name, size_unit, validate_mode
+from .normalization import FeatureNormalizer, METHODS
+
+
+def get_normalized_composite_catalog(mode="3D"):
+    """List all 43 optional corrected composites and their input dependencies."""
+    kind, unit = size_name(mode), size_unit(mode)
+    units = {"height": f"{unit}·HU/m²", "weight": f"{unit}·HU/kg",
+             "bsa": f"{unit}·HU/m²", "bone": "HU"}
+    catalog = {}
+    for method in METHODS:
+        catalog[method] = {}
+        for tissue, (name, _) in TISSUES.items():
+            if method == "bone" and tissue == "Bone":
+                continue
+            feature = f"{tissue}_{kind}Mean"
+            catalog[method][feature] = {
+                "key": f"normalized_composite_{method}_{feature}",
+                "name": f"{name} {method}校正指数 × 平均HU",
+                "unit": units[method],
+                "index_key": f"normalization_{method}_{tissue}_{kind}",
+                "mean_key": f"firstorder_{tissue}_Mean",
+            }
+    return catalog
+
+
+class NormalizedCompositeCalculator:
+    """Calculate only selected methods/tissues from previously computed results.
+
+    输入必须来自同一病例和同一范围。2D两层模式先得到平均形态指标和
+    平均HU，再使用已校正的平均形态指数乘平均HU，不平均逐层乘积。
+    """
+    def __init__(self, mode="3D", methods=METHODS, tissues=None):
+        self.mode = validate_mode(mode)
+        selection = FeatureNormalizer(mode, methods=methods, tissues=tissues)
+        self.methods, self.tissues = selection.methods, selection.tissues
+        self.catalog = get_normalized_composite_catalog(mode)
+        self.last_diagnostics = {}
+
+    def _selected(self, normalized_features):
+        if not isinstance(normalized_features, Mapping):
+            raise TypeError("normalized_features必须为已计算校正指数的字典")
+        selected = []
+        for method in self.methods:
+            matched = []
+            targets = self.tissues if self.tissues is not None else TISSUES
+            for tissue in targets:
+                if method == "bone" and tissue == "Bone":
+                    continue
+                metadata = self.catalog[method][f"{tissue}_{size_name(self.mode)}Mean"]
+                if metadata["index_key"] in normalized_features:
+                    matched.append(metadata)
+                elif self.tissues is not None:
+                    raise ValueError(f"请先计算校正指数：{metadata['index_key']}")
+            if not matched and self.tissues is None:
+                raise ValueError(f"缺少{method}校正指数；请先提取形态特征并执行该校正，且匹配2D/3D模式")
+            selected.extend(matched)
+        return selected
+
+    def get_feature_names(self, normalized_features):
+        return [metadata["key"] for metadata in self._selected(normalized_features)]
+
+    def get_units(self, normalized_features):
+        return {metadata["key"]: metadata["unit"] for metadata in self._selected(normalized_features)}
+
+    def execute(self, normalized_features, original_features):
+        """Return selected corrected indices × mean HU; never read images or mutate inputs."""
+        self.last_diagnostics = {}
+        if not isinstance(original_features, Mapping):
+            raise TypeError("original_features必须为已提取基础特征的字典")
+        selected = self._selected(normalized_features)
+        output = {}
+        for metadata in selected:
+            if metadata["mean_key"] not in original_features:
+                raise ValueError(f"请先提取同组织同范围的平均HU：{metadata['mean_key']}")
+            index = float(normalized_features[metadata["index_key"]])
+            mean = float(original_features[metadata["mean_key"]])
+            if math.isfinite(index) and index < 0:
+                raise ValueError("校正面积或体积指数不能为负数")
+            value = index * mean
+            output[metadata["key"]] = value if math.isfinite(value) else float("nan")
+        self.last_diagnostics = {"mode": self.mode, "methods": list(self.methods),
+                                 "features": list(output), "aggregation": "corrected_index_times_mean_hu"}
+        return output

ctbodycomp-0.1.1.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: ctbodycomp
+Version: 0.1.1
+Summary: Selectable 2D and 3D CT body composition features with separate normalization
+Keywords: CT,body-composition,medical-imaging,feature-extraction
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.22
+Requires-Dist: nibabel>=5
+Requires-Dist: pandas>=2
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+
+# ctbodycomp
+
+CT体成分2D/3D特征提取与独立校正。支持按类别或单个名称选择基础特征，以及独立的身高、体重、BSA和骨参照校正。
+
+## 安装
+
+在本项目目录运行`python -m pip install .`。开发时使用`python -m pip install -e .`。
+支持Python 3.10及以上，依赖numpy、nibabel、pandas；测试需要pytest。
+
+## 四类基础特征
+
+| 类别 | 代码 | 数量 |
+|---|---|---:|
+| 形态：面积或体积 | morphometry | 11 |
+| 一阶统计：Mean、SD、P10、P50、P90、IQR | firstorder | 66 |
+| 组成与分布：组织比值或占比，百分比 | composition | 12 |
+| 复合：面积或体积×平均HU | composite | 11 |
+| 合计 | | 100 |
+
+旧脚本的8项骨参照比和8项骨参照比×HU不再混入基础输出。
+
+组织代码：SM骨骼肌(1)、SF皮下脂肪(4)、IMF肌间脂肪(2)、VF其余内脏脂肪(3)、PVAT血管周围脂肪(6)、EAT心外膜脂肪(7)、AorticPVAT主动脉周围脂肪(8)、Bone骨(5)、CVF(6/7/8)、VF_total(3/6/7/8)、TF(2/3/4/6/7/8)。基础标签互斥。
+
+## 先提取第一类，再校正
+
+```python
+from ctbodycomp import BodyCompositionExtractor, FeatureNormalizer
+
+extractor = BodyCompositionExtractor(
+    mode="3D",
+    features={"morphometry": ["SM_Volume", "SF_Volume", "Bone_Volume"]},
+)
+raw = extractor.execute(image="ct.nii.gz", mask="bc_mask.nii.gz")
+
+# 只校正指定组织；原始结果与校正结果是两个独立字典。
+normalizer = FeatureNormalizer(
+    mode="3D", methods=["height", "weight", "bsa", "bone"], tissues=["SM", "SF"]
+)
+corrected = normalizer.execute(raw, height_cm=170, weight_kg=65)
+```
+
+校正器根据第一类形态指标计算校正指数；开启`include_composite=True`时，同时读取一阶Mean并计算校正指数×Mean。不读取影像，不对HU本身或组成比值二次校正。可以把提取结果保存后，换一组校正方式再次计算。骨校正需提前提取同一范围的`Bone_Volume`或`Bone_Area`。
+
+| 方法 | 公式 | 2D单位 | 3D单位 |
+|---|---|---|---|
+| height | 原始面积/体积 ÷ 身高(m)² | cm²/m² | cm³/m² |
+| weight | 原始面积/体积 ÷ 体重(kg) | cm²/kg | cm³/kg |
+| bsa | 原始面积/体积 ÷ BSA(m²) | cm²/m² | cm³/m² |
+| bone | 原始面积/体积 ÷ 同范围骨面积/体积 | 无量纲 | 无量纲 |
+
+2D和3D都使用身高²。默认BSA使用Mosteller公式：`sqrt(height_cm * weight_kg / 3600)`，也可通过`bsa_m2`直接提供已知BSA；提供值优先，来源记录在`normalizer.last_diagnostics`。Mosteller公式参考：[原始论文](https://doi.org/10.1056/NEJM198710223171717)。
+
+身高、体重、BSA需为有限正数；只选择骨校正时不需要身高体重。缺少所选方法需要的参数会抛出明确错误。骨量为0时骨校正输出NaN。CSV校正失败时保留原始特征及失败原因。
+
+若提取全部11个形态特征且启用全部校正，height、weight、bsa各11项，bone对10个非骨组织输出，共43项。与100项基础特征分开存储。骨校正包括CVF和TF两个聚合组织，不输出恒为1的Bone/Bone。实际输出量由所选组织、特征和校正方式决定。
+
+## 可选：校正指数 × 平均HU
+
+从0.1.1开始，校正指数与校正后的复合特征统一由`FeatureNormalizer`管理。使用`include_composite=True`，同一次校正返回“指数”和“指数×同组织平均HU”，每一对相邻排列。两者均属于校正模块，与四类基础特征分开。默认不开启校正复合项。
+
+```python
+from ctbodycomp import BodyCompositionExtractor, FeatureNormalizer
+
+extractor = BodyCompositionExtractor(
+    mode="3D",
+    features={
+        "morphometry": ["SM_Volume", "Bone_Volume"],
+        "firstorder": ["SM_Mean"],
+    },
+)
+raw = extractor.execute("ct.nii.gz", "bc_mask.nii.gz")
+normalizer = FeatureNormalizer(
+    mode="3D", methods=["height", "bone"], tissues=["SM"],
+    include_composite=True,
+)
+corrected = normalizer.execute(raw, height_cm=170)
+# normalization_height_SM_Volume
+# normalized_composite_height_SM_VolumeMean
+# normalization_bone_SM_Volume
+# normalized_composite_bone_SM_VolumeMean
+units = normalizer.get_units(raw)
+```
+
+2D将模式改为`2D`，将第一类特征的`Volume`改为`Area`，输出为`normalized_composite_height_SM_AreaMean`等。
+
+| 方法 | 公式，μ为同组织平均HU | 2D单位 | 3D单位 | 全部组织数量 |
+|---|---|---|---|---:|
+| height | (面积/体积 ÷ 身高(m)²) × μ | cm²·HU/m² | cm³·HU/m² | 11 |
+| weight | (面积/体积 ÷ 体重(kg)) × μ | cm²·HU/kg | cm³·HU/kg | 11 |
+| bsa | (面积/体积 ÷ BSA(m²)) × μ | cm²·HU/m² | cm³·HU/m² | 11 |
+| bone | (面积/体积 ÷ 同范围骨面积/体积) × μ | HU | HU | 10 |
+
+共43项可选校正复合特征，不输出Bone/Bone×HU。每种模式最多有100项基础特征＋43项校正指数＋43项校正复合特征＝186项。2D和3D是两种模式，不合并计数。负平均HU保留符号；指数或均值为NaN/无穷时结果为NaN，不解释为实际组织质量。
+
+通过`methods`选择校正方式，通过`tissues`选择组织；`tissues=None`从输入已有的形态指标中选择组织。开启复合项需要同时提取目标组织的Mean。可用`get_normalized_composite_catalog("3D")`查询完整复合名称、单位、指数键和均值键。
+
+对于已经保存的校正指数字典，仍支持`NormalizedCompositeCalculator(mode, methods, tissues).execute(indices, raw)`单独补算复合项；两个字典需来自同一病例、同一范围。
+
+**2D两层的计算顺序**：先将两层面积与两层平均HU分别等权平均，面积平均值进行校正，再乘HU平均值。因此结果是“校正后的平均面积指数 × 平均HU”，与基础复合类的“逐层面积×HU后平均”定义不同。例如两层面积0.06、0.18 cm²，均值10、30 HU，身高1 m：校正复合为0.12×20＝2.4 cm²·HU/m²，而基础复合为(0.06×10＋0.18×30)/2＝3 cm²·HU。
+
+## 选择类别或单项
+
+```python
+from ctbodycomp import BodyCompositionExtractor, get_feature_catalog
+
+extractor = BodyCompositionExtractor(mode="2D", spine_label=7)
+extractor.disableAllFeatures()
+extractor.enableFeaturesByName(
+    morphometry=["SM_Area", "Bone_Area"],
+    firstorder=["SM_Mean", "SM_P50"],
+    composition=["MFF"],
+)
+raw = extractor.execute("ct.nii.gz", "bc_mask.nii.gz", spine_mask="spine.nii.gz")
+
+# 按整个类别启用：
+extractor.enableFeatureClassByName("firstorder")
+# 查询当前模式下全部可用名称、英文输出键和单位：
+catalog = get_feature_catalog("2D")
+```
+
+构造参数`features=None`默认启用全部四类；`features={}`不启用任何特征。映射中未列出的类别不提取，类别中的`[]`或`None`表示该类全部。`enableFeaturesByName`替换指定类别的选择，其他已启用类别保持不变，因此要只选择几项时先调用`disableAllFeatures()`。支持全部启用`enableAllFeatures()`和单类别关闭`enableFeatureClassByName("firstorder", False)`。
+
+只输出选择的特征，内部依赖按需计算。例如只选Mean不计算分位数，只选形态不计算HU统计；只选一个组成比值时也不输出其内部依赖的组织面积/体积。
+
+## 输入与选层
+
+- 必需：CT与BC mask。接受文件路径或nibabel图像对象，图像需3D且空间匹配，尺寸以mm解释；不重采样。
+- 可选：Spine mask。不提供时3D计算整幅CT，2D在整幅CT全部层中选中间层。
+- 2D有Spine mask时需`spine_label`，例如7或8。仅对该标签实际出现的切片排序，奇数取中间一层，偶数取中间两层。
+- 3D有Spine mask时默认范围`spine_range=(7, 18)`，可配置，取首末层之间的完整范围。新库依据affine识别上下方向，支持数组轴置换。
+- 每个选中切片的组织ROI来自完整BC mask平面，Spine mask仅定位。斜位影像保持原切片平面。
+- 2D两层基础特征先逐层计算再等权平均。独立校正使用这个平均后的形态值；骨校正因此是“平均组织面积/平均骨面积”，不同于旧脚本的“两层骨比值平均”。
+- SD使用ddof=0；分位数为线性插值；非有限CT值不进入HU统计；空组织的面积/体积为0，HU统计为NaN；任一层某基础指标NaN，则两层平均也为NaN。
+
+诊断信息在`extractor.last_diagnostics`，与纯数值特征分开。无Spine mask请传`None`；填写了错误文件路径不会自动退回全图计算。
+
+## CSV分两步运行
+
+新库的CSV使用有意义的列名（区分大小写），不同于旧脚本按列位置读取：
+
+```csv
+ID,Image,Mask,SpineMask,Height_cm,Weight_kg
+001,ct.nii.gz,bc_mask.nii.gz,,170,65
+```
+
+必需`Image`、`Mask`，其他列可选；`SpineMask`可省略或留空。相对路径相对于输入CSV目录。`Height_cm`、`Weight_kg`、可选`BSA_m2`由校正步骤读取，逐病例值优先于命令行公共值。
+
+```bash
+# 查询特征名
+ctbodycomp features --mode 3D
+
+# 仅提取肌肉、皮下脂肪和骨的体积
+ctbodycomp extract cases.csv raw.csv --mode 3D --config examples/morphometry_3d.json
+
+# 对提取结果进行校正，原始列也保留在输出中
+ctbodycomp normalize raw.csv corrected.csv --mode 3D --methods height weight bsa bone --tissues SM SF
+
+# 2D单标签、部分特征
+ctbodycomp extract cases.csv raw_2d.csv --mode 2D --label 7 --config examples/selected_2d.json
+ctbodycomp normalize raw_2d.csv corrected_2d.csv --mode 2D --methods bone --tissues SM
+```
+
+需要校正复合时，提取配置必须包含目标组织的`firstorder_*_Mean`。在同一校正步骤增加`--include-composite`即可：
+
+```bash
+# 示例配置包含肌肉、骨体积和肌肉Mean
+ctbodycomp extract cases.csv raw.csv --mode 3D --config examples/normalized_composite_3d.json
+ctbodycomp normalize raw.csv corrected.csv --mode 3D --methods height weight bsa bone --tissues SM --include-composite
+
+# 查询校正复合特征及所需输入
+ctbodycomp features --mode 3D --normalized-composite
+```
+
+校正CSV保留基础特征，按“校正指数、对应复合项”的顺序追加列，使用统一的`normalization_status`、`normalization_error`记录结果。缺少所需Mean列时记录失败；Mean数值为空时对应复合项为NaN。影像不存在也不影响已成功提取结果的后续计算。
+
+如需对已有校正CSV补算复合项，也保留单独命令：`ctbodycomp normalized-composite corrected.csv products.csv --mode 3D --methods height bone --tissues SM`。
+
+配置JSON直接写“类别→特征名称列表”。命令返回0表示成功，1表示输出中存在失败病例，参数错误返回2。输出目录需存在，输出不能覆盖输入文件；重复输出路径会替换先前结果。
+
+## 完整使用示例
+
+源码包中的 `examples/reference_usage/README.md` 提供五种完整提取示例：2D T12、2D无脊柱、3D T12、3D T1–T12、3D无脊柱，以及独立校正示例。每种情况同时提供可运行的Python脚本和Markdown教程，不依赖额外本地辅助脚本。
+
+输入使用 `cases.example.csv` 和 `cases_without_spine.example.csv` 通用模板。模板不包含实际病例数据，使用前替换为自己的影像路径。示例计算结果写入示例目录下的 `results/`，不会纳入发布包。
+
+## 测试和构建
+
+在项目根目录运行：
+
+```bash
+python -m pip install -e '.[test]'
+python -m pytest -q -p no:cacheprovider
+python -m pip install --upgrade build twine
+python -m build
+python -m twine check dist/ctbodycomp-0.1.1-py3-none-any.whl dist/ctbodycomp-0.1.1.tar.gz
+```
+
+wheel只包含库模块和安装元数据；源码包另外包含测试与使用教程。虚拟环境、缓存、本地影像、实际病例表和计算结果不纳入发布文件。`PUBLISHING.md` 仅保留在开发目录供维护者参考，不随发布包分发。
+
+作者、邮箱和许可证字段当前未设置，可在后续版本补充。本项目目前没有声明MIT或Apache-2.0授权。

ctbodycomp-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+ctbodycomp/__init__.py,sha256=lR8Ntr4m_DHh4N6qsgy6mIU1N8lcHZuLRFHY5lx-tFE,499
+ctbodycomp/batch.py,sha256=9WRBrA14a7I28ckkvYm4O0NYugr3sGnXuUlFpM05rpA,7523
+ctbodycomp/cli.py,sha256=6JwOWCqwuMSyXVDWgvqx7ZxSVDkecPYkFf0JS2iPrvI,4342
+ctbodycomp/definitions.py,sha256=43v-McsY68G0nU3dkomWHyztw03Cjx9VtUr3W86aDqQ,2891
+ctbodycomp/extractor.py,sha256=2XPbhsji0Fz_sibL5PPniZLmF5UQEeKOUoMcyZNIWUE,3987
+ctbodycomp/features.py,sha256=t21z2ANUO_InoiAX4km9_GpE6658wRywwWgTH_aYF2k,2849
+ctbodycomp/image.py,sha256=BzaWu_sADuzqinJoq2rYnhb5glPT_-YOHt9psK8TU74,3226
+ctbodycomp/normalization.py,sha256=LGZUs1tflL9rasvz6aNCY3-64Zz4cgqcA_YhNSsETzg,6620
+ctbodycomp/normalized_composite.py,sha256=kYMRLPFgGezqvLbJwAWBNAkF1ibCKkCtsxUaT__eL3M,4411
+ctbodycomp-0.1.1.dist-info/METADATA,sha256=-B0kCdNxQGcG8PC0kZDyQg-n1qnrdZem1XiZ8XRZSqQ,12547
+ctbodycomp-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ctbodycomp-0.1.1.dist-info/entry_points.txt,sha256=0uH_Rm57_IGGuWiGUeSKvvJH-SKfl94vq7WX0_CaM9o,51
+ctbodycomp-0.1.1.dist-info/top_level.txt,sha256=7zA4lEw7s2faqmFcEVp4IexE1WdHmgQF5SMUguOerSQ,11
+ctbodycomp-0.1.1.dist-info/RECORD,,

ctbodycomp-0.1.1.dist-info/WHEEL

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

ctbodycomp-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ctbodycomp = ctbodycomp.cli:main

ctbodycomp-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ctbodycomp