Re: Optimisation for animated MultipleGradientPaint code

Andrew Thompson wrote:


Andrew:

I hacked up your code (sorry) to use active rendering and got a huge
increase in speed. It has a few problems but it works more or less.
The code below is probably too trashed to copy so I'll post the source
file at;

http://rabbitbrush.frazmtn.com/GradientPainter2.java

//package org.physci.paint.gradient;

import java.awt.MultipleGradientPaint;
import java.awt.LinearGradientPaint;
import java.awt.RadialGradientPaint;

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.Canvas;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Toolkit;

import java.awt.image.BufferedImage;
import java.awt.image.BufferStrategy;

import java.awt.geom.AffineTransform;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.event.ComponentListener;
import java.awt.event.ComponentEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.ButtonGroup;
import javax.swing.JPanel;
import javax.swing.JCheckBox;
import javax.swing.JRadioButton;
import javax.swing.SwingUtilities;
import javax.swing.JColorChooser;
import javax.swing.JFrame;
import javax.swing.JWindow;

import java.text.DecimalFormat;

import javax.swing.border.TitledBorder;

import java.util.Random;

/**
A simple animated demo of LinearGradiantPaint and RadialGradiantPaint
(both extending MultipleGradientPaint). While MultipleGradientPaint
derivatives support arrays of many colors, this demo uses just three.
These classes have been included in the J2SE since Java 1.6.
@author Andrew Thompson
@version 2008-05-19
*/
class GradientPainter2 extends Canvas implements ComponentListener,
  Runnable {
   volatile BufferStrategy bs;
   volatile Thread mainThread;

   /** Constant to represent a radial gradientType */
   static final int RADIAL = 0;
   /** Constant to represent a linear gradientType */
   static final int LINEAR = 1;

   /** Type of gradient to draw. */
   int gradientType;

   /** The 'fractions' between the gradient painted colors.
   See The J2SE JavaDocs for details. */
   float[] fractions = new float[3];
   /** The colors used for each of the base
   colors of the fractions above. */
   Color[] colors = new Color[3];

   /** Initial (configurable) CycleMethod. */
   MultipleGradientPaint.CycleMethod cycleMethod =
     MultipleGradientPaint.CycleMethod.REFLECT;

   /** Initial (configurable) ColorSpaceType. */
   MultipleGradientPaint.ColorSpaceType colorSpace =
     MultipleGradientPaint.ColorSpaceType.SRGB;

   /** In the LGP example, this is used as point 1, for RGP eg, it is the
   'center'. See The J2SE JavaDocs for details. */
   Point center;

   /** The amount of pixels to move the center point each move. */
   int centerStepX;
   /** The amount of pixels to move the center point each move. */
   int centerStepY;

   /** In the LGP example, this is used as point 2, for RGP eg, it is the
   'focus'. See The J2SE JavaDocs for details. */
   Point focus;

   /** The amount of pixels to move the focus point each move. */
   int focusStepX;
   /** The amount of pixels to move the focus point each move. */
   int focusStepY;

   /** The radius of any RadialGradientPaint. When the
   focus point is outside the radius from the center point,
   the area of the screen around the focus point collapses
   into moire patterns (assuming a cycle method of either
   repeat or reflect). */
   int radius = 200;

   /** Move the radius continuously from
   lowRadius through highRadius and back. */
   boolean alterRadius = true;
   /** The amount by which to move the radius
   (+1 for expanding, -1 for contracting) */
   int radiusStep = 1;
   /** The maximum radius to use, before contracting. */
   int highRadius = 250;
   /** The minimum radius to use, before expanding. */
   int lowRadius = 150;

   /** Whether to also draw the points and radius
   (radius is for RadialGradientPaint only). */
   boolean showPoints = false;

   /** Whether to display the frame rate. */
   boolean showFps = true;

   /** Used in frame rate calculation. */
   long timeSinceLastFrame = -1;

   /** The dormat used for displaying the frame rate. */
   DecimalFormat dfFps = new DecimalFormat("0.0");
   /** We only update the frame rate every ten frames. */
   int iterations = 0;
   /** The last frame rate caluclated. */
   double rate = 0;

   /** We draw our graphics to the store, before quickly
   drawImage()'*** to screen in the paintComponent method. */
   private BufferedImage store;

   /** The single random number generater used for any
   random values required. */
   private Random rnd;

   /** The MultipleGradientPaint's accept an AffineTransform
   for further processing. This example does not need that,
   so we suply an 'identity' (no change) transform. */
   private AffineTransform affineTransform;

   /** Construct a GradientPainter with default values. */
   GradientPainter2() {
     super();
     setPreferredSize( new Dimension(400,300) );
// setOpaque(true);
     rnd = new Random();
     fractions = new float[3];
     fractions[0] = 0.02f;
     fractions[1] = 0.5f;
     fractions[2] = 0.98f;

     colors = new Color[3];
     colors[0] = new Color(200,220,100);
     colors[1] = new Color(50,40,30);
     //colors[0].darker().darker();
     colors[2] = colors[0].brighter();

     initialiseImage();

     center = new Point(
         rnd.nextInt( getPreferredSize().width ),
         rnd.nextInt( getPreferredSize().height ) ); // center

     focus = new Point(
         rnd.nextInt( getPreferredSize().width ),
         rnd.nextInt( getPreferredSize().height ) ); // focus

     centerStepX = rnd.nextInt(10)+1;
     centerStepY = rnd.nextInt(10)+1;

     focusStepX = rnd.nextInt(10)+1;
     focusStepY = rnd.nextInt(10)+1;

     affineTransform = new AffineTransform();

     this.addComponentListener(this);
   }

   public void run() {
       while (!mainThread.interrupted()) {
         do {
           do {
             Graphics2D g = (Graphics2D)bs.getDrawGraphics();
             render(g);
             g.dispose();
           } while (bs.contentsRestored()) ;
           bs.show();
         } while (bs.contentsLost()) ;
       }
   }

   public void start() {
       mainThread = new Thread(this);
       mainThread.start();
   }

   public void stop() {
       mainThread.interrupt();
   }

   /** Get the color used for this colors array index */
   public Color getColor(int index) {
     return colors[index];
   }

   /** Set the color used for this colors array index */
   public void setColor(Color color, int index) {
     colors[index] = color;
   }

   /** Set the gradientType. */
   public void setGradientType(int type) {

     gradientType = type;
   }

   /** Set the cycleMethod. */
   public void setCycleMethod(
     MultipleGradientPaint.CycleMethod method) {

     cycleMethod = method;
   }

   /** Set the colorSpace. */
   public void setColorSpace(
     MultipleGradientPaint.ColorSpaceType color) {

     colorSpace = color;
   }

   /** Set the showPoints. */
   public void setShowPoints(boolean show) {
     showPoints = show;
   }

   public void setShowFps(boolean show) {
     showFps = show;
   }

   /** Move the two points according to their current step values
   and reverse the direction of any that hit component boundaries.*/
   public void movePoints() {
     int newCenterX = (int)center.getX() + centerStepX;
     if ( newCenterX>getWidth() ) {
       centerStepX = -(rnd.nextInt(2)+3);
     } else if ( newCenterX<0 ) {
       centerStepX = (rnd.nextInt(2)+3);
     }

     int newCenterY = (int)center.getY() + centerStepY;
     if ( newCenterY>getHeight() ) {
       centerStepY = -(rnd.nextInt(2)+3);
     } else if ( newCenterY<0 ) {
       centerStepY = (rnd.nextInt(2)+3);
     }

     center = new Point( newCenterX, newCenterY );

     int newFocusX = (int)focus.getX() + focusStepX;
     if ( newFocusX>getWidth() ) {
       focusStepX = -(rnd.nextInt(2)+3);
     } else if ( newFocusX<0 ) {
       focusStepX = (rnd.nextInt(2)+3);
     }

     int newFocusY = (int)focus.getY() + focusStepY;
     if ( newFocusY>getHeight() ) {
       focusStepY = -(rnd.nextInt(2)+3);
     } else if ( newFocusY<0 ) {
       focusStepY = (rnd.nextInt(2)+3);
     }

     if (alterRadius) {
       radius += radiusStep;
       if ( radius>highRadius ) {
         radiusStep = -1;
       } else if (radius<lowRadius) {
         radiusStep = 1;
       }
     }

     focus = new Point(
       newFocusX,
       newFocusY );
   }

   public void componentHidden(ComponentEvent ce) {}
   public void componentShown(ComponentEvent ce) {}
   public void componentMoved(ComponentEvent ce) {}

   /** On component resize, do a single repaint (which will force
   the last frame of the earlier sized BufferedImage to be scaled
   to current screen size when drawn), then invoke a resizing of
   the BufferedImage on a priority thread, kicked off by
   SwingUtilites.invokeLater(). */
   public void componentResized(ComponentEvent ce) {
       if (bs == null) {
           createBufferStrategy(2);
           bs = getBufferStrategy();
           System.out.println(bs);
       }
       start();
   }

   /** Create a BufferedImage suitable as a backing store
   for the current Component size. */
   public void initialiseImage() {
     initialiseImage(
       getPreferredSize().width,
       getPreferredSize().height );
   }

   /** Create a BufferedImage of size - width x height. */
   public void initialiseImage(int width, int height) {
     store = new BufferedImage(
       width,
       height,
       BufferedImage.TYPE_INT_RGB );
   }

   /** Render the new GradientPaint to the store, then blast it to
screen. */
   public void render(Graphics2D g1) {
     movePoints();

     MultipleGradientPaint paint = null;

     switch(gradientType) {
       case RADIAL:
         paint = new RadialGradientPaint(
           center, // center
           radius, // radius
           focus, // focus
           fractions,
           colors,
           cycleMethod,
           colorSpace,
           affineTransform
           );
         break;
       case LINEAR:
         paint = new LinearGradientPaint(
           center, // 'point 1'
           focus, // 'point 2'
           fractions,
           colors,
           cycleMethod
         );
     }

// Graphics2D g1 = (Graphics2D)store.getGraphics();
     g1.setPaint(paint);
     g1.fillRect( 0,0,getWidth(),getHeight() );

     if (showPoints) {
       int small = 2;
       int big = 3;
       g1.setColor( new Color(0,0,0,128) );
       g1.fillOval( (int)center.getX()-big, (int)center.getY()-big,
2*big, 2*big );
       g1.fillOval( (int)focus.getX()-big, (int)focus.getY()-big, 2*big,
2*big );

       g1.setColor( Color.RED );

       g1.fillOval(
         (int)center.getX()-small,
         (int)center.getY()-small, 2*small, 2*small );
       g1.fillOval(
         (int)focus.getX()-small,
         (int)focus.getY()-small, 2*small, 2*small );
       if ( gradientType==RADIAL ) {
         g1.drawOval(
           (int)center.getX()-radius,
           (int)center.getY()-radius,
           radius*2,
           radius*2 );
         g1.drawString( "C", (int)center.getX()+5, (int)center.getY()+5 );
         g1.drawString( "F", (int)focus.getX()+5, (int)focus.getY()+5 );
       } else {
         g1.drawString( "P1", (int)center.getX()+5, (int)center.getY()+5 );
         g1.drawString( "P2", (int)focus.getX()+5, (int)focus.getY()+5 );
       }
     }

     if (showFps) {
       long time = System.currentTimeMillis();
       if ( timeSinceLastFrame>0 ) {
         if (iterations%10==0) {
           long millisSinceLastFrame = time - timeSinceLastFrame;
           rate = 1000d/millisSinceLastFrame;
         }
         g1.setColor(Color.RED);
         g1.drawString( dfFps.format( rate ), 10, 20 );
       }

       timeSinceLastFrame = time;
       iterations++;
     }

// g.drawImage( store,0,0,getWidth(),getHeight(),this );
   }

   public static void main(String[] args) {
     Thread t = new Thread() {
         public void run() {
           final JWindow w = new JWindow();
           w.setSize( Toolkit.getDefaultToolkit().getScreenSize() );
           w.setLocation(0,0);

           final JFrame f = new JFrame("Gradient Painter");
           f.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

           final GradientPainter2 gp = new GradientPainter2();

           final JPanel mainUI = new JPanel(new BorderLayout(5,3));
           mainUI.add( gp, BorderLayout.CENTER );

           gp.addMouseListener( new MouseAdapter(){
               public void mouseClicked(MouseEvent me) {
                 if (me.getClickCount()==2) {
                       Container c = gp.getFocusCycleRootAncestor();
                       if ( c instanceof JFrame ) {
                         gp.stop();
                         mainUI.remove( gp );
                         w.add( gp );
                         w.setVisible(true);
                         w.validate();
                       } else {
                         gp.stop();
                         w.remove( gp );
                         mainUI.add( gp, BorderLayout.CENTER );
                         w.setVisible(false);
                         f.validate();
                       }
                 }
               }
             } );

           GradiantPainterControls gpc = new GradiantPainterControls(gp);
           mainUI.add( gpc, BorderLayout.EAST );

           f.add( mainUI );

           f.pack();
           f.setLocationRelativeTo(null);
           f.setVisible(true);
         }
       };
     SwingUtilities.invokeLater(t);
   }
}

