|
|
""" |
|
|
Lines Dataset Visualizer - Flask app to visualize line segments on cropped P&ID images |
|
|
Supports train/validation/test splits. |
|
|
""" |
|
|
|
|
|
import json |
|
|
from flask import Flask, render_template, jsonify, send_from_directory |
|
|
from pathlib import Path |
|
|
|
|
|
app = Flask(__name__) |
|
|
|
|
|
|
|
|
BASE_DIR = Path(__file__).parent.parent |
|
|
SPLITS = ["train", "validation", "test"] |
|
|
|
|
|
|
|
|
_metadata_cache = {} |
|
|
|
|
|
|
|
|
def get_split_dir(split: str) -> Path: |
|
|
"""Get the directory for a split.""" |
|
|
return BASE_DIR / split |
|
|
|
|
|
|
|
|
def load_metadata(split: str): |
|
|
"""Load all metadata from the jsonl file for a split.""" |
|
|
if split in _metadata_cache: |
|
|
return _metadata_cache[split] |
|
|
|
|
|
split_dir = get_split_dir(split) |
|
|
metadata_file = split_dir / "metadata.jsonl" |
|
|
|
|
|
if not metadata_file.exists(): |
|
|
print(f"Metadata file not found: {metadata_file}") |
|
|
_metadata_cache[split] = [] |
|
|
return [] |
|
|
|
|
|
metadata = [] |
|
|
with open(metadata_file, 'r') as f: |
|
|
for line in f: |
|
|
if line.strip(): |
|
|
metadata.append(json.loads(line)) |
|
|
|
|
|
_metadata_cache[split] = metadata |
|
|
return metadata |
|
|
|
|
|
|
|
|
def get_available_splits(): |
|
|
"""Get list of available splits that have data.""" |
|
|
available = [] |
|
|
for split in SPLITS: |
|
|
split_dir = get_split_dir(split) |
|
|
if split_dir.exists() and (split_dir / "metadata.jsonl").exists(): |
|
|
available.append(split) |
|
|
return available |
|
|
|
|
|
|
|
|
def get_sample_count(split: str): |
|
|
"""Get total number of samples in a split.""" |
|
|
return len(load_metadata(split)) |
|
|
|
|
|
|
|
|
def get_sample(split: str, idx: int) -> dict: |
|
|
"""Get a single sample by index from a split.""" |
|
|
metadata = load_metadata(split) |
|
|
if 0 <= idx < len(metadata): |
|
|
return metadata[idx] |
|
|
return None |
|
|
|
|
|
|
|
|
def get_pipelines_in_sample(sample: dict) -> list: |
|
|
"""Get unique pipelines in a sample.""" |
|
|
pipelines = sample.get("lines", {}).get("pipelines", []) |
|
|
unique = sorted(set(p for p in pipelines if p)) |
|
|
return unique |
|
|
|
|
|
|
|
|
@app.route("/") |
|
|
def index(): |
|
|
"""Serve the main page.""" |
|
|
return render_template("index.html") |
|
|
|
|
|
|
|
|
@app.route("/api/splits") |
|
|
def get_splits(): |
|
|
"""Get available splits with their sample counts.""" |
|
|
splits = get_available_splits() |
|
|
split_info = [] |
|
|
for split in splits: |
|
|
metadata = load_metadata(split) |
|
|
total_lines = sum(len(m.get("lines", {}).get("segments", [])) for m in metadata) |
|
|
split_info.append({ |
|
|
"name": split, |
|
|
"sample_count": len(metadata), |
|
|
"line_count": total_lines |
|
|
}) |
|
|
return jsonify({"splits": split_info}) |
|
|
|
|
|
|
|
|
@app.route("/api/stats") |
|
|
def get_stats(): |
|
|
"""Get overall dataset statistics.""" |
|
|
total_samples = 0 |
|
|
total_lines = 0 |
|
|
solid_count = 0 |
|
|
dashed_count = 0 |
|
|
source_images = set() |
|
|
|
|
|
for split in get_available_splits(): |
|
|
metadata = load_metadata(split) |
|
|
total_samples += len(metadata) |
|
|
|
|
|
for m in metadata: |
|
|
source_images.add(m.get("source_image_idx", 0)) |
|
|
lines_data = m.get("lines", {}) |
|
|
segments = lines_data.get("segments", []) |
|
|
line_types = lines_data.get("line_types", []) |
|
|
|
|
|
total_lines += len(segments) |
|
|
solid_count += sum(1 for t in line_types if t == "solid") |
|
|
dashed_count += sum(1 for t in line_types if t == "dashed") |
|
|
|
|
|
return jsonify({ |
|
|
"total_samples": total_samples, |
|
|
"total_lines": total_lines, |
|
|
"source_images": len(source_images), |
|
|
"solid_lines": solid_count, |
|
|
"dashed_lines": dashed_count |
|
|
}) |
|
|
|
|
|
|
|
|
@app.route("/api/<split>/stats") |
|
|
def get_split_stats(split): |
|
|
"""Get statistics for a specific split.""" |
|
|
if split not in get_available_splits(): |
|
|
return jsonify({"error": "Split not found"}), 404 |
|
|
|
|
|
metadata = load_metadata(split) |
|
|
total_lines = sum(len(m.get("lines", {}).get("segments", [])) for m in metadata) |
|
|
|
|
|
solid_count = 0 |
|
|
dashed_count = 0 |
|
|
source_images = set() |
|
|
|
|
|
for m in metadata: |
|
|
source_images.add(m.get("source_image_idx", 0)) |
|
|
line_types = m.get("lines", {}).get("line_types", []) |
|
|
solid_count += sum(1 for t in line_types if t == "solid") |
|
|
dashed_count += sum(1 for t in line_types if t == "dashed") |
|
|
|
|
|
return jsonify({ |
|
|
"split": split, |
|
|
"total_samples": len(metadata), |
|
|
"total_lines": total_lines, |
|
|
"source_images": len(source_images), |
|
|
"solid_lines": solid_count, |
|
|
"dashed_lines": dashed_count |
|
|
}) |
|
|
|
|
|
|
|
|
@app.route("/api/<split>/samples") |
|
|
def get_all_samples(split): |
|
|
"""Get list of all sample indices and basic info for a split.""" |
|
|
if split not in get_available_splits(): |
|
|
return jsonify({"error": "Split not found"}), 404 |
|
|
|
|
|
metadata = load_metadata(split) |
|
|
samples = [] |
|
|
for idx, m in enumerate(metadata): |
|
|
samples.append({ |
|
|
"idx": idx, |
|
|
"file_name": m.get("file_name"), |
|
|
"source_image_idx": m.get("source_image_idx"), |
|
|
"width": m.get("width"), |
|
|
"height": m.get("height"), |
|
|
"line_count": len(m.get("lines", {}).get("segments", [])) |
|
|
}) |
|
|
return jsonify({"samples": samples, "count": len(samples)}) |
|
|
|
|
|
|
|
|
@app.route("/api/<split>/sample/<int:idx>") |
|
|
def get_sample_data(split, idx): |
|
|
"""Get detailed data for a single sample.""" |
|
|
if split not in get_available_splits(): |
|
|
return jsonify({"error": "Split not found"}), 404 |
|
|
|
|
|
sample = get_sample(split, idx) |
|
|
if sample is None: |
|
|
return jsonify({"error": "Sample not found"}), 404 |
|
|
|
|
|
lines_data = sample.get("lines", {}) |
|
|
segments = lines_data.get("segments", []) |
|
|
line_types = lines_data.get("line_types", []) |
|
|
pipelines = lines_data.get("pipelines", []) |
|
|
|
|
|
|
|
|
lines = [] |
|
|
for i, seg in enumerate(segments): |
|
|
lines.append({ |
|
|
"idx": i, |
|
|
"segment": seg, |
|
|
"type": line_types[i] if i < len(line_types) else "solid", |
|
|
"pipeline": pipelines[i] if i < len(pipelines) else "" |
|
|
}) |
|
|
|
|
|
return jsonify({ |
|
|
"file_name": sample.get("file_name"), |
|
|
"source_image_idx": sample.get("source_image_idx"), |
|
|
"crop_idx": sample.get("crop_idx"), |
|
|
"width": sample.get("width"), |
|
|
"height": sample.get("height"), |
|
|
"lines": lines, |
|
|
"line_count": len(lines), |
|
|
"unique_pipelines": get_pipelines_in_sample(sample) |
|
|
}) |
|
|
|
|
|
|
|
|
@app.route("/images/<split>/<path:filename>") |
|
|
def serve_image(split, filename): |
|
|
"""Serve images from a split directory.""" |
|
|
split_dir = get_split_dir(split) |
|
|
return send_from_directory(split_dir, filename) |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
print("Starting Lines Dataset Visualizer...") |
|
|
print(f"Base directory: {BASE_DIR}") |
|
|
|
|
|
available_splits = get_available_splits() |
|
|
print(f"Available splits: {available_splits}") |
|
|
|
|
|
for split in available_splits: |
|
|
count = get_sample_count(split) |
|
|
print(f" {split}: {count} samples") |
|
|
|
|
|
app.run(debug=True, port=5051) |
|
|
|
