Koodit: Java: Suurennuslasi

//AnimOptBalls.java
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import javax.swing.JFrame;

import java.util.Random;

import java.awt.image.*;
import java.awt.Image;

public class AnimOptBalls extends JFrame implements WindowListener, KeyListener {
  //Pallojen määrä
  private static final int BALLS = 300;

  //Pallo-oliotaulukko (sis. tiedon pallon koordinaateista, väristä ja koosta)
  private OptBall[] balls = new OptBall[BALLS];
  private int [] ballIxs = new int[BALLS];
  private boolean[][] ballCrossX;
  private int[] byA;
  private int[][] bxA;

  private MemoryImageSource mis;
  private Image memoryImage;
  private int [] pixels;

  private int[] ballIntensity;

  //Koneen resoluution selvittämistä varten
  private Toolkit toolkit;
  private Random random;

  private int height;
  private int width;


  //Taulukot taustan ylimmän ja alimman rivin väriarvoille
  private int[] redTop;
  private int[] redBot;
  private int[] greenTop;
  private int[] greenBot;
  private int[] blueTop;
  private int[] blueBot;

  public AnimOptBalls() {
    //Laitetaan ikkuna koko ruudun kokoiseksi ja poistetaan 'turha' otsikkorivi
    toolkit = Toolkit.getDefaultToolkit();
    //this.setSize(toolkit.getScreenSize().width, toolkit.getScreenSize().height);
    this.setSize(640, 400);
    this.setUndecorated(true);
    addWindowListener(this);
    addKeyListener(this);
    random = new Random();
    for (int i = 0; i < BALLS; i++) {
      balls[i] = new OptBall();
    }
    width = this.getWidth();
    height = this.getHeight();
    ballIntensity = new int[256*256];
    initIntensity();

    byA = new int[BALLS];
    ballCrossX = new boolean[BALLS][width];
    bxA = new int[BALLS][width];

    pixels =new int[this.getWidth()*this.getHeight()];

    mis=new MemoryImageSource(this.getWidth(),this.getHeight(),ColorModel.getRGBdefault(),pixels,0,this.getWidth());
    mis.setAnimated(true);
    mis.setFullBufferUpdates(true);
    memoryImage=createImage(mis);

    redTop = new int[width];
    redBot = new int[width];
    greenTop = new int[width];
    greenBot = new int[width];
    blueTop = new int[width];
    blueBot = new int[width];

    if (memoryImage == null) {
      System.out.println("mi = null");
      System.exit(0);
    }

  }

  private void initIntensity() {

    for (int x = 0; x < 256; x++)
      for (int y = 0; y < 256; y++) {

	int dx = x-128;
	int dy = y-128;


        int I = 255-(int)(2*Math.sqrt(dx*dx + dy*dy));

	if (I < 0)
	  I = 0;
	ballIntensity[(y<<8) + x] =  I; // värien intensiteetit integer arvona, max 255, min = 0
      }
  }

