FA-51801 / Raster clipping / Open access

Polyline strip window clip: rejected edge keeps piece · case 01

A fully outside edge does not end the current piece, so a later part starting at the same boundary point joins it.

Verified by executionVariant 1 · 11 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

A fully outside edge does not end the current piece, so a later part starting at the same boundary point joins it.

VERIFIED REPAIR

Restore the specified clipping decision at rejected edge keeps piece. Each command is [points,closed]. Consecutive vertices (plus the closing edge when closed and at least three points) are clipped against the closed pixel-center window [0,size-1]x[0,size-1] with exact parametric clipping. Visible parts that start where the current piece ends extend it (skipping zero-length repeats); any other visible part starts a new piece; a fully rejected edge ends the current piece. For closed paths, a last piece ending where the first piece begins is merged in front of it without repeating the joint. Pieces with fewer than two vertices are dropped. Vertices are exact rational strings.

Unsuccessful approach: Ending only pieces with an interior vertex still joins two-vertex pieces across an outside edge.

Case contract

Each command is [points,closed]. Consecutive vertices (plus the closing edge when closed and at least three points) are clipped against the closed pixel-center window [0,size-1]x[0,size-1] with exact parametric clipping. Visible parts that start where the current piece ends extend it (skipping zero-length repeats); any other visible part starts a new piece; a fully rejected edge ends the current piece. For closed paths, a last piece ending where the first piece begins is merged in front of it without repeating the joint. Pieces with fewer than two vertices are dropped. Vertices are exact rational strings.

Why this case matters

Raster clipping decides which pixels a primitive may touch; a single wrong clip decision writes outside the target or scissor, or silently drops visible coverage.

1 / The failure

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def seg(p,q):
        t0,t1=Fraction(0),Fraction(1)
        for d,e in ((q[0]-p[0],p[0]),(q[1]-p[1],p[1])):
            for pp,qq in ((-d,e),(d,size-1-e)):
                if pp==0:
                    if qq<0: return None
                else:
                    u=qq/pp
                    if pp<0: t0=max(t0,u)
                    else: t1=min(t1,u)
        if t0>t1: return None
        a=(p[0]+t0*(q[0]-p[0]),p[1]+t0*(q[1]-p[1]))
        b=(p[0]+t1*(q[0]-p[0]),p[1]+t1*(q[1]-p[1]))
        return a,b
    out=[]
    for points,closed in commands:
        pts=[(Fraction(x),Fraction(y)) for x,y in points]
        edges=list(zip(pts,pts[1:]))
        if closed and len(pts)>2: edges.append((pts[-1],pts[0]))
        pieces=[]
        current=None
        for p,q in edges:
            part=seg(p,q)
            if part is None:
                continue
            a,b=part
            if current is not None and current[-1]==a:
                if b!=a: current.append(b)
            else:
                current=[a] if a==b else [a,b]
                pieces.append(current)
        if closed and len(pieces)>1 and pieces[0][0]==pieces[-1][-1]:
            pieces[0][:0]=pieces.pop()[:-1]
        pieces=[pc for pc in pieces if len(pc)>=2]
        out.append([[[str(x),str(y)] for x,y in pc] for pc in pieces])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [4, 1], [4, 4]], False]], 6), [[[['1', '1'], ['4', '1'], ['4', '4']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 6), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 6), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 6), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 6), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 6), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 6), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 6), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 6), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 6), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 6), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5]], False]], 7), [[[['1', '1'], ['5', '1'], ['5', '5']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 7), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 7), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 7), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 7), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 7), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 7), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 7), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 7), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 7), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 7), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6]], False]], 8), [[[['1', '1'], ['6', '1'], ['6', '6']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 8), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 8), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 8), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 8), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 8), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 8), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 8), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 8), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 8), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 8), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7]], False]], 9), [[[['1', '1'], ['7', '1'], ['7', '7']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 9), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 9), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 9), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 9), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 9), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 9), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 9), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 9), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 9), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 9), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8]], False]], 10), [[[['1', '1'], ['8', '1'], ['8', '8']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 10), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 10), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 10), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 10), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 10), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 10), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 10), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 10), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 10), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 10), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
