001 /* ===========================================================
002 * JFreeChart : a free chart library for the Java(tm) platform
003 * ===========================================================
004 *
005 * (C) Copyright 2000-2008, by Object Refinery Limited and Contributors.
006 *
007 * Project Info: http://www.jfree.org/jfreechart/index.html
008 *
009 * This library is free software; you can redistribute it and/or modify it
010 * under the terms of the GNU Lesser General Public License as published by
011 * the Free Software Foundation; either version 2.1 of the License, or
012 * (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but
015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017 * License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this library; if not, write to the Free Software
021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022 * USA.
023 *
024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025 * in the United States and other countries.]
026 *
027 * ---------------------
028 * WaferMapRenderer.java
029 * ---------------------
030 * (C) Copyright 2003-2008, by Robert Redburn and Contributors.
031 *
032 * Original Author: Robert Redburn;
033 * Contributor(s): David Gilbert (for Object Refinery Limited);
034 *
035 * Changes
036 * -------
037 * 25-Nov-2003 : Version 1, contributed by Robert Redburn. Changes have been
038 * made to fit the JFreeChart coding style (DG);
039 * 20-Apr-2005 : Small update for changes to LegendItem class (DG);
040 * ------------- JFREECHART 1.0.x ---------------------------------------------
041 * 02-Feb-2007 : Removed author tags from all over JFreeChart sources (DG);
042 *
043 */
044
045 package org.jfree.chart.renderer;
046
047 import java.awt.Color;
048 import java.awt.Paint;
049 import java.awt.Shape;
050 import java.awt.Stroke;
051 import java.awt.geom.Rectangle2D;
052 import java.util.HashMap;
053 import java.util.HashSet;
054 import java.util.Iterator;
055 import java.util.Map;
056 import java.util.Set;
057
058 import org.jfree.chart.LegendItem;
059 import org.jfree.chart.LegendItemCollection;
060 import org.jfree.chart.plot.DrawingSupplier;
061 import org.jfree.chart.plot.WaferMapPlot;
062 import org.jfree.data.general.WaferMapDataset;
063
064 /**
065 * A renderer for wafer map plots. Provides color managment facilities.
066 */
067 public class WaferMapRenderer extends AbstractRenderer {
068
069 /** paint index */
070 private Map paintIndex;
071
072 /** plot */
073 private WaferMapPlot plot;
074
075 /** paint limit */
076 private int paintLimit;
077
078 /** default paint limit */
079 private static final int DEFAULT_PAINT_LIMIT = 35;
080
081 /** default multivalue paint calculation */
082 public static final int POSITION_INDEX = 0;
083
084 /** The default value index. */
085 public static final int VALUE_INDEX = 1;
086
087 /** paint index method */
088 private int paintIndexMethod;
089
090 /**
091 * Creates a new renderer.
092 */
093 public WaferMapRenderer() {
094 this(null, null);
095 }
096
097 /**
098 * Creates a new renderer.
099 *
100 * @param paintLimit the paint limit.
101 * @param paintIndexMethod the paint index method.
102 */
103 public WaferMapRenderer(int paintLimit, int paintIndexMethod) {
104 this(new Integer(paintLimit), new Integer(paintIndexMethod));
105 }
106
107 /**
108 * Creates a new renderer.
109 *
110 * @param paintLimit the paint limit.
111 * @param paintIndexMethod the paint index method.
112 */
113 public WaferMapRenderer(Integer paintLimit, Integer paintIndexMethod) {
114
115 super();
116 this.paintIndex = new HashMap();
117
118 if (paintLimit == null) {
119 this.paintLimit = DEFAULT_PAINT_LIMIT;
120 }
121 else {
122 this.paintLimit = paintLimit.intValue();
123 }
124
125 this.paintIndexMethod = VALUE_INDEX;
126 if (paintIndexMethod != null) {
127 if (isMethodValid(paintIndexMethod.intValue())) {
128 this.paintIndexMethod = paintIndexMethod.intValue();
129 }
130 }
131 }
132
133 /**
134 * Verifies that the passed paint index method is valid.
135 *
136 * @param method the method.
137 *
138 * @return <code>true</code> or </code>false</code>.
139 */
140 private boolean isMethodValid(int method) {
141 switch (method) {
142 case POSITION_INDEX: return true;
143 case VALUE_INDEX: return true;
144 default: return false;
145 }
146 }
147
148 /**
149 * Returns the drawing supplier from the plot.
150 *
151 * @return The drawing supplier.
152 */
153 public DrawingSupplier getDrawingSupplier() {
154 DrawingSupplier result = null;
155 WaferMapPlot p = getPlot();
156 if (p != null) {
157 result = p.getDrawingSupplier();
158 }
159 return result;
160 }
161
162 /**
163 * Returns the plot.
164 *
165 * @return The plot.
166 */
167 public WaferMapPlot getPlot() {
168 return this.plot;
169 }
170
171 /**
172 * Sets the plot and build the paint index.
173 *
174 * @param plot the plot.
175 */
176 public void setPlot(WaferMapPlot plot) {
177 this.plot = plot;
178 makePaintIndex();
179 }
180
181 /**
182 * Returns the paint for a given chip value.
183 *
184 * @param value the value.
185 *
186 * @return The paint.
187 */
188 public Paint getChipColor(Number value) {
189 return getSeriesPaint(getPaintIndex(value));
190 }
191
192 /**
193 * Returns the paint index for a given chip value.
194 *
195 * @param value the value.
196 *
197 * @return The paint index.
198 */
199 private int getPaintIndex(Number value) {
200 return ((Integer) this.paintIndex.get(value)).intValue();
201 }
202
203 /**
204 * Builds a map of chip values to paint colors.
205 * paintlimit is the maximum allowed number of colors.
206 */
207 private void makePaintIndex() {
208 if (this.plot == null) {
209 return;
210 }
211 WaferMapDataset data = this.plot.getDataset();
212 Number dataMin = data.getMinValue();
213 Number dataMax = data.getMaxValue();
214 Set uniqueValues = data.getUniqueValues();
215 if (uniqueValues.size() <= this.paintLimit) {
216 int count = 0; // assign a color for each unique value
217 for (Iterator i = uniqueValues.iterator(); i.hasNext();) {
218 this.paintIndex.put(i.next(), new Integer(count++));
219 }
220 }
221 else {
222 // more values than paints so map
223 // multiple values to the same color
224 switch (this.paintIndexMethod) {
225 case POSITION_INDEX:
226 makePositionIndex(uniqueValues);
227 break;
228 case VALUE_INDEX:
229 makeValueIndex(dataMax, dataMin, uniqueValues);
230 break;
231 default:
232 break;
233 }
234 }
235 }
236
237 /**
238 * Builds the paintindex by assigning colors based on the number
239 * of unique values: totalvalues/totalcolors.
240 *
241 * @param uniqueValues the set of unique values.
242 */
243 private void makePositionIndex(Set uniqueValues) {
244 int valuesPerColor = (int) Math.ceil(
245 (double) uniqueValues.size() / this.paintLimit
246 );
247 int count = 0; // assign a color for each unique value
248 int paint = 0;
249 for (Iterator i = uniqueValues.iterator(); i.hasNext();) {
250 this.paintIndex.put(i.next(), new Integer(paint));
251 if (++count % valuesPerColor == 0) {
252 paint++;
253 }
254 if (paint > this.paintLimit) {
255 paint = this.paintLimit;
256 }
257 }
258 }
259
260 /**
261 * Builds the paintindex by assigning colors evenly across the range
262 * of values: maxValue-minValue/totalcolors
263 *
264 * @param max the maximum value.
265 * @param min the minumum value.
266 * @param uniqueValues the unique values.
267 */
268 private void makeValueIndex(Number max, Number min, Set uniqueValues) {
269 double valueRange = max.doubleValue() - min.doubleValue();
270 double valueStep = valueRange / this.paintLimit;
271 int paint = 0;
272 double cutPoint = min.doubleValue() + valueStep;
273 for (Iterator i = uniqueValues.iterator(); i.hasNext();) {
274 Number value = (Number) i.next();
275 while (value.doubleValue() > cutPoint) {
276 cutPoint += valueStep;
277 paint++;
278 if (paint > this.paintLimit) {
279 paint = this.paintLimit;
280 }
281 }
282 this.paintIndex.put(value, new Integer(paint));
283 }
284 }
285
286 /**
287 * Builds the list of legend entries. called by getLegendItems in
288 * WaferMapPlot to populate the plot legend.
289 *
290 * @return The legend items.
291 */
292 public LegendItemCollection getLegendCollection() {
293 LegendItemCollection result = new LegendItemCollection();
294 if (this.paintIndex != null && this.paintIndex.size() > 0) {
295 if (this.paintIndex.size() <= this.paintLimit) {
296 for (Iterator i = this.paintIndex.entrySet().iterator();
297 i.hasNext();) {
298 // in this case, every color has a unique value
299 Map.Entry entry = (Map.Entry) i.next();
300 String label = entry.getKey().toString();
301 String description = label;
302 Shape shape = new Rectangle2D.Double(1d, 1d, 1d, 1d);
303 Paint paint = lookupSeriesPaint(
304 ((Integer) entry.getValue()).intValue());
305 Paint outlinePaint = Color.black;
306 Stroke outlineStroke = DEFAULT_STROKE;
307
308 result.add(new LegendItem(label, description, null,
309 null, shape, paint, outlineStroke, outlinePaint));
310
311 }
312 }
313 else {
314 // in this case, every color has a range of values
315 Set unique = new HashSet();
316 for (Iterator i = this.paintIndex.entrySet().iterator();
317 i.hasNext();) {
318 Map.Entry entry = (Map.Entry) i.next();
319 if (unique.add(entry.getValue())) {
320 String label = getMinPaintValue(
321 (Integer) entry.getValue()).toString()
322 + " - " + getMaxPaintValue(
323 (Integer) entry.getValue()).toString();
324 String description = label;
325 Shape shape = new Rectangle2D.Double(1d, 1d, 1d, 1d);
326 Paint paint = getSeriesPaint(
327 ((Integer) entry.getValue()).intValue()
328 );
329 Paint outlinePaint = Color.black;
330 Stroke outlineStroke = DEFAULT_STROKE;
331
332 result.add(new LegendItem(label, description,
333 null, null, shape, paint, outlineStroke,
334 outlinePaint));
335 }
336 } // end foreach map entry
337 } // end else
338 }
339 return result;
340 }
341
342 /**
343 * Returns the minimum chip value assigned to a color
344 * in the paintIndex
345 *
346 * @param index the index.
347 *
348 * @return The value.
349 */
350 private Number getMinPaintValue(Integer index) {
351 double minValue = Double.POSITIVE_INFINITY;
352 for (Iterator i = this.paintIndex.entrySet().iterator(); i.hasNext();) {
353 Map.Entry entry = (Map.Entry) i.next();
354 if (((Integer) entry.getValue()).equals(index)) {
355 if (((Number) entry.getKey()).doubleValue() < minValue) {
356 minValue = ((Number) entry.getKey()).doubleValue();
357 }
358 }
359 }
360 return new Double(minValue);
361 }
362
363 /**
364 * Returns the maximum chip value assigned to a color
365 * in the paintIndex
366 *
367 * @param index the index.
368 *
369 * @return The value
370 */
371 private Number getMaxPaintValue(Integer index) {
372 double maxValue = Double.NEGATIVE_INFINITY;
373 for (Iterator i = this.paintIndex.entrySet().iterator(); i.hasNext();) {
374 Map.Entry entry = (Map.Entry) i.next();
375 if (((Integer) entry.getValue()).equals(index)) {
376 if (((Number) entry.getKey()).doubleValue() > maxValue) {
377 maxValue = ((Number) entry.getKey()).doubleValue();
378 }
379 }
380 }
381 return new Double(maxValue);
382 }
383
384
385 } // end class wafermaprenderer