1:
44:
45: package ;
46:
47: import ;
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53: import ;
54: import ;
55: import ;
56: import ;
57:
58: import ;
59: import ;
60: import ;
61: import ;
62: import ;
63:
64:
67: public class WaferMapRenderer extends AbstractRenderer {
68:
69:
70: private Map paintIndex;
71:
72:
73: private WaferMapPlot plot;
74:
75:
76: private int paintLimit;
77:
78:
79: private static final int DEFAULT_PAINT_LIMIT = 35;
80:
81:
82: public static final int POSITION_INDEX = 0;
83:
84:
85: public static final int VALUE_INDEX = 1;
86:
87:
88: private int paintIndexMethod;
89:
90:
93: public WaferMapRenderer() {
94: this(null, null);
95: }
96:
97:
103: public WaferMapRenderer(int paintLimit, int paintIndexMethod) {
104: this(new Integer(paintLimit), new Integer(paintIndexMethod));
105: }
106:
107:
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:
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:
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:
167: public WaferMapPlot getPlot() {
168: return this.plot;
169: }
170:
171:
176: public void setPlot(WaferMapPlot plot) {
177: this.plot = plot;
178: makePaintIndex();
179: }
180:
181:
188: public Paint getChipColor(Number value) {
189: return getSeriesPaint(getPaintIndex(value));
190: }
191:
192:
199: private int getPaintIndex(Number value) {
200: return ((Integer) this.paintIndex.get(value)).intValue();
201: }
202:
203:
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;
217: for (Iterator i = uniqueValues.iterator(); i.hasNext();) {
218: this.paintIndex.put(i.next(), new Integer(count++));
219: }
220: }
221: else {
222:
223:
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:
243: private void makePositionIndex(Set uniqueValues) {
244: int valuesPerColor = (int) Math.ceil(
245: (double) uniqueValues.size() / this.paintLimit
246: );
247: int count = 0;
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:
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:
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:
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 = getSeriesPaint(
304: ((Integer) entry.getValue()).intValue()
305: );
306: Paint outlinePaint = Color.black;
307: Stroke outlineStroke = DEFAULT_STROKE;
308:
309: result.add(new LegendItem(label, description, null,
310: null, shape, paint, outlineStroke, outlinePaint));
311:
312: }
313: }
314: else {
315:
316: Set unique = new HashSet();
317: for (Iterator i = this.paintIndex.entrySet().iterator();
318: i.hasNext();) {
319: Map.Entry entry = (Map.Entry) i.next();
320: if (unique.add(entry.getValue())) {
321: String label = getMinPaintValue(
322: (Integer) entry.getValue()).toString()
323: + " - " + getMaxPaintValue(
324: (Integer) entry.getValue()).toString();
325: String description = label;
326: Shape shape = new Rectangle2D.Double(1d, 1d, 1d, 1d);
327: Paint paint = getSeriesPaint(
328: ((Integer) entry.getValue()).intValue()
329: );
330: Paint outlinePaint = Color.black;
331: Stroke outlineStroke = DEFAULT_STROKE;
332:
333: result.add(new LegendItem(label, description,
334: null, null, shape, paint, outlineStroke,
335: outlinePaint));
336: }
337: }
338: }
339: }
340: return result;
341: }
342:
343:
351: private Number getMinPaintValue(Integer index) {
352: double minValue = Double.POSITIVE_INFINITY;
353: for (Iterator i = this.paintIndex.entrySet().iterator(); i.hasNext();) {
354: Map.Entry entry = (Map.Entry) i.next();
355: if (((Integer) entry.getValue()).equals(index)) {
356: if (((Number) entry.getKey()).doubleValue() < minValue) {
357: minValue = ((Number) entry.getKey()).doubleValue();
358: }
359: }
360: }
361: return new Double(minValue);
362: }
363:
364:
372: private Number getMaxPaintValue(Integer index) {
373: double maxValue = Double.NEGATIVE_INFINITY;
374: for (Iterator i = this.paintIndex.entrySet().iterator(); i.hasNext();) {
375: Map.Entry entry = (Map.Entry) i.next();
376: if (((Integer) entry.getValue()).equals(index)) {
377: if (((Number) entry.getKey()).doubleValue() > maxValue) {
378: maxValue = ((Number) entry.getKey()).doubleValue();
379: }
380: }
381: }
382: return new Double(maxValue);
383: }
384:
385:
386: }