explicit case 0	`[[[['1', '1'], ['4', '1'], ['4', '4']]]]`	`[[[['1', '1'], ['4', '1'], ['4', '4']]]]`	Passed
explicit case 1	`[[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]]`	`[[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]]`	Passed
explicit case 2	`[[[['1', '1'], ['2', '1'], ['3', '2']]]]`	`[[[['1', '1'], ['2', '1'], ['3', '2']]]]`	Passed
explicit case 3	`[[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]]`	`[[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]]`	Passed
explicit case 4	`[[[['1', '0'], ['2', '2']]]]`	`[[[['1', '0'], ['2', '2']]]]`	Passed
explicit case 5	`[[]]`	`[[]]`	Passed
explicit case 6	`[[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]]`	`[[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]]`	Passed
explicit case 7	`[[[['1', '1'], ['3', '1']]]]`	`[[[['1', '1'], ['3', '1']]]]`	Passed
explicit case 8	`[[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]]`	`[[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]]`	Passed
explicit case 9	`[[[['0', '2'], ['2', '2'], ['2', '0']]]]`	`[[[['0', '2'], ['2', '2'], ['2', '0']]]]`	Passed
explicit case 10	`[[[['2', '1'], ['1', '0'], ['2', '2']]]]`	`[[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]]`	Failed

SHA-256 / f958d56a76d78e2a916077ee20c04d052c3a9035e1ec280142b0ddf781a618b8

2 / The unsuccessful fix

Exit 1

"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def seg(p,q):
        t0,t1=Fraction(0),Fraction(1)
        for d,e in ((q[0]-p[0],p[0]),(q[1]-p[1],p[1])):
            for pp,qq in ((-d,e),(d,size-1-e)):
                if pp==0:
                    if qq<0: return None
                else:
                    u=qq/pp
                    if pp<0: t0=max(t0,u)
                    else: t1=min(t1,u)
        if t0>t1: return None
        a=(p[0]+t0*(q[0]-p[0]),p[1]+t0*(q[1]-p[1]))
        b=(p[0]+t1*(q[0]-p[0]),p[1]+t1*(q[1]-p[1]))
        return a,b
    out=[]
    for points,closed in commands:
        pts=[(Fraction(x),Fraction(y)) for x,y in points]
        edges=list(zip(pts,pts[1:]))
        if closed and len(pts)>2: edges.append((pts[-1],pts[0]))
        pieces=[]
        current=None
        for p,q in edges:
            part=seg(p,q)
            if part is None:
                current=None if current and len(current)>2 else current
                continue
            a,b=part
            if current is not None and current[-1]==a:
                if b!=a: current.append(b)
            else:
                current=[a] if a==b else [a,b]
                pieces.append(current)
        if closed and len(pieces)>1 and pieces[0][0]==pieces[-1][-1]:
            pieces[0][:0]=pieces.pop()[:-1]
        pieces=[pc for pc in pieces if len(pc)>=2]
        out.append([[[str(x),str(y)] for x,y in pc] for pc in pieces])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [4, 1], [4, 4]], False]], 6), [[[['1', '1'], ['4', '1'], ['4', '4']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 6), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 6), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 6), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 6), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 6), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 6), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 6), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 6), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 6), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 6), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5]], False]], 7), [[[['1', '1'], ['5', '1'], ['5', '5']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 7), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 7), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 7), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 7), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 7), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 7), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 7), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 7), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 7), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 7), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6]], False]], 8), [[[['1', '1'], ['6', '1'], ['6', '6']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 8), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 8), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 8), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 8), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 8), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 8), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 8), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 8), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 8), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 8), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7]], False]], 9), [[[['1', '1'], ['7', '1'], ['7', '7']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 9), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 9), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 9), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 9), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 9), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 9), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 9), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 9), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 9), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 9), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8]], False]], 10), [[[['1', '1'], ['8', '1'], ['8', '8']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 10), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 10), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 10), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 10), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 10), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 10), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 10), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 10), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 10), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 10), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
