5D Library › Computational Aesthetics, Visual Saliency Maps and Cognitive Ergonomics in User Interface Design · 中文

Chapter 3 What Pops Out First: Visual Search and Saliency Maps

Chapter 2 assumed that the user already knows where the target is and only has to decide and point. On a new page, though, the user first has to find the target. How fast that happens depends on how different the target is from what surrounds it: a red button in a field of grey “pops out” almost at once, while a link that differs from the others by a single word has to be checked one by one. This chapter first covers the classic results on visual search and then implements, with the standard library alone, the 1998 saliency model of Itti, Koch and Niebur, computing the locations on a fictional page that are “attended first”.

Visual search: features, conjunctions and guidance

Treisman and Gelade’s feature-integration theory (1980) distinguished two kinds of search (Treisman and Gelade 1980). In feature search the target differs from the distractors in one basic feature (one red letter among green ones), and search time hardly grows with the number of distractors, as if the target “popped out”. In conjunction search the target differs only in a combination of features (a red X among green Xs and red Os), and search time grows linearly with the number of items, with a slope when the target is present about half that when it is absent—the signature of a serial, self-terminating search that inspects items one at a time and stops on finding the target. Treisman concluded that features are registered early and in parallel, while “gluing” them into objects requires attention to visit items one by one.

Wolfe’s guided search model revised this dichotomy (Wolfe 1994): parallel feature processing does not only make targets pop out; it also computes a priority for every location, and attention visits locations in order of priority. The larger the feature difference between target and distractors, the more likely the target is to rank near the front and the smaller the search slope; with no difference, guided search reduces to random serial search. In this framework “pop-out” and “serial” are two ends of a continuum.

The program below is an illustrative simulation: inspecting one item takes 50 ms, on top of a base time of 450 ms. Feature search does not depend on the number of items; serial search inspects items in random order; guided search inspects them in order of a noisy priority on which the target is d′d' standard deviations above the distractors.

Calculation

# Visual search time against set size (the author's simulation; parameters are
# illustrative). Feature search: the target differs in one feature and is found in
# parallel; RT = 450 ms + noise, independent of n. Serial self-terminating search
# (conjunction, Treisman & Gelade 1980): items inspected one by one at 50 ms each in
# random order; target-present RT slope ~25 ms/item, absent ~50 ms/item. Guided search
# (in the spirit of Wolfe 1994): items visited in order of a noisy priority
# (signal d' for the target), so the target tends to come early.
import random, statistics

def trial(rng, n, kind, present=True, dprime=1.5, per=50.0, base=450.0):
    if kind == "feature":
        return base + rng.gauss(0, 30)
    if kind == "serial":
        k = rng.randint(1, n) if present else n
    else:                                         # guided: rank of target by priority
        t = rng.gauss(dprime, 1.0)
        k = 1 + sum(rng.gauss(0, 1.0) > t for _ in range(n - 1)) if present else n
    return base + per * k + rng.gauss(0, 30)

def slope(xs, ys):
    mx, my = statistics.fmean(xs), statistics.fmean(ys)
    sxx = sum((x - mx) ** 2 for x in xs)
    return sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / sxx

if __name__ == "__main__":
    rng = random.Random(1980); sizes = (4, 8, 16, 32)
    print("mean RT (ms), 400 trials per cell     n =    4      8     16     32   slope")
    for kind, present in (("feature", True), ("serial", True), ("serial", False),
                          ("guided", True), ("guided", False)):
        means = [statistics.fmean(trial(rng, n, kind, present) for _ in range(400))
                 for n in sizes]
        lab = f"{kind} search, target {'present' if present else 'absent'}"
        print(f"   {lab:36s}" + "".join(f"{m:7.0f}" for m in means)
              + f" {slope(sizes, means):6.1f} ms/item")
    print("guided search, target present, 2,000 trials per cell; expected slope")
    print("   = 50 ms x P(a distractor outranks the target) = 50 Phi(-d'/sqrt 2)")
    for d in (0.0, 0.5, 1.5, 3.0):
        m = [statistics.fmean(trial(rng, n, "guided", True, d) for _ in range(2000))
             for n in sizes]
        th = 50 * statistics.NormalDist().cdf(-d / 2 ** 0.5)
        print(f"   d' = {d:3.1f}: simulated {slope(sizes, m):5.1f}, expected {th:5.1f}"
              f" ms/item")
