Last active
December 29, 2015 01:49
-
-
Save sergii-frost/7596522 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* Copyright 2012 AndroidPlot.com | |
* | |
* Licensed under the Apache License, Version 2.0 (the "License"); | |
* you may not use this file except in compliance with the License. | |
* You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
*/ | |
package com.androidplot.xy; | |
import java.util.ArrayList; | |
import java.util.Collections; | |
import java.util.Comparator; | |
import java.util.List; | |
import java.util.Map.Entry; | |
import java.util.TreeMap; | |
import android.graphics.Canvas; | |
import android.graphics.RectF; | |
import com.androidplot.exception.PlotRenderException; | |
import com.androidplot.util.ValPixConverter; | |
/** | |
* Renders a point as a Bar | |
*/ | |
public class BarRenderer<T extends BarFormatter> extends XYSeriesRenderer<T> { | |
private BarRenderStyle renderStyle = BarRenderStyle.OVERLAID; // default Render Style | |
private BarWidthStyle widthStyle = BarWidthStyle.FIXED_WIDTH; // default Width Style | |
private float barWidth = 5; | |
private float barGap = 1; | |
public enum BarRenderStyle { | |
OVERLAID, // bars are overlaid in descending y-val order (largest val in back) | |
STACKED, // bars are drawn stacked vertically on top of each other | |
SIDE_BY_SIDE // bars are drawn horizontally next to each-other | |
} | |
public enum BarWidthStyle { | |
FIXED_WIDTH, // bar width is always barWidth | |
VARIABLE_WIDTH, // bar width is calculated so that there is only barGap between each bar | |
RELATIVE_WIDTH | |
} | |
public BarRenderer(XYPlot plot) { | |
super(plot); | |
} | |
/** | |
* Sets the width of the bars when using the FIXED_WIDTH render style | |
* @param barWidth | |
*/ | |
public void setBarWidth(float barWidth) { | |
this.barWidth = barWidth; | |
} | |
/** | |
* Sets the size of the gap between the bar (or bar groups) when using the VARIABLE_WIDTH render style | |
* @param barGap | |
*/ | |
public void setBarGap(float barGap) { | |
this.barGap = barGap; | |
} | |
public void setBarRenderStyle(BarRenderStyle renderStyle) { | |
this.renderStyle = renderStyle; | |
} | |
public void setBarWidthStyle(BarWidthStyle widthStyle) { | |
this.widthStyle = widthStyle; | |
} | |
public void setBarWidthStyle(BarWidthStyle style, float value) { | |
setBarWidthStyle(style); | |
switch (style) { | |
case FIXED_WIDTH: | |
case RELATIVE_WIDTH: | |
setBarWidth(value); | |
break; | |
case VARIABLE_WIDTH: | |
setBarGap(value); | |
break; | |
default: | |
break; | |
} | |
} | |
@Override | |
public void doDrawLegendIcon(Canvas canvas, RectF rect, BarFormatter formatter) { | |
canvas.drawRect(rect, formatter.getFillPaint()); | |
canvas.drawRect(rect, formatter.getBorderPaint()); | |
} | |
/** | |
* Retrieves the BarFormatter instance that corresponds with the series passed in. | |
* Can be overridden to return other BarFormatters as a result of touch events etc. | |
* @param index index of the point being rendered. | |
* @param series XYSeries to which the point being rendered belongs. | |
* @return | |
*/ | |
@SuppressWarnings("UnusedParameters") | |
protected T getFormatter(int index, XYSeries series) { | |
return getFormatter(series); | |
} | |
public void onRender(Canvas canvas, RectF plotArea) throws PlotRenderException { | |
List<XYSeries> sl = getPlot().getSeriesListForRenderer(this.getClass()); | |
TreeMap<Number, BarGroup> axisMap = new TreeMap<Number, BarGroup>(); | |
// dont try to render anything if there's nothing to render. | |
if(sl == null) return; | |
/* | |
* Build the axisMap (yVal,BarGroup)... a TreeMap of BarGroups | |
* BarGroups represent a point on the X axis where a single or group of bars need to be drawn. | |
*/ | |
// For each Series | |
for(XYSeries series : sl) { | |
BarGroup barGroup; | |
// For each value in the series | |
for(int i = 0; i < series.size(); i++) { | |
if (series.getX(i) != null) { | |
// get a new bar object | |
Bar b = new Bar(series,i,plotArea); | |
// Find or create the barGroup | |
if (axisMap.containsKey(b.intX)) { | |
barGroup = axisMap.get(b.intX); | |
} else { | |
barGroup = new BarGroup(b.intX,plotArea); | |
axisMap.put(b.intX, barGroup); | |
} | |
barGroup.addBar(b); | |
} | |
} | |
} | |
// Loop through the axisMap linking up prev pointers | |
BarGroup prev, current; | |
prev = null; | |
for(Entry<Number, BarGroup> mapEntry : axisMap.entrySet()) { | |
current = mapEntry.getValue(); | |
current.prev = prev; | |
prev = current; | |
} | |
// The default gap between each bar section | |
int gap = (int) barGap; | |
// Determine roughly how wide (rough_width) this bar should be. This is then used as a default width | |
// when there are gaps in the data or for the first/last bars. | |
float f_rough_width = ((plotArea.width() - ((axisMap.size() - 1) * gap)) / (axisMap.size() - 1)); | |
int rough_width = (int) f_rough_width; | |
if (rough_width < 0) rough_width = 0; | |
if (gap > rough_width) { | |
gap = rough_width / 2; | |
} | |
//Log.d("PARAMTER","PLOT_WIDTH=" + plotArea.width()); | |
//Log.d("PARAMTER","BAR_GROUPS=" + axisMap.size()); | |
//Log.d("PARAMTER","ROUGH_WIDTH=" + rough_width); | |
//Log.d("PARAMTER","GAP=" + gap); | |
/* | |
* Calculate the dimensions of each barGroup and then draw each bar within it according to | |
* the Render Style and Width Style. | |
*/ | |
for(Number key : axisMap.keySet()) { | |
BarGroup barGroup = axisMap.get(key); | |
// Determine the exact left and right X for the Bar Group | |
switch (widthStyle) { | |
case RELATIVE_WIDTH: | |
// use intX and go halfwidth either side. | |
float relativeWidth = barWidth * plotArea.width() / (getPlot().getCalculatedMaxX().floatValue() - getPlot().getCalculatedMinX().floatValue()); | |
barGroup.leftX = barGroup.intX - (int) (relativeWidth / 2); | |
barGroup.width = (int) relativeWidth; | |
barGroup.rightX = barGroup.leftX + barGroup.width; | |
break; | |
case FIXED_WIDTH: | |
// use intX and go halfwidth either side. | |
barGroup.leftX = barGroup.intX - (int) (barWidth / 2); | |
barGroup.width = (int) barWidth; | |
barGroup.rightX = barGroup.leftX + barGroup.width; | |
break; | |
case VARIABLE_WIDTH: | |
if (barGroup.prev != null) { | |
if (barGroup.intX - barGroup.prev.intX - gap - 1 > (int)(rough_width * 1.5)) { | |
// use intX and go halfwidth either side. | |
barGroup.leftX = barGroup.intX - (rough_width / 2); | |
barGroup.width = rough_width; | |
barGroup.rightX = barGroup.leftX + barGroup.width; | |
} else { | |
// base left off prev right to get the gap correct. | |
barGroup.leftX = barGroup.prev.rightX + gap + 1; | |
if (barGroup.leftX > barGroup.intX) barGroup.leftX = barGroup.intX; | |
// base right off intX + halfwidth. | |
barGroup.rightX = barGroup.intX + (rough_width / 2); | |
// calculate the width | |
barGroup.width = barGroup.rightX - barGroup.leftX; | |
} | |
} else { | |
// use intX and go halfwidth either side. | |
barGroup.leftX = barGroup.intX - (rough_width / 2); | |
barGroup.width = rough_width; | |
barGroup.rightX = barGroup.leftX + barGroup.width; | |
} | |
break; | |
default: | |
break; | |
} | |
//Log.d("BAR_GROUP", "rough_width=" + rough_width + " width=" + barGroup.width + " <" + barGroup.leftX + "|" + barGroup.intX + "|" + barGroup.rightX + ">"); | |
/* | |
* Draw the bars within the barGroup area. | |
*/ | |
switch (renderStyle) { | |
case OVERLAID: | |
Collections.sort(barGroup.bars, new BarComparator()); | |
for (Bar b : barGroup.bars) { | |
BarFormatter formatter = b.formatter(); | |
PointLabelFormatter plf = formatter.getPointLabelFormatter(); | |
PointLabeler pointLabeler = null; | |
if (formatter != null) { | |
pointLabeler = formatter.getPointLabeler(); | |
} | |
//Log.d("BAR", b.series.getTitle() + " <" + b.barGroup.leftX + "|" + b.barGroup.intX + "|" + b.barGroup.rightX + "> " + b.intY); | |
if (b.barGroup.width >= 2) { | |
canvas.drawRect(b.barGroup.leftX, b.intY, b.barGroup.rightX, b.barGroup.plotArea.bottom, formatter.getFillPaint()); | |
} | |
canvas.drawRect(b.barGroup.leftX, b.intY, b.barGroup.rightX, b.barGroup.plotArea.bottom, formatter.getBorderPaint()); | |
if(plf != null && pointLabeler != null) { | |
canvas.drawText(pointLabeler.getLabel(b.series, b.seriesIndex), b.intX + plf.hOffset, b.intY + plf.vOffset, plf.getTextPaint()); | |
} | |
} | |
break; | |
case SIDE_BY_SIDE: | |
int width = (int) barGroup.width / barGroup.bars.size(); | |
int leftX = barGroup.leftX; | |
Collections.sort(barGroup.bars, new BarComparator()); | |
for (Bar b : barGroup.bars) { | |
BarFormatter formatter = b.formatter(); | |
PointLabelFormatter plf = formatter.getPointLabelFormatter(); | |
PointLabeler pointLabeler = null; | |
if (formatter != null) { | |
pointLabeler = formatter.getPointLabeler(); | |
} | |
//Log.d("BAR", "width=" + width + " <" + leftX + "|" + b.intX + "|" + (leftX + width) + "> " + b.intY); | |
if (b.barGroup.width >= 2) { | |
canvas.drawRect(leftX, b.intY, leftX + width, b.barGroup.plotArea.bottom, formatter.getFillPaint()); | |
} | |
canvas.drawRect(leftX, b.intY, leftX + width, b.barGroup.plotArea.bottom, formatter.getBorderPaint()); | |
if(plf != null && pointLabeler != null) { | |
canvas.drawText(pointLabeler.getLabel(b.series, b.seriesIndex), leftX + width/2 + plf.hOffset, b.intY + plf.vOffset, plf.getTextPaint()); | |
} | |
leftX = leftX + width; | |
} | |
break; | |
case STACKED: | |
int bottom = (int) barGroup.plotArea.bottom; | |
Collections.sort(barGroup.bars, new BarComparator()); | |
for (Bar b : barGroup.bars) { | |
BarFormatter formatter = b.formatter(); | |
PointLabelFormatter plf = formatter.getPointLabelFormatter(); | |
PointLabeler pointLabeler = null; | |
if (formatter != null) { | |
pointLabeler = formatter.getPointLabeler(); | |
} | |
int height = (int) b.barGroup.plotArea.bottom - b.intY; | |
int top = bottom - height; | |
//Log.d("BAR", "top=" + top + " bottom=" + bottom + " height=" + height); | |
if (b.barGroup.width >= 2) { | |
canvas.drawRect(b.barGroup.leftX, top, b.barGroup.rightX, bottom, formatter.getFillPaint()); | |
} | |
canvas.drawRect(b.barGroup.leftX, top, b.barGroup.rightX, bottom, formatter.getBorderPaint()); | |
if(plf != null && pointLabeler != null) { | |
canvas.drawText(pointLabeler.getLabel(b.series, b.seriesIndex), b.intX + plf.hOffset, b.intY + plf.vOffset, plf.getTextPaint()); | |
} | |
bottom = top; | |
} | |
break; | |
default: | |
break; | |
} | |
} | |
} | |
private class Bar { | |
public XYSeries series; | |
public int seriesIndex; | |
public double yVal, xVal; | |
public int intX, intY; | |
public float pixX, pixY; | |
public BarGroup barGroup; | |
public Bar(XYSeries series, int seriesIndex, RectF plotArea) { | |
this.series = series; | |
this.seriesIndex = seriesIndex; | |
this.xVal = series.getX(seriesIndex).doubleValue(); | |
this.pixX = ValPixConverter.valToPix(xVal, getPlot().getCalculatedMinX().doubleValue(), getPlot().getCalculatedMaxX().doubleValue(), plotArea.width(), false) + (plotArea.left); | |
this.intX = (int) pixX; | |
if (series.getY(seriesIndex) != null) { | |
this.yVal = series.getY(seriesIndex).doubleValue(); | |
this.pixY = ValPixConverter.valToPix(yVal, getPlot().getCalculatedMinY().doubleValue(), getPlot().getCalculatedMaxY().doubleValue(), plotArea.height(), true) + plotArea.top; | |
this.intY = (int) pixY; | |
} else { | |
this.yVal = 0; | |
this.pixY = plotArea.bottom; | |
this.intY = (int) pixY; | |
} | |
} | |
public BarFormatter formatter() { | |
return getFormatter(seriesIndex, series); | |
} | |
} | |
private class BarGroup { | |
public ArrayList<Bar> bars; | |
public int intX; | |
public int width, leftX, rightX; | |
public RectF plotArea; | |
public BarGroup prev; | |
public BarGroup(int intX, RectF plotArea) { | |
// Setup the TreeMap with the required comparator | |
this.bars = new ArrayList<Bar>(); // create a comparator that compares series title given the index. | |
this.intX = intX; | |
this.plotArea = plotArea; | |
} | |
public void addBar(Bar bar) { | |
bar.barGroup = this; | |
this.bars.add(bar); | |
} | |
} | |
@SuppressWarnings("WeakerAccess") | |
public class BarComparator implements Comparator<Bar>{ | |
@Override | |
public int compare(Bar bar1, Bar bar2) { | |
switch (renderStyle) { | |
case OVERLAID: | |
return Integer.valueOf(bar1.intY).compareTo(bar2.intY); | |
case SIDE_BY_SIDE: | |
return bar1.series.getTitle().compareToIgnoreCase(bar2.series.getTitle()); | |
case STACKED: | |
return bar1.series.getTitle().compareToIgnoreCase(bar2.series.getTitle()); | |
default: | |
return 0; | |
} | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment