Round 7 fixes: flagged-view share, partial-view retry, inside of hollow parts, no straight-down gap views

app/llms.txt

@@ -119,7 +119,9 @@ it leaves much of a complex mesh uncovered; use balanced or dense for real work.
 - summary.coverage_pct / holes_pct are measured over the surface a camera can see from the side or above
   (summary.measured_over). The underside, visible only from below (e.g. the bottom of a crate standing on the
   ground), is reported apart as underside_pct / underside_covered_pct; uncovered texels are filled with nearby
-  colours. Typical good results: coverage 85-95 %, holes < 10 %.
+  colours. So is the inside of hollow parts seen only through an opening (a vase, a cup, a well, a chimney):
+  inside_pct; image models cannot paint views into such openings, so it gets the main painted colour of its
+  material (e.g. the white glaze of a blue-and-white vase). Typical good results: coverage 85-95 %, holes < 10 %.
 - last_result: outcome of the latest operation. retouch: status (applied | empty_mask | rejected), images.compare
   (before | model input | model output | after), validation attempts; regenerate/texture: per-view status;
   fill_gaps: coverage before/after and views added. If a retouch was not applied, `next` says how to aim it.
@@ -130,7 +132,8 @@ it leaves much of a complex mesh uncovered; use balanced or dense for real work.
   partial: true = the view matched the geometry but not the texture already painted (each view of a teapot
   invents its own flowers), so it only paints where it sees the surface better than the views before it.
 - summary.views_flagged_inconsistent: views whose content contradicts the others (e.g. a face painted on the back
-  of a head). Regenerate them; disable if still flagged.
+  of a head); flagged_views_shown_pct is how much of the surface they actually paint that way. Regenerate them;
+  disable if still flagged. Below about 2 % it rarely shows: look at the contact sheet before spending a retry.
 - retouch_suggestions: problem regions (uncovered / stretched / inconsistent) with an index for /retouch.
 - warnings: parameter problems worth fixing (e.g. "up" given for a GLB).
 

app/server.py

@@ -78,9 +78,13 @@ def status_payload(job, base: str, events: int = 12) -> dict:
                    "inconsistent_pct": stats.get("inconsistent"), "views_used": stats.get("views_used"),
                    "views_rejected": [v["name"] for v in views if v["status"] == "rejected"],
                    "views_flagged_inconsistent": (ins.get("regenerate_views") or {}).get("views", [])}
+        if summary["views_flagged_inconsistent"] and stats.get("flagged_views_shown") is not None:
+            summary["flagged_views_shown_pct"] = stats["flagged_views_shown"]
         if stats.get("underside"):
             summary["underside_pct"] = stats["underside"]
             summary["underside_covered_pct"] = stats.get("underside_covered")
+        if stats.get("inside"):
+            summary["inside_pct"] = stats["inside"]
         summary["verdict"], summary["verdict_why"] = verdict(summary)
     out: dict[str, Any] = {
         "job_id": job.id, "state": job.state, "operation": job.op, "progress": job.progress,
@@ -159,15 +163,18 @@ def verdict(summ: dict) -> tuple[str, str]:
     """good: ship it | usable: fine at a distance, optional fixes | needs work: follow `next`."""
     cov, holes = summ.get("coverage_pct") or 0.0, summ.get("holes_pct") or 0.0
     flagged, rejected = summ.get("views_flagged_inconsistent") or [], summ.get("views_rejected") or []
-    incons = summ.get("inconsistent_pct") or 0.0
-    if cov < 75 or (flagged and incons >= 2.0):
+    # the part of the texture where a flagged view wins the blend and contradicts the others (older results only
+    # have the overall disagreement between views)
+    shown = summ.get("flagged_views_shown_pct", summ.get("inconsistent_pct") or 0.0)
+    if cov < 75 or (flagged and shown >= 2.0):
         why = [f"coverage {cov} %" if cov < 75 else "",
-               f"inconsistent views {flagged} ({incons} % of the surface)" if flagged and incons >= 2.0 else ""]
+               f"view(s) {flagged} contradict the others on {shown} % of the surface" if flagged and shown >= 2.0
+               else ""]
         return "needs work", "; ".join(w for w in why if w)
     if cov < 90 or holes >= 5 or rejected or flagged:
         why = [f"coverage {cov} %" if cov < 90 else "", f"holes {holes} %" if holes >= 5 else "",
                f"rejected views {rejected}" if rejected else "",
-               f"view(s) {flagged} disagree with the others ({incons} % of the surface)" if flagged else ""]
+               f"view(s) {flagged} disagree with the others ({shown} % of the surface shows it)" if flagged else ""]
         return "usable", "; ".join(w for w in why if w)
     return "good", f"coverage {cov} %, holes {holes} %, all views consistent"
 