# mean RT (ms), 400 trials per cell     n =    4      8     16     32   slope
#    feature search, target present          448    451    452    451    0.0 ms/item
#    serial search, target present           575    679    887   1247   23.9 ms/item
#    serial search, target absent            647    851   1250   2051   50.1 ms/item
#    guided search, target present           522    544    606    750    8.3 ms/item
#    guided search, target absent            649    848   1253   2049   50.0 ms/item
# guided search, target present, 2,000 trials per cell; expected slope
#    = 50 ms x P(a distractor outranks the target) = 50 Phi(-d'/sqrt 2)
#    d' = 0.0: simulated  24.6, expected  25.0 ms/item
#    d' = 0.5: simulated  18.1, expected  18.1 ms/item
#    d' = 1.5: simulated   7.2, expected   7.2 ms/item
#    d' = 3.0: simulated   0.8, expected   0.8 ms/item

Feature search has a slope of 0.0 ms per item; serial search has 23.9 ms per item when the target is present and 50.1 when it is absent, a ratio of about 1:2. Guided search (d′=1.5d' = 1.5) has only 8.3 ms per item when the target is present; when it is absent all items must still be checked and the slope returns to 50.0. The second part checks a simple relation: in this model, the expected slope with the target present equals the time per item times “the probability that a distractor outranks the target”, that is 50Φ(−d′/2)50\,\Phi(-d'/\sqrt2). For d′=0d' = 0 it is 25 ms per item (random serial search), for d′=0.5d' = 0.5 it is 18.1, for d′=1.5d' = 1.5 it is 7.2 and for d′=3d' = 3 only 0.8; the simulated values agree.

For interface design this gives a more precise statement than “colours should be eye-catching”: whether an element can be found quickly depends on how much it differs from its surroundings, relative to noise, on some feature that can be computed in parallel, and that difference is relative—when the page is full of red buttons, red no longer guides search. Book 24 discussed Posner’s orienting network and attentional capture; here we only recap that salient exogenous stimuli can draw attention automatically, but such capture is modulated by the current task set.

The Itti–Koch–Niebur saliency model

Structure of the original

The short paper by Itti, Koch and Niebur in IEEE Transactions on Pattern Analysis and Machine Intelligence 20(11):1254–1259 (1998) turned “what pops out first” into a model that can be computed (Itti et al. 1998). Checked against the paper, its structure is as follows:

  1. The input image is split into intensity, colour (red–green and blue–yellow double-opponent) and orientation (0°, 45°, 90°, 135°, from Gabor pyramids) channels, and a nine-level dyadic Gaussian pyramid is built for each (level 0 is the image, level 8 is reduced 256 times).
  2. Centre–surround differences: centres at level c∈{2,3,4}c \in \{2,3,4\}, surrounds at level s=c+δs = c + \delta with δ∈{3,4}\delta \in \{3,4\}; the surround is interpolated to the centre’s scale and subtracted point by point, taking absolute values. Each channel yields 6 maps, giving 6 intensity, 12 colour and 24 orientation maps, 42 feature maps in all.
  3. Normalisation operator 𝒩(⋅)\mathcal N(\cdot): scale the map to a fixed range [0,M][0, M], find the global maximum MM and the mean m‾\bar m of the other local maxima, and multiply the whole map by (M−m‾)2(M-\bar m)^2. Maps with one strong peak are promoted; maps with many comparable peaks are suppressed.
  4. The feature maps of each type are summed at level 4 into intensity, colour and orientation “conspicuity maps”, each normalised, and averaged into the saliency map S=13(𝒩(I‾)+𝒩(C‾)+𝒩(O‾))S = \tfrac13\big(\mathcal N(\bar I) + \mathcal N(\bar C) + \mathcal N(\bar O)\big).
  5. Winner-take-all and inhibition of return: the saliency map drives a winner-take-all network of integrate-and-fire neurons; the first location to fire becomes the focus of attention, and that location is then locally inhibited (inhibition of return), so attention moves to the next most salient location. In the paper the focus of attention is a disk of radius one-sixth of the smaller image dimension; shifts take about 30–70 ms of simulated time, and an attended area stays inhibited for about 500–900 ms.

The paper is equally explicit about the model’s limits: only features explicitly represented in the feature maps can pop out, so conjunctions of features cannot be detected; there is no top-down component; and the attentional trajectories produced by the model are “not necessarily” similar to human eye fixations (Itti et al. 1998).

A standard-library implementation

