optical illusion?

This is a static image. I'm not sure if what you are seeing would still happen if it was on printed paper. I think it might have something to do with the refresh on the monitor ...

Kind of reminds me of when my kids were little: I told them to set still and the said "we are"!

Well, you are supposed to pick out 2 points on the image and then look through the image . When I did that a huge guppy pounced at me and then disappeared.
Working around one point I think I saw a coiled snake but not it's head!
regards

The effect still works on paper. Probably has to do with how much of your field of vision you can maintain focussed at a particular depth.

Look at it at an angle and the illusion stops.

hmmm. if you move away from your PC and look at it from a distance, the illusion stops. Imagine having a room with a huge wallpapers made this way. that would be

Why does it seem to move?

Originally posted by Paul Wheaton:
I'm not sure if what you are seeing would still happen if it was on printed paper. I think it might have something to do with the refresh on the monitor ...

Oooooohhh - I printed it (black & white) & it still seems to move a little. Pretty wild!!

I note that the order of blue vs green is reversed on each adjacent circle, which seems to be why it looks like half are turning one way, and half the other. I wonder, if all the circles has the blue-green going the same way, would it look like everything is turning the same way? Or would the illusion go away because the constrase in patters is what sets it off?
[Paul S]: Look at it at an angle and the illusion stops.
Not for me, though it might be reduced a bit in effect. Curious.
Closing one eye has no effect on the motion part of it. Dunno if HST is pulling our legs about an embedded steroscopic image; I never can see those things anyway. But the illusion of motion is there, and has nothing to do with stereo vision, IMO.
[ October 07, 2003: Message edited by: Jim Yingst ]

Originally posted by Jim Yingst:
I note that the order of blue vs green is reversed on each adjacent circle, which seems to be why it looks like half are turning one way, and half the other. I wonder, if all the circles has the blue-green going the same way, would it look like everything is turning the same way?

I printed it in black and white and the effect was still there.

Right, as Elaine said - but when you do that, do blue & green translate to two different shades of gray, or do they look the same? If they're so close in tone that you can't tell the difference, I doubt you'll see much motion. But maybe I'm wrong.
Someone with Photoshop or something similar might try making a version of this in which all the circles are copies of the same pattern, rather than half going one way and half the other. I've got very, very primitive image editing capabilities at the moment...

My theory is as follows:
Peripheral vision is distorted. When you move your eyes the amount of distortion changes creating movement illusion. It is like looking through imperfect window glass. If you move your head, the outside world appears to change shape. This implies the following:
1)The point you focus at never moves.
2)If you look from a distance there is no movement, because entire picture is in focus, outside peripheral vision
3)Movement stops even in your peripheral vision if your eyes don�t move. This is because distortion at point X is constant.
4)The more your eyes shake and wonder around, the more movement you see. This is because distortion at point X changes, as its image enters the eye at different angles.
Colors only help see the movement. The movement still exist even if you look at white screen, you just don�t notice it.

JY: Dunno if HST is pulling our legs about an embedded steroscopic image; I never can see those things anyway.
As far as I can tell, yes, HS is pulling our leg.
When I look at it, um, stereoscopically, no hidden 3-d image emerges. The motion illusion goes away and the circular patterns deepen into wells with the the four complete circles (six, under "normal" viewing) seeming deeper than the partial circles.
The key to stereograms is that there are slight discrepancies in the repeated pattern. This one seems entirely regular to me.
[ October 07, 2003: Message edited by: Michael Matola ]

JY: But the illusion of motion is there, and has nothing to do with stereo vision, IMO.
The image has been named Notmoving.Gif.

See here for the image in isolation web page

I think you are supposed to see something and no, I wasn't kidding.
Though I can't see a guppy, today. I can see an owl.
The snake tongues sticking out from under the pile of coils may have added to the illusion for me.
regards
[ October 07, 2003: Message edited by: HS Thomas ]

James Guerney had a nice blog entry about this last sort of illusion back in January.

Here's another neat illusion that abuses retinal processing of colors. If you stare at the black cross in the center, the magenta spots will disappear and be replaced by a single light green spot that is moving around the center.

import java.awt.*;
import java.awt.event.*;
import java.awt.image.BufferedImage;
import javax.swing.*;

/**
 * @author Pete Stein
 * 10/30/2010
 */