  public void render() {

 //Taustan väriliu'un väriarvot. Saa muuttaa...
    int r = random.nextInt();

    int R_LEFT_TOP = ((r & 0x1) > 0)? 255 : 0;
    int G_LEFT_TOP = ((r & 0x2) > 0)? 255 : 0;
    int B_LEFT_TOP = ((r & 0x4) > 0)? 255 : 0;

    int R_RIGHT_TOP = ((r & 0x10) > 0)? 255 : 0;
    int G_RIGHT_TOP = ((r & 0x20) > 0)? 255 : 0;
    int B_RIGHT_TOP = ((r & 0x40) > 0)? 255 : 0;

    int R_LEFT_BOT = ((r & 0x100) > 0)? 255 : 0;
    int G_LEFT_BOT = ((r & 0x200) > 0)? 255 : 0;
    int B_LEFT_BOT = ((r & 0x400) > 0)? 255 : 0;

    int R_RIGHT_BOT = ((r & 0x1000) > 0)? 255 : 0;
    int G_RIGHT_BOT = ((r & 0x2000) > 0)? 255 : 0;
    int B_RIGHT_BOT = ((r & 0x4000) > 0)? 255 : 0;


    //Vähennetään huomattavasti tarvittavien laskutoimitusten määrää laskemalla taustan
    //ylimmän ja alimman rivin väriarvot valmiiksi (niitä käytetään koko taustan laskemisessa...

    for (int x = 0; x < width; x++) {
      int mul1 = ((width - x)<<8) / width; //suoritetaan jakolasku vain kerran
      int mul2 = 256-mul1;

      redTop[x]   = ( mul1 * R_LEFT_TOP + mul2 * R_RIGHT_TOP ) >> 8;
      redBot[x]   = ( mul1 * R_LEFT_BOT + mul2 * R_RIGHT_BOT ) >> 8;
      greenTop[x] = ( mul1 * G_LEFT_TOP + mul2 * G_RIGHT_TOP ) >> 8;
      greenBot[x] = ( mul1 * G_LEFT_BOT + mul2 * G_RIGHT_BOT ) >> 8;
      blueTop[x]  = ( mul1 * B_LEFT_TOP + mul2 * B_RIGHT_TOP ) >> 8;
      blueBot[x]  = ( mul1 * B_LEFT_BOT + mul2 * B_RIGHT_BOT ) >> 8;

    }

    //Arvotaan päälle tuleville palloille koordinaatit, väri ja koko

    for (int i = 0; i < BALLS; i++) {
      //balls[i] = new Ball();
      balls[i].x = random.nextInt( width );
      balls[i].y = random.nextInt( height );
      balls[i].radius = 20 + random.nextInt( 50 );
      int color = random.nextInt();
      balls[i].red = (color & 0x00ff0000) >> 16;
      balls[i].green = (color & 0x0000ff00) >> 8;
      balls[i].blue = (color & 0x000000ff);

      // lasketaan taulukkoon, millä x:n arvolla pallo on kohdalla
      for (int x = 0; x < width; x++) {
	ballCrossX[i][x] = false;
      }
      int xmax = balls[i].x+balls[i].radius;
      int xmin = balls[i].x-balls[i].radius;
      if (xmax > width)
	xmax = width;
      if(xmin < 0)
	xmin = 0;
      for (int x = xmin; x < xmax; x++) {
	bxA[i][x] = ((x - balls[i].x + balls[i].radius)<<7)/balls[i].radius;
	ballCrossX[i][x] =  ((bxA[i][x] & 0xffffff00) == 0);
	bxA[i][x] <<=8; //kerrotaan valmiiksi intensiteetti taulukon leveydellä (256)
      }
    }


    int offs = 0;
    int colMul1;
    int colMul2;
    //Käydään jokainen kuvan piste läpi ja lasketaan sille väriarvo
    for (int y = 0; y < height; y++) {


      int ballsInRow = 0;
      for (int i = 0; i < BALLS; i++) {
	byA[i] = ((y - balls[i].y + balls[i].radius)<<7)/balls[i].radius;
	if  ((byA[i] & 0xffffff00) == 0)
	  ballIxs[ballsInRow++] = i;
      }

      colMul1 = ((height - y)<<8) / height;
      colMul2 = 256 - colMul1;

      for (int x = 0; x < width; x ++) {
	//Oletuksena pisteen väri on musta
	int red = 0, green = 0, blue = 0;

	//Lasketaan mitkä kaikki pallot ovat riittävän lähellä pistettä

	for (int i = 0; i < ballsInRow; i++) {
	  int iBall = ballIxs[i];
	  if (ballCrossX[iBall][x]) {
	    int I = ballIntensity[bxA[iBall][x]+byA[iBall]];
	    int re = (I*balls[iBall].red)  >>4; //estetään overflow neliöitäessä
	    int gr = (I*balls[iBall].green)  >>4;
	    int bl = (I*balls[iBall].blue)  >>4;
	    //red += re;
	    //green += gr;
	    //blue += bl;
	    red += (re*re);
	    green += (gr*gr);
	    blue += (bl*bl);
	  }
	}

	//Jos yksikään pallo ei ollut riittävän lähellä pistettä, niin piirretään taustaa

	if (red == 0 && green == 0 && blue == 0) {

	  red = (colMul1 * redTop[x] + colMul2 * redBot[x]) >> 8;
	  green = (colMul1 * greenTop[x] + colMul2 * greenBot[x]) >> 8;
	  blue = (colMul1 * blueTop[x] + colMul2 * blueBot[x]) >> 8;
	}
	else {

	  red = (int)Math.sqrt(red);
	  green = (int)Math.sqrt(green);
	  blue = (int)Math.sqrt(blue);
	  red >>=4; //skaalataan intensiteetillä kertominen oikeaksi väriksi
	  green >>=4;
	  blue >>=4;

	  if (red > 255)   red = 255;
	  if (green > 255) green = 255;
	  if (blue > 255)  blue = 255;

	}


	pixels[offs++] = 0xff000000 | (red << 16) | (green << 8) | blue;

      }
    }
  }

