# How Does the Image‑Generation Gate (Line‑Art) Determine if Existing Images Are Sufficient?

> Learn how the image generation gate determines if existing images are sufficient. Discover its validation fallback to text-to-image generation.

- Repository: [handsomestWei/patent-disclosure-skill](https://github.com/handsomestWei/patent-disclosure-skill)
- Tags: deep-dive
- Published: 2026-09-02

---

**The line‑art gate declares existing images sufficient when at least one file referenced in a view's `source_paths` exists and is readable; otherwise it fails validation or falls back to text‑to‑image generation.**

In the `handsomestWei/patent-disclosure-skill` repository, the **image‑generation gate (line‑art)** controls whether line‑art workflows proceed with existing reference images or synthesize new ones. This decision logic lives in [`tools/shared/design_lineart_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tools/shared/design_lineart_gate.py) and operates through a strict two‑phase validation system that checks file existence before any image processing begins.

## Validation Phase: Checking Source Image Availability

The gate's primary method, `run_check`, enforces the sufficiency rule during the validation phase. It loads the *`design_lineart_brief`* and invokes `validate_brief` to inspect every defined view.

For each view, the gate examines the `source_paths` list:

- Each path is resolved to an absolute path via `_resolve_path`
- The gate verifies whether the file exists on disk
- If **no path exists**, it records a specific error: `"views[i] 源图不存在: …"`
- If **none of the listed images are readable**, it adds the aggregated error: `"views[i] 无任何可读源图"`【lines 89‑101】

The entire check returns `ok: false` whenever any view lacks at least one usable reference image. This hard failure prevents downstream processing from attempting operations on missing files.

## Job‑Preparation Phase: Building Work Units from Valid Images

Once validation passes, `build_jobs` constructs executable job specifications. This phase performs a second, pragmatic resolution of `source_paths`:

```python

# From tools/shared/design_lineart_gate.py, lines 25-30

for raw_path in view.get("source_paths", []):
    resolved = _resolve_path(case_dir, str(raw_path))
    if resolved.is_file():
        job["source_paths"].append(str(resolved))

```

Only paths that point to actual files are retained. Views with an empty `resolved` list after this filtering will trigger the fallback behavior in subsequent pipeline stages.

## Fallback Behavior When No Images Are Sufficient

The gate itself does not generate images—it prepares the job structure that enables generation decisions downstream. When a view's `resolved` list is empty, the later image‑generation logic falls back to **text‑to‑image (txt2img)** synthesis.

The prompt for this synthesis is assembled automatically **only when no explicit `gen_prompt` is supplied**【lines 33‑44】:

```python

# Conceptual flow from the gate's build_jobs logic

if not job["source_paths"] and not view.get("gen_prompt"):
    job["gen_prompt"] = auto_assemble_prompt(view)

```

This ensures the pipeline never stalls: sufficient images enable `img2img` reference‑based generation, while their absence triggers prompt‑driven creation.

## Running the Line‑Art Gate as a CLI Tool

The module exposes direct command‑line interfaces for inspection and job preparation.

Validate a case directory exclusively for source‑image sufficiency:

```bash
python tools/shared/design_lineart_gate.py --case-dir outputs/my_case --check

# Output: JSON report with "ok": true/false and per‑view error details

```

Prepare jobs after successful validation:

```bash
python tools/shared/design_lineart_gate.py --case-dir outputs/my_case --prepare-jobs

# Creates: lineart_assist/design_lineart_jobs.json

```

Each generated job contains:
- **`source_paths`**: filtered list of verified existing images
- **`gen_prompt`**: auto‑generated when no images are found
- **`output_path`**: destination for the final line‑art PNG

## Core Decision Logic in Python

The gate's sufficiency test can be replicated directly:

```python
from pathlib import Path
from tools.shared.design_lineart_gate import _resolve_path

def has_sufficient_images(case_dir: Path, view: dict) -> bool:
    """
    Determine if a view has at least one readable source image.
    Mirrors the gate's internal validation logic.
    """
    for raw in view.get("source_paths") or []:
        if _resolve_path(case_dir, str(raw)).is_file():
            return True
    return False

```

This function returns `True` exactly when the gate would permit progression—establishing the same **existence‑and‑readability** criterion.

## Key Source Files in the Repository

| File | Purpose |
|------|---------|
| [`tools/shared/design_lineart_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tools/shared/design_lineart_gate.py) | Core implementation: `run_check`, `validate_brief`, `build_jobs`, and `_resolve_path` |
| [`tests/shared/test_design_lineart_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tests/shared/test_design_lineart_gate.py) | Unit tests verifying behavior across present, missing, and partially‑available source images |
| [`references/schemas/design_lineart_brief.schema.yaml`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/references/schemas/design_lineart_brief.schema.yaml) | JSON Schema defining valid brief structure for gate consumption |
| [`prompts/shared/image_gen.md`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/prompts/shared/image_gen.md) | Documentation of automatic txt2img prompts used in fallback scenarios |

## Summary

- **Existence check**: The gate requires at least one file in `source_paths` to resolve to a readable path
- **Strict validation**: Any view failing this check causes `ok: false` and halts processing
- **Dual path filtering**: Validation and job‑preparation both resolve and verify, ensuring no stale references propagate
- **Graceful degradation**: Empty source lists trigger automatic prompt generation for pure text‑to‑image synthesis
- **Pipeline integration**: The gate's output jobs explicitly separate `img2img` (reference‑based) from `txt2img` (prompt‑based) execution paths

## Frequently Asked Questions

### What happens if some source images exist but others are missing?

The gate accepts a view as sufficient when **any** listed image is readable. Missing paths are silently excluded during job preparation; the pipeline proceeds with whatever valid references remain.

### Can the gate be bypassed to force text‑to‑image generation?

Yes—by ensuring no `source_paths` entries resolve to existing files and omitting any explicit `gen_prompt`, the gate will produce jobs with empty source lists and auto‑assembled prompts, triggering downstream txt2img logic.

### How does `_resolve_path` handle relative paths?

The helper resolves paths relative to the specified `case_dir`, converting them to absolute filesystem locations before existence checks. This anchors all references to the case directory structure.

### Where are validation errors surfaced for debugging?

Errors are embedded in the JSON output from `run_check`, with per‑view messages indicating specific missing files or complete source‑image absence. Unit tests in [`tests/shared/test_design_lineart_gate.py`](https://github.com/handsomestWei/patent-disclosure-skill/blob/main/tests/shared/test_design_lineart_gate.py) demonstrate expected error formats.