explicit case 0	`[[[['1', '1'], ['4', '1'], ['4', '4']]]]`	`[[[['1', '1'], ['4', '1'], ['4', '4']]]]`	Passed
explicit case 1	`[[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]]`	`[[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]]`	Passed
explicit case 2	`[[[['1', '1'], ['2', '1'], ['3', '2']]]]`	`[[[['1', '1'], ['2', '1'], ['3', '2']]]]`	Passed
explicit case 3	`[[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]]`	`[[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]]`	Passed
explicit case 4	`[[[['1', '0'], ['2', '2']]]]`	`[[[['1', '0'], ['2', '2']]]]`	Passed
explicit case 5	`[[]]`	`[[]]`	Passed
explicit case 6	`[[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]]`	`[[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]]`	Passed
explicit case 7	`[[[['1', '1'], ['3', '1']]]]`	`[[[['1', '1'], ['3', '1']]]]`	Passed
explicit case 8	`[[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]]`	`[[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]]`	Passed
explicit case 9	`[[[['0', '2'], ['2', '2'], ['2', '0']]]]`	`[[[['0', '2'], ['2', '2'], ['2', '0']]]]`	Passed
explicit case 10	`[[[['2', '1'], ['1', '0'], ['2', '2']]]]`	`[[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]]`	Failed

SHA-256 / 4849bda465b3482d48d145a3ad60ec7a1fafb3025ba39df74fef6b0ce6a31d7c

3 / The verified repair

Exit 0

"""Failure Map reference implementation. Python standard library only."""
import json
from fractions import Fraction
N = 1
observations = []
def solve(commands, size):
    def seg(p,q):
        t0,t1=Fraction(0),Fraction(1)
        for d,e in ((q[0]-p[0],p[0]),(q[1]-p[1],p[1])):
            for pp,qq in ((-d,e),(d,size-1-e)):
                if pp==0:
                    if qq<0: return None
                else:
                    u=qq/pp
                    if pp<0: t0=max(t0,u)
                    else: t1=min(t1,u)
        if t0>t1: return None
        a=(p[0]+t0*(q[0]-p[0]),p[1]+t0*(q[1]-p[1]))
        b=(p[0]+t1*(q[0]-p[0]),p[1]+t1*(q[1]-p[1]))
        return a,b
    out=[]
    for points,closed in commands:
        pts=[(Fraction(x),Fraction(y)) for x,y in points]
        edges=list(zip(pts,pts[1:]))
        if closed and len(pts)>2: edges.append((pts[-1],pts[0]))
        pieces=[]
        current=None
        for p,q in edges:
            part=seg(p,q)
            if part is None:
                current=None
                continue
            a,b=part
            if current is not None and current[-1]==a:
                if b!=a: current.append(b)
            else:
                current=[a] if a==b else [a,b]
                pieces.append(current)
        if closed and len(pieces)>1 and pieces[0][0]==pieces[-1][-1]:
            pieces[0][:0]=pieces.pop()[:-1]
        pieces=[pc for pc in pieces if len(pc)>=2]
        out.append([[[str(x),str(y)] for x,y in pc] for pc in pieces])
    return out
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
if N == 1:
    check('explicit case 0', solve([[[[1, 1], [4, 1], [4, 4]], False]], 6), [[[['1', '1'], ['4', '1'], ['4', '4']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 6), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 6), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 6), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 6), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 6), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 6), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 6), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 6), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 6), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 6), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 2:
    check('explicit case 0', solve([[[[1, 1], [5, 1], [5, 5]], False]], 7), [[[['1', '1'], ['5', '1'], ['5', '5']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 7), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 7), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 7), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 7), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 7), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 7), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 7), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 7), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 7), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 7), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 3:
    check('explicit case 0', solve([[[[1, 1], [6, 1], [6, 6]], False]], 8), [[[['1', '1'], ['6', '1'], ['6', '6']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 8), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 8), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 8), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 8), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 8), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 8), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 8), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 8), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 8), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 8), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 4:
    check('explicit case 0', solve([[[[1, 1], [7, 1], [7, 7]], False]], 9), [[[['1', '1'], ['7', '1'], ['7', '7']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 9), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 9), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 9), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 9), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 9), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 9), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 9), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 9), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 9), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 9), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