The program below implements the model on a fictional 256 × 192-pixel landing page. The page has a navigation bar, an orange logo, a hero photograph with a “sun” in it, a headline and body text (simulated with stripes), a call-to-action (CTA) button and a light secondary button, and four product cards. In layout A the CTA is red; in layout B it is grey, with the same intensity I=(r+g+b)/3I = (r+g+b)/3 as the red, so only the colour difference is removed.

Differences from the paper, item by item: (1) the orientation channel uses absolute second differences in four directions instead of Gabor filters; (2) cross-scale subtraction uses nearest-neighbour expansion instead of interpolation; (3) local maxima in the normalisation are found in 3 × 3 neighbourhoods and the multiplier is written (1−m‾)2(1-\bar m)^2 (the map having been scaled to [0,1][0,1]); (4) winner-take-all is “take the maximum” instead of integrate-and-fire neurons, and inhibition of return is a disk of radius 2 cells (on a 16 × 12 grid, about one-sixth of the shorter side). The number of feature maps, 42, is the same as in the paper.

Calculation

# Itti-Koch-Niebur (1998) saliency, synthetic 256 x 192 landing page, standard
# library only. Nine dyadic Gaussian levels (0-8); centre c in {2,3,4}, surround
# s = c + d, d in {3,4}; 6 intensity, 12 colour, 24 orientation maps (42 in all);
# N(.) = scale to [0,1], multiply by (1 - mean of the other local maxima)^2; conspicuity
# maps summed at level 4; S = (N(I) + N(C) + N(O))/3. Simplifications: orientation =
# |oriented second difference| instead of Gabor filters, nearest-neighbour expansion,
# and an argmax WTA with disk-shaped inhibition of return (radius 1/6 of the smaller
# image side) instead of integrate-and-fire neurons. Layout A: red call-to-action
# (CTA) button; layout B: the same button in grey of equal intensity I = (r+g+b)/3.
import math                         # math.fsum: same float sums on Python 3.8-3.13
W, H = 256, 192
BOXES = [("nav bar", 0, 0, 256, 16, (.15, .15, .17)),
         ("logo", 8, 3, 40, 13, (.95, .55, .1)),
         ("hero photo", 8, 24, 124, 100, (.35, .55, .6)),
         ("sun in photo", 84, 34, 100, 50, (.98, .85, .2)),
         ("headline", 136, 28, 248, 36, None), ("body text", 136, 44, 248, 64, None),
         ("CTA button", 136, 76, 196, 92, (.85, .1, .1)),
         ("2nd button", 204, 76, 248, 92, (.9, .9, .9))]
BOXES += [(f"card {k + 1}", 8 + 62 * k, 116, 62 * k + 64, 180, (.93, .93, .93))
          for k in range(4)]
THUMB = ((.75, .8, .85), (.85, .8, .75), (.8, .85, .78), (.82, .8, .86))

def page(cta):
    img = [[(.97, .97, .97)] * W for _ in range(H)]
    for name, x0, y0, x1, y1, col in BOXES:
        col = cta if name == "CTA button" else col
        for y in range(y0, y1):
            for x in range(x0, x1):
                if col:
                    img[y][x] = col
                elif x % 7 < 4 and (name == "headline" or y % 7 < 4):   # text strokes
                    img[y][x] = (.1, .1, .1) if name == "headline" else (.35, .35, .35)
    for k in range(4):                                     # card thumbnails and labels
        for y in range(122, 160):
            for x in range(14 + 62 * k, 58 + 62 * k):
                img[y][x] = THUMB[k]
        for y in range(166, 174):
            for x in range(14 + 62 * k, 50 + 62 * k):
                if x % 5 < 3:
                    img[y][x] = (.4, .4, .4)
    return img

def down(m):                         # blur with [1 4 6 4 1]/16, then keep every 2nd pixel
    h, w = len(m), len(m[0]); k = (1, 4, 6, 4, 1)
    fs = math.fsum
    rows = [[fs(k[j] * r[min(max(x + j - 2, 0), w - 1)] for j in range(5)) / 16
             for x in range(0, w, 2)] for r in m]
    return [[fs(k[j] * rows[min(max(y + j - 2, 0), h - 1)][x] for j in range(5)) / 16
             for x in range(len(rows[0]))] for y in range(0, h, 2)]

def pyramid(m):
    p = [m]
    while len(p) < 9:
        p.append(down(p[-1]))
    return p

