1:
45:
46: package ;
47:
48: import ;
49: import ;
50: import ;
51: import ;
52: import ;
53:
54: import ;
55: import ;
56: import ;
57: import ;
58: import ;
59: import ;
60: import ;
61: import ;
62: import ;
63:
64:
70: public class VectorRenderer extends AbstractXYItemRenderer
71: implements XYItemRenderer, Cloneable, PublicCloneable, Serializable {
72:
73:
74: private double baseLength = 0.10;
75:
76:
77: private double headLength = 0.14;
78:
79:
83: public VectorRenderer() {
84: }
85:
86:
95: public Range findDomainBounds(XYDataset dataset) {
96: if (dataset == null) {
97: throw new IllegalArgumentException("Null 'dataset' argument.");
98: }
99: double minimum = Double.POSITIVE_INFINITY;
100: double maximum = Double.NEGATIVE_INFINITY;
101: int seriesCount = dataset.getSeriesCount();
102: double lvalue;
103: double uvalue;
104: if (dataset instanceof VectorXYDataset) {
105: VectorXYDataset vdataset = (VectorXYDataset) dataset;
106: for (int series = 0; series < seriesCount; series++) {
107: int itemCount = dataset.getItemCount(series);
108: for (int item = 0; item < itemCount; item++) {
109: double delta = vdataset.getVectorXValue(series, item);
110: if (delta < 0.0) {
111: uvalue = vdataset.getXValue(series, item);
112: lvalue = uvalue + delta;
113: }
114: else {
115: lvalue = vdataset.getXValue(series, item);
116: uvalue = lvalue + delta;
117: }
118: minimum = Math.min(minimum, lvalue);
119: maximum = Math.max(maximum, uvalue);
120: }
121: }
122: }
123: else {
124: for (int series = 0; series < seriesCount; series++) {
125: int itemCount = dataset.getItemCount(series);
126: for (int item = 0; item < itemCount; item++) {
127: lvalue = dataset.getXValue(series, item);
128: uvalue = lvalue;
129: minimum = Math.min(minimum, lvalue);
130: maximum = Math.max(maximum, uvalue);
131: }
132: }
133: }
134: if (minimum > maximum) {
135: return null;
136: }
137: else {
138: return new Range(minimum, maximum);
139: }
140: }
141:
142:
151: public Range findRangeBounds(XYDataset dataset) {
152: if (dataset == null) {
153: throw new IllegalArgumentException("Null 'dataset' argument.");
154: }
155: double minimum = Double.POSITIVE_INFINITY;
156: double maximum = Double.NEGATIVE_INFINITY;
157: int seriesCount = dataset.getSeriesCount();
158: double lvalue;
159: double uvalue;
160: if (dataset instanceof VectorXYDataset) {
161: VectorXYDataset vdataset = (VectorXYDataset) dataset;
162: for (int series = 0; series < seriesCount; series++) {
163: int itemCount = dataset.getItemCount(series);
164: for (int item = 0; item < itemCount; item++) {
165: double delta = vdataset.getVectorYValue(series, item);
166: if (delta < 0.0) {
167: uvalue = vdataset.getYValue(series, item);
168: lvalue = uvalue + delta;
169: }
170: else {
171: lvalue = vdataset.getYValue(series, item);
172: uvalue = lvalue + delta;
173: }
174: minimum = Math.min(minimum, lvalue);
175: maximum = Math.max(maximum, uvalue);
176: }
177: }
178: }
179: else {
180: for (int series = 0; series < seriesCount; series++) {
181: int itemCount = dataset.getItemCount(series);
182: for (int item = 0; item < itemCount; item++) {
183: lvalue = dataset.getYValue(series, item);
184: uvalue = lvalue;
185: minimum = Math.min(minimum, lvalue);
186: maximum = Math.max(maximum, uvalue);
187: }
188: }
189: }
190: if (minimum > maximum) {
191: return null;
192: }
193: else {
194: return new Range(minimum, maximum);
195: }
196: }
197:
198:
214: public void drawItem(Graphics2D g2, XYItemRendererState state,
215: Rectangle2D dataArea, PlotRenderingInfo info, XYPlot plot,
216: ValueAxis domainAxis, ValueAxis rangeAxis, XYDataset dataset,
217: int series, int item, CrosshairState crosshairState, int pass) {
218:
219: double x = dataset.getXValue(series, item);
220: double y = dataset.getYValue(series, item);
221: double dx = 0.0;
222: double dy = 0.0;
223: if (dataset instanceof VectorXYDataset) {
224: dx = ((VectorXYDataset) dataset).getVectorXValue(series, item);
225: dy = ((VectorXYDataset) dataset).getVectorYValue(series, item);
226: }
227: double xx0 = domainAxis.valueToJava2D(x, dataArea,
228: plot.getDomainAxisEdge());
229: double yy0 = rangeAxis.valueToJava2D(y, dataArea,
230: plot.getRangeAxisEdge());
231: double xx1 = domainAxis.valueToJava2D(x + dx, dataArea,
232: plot.getDomainAxisEdge());
233: double yy1 = rangeAxis.valueToJava2D(y + dy, dataArea,
234: plot.getRangeAxisEdge());
235: Line2D line;
236: PlotOrientation orientation = plot.getOrientation();
237: if (orientation.equals(PlotOrientation.HORIZONTAL)) {
238: line = new Line2D.Double(yy0, xx0, yy1, xx1);
239: }
240: else {
241: line = new Line2D.Double(xx0, yy0, xx1, yy1);
242: }
243: g2.setPaint(getItemPaint(series, item));
244: g2.setStroke(getItemStroke(series, item));
245: g2.draw(line);
246:
247:
248: double dxx = (xx1 - xx0);
249: double dyy = (yy1 - yy0);
250: double bx = xx0 + (1.0 - this.baseLength) * dxx;
251: double by = yy0 + (1.0 - this.baseLength) * dyy;
252:
253: double cx = xx0 + (1.0 - this.headLength) * dxx;
254: double cy = yy0 + (1.0 - this.headLength) * dyy;
255:
256: double angle = 0.0;
257: if (dxx != 0.0) {
258: angle = Math.PI / 2.0 - Math.atan(dyy / dxx);
259: }
260: double deltaX = 2.0 * Math.cos(angle);
261: double deltaY = 2.0 * Math.sin(angle);
262:
263: double leftx = cx + deltaX;
264: double lefty = cy - deltaY;
265: double rightx = cx - deltaX;
266: double righty = cy + deltaY;
267:
268: GeneralPath p = new GeneralPath();
269: if (orientation == PlotOrientation.VERTICAL) {
270: p.moveTo((float) xx1, (float) yy1);
271: p.lineTo((float) rightx, (float) righty);
272: p.lineTo((float) bx, (float) by);
273: p.lineTo((float) leftx, (float) lefty);
274: }
275: else {
276: p.moveTo((float) yy1, (float) xx1);
277: p.lineTo((float) righty, (float) rightx);
278: p.lineTo((float) by, (float) bx);
279: p.lineTo((float) lefty, (float) leftx);
280: }
281: p.closePath();
282: g2.draw(p);
283:
284:
285: }
286:
287:
301: public boolean equals(Object obj) {
302: if (obj == this) {
303: return true;
304: }
305: if (!(obj instanceof VectorRenderer)) {
306: return false;
307: }
308: VectorRenderer that = (VectorRenderer) obj;
309: if (this.baseLength != that.baseLength) {
310: return false;
311: }
312: if (this.headLength != that.headLength) {
313: return false;
314: }
315: return super.equals(obj);
316: }
317:
318:
326: public Object clone() throws CloneNotSupportedException {
327: return super.clone();
328: }
329:
330: }