  public void nextFrame() {
     mis.newPixels(0, 0, width, height);
  }

  public void paint(Graphics g) {

    g.drawImage(memoryImage, 0,0,this);
  }

  //-------------------- MAIN ------------

  public static void main(String[] args) {
    AnimOptBalls liuku = new AnimOptBalls();


    int n = 100;
    long time = System.currentTimeMillis();
    for (int i = 0; i < n; i++)
      liuku.render();
    System.out.println("Render time: "+((System.currentTimeMillis()-time)/(double)n));

    Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

    liuku.setVisible(true);

    while(liuku.isShowing()) {
      liuku.render();
      liuku.nextFrame();
      try {
	Thread.sleep(1);
      }catch(Exception e) {return;}
    }
  }

  public void windowActivated(WindowEvent arg0) {
  }

    public void windowClosed(WindowEvent arg0) {
    }

    public void windowClosing(WindowEvent arg0) {
        System.exit(0);
    }

    public void windowDeactivated(WindowEvent arg0) {
    }

    public void windowDeiconified(WindowEvent arg0) {
    }

    public void windowIconified(WindowEvent arg0) {
    }

    public void windowOpened(WindowEvent arg0) {
    }

    //Näppäinkomennot: Väli tai esc lopettaa, Enter piirtää uuden kuvan
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_SPACE
            || e.getKeyCode() == KeyEvent.VK_ESCAPE) {
            System.exit(0);
        }

        if (e.getKeyCode() == KeyEvent.VK_ENTER) {
	  //render();
        }
    }

    public void keyReleased(KeyEvent e) {
    }

    public void keyTyped(KeyEvent e) {
    }
}

// Ball.java
public class OptBall {
    public int x;
    public int y;
    public int red;
    public int green;
    public int blue;
    public int radius;

    public OptBall() {
    }

    public OptBall(int x,int  y,int  red,int  green,int  blue,int  radius) {
        this.x = x;
        this.y = y;
        this.red = red;
        this.green = green;
        this.blue = blue;
        this.radius = radius;
    }
}

//OptBalls.java
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

import javax.swing.JFrame;

import java.util.Random;

import java.awt.image.*;
import java.awt.Image;

public class OptBalls extends JFrame implements WindowListener, KeyListener {
  //Pallojen määrä
  private static final int BALLS = 300;

  //Pallo-oliotaulukko (sis. tiedon pallon koordinaateista, väristä ja koosta)
  private OptBall[] balls = new OptBall[BALLS];

  //taulokko johon sijoitetaan pallojen indeksit, jotka x-koordinaatti leikkaa
  private int [] ballIxs = new int[BALLS];

  //kullekin kuvan riville laskettu, mitä palloja se rivi leikkaa.
  private boolean[][] ballCrossY;

  //intensiteetti taulukkoon skaalattujen x ja y-koordinaatteja laskettuna
  private int[] bxA;
  private int[][] byA;

  //256x256 taulukko, jossa valointensiteetit valmiiksi laskettuna
  private int[] ballIntensity;

  //kuinka monta kertaa käydään kuva läpi ennen kuin se on piirretty
  private static final int passes = 7;

  //Mistä pikseleistä lähdetään liikkeelle ja kuinka paljon edetään.
  //Tässä on sama tapa, jolla esim. PNG toteuttaa interlace ominaisuutensa
  private static final int[] xstart = {0,0,4,0,2,0,1};
  private static final int[] xadd   = {8,8,8,4,4,2,2};
  private static final int[] ystart = {0,4,0,2,0,1,0};
  private static final int[] yadd   = {8,8,4,4,2,2,1};

  //Koneen resoluution selvittämistä varten
  private Toolkit toolkit;


  private Random random;

  private int height;
  private int width;


  //Taulukot taustan ylimmän ja alimman rivin väriarvoille
  private int[] redTop;
  private int[] redBot;
  private int[] greenTop;
  private int[] greenBot;
  private int[] blueTop;
  private int[] blueBot;