def diff(c, s, sign=1):              # |c (-) s|: expand s to the size of c, subtract
    fy, fx = len(s) / len(c), len(s[0]) / len(c[0])
    return [[abs(c[y][x] - sign * s[int(y * fy)][int(x * fx)]) for x in range(len(c[0]))]
            for y in range(len(c))]

def N(m):
    mx = max(max(r) for r in m) or 1.0
    m = [[v / mx for v in r] for r in m]; h, w = len(m), len(m[0]); peaks = []
    for y in range(h):
        for x in range(w):
            v = m[y][x]
            if 0 < v < 1 and all(v >= m[j][i] for j in range(max(y - 1, 0), min(y + 2, h))
                                 for i in range(max(x - 1, 0), min(x + 2, w))):
                peaks.append(v)
    f = (1 - math.fsum(peaks) / len(peaks)) ** 2 if peaks else 1.0
    return [[v * f for v in r] for r in m]

def to4(m):                                        # average-pool any level to 16 x 12
    f = len(m) // 12
    return [[math.fsum(m[y * f + j][x * f + i] for j in range(f) for i in range(f)) / f**2
             for x in range(16)] for y in range(12)]

def add(a, b):
    return [[u + v for u, v in zip(r, q)] for r, q in zip(a, b)]

def orient(m, t):                    # oriented second difference, theta = 0/45/90/135
    dy, dx = ((0, 1), (1, 1), (1, 0), (1, -1))[t]; h, w = len(m), len(m[0])
    g = lambda y, x: m[min(max(y, 0), h - 1)][min(max(x, 0), w - 1)]
    return [[abs(2 * g(y, x) - g(y - dy, x - dx) - g(y + dy, x + dx)) for x in range(w)]
            for y in range(h)]

def saliency(img):
    I = [[math.fsum(p) / 3 for p in r] for r in img]; imax = max(max(r) for r in I)
    def opp(p, i):
        if i < imax / 10:
            return 0.0, 0.0
        r, g, b = (v / i for v in p)
        R, G, B = r - (g + b) / 2, g - (r + b) / 2, b - (r + g) / 2
        Y = (r + g) / 2 - abs(r - g) / 2 - b
        return max(R, 0) - max(G, 0), max(B, 0) - max(Y, 0)
    op = [[opp(p, i) for p, i in zip(r, ri)] for r, ri in zip(img, I)]
    PI = pyramid(I); PRG = pyramid([[o[0] for o in r] for r in op])
    PBY = pyramid([[o[1] for o in r] for r in op])
    PO = [[orient(PI[l], t) if l >= 2 else None for l in range(9)] for t in range(4)]
    zero = [[0.0] * 16 for _ in range(12)]; Ib, Cb, Ob = zero, zero, [zero] * 4; n = 0
    for c in (2, 3, 4):
        for s in (c + 3, c + 4):
            Ib = add(Ib, to4(N(diff(PI[c], PI[s]))))
            rg, by = to4(N(diff(PRG[c], PRG[s], -1))), to4(N(diff(PBY[c], PBY[s], -1)))
            Cb = add(Cb, add(rg, by))
            Ob = [add(Ob[t], to4(N(diff(PO[t][c], PO[t][s])))) for t in range(4)]
            n += 7                       # 1 intensity + 2 colour + 4 orientation maps
    Ob = [N(o) for o in Ob]; O = add(add(Ob[0], Ob[1]), add(Ob[2], Ob[3]))
    S = add(add(N(Ib), N(Cb)), N(O))
    return [[v / 3 for v in r] for r in S], n

def label(x, y):                     # level-4 cell -> page element under its centre
    px, py = 16 * x + 8, 16 * y + 8
    for name, x0, y0, x1, y1, _ in reversed(BOXES):
        if x0 <= px < x1 and y0 <= py < y1:
            return name
    return "white space"

def scanpath(S, k=6, r=2):
    S = [row[:] for row in S]; out = []
    for _ in range(k):
        v, y, x = max((S[y][x], y, x) for y in range(12) for x in range(16))
        out.append((x, y, v))
        for j in range(12):
            for i in range(16):
                if (i - x) ** 2 + (j - y) ** 2 <= r * r:
                    S[j][i] = 0.0
    return out

