enhance_logo.py

skills/lowres-logo-rescue/scripts/enhance_logo.py

1. #!/usr/bin/env python3
2. """
3. Low-res logo rescue pipeline (no neural models required).
5. For soft, low-resolution *flat* logos this classic pipeline beats neural
6. upscalers: it denoises, upscales cleanly (Lanczos), sharpens, and can "flatten"
7. the art back to a small set of solid colors so fuzzy anti-aliased edges snap
8. crisp again. That is both more readable AND a far better input for vector tracing
9. (Illustrator Image Trace / Vector Magic / potrace) than the original blur.
11. It does NOT invent detail. If the source is a photo/scan of a physical object
12. (a medallion, an embroidered patch, a sign), no amount of upscaling recovers
13. edges the camera never captured -- the script will say so in its readout.
15. Produces, per image:
16. <stem>_A_enhanced.png denoise + Lanczos upscale + unsharp + gentle contrast.
17. Natural look, no posterization. Safe general upscale.
18. <stem>_B_flat<N>.png enhanced, then k-means color-flatten to N solid colors.
19. Crisp edges, tiny palette. Best "make it readable"
20. version and the file to hand a tracer. (Flat art only.)
21. <stem>_C_traceready.png high-contrast, flattened, on solid white -- optimized
22. purely as a bitmap-trace source.
24. Usage:
25. python3 enhance_logo.py IMAGE [IMAGE ...] [--outdir DIR]
26. [--scale N] [--long-edge PX] [--colors N]
27. python3 enhance_logo.py /path/to/folder # processes images in folder
29. Examples:
30. python3 enhance_logo.py "client_logo.png"
31. python3 enhance_logo.py *.png --outdir ./enhanced --colors 8
32. """
33. import sys, os, glob, argparse
34. import numpy as np
35. import cv2
36. from PIL import Image
37. from sklearn.cluster import KMeans
39. IMG_EXTS = (".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff", ".webp")
42. def load_rgba(path):
43. return np.array(Image.open(path).convert("RGBA"))
46. def analyze(rgb):
47. """Decide flat-art vs photographic, robustly.
49. Two signals, because a naive unique-color count is fooled by photos that
50. have large flat-ish regions (e.g. a photo of a blue medallion):
51. * color concentration -- what fraction of pixels the 8 most common colors
52. cover. Flat logos are dominated by a few colors (high); photos spread
53. across many (low).
54. * soft-transition share -- fraction of pixels sitting on gentle gradients
55. (mid gradient magnitude). Photos are full of soft shading; flat art
56. transitions are either flat or a hard edge.
57. Returns (is_photographic, top8_coverage, unique_colors, soft_share)."""
58. small = cv2.resize(rgb, (256, 256), interpolation=cv2.INTER_AREA)
59. q = (small // 8).reshape(-1, 3)
60. vals, counts = np.unique(q, axis=0, return_counts=True)
61. order = np.argsort(-counts)
62. top8 = float(counts[order[:8]].sum() / counts.sum())
63. g = cv2.cvtColor(small, cv2.COLOR_RGB2GRAY)
64. mag = np.sqrt(cv2.Sobel(g, cv2.CV_32F, 1, 0) ** 2 +
65. cv2.Sobel(g, cv2.CV_32F, 0, 1) ** 2)
66. soft = float(((mag > 10) & (mag < 60)).mean())
67. photographic = top8 < 0.65 or (top8 < 0.82 and soft > 0.18)
68. return photographic, top8, len(vals), soft
71. def palette_size(top8):
72. """Fewer, cleaner colors when the art is already highly concentrated."""
73. if top8 > 0.90:
74. return 6
75. if top8 > 0.80:
76. return 8
77. return 10
80. def scale_for(w, h, max_scale, long_edge):
81. return max(1.0, min(max_scale, long_edge / max(w, h)))
84. def denoise(rgb, strength):
85. return cv2.bilateralFilter(rgb, d=7, sigmaColor=strength, sigmaSpace=7)
88. def upscale(a, scale):
89. h, w = a.shape[:2]
90. return cv2.resize(a, (int(round(w * scale)), int(round(h * scale))),
91. interpolation=cv2.INTER_LANCZOS4)
94. def unsharp(rgb, amount=1.0, radius=2.0):
95. blur = cv2.GaussianBlur(rgb, (0, 0), radius)
96. out = cv2.addWeighted(rgb, 1 + amount, blur, -amount, 0)
97. return np.clip(out, 0, 255).astype(np.uint8)
100. def gentle_contrast(rgb):
101. lab = cv2.cvtColor(rgb, cv2.COLOR_RGB2LAB)
102. l, a, b = cv2.split(lab)
103. l = cv2.createCLAHE(clipLimit=1.6, tileGridSize=(8, 8)).apply(l)
104. return cv2.cvtColor(cv2.merge((l, a, b)), cv2.COLOR_LAB2RGB)
107. def kmeans_flatten(rgb, n_colors, alpha=None):
108. """Snap to n solid colors. If alpha given, cluster only opaque pixels."""
109. h, w = rgb.shape[:2]
110. flat = rgb.reshape(-1, 3).astype(np.float32)
111. sample = flat[alpha.reshape(-1) > 20] if alpha is not None else flat
112. if len(sample) > 60000:
113. sample = sample[np.random.choice(len(sample), 60000, replace=False)]
114. km = KMeans(n_clusters=min(n_colors, len(np.unique(sample, axis=0))),
115. n_init=4, random_state=0).fit(sample)
116. out = km.cluster_centers_[km.predict(flat)].reshape(h, w, 3)
117. return np.clip(out, 0, 255).astype(np.uint8)
120. def save(rgb, alpha, path):
121. if alpha is not None:
122. Image.fromarray(np.dstack([rgb, alpha]), "RGBA").save(path)
123. else:
124. Image.fromarray(rgb, "RGB").save(path)
125. print(" wrote", os.path.basename(path))
128. def process(path, outdir, max_scale, long_edge, forced_colors):
129. stem = os.path.splitext(os.path.basename(path))[0].split("-")[0].strip().rstrip("_")
130. rgba = load_rgba(path)
131. rgb, alpha = rgba[:, :, :3], rgba[:, :, 3]
132. has_alpha = alpha.min() < 250
133. h, w = rgb.shape[:2]
134. photographic, top8, nuniq, soft = analyze(rgb)
135. scale = scale_for(w, h, max_scale, long_edge)
136. kind = "photographic (limited gains, do NOT vector-trace)" if photographic \
137. else "flat art (good vectorize candidate)"
138. print(f"\n{os.path.basename(path)}: {w}x{h} -> {kind}"
139. f" [top8={top8:.2f} soft={soft:.2f} uniq={nuniq}]"
140. f" upscale x{scale:.2f} alpha={has_alpha}")
142. d = denoise(rgb, strength=45 if photographic else 30)
143. up = gentle_contrast(upscale(d, scale))
144. a_up = upscale(alpha, scale) if has_alpha else None
145. A = unsharp(up, amount=1.0, radius=2.0)
146. save(A, a_up, os.path.join(outdir, f"{stem}_A_enhanced.png"))
148. n_colors = forced_colors or (18 if photographic else palette_size(top8))
149. B = cv2.medianBlur(kmeans_flatten(A, n_colors, alpha=a_up), 3)
150. save(B, a_up, os.path.join(outdir, f"{stem}_B_flat{n_colors}.png"))
152. if a_up is not None:
153. af = (a_up.astype(np.float32) / 255.0)[:, :, None]
154. C = (B * af + np.full_like(B, 255) * (1 - af)).astype(np.uint8)
155. else:
156. C = B.copy()
157. save(unsharp(C, amount=0.6, radius=1.5), None,
158. os.path.join(outdir, f"{stem}_C_traceready.png"))
159. return dict(name=os.path.basename(path), photographic=photographic,
160. out=f"{A.shape[1]}x{A.shape[0]}", colors=n_colors)
163. def collect(paths):
164. out = []
165. for p in paths:
166. if os.path.isdir(p):
167. out += [f for f in sorted(glob.glob(os.path.join(p, "*")))
168. if f.lower().endswith(IMG_EXTS)]
169. else:
170. out.append(p)
171. return out
174. def main():
175. ap = argparse.ArgumentParser(description="Rescue low-res logos for readability + tracing.")
176. ap.add_argument("paths", nargs="+", help="image files, globs, or a folder")
177. ap.add_argument("--outdir", default=None, help="output dir (default: alongside input)")
178. ap.add_argument("--scale", type=float, default=3.0, help="max upscale factor (default 3)")
179. ap.add_argument("--long-edge", type=int, default=3600, help="cap on upscaled long edge px")
180. ap.add_argument("--colors", type=int, default=None, help="force flatten palette size")
181. args = ap.parse_args()
183. files = collect(args.paths)
184. if not files:
185. print("No images found."); sys.exit(1)
187. results = []
188. for f in files:
189. outdir = args.outdir or os.path.dirname(os.path.abspath(f))
190. os.makedirs(outdir, exist_ok=True)
191. results.append(process(f, outdir, args.scale, args.long_edge, args.colors))
193. print("\nSUMMARY")
194. for r in results:
195. print(f" {r['name']}: {'PHOTO' if r['photographic'] else 'flat'}, "
196. f"out {r['out']}, flatten palette {r['colors']}")
197. if any(r["photographic"] for r in results):
198. print("\nNote: photographic sources can't be sharpened into vector-quality art. "
199. "Chase the original/official vector or rebuild it instead of tracing.")
202. if __name__ == "__main__":
203. main()