Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,56 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_230219_A191_1.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_230219_A191_1_test.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_230219_A200_4.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_IMG_02C458E4D7CE-3.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_IMG_02C458E4D7CE-4.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_IMG_02C458E4D7CE-5.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_IMG_02C458E4D7CE-6.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_IMG_02C458E4D7CE-7.jpg filter=lfs diff=lfs merge=lfs -text
+alopecia/count_result/visualizations/vis_IMG_02C458E4D7CE-9.jpg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/complete_pipeline_230219_A191_1.jpg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/complete_pipeline_230219_A191_1_test.jpg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/complete_pipeline_230219_A200_4.jpg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/complete_pipeline_IMG_02C458E4D7CE-3.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/complete_pipeline_IMG_02C458E4D7CE-4.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/complete_pipeline_IMG_02C458E4D7CE-5.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/complete_pipeline_IMG_02C458E4D7CE-6.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/labeled_230219_A191_1.jpg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/labeled_230219_A191_1_test.jpg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/labeled_230219_A200_4.jpg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/labeled_IMG_02C458E4D7CE-3.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/labeled_IMG_02C458E4D7CE-4.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/labeled_IMG_02C458E4D7CE-5.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/labeled_IMG_02C458E4D7CE-6.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/lines_mask_IMG_02C458E4D7CE-3.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/lines_mask_IMG_02C458E4D7CE-5.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/lines_mask_IMG_02C458E4D7CE-6.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/merged_foreground_IMG_02C458E4D7CE-3.jpeg filter=lfs diff=lfs merge=lfs -text
+complete_pipeline_out/merged_foreground_IMG_02C458E4D7CE-6.jpeg filter=lfs diff=lfs merge=lfs -text
+datasets/data/230219_A191_1.jpg filter=lfs diff=lfs merge=lfs -text
+datasets/data/230219_A191_1_test.jpg filter=lfs diff=lfs merge=lfs -text
+datasets/data/IMG_02C458E4D7CE-3.jpeg filter=lfs diff=lfs merge=lfs -text
+datasets/data/IMG_02C458E4D7CE-4.jpeg filter=lfs diff=lfs merge=lfs -text
+datasets/data/IMG_02C458E4D7CE-5.jpeg filter=lfs diff=lfs merge=lfs -text
+datasets/data/IMG_02C458E4D7CE-6.jpeg filter=lfs diff=lfs merge=lfs -text
+datasets/data/IMG_02C458E4D7CE-7.jpeg filter=lfs diff=lfs merge=lfs -text
+datasets/data/IMG_02C458E4D7CE-9.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/ensemble_result/ensemble_val/IMG_02C458E4D7CE-5.jpg filter=lfs diff=lfs merge=lfs -text
+prediction/ensemble_result/ensemble_val/IMG_02C458E4D7CE-7.jpg filter=lfs diff=lfs merge=lfs -text
+prediction/ensemble_result/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-3.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/ensemble_result/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-5.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/ensemble_result/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-6.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/ensemble_result/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-7.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/ensemble_result/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-9.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/sam_result/sam_val/230219_A191_1.jpg filter=lfs diff=lfs merge=lfs -text
+prediction/sam_result/sam_val/230219_A191_1_test.jpg filter=lfs diff=lfs merge=lfs -text
+prediction/sam_result/sam_val/230219_A200_4.jpg filter=lfs diff=lfs merge=lfs -text
+prediction/sam_result/sam_val/IMG_02C458E4D7CE-5.jpg filter=lfs diff=lfs merge=lfs -text
+prediction/sam_result/sam_val/IMG_02C458E4D7CE-7.jpg filter=lfs diff=lfs merge=lfs -text
+prediction/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-3.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-5.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-6.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-7.jpeg filter=lfs diff=lfs merge=lfs -text
+prediction/test_val/test_step7_merged_foreground_IMG_02C458E4D7CE-9.jpeg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+/Users/Admin/ScalpVision/sam_vit_h_4b8939.pth
+/Users/Admin/ScalpVision/alopecia/alopecia_prediction.py
+/Users/Admin/ScalpVision/datasets/old_data
+DiffuseIT-M
+etc
+_pycache_/