/** A GUI based configuration class for the GradientPainter. */
class GradiantPainterControls extends JPanel {

   /** Used for selecting alternate colors for the
   three in the default array. */
   JColorChooser colorChooser;

   GradiantPainterControls(final GradientPainter2 painter) {
     colorChooser = new JColorChooser();

     BoxLayout layout = new BoxLayout(this, BoxLayout.Y_AXIS);
     setLayout(layout);

     ButtonGroup type = new ButtonGroup();

     JPanel typeContainer = new JPanel();
     BoxLayout typeLayout = new BoxLayout(typeContainer, BoxLayout.Y_AXIS);
     typeContainer.setLayout(typeLayout);

     typeContainer.setBorder( new TitledBorder("Paint Type") );

     JRadioButton radial = new JRadioButton("Radial", true);
     radial.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           painter.setGradientType( GradientPainter2.RADIAL );
         }
       } );
     typeContainer.add(radial);
     type.add(radial);

     JRadioButton linear = new JRadioButton("Linear", false);
     linear.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           painter.setGradientType( GradientPainter2.LINEAR );
         }
       } );
     typeContainer.add(linear);
     type.add(linear);

     JPanel typeWidthStretch = new JPanel(new BorderLayout());

     typeWidthStretch.add( typeContainer, BorderLayout.CENTER );
     add( typeWidthStretch );

     ButtonGroup spaceGroup = new ButtonGroup();

     JPanel spaceContainer = new JPanel();
     BoxLayout spaceLayout = new BoxLayout(spaceContainer,
BoxLayout.Y_AXIS);
     spaceContainer.setLayout(spaceLayout);

     spaceContainer.setBorder( new TitledBorder("Color Space") );

     JRadioButton srgb = new JRadioButton("S-RGB", true);
     srgb.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           painter.setColorSpace(
             MultipleGradientPaint.ColorSpaceType.SRGB);
         }
       } );
     spaceContainer.add(srgb);
     spaceGroup.add(srgb);

     JRadioButton lrgb = new JRadioButton("Linear RGB", false);
     lrgb.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           painter.setColorSpace(
             MultipleGradientPaint.ColorSpaceType.LINEAR_RGB);
         }
       } );
     spaceContainer.add(lrgb);
     spaceGroup.add(lrgb);

     JPanel spaceWidthStretch = new JPanel(new BorderLayout());

     spaceWidthStretch.add( spaceContainer, BorderLayout.CENTER );
     add( spaceWidthStretch );

     ButtonGroup cycleGroup = new ButtonGroup();

     JPanel cycleContainer = new JPanel();
     BoxLayout cycleLayout = new BoxLayout(cycleContainer,
BoxLayout.Y_AXIS);
     cycleContainer.setLayout(cycleLayout);

     cycleContainer.setBorder( new TitledBorder("Cycle Method") );

     JRadioButton reflect = new JRadioButton("Reflect", true);
     reflect.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           painter.setCycleMethod(
             MultipleGradientPaint.CycleMethod.REFLECT );
         }
       } );
     cycleContainer.add(reflect);
     cycleGroup.add(reflect);

     JRadioButton repeat = new JRadioButton("Repeat", false);
     repeat.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           painter.setCycleMethod(
             MultipleGradientPaint.CycleMethod.REPEAT );
         }
       } );
     cycleContainer.add(repeat);
     cycleGroup.add(repeat);

     JRadioButton noCycle = new JRadioButton("No Cycle", false);
     noCycle.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           painter.setCycleMethod(
             MultipleGradientPaint.CycleMethod.NO_CYCLE );
         }
       } );
     cycleContainer.add(noCycle);
     cycleGroup.add(noCycle);

     JPanel cycleWidthStretch = new JPanel(new BorderLayout());

     cycleWidthStretch.add( cycleContainer, BorderLayout.CENTER );
     add( cycleWidthStretch );

     final JCheckBox displayFps = new JCheckBox("Show FPS", true);
     displayFps.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae){
           painter.setShowFps( displayFps.isSelected() );
         }
       } );

     JPanel displayWidthStretch = new JPanel(new GridLayout(0,1));
     displayWidthStretch.add( displayFps );

     final JCheckBox displayPoints = new JCheckBox("Show Points", false);
     displayPoints.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae){
           painter.setShowPoints( displayPoints.isSelected() );
         }
       } );

     displayWidthStretch.add( displayPoints );

     add( displayWidthStretch );

     JPanel colorContainer = new JPanel();
     BoxLayout colorLayout = new BoxLayout(colorContainer,
BoxLayout.Y_AXIS);
     colorContainer.setLayout(colorLayout);
     colorContainer.setBorder( new TitledBorder("Colors") );

     JPanel colorWidthStretch = new JPanel(new BorderLayout());

     colorWidthStretch.add( colorContainer, BorderLayout.CENTER );
     add( colorWidthStretch );

     final JButton c1 = new JButton("Color 1");
     c1.setOpaque(true);
     c1.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           Color temp = colorChooser.showDialog(
             painter,
             "Color 1",
             painter.getColor(0));
           if (temp!=null) {
             painter.setColor(temp, 0);
             c1.setBackground( temp );
           }
         }
       } );
     colorContainer.add(c1);

     final JButton c2 = new JButton("Color 2");
     c2.setOpaque(true);
     c2.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           Color temp = colorChooser.showDialog(
             painter,
             "Color 2",
             painter.getColor(1));
           if (temp!=null) {
             painter.setColor(temp, 1);
             c2.setBackground( temp );
           }
         }
       } );
     colorContainer.add(c2);

     final JButton c3 = new JButton("Color 3");
     c3.setOpaque(true);
     c3.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent ae) {
           Color temp = colorChooser.showDialog(
             painter,
             "Color 3",
             painter.getColor(2));
           if (temp!=null) {
             painter.setColor(temp, 2);
             c3.setBackground( temp );
           }
         }
       } );
     colorContainer.add(c3);
   }
}

--

Knute Johnson
email s/knute/nospam/

--
Posted via NewsDemon.com - Premium Uncensored Newsgroup Service
      ------->>>>>>http://www.NewsDemon.com<<<<<<------
Unlimited Access, Anonymous Accounts, Uncensored Broadband Access