if N == 5:
    check('explicit case 0', solve([[[[1, 1], [8, 1], [8, 8]], False]], 10), [[[['1', '1'], ['8', '1'], ['8', '8']]]])
    check('explicit case 1', solve([[[[1, 1], [1, -3], [3, 1]], False]], 10), [[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]])
    check('explicit case 2', solve([[[[1, 1], [2, 1], [2, 1], [3, 2]], False]], 10), [[[['1', '1'], ['2', '1'], ['3', '2']]]])
    check('explicit case 3', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], False]], 10), [[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]])
    check('explicit case 4', solve([[[[1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 10), [[[['1', '0'], ['2', '2']]]])
    check('explicit case 5', solve([[[[-1, 1], [1, -1]], False]], 10), [[]])
    check('explicit case 6', solve([[[[1, 1], [3, 1], [2, 3]], True]], 10), [[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]])
    check('explicit case 7', solve([[[[1, 1], [3, 1]], True]], 10), [[[['1', '1'], ['3', '1']]]])
    check('explicit case 8', solve([[[[1, 1], [1, -2], [3, -2], [3, 1]], True]], 10), [[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]])
    check('explicit case 9', solve([[[[-2, 2], [2, 2], [2, -2], [-2, 2]], False]], 10), [[[['0', '2'], ['2', '2'], ['2', '0']]]])
    check('explicit case 10', solve([[[[2, 1], [1, 0], [1, -2], [3, -2], [1, 0], [2, 2]], False]], 10), [[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]])
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)

Boundary fixture	Actual	Expected	Outcome
explicit case 0	`[[[['1', '1'], ['4', '1'], ['4', '4']]]]`	`[[[['1', '1'], ['4', '1'], ['4', '4']]]]`	Passed
explicit case 1	`[[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]]`	`[[[['1', '1'], ['1', '0']], [['5/2', '0'], ['3', '1']]]]`	Passed
explicit case 2	`[[[['1', '1'], ['2', '1'], ['3', '2']]]]`	`[[[['1', '1'], ['2', '1'], ['3', '2']]]]`	Passed
explicit case 3	`[[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]]`	`[[[['1', '1'], ['1', '0']], [['3', '0'], ['3', '1']]]]`	Passed
explicit case 4	`[[[['1', '0'], ['2', '2']]]]`	`[[[['1', '0'], ['2', '2']]]]`	Passed
explicit case 5	`[[]]`	`[[]]`	Passed
explicit case 6	`[[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]]`	`[[[['1', '1'], ['3', '1'], ['2', '3'], ['1', '1']]]]`	Passed
explicit case 7	`[[[['1', '1'], ['3', '1']]]]`	`[[[['1', '1'], ['3', '1']]]]`	Passed
explicit case 8	`[[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]]`	`[[[['3', '0'], ['3', '1'], ['1', '1'], ['1', '0']]]]`	Passed
explicit case 9	`[[[['0', '2'], ['2', '2'], ['2', '0']]]]`	`[[[['0', '2'], ['2', '2'], ['2', '0']]]]`	Passed
explicit case 10	`[[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]]`	`[[[['2', '1'], ['1', '0']], [['1', '0'], ['2', '2']]]]`	Passed

SHA-256 / 9b9082edd1e8f6683936206a465d03e87103ffcd2fed498813cae88c4484129d

Verification & scope

Exact integer/rational arithmetic on small stipulated fixtures models the clipping decision only; no memory layout, GPU pipeline, graphics API or standards conformance is claimed. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:45:22.433728+00:00.

Case digest / 9f86966d49abcd1f98203f8daef3412e14005aca1f4e0ff60fc57afb98ba6920