README.md

@@ -0,0 +1,26 @@
+## ScalpPipeline (`pipeline.py`)
+
+Refactored pipeline combining all steps into a single class.
+
+### Usage
+```bash
+python pipeline.py
+```
+
+### Dependencies (Files)
+The pipeline requires the following files and directories to exist:
+
+1.  **Input Images**:
+    - `datasets/data/` : Directory containing input images (`.jpg`, `.jpeg`, `.png`).
+
+2.  **Model Weights**:
+    - `segmentation/model/U2NET.pth` : Pre-trained U2NET model.
+    - `sam_vit_h_4b8939.pth` : SAM (Segment Anything Model) checkpoint (ViT-H).
+
+### Output
+Results are saved in:
+- `datasets/seg_train/` (U2NET masks)
+- `prediction/sam_result/sam_val/` (SAM masks)
+- `prediction/ensemble_result/ensemble_val/` (Ensemble masks)
+- `alopecia/thickness_result/` (Thickness data & visualization)
+- `alopecia/count_result/` (Hair count CSV & visualization)

alopecia/calculate_hair_count.py

@@ -0,0 +1,317 @@
+import cv2
+import os
+import argparse
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+import json
+import csv
+
+# --- CẤU HÌNH ĐƯỜNG DẪN CỦA BẠN ---
+DEFAULT_SEGMENT_FOLDER = "../prediction/ensemble_result/ensemble_val"
+DEFAULT_ORIGINAL_FOLDER = "../datasets/data"
+DEFAULT_SAVE_PATH = "alopecia/count_result"
+
+def load_segment_mask(img_path):
+    if not os.path.exists(img_path): return None
+    img_gray = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
+    if img_gray is None: return None
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    binary_filtered = cv2.morphologyEx(img_gray, cv2.MORPH_OPEN, kernel)
+    # ensure binary (0/255)
+    _, binary_filtered = cv2.threshold(binary_filtered, 127, 255, cv2.THRESH_BINARY)
+    return binary_filtered
+
+def run_watershed_for_sep(binary_img, original_img, sep_factor):
+    """
+    Chạy watershed cho 1 separation_factor, trả về markers (int32 array)
+    markers: -1 = boundary, 1 = background, >=2 = object labels (giữ tương tự structure cũ)
+    """
+    # Distance transform
+    dist_transform = cv2.distanceTransform(binary_img, cv2.DIST_L2, 5)
+    # sure foreground (seeds)
+    _, sure_fg = cv2.threshold(dist_transform, sep_factor * dist_transform.max(), 255, 0)
+    sure_fg = np.uint8(sure_fg)
+    # sure background
+    kernel = np.ones((3,3), np.uint8)
+    sure_bg = cv2.dilate(binary_img, kernel, iterations=3)
+    # unknown
+    unknown = cv2.subtract(sure_bg, sure_fg)
+    # markers
+    ret, markers = cv2.connectedComponents(sure_fg)
+    markers = markers + 1  # background = 1
+    markers[unknown == 255] = 0
+    # prepare original color
+    if len(original_img.shape) == 2:
+        original_color = cv2.cvtColor(original_img, cv2.COLOR_GRAY2BGR)
+    else:
+        original_color = original_img.copy()
+    # watershed
+    markers_w = markers.copy().astype(np.int32)
+    cv2.watershed(original_color, markers_w)
+    # After watershed: boundary pixels labeled -1; keep it
+    return markers_w
+
+def apply_watershed_hierarchical(binary_img, original_img, min_area, min_aspect_ratio, min_length,
+                                 separation_factor=0.2, hierarchy_levels=3):
+    """
+    Multi-level hierarchical watershed refinement.
+    - Chạy watershed ở nhiều mức (tăng dần separation_factor)
+    - Bắt đầu từ coarse level (nhỏ nhất), refine bằng cách thay parent bằng các children từ level sau
+    - Chỉ chấp nhận split nếu child components thỏa điều kiện hình thái để tránh over-segmentation
+    """
+    # 0. chuẩn bị (distance transform dùng bên trong run_watershed_for_sep)
+    # tạo danh sách separation levels (từ nhẹ -> mạnh)
+    # scale factors: từ sep*0.7 -> sep*1.6 (tùy hierarchy_levels)
+    low = max(0.01, separation_factor * 0.7)
+    high = separation_factor * 1.6
+    if hierarchy_levels <= 1:
+        sep_levels = [separation_factor]
+    else:
+        sep_levels = list(np.linspace(low, high, hierarchy_levels))
+
+    # 1. chạy watershed cho mọi level
+    markers_levels = []
+    for s in sep_levels:
+        markers_levels.append(run_watershed_for_sep(binary_img, original_img, s))
+
+    # 2. Bắt đầu từ coarse (level 0), dần refine bằng level 1,2,...
+    current = markers_levels[0].copy().astype(np.int32)
+    # normalize: ensure background value 1, boundaries -1
+    # We'll create new labels map 'cur_labels' where labels >=2 are objects
+    # start label id counter
+    next_label = int(current.max()) + 1
+
+    # helper: compute morphological properties for a mask
+    def region_props_from_mask(mask_uint8):
+        # returns a dict with area, major_axis(length), minor_axis, aspect_ratio, centroid
+        cnts, _ = cv2.findContours(mask_uint8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        props = []
+        for cnt in cnts:
+            area = cv2.contourArea(cnt)
+            if area <= 0: 
+                continue
+            if len(cnt) >= 5:
+                try:
+                    (x, y), (MA, ma), angle = cv2.fitEllipse(cnt)
+                except:
+                    MA = ma = 0
+                    x = y = 0
+            else:
+                # approximate with bounding rect
+                x, y, w, h = cv2.boundingRect(cnt)
+                MA = max(w,h)
+                ma = min(w,h)
+                angle = 0
+            minor = ma if ma > 0 else 1e-6
+            aspect = float(max(MA, ma)) / (minor + 1e-6)
+            props.append({
+                'area': area,
+                'major': max(MA, ma),
+                'minor': minor,
+                'aspect': aspect,
+                'centroid': (float(x), float(y)) if 'x' in locals() else (0,0),
+                'contour': cnt
+            })
+        return props
+
+    # iterate refinement levels
+    for lvl in range(1, len(markers_levels)):
+        finer = markers_levels[lvl]
+        new_current = current.copy()
+        unique_parents = np.unique(current)
+        # ignore background and boundary labels
+        for parent_label in unique_parents:
+            if parent_label <= 1:  # 1 background, 0/ -1 unknown/boundary
+                continue
+            parent_mask = (current == parent_label)
+            if parent_mask.sum() == 0:
+                continue
+            # find overlapping child labels in finer segmentation (exclude background/boundary)
+            overlapped = finer[parent_mask]
+            child_labels = np.unique(overlapped[(overlapped > 1)])  # only valid object labels
+            if len(child_labels) <= 1:
+                # no split present in finer-> keep parent
+                continue
+
+            # Evaluate each child component restricted to parent mask
+            accepted_children = []
+            for cl in child_labels:
+                child_mask = np.logical_and(finer == cl, parent_mask)
+                child_mask_uint8 = (child_mask.astype(np.uint8) * 255)
+                props = region_props_from_mask(child_mask_uint8)
+                if len(props) == 0:
+                    continue
+                # take the largest prop if multiple contours
+                p = max(props, key=lambda x: x['area'])
+                # morphological filters
+                if p['area'] >= min_area and p['major'] >= min_length and p['aspect'] >= min_aspect_ratio:
+                    accepted_children.append((child_mask_uint8, p))
+            # Decide whether to replace parent by children
+            if len(accepted_children) >= 2:
+                # remove parent label and assign new labels for each accepted child
+                new_current[parent_mask] = 0  # clear parent region
+                for (cmask_uint8, p) in accepted_children:
+                    new_label = next_label
+                    next_label += 1
+                    new_current[cmask_uint8 == 255] = new_label
+            # else keep parent as-is (not split)
+        # after processing all parents, set current to new_current
+        # fill any 0 inside the binary foreground (remaining unknown areas) with background=1 to avoid gaps
+        # but keep watershed boundaries (-1) from original finer? We will not carry -1 boundaries forward.
+        current = new_current
+        # optional: small postprocess: fill small holes inside current using morphological close
+        # (skip for now to keep deterministic)
+
+    # final_labels in 'current' (labels >=2 are hair candidates)
+    final_labels = current
+
+    # At the end, extract contours for each final label and apply ellipse fitting + final filters
+    valid_hairs = []
+    unique_labels = np.unique(final_labels)
+    for label in unique_labels:
+        if label <= 1: continue
+        mask = (final_labels == label).astype(np.uint8) * 255
+        cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        for cnt in cnts:
+            area = cv2.contourArea(cnt)
+            if area < min_area: 
+                continue
+            if len(cnt) < 5:
+                continue
+            try:
+                (x, y), (MA, ma), angle = cv2.fitEllipse(cnt)
+                major_axis = max(MA, ma)
+                minor_axis = min(MA, ma)
+                aspect_ratio = major_axis / (minor_axis + 1e-6)
+                if major_axis >= min_length and aspect_ratio >= min_aspect_ratio:
+                    valid_hairs.append({
+                        'centroid': (x, y),
+                        'ellipse': ((x, y), (MA, ma), angle),
+                        'length': major_axis,
+                        'thickness': minor_axis,
+                        'area': area,
+                        'label': int(label)
+                    })
+            except Exception:
+                continue
+
+    return len(valid_hairs), valid_hairs
+
+def create_visualization(true_original, sam_background, hair_info, filename, save_dir):
+    h, w = true_original.shape[:2]
+    overlay = sam_background.copy()
+    if overlay.shape[:2] != (h, w):
+        overlay = cv2.resize(overlay, (w, h), interpolation=cv2.INTER_LINEAR)
+    for i, info in enumerate(hair_info):
+        cv2.ellipse(overlay, info['ellipse'], (0, 255, 0), 2)
+        cx, cy = map(int, info['centroid'])
+        if w > 300:
+            cv2.putText(overlay, str(i), (cx, cy), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), 1)
+    border = np.zeros((h, 5, 3), dtype=np.uint8)
+    combined = np.hstack([true_original, border, overlay])
+    header_height = 50
+    header = np.zeros((header_height, combined.shape[1], 3), dtype=np.uint8)
+    info_text = f"{filename} | Count: {len(hair_info)}"
+    cv2.putText(header, info_text, (10, 35), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
+    final_vis = np.vstack([header, combined])
+    cv2.imwrite(os.path.join(save_dir, f'vis_{filename}'), final_vis)
+
+def main(args, im):
+    segment_path = os.path.join(args.img_folder, im)
+    original_path = os.path.join(args.original_folder, im)
+    sam_path = os.path.join(args.sam_folder, im)
+    if not os.path.exists(segment_path): return 0, {}
+    binary = load_segment_mask(segment_path)
+    if binary is None: return 0, {}
+    true_original = cv2.imread(original_path)
+    if true_original is None:
+        true_original = np.zeros((binary.shape[0], binary.shape[1], 3), dtype=np.uint8)
+    sam_background = cv2.imread(sam_path)
+    if sam_background is None:
+        sam_background = cv2.cvtColor(binary, cv2.COLOR_GRAY2BGR)
+
+    hair_count, hair_info = apply_watershed_hierarchical(
+        binary,
+        true_original,
+        min_area=args.min_area,
+        min_aspect_ratio=args.min_ratio,
+        min_length=args.min_length,
+        separation_factor=args.separation_factor,
+        hierarchy_levels=args.hierarchy_levels
+    )
+
+    density_data = {
+        'count': hair_count,
+        'avg_thickness': float(np.mean([h['thickness'] for h in hair_info]) if hair_info else 0),
+        'avg_length': float(np.mean([h['length'] for h in hair_info]) if hair_info else 0)
+    }
+
+    if args.draw_lines == 1:
+        vis_dir = os.path.join(args.save_path, 'visualizations')
+        os.makedirs(vis_dir, exist_ok=True)
+        create_visualization(true_original, sam_background, hair_info, im, vis_dir)
+
+    return hair_count, density_data
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--img_folder', type=str, default=DEFAULT_SEGMENT_FOLDER)
+    parser.add_argument('--original_folder', type=str, default=DEFAULT_ORIGINAL_FOLDER)
+    parser.add_argument('--sam_folder', type=str, default=DEFAULT_SEGMENT_FOLDER,
+                        help="Thư mục chứa ảnh SAM segment (Visual bên phải).")
+    parser.add_argument('--save_path', type=str, default=DEFAULT_SAVE_PATH)
+    parser.add_argument('--label_csv', type=str, default="alopecia.csv")
+    parser.add_argument('--min_area', type=int, default=1500, help="Diện tích tối thiểu (pixels).")
+    parser.add_argument('--min_length', type=int, default=20, help="Chiều dài tối thiểu (pixels).")
+    parser.add_argument('--min_ratio', type=float, default=1.0, help="Tỷ lệ Dài/Rộng tối thiểu.")
+    parser.add_argument('--separation_factor', type=float, default=0.3,
+                        help="Độ mạnh khi tách tóc dính (0.1-0.9). Cao = Tách nhiều.")
+    parser.add_argument('--hierarchy_levels', type=int, default=2,
+                        help="Số mức hierarchical (multi-level) để refine segmentation. 1 = no hierarchy.")
+    parser.add_argument('--start', type=int, default=0)
+    parser.add_argument('--end', type=int, default=20000)
+    parser.add_argument('--draw_lines', type=int, default=1)
+    args = parser.parse_args()
+
+    print(f"🚀 Bắt đầu đếm tóc (Hierarchical Watershed).")
+    print(f"   separation_factor: {args.separation_factor}, hierarchy_levels: {args.hierarchy_levels}")
+    os.makedirs(args.save_path, exist_ok=True)
+
+    img_names = []
+    if os.path.exists(args.label_csv):
+        try:
+            df = pd.read_csv(args.label_csv)
+            img_names = df["img_name"].values[args.start:args.end]
+        except:
+            pass
+    if len(img_names) == 0:
+        import glob
+        for ext in ['*.jpg', '*.png', '*.jpeg']:
+            full_paths = glob.glob(os.path.join(args.img_folder, ext))
+            img_names.extend([os.path.basename(p) for p in full_paths])
+    if len(img_names) == 0:
+        img_names = ['230219_A191_1.jpg']
+
+    print(f"🔢 Số lượng ảnh cần xử lý: {len(img_names)}")
+    results = {}
+    density_results = {}
+
+    for im in tqdm(img_names, desc="Processing"):
+        count, density = main(args, im)
+        if count > 0 or density:
+            results[im] = count
+            density_results[im] = density
+
+    csv_path = os.path.join(args.save_path, 'hair_count.csv')
+    with open(csv_path, 'w', newline='') as f:
+        w = csv.writer(f)
+        w.writerow(['image_name', 'hair_count'])
+        for k, v in results.items():
+            w.writerow([k, v])
+
+    json_path = os.path.join(args.save_path, 'density.json')
+    with open(json_path, 'w') as f:
+        json.dump(density_results, f, indent=2)
+
+    print(f"✅ Hoàn thành! Visualizations tại: {os.path.join(args.save_path, 'visualizations')}")

alopecia/calculate_hair_thickness.py

@@ -0,0 +1,174 @@
+import cv2
+import numpy as np
+import glob
+import argparse
+from tqdm import tqdm
+import os
+import warnings
+warnings.filterwarnings('ignore')
+
+def nms(boxes, thresh):
+    if len(boxes) == 0:
+        return []
+    pick = []
+    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
+    area = (x2 - x1 + 1) * (y2 - y1 + 1)
+    idxs = np.argsort(y2)
+    while len(idxs) > 0:
+        last = len(idxs) - 1
+        i = idxs[last]
+        pick.append(i)
+        xx1 = np.maximum(x1[i], x1[idxs[:last]])
+        yy1 = np.maximum(y1[i], y1[idxs[:last]])
+        xx2 = np.minimum(x2[i], x2[idxs[:last]])
+        yy2 = np.minimum(y2[i], y2[idxs[:last]])
+        w = np.maximum(0, xx2 - xx1 + 1)
+        h = np.maximum(0, yy2 - yy1 + 1)
+        overlap = (w * h) / area[idxs[:last]]
+        idxs = np.delete(idxs, np.concatenate(([last], np.where(overlap > thresh)[0])))
+    return boxes[pick]
+
+def find_pts_on_line(og, slope, d):
+    cx, cy = og
+    x1 = cx - d / ((1 + slope ** 2) ** 0.5)
+    y1 = cy - slope * cx + x1 * slope
+    if np.isnan(x1) or np.isnan(y1):
+        x1 = y1 = -1
+    return x1, y1
+
+def find_intersection_points2(center, slope, img, threshold):
+    p2 = p1 = (-1, -1)
+    w, h = img.shape
+    step, searching_len = 100, 50
+    for d in range(1, step * searching_len):
+        px, py = find_pts_on_line(center, slope, d / step)
+        if (0 < int(px) < h) and (0 < int(py) < w) and img[int(py)][int(px)] > threshold:
+            p1 = (px, py)
+        else:
+            break
+    for d in range(1, step * searching_len):
+        px, py = find_pts_on_line(center, slope, -d / step)
+        if (0 < int(px) < h) and (0 < int(py) < w) and img[int(py)][int(px)] > threshold:
+            p2 = (px, py)
+        else:
+            break
+    dst = 0 if p1 == (-1, -1) or p2 == (-1, -1) else np.linalg.norm(np.asarray(p1) - np.asarray(p2))
+    return [p1, p2], dst
+
+def get_direction2(bbox_pixels):
+    nonzero_indices = np.column_stack(np.nonzero(bbox_pixels))
+    nonzero_indices = np.float32(nonzero_indices)
+    if len(nonzero_indices) >= 2:
+        mean, eigenvectors = cv2.PCACompute(nonzero_indices, mean=None)
+        cntr = ((mean[0, 1]), (mean[0, 0]))
+        return eigenvectors[0], cntr
+    else:
+        return (0,0), (0,0)
+
+def main(img_path, save_path, save_img=True):
+    img = cv2.imread(img_path)
+    imgray = cv2.imread(img_path, cv2.IMREAD_GRAYSCALE)
+    img_name = os.path.splitext(os.path.basename(img_path))[0]
+
+    if np.all(imgray == 255) or np.all(imgray == 0):
+        np.save(os.path.join(save_path, img_name), np.array([]))
+        return
+
+    ret, binary_map = cv2.threshold(imgray, 127, 255, 0)
+    nlabels, labels, stats, centroids = cv2.connectedComponentsWithStats(binary_map, None, None, None, 8, cv2.CV_32S)
+    areas = stats[1:, cv2.CC_STAT_AREA]
+    result = np.zeros((labels.shape), np.uint8)
+    for i in range(nlabels - 1):
+        if areas[i] >= 250:
+            result[labels == i + 1] = 255
+    re_copy = result.copy()
+
+    # skeletonization
+    skel = np.zeros(result.shape, np.uint8)
+    element = cv2.getStructuringElement(cv2.MORPH_CROSS, (3,3))
+    while True:
+        open = cv2.morphologyEx(result, cv2.MORPH_OPEN, element)
+        temp = cv2.subtract(result, open)
+        eroded = cv2.erode(result, element)
+        skel = cv2.bitwise_or(skel, temp)
+        result = eroded.copy()
+        if cv2.countNonZero(result) == 0:
+            break
+
+    # remove small skeleton noise
+    nlabels, labels, stats, centroids = cv2.connectedComponentsWithStats(skel, None, None, None, 8, cv2.CV_32S)
+    areas = stats[1:, cv2.CC_STAT_AREA]
+    skel = np.zeros((labels.shape), np.uint8)
+    for i in range(nlabels - 1):
+        if areas[i] >= 5:
+            skel[labels == i + 1] = 255
+
+    filtered_image = cv2.cvtColor(re_copy, cv2.COLOR_GRAY2BGR)
+
+    # visualize skeleton
+    filtered_image[skel == 255] = [0, 255, 0]
+
+    # bounding box extraction
+    white_pixels = np.where(skel == 255)
+    x_coords, y_coords = white_pixels[1], white_pixels[0]
+    filter_size = (20, 20)
+    x1, y1 = x_coords - filter_size[0]//2, y_coords - filter_size[1]//2
+    x2, y2 = x_coords + filter_size[0]//2, y_coords + filter_size[1]//2
+    white_regions = np.column_stack((x1, y1, x2, y2))
+    white_regions = nms(white_regions, thresh=0.1)
+
+    directions, center_points, thicknesses = [], [], []
+
+    for coor in white_regions:
+        x1, y1, x2, y2 = coor
+        bbox_pixels = skel[y1:y2, x1:x2]
+        direction, mean = get_direction2(bbox_pixels)
+        directions.append(direction)
+        center_points.append((mean[0] + x1, mean[1] + y1))
+
+    perpendicular_slope = []
+    for direction in directions:
+        if direction[1] != 0:
+            perpendicular_slope.append(-1 / (direction[0] / direction[1]))
+        else:
+            perpendicular_slope.append(0)
+
+    for center_point, perp_slope in zip(center_points, perpendicular_slope):
+        intersection, dst = find_intersection_points2(center_point, perp_slope, re_copy, 200)
+        if dst != 0:
+            thicknesses.append(dst)
+        if intersection[0] != (-1, -1) and intersection[1] != (-1, -1):
+            cv2.line(filtered_image, 
+                     (int(intersection[0][0]), int(intersection[0][1])), 
+                     (int(intersection[1][0]), int(intersection[1][1])), 
+                     (0, 255, 255), 1)
+            for pt in intersection:
+                cv2.circle(filtered_image, (int(pt[0]), int(pt[1])), 3, (0, 0, 255), -1)
+
+    # display text
+    if len(thicknesses) > 0:
+        avg_thickness = np.mean(thicknesses)
+        cv2.putText(filtered_image, f"Avg thickness: {avg_thickness:.2f}px",
+                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0), 2)
+
+    if save_img:
+        #save_img_path = os.path.join(save_path, f"{img_name}_vis.jpg")
+        save_img_path = os.path.join(save_path, f"{img_name}_vis.png")
+
+        cv2.imwrite(save_img_path, filtered_image)
+
+    np.save(os.path.join(save_path, img_name), np.sort(thicknesses))
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--img_folder', type=str, default='prediction/ensemble_result/ensemble_val')
+    #parser.add_argument('--img_folder', type=str, default='datasets/seg_train/')
+    parser.add_argument('--save_path', type=str, default='alopecia/thickness_result')
+    args = parser.parse_args()
+
+    os.makedirs(args.save_path, exist_ok=True)
+    for im in tqdm(sorted(glob.glob(os.path.join(args.img_folder, '*.jpg')))):
+    #for im in tqdm(sorted(glob.glob(os.path.join(args.img_folder, '*.png')))):
+
+        main(im, args.save_path, save_img=True)

