Wells outlined exactly: thin lines just outside the well cell on the map and the well column in the sections, so every cell of the well shows in full.

app.py

@@ -396,10 +396,10 @@ with gr.Blocks(title='ResFlow: 3D reservoir generation', theme=THEME, css=CSS, j
             img_xy = gr.Image(FIRST['xy'], **image)
             z_s = gr.Slider(0, B.Z - 1, value=B.Z // 2, step=1, label='Depth z (0 = base)')
         with gr.Column(scale=1, min_width=360):
-            gr.Markdown('Section along x (XZ) at the y below; a darker column is a well.', elem_classes='cap')
+            gr.Markdown('Section along x (XZ) at the y below; a well is the column between two dark lines.', elem_classes='cap')
             img_xz = gr.Image(FIRST['xz'], **image)
             y_s = gr.Slider(0, FIRST['y']['maximum'], value=FIRST['y']['value'], step=1, label='y of the XZ section')
-            gr.Markdown('Section along y (YZ) at the x below; a darker column is a well.', elem_classes='cap')
+            gr.Markdown('Section along y (YZ) at the x below; a well is the column between two dark lines.', elem_classes='cap')
             img_yz = gr.Image(FIRST['yz'], **image)
             x_s = gr.Slider(0, FIRST['x']['maximum'], value=FIRST['x']['value'], step=1, label='x of the YZ section')
             download = gr.File(FIRST['path'], label='Download (.npz: facies 1 = sand, active = inside the outline)')

backend.py

@@ -139,38 +139,46 @@ def _rgb(sl, active):
     return np.where(active[..., None], img, OUTSIDE_RGB).astype(np.uint8)
 
 
+def _beside(lo, hi, w, n):
+    """Two slices, ``w`` pixels wide, just outside the pixel span [lo, hi) of an image ``n`` pixels across; at the
+    image edge the slice moves inside the span."""
+    return (slice(lo - w, lo) if lo >= w else slice(lo, lo + w),
+            slice(hi, hi + w) if hi + w <= n else slice(hi - w, hi))
+
+
 def slice_image(field, active, axis, index, wells=(), scale=None):
     """RGB image of one section: axis 'z' gives a map view (x right, y up), 'y' an XZ and 'x' a
-    YZ section (depth up). Cells outside the reservoir are white; a well is a one-pixel dark ring on the map,
-    with its cells showing inside, and a darker column in a section. ``scale`` sets the pixels per cell of the
-    map view."""
+    YZ section (depth up). Cells outside the reservoir are white. A well is outlined by thin dark lines drawn
+    just outside the cells it conditions, and only those: a one-pixel ring around its cell on the map, a line
+    down each side of its column in a section, so every cell of the well shows in full. ``scale`` sets the
+    pixels per cell of the map view."""
     nx, ny, nz = field.shape
     if axis == 'z':
         img = _rgb(field[:, :, index], active)[:, ::-1].transpose(1, 0, 2)
         k = scale or max(1, 512 // max(img.shape[:2]))
         img = np.kron(img, np.ones((k, k, 1), np.uint8))
-        r = max(1, max(nx, ny) // 128)
-        for x, y, _ in wells:                               # a one-pixel dark ring; the cells within r show inside
-            row, col = ny - 1 - int(y), int(x)
-            r0, r1 = max(0, row - r) * k, min(ny, row + r + 1) * k
-            c0, c1 = max(0, col - r) * k, min(nx, col + r + 1) * k
-            img[r0, c0:c1] = img[r1 - 1, c0:c1] = WELL_RGB
-            img[r0:r1, c0] = img[r0:r1, c1 - 1] = WELL_RGB
-        return _number_wells(img, [((ny - 1 - int(y)) * k + k // 2, int(x) * k + k // 2, (r + 0.5) * k)
+        for x, y, _ in wells:
+            row, col = (ny - 1 - int(y)) * k, int(x) * k
+            top, bottom = _beside(row, row + k, 1, img.shape[0])
+            left, right = _beside(col, col + k, 1, img.shape[1])
+            rows, cols = slice(top.start, bottom.stop), slice(left.start, right.stop)
+            img[top, cols] = img[bottom, cols] = img[rows, left] = img[rows, right] = WELL_RGB
+        return _number_wells(img, [((ny - 1 - int(y)) * k + k // 2, int(x) * k + k // 2, k / 2 + 1)
                                    for x, y, _ in wells]) if len(wells) else img
     elif axis == 'y':
         img = _rgb(field[:, index, :], np.repeat(active[:, index, None], nz, 1))[:, ::-1].transpose(1, 0, 2)
-        for x, y, _ in wells:
-            if int(y) == index:
-                img[:, int(x)] = (0.55 * img[:, int(x)] + 0.45 * WELL_RGB).astype(np.uint8)
+        marks = [int(x) for x, y, _ in wells if int(y) == index]
     else:
         img = _rgb(field[index, :, :], np.repeat(active[index, :, None], nz, 1))[:, ::-1].transpose(1, 0, 2)
-        for x, y, _ in wells:
-            if int(x) == index:
-                img[:, int(y)] = (0.55 * img[:, int(y)] + 0.45 * WELL_RGB).astype(np.uint8)
+        marks = [int(y) for x, y, _ in wells if int(x) == index]
     kx = max(1, 1536 // img.shape[1])                       # sections: about 1536 x 256 px (6:1) at any length
     kz = max(1, round(img.shape[1] * kx / 6 / img.shape[0]))
-    return np.kron(img, np.ones((kz, kx, 1), np.uint8))
+    img = np.kron(img, np.ones((kz, kx, 1), np.uint8))
+    w = 1 if kx < 4 else 2                                  # the lines must survive the browser scaling the image down
+    for c in marks:
+        left, right = _beside(c * kx, (c + 1) * kx, w, img.shape[1])
+        img[:, left] = img[:, right] = WELL_RGB
+    return img
 
 
 MAP_INSIDE_RGB = np.array([217, 217, 217], np.uint8)