gov/nasa/worldwind/render/PatternFactory.java

   1 package gov.nasa.worldwind.render;
   2
   3 import java.awt.image.BufferedImage;
   4 import java.awt.*;
   5 import java.awt.geom.AffineTransform;
   6
   7 /**
   8  * Static class to creates tilable patterns.
   9  * <p>
  10  * The <code>createPattern()</code> method draws a shape inside a usually square bitmap, so that it will match if tiled.
  11  * </p>
  12  * <p>
  13  * Each pattern supports a <code>scale</code> factor between <code>zero</code> and <code>one</code> - default is .5.
  14  * With a scale of <code>zero</code> no pattern will be produced. With a scale of <code>one</code> the pattern will
  15  * cover all the background.
  16  * </p>
  17  * @author Patrick Murris
  18  * @version $Id$
  19  */
  20 public class PatternFactory {
  21
  22     public final static String PATTERN_CIRCLE = "PatternFactory.PatternCircle";
  23     public final static String PATTERN_CIRCLES = "PatternFactory.PatternCircles";
  24     public final static String PATTERN_SQUARE = "PatternFactory.PatternSquare";
  25     public final static String PATTERN_SQUARES = "PatternFactory.PatternSquares";
  26     public final static String PATTERN_HLINE = "PatternFactory.PatternHLine";
  27     public final static String PATTERN_VLINE = "PatternFactory.PatternVLine";
  28     public final static String PATTERN_HVLINE = "PatternFactory.PatternHVLine";
  29     public final static String PATTERN_DIAGONAL_UP = "PatternFactory.PatternDiagonalUp";
  30     public final static String PATTERN_DIAGONAL_DOWN = "PatternFactory.PatternDiagonalDown";
  31
  32     public final static String GRADIENT_HLINEAR = "PatternFactory.GradientHLinear";
  33     public final static String GRADIENT_VLINEAR = "PatternFactory.GradientVLinear";
  34
  35     private static Dimension defaultDimension = new Dimension(32, 32);
  36     private static float defaultScale = .5f;
  37     private static Color defaultLineColor = Color.LIGHT_GRAY;
  38     private static Color defaultBackColor = new Color(0f, 0f, 0f, 0f);
  39
  40     /**
  41      * Draws a pattern using the default scale (.5), bitmap dimensions (32x32) and colors (light grey over
  42      * a transparent background).
  43      * @param pattern the pattern to draw. See {@link PatternFactory} static constants.
  44      * @return the corresponding <code>BufferedImage</code>.
  45      */
  46     public static BufferedImage createPattern(String pattern)
  47     {
  48         return createPattern(pattern, defaultDimension, defaultScale, defaultLineColor, defaultBackColor);
  49     }
  50
  51     /**
  52      * Draws a pattern with a given <code>Color</code> using the default scale (.5), bitmap dimensions (32x32)
  53      * and backgound color (transparent).
  54      * @param pattern the pattern to draw. See {@link PatternFactory} static constants.
  55      * @param lineColor the pattern <code>Color</code>.
  56      * @return the corresponding <code>BufferedImage</code>.
  57      */
  58     public static BufferedImage createPattern(String pattern, Color lineColor)
  59     {
  60         return createPattern(pattern, defaultDimension, defaultScale, lineColor, defaultBackColor);
  61     }
  62
  63     /**
  64      * Draws a pattern with a given <code>scale</code> using the default bitmap dimensions (32x32) and colors
  65      * (light grey over a transparent background).
  66      * @param pattern the pattern to draw. See {@link PatternFactory} static constants.
  67      * @param scale the scale at which the pattern should be drawn (0 to 1).
  68      * @return the corresponding <code>BufferedImage</code>.
  69      */
  70     public static BufferedImage createPattern(String pattern, float scale)
  71     {
  72         return createPattern(pattern, defaultDimension, scale, defaultLineColor, defaultBackColor);
  73     }
  74
  75     /**
  76      * Draws a pattern with a given <code>scale</code> and <code>Color</code> using the default bitmap
  77      * dimensions (32x32) and backgound color (transparent).
  78      * @param pattern the pattern to draw. See {@link PatternFactory} static constants.
  79      * @param scale the scale at which the pattern should be drawn (0 to 1).
  80      * @param lineColor the pattern <code>Color</code>.
  81      * @return the corresponding <code>BufferedImage</code>.
  82      */
  83     public static BufferedImage createPattern(String pattern, float scale, Color lineColor)
  84     {
  85         return createPattern(pattern, defaultDimension, scale, lineColor, defaultBackColor);
  86     }
  87
  88     /**
  89      * Draws a pattern with a given <code>scale</code> and <code>Color</code>s using the default bitmap
  90      * dimensions (32x32).
  91      * @param pattern the pattern to draw. See {@link PatternFactory} static constants.
  92      * @param scale the scale at which the pattern should be drawn (0 to 1).
  93      * @param lineColor the pattern <code>Color</code>.
  94      * @param backColor the pattern background <code>Color</code>.
  95      * @return the corresponding <code>BufferedImage</code>.
  96      */
  97     public static BufferedImage createPattern(String pattern, float scale, Color lineColor, Color backColor)
  98     {
  99         return createPattern(pattern, defaultDimension, scale, lineColor, backColor);
 100     }
 101
 102     /**
 103      * Draws a pattern with a given <code>scale</code>, <code>Color</code> and bitmap
 104      * dimensions, using the default backgound color (transparent).
 105      * @param pattern the pattern to draw. See {@link PatternFactory} static constants.
 106      * @param size the <code>Dimension</code> of the <code>BufferedImage produced</code>.
 107      * @param scale the scale at which the pattern should be drawn (0 to 1).
 108      * @param lineColor the pattern <code>Color</code>.
 109      * @return the corresponding <code>BufferedImage</code>.
 110      */
 111     public static BufferedImage createPattern(String pattern, Dimension size, float scale, Color lineColor)
 112     {
 113         return createPattern(pattern, size, scale, lineColor, defaultBackColor);
 114     }
 115
 116     /**
 117      * Draws a pattern with the given <code>scale</code>, <code>Color</code>s and bitmap dimensions.
 118      * @param pattern the pattern to draw. See {@link PatternFactory} static constants.
 119      * @param size the <code>Dimension</code> of the <code>BufferedImage produced</code>.
 120      * @param scale the scale at which the pattern should be drawn (0 to 1).
 121      * @param lineColor the pattern <code>Color</code>.
 122      * @param backColor the pattern background <code>Color</code>.
 123      * @return the corresponding <code>BufferedImage</code>.
 124      */
 125     public static BufferedImage createPattern(String pattern, Dimension size, float scale, Color lineColor, Color backColor)
 126     {
 127         int halfWidth = size.width / 2;
 128         int halfHeight = size.height / 2;
 129         int dim = (int)(size.width * scale);
 130         BufferedImage image = new BufferedImage(size.width,  size.height, BufferedImage.TYPE_4BYTE_ABGR);
 131         Graphics2D g2 = image.createGraphics();
 132         g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 133
 134         // Background
 135         g2.setPaint(backColor);
 136         g2.fillRect(0, 0, size.width, size.height);
 137         if (scale <= 0)
 138             return image;
 139
 140         // Pattern
 141         g2.setPaint(lineColor);
 142         g2.setStroke(new BasicStroke(dim));
 143         if (pattern.compareTo(PATTERN_HLINE) == 0)
 144         {
 145             int y = halfHeight - 1 - dim / 2;
 146             g2.fillRect(0, y, size.width, dim);
 147         }
 148         else if (pattern.compareTo(PATTERN_VLINE) == 0)
 149         {
 150             int x = halfWidth - 1 - dim / 2;
 151             g2.fillRect(x, 0, dim, size.height);
 152         }
 153         if (pattern.compareTo(PATTERN_HVLINE) == 0)
 154         {
 155             int x = halfWidth - 1 - dim / 2;
 156             g2.fillRect(x, 0, dim, size.height);
 157             int y = halfHeight - 1 - dim / 2;
 158             g2.fillRect(0, y, size.width, dim);
 159         }
 160         else if (pattern.compareTo(PATTERN_SQUARE) == 0)
 161         {
 162             int x = halfWidth - 1 - dim / 2;
 163             int y = halfHeight - 1 - dim / 2;
 164             g2.fillRect(x, y, dim, dim);
 165         }
 166         else if (pattern.compareTo(PATTERN_SQUARES) == 0)
 167         {
 168             int x = halfWidth - 1 - dim / 2;
 169             int y = halfHeight - 1 - dim / 2;
 170             g2.fillRect(x, y, dim, dim);
 171             g2.fillRect(x - halfWidth, y - halfHeight, dim, dim);
 172             g2.fillRect(x - halfWidth, y + halfHeight, dim, dim);
 173             g2.fillRect(x + halfWidth, y - halfHeight, dim, dim);
 174             g2.fillRect(x + halfWidth, y + halfHeight, dim, dim);
 175         }
 176         else if (pattern.compareTo(PATTERN_CIRCLE) == 0)
 177         {
 178             int x = halfWidth - 1 - dim / 2;
 179             int y = halfHeight - 1 - dim / 2;
 180             g2.fillOval(x, y, dim, dim);
 181         }
 182         else if (pattern.compareTo(PATTERN_CIRCLES) == 0)
 183         {
 184             int x = halfWidth - 1 - dim / 2;
 185             int y = halfHeight - 1 - dim / 2;
 186             g2.fillOval(x, y, dim, dim);
 187             g2.fillOval(x - halfWidth, y - halfHeight, dim, dim);
 188             g2.fillOval(x - halfWidth, y + halfHeight, dim, dim);
 189             g2.fillOval(x + halfWidth, y - halfHeight, dim, dim);
 190             g2.fillOval(x + halfWidth, y + halfHeight, dim, dim);
 191         }
 192         else if (pattern.compareTo(PATTERN_DIAGONAL_UP) == 0 || pattern.compareTo(PATTERN_DIAGONAL_DOWN) == 0)
 193         {
 194             if (pattern.compareTo(PATTERN_DIAGONAL_DOWN) == 0)
 195             {
 196                 AffineTransform at = AffineTransform.getScaleInstance(-1, 1);
 197                 at.translate(-size.width, 0);
 198                 g2.setTransform(at);
 199             }
 200             g2.drawLine(-dim, size.height - 1 + dim, size.width - 1 + dim, - dim);
 201             g2.drawLine(-dim - 1, dim, dim - 1, - dim);
 202             g2.drawLine(size.width - dim, size.height - 1 + dim, size.width + dim, size.height - 1 - dim);
 203         }
 204         else if (pattern.compareTo(GRADIENT_VLINEAR) == 0)
 205         {
 206             g2.setPaint(new GradientPaint((float)halfWidth, 0f, lineColor, (float)halfWidth, (float)size.height - 1, backColor));
 207             g2.fillRect(0, 0, size.width, size.height);
 208         }
 209         else if (pattern.compareTo(GRADIENT_HLINEAR) == 0)
 210         {
 211             g2.setPaint(new GradientPaint(0f, halfHeight, lineColor, (float)size.width - 1, halfHeight, backColor));
 212             g2.fillRect(0, 0, size.width, size.height);
 213         }
 214
 215         return image;
 216     }
 217 }