Spaces:
Running on Zero
Running on Zero
File size: 8,877 Bytes
28dbedc 8e0d79f 28dbedc 8e0d79f 28dbedc 8e0d79f 28dbedc 52f0700 28dbedc 8e0d79f 28dbedc 52f0700 8e0d79f 52f0700 8e0d79f 52f0700 8e0d79f 52f0700 28dbedc 07f2e54 28dbedc 52f0700 28dbedc 07f2e54 52f0700 8e0d79f 28dbedc 8e0d79f 28dbedc 8e0d79f 28dbedc | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 | from __future__ import annotations
from collections.abc import Iterable
from functools import lru_cache
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont
from .protocol import Primitive
PURPLE = (120, 78, 188)
GREEN = (145, 195, 49)
PINK = (214, 120, 172)
CYAN = (55, 171, 183)
PALETTE = (PURPLE, GREEN, PINK, CYAN)
@lru_cache(maxsize=32)
def _load_font(size: int, multilingual: bool) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
assets = Path(__file__).resolve().parents[1] / "assets"
if multilingual:
# Pillow does not perform the browser's font fallback. Bundle CJK glyphs
# so Chinese OCR labels render identically on macOS and the Linux Space.
return ImageFont.truetype(str(assets / "NotoSansCJKsc-Regular.otf"), size=size)
candidates = (
str(assets / "Manrope-variable.ttf"),
"/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
"/usr/share/fonts/truetype/liberation2/LiberationSans-Regular.ttf",
)
for candidate in candidates:
if Path(candidate).is_file():
font = ImageFont.truetype(candidate, size=size)
if Path(candidate).name == "Manrope-variable.ttf":
font.set_variation_by_axes([600])
return font
return ImageFont.load_default()
def _font(size: int, text: str = "") -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
return _load_font(size, not text.isascii())
def _xy(values: tuple[int, ...], width: int, height: int) -> tuple[int, ...]:
if len(values) == 2:
return round(values[0] * (width - 1) / 999), round(values[1] * (height - 1) / 999)
return (
round(values[0] * (width - 1) / 999),
round(values[1] * (height - 1) / 999),
round(values[2] * (width - 1) / 999),
round(values[3] * (height - 1) / 999),
)
def _intersects(a, b, gap=2):
return a[0] < b[2]+gap and b[0] < a[2]+gap and a[1] < b[3]+gap and b[1] < a[3]+gap
def layout_box_labels(primitives, width, height, font, padding=4):
"""One collision-free badge per exact category; returned boxes stay untouched."""
groups = {}
for primitive in primitives:
if len(primitive.coordinates) == 4:
groups.setdefault(primitive.label, []).append(_xy(primitive.coordinates, width, height))
area = lambda b: max(0,b[2]-b[0])*max(0,b[3]-b[1])
small = [b for boxes in groups.values() for b in boxes if area(b)<width*height*.01]
measure = ImageDraw.Draw(Image.new("RGB", (1, 1)))
occupied, placed = [], []
# Give small targets first choice of nearby space. Large regions have more
# candidate anchors. Ordering affects label placement only, never predictions.
for label, boxes in sorted(groups.items(), key=lambda item: max(map(area,item[1]))):
label_font = _font(getattr(font, "size", 13), label) if not label.isascii() else font
text = label if len(label)<=38 else label[:37]+"…"
while text:
bounds = measure.textbbox((0,0),text,font=label_font)
tw, th = bounds[2]-bounds[0]+2*padding, bounds[3]-bounds[1]+2*padding
if tw<=width-2 and th<=height-2: break
text = text[:-2]+"…" if len(text)>2 else ""
if not text: continue
candidates=[]
for target in sorted(boxes,key=area,reverse=True):
x1,y1,x2,y2=target
for x,y in [(x1,y1-th-2),(x1,y1+2),(x1,y2+2),(x2-tw,y1-th-2),
(x2-tw,y2-th-2),(x2+2,y1),(x1-tw-2,y1)]:
x=max(1,min(x,width-tw-1));y=max(1,min(y,height-th-1))
candidates.append(((x,y,x+tw,y+th),target))
chosen=next(((b,t) for b,t in candidates if not any(_intersects(b,o) for o in occupied+small)),None)
if chosen is None:
# Rare crowded anchors use the nearest free area with a leader line.
# Never put a badge on another badge or cover a small prediction.
free=[]
for y in range(1,max(2,height-th),max(4,th//2)):
for x in range(1,max(2,width-tw),max(6,tw//4)):
b=(x,y,x+tw,y+th)
if any(_intersects(b,o) for o in occupied+small): continue
for t in boxes:
dx=max(t[0]-b[2],b[0]-t[2],0);dy=max(t[1]-b[3],b[1]-t[3],0)
# Prefer top-left anchors among equally near locations.
score=dx*dx+dy*dy+.01*((x-t[0])**2+(y-t[1])**2)
free.append((score,b,t))
if free:
_,b,t=min(free,key=lambda item:item[0]);chosen=(b,t)
if chosen:
b,target=chosen;occupied.append(b)
placed.append(dict(label=label,text=text,box=b,target=target,text_bounds=bounds,font=label_font))
return placed
def draw_primitives(
image: Image.Image,
primitives: Iterable[Primitive],
references: Iterable[Primitive] = (),
title: str | None = None,
) -> Image.Image:
canvas = image.convert("RGBA")
overlay = Image.new("RGBA", canvas.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(overlay)
width, height = canvas.size
primitives = list(primitives)
dense = len(primitives) > 12
# Fine boundaries keep a dense scene readable; short corners make small
# boxes discoverable without filling, moving, or removing any prediction.
line = max(1 if dense else 2, round(min(width, height) / (420 if dense else 260)))
radius = max(6, line * 3)
font = _font(max(12 if dense else 13, round(min(width, height) / 48)))
label_colors: dict[str, tuple[int, int, int]] = {}
for ref in references:
if len(ref.coordinates) != 4:
continue
box = _xy(ref.coordinates, width, height)
draw.rectangle(box, outline=(*GREEN, 255), width=line * 2)
x1, y1, x2, y2 = box
dash = max(5, line * 3)
for x in range(x1, x2, dash * 2):
draw.line((x, y1, min(x + dash, x2), y1), fill=(*GREEN, 255), width=line)
draw.line((x, y2, min(x + dash, x2), y2), fill=(*GREEN, 255), width=line)
# Opaque RGBA writes replace earlier pixels in a Pillow layer. In particular,
# a later lake/cloud fill used to erase every small object drawn inside it.
# Keep region interiors untouched; geometry and labels are separate passes.
for primitive in primitives:
color = label_colors.setdefault(primitive.label, PALETTE[len(label_colors) % len(PALETTE)])
coords = _xy(primitive.coordinates, width, height)
if len(coords) == 2:
x, y = coords
draw.ellipse(
(x - radius, y - radius, x + radius, y + radius),
outline=(*color, 255),
width=line,
)
draw.line((x - radius * 2, y, x + radius * 2, y), fill=(*color, 255), width=line)
draw.line((x, y - radius * 2, x, y + radius * 2), fill=(*color, 255), width=line)
else:
x1, y1, x2, y2 = coords
draw.rectangle(coords, outline=(*color, 255), width=line)
if dense:
corner = min(max(4, round(min(width, height) / 80)), (x2-x1)//3, (y2-y1)//3)
if corner > 0:
for x, y, dx, dy in ((x1,y1,1,1),(x2,y1,-1,1),(x1,y2,1,-1),(x2,y2,-1,-1)):
draw.line((x+dx*corner,y,x,y,x,y+dy*corner), fill=(*color,255), width=max(2,line))
# Labels remain visible in dense scenes, once per category across all boxes.
padding=max(4,line*2)
for badge in layout_box_labels(primitives,width,height,font,padding):
text,box,target=badge["text"],badge["box"],badge["target"]
color=label_colors[badge["label"]]
tx,ty=box[:2];tb=badge["text_bounds"]
# Attach displaced badges to their actual prediction with a fine leader.
if not _intersects(box,target,gap=4):
cx,cy=(box[0]+box[2])/2,(box[1]+box[3])/2
ex=max(target[0],min(cx,target[2]));ey=max(target[1],min(cy,target[3]))
sx=max(box[0],min(ex,box[2]));sy=max(box[1],min(ey,box[3]))
draw.line((sx,sy,ex,ey),fill=(*color,230),width=1)
light=tuple(round(c*.10+255*.90) for c in color)
draw.rounded_rectangle(box,radius=3,fill=(*light,248),outline=(*color,255),width=1)
draw.text((tx+padding-tb[0],ty+padding-tb[1]),text,font=badge["font"],fill=(38,30,49,255))
if title:
title_font = _font(getattr(font, "size", 13), title)
tb = draw.textbbox((0, 0), title, font=title_font)
draw.rounded_rectangle(
(10, 10, min(width - 10, tb[2] + 28), tb[3] + 24),
radius=10,
fill=(255, 255, 255, 225),
outline=(*PURPLE, 255),
width=line,
)
draw.text((18, 16), title, font=title_font, fill=(*PURPLE, 255))
return Image.alpha_composite(canvas, overlay).convert("RGB")
|