  public OptBalls() {
    //Laitetaan ikkuna koko ruudun kokoiseksi ja poistetaan 'turha' otsikkorivi
    toolkit = Toolkit.getDefaultToolkit();
    //  this.setSize(toolkit.getScreenSize().width, toolkit.getScreenSize().height);
    this.setSize(640, 400);
    this.setUndecorated(true);
    addWindowListener(this);
    addKeyListener(this);
    random = new Random();
    for (int i = 0; i < BALLS; i++) {
      balls[i] = new OptBall();
    }
    width = this.getWidth();
    height = this.getHeight();
    ballIntensity = new int[256*256];
    initIntensity();

    bxA = new int[BALLS];
    ballCrossY = new boolean[BALLS][height];
    byA = new int[BALLS][height];

    redTop = new int[width];
    redBot = new int[width];
    greenTop = new int[width];
    greenBot = new int[width];
    blueTop = new int[width];
    blueBot = new int[width];
  }

  /**
   * Lasketaan etäisyyden mukaan pienenevä intensiteetti
   * 256x256 taulukkoon. Pallojen koordinaatit skaalataan
   * tähän sopivaksi.
   */
  private void initIntensity() {

    for (int x = 0; x < 256; x++)
      for (int y = 0; y < 256; y++) {

	int dx = x-128;
	int dy = y-128;


        int I = 255-(int)(2*Math.sqrt(dx*dx + dy*dy));

	if (I < 0)
	  I = 0;
	ballIntensity[(y<<8) + x] =  I; // värien intensiteetit integer arvona, max 255, min = 0
      }
  }

