WHAT HAPPENS IN VEGAS
  STAYS IN VEGAS

https://ibb.co/WWMSXQkQ

I can barely read the actual message, and it's about as "readable" to me as the Magic Eye 3D pictures. Actually I think I have a headache from looking at it on a mobile screen.

As a research idea it's cool though. But I do wonder if/when AI models will figure out how to decode it - I imagine a bit of additional prompting would get them there.

So...usefulness?

Took a picture (only a single frame) and a 1s movie and threw it toward GPT 5.6 Sol (High):

Frame took 9m30s to decyper and GPT 5.6, it returned: WRITTEN IN GHOST FONT. Weird because I can only see "GHOST FONT" on the demo... but extracted data from image (I saw the highlited one) definitely looks like the "Ghost Font".

--

Video is more amusing, because after 3m GPT 5.6 figured it's motion-defined and asked to run QuickTime. At one moment I got:

> The animation is a motion-defined illusion. I’ve confirmed there’s no readable static OCR layer; I’m decoding its optical-flow field so the letter shapes become explicit.

At 4m it got extracted motion image that was in shape of letters but analyzed for 9 more letters and returned (at 13m36s) "GHOST FONT"

--

So:

    a font...             - FALSE - not a font, but video effect
    ...humans can read... - FALSE - I can't read it from image (but AI can!)
    ...but AI cannot      - FALSE - it can

Edit: https://imgur.com/a/SHlGu4O - work-in-progress images

- "This game disappears if you pause it": https://youtu.be/Bg3RAI8uyVw

- "Illusion: If You Pause, The Image Will Disappear": https://youtu.be/ZqGfb_Vlrig

Edit: looks like yes, from the shared chats people are posting. But it’s interesting to think of communication schemes that require a temporal component so any single image is unreadable and can’t be beaten by long exposures or other tricks (otherwise persistence of vision displays would satisfy). A sort of physical anti copy/paste.

"ﾌㄖ乇ㄚ ᗪㄖ乇丂几'ㄒ 丂卄卂尺乇 千ㄖㄖᗪ"

However, I have noticed that voice assistants have a hard time understanding homonyms. Saying "bow" (as in to bow one's head) is often stored as "bow" (as in a bow and arrow). I wonder if there's a sufficiently complex sentence which is intelligible to humans but not to machines?

If the string is empty, I can read "WRITTEN IN GHOST FONT" very faintly. I'm guessing that is a watermark Edit: Ah, it's decoy text. Of course.

strong statement, I struggle to read it

It's interesting work for sure, but the end goal of separating out AI versus human consumers is tough. Indeed, if there was a lasting solution, that would be a substantial discovery that would quickly become very famous...

How about writing or drawing stuff using optical illusions?

Shapes that not even human eyes can see, but the brain hallucinates: Shapes that seem to appear when you look straight at a pattern, or for a second after you look away from a pattern, or after you close your eyes, etc.

If you take a screenshot or a photo the image would just contain the same static pattern.

i.e. qualia-based "cryptography" :)

Skill issue on promoter side.

Fable oneshotted it for me.

""" Reveal a motion-camouflaged message hidden in video noise.

How it works: The background noise scrolls vertically at a constant rate (a few px/frame), while the noise inside the letters does not follow that motion. Any single frame looks like pure static. The decode is:

    1. Estimate the background's global motion between consecutive frames
       with phase correlation (this is the "optical flow" step - the motion
       is a pure translation, so one global vector suffices).
    2. Motion-compensate: shift frame t+1 back by that vector so the
       background lines up with frame t.
    3. Take the absolute difference. The background cancels almost
       perfectly; the letters (which don't move with the background)
       light up.
    4. Average the residual over a SHORT window of consecutive frame pairs
       (long windows smear the letters, because the text itself drifts
       slowly over time), blur lightly, and threshold with Otsu.

import sys import cv2 import numpy as np

PAIRS = 5 # number of consecutive frame pairs to average (keep small!) BLUR_SIGMA = 6 # spatial blur of each residual, in pixels START_FRAME = 0 # where in the video to start

def load_gray_frames(path, count): cap = cv2.VideoCapture(path) frames = [] while len(frames) < count: ok, frame = cap.read() if not ok: break frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY).astype(np.float32)) cap.release() if len(frames) < 2: raise SystemExit("Could not read enough frames from the video.") return frames

def main(): if len(sys.argv) < 2: raise SystemExit(__doc__) src = sys.argv[1] dst = sys.argv[2] if len(sys.argv) > 2 else "revealed_message.png"

    frames = load_gray_frames(src, START_FRAME + PAIRS + 1)
    h, w = frames[0].shape
    acc = np.zeros((h, w), np.float32)

    for i in range(START_FRAME, START_FRAME + PAIRS):
        a, b = frames[i], frames[i + 1]

        # 1) global background motion between the two frames
        (dx, dy), response = cv2.phaseCorrelate(a, b)
        dxi, dyi = int(round(dx)), int(round(dy))
        print(f"pair {i}: background shift = ({dx:+.2f}, {dy:+.2f}) px, "
              f"response = {response:.2f}")

        # 2) motion-compensate frame b by integer (dxi, dyi), then
        # 3) residual = |a - b_shifted| on the overlapping region
        ys = slice(max(0, -dyi), min(h, h - dyi))
        xs = slice(max(0, -dxi), min(w, w - dxi))
        ysb = slice(max(0, dyi), min(h, h + dyi) if dyi < 0 else h)
        # simpler: crop both to the common overlap
        a_ov = a[max(0, -dyi):h - max(0, dyi), max(0, -dxi):w - max(0, dxi)]
        b_ov = b[max(0, dyi):h - max(0, -dyi), max(0, dxi):w - max(0, -dxi)]
        resid = cv2.GaussianBlur(np.abs(a_ov - b_ov), (0, 0), BLUR_SIGMA)
        acc[:resid.shape[0], :resid.shape[1]] += resid

    # 4) normalize + Otsu threshold + light cleanup
    u8 = cv2.normalize(acc, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
    _, mask = cv2.threshold(u8, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)

    out = 255 - mask  # black text on white
    cv2.imwrite(dst, out)
    print(f"wrote {dst}")

    # optional: OCR if pytesseract is installed
    try:
        import pytesseract
        text = pytesseract.image_to_string(out, config="--psm 6").strip()
        print("OCR result:\n" + text)
    except ImportError:
        pass