if __name__ == "__main__":
    for tag, cta in (("A, red CTA", (.85, .1, .1)), ("B, grey CTA", (.35, .35, .35))):
        S, n = saliency(page(cta))
        print(f"layout {tag}: {n} feature maps; saliency map 16 x 12 (level 4)")
        if tag[0] == "A":
            mx = max(max(r) for r in S)
            for r in S:
                print("   |" + "".join(" .:-=+*#%@"[min(int(v / mx * 10), 9)] for v in r)
                  + "|")
        path = scanpath(S, k=40)
        for i, (x, y, v) in enumerate(path[:6], 1):
            print(f"   shift {i}: cell ({x:2d},{y:2d})  S = {v:.3f}  {label(x, y)}")
        first = next(i for i, (x, y, v) in enumerate(path, 1)
                     if label(x, y) == "CTA button")
        print(f"   the CTA button is first attended at shift {first}")
        peak = {}
        for y in range(12):
            for x in range(16):
                peak[label(x, y)] = max(peak.get(label(x, y), 0.0), S[y][x])
        print("   peak S: " + ", ".join(f"{k} {peak[k]:.3f}" for k in
              ("CTA button", "logo", "hero photo", "body text", "card 1")))
# layout A, red CTA: 42 feature maps; saliency map 16 x 12 (level 4)
#    |=*+=============|
#    |-=--=====-------|
#    |++====-++-------|
#    |++==+--++-------|
#    |=*++++++====----|
#    |=*++++++*@@@*---|
#    |-=======--==--::|
#    |-:------::::::::|
#    |:::::...:.......|
#    |:::::...:.......|
#    |:::.:...:...:...|
#    |:.:::.:::.......|
#    shift 1: cell (11, 5)  S = 0.245  CTA button
#    shift 2: cell ( 1, 0)  S = 0.165  logo
#    shift 3: cell ( 8, 5)  S = 0.162  CTA button
#    shift 4: cell ( 1, 5)  S = 0.149  hero photo
#    shift 5: cell ( 3, 4)  S = 0.139  hero photo
#    shift 6: cell ( 8, 2)  S = 0.135  white space
#    the CTA button is first attended at shift 1
#    peak S: CTA button 0.245, logo 0.165, hero photo 0.149, body text 0.134, card 1 0.082
# layout B, grey CTA: 42 feature maps; saliency map 16 x 12 (level 4)
#    shift 1: cell ( 1, 0)  S = 0.274  logo
#    shift 2: cell ( 2, 5)  S = 0.183  hero photo
#    shift 3: cell ( 6, 5)  S = 0.176  hero photo
#    shift 4: cell ( 4, 4)  S = 0.172  hero photo
#    shift 5: cell ( 7, 3)  S = 0.159  hero photo
#    shift 6: cell ( 1, 3)  S = 0.158  hero photo
#    the CTA button is first attended at shift 18
#    peak S: CTA button 0.127, logo 0.274, hero photo 0.183, body text 0.146, card 1 0.090

In the saliency map of layout A (shown as character art; denser characters are more salient), the brightest region is the row containing the CTA button. The model’s first shift of attention lands on the CTA (S=0.245S = 0.245), the second on the logo (0.165), and then back to the left end of the CTA and to the hero photograph. In layout B the CTA’s peak falls to 0.127, the first shift lands on the orange logo (0.274) and the next five all stay on the hero photograph; the CTA is not attended until the 18th shift. The only difference between the layouts is the colour of the button, with identical intensity, so the whole difference comes from the colour channel: the red button is the single prominent peak in the red–green opponent map, and once 𝒩(⋅)\mathcal N(\cdot) has promoted it, it dominates the whole saliency map. Figure 3 shows both saliency maps and the first five shifts.

Saliency maps (16 × 12, level 4; darker is more salient) produced by the author’s implementation of the Itti–Koch–Niebur model on a fictional landing page, with the first five shifts of attention produced by winner-take-all and inhibition of return (open circle: first shift). Left: red call-to-action button (gold frame); right: a grey button of the same intensity. The two layouts differ only in the colour of the button.

Note

What this result shows and what it does not. It shows that, in this model, an element that is unique in colour is predicted to be attended first, and that removing its colour difference can move the same element back to beyond the tenth shift. It does not show that users click red buttons faster, still less that red buttons convert better. The model does not know what the user is trying to do, does not read text and has no centre bias; Chapter 4 shows that these factors often matter more on web pages than low-level saliency. Case reports such as “red buttons convert better than green”, without pre-registration or correction for multiple comparisons (Chapter 1), are not evidence.

How saliency models do on web pages

Dozens of saliency models followed Itti and Koch’s. Borji and Itti’s 2013 review classified and compared nearly 65 models against 13 criteria (Borji and Itti 2013), and discussed a recurring problem: in free viewing of natural scenes, a plain “centre bias” (replacing the saliency map with a Gaussian peaked at the image centre) often predicts fixations about as well as many saliency models.