  public void render(Graphics g) {

    //Taustan väriliu'un väriarvot. Saa muuttaa...

    //arvotaan kaikki värit yhdellä kertaa :)
    int r = random.nextInt();

    int R_LEFT_TOP = ((r & 0x1) > 0)? 255 : 0;
    int G_LEFT_TOP = ((r & 0x2) > 0)? 255 : 0;
    int B_LEFT_TOP = ((r & 0x4) > 0)? 255 : 0;

    int R_RIGHT_TOP = ((r & 0x10) > 0)? 255 : 0;
    int G_RIGHT_TOP = ((r & 0x20) > 0)? 255 : 0;
    int B_RIGHT_TOP = ((r & 0x40) > 0)? 255 : 0;

    int R_LEFT_BOT = ((r & 0x100) > 0)? 255 : 0;
    int G_LEFT_BOT = ((r & 0x200) > 0)? 255 : 0;
    int B_LEFT_BOT = ((r & 0x400) > 0)? 255 : 0;

    int R_RIGHT_BOT = ((r & 0x1000) > 0)? 255 : 0;
    int G_RIGHT_BOT = ((r & 0x2000) > 0)? 255 : 0;
    int B_RIGHT_BOT = ((r & 0x4000) > 0)? 255 : 0;


    //Vähennetään huomattavasti tarvittavien laskutoimitusten määrää laskemalla taustan
    //ylimmän ja alimman rivin väriarvot valmiiksi (niitä käytetään koko taustan laskemisessa...
    for (int x = 0; x < width; x++) {
      redTop[x] = ((width - x) * R_LEFT_TOP + x * R_RIGHT_TOP) / width;
      redBot[x] = ((width - x) * R_LEFT_BOT + x * R_RIGHT_BOT) / width;
      greenTop[x] = ((width - x) * G_LEFT_TOP + x * G_RIGHT_TOP) / width;
      greenBot[x] = ((width - x) * G_LEFT_BOT + x * G_RIGHT_BOT) / width;
      blueTop[x] = ((width - x) * B_LEFT_TOP + x * B_RIGHT_TOP) / width;
      blueBot[x] = ((width - x) * B_LEFT_BOT + x * B_RIGHT_BOT) / width;
    }

    //Arvotaan päälle tuleville palloille koordinaatit, väri ja koko
    for (int i = 0; i < BALLS; i++) {
      //balls[i] = new Ball();
      balls[i].x = random.nextInt( width );
      balls[i].y = random.nextInt( height );
      balls[i].radius = 20 + random.nextInt( 50 );
      int color = random.nextInt();
      balls[i].red = (color & 0x00ff0000) >> 16;
      balls[i].green = (color & 0x0000ff00) >> 8;
      balls[i].blue = (color & 0x000000ff);

      // lasketaan taulukkoon, millä y:n arvolla pallo on kohdalla
      for (int y = 0; y < height; y++) {
	byA[i][y] = ((y - balls[i].y + balls[i].radius)<<7)/balls[i].radius;
	ballCrossY[i][y] =  ((byA[i][y] & 0xffffff00) == 0);
	byA[i][y] <<=8; //kerrotaan valmiiksi intensiteetti taulukon leveydellä (256)
      }
    }

    //Käydään jokainen kuvan piste läpi ja lasketaan sille väriarvo

    //
    for (int iPass = 0; iPass < passes; iPass++) {
      for (int x = xstart[iPass]; x < width; x += xadd[iPass]) {

	//tarkastetaan mitä palloja x-koordinaatti leikkaa
      	int ballsInCol = 0;
	for (int i = 0; i < BALLS; i++) {

	  bxA[i] = ((x - balls[i].x + balls[i].radius)<<7)/balls[i].radius;
	  if  ((bxA[i] & 0xffffff00) == 0) //bxA[i] == (0-255)
	    ballIxs[ballsInCol++] = i; //taulukoidaan mahdolliset pallot
	}

	for (int y = ystart[iPass]; y < height; y+=yadd[iPass]) {
	//Oletuksena pisteen väri on musta
	  int red = 0, green = 0, blue = 0;

	  //Tarkastetaan vain ne pallot, jotka x-koordinaatti leikkaa.
	  for (int i = 0; i < ballsInCol; i++) {
	    int iBall = ballIxs[i];
	  if (ballCrossY[iBall][y]) {
	    int I = ballIntensity[byA[iBall][y]+bxA[iBall]];
	    int re = (I*balls[iBall].red)  >>4; //estetään overflow neliöitäessä
	    int gr = (I*balls[iBall].green)  >>4;
	    int bl = (I*balls[iBall].blue)  >>4;
	    red += (re*re);
	    green += (gr*gr);
	    blue += (bl*bl);
	  }
	  }
	  //Jos yksikään pallo ei ollut riittävän lähellä pistettä, niin piirretään taustaa
	  if (red == 0 && green == 0 && blue == 0) {
	    red = ((height - y) * redTop[x] + y * redBot[x]) / height;
	    green = ((height - y) * greenTop[x] + y * greenBot[x]) / height;
	    blue = ((height - y) * blueTop[x] + y * blueBot[x]) / height;

	  }
	  else {
	    red = (int)Math.sqrt(red);
	    green = (int)Math.sqrt(green);
	    blue = (int)Math.sqrt(blue);
	    red >>=4; //skaalataan intensiteetillä kertominen oikeaksi väriksi
	    green >>=4;
	    blue >>=4;
	    if (red > 255)   red = 255;
	    if (green > 255) green = 255;
	    if (blue > 255)  blue = 255;

	  }
	  g.setColor(new Color(red, green, blue));
	  //kuva nopeasti esiin
	  g.fillRect(x, y, xadd[iPass], yadd[iPass]);

	  //ihan kiva efekti
	  //g.fillRect(x, y, 1, 1);
	}
      }
    }
  }

  public void paint(Graphics g) {
    render(g);
  }

  public static void main(String[] args) {
    OptBalls liuku = new OptBalls();
    Thread me = Thread.currentThread( );
    me.setPriority(Thread.MIN_PRIORITY);

    liuku.setVisible(true);
  }

  public void windowActivated(WindowEvent arg0) {
  }

    public void windowClosed(WindowEvent arg0) {
    }

    public void windowClosing(WindowEvent arg0) {
        System.exit(0);
    }

    public void windowDeactivated(WindowEvent arg0) {
    }

    public void windowDeiconified(WindowEvent arg0) {
    }

    public void windowIconified(WindowEvent arg0) {
    }

    public void windowOpened(WindowEvent arg0) {
    }

    //Näppäinkomennot: Väli tai esc lopettaa, Enter piirtää uuden kuvan
    public void keyPressed(KeyEvent e) {
        if (e.getKeyCode() == KeyEvent.VK_SPACE
            || e.getKeyCode() == KeyEvent.VK_ESCAPE) {
            System.exit(0);
        }

        if (e.getKeyCode() == KeyEvent.VK_ENTER) {
	  repaint();
        }
    }

    public void keyReleased(KeyEvent e) {
    }

    public void keyTyped(KeyEvent e) {
    }
}