projtex/planning.py

@@ -605,28 +605,34 @@ def greedy_probe_positions(probe: CoverageProbe, walkable: np.ndarray, relevant:
 
 
 def outside_visibility(probe: CoverageProbe, mesh: TexMesh, n: int = 64, fov: float = 35.0, size: int = 768,
-                       min_elevation: float | None = None, with_mean: bool = False):
+                       min_elevation: float | None = None, with_mean: bool = False, with_frac: bool = False):
     """Texels visible from a dense sphere of outside cameras (what any orbit view could ever show).
     ``min_elevation`` (degrees) keeps only cameras at or above that elevation, e.g. 0 for 'seen from the side or
     above' (an object's underside is then excluded). ``size``: probe resolution; coarse probes (e.g. 192 px) count
     faces lying millimetres under other parts as visible, which the real 1024 px projection rightly never covers.
     ``with_mean``: also return the mean quality over the cameras, i.e. how much a texel is seen from around the
-    object (deep concave surfaces glimpsed from one grazing angle get little weight)."""
+    object (deep concave surfaces glimpsed from one grazing angle get little weight). ``with_frac``: also return
+    the share of the cameras that see each texel at all, and the share of those below 50 degrees elevation, as
+    a (res, res, 2) array (the inside of a vase is seen only from steep cameras, through its mouth)."""
     if min_elevation is not None:  # same density on the part of the sphere that is kept
         n = int(round(n * 2 / (1 - np.sin(np.radians(min_elevation)))))
     k = np.arange(n) + 0.5
     el = np.degrees(np.arcsin(1 - 2 * k / n))
     az = np.degrees(np.pi * (1 + 5 ** 0.5) * k) % 360
     vis = np.zeros((probe.res, probe.res), np.float32)
-    total, used = np.zeros_like(vis), 0
+    total, seen_by, used = np.zeros_like(vis), np.zeros((probe.res, probe.res, 2), np.float32), 0
     for a, e in zip(az, el):
         if min_elevation is not None and e < min_elevation:
             continue
         q = probe.quality(_frame_camera(mesh, a, e, fov, 256), size=size)
         vis = np.maximum(vis, q)
         total += q
+        seen_by[..., 0] += q > 0.01  # geometric visibility: small parts get low quality from every camera
+        if e < 50:
+            seen_by[..., 1] += q > 0.01
         used += 1
-    return (vis, total / max(used, 1)) if with_mean else vis
+    out = (vis,) + ((total / max(used, 1),) if with_mean else ()) + ((seen_by / max(used, 1),) if with_frac else ())
+    return out if len(out) > 1 else vis
 
 
 def walk_viewpoints(gl: GL, mesh: TexMesh, walkable: np.ndarray, n: int, size: int, fov: float = 75.0,
@@ -740,6 +746,16 @@ def plan_gaps(gl: GL, mesh: TexMesh, alpha: np.ndarray, probe: CoverageProbe, ma
             q = probe.quality(cam)
             gain = float((W * np.maximum(q - best, 0) * todo).sum())
             scored.append((gain, cam, q))
+        if not environment:  # straight-down views of an object come back as a closed top (a vase's mouth painted
+            # over): keep one only when no camera at 70 degrees or lower gets at least 60 % of its gain
+            def steep(c_):
+                d_ = c_.eye_np - np.asarray(c_.target, np.float64)
+                return d_[1] / max(np.linalg.norm(d_), 1e-12) > np.sin(np.radians(70))
+
+            top = max(scored, key=lambda s_: s_[0])
+            lower = [s_ for s_ in scored if not steep(s_[1])]
+            if steep(top[1]) and lower and max(s_[0] for s_ in lower) >= 0.6 * top[0]:
+                scored = lower
         gain, cam, q = max(scored, key=lambda s_: s_[0])
         whole = [s_ for s_ in scored if getattr(s_[1], "meta_whole", False)]
         if whole and not getattr(cam, "meta_whole", False):

projtex/project.py

@@ -78,6 +78,8 @@ DEFAULT_SETTINGS: dict[str, Any] = {
     # a view that only disagrees with texture already painted, while matching the geometry well, paints just the
     # surface not painted yet (see _partial_ok) instead of being rejected
     "partial_views": True,
+    "inside_seen_frac": 0.06,  # surface seen by fewer cameras is "inside" (see Project.inside); 0 disables
+    "partial_retries": 1,  # extra tries for a view kept as partial, in case one continues the painted pattern
     "min_edge_agreement_env": 0.1,
     "max_outside_change": 0.06,
     "max_lowpass_change": 0.035,  # retouch upscale: the blurred content must stay the same  # retouch: reject outputs that repaint the picture outside the mask
@@ -103,6 +105,19 @@ def _save(a: np.ndarray, path: Path) -> Path:
     return path
 
 
+def _main_color(cols: np.ndarray) -> np.ndarray:
+    """Dominant colour of a set of texels: the fullest cell of a coarse colour grid, then its median (the white
+    ground of a patterned glaze, not the average of ground and pattern)."""
+    from scipy.ndimage import uniform_filter
+
+    cols = np.nan_to_num(cols.reshape(-1, 3))
+    q = np.clip((cols * 8).astype(np.int64), 0, 7)
+    hist = np.bincount(q[:, 0] * 64 + q[:, 1] * 8 + q[:, 2], minlength=512).reshape(8, 8, 8).astype(np.float64)
+    top = np.array(np.unravel_index(uniform_filter(hist, 3, mode="constant").argmax(), hist.shape))
+    near = (np.abs(q - top) <= 1).all(1)  # one colour family can straddle a cell border
+    return np.median(cols[near], axis=0).astype(np.float32)
+
+
 @dataclass
 class View:
     name: str
@@ -405,6 +420,9 @@ class Project:
         if not env:  # estimate what the QA reports: the surface seen from the side or above, weighted by how much
             relevant = self.relevance(probe.res, above=True)
             weights = self.seen_weights(probe.res)
+            ins = self.inside(probe.res)
+            if ins is not None:  # no view can paint it: filled with its material's colour instead
+                relevant = np.where(ins, 0.0, relevant)
         best = np.zeros((probe.res, probe.res), np.float32)
         for s in specs:
             q = probe.quality(s.camera)
@@ -479,8 +497,10 @@ class Project:
         if self.mode == "environment" and walk is not None:
             rel = planning.pvs_alpha(probe, walk)
         elif above:
-            rel, seen = planning.outside_visibility(probe, self.mesh, min_elevation=0.0, with_mean=True)
+            rel, seen, frac = planning.outside_visibility(probe, self.mesh, min_elevation=0.0, with_mean=True,
+                                                          with_frac=True)
             np.save(self.root / "mesh" / f"seen_above_{res}.npy", seen)
+            np.save(self.root / "mesh" / f"seenfrac_above_{res}.npy", frac)
         else:
             rel = planning.outside_visibility(probe, self.mesh)
         np.save(f, rel)
@@ -499,6 +519,55 @@ class Project:
         tws = texel_world_size(self.gl.uv_gbuffer(self.mesh, res))
         return np.nan_to_num(np.load(f) * tws * tws).astype(np.float32)
 
+    def inside(self, res: int = 1024) -> np.ndarray | None:
+        """Objects: surface seen only from above through a narrow opening (the inside of a vase, a cup or a
+        chimney): by fewer than ``inside_seen_frac`` of the cameras around and above the object, and mostly by
+        steep ones (a recessed window or a porch floor is seen from the side). Image models cannot paint views
+        down such openings (they close them: three gap views into a vase's mouth all failed), so gap views do not
+        aim at it and fuse() gives what stays unpainted there the main colour of its material. None for
+        environments."""
+        thr = float(self.settings.get("inside_seen_frac") or 0.0)
+        if self.mode == "environment" or thr <= 0:
+            return None
+        f = self.root / "mesh" / f"seenfrac_above_{res}.npy"
+        if not f.exists():
+            (self.root / "mesh" / f"pvs_above_{res}.npy").unlink(missing_ok=True)
+            self.relevance(res, above=True)
+        frac = np.load(f)
+        if frac.ndim != 3:  # written before the low-camera share was kept
+            f.unlink()
+            (self.root / "mesh" / f"pvs_above_{res}.npy").unlink(missing_ok=True)
+            self.relevance(res, above=True)
+            frac = np.load(f)
+        seen, low = frac[..., 0], frac[..., 1]
+        return (seen > 0) & (seen < thr) & (low <= 0.25 * seen)
+
+    def _fill_inside(self, color: np.ndarray, alpha: np.ndarray, covered: np.ndarray, res: int) -> int:
+        """Paint the unpainted inside surface (see inside()) with the dominant painted colour of its material
+        (the white glaze of a blue-and-white vase), in place. Returns the number of texels filled."""
+        ins = self.inside(min(res, 1024))
+        if ins is None or not ins.any():
+            return 0
+        idx = np.arange(res) * ins.shape[0] // res
+        todo = ins[idx][:, idx] & (alpha < 0.3)
+        if not todo.any():
+            return 0
+        fid = self.gl.uv_gbuffer(self.mesh, res)["face"]
+        mat = np.where(fid >= 0, self.mesh.face_material[np.maximum(fid, 0)], -1)
+        good = (alpha >= 0.6) & (fid >= 0)
+        if good.sum() < 64:
+            return 0
+        filled = np.zeros_like(todo)
+        for m in np.unique(mat[todo]):
+            src = good & (mat == m)
+            tgt = todo & (mat == m)
+            main = _main_color(color[src] if src.sum() >= 64 else color[good])
+            a = np.clip(alpha[tgt] / 0.3, 0, 1)[:, None]  # keep what little a view painted there, blended in
+            color[tgt] = a * color[tgt] + (1 - a) * main
+            filled |= tgt
+        covered |= filled
+        return int(filled.sum())
+
     def _set_dens_ref(self, specs) -> None:
         vals = []
         for s in specs[:12]:
@@ -707,8 +776,9 @@ class Project:
         alpha = acc.alpha.copy()
         changed = self._apply_layers(color, alpha, res) if layers else 0
         covered = (acc.den > 0) | (alpha > 0.01)
+        inside = self._fill_inside(color, alpha, covered, res) if used else 0
         out = {"color": color, "alpha": alpha, "covered": covered, "acc": acc, "views": used,
-               "layer_texels": changed, "res": res}
+               "layer_texels": changed, "inside_filled": inside, "res": res}
         self._tex_cache = {"key": key, "value": out}
         return out
 
@@ -913,7 +983,8 @@ class Project:
         return {"color": color, "alpha": alpha, "covered": (acc.den > 0) | (alpha > 0.01), "acc": acc}
 
     def _view_prompt(self, v: View, coverage: float, n_refs: int, cropped: bool = False, retry: int = 0,
-                     caption: str = "", layout: str = "", color_guide: bool = False) -> str:
+                     caption: str = "", layout: str = "", color_guide: bool = False,
+                     retry_painted: bool = False) -> str:
         s = self.settings
         hint = v.prompt_hint
         base = s.get("focus_prompt") if v.kind == "focus" and s.get("focus_prompt") else s["prompt"]
@@ -947,7 +1018,8 @@ class Project:
         return view_prompt(prompt, coverage=coverage, kind=v.kind, hint=hint, lighting=s["lighting"],
                            subject=subject, environment=self.mode == "environment", n_refs=n_refs,
                            raw_prompt=bool(s.get("raw_prompt")), cropped=cropped, retry=retry, focus_label=label,
-                           caption=caption, pose_hint=ph, layout=layout, color_guide=color_guide)
+                           caption=caption, pose_hint=ph, layout=layout, color_guide=color_guide,
+                           retry_painted=retry_painted)
 
     def generate(self, views: list[str] | None = None, force: bool = False, backend: Any = None,
                  bake: bool = True, progress: Any = None) -> dict:
@@ -996,7 +1068,8 @@ class Project:
             tries = 1 + (int(self.settings.get("max_retries", 2)) if validate else 0)
             attempts, best, failed = [], None, None
             rescue_inside = None
-            partial_mask = None
+            partial_best = None  # an attempt good enough to paint only the unpainted surface (see _partial_ok)
+            retry_painted = False
             view_mask = None
             if self.settings.get("view_masks") and be.native_mask and cond["coverage"] > 0.02:
                 clay = (cond["cover_px"] < 0.5) & (cond["depth"] > 0)
@@ -1010,7 +1083,7 @@ class Project:
                 layout, negative = self._layout(cond["face"])
                 prompt = self._view_prompt(v, cond["coverage"], len(refs), cropped=cond["cropped"], retry=k,
                                            caption=cond.get("caption", ""), layout=layout,
-                                           color_guide=cond.get("color_guide", False))
+                                           color_guide=cond.get("color_guide", False), retry_painted=retry_painted)
                 (vdir / "prompt.txt").write_text(prompt + (f"\n\nNEGATIVE: {negative}" if negative else ""))
                 req = GenRequest(image=_np_to_img(cond["image"]), prompt=prompt, width=v.camera.width, mask=view_mask,
                                  height=v.camera.height, seed=seed + 7919 * k, task="view", references=refs,
@@ -1047,23 +1120,33 @@ class Project:
                             post.update(chk)
                             post.pop("reject_reasons", None)
                             rescue_inside = inside
+                partial = None
                 if not post["accepted"] and self._partial_ok(post):
-                    partial_mask = self._unpainted_mask(cond, img.shape[:2])
-                    if partial_mask is not None:  # keep it, but only where nothing was painted yet
-                        post["accepted"], post["partial"] = True, True
+                    partial = self._unpainted_mask(cond, img.shape[:2])
                 cost = (getattr(be, "last_usage", None) or {}).get("cost")
                 attempts.append({"seed": seed + 7919 * k, "cost_usd": cost,
                                  **{kk: post.get(kk) for kk in ("edge_agreement", "silhouette_iou", "painted_corr",
-                                                                "accepted")}})
+                                                                "accepted")},
+                                 **({"partial": True} if partial is not None else {})})
+                if partial is not None and (partial_best is None or (post.get("painted_corr") or -1.0)
+                                            > (partial_best[1].get("painted_corr") or -1.0)):
+                    # usable where nothing is painted yet; a retry may still continue the painted pattern
+                    partial_best = (img, {**post, "accepted": True, "partial": True}, seed + 7919 * k,
+                                    rescue_inside, partial)
                 if best is None or (post.get("edge_agreement") or 0) > (best[1].get("edge_agreement") or 0):
-                    best = (img, post, seed + 7919 * k, rescue_inside, partial_mask)
+                    best = (img, post, seed + 7919 * k, rescue_inside, None)
                 if post["accepted"]:
-                    best = (img, post, seed + 7919 * k, rescue_inside, partial_mask)
+                    best = (img, post, seed + 7919 * k, rescue_inside, None)
                     break
-                rescue_inside = partial_mask = None
+                retry_painted = post.get("reject_reasons") == ["painted"]
+                rescue_inside = None
                 log.warning("view %s attempt %d rejected (%s)", v.name, k + 1,
                             {kk: post.get(kk) for kk in ("edge_agreement", "silhouette_iou", "painted_corr",
                                                          "painted_diff")})
+                if partial_best is not None and k >= int(self.settings.get("partial_retries", 1)):
+                    break
+            if partial_best is not None and not (best is not None and best[1]["accepted"]):
+                best, failed = partial_best, None  # no retry continued the painted texture: keep the closest one
             if failed and failed[0] == "fatal":  # e.g. GPU quota exhausted: stop, keep the view planned
                 _emit({"view": v.name, "status": "stopped", "detail": failed[1]})
                 stopped = (failed[1], [t.name for t in targets[targets.index(v):]])
@@ -1152,6 +1235,9 @@ class Project:
             probe = planning.CoverageProbe(self.gl, self.mesh, res=res, params=self.fusion())
             rel = self.relevance(res)
             env = self.mode == "environment"
+            ins = self.inside(res)
+            if ins is not None:
+                rel = np.where(ins, 0.0, rel)
             imp = self.importance(res) if env else None
             weights = planning.pvs_weights(imp) if imp is not None else None
             before = self._cov(probe, st["alpha"], rel, weights=weights)

projtex/prompts.py

@@ -35,7 +35,7 @@ def view_prompt(user_prompt: str, *, coverage: float, kind: str = "base", hint:
                 lighting: str = "flat", subject: str = "", environment: bool = False,
                 n_refs: int = 0, raw_prompt: bool = False, cropped: bool = False, retry: int = 0,
                 focus_label: str = "head", caption: str = "", pose_hint: str = "", layout: str = "",
-                color_guide: bool = False) -> str:
+                color_guide: bool = False, retry_painted: bool = False) -> str:
     if raw_prompt:
         return user_prompt
     what = "the inside of a 3D environment" if environment else ("a 3D model" + (f" of {subject}" if subject else ""))
@@ -80,7 +80,11 @@ def view_prompt(user_prompt: str, *, coverage: float, kind: str = "base", hint:
         parts.append("The render is a tight crop that cuts through the subject at the image border: keep exactly "
                      "this crop, zoom level and camera distance. Do not zoom out, do not re-center and do not show "
                      "more of the subject than the render shows.")
-    if retry:
+    if retry and retry_painted and coverage >= 0.02:  # the last try matched the shapes but repainted the texture
+        parts.append("Most important: the already textured surfaces must keep exactly the pattern, motifs and "
+                     "colours they show now, pixel for pixel; extend that same design onto the untextured parts "
+                     "instead of painting a new one over it.")
+    elif retry:
         parts.append("Most important: the output must overlay the input render exactly, pixel for pixel, as a "
                      "texture painted onto the very same shapes.")
     if LIGHTING.get(lighting):

projtex/qa.py

@@ -23,16 +23,21 @@ def analyse(project, st: dict, max_suggestions: int = 6) -> dict:
     all_valid = uvg["valid"]
     tws = texel_world_size(uvg)
     area_all = tws * tws * all_valid
-    under = None
+    under = inside = None
     try:
         rel = project.relevance(res) > 0.05
         if project.mode != "environment":  # judge what the side and top views can show; report the underside apart
             above = project.relevance(res, above=True) > 0.05
             under, rel = rel & ~above & all_valid, above
+            ins = project.inside(res)
+            if ins is not None:  # seen only through an opening: filled with its material's colour, reported apart
+                inside, rel = ins & all_valid, rel & ~ins
     except Exception:  # pragma: no cover - QA must not fail because of the visibility pass
         rel = np.ones_like(all_valid)
     valid = all_valid & rel
     hidden = all_valid & ~rel if under is None else all_valid & ~rel & ~under
+    if inside is not None:
+        hidden &= ~inside
     area = tws * tws * valid
     if under is not None:  # weight by how much each texel is seen (mean over side/top cameras), not just whether
         try:
@@ -79,10 +84,27 @@ def analyse(project, st: dict, max_suggestions: int = 6) -> dict:
         ua = float(area_all[under].sum())
         stats["underside"] = round(100.0 * ua / max(float(area_all.sum()), 1e-30), 2)
         stats["underside_covered"] = round(100.0 * float(area_all[under & (alpha >= 0.3)].sum()) / ua, 2) if ua else None
+    if inside is not None and inside.any():
+        ia = float(area_all[inside].sum())
+        stats["inside"] = round(100.0 * ia / max(float(area_all.sum()), 1e-30), 2)
+        stats["inside_painted"] = round(100.0 * float(area_all[inside & (alpha >= 0.3)].sum()) / ia, 2) if ia else None
+        stats["stats_over"] += "; so is the inside of hollow parts, seen only through an opening, which gets the " \
+                               "main colour of its material where no view painted it"
     bad = valid & ((alpha < 0.3) | ((cos < 0.3) & covered) | (dis > 0.15))
     suggestions = _clusters(uvg, area, bad, alpha, cos, dis, total, max_suggestions, mesh.radius)
     consistency = view_consistency(project) if len(project.views) <= 80 else []
     outliers = [o["view"] for o in consistency if o.get("outlier")]
+    shown = np.zeros_like(valid)
+    affected = {}
+    for o in consistency:
+        m = o.pop("_mask", None)
+        if m is None:
+            continue
+        idx = np.arange(res) * m.shape[0] // res  # the check runs at its own resolution
+        m = m[idx][:, idx] & valid
+        affected[o["view"]] = pct(m)
+        shown |= m
+    stats["flagged_views_shown"] = pct(shown)
     maps = {
         "coverage": _heat(alpha) * valid[..., None],
         "angle_quality": _heat(cos, 0.0, 1.0) * valid[..., None],
@@ -93,6 +115,7 @@ def analyse(project, st: dict, max_suggestions: int = 6) -> dict:
     if outliers:
         out["regenerate_views"] = {
             "views": outliers,
+            "shown_pct": affected,
             "why": "these views disagree with the other views where they overlap (e.g. a face painted on the back "
                    "or top of a head): regenerate them (`generate --views ... --force`, possibly with "
                    "`view NAME --prompt-extra`) or disable them (`view NAME --disable`)"}
@@ -215,6 +238,18 @@ def view_consistency(project, res: int = 512, diff_thresh: float = 0.15) -> list
         if not cand or len(excluded) >= max(1, len(names) // 3):
             break
         excluded.add(max(cand)[1])
+    # where each flagged view actually shows: it dominates the blend there and differs from the other views
+    mo_all = np.maximum(W.max(0), 1e-30)
+    Wn = (W / mo_all[None]) ** params.sharpness
+    share = Wn / np.maximum(Wn.sum(0), 1e-30)[None]
+    ref = [j for j in range(len(names)) if j not in excluded]
     for i, o in enumerate(out):
         o["outlier"] = i in excluded
+        others = [j for j in ref if j != i]
+        if i not in excluded or not others:
+            continue
+        Wo = np.minimum(W[others] / np.maximum(W[others].max(0), 1e-30)[None], 1.0) ** params.sharpness
+        den_i = Wo.sum(0)
+        loo = (Wo[..., None] * C[others]).sum(0) / np.maximum(den_i, 1e-12)[..., None]
+        o["_mask"] = (share[i] >= 0.3) & (A[i] >= 0.5) & (den_i > 0) & (np.abs(C[i] - loo).mean(-1) > diff_thresh)
     return out