alopecia/count_result/density.json

@@ -0,0 +1,47 @@
+{
+  "test_step7_merged_foreground_230219_A200_4.jpg": {
+    "count": 8,
+    "avg_thickness": 46.929224491119385,
+    "avg_length": 450.0047779083252
+  },
+  "test_step7_merged_foreground_230219_A191_1_test.jpg": {
+    "count": 10,
+    "avg_thickness": 54.611060333251956,
+    "avg_length": 241.15121002197264
+  },
+  "test_step7_merged_foreground_230219_A191_1.jpg": {
+    "count": 10,
+    "avg_thickness": 54.45850448608398,
+    "avg_length": 238.0105888366699
+  },
+  "test_step7_merged_foreground_IMG_02C458E4D7CE-6.jpeg": {
+    "count": 14,
+    "avg_thickness": 51.27924510410854,
+    "avg_length": 175.85291181291853
+  },
+  "test_step7_merged_foreground_IMG_02C458E4D7CE-7.jpeg": {
+    "count": 8,
+    "avg_thickness": 54.27548885345459,
+    "avg_length": 192.99601650238037
+  },
+  "test_step7_merged_foreground_IMG_02C458E4D7CE-3.jpeg": {
+    "count": 8,
+    "avg_thickness": 61.52065181732178,
+    "avg_length": 262.84897232055664
+  },
+  "test_step7_merged_foreground_IMG_02C458E4D7CE-4.jpeg": {
+    "count": 10,
+    "avg_thickness": 56.64297752380371,
+    "avg_length": 114.51317901611328
+  },
+  "test_step7_merged_foreground_IMG_02C458E4D7CE-9.jpeg": {
+    "count": 11,
+    "avg_thickness": 57.8118123141202,
+    "avg_length": 165.69457591663706
+  },
+  "test_step7_merged_foreground_IMG_02C458E4D7CE-5.jpeg": {
+    "count": 11,
+    "avg_thickness": 47.383614626797765,
+    "avg_length": 199.2529823996804
+  }
+}

