AVOID — Stale and unlicensed — last commit 3y ago

• 6 active contributors
• ⚠ Stale — last commit 3y ago
• ⚠ Single-maintainer risk — top contributor 93% of recent commits
• ⚠ No license — legally unclear to depend on
• ⚠ No CI workflows detected
• ⚠ No test directory detected
• ⚠ Scorecard: marked unmaintained (0/10)
• ⚠ Scorecard: default branch unprotected (0/10)

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests + OpenSSF Scorecard}

CURL (Neural Curve Layers) is a deep learning model for global image enhancement that learns per-pixel tone curve transformations to improve underexposed or color-cast photos. It replaces traditional hand-tuned image processing pipelines with a neural network that predicts RGB curves for brightness, contrast, and color correction in a single forward pass. Monolithic single-directory structure: core training/inference logic in main.py, model architecture defined in model.py, data loading in data.py, utility functions in util.py, and metric computation in metric.py. Pretrained weights stored in pretrained_models/adobe_dpe/ with example inputs/outputs in adobe5k_dpe/. No modular package structure—everything is script-based.

Computer vision researchers and photo editing application developers who need automatic image enhancement. Specifically useful for photographers and computational photography teams building autonomous photo enhancement pipelines without manual parameter tuning.

The repo is research code from ICPR 2020 (published 2020, updated May 2022). It shows community engagement with two refactored versions in issues (#27, #31), but the original code remains batch-size-limited and the authors explicitly warn they haven't tested community patches. This is academically mature but production-use requires caution.

Critical limitation: code designed for batch_size=1 only; community attempted patches exist but authors haven't validated them. Dependencies are pinned to 2020-era libraries (torch==1.7.1, torchvision==0.8.2) with potential compatibility issues on modern systems. Single maintainer (sjmoran), no CI/CD pipeline visible, no test suite in file structure. The refactored and large_batch versions fork the codebase, creating maintenance fragmentation.

No recent active development visible. Last documented update is May 2022 when community contributions for batch>1 support were acknowledged but not merged. The repo appears to be in maintenance-only mode; the main activity is issue reports about batch size limitations and requests for improvements.

git clone https://github.com/sjmoran/curl-image-enhancement.git
cd curl-image-enhancement
pip install -r requirements.txt
python main.py --help

Refer to Colab Demo.ipynb for a runnable example without local setup.

Daily commands: For inference: python main.py --input_image path/to/image.png --model_path pretrained_models/adobe_dpe/curl_*_model.pt --output_dir ./output. For training: python main.py --mode train --dataset_dir adobe5k_dpe/ --batch_size 1 --num_epochs 500. See README.md for full CLI arguments.

• main.py — Entry point for training and inference; orchestrates the entire pipeline including data loading, model initialization, and training loop—essential for understanding workflow
• model.py — Defines the CURL neural network architecture with curve layers; core ML abstraction that every contributor must understand
• data.py — Handles dataset loading and preprocessing for Adobe DPE; critical for training pipeline and data integrity
• metric.py — Implements PSNR and SSIM evaluation metrics; used throughout training and validation to measure enhancement quality
• util.py — Shared utility functions for image I/O and tensor operations; foundational helpers used across the codebase
• requirements.txt — Specifies PyTorch 1.7.1, scikit-image, and other critical dependencies; batch size 1 constraint is documented in README
• pretrained_models/adobe_dpe/curl_validpsnr_23.073045286204017_validloss_0.0701291635632515_testpsnr_23.584083321292365_testloss_0.061363041400909424_epoch_510_model.pt — Pre-trained model weights for Adobe DPE dataset; required for inference without retraining

Train on a custom dataset

1. Create a new dataset class in data.py inheriting from torch.utils.data.Dataset with len and getitem returning (input_image_tensor, target_image_tensor) (data.py)
2. Add dataset selection logic to the main.py argument parser and instantiation (e.g., add --dataset flag and conditional in train_setup()) (main.py)
3. Ensure images are normalized to [0, 1] and match the model input shape expected by model.py forward pass (data.py)

Modify the CURL architecture (e.g., add skip connections or change curve parameters)

1. Edit the CURLNet class init and forward methods in model.py to add new layers or parametrizations (model.py)
2. Update main.py model initialization if new hyperparameters are required (e.g., num_curves, curve_control_points) (main.py)
3. Run a quick validation on sample data to verify output shape consistency and no dimension mismatches (model.py)

Evaluate pre-trained model on test data and export results

1. Load checkpoint from pretrained_models/adobe_dpe/ in main.py using torch.load() and model.load_state_dict() (main.py)
2. Set model to eval mode and disable gradients, then loop through test dataset from data.py (main.py)
3. For each batch, compute PSNR and SSIM using metric.py functions and save outputs using util.py image writers (metric.py)

Change loss function or optimization strategy

1. Modify the loss computation in main.py training loop (currently MSE loss); swap torch.nn.MSELoss() for L1Loss, perceptual loss, or custom loss (main.py)
2. Update optimizer choice (currently assumes Adam); change torch.optim.Adam to SGD, RMSprop, etc. with appropriate learning rate scheduling (main.py)
3. Verify backward pass still computes gradients correctly by checking model.parameters() are updated after loss.backward() (main.py)

• PyTorch 1.7.1 — Deep learning framework for neural curve layer implementation; autograd enables end-to-end training of parametric enhancement curves
• NumPy 1.22.0 & SciPy 1.5.2 — Numerical operations for metric computation and image preprocessing; SciPy provides convolution primitives for SSIM calculation
• scikit-image 0.18.1 — PSNR and SSIM metric implementations; provides reference implementations validated against standard benchmarks
• PIL/Pillow 8.1.2 — Image file I/O and format conversion; essential for loading diverse image formats from Adobe DPE dataset

• Batch size fixed to 1 in data.py and model.py

  • Why: Simplifies curve layer computation and reduces memory overhead during development; allows training on limited GPU memory
  • Consequence: Training is 10–100× slower; GPU utilization is poor; mini-batch statistics unavailable for batch normalization (if added)

• Global enhancement only (no spatial/local adjustments)

  • Why: Reduces parameter count and training complexity; curve layers apply single transformation to all pixels
  • Consequence: Cannot handle spatially-varying defects (e.g., vignetting, localized noise); results may be suboptimal for images with mixed lighting

• MSE loss in training loop

  • Why: Simple, differentiable, and well-understood; easy to implement and debug
  • Consequence: Penalizes outliers equally; may not match human perceptual quality; alternative losses (L1, perceptual) not explored in codebase

• Single-path architecture (no multi-scale or multi-branch processing)

  • Why: Computational efficiency and code simplicity; aligns with ICPR 2020 submission constraints
  • Consequence: Limited receptive field; may miss fine details or global context in complex images

• Does not support batch processing (batch_size > 1) — README explicitly states batch size must be 1
• Does not include real-time inference optimization (no quantization, pruning, or mobile deployment)
• Does not provide UI or interactive adjustment tools; command-line and Python API only
• Does not handle video enhancement; image-based only
• Does not implement domain adaptation or transfer learning to other datasets (Adobe DPE dataset-specific)

CRITICAL: batch_size=1 hardcoded in forward pass; code will fail or produce incorrect results with batch_size>1 despite config accepting it. Pretrained weights expect 3-channel RGB input; grayscale images will cause shape mismatch. Dataset paths are absolute/relative-fragile; adobe5k_dpe/ must exist or data.py fails silently. No GPU detection or CPU fallback—code assumes CUDA availability without explicit error message. Epoch numbering in saved model filenames (e.g., epoch_510) is off-by-one from training loop convention.

• Tone curve / LUT (Look-Up Table) transformation — CURL's core innovation is learning per-pixel tone curves instead of global ones; understanding how curves map pixel values through learned 3D RGB space is essential to the model design
• Perceptual loss (L1/L2 vs. SSIM-weighted) — metric.py uses both MSE and SSIM; understanding why SSIM aligns better with human perception than pixel-level L2 loss informs training strategy choices
• Batch normalization with batch_size=1 — The batch_size=1 constraint breaks typical batch norm behavior (statistics computed on single sample); explains why community members struggled to scale this architecture
• Global vs. local image enhancement — CURL learns global tone curves (same curve per pixel channel across image); knowing this limitation explains why it struggles with spatially-varying lighting (author's later work addresses this)
• Adobe5K-DPE dataset (MIT-Adobe FiveK subset) — Benchmark dataset with expert edits; understanding the data distribution (500 train, 50 valid, 50 test images) is critical for reproducibility and knowing generalization limits
• 3D color space parameterization (RGB histogram binning) — The curve layer quantizes the RGB space into bins; model.py's binning strategy directly affects curve smoothness and memory footprint

• aashishkumar/DPED — Earlier deep photo enhancement dataset and method; CURL's predecessor work that uses the same Adobe5K-DPE dataset
• cydonia999/Learning_to_Enhance_with_Perceptual_Loss — Concurrent image enhancement work using perceptual loss; alternative approach to the same problem without explicit curve layers
• sjmoran/deep-local-parametrization — Author's follow-up work extending local (spatially-varying) tone curves; natural evolution of CURL
• sjmoran/enlightenment-denoising — Author's other enhancement work combining denoising and enlightenment; complementary to CURL's color/contrast correction
• twhuan/MIRNet-TFGAN — Multi-scale residual network for image restoration; modern alternative architecture for similar enhancement tasks

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add batch size support and unit tests for model.py

The README explicitly states 'this code is designed for a batch size of 1' and 'needs re-engineered to support higher batch sizes.' This is a critical limitation. A contributor could refactor the curve layer operations in model.py to support arbitrary batch sizes and add comprehensive unit tests validating batch size compatibility (1, 2, 4, 8, 16). This would directly address the maintainer's note and unlock higher throughput usage.

• [ ] Identify batch-dependent operations in model.py (likely in curve layer forward pass)
• [ ] Refactor tensor operations to handle batch dimension correctly
• [ ] Create test_model.py with unit tests for batch sizes [1, 2, 4, 8, 16]
• [ ] Validate against existing pretrained_models/adobe_dpe weights to ensure backward compatibility
• [ ] Update README with new batch size capabilities and performance benchmarks

Add inference validation tests for adobe5k_dpe example outputs

The repo contains adobe5k_dpe test data with input images, reference outputs, and metrics (PSNR/SSIM) embedded in filenames. However, there are no automated tests that verify the pretrained model produces outputs matching these expected metrics. Adding test_inference.py would validate model integrity and catch regressions when dependencies are updated.

• [ ] Create test_inference.py that loads adobe5k_dpe/curl_example_test_input images
• [ ] Use pretrained_models/adobe_dpe model to generate outputs
• [ ] Extract expected PSNR/SSIM from filename metadata in adobe5k_dpe/curl_example_test_inference
• [ ] Compare generated metrics against expected values with tolerance thresholds
• [ ] Add test execution to a GitHub Actions CI workflow for regression detection

Create utility module for image I/O and metric computation with type hints

Currently metric.py and util.py are minimal utility files, and image loading/saving logic is scattered across main.py, data.py, and raw_ted.py. Python 3.7+ type hints are absent. Consolidating image I/O operations (loading PNGs with different naming schemes from adobe5k_dpe), metric computation, and adding type hints would improve maintainability and enable better IDE support for contributors.

• [ ] Review data.py, raw_ted.py, rgb_ted.py for duplicated image loading logic (particularly for adobe5k_dpe dataset)
• [ ] Create image_utils.py with typed functions: load_image(path: str) -> np.ndarray, save_image(array: np.ndarray, path: str) -> None
• [ ] Add type hints to existing metric.py functions (e.g., psnr(img1: np.ndarray, img2: np.ndarray) -> float)
• [ ] Refactor data.py and main.py to use centralized image_utils module
• [ ] Add docstrings explaining dataset naming conventions (e.g., '_VALID_510_30_PSNR_27.756')

• Add a pytest-based test suite covering model.py curve layer outputs for batch_size=1,2,4; currently no tests exist and batch size support is broken.
• Document the curve layer mathematics with inline comments in model.py; the ICPR paper explains it but code comments are minimal, blocking understanding for new contributors.
• Create a Dockerfile with pinned PyTorch 1.7.1 and test it end-to-end (clone → install → inference on adobe5k_dpe examples); dependency hell is unresolved and this would unblock modern system testing.

The codebase has significant security concerns primarily stemming from outdated and vulnerable dependencies (numpy, torch, scipy

• High · Outdated and Vulnerable Dependencies — requirements.txt. Multiple dependencies have known security vulnerabilities and are significantly outdated. numpy==1.22.0 (released Jan 2022), torch==1.7.1 (released Oct 2020), torchvision==0.8.2 (released Nov 2020), and scipy==1.5.2 (released Jun 2020) contain known CVEs including buffer overflow, denial of service, and arbitrary code execution vulnerabilities. Fix: Update all dependencies to their latest stable versions. Specifically: numpy>=1.26.0, torch>=2.0.0, torchvision>=0.15.0, scipy>=1.11.0. Run 'pip install --upgrade -r requirements.txt' and test thoroughly before deployment.
• High · Pillow Version Constraint Too Loose — requirements.txt. Pillow>=8.1.2 uses a lower bound version constraint without an upper bound. Pillow 8.1.x through 9.4.x contain multiple CVEs (CVE-2022-22815, CVE-2022-22816, CVE-2022-22817). Without pinning to a minimum secure version, installations may pull vulnerable versions. Fix: Update to Pillow>=10.0.0 (current stable). Change 'Pillow>=8.1.2' to 'Pillow>=10.0.0,<11.0.0' for better version control.
• Medium · Skimage Package Ambiguity — requirements.txt. The package 'skimage==0.0' listed in requirements.txt appears to be an incorrect or placeholder version. The actual scikit-image package (imported as skimage) is separately listed as scikit_image==0.18.1. This creates confusion and the skimage==0.0 entry will fail to install properly. Fix: Remove the 'skimage==0.0' entry from requirements.txt. Use only 'scikit-image>=0.19.0' and update to a modern version (>=0.21.0) that addresses security and functionality issues.
• Medium · No Input Validation Visible in Data Processing — data.py, raw_ted.py, main.py. The codebase includes data.py and raw_ted.py which likely process user-supplied image files. Without visible input validation in the file structure, there's risk of malformed image file handling, path traversal attacks, or denial of service through crafted input files. Fix: Implement strict input validation: validate file extensions, file sizes, and use secure path handling (pathlib.Path, os.path.abspath). Sanitize all file paths to prevent directory traversal. Add file format validation using magic bytes rather than extensions alone.
• Medium · Hardcoded Model Paths — pretrained_models/ directory, likely referenced in model.py and main.py. The directory structure shows pretrained_models with hardcoded model paths. If these paths are referenced with string concatenation in code without validation, this could allow arbitrary file access or model substitution attacks. Fix: Use environment variables or configuration files for model paths. Implement file integrity checks using cryptographic hashes (SHA-256) to verify model files haven't been tampered with before loading.
• Low · No Security Headers or CORS Configuration — Colab Demo.ipynb. While this is primarily a local ML research codebase, the Colab Demo notebook may be exposed to web environments without proper security considerations. No evidence of security headers or CORS restrictions visible. Fix: If exposing this via web service: implement Content Security Policy headers, disable CORS for untrusted origins, validate all user inputs at API boundaries. Consider running inference in isolated containers.
• Low · Missing Dependency Lock File — Repository root. No requirements.lock or poetry.lock file is present, making reproducible builds difficult and increasing supply chain risk if transitive dependencies are compromised. Fix: Generate a lock file using 'pip freeze > requirements.lock' or use Poetry (poetry.lock) or Pipenv (Pipfile.lock) for deterministic dependency resolution and better security tracking.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Read in the suggested order before editing unfamiliar code. The reading-order list is computed from the actual import graph, not LLM guesses; reading bottom-up materially reduces wrong-edit risk.
3. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
4. Cite source on changes. When proposing an edit, cite the specific path/to/file.ext:Lstart-Lend you're reasoning about, the same way RepoPilot's own RAG cites code in https://repopilot.app/r/sjmoran/curl-image-enhancement.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live sjmoran/curl-image-enhancement repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/sjmoran/curl-image-enhancement.

What it runs against: a local clone of sjmoran/curl-image-enhancement — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in sjmoran/curl-image-enhancement | Confirms the artifact applies here, not a fork | | 2 | Default branch master exists | Catches branch renames | | 3 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 4 | Last commit ≤ 1072 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of sjmoran/curl-image-enhancement. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/sjmoran/curl-image-enhancement.git
#   cd curl-image-enhancement
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of sjmoran/curl-image-enhancement and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "sjmoran/curl-image-enhancement(\\.git)?\\b" \\
  && ok "origin remote is sjmoran/curl-image-enhancement" \\
  || miss "origin remote is not sjmoran/curl-image-enhancement (artifact may be from a fork)"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "main.py" \\
  && ok "main.py" \\
  || miss "missing critical file: main.py"
test -f "model.py" \\
  && ok "model.py" \\
  || miss "missing critical file: model.py"
test -f "data.py" \\
  && ok "data.py" \\
  || miss "missing critical file: data.py"
test -f "metric.py" \\
  && ok "metric.py" \\
  || miss "missing critical file: metric.py"
test -f "util.py" \\
  && ok "util.py" \\
  || miss "missing critical file: util.py"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 1072 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1042d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/sjmoran/curl-image-enhancement"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Computed from the actual import graph (no LLM). Read in this order to learn the codebase from the foundation up — each step builds on the previous ones.

1. util.py — Foundation: doesn't import anything internally and is imported by 3 other files. Read first to learn the vocabulary.
2. rgb_ted.py — Foundation: imported by 1, no internal dependencies of its own.
3. model.py — Built on the foundation; imported by 1 downstream file.
4. data.py — Built on the foundation; imported by 1 downstream file.
5. main.py — Layer 2 — application-level code that wires the lower layers together.

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.