public class OpticalIllusionGreenCirc2 extends JPanel  {
   private static final long serialVersionUID = 1L;
   private static final int APP_WIDTH = 450;
   private static final Dimension APP_SIZE = new Dimension(APP_WIDTH, APP_WIDTH);
   private static final int BCKGRD_RGB = 175;
   private static final Color BACKGROUND = new Color(BCKGRD_RGB, BCKGRD_RGB, BCKGRD_RGB);
   private static final int SPOT_WIDTH = 80;
   private static final Color SPOT_COLOR = Color.magenta;
   private static final int SPOT_COUNT = 15;
   private static final double FRACTIONAL_RADIUS = 0.7;
   private static final int CYCLE_PERIOD = 1200;
   private static final int CROSS_LENGTH = 8;
   private static final float CROSS_STROKE_WIDTH = 3;
   private static final int RADIAL_GRAD_FRACTION_POINTS = 20;
   private static final double NORMAL_DIST_SIGMA = 0.3;
   
   private float[] radialGradFractions = new float[RADIAL_GRAD_FRACTION_POINTS];
   private Color[] radialGradColors = new Color[RADIAL_GRAD_FRACTION_POINTS];
   private BufferedImage spotImg;
   private Point[] spotPoints = new Point[SPOT_COUNT];
   private int spotsIndex = 0;

public OpticalIllusionGreenCirc2() {
      setPreferredSize(APP_SIZE);
      setBackground(BACKGROUND);
      
      spotImg = createSpot();
      
      for (int i = 0; i < spotPoints.length; i++) {
         double theta = i *(2 * Math.PI) / spotPoints.length;
         int x = (int)(FRACTIONAL_RADIUS * APP_WIDTH * Math.cos(theta)/2) + APP_WIDTH / 2 - SPOT_WIDTH/2;
         int y =(int)(FRACTIONAL_RADIUS * APP_WIDTH * Math.sin(theta)/2) + APP_WIDTH / 2 - SPOT_WIDTH/2;
         spotPoints[i] = new Point(x, y);         
      }
      
      new Timer(CYCLE_PERIOD / SPOT_COUNT, new ActionListener() {
         public void actionPerformed(ActionEvent e) {
            timerActionPerformed();
         }
      }).start();
   }
   
   private void timerActionPerformed() {
      int oldIndex = spotsIndex;
      spotsIndex++;
      spotsIndex %= spotPoints.length;
      repaint(spotPoints[oldIndex].x, spotPoints[oldIndex].y, SPOT_WIDTH, SPOT_WIDTH);
      repaint(spotPoints[spotsIndex].x, spotPoints[spotsIndex].y, SPOT_WIDTH, SPOT_WIDTH);
   }

private BufferedImage createSpot() {
      BufferedImage img = new BufferedImage(SPOT_WIDTH, SPOT_WIDTH, 
               BufferedImage.TYPE_INT_ARGB);
      Graphics2D g2 = img.createGraphics();
      for (int i = 0; i < RADIAL_GRAD_FRACTION_POINTS; i++) {
         float f = (float)i/(RADIAL_GRAD_FRACTION_POINTS - 1);
         radialGradFractions[i] = f;
         
         // use normal distribution to create "fuzzy" dots
         int alpha = (int)Math.round(255 * Math.exp(-f*f/(2*NORMAL_DIST_SIGMA*NORMAL_DIST_SIGMA)));
         int red = SPOT_COLOR.getRed();
         int green = SPOT_COLOR.getGreen();
         int blue = SPOT_COLOR.getBlue();
         radialGradColors[i] = new Color(red, green, blue, alpha);
      }
      float center = (float)SPOT_WIDTH/2;
      g2.setPaint(new RadialGradientPaint(center, center, center, radialGradFractions, radialGradColors));
      g2.fillOval(0, 0, SPOT_WIDTH, SPOT_WIDTH);
      g2.dispose();
      
      return img;
   }

@Override
   protected void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2 = (Graphics2D)g;
      g2.setStroke(new BasicStroke(CROSS_STROKE_WIDTH));
      g2.setColor(Color.black);
      int length = CROSS_LENGTH;
      int x1 = APP_WIDTH/2 - length;
      int x2 = APP_WIDTH/2 + length;
      g2.drawLine(x1, APP_WIDTH/2, x2, APP_WIDTH/2);
      g2.drawLine(APP_WIDTH/2, x1, APP_WIDTH/2, x2);
      for (int i = 0; i < spotPoints.length; i++) {
         if (i != spotsIndex) {
            int x = spotPoints[i].x;
            int y = spotPoints[i].y;
            g.drawImage(spotImg, x, y, null);
         }
      }
   }
   
   private static void createAndShowUI() {
      JFrame frame = new JFrame("Optical Illusion Green Circle");
      frame.getContentPane().setLayout(new GridBagLayout());
      frame.getContentPane().setBackground(Color.black);
      frame.getContentPane().add(new OpticalIllusionGreenCirc2());
      frame.pack();
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
      frame.setLocationRelativeTo(null);
      frame.setVisible(true);
   }

public static void main(String[] args) {
      java.awt.EventQueue.invokeLater(new Runnable() {
         public void run() {
            createAndShowUI();
         }
      });
   }
}