alopecia/thickness_result/230219_A191_1.npy

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

alopecia/thickness_result/230219_A191_1_test.npy

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

alopecia/thickness_result/230219_A200_4.npy

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

alopecia/thickness_result/IMG_02C458E4D7CE-3.npy

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

alopecia/thickness_result/IMG_02C458E4D7CE-4.npy

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

alopecia/thickness_result/IMG_02C458E4D7CE-5.npy

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

alopecia/thickness_result/IMG_02C458E4D7CE-6.npy

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

alopecia/thickness_result/IMG_02C458E4D7CE-7.npy

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

alopecia/thickness_result/IMG_02C458E4D7CE-9.npy

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

auto_run.py

@@ -0,0 +1,26 @@
+import subprocess
+
+def run_script(script_path):
+    print(f"\n🔹 Đang chạy: {script_path}")
+    result = subprocess.run(["python", script_path], capture_output=True, text=True)
+    
+    if result.returncode == 0:
+        print(f"✅ Hoàn thành: {script_path}\n")
+    else:
+        print(f"❌ Lỗi khi chạy {script_path}:\n{result.stderr}\n")
+
+if __name__ == "__main__":
+    # Danh sách file cần chạy tuần tự
+    scripts = [
+        "segmentation/u2net_test.py",
+        "segmentation/sam_guide.py",
+        "segmentation/sam_predict.py",
+        "segmentation/make_final_mask.py",
+        "alopecia/calculate_hair_thickness.py",
+        "alopecia/calculate_hair_count.py"
+    ]
+
+    for script in scripts:
+        run_script(script)
+
+    print("🎉 Hoàn tất toàn bộ quy trình!")