Web pages differ again from natural scenes. Shen and Zhao (2014) collected eye movements from 11 observers freely viewing 149 web-page screenshots (5 s each) and found that early fixations were clearly biased towards the centre and top-left of the page, often landing on large text, logos, faces and objects; fixations on text regions were harder to predict than on pictures; and adding face detection and a positional bias to a model improved its predictions (Shen and Zhao 2014). Buscher, Cutrell and Morris (2009) recorded the eye movements of 20 users on 361 web pages and found that the distribution of attention varied with the task (information foraging or page recognition) and with demographics (Buscher et al. 2009).

Evidence

Eye movements and saliency on web pages (summary). Borji and Itti 2013: review of about 65 attention models, discussing centre bias, the separation of top-down and bottom-up influences, and evaluation measures (Borji and Itti 2013). Shen and Zhao 2014: 149 web pages, 11 observers, 5 s per page; early fixations biased to the centre and top-left, text harder to predict, models improved by face and position priors (Shen and Zhao 2014). Buscher and colleagues 2009: 20 users, 361 web pages; the distribution of attention depends on task and population (Buscher et al. 2009). These studies have small samples and a limited choice of pages and tasks; their conclusions should be read as directional.

Hypothesis · not established · The marginal effect of colour uniqueness

The author’s hypothesis (not established): on e-commerce pages with a clear task (“find and click the buy button”), changing the call-to-action button from a colour that matches the page to the only highly saturated colour on the page shortens the time to first fixation on the button, but the shortening is smaller with a clear task than in free viewing. What result would show it wrong: in a pre-registered eye-tracking experiment, the confidence interval for the colour × task interaction includes zero, or the shortening with a task is no smaller than in free viewing.

Chapter summary

The speed of visual search depends on the relative difference between target and distractors on features that can be computed in parallel: a large enough difference makes the target pop out, no difference reduces search to inspecting items one by one, and guided search lies in between; the simulated slopes agree with the prediction 50Φ(−d′/2)50\,\Phi(-d'/\sqrt2). The structure of the Itti–Koch–Niebur model (nine-level pyramids, c∈{2,3,4}c\in\{2,3,4\}, δ∈{3,4}\delta\in\{3,4\}, 42 feature maps, 𝒩(⋅)\mathcal N(\cdot), winner-take-all with inhibition of return) checks out; a standard-library implementation shows that, in this model, a button’s colour uniqueness can move it from the 18th shift of attention to the first. But the model describes only low-level saliency, and the paper itself says its trajectories are not necessarily similar to human fixations; on web pages, centre and top-left biases, the task, text and faces are often more important.

References

Borji, Ali, and Laurent Itti. 2013. “State-of-the-Art in Visual Attention Modeling.” IEEE Transactions on Pattern Analysis and Machine Intelligence 35 (1): 185–207.
Buscher, Georg, Edward Cutrell, and Meredith Ringel Morris. 2009. “What Do You See When You’re Surfing? Using Eye Tracking to Predict Salient Regions of Web Pages.” Proceedings of the SIGCHI Conference on Human Factors in Computing Systems (CHI ’09), 21–30.
Itti, Laurent, Christof Koch, and Ernst Niebur. 1998. “A Model of Saliency-Based Visual Attention for Rapid Scene Analysis.” IEEE Transactions on Pattern Analysis and Machine Intelligence 20 (11): 1254–59.
Shen, Chengyao, and Qi Zhao. 2014. “Webpage Saliency.” Computer Vision – ECCV 2014, 33–46. https://doi.org/10.1007/978-3-319-10584-0_3.
Treisman, Anne M., and Garry Gelade. 1980. “A Feature-Integration Theory of Attention.” Cognitive Psychology 12 (1): 97–136.
Wolfe, Jeremy M. 1994. “Guided Search 2.0: A Revised Model of Visual Search.” Psychonomic Bulletin & Review 1 (2): 202–38.

Fan, Y. (2026). Computational Aesthetics, Visual Saliency Maps and Cognitive Ergonomics in User Interface Design: From the Hick–Hyman Law and Spatial Frequency Channels to Saccadic Trajectory Modelling, Read Beside the Kaogongji and Classical Treatise on Architectural Methods [计算美学、视觉显著性图谱与人机界面认知工程] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.23836258 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).